backports

mozilla-release/patches/mozilla-central_584331.patch

@@ -0,0 +1,455 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1624580410 0
+#      Fri Jun 25 00:20:10 2021 +0000
+# Node ID 1d1f1d413aeec40c9d2923d021b4edc78e43891b
+# Parent  7c85ca42c25196ea9e924ee81625ada9c9fd9c49
+Bug 1717947 - Remove support for brotli streams in Jar archives. r=valentin
+
+This was added in bug 1355661, has been kept Nightly-only since then,
+and was only used briefly for omni.ja, and eventually we switched
+compression off entirely on omni.ja. If we ever switch compression on
+again on omni.ja, it would likely be with zstd, which is much faster
+on the compression side.
+
+Differential Revision: https://phabricator.services.mozilla.com/D118654
+
+diff --git a/modules/libjar/nsJARInputStream.cpp b/modules/libjar/nsJARInputStream.cpp
+--- a/modules/libjar/nsJARInputStream.cpp
++++ b/modules/libjar/nsJARInputStream.cpp
+@@ -2,19 +2,16 @@
+ /* nsJARInputStream.cpp
+  *
+  * This Source Code Form is subject to the terms of the Mozilla Public
+  * License, v. 2.0. If a copy of the MPL was not distributed with this
+  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ 
+ #include "nsJARInputStream.h"
+ #include "zipstruct.h"         // defines ZIP compression codes
+-#ifdef MOZ_JAR_BROTLI
+-#include "brotli/decode.h"  // brotli
+-#endif
+ #include "nsZipArchive.h"
+ 
+ #include "nsEscape.h"
+ #include "nsIFile.h"
+ #include "nsDebug.h"
+ #include <algorithm>
+ #if defined(XP_WIN)
+ #include <windows.h>
+@@ -49,25 +46,16 @@ nsJARInputStream::InitFile(nsJAR *aJar, 
+            rv = gZlibInit(&mZs);
+            NS_ENSURE_SUCCESS(rv, rv);
+ 
+            mMode = MODE_INFLATE;
+            mInCrc = item->CRC32();
+            mOutCrc = crc32(0L, Z_NULL, 0);
+            break;
+ 
+-#ifdef MOZ_JAR_BROTLI
+-       case MOZ_JAR_BROTLI:
+-           mBrotliState = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
+-           mMode = MODE_BROTLI;
+-           mInCrc = item->CRC32();
+-           mOutCrc = crc32(0L, Z_NULL, 0);
+-           break;
+-#endif
+-
+        default:
+            return NS_ERROR_NOT_IMPLEMENTED;
+     }
+ 
+     // Must keep handle to filepointer and mmap structure as long as we need access to the mmapped data
+     mFd = aJar->mZip->GetFD();
+     mZs.next_in = (Bytef *)aJar->mZip->GetData(item);
+     if (!mZs.next_in) {
+@@ -173,19 +161,16 @@ nsJARInputStream::Available(uint64_t *_r
+       case MODE_CLOSED:
+         return NS_BASE_STREAM_CLOSED;
+ 
+       case MODE_DIRECTORY:
+         *_retval = mBuffer.Length();
+         break;
+ 
+       case MODE_INFLATE:
+-#ifdef MOZ_JAR_BROTLI
+-      case MODE_BROTLI:
+-#endif
+       case MODE_COPY:
+         *_retval = mOutSize - mZs.total_out;
+         break;
+     }
+ 
+     return NS_OK;
+ }
+ 
+@@ -205,19 +190,16 @@ MOZ_WIN_MEM_TRY_BEGIN
+ 
+       case MODE_CLOSED:
+         return NS_BASE_STREAM_CLOSED;
+ 
+       case MODE_DIRECTORY:
+         return ReadDirectory(aBuffer, aCount, aBytesRead);
+ 
+       case MODE_INFLATE:
+-#ifdef MOZ_JAR_BROTLI
+-      case MODE_BROTLI:
+-#endif
+         if (mZs.total_out < mOutSize) {
+           rv = ContinueInflate(aBuffer, aCount, aBytesRead);
+         }
+         // be aggressive about releasing the file!
+         // note that sometimes, we will release  mFd before we've finished
+         // deflating - this is because zlib buffers the input
+         if (mZs.avail_in == 0) {
+             mFd = nullptr;
+@@ -259,21 +241,16 @@ nsJARInputStream::IsNonBlocking(bool *aN
+ }
+ 
+ NS_IMETHODIMP
+ nsJARInputStream::Close()
+ {
+     if (mMode == MODE_INFLATE) {
+         inflateEnd(&mZs);
+     }
+-#ifdef MOZ_JAR_BROTLI
+-    if (mMode == MODE_BROTLI) {
+-        BrotliDecoderDestroyInstance(mBrotliState);
+-    }
+-#endif
+     mMode = MODE_CLOSED;
+     mFd = nullptr;
+     return NS_OK;
+ }
+ 
+ nsresult
+ nsJARInputStream::ContinueInflate(char* aBuffer, uint32_t aCount,
+                                   uint32_t* aBytesRead)
+@@ -286,50 +263,24 @@ nsJARInputStream::ContinueInflate(char* 
+ 
+     // Keep old total_out count
+     const uint32_t oldTotalOut = mZs.total_out;
+ 
+     // make sure we aren't reading too much
+     mZs.avail_out = std::min(aCount, (mOutSize-oldTotalOut));
+     mZs.next_out = (unsigned char*)aBuffer;
+ 
+-#ifndef MOZ_JAR_BROTLI
+-    MOZ_ASSERT(mMode == MODE_INFLATE);
+-#endif
+     if (mMode == MODE_INFLATE) {
+         // now inflate
+         int zerr = inflate(&mZs, Z_SYNC_FLUSH);
+         if ((zerr != Z_OK) && (zerr != Z_STREAM_END)) {
+             nsZipArchive::sFileCorruptedReason = "nsJARInputStream: error while inflating";
+             return NS_ERROR_FILE_CORRUPTED;
+         }
+         finished = (zerr == Z_STREAM_END);
+-#ifdef MOZ_JAR_BROTLI
+-    } else {
+-        MOZ_ASSERT(mMode == MODE_BROTLI);
+-        /* The brotli library wants size_t, but z_stream only contains
+-         * unsigned int for avail_* and unsigned long for total_*.
+-         * So use temporary stack values. */
+-        size_t avail_in = mZs.avail_in;
+-        size_t avail_out = mZs.avail_out;
+-        size_t total_out = mZs.total_out;
+-        BrotliDecoderResult result = BrotliDecoderDecompressStream(
+-            mBrotliState,
+-            &avail_in, const_cast<const unsigned char**>(&mZs.next_in),
+-            &avail_out, &mZs.next_out, &total_out);
+-        /* We don't need to update avail_out, it's not used outside this
+-         * function. */
+-        mZs.total_out = total_out;
+-        mZs.avail_in = avail_in;
+-        if (result == BROTLI_DECODER_RESULT_ERROR) {
+-            nsZipArchive::sFileCorruptedReason = "nsJARInputStream: brotli decompression error";
+-            return NS_ERROR_FILE_CORRUPTED;
+-        }
+-        finished = (result == BROTLI_DECODER_RESULT_SUCCESS);
+-#endif
+     }
+ 
+     *aBytesRead = (mZs.total_out - oldTotalOut);
+ 
+     // Calculate the CRC on the output
+     mOutCrc = crc32(mOutCrc, (unsigned char*)aBuffer, *aBytesRead);
+ 
+     // be aggressive about ending the inflation
+diff --git a/modules/libjar/nsJARInputStream.h b/modules/libjar/nsJARInputStream.h
+--- a/modules/libjar/nsJARInputStream.h
++++ b/modules/libjar/nsJARInputStream.h
+@@ -7,35 +7,28 @@
+ #ifndef nsJARINPUTSTREAM_h__
+ #define nsJARINPUTSTREAM_h__
+ 
+ #include "nsIInputStream.h"
+ #include "nsJAR.h"
+ #include "nsTArray.h"
+ #include "mozilla/Attributes.h"
+ 
+-#ifdef MOZ_JAR_BROTLI
+-struct BrotliDecoderStateStruct;
+-#endif
+-
+ /*-------------------------------------------------------------------------
+  * Class nsJARInputStream declaration. This class defines the type of the
+  * object returned by calls to nsJAR::GetInputStream(filename) for the
+  * purpose of reading a file item out of a JAR file.
+  *------------------------------------------------------------------------*/
+ class nsJARInputStream final : public nsIInputStream
+ {
+   public:
+     nsJARInputStream()
+     : mOutSize(0)
+     , mInCrc(0)
+     , mOutCrc(0)
+-#ifdef MOZ_JAR_BROTLI
+-    , mBrotliState(nullptr)
+-#endif
+     , mNameLen(0)
+     , mCurPos(0)
+     , mArrPos(0)
+     , mMode(MODE_NOTINITED)
+     {
+       memset(&mZs, 0, sizeof(z_stream));
+     }
+ 
+@@ -52,36 +45,30 @@ class nsJARInputStream final : public ns
+   private:
+     ~nsJARInputStream() { Close(); }
+ 
+     RefPtr<nsZipHandle>  mFd;         // handle for reading
+     uint32_t               mOutSize;    // inflated size
+     uint32_t               mInCrc;      // CRC as provided by the zipentry
+     uint32_t               mOutCrc;     // CRC as calculated by me
+     z_stream               mZs;         // zip data structure
+-#ifdef MOZ_JAR_BROTLI
+-    BrotliDecoderStateStruct* mBrotliState; // Brotli decoder state
+-#endif
+ 
+     /* For directory reading */
+     RefPtr<nsJAR>          mJar;        // string reference to zipreader
+     uint32_t               mNameLen;    // length of dirname
+     nsCString              mBuffer;     // storage for generated text of stream
+     uint32_t               mCurPos;     // Current position in buffer
+     uint32_t               mArrPos;     // current position within mArray
+     nsTArray<nsCString>    mArray;      // array of names in (zip) directory
+ 
+ 	typedef enum {
+         MODE_NOTINITED,
+         MODE_CLOSED,
+         MODE_DIRECTORY,
+         MODE_INFLATE,
+-#ifdef MOZ_JAR_BROTLI
+-        MODE_BROTLI,
+-#endif
+         MODE_COPY
+     } JISMode;
+ 
+     JISMode                mMode;		// Modus of the stream
+ 
+     nsresult ContinueInflate(char* aBuf, uint32_t aCount, uint32_t* aBytesRead);
+     nsresult ReadDirectory(char* aBuf, uint32_t aCount, uint32_t* aBytesRead);
+     uint32_t CopyDataToBuffer(char* &aBuffer, uint32_t &aCount);
+diff --git a/modules/libjar/nsZipArchive.cpp b/modules/libjar/nsZipArchive.cpp
+--- a/modules/libjar/nsZipArchive.cpp
++++ b/modules/libjar/nsZipArchive.cpp
+@@ -7,19 +7,16 @@
+  * This module implements a simple archive extractor for the PKZIP format.
+  *
+  * The underlying nsZipArchive is NOT thread-safe. Do not pass references
+  * or pointers to it across thread boundaries.
+  */
+ 
+ #define READTYPE  int32_t
+ #include "zlib.h"
+-#ifdef MOZ_JAR_BROTLI
+-#include "brotli/decode.h" // brotli
+-#endif
+ #include "nsISupportsUtils.h"
+ #include "prio.h"
+ #include "plstr.h"
+ #include "mozilla/Attributes.h"
+ #include "mozilla/Logging.h"
+ #include "mozilla/UniquePtrExtensions.h"
+ #include "stdlib.h"
+ #include "nsDirectoryService.h"
+@@ -1235,54 +1232,40 @@ bool nsZipItem::IsSymlink()
+ }
+ #endif
+ 
+ nsZipCursor::nsZipCursor(nsZipItem *item, nsZipArchive *aZip, uint8_t* aBuf,
+                          uint32_t aBufSize, bool doCRC)
+   : mItem(item)
+   , mBuf(aBuf)
+   , mBufSize(aBufSize)
+-#ifdef MOZ_JAR_BROTLI
+-  , mBrotliState(nullptr)
+-#endif
+   , mCRC(0)
+   , mDoCRC(doCRC)
+ {
+   if (mItem->Compression() == DEFLATED) {
+ #ifdef DEBUG
+     nsresult status =
+ #endif
+       gZlibInit(&mZs);
+     NS_ASSERTION(status == NS_OK, "Zlib failed to initialize");
+     NS_ASSERTION(aBuf, "Must pass in a buffer for DEFLATED nsZipItem");
+   }
+ 
+   mZs.avail_in = item->Size();
+   mZs.next_in = (Bytef*)aZip->GetData(item);
+ 
+-#ifdef MOZ_JAR_BROTLI
+-  if (mItem->Compression() == MOZ_JAR_BROTLI) {
+-    mBrotliState = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
+-  }
+-#endif
+-
+   if (doCRC)
+     mCRC = crc32(0L, Z_NULL, 0);
+ }
+ 
+ nsZipCursor::~nsZipCursor()
+ {
+   if (mItem->Compression() == DEFLATED) {
+     inflateEnd(&mZs);
+   }
+-#ifdef MOZ_JAR_BROTLI
+-  if (mItem->Compression() == MOZ_JAR_BROTLI) {
+-    BrotliDecoderDestroyInstance(mBrotliState);
+-  }
+-#endif
+ }
+ 
+ uint8_t* nsZipCursor::ReadOrCopy(uint32_t *aBytesRead, bool aCopy) {
+   int zerr;
+   uint8_t *buf = nullptr;
+   bool verifyCRC = true;
+ 
+   if (!mZs.next_in)
+@@ -1309,41 +1292,16 @@ MOZ_WIN_MEM_TRY_BEGIN
+ 
+     zerr = inflate(&mZs, Z_PARTIAL_FLUSH);
+     if (zerr != Z_OK && zerr != Z_STREAM_END)
+       return nullptr;
+ 
+     *aBytesRead = mZs.next_out - buf;
+     verifyCRC = (zerr == Z_STREAM_END);
+     break;
+-#ifdef MOZ_JAR_BROTLI
+-  case MOZ_JAR_BROTLI: {
+-    buf = mBuf;
+-    mZs.next_out = buf;
+-    /* The brotli library wants size_t, but z_stream only contains
+-     * unsigned int for avail_*. So use temporary stack values. */
+-    size_t avail_out = mBufSize;
+-    size_t avail_in = mZs.avail_in;
+-    BrotliDecoderResult result = BrotliDecoderDecompressStream(
+-      mBrotliState,
+-      &avail_in, const_cast<const unsigned char**>(&mZs.next_in),
+-      &avail_out, &mZs.next_out, nullptr);
+-    /* We don't need to update avail_out, it's not used outside this
+-     * function. */
+-    mZs.avail_in = avail_in;
+-
+-    if (result == BROTLI_DECODER_RESULT_ERROR) {
+-      return nullptr;
+-    }
+-
+-    *aBytesRead = mZs.next_out - buf;
+-    verifyCRC = (result == BROTLI_DECODER_RESULT_SUCCESS);
+-    break;
+-  }
+-#endif
+   default:
+     return nullptr;
+   }
+ 
+   if (mDoCRC) {
+     mCRC = crc32(mCRC, (const unsigned char*)buf, *aBytesRead);
+     if (verifyCRC && mCRC != mItem->CRC32())
+       return nullptr;
+@@ -1361,19 +1319,16 @@ nsZipItemPtr_base::nsZipItemPtr_base(nsZ
+   mZipHandle = aZip->GetFD();
+ 
+   nsZipItem* item = aZip->GetItem(aEntryName);
+   if (!item)
+     return;
+ 
+   uint32_t size = 0;
+   bool compressed = (item->Compression() == DEFLATED);
+-#ifdef MOZ_JAR_BROTLI
+-  compressed |= (item->Compression() == MOZ_JAR_BROTLI);
+-#endif
+   if (compressed) {
+     size = item->RealSize();
+     mAutoBuf = MakeUniqueFallible<uint8_t[]>(size);
+     if (!mAutoBuf) {
+       return;
+     }
+   }
+ 
+diff --git a/modules/libjar/nsZipArchive.h b/modules/libjar/nsZipArchive.h
+--- a/modules/libjar/nsZipArchive.h
++++ b/modules/libjar/nsZipArchive.h
+@@ -32,19 +32,16 @@
+   }
+ #else
+ #define MOZ_WIN_MEM_TRY_BEGIN {
+ #define MOZ_WIN_MEM_TRY_CATCH(cmd) }
+ #endif
+ 
+ class nsZipFind;
+ struct PRFileDesc;
+-#ifdef MOZ_JAR_BROTLI
+-struct BrotliDecoderStateStruct;
+-#endif
+ 
+ /**
+  * This file defines some of the basic structures used by libjar to
+  * read Zip files. It makes use of zlib in order to do the decompression.
+  *
+  * A few notes on the classes/structs:
+  * nsZipArchive   represents a single Zip file, and maintains an index
+  *                of all the items in the file.
+@@ -312,19 +309,16 @@ public:
+ private:
+   /* Actual implementation for both Read and Copy above */
+   uint8_t* ReadOrCopy(uint32_t *aBytesRead, bool aCopy);
+ 
+   nsZipItem *mItem;
+   uint8_t  *mBuf;
+   uint32_t  mBufSize;
+   z_stream  mZs;
+-#ifdef MOZ_JAR_BROTLI
+-  BrotliDecoderStateStruct* mBrotliState;
+-#endif
+   uint32_t mCRC;
+   bool mDoCRC;
+ };
+ 
+ /**
+  * nsZipItemPtr - a RAII convenience class for reading the individual items in a zip.
+  * It reads whole files and does zero-copy IO for stored files. A buffer is allocated
+  * for decompression.
+diff --git a/modules/libjar/zipstruct.h b/modules/libjar/zipstruct.h
+--- a/modules/libjar/zipstruct.h
++++ b/modules/libjar/zipstruct.h
+@@ -97,14 +97,10 @@ typedef struct ZipEnd_
+ #define REDUCED1          2
+ #define REDUCED2          3
+ #define REDUCED3          4
+ #define REDUCED4          5
+ #define IMPLODED          6
+ #define TOKENIZED         7
+ #define DEFLATED          8
+ #define UNSUPPORTED       0xFF
+-/* non-standard extension */
+-#ifdef NIGHTLY_BUILD
+-#define MOZ_JAR_BROTLI    0x81
+-#endif
+ 
+ #endif /* _zipstruct_h */

mozilla-release/patches/mozilla-central_584332.patch

@@ -0,0 +1,329 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1624580410 0
+#      Fri Jun 25 00:20:10 2021 +0000
+# Node ID 97f4820bdb020525fe6418b18021614eb2840f7a
+# Parent  bb6dc57385601b7ce2d401a8418be8527276bd4d
+Bug 1717947 - Remove packager support for brotli in Jars. r=firefox-build-system-reviewers,nalexander
+
+This was added ing bug 1352595. It has only been used briefly, and we
+since then have gone all the way to never compress omni.ja. Even if we
+did go back to compressing, we'd probably go with zstd rather than
+brotli.
+The gecko-side support for this has only ever been nightly-only.
+
+Differential Revision: https://phabricator.services.mozilla.com/D118655
+
+diff --git a/python/mozbuild/mozpack/copier.py b/python/mozbuild/mozpack/copier.py
+--- a/python/mozbuild/mozpack/copier.py
++++ b/python/mozbuild/mozpack/copier.py
+@@ -10,17 +10,17 @@ import os
+ import stat
+ import sys
+ from collections import Counter, OrderedDict, defaultdict
+ 
+ import six
+ 
+ import mozpack.path as mozpath
+ from mozpack.errors import errors
+-from mozpack.files import BaseFile, DeflatedFile, Dest, ManifestFile, XPTFile
++from mozpack.files import BaseFile, Dest
+ 
+ 
+ class FileRegistry(object):
+     '''
+     Generic container to keep track of a set of BaseFile instances. It
+     preserves the order under which the files are added, but doesn't keep
+     track of empty directories (directories are not stored at all).
+     The paths associated with the BaseFile instances are relative to an
+@@ -556,46 +556,33 @@ class Jarrer(FileRegistry, BaseFile):
+ 
+             def exists(self):
+                 return self.deflater is not None
+ 
+         if isinstance(dest, six.string_types):
+             dest = Dest(dest)
+         assert isinstance(dest, Dest)
+ 
+-        from mozpack.mozjar import JarWriter, JarReader, JAR_BROTLI
++        from mozpack.mozjar import JarWriter, JarReader
+         try:
+             old_jar = JarReader(fileobj=dest)
+         except Exception:
+             old_jar = []
+ 
+         old_contents = dict([(f.filename, f) for f in old_jar])
+ 
+         with JarWriter(fileobj=dest, compress=self.compress) as jar:
+             for path, file in self:
+                 compress = self._compress_options.get(path, self.compress)
+-                # Temporary: Because l10n repacks can't handle brotli just yet,
+-                # but need to be able to decompress those files, per
+-                # UnpackFinder and formatters, we force deflate on them.
+-                if compress == JAR_BROTLI and (
+-                        isinstance(file, (ManifestFile, XPTFile)) or
+-                        mozpath.basename(path) == 'install.rdf'):
+-                    compress = True
+ 
+-                # If the added content already comes from a jar file, we just add
+-                # the raw data from the original jar file to the new one.
+-                if isinstance(file, DeflatedFile):
+-                    jar.add(path, file.file, mode=file.mode,
+-                            compress=file.file.compress)
+-                    continue
+                 # If the file is already in the old contents for this jar,
+                 # we avoid compressing when the contents match, which requires
+                 # decompressing the old content. But for e.g. l10n repacks,
+                 # which can't decompress brotli, we skip this.
+-                elif path in old_contents and old_contents[path].compress != JAR_BROTLI:
++                if path in old_contents:
+                     deflater = DeflaterDest(old_contents[path], compress)
+                 else:
+                     deflater = DeflaterDest(compress=compress)
+                 file.copy(deflater, skip_if_older)
+                 jar.add(path, deflater.deflater, mode=file.mode, compress=compress)
+             if self._preload:
+                 jar.preload(self._preload)
+ 
+diff --git a/python/mozbuild/mozpack/mozjar.py b/python/mozbuild/mozpack/mozjar.py
+--- a/python/mozbuild/mozpack/mozjar.py
++++ b/python/mozbuild/mozpack/mozjar.py
+@@ -1,38 +1,27 @@
+ # This Source Code Form is subject to the terms of the Mozilla Public
+ # License, v. 2.0. If a copy of the MPL was not distributed with this
+ # file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ 
+ from __future__ import absolute_import, print_function, unicode_literals
+ 
+-from io import (
+-    BytesIO,
+-    UnsupportedOperation,
+-)
++from io import BytesIO, UnsupportedOperation
+ import struct
+-import subprocess
+ import zlib
+ import os
+ import six
+-from zipfile import (
+-    ZIP_STORED,
+-    ZIP_DEFLATED,
+-)
++from zipfile import ZIP_STORED, ZIP_DEFLATED
+ from collections import OrderedDict
+ import mozpack.path as mozpath
+-from mozbuild.util import (
+-    memoize,
+-    ensure_bytes,
+-)
++from mozbuild.util import ensure_bytes
+ 
+ 
+ JAR_STORED = ZIP_STORED
+ JAR_DEFLATED = ZIP_DEFLATED
+-JAR_BROTLI = 0x81
+ MAX_WBITS = 15
+ 
+ 
+ class JarReaderError(Exception):
+     '''Error type for Jar reader errors.'''
+ 
+ 
+ class JarWriterError(Exception):
+@@ -270,17 +259,17 @@ class JarFileReader(object):
+     '''
+ 
+     def __init__(self, header, data):
+         '''
+         Initialize a JarFileReader. header is the local file header
+         corresponding to the file in the jar archive, data a buffer containing
+         the file data.
+         '''
+-        assert header['compression'] in [JAR_DEFLATED, JAR_STORED, JAR_BROTLI]
++        assert header['compression'] in [JAR_DEFLATED, JAR_STORED]
+         self._data = data
+         # Copy some local file header fields.
+         for name in ['compressed_size', 'uncompressed_size', 'crc32']:
+             setattr(self, name, header[name])
+         self.filename = six.ensure_text(header['filename'])
+         self.compressed = header['compression'] != JAR_STORED
+         self.compress = header['compression']
+ 
+@@ -328,18 +317,16 @@ class JarFileReader(object):
+         '''
+         Return the uncompressed data.
+         '''
+         if hasattr(self, '_uncompressed_data'):
+             return self._uncompressed_data
+         data = self.compressed_data
+         if self.compress == JAR_STORED:
+             data = data.tobytes()
+-        elif self.compress == JAR_BROTLI:
+-            data = Brotli.decompress(data.tobytes())
+         elif self.compress == JAR_DEFLATED:
+             data = zlib.decompress(data.tobytes(), -MAX_WBITS)
+         else:
+             assert False  # Can't be another value per __init__
+         if len(data) != self.uncompressed_size:
+             raise JarReaderError('Corrupted file? %s' % self.filename)
+         self._uncompressed_data = BytesIO(data)
+         return self._uncompressed_data
+@@ -599,17 +586,17 @@ class JarWriter(object):
+         self._data.write(end.serialize())
+         self._data.close()
+ 
+     def add(self, name, data, compress=None, mode=None, skip_duplicates=False):
+         '''
+         Add a new member to the jar archive, with the given name and the given
+         data.
+         The compress option indicates how the given data should be compressed
+-        (one of JAR_STORED, JAR_DEFLATE or JAR_BROTLI), or compressed according
++        (one of JAR_STORED or JAR_DEFLATE), or compressed according
+         to the default defined when creating the JarWriter (None). True and
+         False are allowed values for backwards compatibility, mapping,
+         respectively, to JAR_DEFLATE and JAR_STORED.
+         When the data should be compressed, it is only really compressed if
+         the compressed size is smaller than the uncompressed size.
+         The mode option gives the unix permissions that should be stored
+         for the jar entry.
+         If a duplicated member is found skip_duplicates will prevent raising
+@@ -700,22 +687,18 @@ class Deflater(object):
+         compress.
+         '''
+         self._data = BytesIO()
+         if compress is True:
+             compress = JAR_DEFLATED
+         elif compress is False:
+             compress = JAR_STORED
+         self.compress = compress
+-        if compress in (JAR_DEFLATED, JAR_BROTLI):
+-            if compress == JAR_DEFLATED:
+-                self._deflater = zlib.compressobj(
+-                    compress_level, zlib.DEFLATED, -MAX_WBITS)
+-            else:
+-                self._deflater = BrotliCompress()
++        if compress == JAR_DEFLATED:
++            self._deflater = zlib.compressobj(compress_level, zlib.DEFLATED, -MAX_WBITS)
+             self._deflated = BytesIO()
+         else:
+             assert compress == JAR_STORED
+             self._deflater = None
+         self.crc32 = 0
+ 
+     def write(self, data):
+         '''
+@@ -797,56 +780,16 @@ class Deflater(object):
+         compressed size smaller than the uncompressed size), or the
+         uncompressed data otherwise.
+         '''
+         if self.compressed:
+             return self._deflated.getvalue()
+         return self._data.getvalue()
+ 
+ 
+-class Brotli(object):
+-    @staticmethod
+-    @memoize
+-    def brotli_tool():
+-        from buildconfig import topobjdir, substs
+-        return os.path.join(topobjdir, 'dist', 'host', 'bin',
+-                            'bro' + substs.get('BIN_SUFFIX', ''))
+-
+-    @staticmethod
+-    def run_brotli_tool(args, input):
+-        proc = subprocess.Popen([Brotli.brotli_tool()] + args,
+-                                stdin=subprocess.PIPE,
+-                                stdout=subprocess.PIPE)
+-        (stdout, _) = proc.communicate(input)
+-        ret = proc.wait()
+-        if ret != 0:
+-            raise Exception("Brotli compression failed")
+-        return stdout
+-
+-    @staticmethod
+-    def compress(data):
+-        return Brotli.run_brotli_tool(['--window', '17'], data)
+-
+-    @staticmethod
+-    def decompress(data):
+-        return Brotli.run_brotli_tool(['--decompress'], data)
+-
+-
+-class BrotliCompress(object):
+-    def __init__(self):
+-        self._buf = BytesIO()
+-
+-    def compress(self, data):
+-        self._buf.write(data)
+-        return b''
+-
+-    def flush(self):
+-        return Brotli.compress(self._buf.getvalue())
+-
+-
+ class JarLog(dict):
+     '''
+     Helper to read the file Gecko generates when setting MOZ_JAR_LOG_FILE.
+     The jar log is then available as a dict with the jar path as key, and
+     the corresponding access log as a list value. Only the first access to
+     a given member of a jar is stored.
+     '''
+ 
+diff --git a/toolkit/mozapps/installer/packager.py b/toolkit/mozapps/installer/packager.py
+--- a/toolkit/mozapps/installer/packager.py
++++ b/toolkit/mozapps/installer/packager.py
+@@ -21,17 +21,16 @@ from mozpack.files import (
+     File,
+ )
+ from mozpack.copier import (
+     FileCopier,
+     Jarrer,
+ )
+ from mozpack.errors import errors
+ from mozpack.files import ExecutableFile
+-from mozpack.mozjar import JAR_BROTLI
+ import mozpack.path as mozpath
+ import buildconfig
+ from argparse import ArgumentParser
+ from createprecomplete import generate_precomplete
+ import os
+ import six
+ from six import StringIO
+ import subprocess
+@@ -119,17 +118,17 @@ def main():
+     parser.add_argument('--minify-js', action='store_true',
+                         help='Minify JavaScript files while packaging.')
+     parser.add_argument('--js-binary',
+                         help='Path to js binary. This is used to verify '
+                         'minified JavaScript. If this is not defined, '
+                         'minification verification will not be performed.')
+     parser.add_argument('--jarlog', default='', help='File containing jar ' +
+                         'access logs')
+-    parser.add_argument('--compress', choices=('none', 'deflate', 'brotli'),
++    parser.add_argument('--compress', choices=('none', 'deflate'),
+                         default='deflate',
+                         help='Use given jar compression (default: deflate)')
+     parser.add_argument('manifest', default=None, nargs='?',
+                         help='Manifest file name')
+     parser.add_argument('source', help='Source directory')
+     parser.add_argument('destination', help='Destination directory')
+     parser.add_argument('--non-resource', nargs='+', metavar='PATTERN',
+                         default=[],
+@@ -142,17 +141,16 @@ def main():
+ 
+     if args.defines:
+         for name, value in [split_define(d) for d in args.defines]:
+             defines[name] = value
+ 
+     compress = {
+         'none': False,
+         'deflate': True,
+-        'brotli': JAR_BROTLI,
+     }[args.compress]
+ 
+     copier = FileCopier()
+     if args.format == 'flat':
+         formatter = FlatFormatter(copier)
+     elif args.format == 'jar':
+         formatter = JarFormatter(copier, compress=compress)
+     elif args.format == 'omni':

mozilla-release/patches/mozilla-central_584333.patch

@@ -0,0 +1,23651 @@
+# HG changeset patch
+# User Mike Hommey <mh+mozilla@glandium.org>
+# Date 1624580411 0
+#      Fri Jun 25 00:20:11 2021 +0000
+# Node ID 23c261d45df26242c6ac82969d9cccd511b4600b
+# Parent  9e5f86a9b436454bb92876e6120f93b9dbca858e
+Bug 1717947 - Don't build the brotli host program. r=firefox-build-system-reviewers,nalexander
+
+We now have no use for it. Remove the corresponding source, which we
+added in bug 1355671 just for this.
+
+Differential Revision: https://phabricator.services.mozilla.com/D118656
+
+diff --git a/modules/brotli/enc/backward_references.c b/modules/brotli/enc/backward_references.c
+deleted file mode 100644
+--- a/modules/brotli/enc/backward_references.c
++++ /dev/null
+@@ -1,145 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function to find backward reference copies. */
+-
+-#include "./backward_references.h"
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./dictionary_hash.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static BROTLI_INLINE size_t ComputeDistanceCode(size_t distance,
+-                                                size_t max_distance,
+-                                                const int* dist_cache) {
+-  if (distance <= max_distance) {
+-    size_t distance_plus_3 = distance + 3;
+-    size_t offset0 = distance_plus_3 - (size_t)dist_cache[0];
+-    size_t offset1 = distance_plus_3 - (size_t)dist_cache[1];
+-    if (distance == (size_t)dist_cache[0]) {
+-      return 0;
+-    } else if (distance == (size_t)dist_cache[1]) {
+-      return 1;
+-    } else if (offset0 < 7) {
+-      return (0x9750468 >> (4 * offset0)) & 0xF;
+-    } else if (offset1 < 7) {
+-      return (0xFDB1ACE >> (4 * offset1)) & 0xF;
+-    } else if (distance == (size_t)dist_cache[2]) {
+-      return 2;
+-    } else if (distance == (size_t)dist_cache[3]) {
+-      return 3;
+-    }
+-  }
+-  return distance + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
+-}
+-
+-#define EXPAND_CAT(a, b) CAT(a, b)
+-#define CAT(a, b) a ## b
+-#define FN(X) EXPAND_CAT(X, HASHER())
+-#define EXPORT_FN(X) EXPAND_CAT(X, EXPAND_CAT(PREFIX(), HASHER()))
+-
+-#define PREFIX() N
+-
+-#define HASHER() H2
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H3
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H4
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H5
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H6
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H40
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H41
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H42
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H54
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H35
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H55
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#define HASHER() H65
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./backward_references_inc.h"
+-#undef HASHER
+-
+-#undef PREFIX
+-
+-#undef EXPORT_FN
+-#undef FN
+-#undef CAT
+-#undef EXPAND_CAT
+-
+-void BrotliCreateBackwardReferences(size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals) {
+-  switch (params->hasher.type) {
+-#define CASE_(N)                                                  \
+-    case N:                                                       \
+-      CreateBackwardReferencesNH ## N(num_bytes,                  \
+-          position, ringbuffer, ringbuffer_mask,                  \
+-          literal_context_lut, params, hasher, dist_cache,        \
+-          last_insert_len, commands, num_commands, num_literals); \
+-      return;
+-    FOR_GENERIC_HASHERS(CASE_)
+-#undef CASE_
+-    default:
+-      break;
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/backward_references.h b/modules/brotli/enc/backward_references.h
+deleted file mode 100644
+--- a/modules/brotli/enc/backward_references.h
++++ /dev/null
+@@ -1,39 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function to find backward reference copies. */
+-
+-#ifndef BROTLI_ENC_BACKWARD_REFERENCES_H_
+-#define BROTLI_ENC_BACKWARD_REFERENCES_H_
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./hash.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* "commands" points to the next output command to write to, "*num_commands" is
+-   initially the total amount of commands output by previous
+-   CreateBackwardReferences calls, and must be incremented by the amount written
+-   by this call. */
+-BROTLI_INTERNAL void BrotliCreateBackwardReferences(size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_BACKWARD_REFERENCES_H_ */
+diff --git a/modules/brotli/enc/backward_references_hq.c b/modules/brotli/enc/backward_references_hq.c
+deleted file mode 100644
+--- a/modules/brotli/enc/backward_references_hq.c
++++ /dev/null
+@@ -1,843 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function to find backward reference copies. */
+-
+-#include "./backward_references_hq.h"
+-
+-#include <string.h>  /* memcpy, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./fast_log.h"
+-#include "./find_match_length.h"
+-#include "./literal_cost.h"
+-#include "./memory.h"
+-#include "./params.h"
+-#include "./prefix.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* BrotliCalculateDistanceCodeLimit(BROTLI_MAX_ALLOWED_DISTANCE, 3, 120). */
+-#define BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE 544
+-
+-static const float kInfinity = 1.7e38f;  /* ~= 2 ^ 127 */
+-
+-static const uint32_t kDistanceCacheIndex[] = {
+-  0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
+-};
+-static const int kDistanceCacheOffset[] = {
+-  0, 0, 0, 0, -1, 1, -2, 2, -3, 3, -1, 1, -2, 2, -3, 3
+-};
+-
+-void BrotliInitZopfliNodes(ZopfliNode* array, size_t length) {
+-  ZopfliNode stub;
+-  size_t i;
+-  stub.length = 1;
+-  stub.distance = 0;
+-  stub.dcode_insert_length = 0;
+-  stub.u.cost = kInfinity;
+-  for (i = 0; i < length; ++i) array[i] = stub;
+-}
+-
+-static BROTLI_INLINE uint32_t ZopfliNodeCopyLength(const ZopfliNode* self) {
+-  return self->length & 0x1FFFFFF;
+-}
+-
+-static BROTLI_INLINE uint32_t ZopfliNodeLengthCode(const ZopfliNode* self) {
+-  const uint32_t modifier = self->length >> 25;
+-  return ZopfliNodeCopyLength(self) + 9u - modifier;
+-}
+-
+-static BROTLI_INLINE uint32_t ZopfliNodeCopyDistance(const ZopfliNode* self) {
+-  return self->distance;
+-}
+-
+-static BROTLI_INLINE uint32_t ZopfliNodeDistanceCode(const ZopfliNode* self) {
+-  const uint32_t short_code = self->dcode_insert_length >> 27;
+-  return short_code == 0 ?
+-      ZopfliNodeCopyDistance(self) + BROTLI_NUM_DISTANCE_SHORT_CODES - 1 :
+-      short_code - 1;
+-}
+-
+-static BROTLI_INLINE uint32_t ZopfliNodeCommandLength(const ZopfliNode* self) {
+-  return ZopfliNodeCopyLength(self) + (self->dcode_insert_length & 0x7FFFFFF);
+-}
+-
+-/* Histogram based cost model for zopflification. */
+-typedef struct ZopfliCostModel {
+-  /* The insert and copy length symbols. */
+-  float cost_cmd_[BROTLI_NUM_COMMAND_SYMBOLS];
+-  float* cost_dist_;
+-  uint32_t distance_histogram_size;
+-  /* Cumulative costs of literals per position in the stream. */
+-  float* literal_costs_;
+-  float min_cost_cmd_;
+-  size_t num_bytes_;
+-} ZopfliCostModel;
+-
+-static void InitZopfliCostModel(
+-    MemoryManager* m, ZopfliCostModel* self, const BrotliDistanceParams* dist,
+-    size_t num_bytes) {
+-  self->num_bytes_ = num_bytes;
+-  self->literal_costs_ = BROTLI_ALLOC(m, float, num_bytes + 2);
+-  self->cost_dist_ = BROTLI_ALLOC(m, float, dist->alphabet_size_limit);
+-  self->distance_histogram_size = dist->alphabet_size_limit;
+-  if (BROTLI_IS_OOM(m)) return;
+-}
+-
+-static void CleanupZopfliCostModel(MemoryManager* m, ZopfliCostModel* self) {
+-  BROTLI_FREE(m, self->literal_costs_);
+-  BROTLI_FREE(m, self->cost_dist_);
+-}
+-
+-static void SetCost(const uint32_t* histogram, size_t histogram_size,
+-                    BROTLI_BOOL literal_histogram, float* cost) {
+-  size_t sum = 0;
+-  size_t missing_symbol_sum;
+-  float log2sum;
+-  float missing_symbol_cost;
+-  size_t i;
+-  for (i = 0; i < histogram_size; i++) {
+-    sum += histogram[i];
+-  }
+-  log2sum = (float)FastLog2(sum);
+-  missing_symbol_sum = sum;
+-  if (!literal_histogram) {
+-    for (i = 0; i < histogram_size; i++) {
+-      if (histogram[i] == 0) missing_symbol_sum++;
+-    }
+-  }
+-  missing_symbol_cost = (float)FastLog2(missing_symbol_sum) + 2;
+-  for (i = 0; i < histogram_size; i++) {
+-    if (histogram[i] == 0) {
+-      cost[i] = missing_symbol_cost;
+-      continue;
+-    }
+-
+-    /* Shannon bits for this symbol. */
+-    cost[i] = log2sum - (float)FastLog2(histogram[i]);
+-
+-    /* Cannot be coded with less than 1 bit */
+-    if (cost[i] < 1) cost[i] = 1;
+-  }
+-}
+-
+-static void ZopfliCostModelSetFromCommands(ZopfliCostModel* self,
+-                                           size_t position,
+-                                           const uint8_t* ringbuffer,
+-                                           size_t ringbuffer_mask,
+-                                           const Command* commands,
+-                                           size_t num_commands,
+-                                           size_t last_insert_len) {
+-  uint32_t histogram_literal[BROTLI_NUM_LITERAL_SYMBOLS];
+-  uint32_t histogram_cmd[BROTLI_NUM_COMMAND_SYMBOLS];
+-  uint32_t histogram_dist[BROTLI_MAX_EFFECTIVE_DISTANCE_ALPHABET_SIZE];
+-  float cost_literal[BROTLI_NUM_LITERAL_SYMBOLS];
+-  size_t pos = position - last_insert_len;
+-  float min_cost_cmd = kInfinity;
+-  size_t i;
+-  float* cost_cmd = self->cost_cmd_;
+-
+-  memset(histogram_literal, 0, sizeof(histogram_literal));
+-  memset(histogram_cmd, 0, sizeof(histogram_cmd));
+-  memset(histogram_dist, 0, sizeof(histogram_dist));
+-
+-  for (i = 0; i < num_commands; i++) {
+-    size_t inslength = commands[i].insert_len_;
+-    size_t copylength = CommandCopyLen(&commands[i]);
+-    size_t distcode = commands[i].dist_prefix_ & 0x3FF;
+-    size_t cmdcode = commands[i].cmd_prefix_;
+-    size_t j;
+-
+-    histogram_cmd[cmdcode]++;
+-    if (cmdcode >= 128) histogram_dist[distcode]++;
+-
+-    for (j = 0; j < inslength; j++) {
+-      histogram_literal[ringbuffer[(pos + j) & ringbuffer_mask]]++;
+-    }
+-
+-    pos += inslength + copylength;
+-  }
+-
+-  SetCost(histogram_literal, BROTLI_NUM_LITERAL_SYMBOLS, BROTLI_TRUE,
+-          cost_literal);
+-  SetCost(histogram_cmd, BROTLI_NUM_COMMAND_SYMBOLS, BROTLI_FALSE,
+-          cost_cmd);
+-  SetCost(histogram_dist, self->distance_histogram_size, BROTLI_FALSE,
+-          self->cost_dist_);
+-
+-  for (i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; ++i) {
+-    min_cost_cmd = BROTLI_MIN(float, min_cost_cmd, cost_cmd[i]);
+-  }
+-  self->min_cost_cmd_ = min_cost_cmd;
+-
+-  {
+-    float* literal_costs = self->literal_costs_;
+-    float literal_carry = 0.0;
+-    size_t num_bytes = self->num_bytes_;
+-    literal_costs[0] = 0.0;
+-    for (i = 0; i < num_bytes; ++i) {
+-      literal_carry +=
+-          cost_literal[ringbuffer[(position + i) & ringbuffer_mask]];
+-      literal_costs[i + 1] = literal_costs[i] + literal_carry;
+-      literal_carry -= literal_costs[i + 1] - literal_costs[i];
+-    }
+-  }
+-}
+-
+-static void ZopfliCostModelSetFromLiteralCosts(ZopfliCostModel* self,
+-                                               size_t position,
+-                                               const uint8_t* ringbuffer,
+-                                               size_t ringbuffer_mask) {
+-  float* literal_costs = self->literal_costs_;
+-  float literal_carry = 0.0;
+-  float* cost_dist = self->cost_dist_;
+-  float* cost_cmd = self->cost_cmd_;
+-  size_t num_bytes = self->num_bytes_;
+-  size_t i;
+-  BrotliEstimateBitCostsForLiterals(position, num_bytes, ringbuffer_mask,
+-                                    ringbuffer, &literal_costs[1]);
+-  literal_costs[0] = 0.0;
+-  for (i = 0; i < num_bytes; ++i) {
+-    literal_carry += literal_costs[i + 1];
+-    literal_costs[i + 1] = literal_costs[i] + literal_carry;
+-    literal_carry -= literal_costs[i + 1] - literal_costs[i];
+-  }
+-  for (i = 0; i < BROTLI_NUM_COMMAND_SYMBOLS; ++i) {
+-    cost_cmd[i] = (float)FastLog2(11 + (uint32_t)i);
+-  }
+-  for (i = 0; i < self->distance_histogram_size; ++i) {
+-    cost_dist[i] = (float)FastLog2(20 + (uint32_t)i);
+-  }
+-  self->min_cost_cmd_ = (float)FastLog2(11);
+-}
+-
+-static BROTLI_INLINE float ZopfliCostModelGetCommandCost(
+-    const ZopfliCostModel* self, uint16_t cmdcode) {
+-  return self->cost_cmd_[cmdcode];
+-}
+-
+-static BROTLI_INLINE float ZopfliCostModelGetDistanceCost(
+-    const ZopfliCostModel* self, size_t distcode) {
+-  return self->cost_dist_[distcode];
+-}
+-
+-static BROTLI_INLINE float ZopfliCostModelGetLiteralCosts(
+-    const ZopfliCostModel* self, size_t from, size_t to) {
+-  return self->literal_costs_[to] - self->literal_costs_[from];
+-}
+-
+-static BROTLI_INLINE float ZopfliCostModelGetMinCostCmd(
+-    const ZopfliCostModel* self) {
+-  return self->min_cost_cmd_;
+-}
+-
+-/* REQUIRES: len >= 2, start_pos <= pos */
+-/* REQUIRES: cost < kInfinity, nodes[start_pos].cost < kInfinity */
+-/* Maintains the "ZopfliNode array invariant". */
+-static BROTLI_INLINE void UpdateZopfliNode(ZopfliNode* nodes, size_t pos,
+-    size_t start_pos, size_t len, size_t len_code, size_t dist,
+-    size_t short_code, float cost) {
+-  ZopfliNode* next = &nodes[pos + len];
+-  next->length = (uint32_t)(len | ((len + 9u - len_code) << 25));
+-  next->distance = (uint32_t)dist;
+-  next->dcode_insert_length = (uint32_t)(
+-      (short_code << 27) | (pos - start_pos));
+-  next->u.cost = cost;
+-}
+-
+-typedef struct PosData {
+-  size_t pos;
+-  int distance_cache[4];
+-  float costdiff;
+-  float cost;
+-} PosData;
+-
+-/* Maintains the smallest 8 cost difference together with their positions */
+-typedef struct StartPosQueue {
+-  PosData q_[8];
+-  size_t idx_;
+-} StartPosQueue;
+-
+-static BROTLI_INLINE void InitStartPosQueue(StartPosQueue* self) {
+-  self->idx_ = 0;
+-}
+-
+-static size_t StartPosQueueSize(const StartPosQueue* self) {
+-  return BROTLI_MIN(size_t, self->idx_, 8);
+-}
+-
+-static void StartPosQueuePush(StartPosQueue* self, const PosData* posdata) {
+-  size_t offset = ~(self->idx_++) & 7;
+-  size_t len = StartPosQueueSize(self);
+-  size_t i;
+-  PosData* q = self->q_;
+-  q[offset] = *posdata;
+-  /* Restore the sorted order. In the list of |len| items at most |len - 1|
+-     adjacent element comparisons / swaps are required. */
+-  for (i = 1; i < len; ++i) {
+-    if (q[offset & 7].costdiff > q[(offset + 1) & 7].costdiff) {
+-      BROTLI_SWAP(PosData, q, offset & 7, (offset + 1) & 7);
+-    }
+-    ++offset;
+-  }
+-}
+-
+-static const PosData* StartPosQueueAt(const StartPosQueue* self, size_t k) {
+-  return &self->q_[(k - self->idx_) & 7];
+-}
+-
+-/* Returns the minimum possible copy length that can improve the cost of any */
+-/* future position. */
+-static size_t ComputeMinimumCopyLength(const float start_cost,
+-                                       const ZopfliNode* nodes,
+-                                       const size_t num_bytes,
+-                                       const size_t pos) {
+-  /* Compute the minimum possible cost of reaching any future position. */
+-  float min_cost = start_cost;
+-  size_t len = 2;
+-  size_t next_len_bucket = 4;
+-  size_t next_len_offset = 10;
+-  while (pos + len <= num_bytes && nodes[pos + len].u.cost <= min_cost) {
+-    /* We already reached (pos + len) with no more cost than the minimum
+-       possible cost of reaching anything from this pos, so there is no point in
+-       looking for lengths <= len. */
+-    ++len;
+-    if (len == next_len_offset) {
+-      /* We reached the next copy length code bucket, so we add one more
+-         extra bit to the minimum cost. */
+-      min_cost += 1.0f;
+-      next_len_offset += next_len_bucket;
+-      next_len_bucket *= 2;
+-    }
+-  }
+-  return len;
+-}
+-
+-/* REQUIRES: nodes[pos].cost < kInfinity
+-   REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
+-static uint32_t ComputeDistanceShortcut(const size_t block_start,
+-                                        const size_t pos,
+-                                        const size_t max_backward_limit,
+-                                        const size_t gap,
+-                                        const ZopfliNode* nodes) {
+-  const size_t clen = ZopfliNodeCopyLength(&nodes[pos]);
+-  const size_t ilen = nodes[pos].dcode_insert_length & 0x7FFFFFF;
+-  const size_t dist = ZopfliNodeCopyDistance(&nodes[pos]);
+-  /* Since |block_start + pos| is the end position of the command, the copy part
+-     starts from |block_start + pos - clen|. Distances that are greater than
+-     this or greater than |max_backward_limit| + |gap| are static dictionary
+-     references, and do not update the last distances.
+-     Also distance code 0 (last distance) does not update the last distances. */
+-  if (pos == 0) {
+-    return 0;
+-  } else if (dist + clen <= block_start + pos + gap &&
+-             dist <= max_backward_limit + gap &&
+-             ZopfliNodeDistanceCode(&nodes[pos]) > 0) {
+-    return (uint32_t)pos;
+-  } else {
+-    return nodes[pos - clen - ilen].u.shortcut;
+-  }
+-}
+-
+-/* Fills in dist_cache[0..3] with the last four distances (as defined by
+-   Section 4. of the Spec) that would be used at (block_start + pos) if we
+-   used the shortest path of commands from block_start, computed from
+-   nodes[0..pos]. The last four distances at block_start are in
+-   starting_dist_cache[0..3].
+-   REQUIRES: nodes[pos].cost < kInfinity
+-   REQUIRES: nodes[0..pos] satisfies that "ZopfliNode array invariant". */
+-static void ComputeDistanceCache(const size_t pos,
+-                                 const int* starting_dist_cache,
+-                                 const ZopfliNode* nodes,
+-                                 int* dist_cache) {
+-  int idx = 0;
+-  size_t p = nodes[pos].u.shortcut;
+-  while (idx < 4 && p > 0) {
+-    const size_t ilen = nodes[p].dcode_insert_length & 0x7FFFFFF;
+-    const size_t clen = ZopfliNodeCopyLength(&nodes[p]);
+-    const size_t dist = ZopfliNodeCopyDistance(&nodes[p]);
+-    dist_cache[idx++] = (int)dist;
+-    /* Because of prerequisite, p >= clen + ilen >= 2. */
+-    p = nodes[p - clen - ilen].u.shortcut;
+-  }
+-  for (; idx < 4; ++idx) {
+-    dist_cache[idx] = *starting_dist_cache++;
+-  }
+-}
+-
+-/* Maintains "ZopfliNode array invariant" and pushes node to the queue, if it
+-   is eligible. */
+-static void EvaluateNode(
+-    const size_t block_start, const size_t pos, const size_t max_backward_limit,
+-    const size_t gap, const int* starting_dist_cache,
+-    const ZopfliCostModel* model, StartPosQueue* queue, ZopfliNode* nodes) {
+-  /* Save cost, because ComputeDistanceCache invalidates it. */
+-  float node_cost = nodes[pos].u.cost;
+-  nodes[pos].u.shortcut = ComputeDistanceShortcut(
+-      block_start, pos, max_backward_limit, gap, nodes);
+-  if (node_cost <= ZopfliCostModelGetLiteralCosts(model, 0, pos)) {
+-    PosData posdata;
+-    posdata.pos = pos;
+-    posdata.cost = node_cost;
+-    posdata.costdiff = node_cost -
+-        ZopfliCostModelGetLiteralCosts(model, 0, pos);
+-    ComputeDistanceCache(
+-        pos, starting_dist_cache, nodes, posdata.distance_cache);
+-    StartPosQueuePush(queue, &posdata);
+-  }
+-}
+-
+-/* Returns longest copy length. */
+-static size_t UpdateNodes(
+-    const size_t num_bytes, const size_t block_start, const size_t pos,
+-    const uint8_t* ringbuffer, const size_t ringbuffer_mask,
+-    const BrotliEncoderParams* params, const size_t max_backward_limit,
+-    const int* starting_dist_cache, const size_t num_matches,
+-    const BackwardMatch* matches, const ZopfliCostModel* model,
+-    StartPosQueue* queue, ZopfliNode* nodes) {
+-  const size_t stream_offset = params->stream_offset;
+-  const size_t cur_ix = block_start + pos;
+-  const size_t cur_ix_masked = cur_ix & ringbuffer_mask;
+-  const size_t max_distance = BROTLI_MIN(size_t, cur_ix, max_backward_limit);
+-  const size_t dictionary_start = BROTLI_MIN(size_t,
+-      cur_ix + stream_offset, max_backward_limit);
+-  const size_t max_len = num_bytes - pos;
+-  const size_t max_zopfli_len = MaxZopfliLen(params);
+-  const size_t max_iters = MaxZopfliCandidates(params);
+-  size_t min_len;
+-  size_t result = 0;
+-  size_t k;
+-  size_t gap = 0;
+-
+-  EvaluateNode(block_start + stream_offset, pos, max_backward_limit, gap,
+-      starting_dist_cache, model, queue, nodes);
+-
+-  {
+-    const PosData* posdata = StartPosQueueAt(queue, 0);
+-    float min_cost = (posdata->cost + ZopfliCostModelGetMinCostCmd(model) +
+-        ZopfliCostModelGetLiteralCosts(model, posdata->pos, pos));
+-    min_len = ComputeMinimumCopyLength(min_cost, nodes, num_bytes, pos);
+-  }
+-
+-  /* Go over the command starting positions in order of increasing cost
+-     difference. */
+-  for (k = 0; k < max_iters && k < StartPosQueueSize(queue); ++k) {
+-    const PosData* posdata = StartPosQueueAt(queue, k);
+-    const size_t start = posdata->pos;
+-    const uint16_t inscode = GetInsertLengthCode(pos - start);
+-    const float start_costdiff = posdata->costdiff;
+-    const float base_cost = start_costdiff + (float)GetInsertExtra(inscode) +
+-        ZopfliCostModelGetLiteralCosts(model, 0, pos);
+-
+-    /* Look for last distance matches using the distance cache from this
+-       starting position. */
+-    size_t best_len = min_len - 1;
+-    size_t j = 0;
+-    for (; j < BROTLI_NUM_DISTANCE_SHORT_CODES && best_len < max_len; ++j) {
+-      const size_t idx = kDistanceCacheIndex[j];
+-      const size_t backward =
+-          (size_t)(posdata->distance_cache[idx] + kDistanceCacheOffset[j]);
+-      size_t prev_ix = cur_ix - backward;
+-      size_t len = 0;
+-      uint8_t continuation = ringbuffer[cur_ix_masked + best_len];
+-      if (cur_ix_masked + best_len > ringbuffer_mask) {
+-        break;
+-      }
+-      if (BROTLI_PREDICT_FALSE(backward > dictionary_start + gap)) {
+-        /* Word dictionary -> ignore. */
+-        continue;
+-      }
+-      if (backward <= max_distance) {
+-        /* Regular backward reference. */
+-        if (prev_ix >= cur_ix) {
+-          continue;
+-        }
+-
+-        prev_ix &= ringbuffer_mask;
+-        if (prev_ix + best_len > ringbuffer_mask ||
+-            continuation != ringbuffer[prev_ix + best_len]) {
+-          continue;
+-        }
+-        len = FindMatchLengthWithLimit(&ringbuffer[prev_ix],
+-                                       &ringbuffer[cur_ix_masked],
+-                                       max_len);
+-      } else {
+-        /* "Gray" area. It is addressable by decoder, but this encoder
+-           instance does not have that data -> should not touch it. */
+-        continue;
+-      }
+-      {
+-        const float dist_cost = base_cost +
+-            ZopfliCostModelGetDistanceCost(model, j);
+-        size_t l;
+-        for (l = best_len + 1; l <= len; ++l) {
+-          const uint16_t copycode = GetCopyLengthCode(l);
+-          const uint16_t cmdcode =
+-              CombineLengthCodes(inscode, copycode, j == 0);
+-          const float cost = (cmdcode < 128 ? base_cost : dist_cost) +
+-              (float)GetCopyExtra(copycode) +
+-              ZopfliCostModelGetCommandCost(model, cmdcode);
+-          if (cost < nodes[pos + l].u.cost) {
+-            UpdateZopfliNode(nodes, pos, start, l, l, backward, j + 1, cost);
+-            result = BROTLI_MAX(size_t, result, l);
+-          }
+-          best_len = l;
+-        }
+-      }
+-    }
+-
+-    /* At higher iterations look only for new last distance matches, since
+-       looking only for new command start positions with the same distances
+-       does not help much. */
+-    if (k >= 2) continue;
+-
+-    {
+-      /* Loop through all possible copy lengths at this position. */
+-      size_t len = min_len;
+-      for (j = 0; j < num_matches; ++j) {
+-        BackwardMatch match = matches[j];
+-        size_t dist = match.distance;
+-        BROTLI_BOOL is_dictionary_match =
+-            TO_BROTLI_BOOL(dist > dictionary_start + gap);
+-        /* We already tried all possible last distance matches, so we can use
+-           normal distance code here. */
+-        size_t dist_code = dist + BROTLI_NUM_DISTANCE_SHORT_CODES - 1;
+-        uint16_t dist_symbol;
+-        uint32_t distextra;
+-        uint32_t distnumextra;
+-        float dist_cost;
+-        size_t max_match_len;
+-        PrefixEncodeCopyDistance(
+-            dist_code, params->dist.num_direct_distance_codes,
+-            params->dist.distance_postfix_bits, &dist_symbol, &distextra);
+-        distnumextra = dist_symbol >> 10;
+-        dist_cost = base_cost + (float)distnumextra +
+-            ZopfliCostModelGetDistanceCost(model, dist_symbol & 0x3FF);
+-
+-        /* Try all copy lengths up until the maximum copy length corresponding
+-           to this distance. If the distance refers to the static dictionary, or
+-           the maximum length is long enough, try only one maximum length. */
+-        max_match_len = BackwardMatchLength(&match);
+-        if (len < max_match_len &&
+-            (is_dictionary_match || max_match_len > max_zopfli_len)) {
+-          len = max_match_len;
+-        }
+-        for (; len <= max_match_len; ++len) {
+-          const size_t len_code =
+-              is_dictionary_match ? BackwardMatchLengthCode(&match) : len;
+-          const uint16_t copycode = GetCopyLengthCode(len_code);
+-          const uint16_t cmdcode = CombineLengthCodes(inscode, copycode, 0);
+-          const float cost = dist_cost + (float)GetCopyExtra(copycode) +
+-              ZopfliCostModelGetCommandCost(model, cmdcode);
+-          if (cost < nodes[pos + len].u.cost) {
+-            UpdateZopfliNode(nodes, pos, start, len, len_code, dist, 0, cost);
+-            result = BROTLI_MAX(size_t, result, len);
+-          }
+-        }
+-      }
+-    }
+-  }
+-  return result;
+-}
+-
+-static size_t ComputeShortestPathFromNodes(size_t num_bytes,
+-    ZopfliNode* nodes) {
+-  size_t index = num_bytes;
+-  size_t num_commands = 0;
+-  while ((nodes[index].dcode_insert_length & 0x7FFFFFF) == 0 &&
+-      nodes[index].length == 1) --index;
+-  nodes[index].u.next = BROTLI_UINT32_MAX;
+-  while (index != 0) {
+-    size_t len = ZopfliNodeCommandLength(&nodes[index]);
+-    index -= len;
+-    nodes[index].u.next = (uint32_t)len;
+-    num_commands++;
+-  }
+-  return num_commands;
+-}
+-
+-/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
+-void BrotliZopfliCreateCommands(const size_t num_bytes,
+-    const size_t block_start, const ZopfliNode* nodes, int* dist_cache,
+-    size_t* last_insert_len, const BrotliEncoderParams* params,
+-    Command* commands, size_t* num_literals) {
+-  const size_t stream_offset = params->stream_offset;
+-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+-  size_t pos = 0;
+-  uint32_t offset = nodes[0].u.next;
+-  size_t i;
+-  size_t gap = 0;
+-  for (i = 0; offset != BROTLI_UINT32_MAX; i++) {
+-    const ZopfliNode* next = &nodes[pos + offset];
+-    size_t copy_length = ZopfliNodeCopyLength(next);
+-    size_t insert_length = next->dcode_insert_length & 0x7FFFFFF;
+-    pos += insert_length;
+-    offset = next->u.next;
+-    if (i == 0) {
+-      insert_length += *last_insert_len;
+-      *last_insert_len = 0;
+-    }
+-    {
+-      size_t distance = ZopfliNodeCopyDistance(next);
+-      size_t len_code = ZopfliNodeLengthCode(next);
+-      size_t dictionary_start = BROTLI_MIN(size_t,
+-          block_start + pos + stream_offset, max_backward_limit);
+-      BROTLI_BOOL is_dictionary =
+-          TO_BROTLI_BOOL(distance > dictionary_start + gap);
+-      size_t dist_code = ZopfliNodeDistanceCode(next);
+-      InitCommand(&commands[i], &params->dist, insert_length,
+-          copy_length, (int)len_code - (int)copy_length, dist_code);
+-
+-      if (!is_dictionary && dist_code > 0) {
+-        dist_cache[3] = dist_cache[2];
+-        dist_cache[2] = dist_cache[1];
+-        dist_cache[1] = dist_cache[0];
+-        dist_cache[0] = (int)distance;
+-      }
+-    }
+-
+-    *num_literals += insert_length;
+-    pos += copy_length;
+-  }
+-  *last_insert_len += num_bytes - pos;
+-}
+-
+-static size_t ZopfliIterate(size_t num_bytes, size_t position,
+-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    const BrotliEncoderParams* params, const size_t gap, const int* dist_cache,
+-    const ZopfliCostModel* model, const uint32_t* num_matches,
+-    const BackwardMatch* matches, ZopfliNode* nodes) {
+-  const size_t stream_offset = params->stream_offset;
+-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+-  const size_t max_zopfli_len = MaxZopfliLen(params);
+-  StartPosQueue queue;
+-  size_t cur_match_pos = 0;
+-  size_t i;
+-  nodes[0].length = 0;
+-  nodes[0].u.cost = 0;
+-  InitStartPosQueue(&queue);
+-  for (i = 0; i + 3 < num_bytes; i++) {
+-    size_t skip = UpdateNodes(num_bytes, position, i, ringbuffer,
+-        ringbuffer_mask, params, max_backward_limit, dist_cache,
+-        num_matches[i], &matches[cur_match_pos], model, &queue, nodes);
+-    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
+-    cur_match_pos += num_matches[i];
+-    if (num_matches[i] == 1 &&
+-        BackwardMatchLength(&matches[cur_match_pos - 1]) > max_zopfli_len) {
+-      skip = BROTLI_MAX(size_t,
+-          BackwardMatchLength(&matches[cur_match_pos - 1]), skip);
+-    }
+-    if (skip > 1) {
+-      skip--;
+-      while (skip) {
+-        i++;
+-        if (i + 3 >= num_bytes) break;
+-        EvaluateNode(position + stream_offset, i, max_backward_limit, gap,
+-            dist_cache, model, &queue, nodes);
+-        cur_match_pos += num_matches[i];
+-        skip--;
+-      }
+-    }
+-  }
+-  return ComputeShortestPathFromNodes(num_bytes, nodes);
+-}
+-
+-/* REQUIRES: nodes != NULL and len(nodes) >= num_bytes + 1 */
+-size_t BrotliZopfliComputeShortestPath(MemoryManager* m, size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    const int* dist_cache, Hasher* hasher, ZopfliNode* nodes) {
+-  const size_t stream_offset = params->stream_offset;
+-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+-  const size_t max_zopfli_len = MaxZopfliLen(params);
+-  ZopfliCostModel model;
+-  StartPosQueue queue;
+-  BackwardMatch matches[2 * (MAX_NUM_MATCHES_H10 + 64)];
+-  const size_t store_end = num_bytes >= StoreLookaheadH10() ?
+-      position + num_bytes - StoreLookaheadH10() + 1 : position;
+-  size_t i;
+-  size_t gap = 0;
+-  size_t lz_matches_offset = 0;
+-  BROTLI_UNUSED(literal_context_lut);
+-  nodes[0].length = 0;
+-  nodes[0].u.cost = 0;
+-  InitZopfliCostModel(m, &model, &params->dist, num_bytes);
+-  if (BROTLI_IS_OOM(m)) return 0;
+-  ZopfliCostModelSetFromLiteralCosts(
+-      &model, position, ringbuffer, ringbuffer_mask);
+-  InitStartPosQueue(&queue);
+-  for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; i++) {
+-    const size_t pos = position + i;
+-    const size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
+-    const size_t dictionary_start = BROTLI_MIN(size_t,
+-        pos + stream_offset, max_backward_limit);
+-    size_t skip;
+-    size_t num_matches;
+-    num_matches = FindAllMatchesH10(&hasher->privat._H10,
+-        &params->dictionary,
+-        ringbuffer, ringbuffer_mask, pos, num_bytes - i, max_distance,
+-        dictionary_start + gap, params, &matches[lz_matches_offset]);
+-    if (num_matches > 0 &&
+-        BackwardMatchLength(&matches[num_matches - 1]) > max_zopfli_len) {
+-      matches[0] = matches[num_matches - 1];
+-      num_matches = 1;
+-    }
+-    skip = UpdateNodes(num_bytes, position, i, ringbuffer, ringbuffer_mask,
+-        params, max_backward_limit, dist_cache, num_matches, matches, &model,
+-        &queue, nodes);
+-    if (skip < BROTLI_LONG_COPY_QUICK_STEP) skip = 0;
+-    if (num_matches == 1 && BackwardMatchLength(&matches[0]) > max_zopfli_len) {
+-      skip = BROTLI_MAX(size_t, BackwardMatchLength(&matches[0]), skip);
+-    }
+-    if (skip > 1) {
+-      /* Add the tail of the copy to the hasher. */
+-      StoreRangeH10(&hasher->privat._H10,
+-          ringbuffer, ringbuffer_mask, pos + 1, BROTLI_MIN(
+-          size_t, pos + skip, store_end));
+-      skip--;
+-      while (skip) {
+-        i++;
+-        if (i + HashTypeLengthH10() - 1 >= num_bytes) break;
+-        EvaluateNode(position + stream_offset, i, max_backward_limit, gap,
+-            dist_cache, &model, &queue, nodes);
+-        skip--;
+-      }
+-    }
+-  }
+-  CleanupZopfliCostModel(m, &model);
+-  return ComputeShortestPathFromNodes(num_bytes, nodes);
+-}
+-
+-void BrotliCreateZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals) {
+-  ZopfliNode* nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(nodes)) return;
+-  BrotliInitZopfliNodes(nodes, num_bytes + 1);
+-  *num_commands += BrotliZopfliComputeShortestPath(m, num_bytes,
+-      position, ringbuffer, ringbuffer_mask, literal_context_lut, params,
+-      dist_cache, hasher, nodes);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
+-      last_insert_len, params, commands, num_literals);
+-  BROTLI_FREE(m, nodes);
+-}
+-
+-void BrotliCreateHqZopfliBackwardReferences(MemoryManager* m, size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals) {
+-  const size_t stream_offset = params->stream_offset;
+-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+-  uint32_t* num_matches = BROTLI_ALLOC(m, uint32_t, num_bytes);
+-  size_t matches_size = 4 * num_bytes;
+-  const size_t store_end = num_bytes >= StoreLookaheadH10() ?
+-      position + num_bytes - StoreLookaheadH10() + 1 : position;
+-  size_t cur_match_pos = 0;
+-  size_t i;
+-  size_t orig_num_literals;
+-  size_t orig_last_insert_len;
+-  int orig_dist_cache[4];
+-  size_t orig_num_commands;
+-  ZopfliCostModel model;
+-  ZopfliNode* nodes;
+-  BackwardMatch* matches = BROTLI_ALLOC(m, BackwardMatch, matches_size);
+-  size_t gap = 0;
+-  size_t shadow_matches = 0;
+-  BROTLI_UNUSED(literal_context_lut);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(num_matches) ||
+-      BROTLI_IS_NULL(matches)) {
+-    return;
+-  }
+-  for (i = 0; i + HashTypeLengthH10() - 1 < num_bytes; ++i) {
+-    const size_t pos = position + i;
+-    size_t max_distance = BROTLI_MIN(size_t, pos, max_backward_limit);
+-    size_t dictionary_start = BROTLI_MIN(size_t,
+-        pos + stream_offset, max_backward_limit);
+-    size_t max_length = num_bytes - i;
+-    size_t num_found_matches;
+-    size_t cur_match_end;
+-    size_t j;
+-    /* Ensure that we have enough free slots. */
+-    BROTLI_ENSURE_CAPACITY(m, BackwardMatch, matches, matches_size,
+-        cur_match_pos + MAX_NUM_MATCHES_H10 + shadow_matches);
+-    if (BROTLI_IS_OOM(m)) return;
+-    num_found_matches = FindAllMatchesH10(&hasher->privat._H10,
+-        &params->dictionary,
+-        ringbuffer, ringbuffer_mask, pos, max_length,
+-        max_distance, dictionary_start + gap, params,
+-        &matches[cur_match_pos + shadow_matches]);
+-    cur_match_end = cur_match_pos + num_found_matches;
+-    for (j = cur_match_pos; j + 1 < cur_match_end; ++j) {
+-      BROTLI_DCHECK(BackwardMatchLength(&matches[j]) <=
+-          BackwardMatchLength(&matches[j + 1]));
+-    }
+-    num_matches[i] = (uint32_t)num_found_matches;
+-    if (num_found_matches > 0) {
+-      const size_t match_len = BackwardMatchLength(&matches[cur_match_end - 1]);
+-      if (match_len > MAX_ZOPFLI_LEN_QUALITY_11) {
+-        const size_t skip = match_len - 1;
+-        matches[cur_match_pos++] = matches[cur_match_end - 1];
+-        num_matches[i] = 1;
+-        /* Add the tail of the copy to the hasher. */
+-        StoreRangeH10(&hasher->privat._H10,
+-                      ringbuffer, ringbuffer_mask, pos + 1,
+-                      BROTLI_MIN(size_t, pos + match_len, store_end));
+-        memset(&num_matches[i + 1], 0, skip * sizeof(num_matches[0]));
+-        i += skip;
+-      } else {
+-        cur_match_pos = cur_match_end;
+-      }
+-    }
+-  }
+-  orig_num_literals = *num_literals;
+-  orig_last_insert_len = *last_insert_len;
+-  memcpy(orig_dist_cache, dist_cache, 4 * sizeof(dist_cache[0]));
+-  orig_num_commands = *num_commands;
+-  nodes = BROTLI_ALLOC(m, ZopfliNode, num_bytes + 1);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(nodes)) return;
+-  InitZopfliCostModel(m, &model, &params->dist, num_bytes);
+-  if (BROTLI_IS_OOM(m)) return;
+-  for (i = 0; i < 2; i++) {
+-    BrotliInitZopfliNodes(nodes, num_bytes + 1);
+-    if (i == 0) {
+-      ZopfliCostModelSetFromLiteralCosts(
+-          &model, position, ringbuffer, ringbuffer_mask);
+-    } else {
+-      ZopfliCostModelSetFromCommands(&model, position, ringbuffer,
+-          ringbuffer_mask, commands, *num_commands - orig_num_commands,
+-          orig_last_insert_len);
+-    }
+-    *num_commands = orig_num_commands;
+-    *num_literals = orig_num_literals;
+-    *last_insert_len = orig_last_insert_len;
+-    memcpy(dist_cache, orig_dist_cache, 4 * sizeof(dist_cache[0]));
+-    *num_commands += ZopfliIterate(num_bytes, position, ringbuffer,
+-        ringbuffer_mask, params, gap, dist_cache, &model, num_matches, matches,
+-        nodes);
+-    BrotliZopfliCreateCommands(num_bytes, position, nodes, dist_cache,
+-        last_insert_len, params, commands, num_literals);
+-  }
+-  CleanupZopfliCostModel(m, &model);
+-  BROTLI_FREE(m, nodes);
+-  BROTLI_FREE(m, matches);
+-  BROTLI_FREE(m, num_matches);
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/backward_references_hq.h b/modules/brotli/enc/backward_references_hq.h
+deleted file mode 100644
+--- a/modules/brotli/enc/backward_references_hq.h
++++ /dev/null
+@@ -1,95 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function to find backward reference copies. */
+-
+-#ifndef BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
+-#define BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./hash.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-BROTLI_INTERNAL void BrotliCreateZopfliBackwardReferences(MemoryManager* m,
+-    size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals);
+-
+-BROTLI_INTERNAL void BrotliCreateHqZopfliBackwardReferences(MemoryManager* m,
+-    size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals);
+-
+-typedef struct ZopfliNode {
+-  /* Best length to get up to this byte (not including this byte itself)
+-     highest 7 bit is used to reconstruct the length code. */
+-  uint32_t length;
+-  /* Distance associated with the length. */
+-  uint32_t distance;
+-  /* Number of literal inserts before this copy; highest 5 bits contain
+-     distance short code + 1 (or zero if no short code). */
+-  uint32_t dcode_insert_length;
+-
+-  /* This union holds information used by dynamic-programming. During forward
+-     pass |cost| it used to store the goal function. When node is processed its
+-     |cost| is invalidated in favor of |shortcut|. On path back-tracing pass
+-     |next| is assigned the offset to next node on the path. */
+-  union {
+-    /* Smallest cost to get to this byte from the beginning, as found so far. */
+-    float cost;
+-    /* Offset to the next node on the path. Equals to command_length() of the
+-       next node on the path. For last node equals to BROTLI_UINT32_MAX */
+-    uint32_t next;
+-    /* Node position that provides next distance for distance cache. */
+-    uint32_t shortcut;
+-  } u;
+-} ZopfliNode;
+-
+-BROTLI_INTERNAL void BrotliInitZopfliNodes(ZopfliNode* array, size_t length);
+-
+-/* Computes the shortest path of commands from position to at most
+-   position + num_bytes.
+-
+-   On return, path->size() is the number of commands found and path[i] is the
+-   length of the i-th command (copy length plus insert length).
+-   Note that the sum of the lengths of all commands can be less than num_bytes.
+-
+-   On return, the nodes[0..num_bytes] array will have the following
+-   "ZopfliNode array invariant":
+-   For each i in [1..num_bytes], if nodes[i].cost < kInfinity, then
+-     (1) nodes[i].copy_length() >= 2
+-     (2) nodes[i].command_length() <= i and
+-     (3) nodes[i - nodes[i].command_length()].cost < kInfinity */
+-BROTLI_INTERNAL size_t BrotliZopfliComputeShortestPath(
+-    MemoryManager* m, size_t num_bytes,
+-    size_t position, const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    const int* dist_cache, Hasher* hasher, ZopfliNode* nodes);
+-
+-BROTLI_INTERNAL void BrotliZopfliCreateCommands(
+-    const size_t num_bytes, const size_t block_start, const ZopfliNode* nodes,
+-    int* dist_cache, size_t* last_insert_len, const BrotliEncoderParams* params,
+-    Command* commands, size_t* num_literals);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_BACKWARD_REFERENCES_HQ_H_ */
+diff --git a/modules/brotli/enc/backward_references_inc.h b/modules/brotli/enc/backward_references_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/backward_references_inc.h
++++ /dev/null
+@@ -1,163 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: EXPORT_FN, FN */
+-
+-static BROTLI_NOINLINE void EXPORT_FN(CreateBackwardReferences)(
+-    size_t num_bytes, size_t position,
+-    const uint8_t* ringbuffer, size_t ringbuffer_mask,
+-    ContextLut literal_context_lut, const BrotliEncoderParams* params,
+-    Hasher* hasher, int* dist_cache, size_t* last_insert_len,
+-    Command* commands, size_t* num_commands, size_t* num_literals) {
+-  HASHER()* privat = &hasher->privat.FN(_);
+-  /* Set maximum distance, see section 9.1. of the spec. */
+-  const size_t max_backward_limit = BROTLI_MAX_BACKWARD_LIMIT(params->lgwin);
+-  const size_t position_offset = params->stream_offset;
+-
+-  const Command* const orig_commands = commands;
+-  size_t insert_length = *last_insert_len;
+-  const size_t pos_end = position + num_bytes;
+-  const size_t store_end = num_bytes >= FN(StoreLookahead)() ?
+-      position + num_bytes - FN(StoreLookahead)() + 1 : position;
+-
+-  /* For speed up heuristics for random data. */
+-  const size_t random_heuristics_window_size =
+-      LiteralSpreeLengthForSparseSearch(params);
+-  size_t apply_random_heuristics = position + random_heuristics_window_size;
+-  const size_t gap = 0;
+-
+-  /* Minimum score to accept a backward reference. */
+-  const score_t kMinScore = BROTLI_SCORE_BASE + 100;
+-
+-  BROTLI_UNUSED(literal_context_lut);
+-
+-  FN(PrepareDistanceCache)(privat, dist_cache);
+-
+-  while (position + FN(HashTypeLength)() < pos_end) {
+-    size_t max_length = pos_end - position;
+-    size_t max_distance = BROTLI_MIN(size_t, position, max_backward_limit);
+-    size_t dictionary_start = BROTLI_MIN(size_t,
+-        position + position_offset, max_backward_limit);
+-    HasherSearchResult sr;
+-    sr.len = 0;
+-    sr.len_code_delta = 0;
+-    sr.distance = 0;
+-    sr.score = kMinScore;
+-    FN(FindLongestMatch)(privat, &params->dictionary,
+-        ringbuffer, ringbuffer_mask, dist_cache, position, max_length,
+-        max_distance, dictionary_start + gap, params->dist.max_distance, &sr);
+-    if (sr.score > kMinScore) {
+-      /* Found a match. Let's look for something even better ahead. */
+-      int delayed_backward_references_in_row = 0;
+-      --max_length;
+-      for (;; --max_length) {
+-        const score_t cost_diff_lazy = 175;
+-        HasherSearchResult sr2;
+-        sr2.len = params->quality < MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH ?
+-            BROTLI_MIN(size_t, sr.len - 1, max_length) : 0;
+-        sr2.len_code_delta = 0;
+-        sr2.distance = 0;
+-        sr2.score = kMinScore;
+-        max_distance = BROTLI_MIN(size_t, position + 1, max_backward_limit);
+-        dictionary_start = BROTLI_MIN(size_t,
+-            position + 1 + position_offset, max_backward_limit);
+-        FN(FindLongestMatch)(privat,
+-            &params->dictionary,
+-            ringbuffer, ringbuffer_mask, dist_cache, position + 1, max_length,
+-            max_distance, dictionary_start + gap, params->dist.max_distance,
+-            &sr2);
+-        if (sr2.score >= sr.score + cost_diff_lazy) {
+-          /* Ok, let's just write one byte for now and start a match from the
+-             next byte. */
+-          ++position;
+-          ++insert_length;
+-          sr = sr2;
+-          if (++delayed_backward_references_in_row < 4 &&
+-              position + FN(HashTypeLength)() < pos_end) {
+-            continue;
+-          }
+-        }
+-        break;
+-      }
+-      apply_random_heuristics =
+-          position + 2 * sr.len + random_heuristics_window_size;
+-      dictionary_start = BROTLI_MIN(size_t,
+-          position + position_offset, max_backward_limit);
+-      {
+-        /* The first 16 codes are special short-codes,
+-           and the minimum offset is 1. */
+-        size_t distance_code = ComputeDistanceCode(
+-            sr.distance, dictionary_start + gap, dist_cache);
+-        if ((sr.distance <= (dictionary_start + gap)) && distance_code > 0) {
+-          dist_cache[3] = dist_cache[2];
+-          dist_cache[2] = dist_cache[1];
+-          dist_cache[1] = dist_cache[0];
+-          dist_cache[0] = (int)sr.distance;
+-          FN(PrepareDistanceCache)(privat, dist_cache);
+-        }
+-        InitCommand(commands++, &params->dist, insert_length,
+-            sr.len, sr.len_code_delta, distance_code);
+-      }
+-      *num_literals += insert_length;
+-      insert_length = 0;
+-      /* Put the hash keys into the table, if there are enough bytes left.
+-         Depending on the hasher implementation, it can push all positions
+-         in the given range or only a subset of them.
+-         Avoid hash poisoning with RLE data. */
+-      {
+-        size_t range_start = position + 2;
+-        size_t range_end = BROTLI_MIN(size_t, position + sr.len, store_end);
+-        if (sr.distance < (sr.len >> 2)) {
+-          range_start = BROTLI_MIN(size_t, range_end, BROTLI_MAX(size_t,
+-              range_start, position + sr.len - (sr.distance << 2)));
+-        }
+-        FN(StoreRange)(privat, ringbuffer, ringbuffer_mask, range_start,
+-                       range_end);
+-      }
+-      position += sr.len;
+-    } else {
+-      ++insert_length;
+-      ++position;
+-      /* If we have not seen matches for a long time, we can skip some
+-         match lookups. Unsuccessful match lookups are very very expensive
+-         and this kind of a heuristic speeds up compression quite
+-         a lot. */
+-      if (position > apply_random_heuristics) {
+-        /* Going through uncompressible data, jump. */
+-        if (position >
+-            apply_random_heuristics + 4 * random_heuristics_window_size) {
+-          /* It is quite a long time since we saw a copy, so we assume
+-             that this data is not compressible, and store hashes less
+-             often. Hashes of non compressible data are less likely to
+-             turn out to be useful in the future, too, so we store less of
+-             them to not to flood out the hash table of good compressible
+-             data. */
+-          const size_t kMargin =
+-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 4);
+-          size_t pos_jump =
+-              BROTLI_MIN(size_t, position + 16, pos_end - kMargin);
+-          for (; position < pos_jump; position += 4) {
+-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
+-            insert_length += 4;
+-          }
+-        } else {
+-          const size_t kMargin =
+-              BROTLI_MAX(size_t, FN(StoreLookahead)() - 1, 2);
+-          size_t pos_jump =
+-              BROTLI_MIN(size_t, position + 8, pos_end - kMargin);
+-          for (; position < pos_jump; position += 2) {
+-            FN(Store)(privat, ringbuffer, ringbuffer_mask, position);
+-            insert_length += 2;
+-          }
+-        }
+-      }
+-    }
+-  }
+-  insert_length += pos_end - position;
+-  *last_insert_len = insert_length;
+-  *num_commands += (size_t)(commands - orig_commands);
+-}
+diff --git a/modules/brotli/enc/bit_cost.c b/modules/brotli/enc/bit_cost.c
+deleted file mode 100644
+--- a/modules/brotli/enc/bit_cost.c
++++ /dev/null
+@@ -1,35 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions to estimate the bit cost of Huffman trees. */
+-
+-#include "./bit_cost.h"
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./fast_log.h"
+-#include "./histogram.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define FN(X) X ## Literal
+-#include "./bit_cost_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#include "./bit_cost_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-#include "./bit_cost_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/bit_cost.h b/modules/brotli/enc/bit_cost.h
+deleted file mode 100644
+--- a/modules/brotli/enc/bit_cost.h
++++ /dev/null
+@@ -1,63 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions to estimate the bit cost of Huffman trees. */
+-
+-#ifndef BROTLI_ENC_BIT_COST_H_
+-#define BROTLI_ENC_BIT_COST_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./fast_log.h"
+-#include "./histogram.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static BROTLI_INLINE double ShannonEntropy(
+-    const uint32_t* population, size_t size, size_t* total) {
+-  size_t sum = 0;
+-  double retval = 0;
+-  const uint32_t* population_end = population + size;
+-  size_t p;
+-  if (size & 1) {
+-    goto odd_number_of_elements_left;
+-  }
+-  while (population < population_end) {
+-    p = *population++;
+-    sum += p;
+-    retval -= (double)p * FastLog2(p);
+- odd_number_of_elements_left:
+-    p = *population++;
+-    sum += p;
+-    retval -= (double)p * FastLog2(p);
+-  }
+-  if (sum) retval += (double)sum * FastLog2(sum);
+-  *total = sum;
+-  return retval;
+-}
+-
+-static BROTLI_INLINE double BitsEntropy(
+-    const uint32_t* population, size_t size) {
+-  size_t sum;
+-  double retval = ShannonEntropy(population, size, &sum);
+-  if (retval < sum) {
+-    /* At least one bit per literal is needed. */
+-    retval = (double)sum;
+-  }
+-  return retval;
+-}
+-
+-BROTLI_INTERNAL double BrotliPopulationCostLiteral(const HistogramLiteral*);
+-BROTLI_INTERNAL double BrotliPopulationCostCommand(const HistogramCommand*);
+-BROTLI_INTERNAL double BrotliPopulationCostDistance(const HistogramDistance*);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_BIT_COST_H_ */
+diff --git a/modules/brotli/enc/bit_cost_inc.h b/modules/brotli/enc/bit_cost_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/bit_cost_inc.h
++++ /dev/null
+@@ -1,127 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN */
+-
+-#define HistogramType FN(Histogram)
+-
+-double FN(BrotliPopulationCost)(const HistogramType* histogram) {
+-  static const double kOneSymbolHistogramCost = 12;
+-  static const double kTwoSymbolHistogramCost = 20;
+-  static const double kThreeSymbolHistogramCost = 28;
+-  static const double kFourSymbolHistogramCost = 37;
+-  const size_t data_size = FN(HistogramDataSize)();
+-  int count = 0;
+-  size_t s[5];
+-  double bits = 0.0;
+-  size_t i;
+-  if (histogram->total_count_ == 0) {
+-    return kOneSymbolHistogramCost;
+-  }
+-  for (i = 0; i < data_size; ++i) {
+-    if (histogram->data_[i] > 0) {
+-      s[count] = i;
+-      ++count;
+-      if (count > 4) break;
+-    }
+-  }
+-  if (count == 1) {
+-    return kOneSymbolHistogramCost;
+-  }
+-  if (count == 2) {
+-    return (kTwoSymbolHistogramCost + (double)histogram->total_count_);
+-  }
+-  if (count == 3) {
+-    const uint32_t histo0 = histogram->data_[s[0]];
+-    const uint32_t histo1 = histogram->data_[s[1]];
+-    const uint32_t histo2 = histogram->data_[s[2]];
+-    const uint32_t histomax =
+-        BROTLI_MAX(uint32_t, histo0, BROTLI_MAX(uint32_t, histo1, histo2));
+-    return (kThreeSymbolHistogramCost +
+-            2 * (histo0 + histo1 + histo2) - histomax);
+-  }
+-  if (count == 4) {
+-    uint32_t histo[4];
+-    uint32_t h23;
+-    uint32_t histomax;
+-    for (i = 0; i < 4; ++i) {
+-      histo[i] = histogram->data_[s[i]];
+-    }
+-    /* Sort */
+-    for (i = 0; i < 4; ++i) {
+-      size_t j;
+-      for (j = i + 1; j < 4; ++j) {
+-        if (histo[j] > histo[i]) {
+-          BROTLI_SWAP(uint32_t, histo, j, i);
+-        }
+-      }
+-    }
+-    h23 = histo[2] + histo[3];
+-    histomax = BROTLI_MAX(uint32_t, h23, histo[0]);
+-    return (kFourSymbolHistogramCost +
+-            3 * h23 + 2 * (histo[0] + histo[1]) - histomax);
+-  }
+-
+-  {
+-    /* In this loop we compute the entropy of the histogram and simultaneously
+-       build a simplified histogram of the code length codes where we use the
+-       zero repeat code 17, but we don't use the non-zero repeat code 16. */
+-    size_t max_depth = 1;
+-    uint32_t depth_histo[BROTLI_CODE_LENGTH_CODES] = { 0 };
+-    const double log2total = FastLog2(histogram->total_count_);
+-    for (i = 0; i < data_size;) {
+-      if (histogram->data_[i] > 0) {
+-        /* Compute -log2(P(symbol)) = -log2(count(symbol)/total_count) =
+-                                    = log2(total_count) - log2(count(symbol)) */
+-        double log2p = log2total - FastLog2(histogram->data_[i]);
+-        /* Approximate the bit depth by round(-log2(P(symbol))) */
+-        size_t depth = (size_t)(log2p + 0.5);
+-        bits += histogram->data_[i] * log2p;
+-        if (depth > 15) {
+-          depth = 15;
+-        }
+-        if (depth > max_depth) {
+-          max_depth = depth;
+-        }
+-        ++depth_histo[depth];
+-        ++i;
+-      } else {
+-        /* Compute the run length of zeros and add the appropriate number of 0
+-           and 17 code length codes to the code length code histogram. */
+-        uint32_t reps = 1;
+-        size_t k;
+-        for (k = i + 1; k < data_size && histogram->data_[k] == 0; ++k) {
+-          ++reps;
+-        }
+-        i += reps;
+-        if (i == data_size) {
+-          /* Don't add any cost for the last zero run, since these are encoded
+-             only implicitly. */
+-          break;
+-        }
+-        if (reps < 3) {
+-          depth_histo[0] += reps;
+-        } else {
+-          reps -= 2;
+-          while (reps > 0) {
+-            ++depth_histo[BROTLI_REPEAT_ZERO_CODE_LENGTH];
+-            /* Add the 3 extra bits for the 17 code length code. */
+-            bits += 3;
+-            reps >>= 3;
+-          }
+-        }
+-      }
+-    }
+-    /* Add the estimated encoding cost of the code length code histogram. */
+-    bits += (double)(18 + 2 * max_depth);
+-    /* Add the entropy of the code length code histogram. */
+-    bits += BitsEntropy(depth_histo, BROTLI_CODE_LENGTH_CODES);
+-  }
+-  return bits;
+-}
+-
+-#undef HistogramType
+diff --git a/modules/brotli/enc/block_encoder_inc.h b/modules/brotli/enc/block_encoder_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/block_encoder_inc.h
++++ /dev/null
+@@ -1,34 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2014 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN */
+-
+-#define HistogramType FN(Histogram)
+-
+-/* Creates entropy codes for all block types and stores them to the bit
+-   stream. */
+-static void FN(BuildAndStoreEntropyCodes)(MemoryManager* m, BlockEncoder* self,
+-    const HistogramType* histograms, const size_t histograms_size,
+-    const size_t alphabet_size, HuffmanTree* tree,
+-    size_t* storage_ix, uint8_t* storage) {
+-  const size_t table_size = histograms_size * self->histogram_length_;
+-  self->depths_ = BROTLI_ALLOC(m, uint8_t, table_size);
+-  self->bits_ = BROTLI_ALLOC(m, uint16_t, table_size);
+-  if (BROTLI_IS_OOM(m)) return;
+-
+-  {
+-    size_t i;
+-    for (i = 0; i < histograms_size; ++i) {
+-      size_t ix = i * self->histogram_length_;
+-      BuildAndStoreHuffmanTree(&histograms[i].data_[0], self->histogram_length_,
+-          alphabet_size, tree, &self->depths_[ix], &self->bits_[ix],
+-          storage_ix, storage);
+-    }
+-  }
+-}
+-
+-#undef HistogramType
+diff --git a/modules/brotli/enc/block_splitter.c b/modules/brotli/enc/block_splitter.c
+deleted file mode 100644
+--- a/modules/brotli/enc/block_splitter.c
++++ /dev/null
+@@ -1,194 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Block split point selection utilities. */
+-
+-#include "./block_splitter.h"
+-
+-#include <string.h>  /* memcpy, memset */
+-
+-#include "../common/platform.h"
+-#include "./bit_cost.h"
+-#include "./cluster.h"
+-#include "./command.h"
+-#include "./fast_log.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static const size_t kMaxLiteralHistograms = 100;
+-static const size_t kMaxCommandHistograms = 50;
+-static const double kLiteralBlockSwitchCost = 28.1;
+-static const double kCommandBlockSwitchCost = 13.5;
+-static const double kDistanceBlockSwitchCost = 14.6;
+-static const size_t kLiteralStrideLength = 70;
+-static const size_t kCommandStrideLength = 40;
+-static const size_t kSymbolsPerLiteralHistogram = 544;
+-static const size_t kSymbolsPerCommandHistogram = 530;
+-static const size_t kSymbolsPerDistanceHistogram = 544;
+-static const size_t kMinLengthForBlockSplitting = 128;
+-static const size_t kIterMulForRefining = 2;
+-static const size_t kMinItersForRefining = 100;
+-
+-static size_t CountLiterals(const Command* cmds, const size_t num_commands) {
+-  /* Count how many we have. */
+-  size_t total_length = 0;
+-  size_t i;
+-  for (i = 0; i < num_commands; ++i) {
+-    total_length += cmds[i].insert_len_;
+-  }
+-  return total_length;
+-}
+-
+-static void CopyLiteralsToByteArray(const Command* cmds,
+-                                    const size_t num_commands,
+-                                    const uint8_t* data,
+-                                    const size_t offset,
+-                                    const size_t mask,
+-                                    uint8_t* literals) {
+-  size_t pos = 0;
+-  size_t from_pos = offset & mask;
+-  size_t i;
+-  for (i = 0; i < num_commands; ++i) {
+-    size_t insert_len = cmds[i].insert_len_;
+-    if (from_pos + insert_len > mask) {
+-      size_t head_size = mask + 1 - from_pos;
+-      memcpy(literals + pos, data + from_pos, head_size);
+-      from_pos = 0;
+-      pos += head_size;
+-      insert_len -= head_size;
+-    }
+-    if (insert_len > 0) {
+-      memcpy(literals + pos, data + from_pos, insert_len);
+-      pos += insert_len;
+-    }
+-    from_pos = (from_pos + insert_len + CommandCopyLen(&cmds[i])) & mask;
+-  }
+-}
+-
+-static BROTLI_INLINE uint32_t MyRand(uint32_t* seed) {
+-  /* Initial seed should be 7. In this case, loop length is (1 << 29). */
+-  *seed *= 16807U;
+-  return *seed;
+-}
+-
+-static BROTLI_INLINE double BitCost(size_t count) {
+-  return count == 0 ? -2.0 : FastLog2(count);
+-}
+-
+-#define HISTOGRAMS_PER_BATCH 64
+-#define CLUSTERS_PER_BATCH 16
+-
+-#define FN(X) X ## Literal
+-#define DataType uint8_t
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_splitter_inc.h"
+-#undef DataType
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#define DataType uint16_t
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_splitter_inc.h"
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_splitter_inc.h"
+-#undef DataType
+-#undef FN
+-
+-void BrotliInitBlockSplit(BlockSplit* self) {
+-  self->num_types = 0;
+-  self->num_blocks = 0;
+-  self->types = 0;
+-  self->lengths = 0;
+-  self->types_alloc_size = 0;
+-  self->lengths_alloc_size = 0;
+-}
+-
+-void BrotliDestroyBlockSplit(MemoryManager* m, BlockSplit* self) {
+-  BROTLI_FREE(m, self->types);
+-  BROTLI_FREE(m, self->lengths);
+-}
+-
+-void BrotliSplitBlock(MemoryManager* m,
+-                      const Command* cmds,
+-                      const size_t num_commands,
+-                      const uint8_t* data,
+-                      const size_t pos,
+-                      const size_t mask,
+-                      const BrotliEncoderParams* params,
+-                      BlockSplit* literal_split,
+-                      BlockSplit* insert_and_copy_split,
+-                      BlockSplit* dist_split) {
+-  {
+-    size_t literals_count = CountLiterals(cmds, num_commands);
+-    uint8_t* literals = BROTLI_ALLOC(m, uint8_t, literals_count);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literals)) return;
+-    /* Create a continuous array of literals. */
+-    CopyLiteralsToByteArray(cmds, num_commands, data, pos, mask, literals);
+-    /* Create the block split on the array of literals.
+-       Literal histograms have alphabet size 256. */
+-    SplitByteVectorLiteral(
+-        m, literals, literals_count,
+-        kSymbolsPerLiteralHistogram, kMaxLiteralHistograms,
+-        kLiteralStrideLength, kLiteralBlockSwitchCost, params,
+-        literal_split);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BROTLI_FREE(m, literals);
+-  }
+-
+-  {
+-    /* Compute prefix codes for commands. */
+-    uint16_t* insert_and_copy_codes = BROTLI_ALLOC(m, uint16_t, num_commands);
+-    size_t i;
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(insert_and_copy_codes)) return;
+-    for (i = 0; i < num_commands; ++i) {
+-      insert_and_copy_codes[i] = cmds[i].cmd_prefix_;
+-    }
+-    /* Create the block split on the array of command prefixes. */
+-    SplitByteVectorCommand(
+-        m, insert_and_copy_codes, num_commands,
+-        kSymbolsPerCommandHistogram, kMaxCommandHistograms,
+-        kCommandStrideLength, kCommandBlockSwitchCost, params,
+-        insert_and_copy_split);
+-    if (BROTLI_IS_OOM(m)) return;
+-    /* TODO: reuse for distances? */
+-    BROTLI_FREE(m, insert_and_copy_codes);
+-  }
+-
+-  {
+-    /* Create a continuous array of distance prefixes. */
+-    uint16_t* distance_prefixes = BROTLI_ALLOC(m, uint16_t, num_commands);
+-    size_t j = 0;
+-    size_t i;
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(distance_prefixes)) return;
+-    for (i = 0; i < num_commands; ++i) {
+-      const Command* cmd = &cmds[i];
+-      if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
+-        distance_prefixes[j++] = cmd->dist_prefix_ & 0x3FF;
+-      }
+-    }
+-    /* Create the block split on the array of distance prefixes. */
+-    SplitByteVectorDistance(
+-        m, distance_prefixes, j,
+-        kSymbolsPerDistanceHistogram, kMaxCommandHistograms,
+-        kCommandStrideLength, kDistanceBlockSwitchCost, params,
+-        dist_split);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BROTLI_FREE(m, distance_prefixes);
+-  }
+-}
+-
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/block_splitter.h b/modules/brotli/enc/block_splitter.h
+deleted file mode 100644
+--- a/modules/brotli/enc/block_splitter.h
++++ /dev/null
+@@ -1,51 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Block split point selection utilities. */
+-
+-#ifndef BROTLI_ENC_BLOCK_SPLITTER_H_
+-#define BROTLI_ENC_BLOCK_SPLITTER_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct BlockSplit {
+-  size_t num_types;  /* Amount of distinct types */
+-  size_t num_blocks;  /* Amount of values in types and length */
+-  uint8_t* types;
+-  uint32_t* lengths;
+-
+-  size_t types_alloc_size;
+-  size_t lengths_alloc_size;
+-} BlockSplit;
+-
+-BROTLI_INTERNAL void BrotliInitBlockSplit(BlockSplit* self);
+-BROTLI_INTERNAL void BrotliDestroyBlockSplit(MemoryManager* m,
+-                                             BlockSplit* self);
+-
+-BROTLI_INTERNAL void BrotliSplitBlock(MemoryManager* m,
+-                                      const Command* cmds,
+-                                      const size_t num_commands,
+-                                      const uint8_t* data,
+-                                      const size_t offset,
+-                                      const size_t mask,
+-                                      const BrotliEncoderParams* params,
+-                                      BlockSplit* literal_split,
+-                                      BlockSplit* insert_and_copy_split,
+-                                      BlockSplit* dist_split);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_BLOCK_SPLITTER_H_ */
+diff --git a/modules/brotli/enc/block_splitter_inc.h b/modules/brotli/enc/block_splitter_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/block_splitter_inc.h
++++ /dev/null
+@@ -1,440 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, DataType */
+-
+-#define HistogramType FN(Histogram)
+-
+-static void FN(InitialEntropyCodes)(const DataType* data, size_t length,
+-                                    size_t stride,
+-                                    size_t num_histograms,
+-                                    HistogramType* histograms) {
+-  uint32_t seed = 7;
+-  size_t block_length = length / num_histograms;
+-  size_t i;
+-  FN(ClearHistograms)(histograms, num_histograms);
+-  for (i = 0; i < num_histograms; ++i) {
+-    size_t pos = length * i / num_histograms;
+-    if (i != 0) {
+-      pos += MyRand(&seed) % block_length;
+-    }
+-    if (pos + stride >= length) {
+-      pos = length - stride - 1;
+-    }
+-    FN(HistogramAddVector)(&histograms[i], data + pos, stride);
+-  }
+-}
+-
+-static void FN(RandomSample)(uint32_t* seed,
+-                             const DataType* data,
+-                             size_t length,
+-                             size_t stride,
+-                             HistogramType* sample) {
+-  size_t pos = 0;
+-  if (stride >= length) {
+-    stride = length;
+-  } else {
+-    pos = MyRand(seed) % (length - stride + 1);
+-  }
+-  FN(HistogramAddVector)(sample, data + pos, stride);
+-}
+-
+-static void FN(RefineEntropyCodes)(const DataType* data, size_t length,
+-                                   size_t stride,
+-                                   size_t num_histograms,
+-                                   HistogramType* histograms) {
+-  size_t iters =
+-      kIterMulForRefining * length / stride + kMinItersForRefining;
+-  uint32_t seed = 7;
+-  size_t iter;
+-  iters = ((iters + num_histograms - 1) / num_histograms) * num_histograms;
+-  for (iter = 0; iter < iters; ++iter) {
+-    HistogramType sample;
+-    FN(HistogramClear)(&sample);
+-    FN(RandomSample)(&seed, data, length, stride, &sample);
+-    FN(HistogramAddHistogram)(&histograms[iter % num_histograms], &sample);
+-  }
+-}
+-
+-/* Assigns a block id from the range [0, num_histograms) to each data element
+-   in data[0..length) and fills in block_id[0..length) with the assigned values.
+-   Returns the number of blocks, i.e. one plus the number of block switches. */
+-static size_t FN(FindBlocks)(const DataType* data, const size_t length,
+-                             const double block_switch_bitcost,
+-                             const size_t num_histograms,
+-                             const HistogramType* histograms,
+-                             double* insert_cost,
+-                             double* cost,
+-                             uint8_t* switch_signal,
+-                             uint8_t* block_id) {
+-  const size_t data_size = FN(HistogramDataSize)();
+-  const size_t bitmaplen = (num_histograms + 7) >> 3;
+-  size_t num_blocks = 1;
+-  size_t i;
+-  size_t j;
+-  BROTLI_DCHECK(num_histograms <= 256);
+-  if (num_histograms <= 1) {
+-    for (i = 0; i < length; ++i) {
+-      block_id[i] = 0;
+-    }
+-    return 1;
+-  }
+-  memset(insert_cost, 0, sizeof(insert_cost[0]) * data_size * num_histograms);
+-  for (i = 0; i < num_histograms; ++i) {
+-    insert_cost[i] = FastLog2((uint32_t)histograms[i].total_count_);
+-  }
+-  for (i = data_size; i != 0;) {
+-    --i;
+-    for (j = 0; j < num_histograms; ++j) {
+-      insert_cost[i * num_histograms + j] =
+-          insert_cost[j] - BitCost(histograms[j].data_[i]);
+-    }
+-  }
+-  memset(cost, 0, sizeof(cost[0]) * num_histograms);
+-  memset(switch_signal, 0, sizeof(switch_signal[0]) * length * bitmaplen);
+-  /* After each iteration of this loop, cost[k] will contain the difference
+-     between the minimum cost of arriving at the current byte position using
+-     entropy code k, and the minimum cost of arriving at the current byte
+-     position. This difference is capped at the block switch cost, and if it
+-     reaches block switch cost, it means that when we trace back from the last
+-     position, we need to switch here. */
+-  for (i = 0; i < length; ++i) {
+-    const size_t byte_ix = i;
+-    size_t ix = byte_ix * bitmaplen;
+-    size_t insert_cost_ix = data[byte_ix] * num_histograms;
+-    double min_cost = 1e99;
+-    double block_switch_cost = block_switch_bitcost;
+-    size_t k;
+-    for (k = 0; k < num_histograms; ++k) {
+-      /* We are coding the symbol in data[byte_ix] with entropy code k. */
+-      cost[k] += insert_cost[insert_cost_ix + k];
+-      if (cost[k] < min_cost) {
+-        min_cost = cost[k];
+-        block_id[byte_ix] = (uint8_t)k;
+-      }
+-    }
+-    /* More blocks for the beginning. */
+-    if (byte_ix < 2000) {
+-      block_switch_cost *= 0.77 + 0.07 * (double)byte_ix / 2000;
+-    }
+-    for (k = 0; k < num_histograms; ++k) {
+-      cost[k] -= min_cost;
+-      if (cost[k] >= block_switch_cost) {
+-        const uint8_t mask = (uint8_t)(1u << (k & 7));
+-        cost[k] = block_switch_cost;
+-        BROTLI_DCHECK((k >> 3) < bitmaplen);
+-        switch_signal[ix + (k >> 3)] |= mask;
+-      }
+-    }
+-  }
+-  {  /* Trace back from the last position and switch at the marked places. */
+-    size_t byte_ix = length - 1;
+-    size_t ix = byte_ix * bitmaplen;
+-    uint8_t cur_id = block_id[byte_ix];
+-    while (byte_ix > 0) {
+-      const uint8_t mask = (uint8_t)(1u << (cur_id & 7));
+-      BROTLI_DCHECK(((size_t)cur_id >> 3) < bitmaplen);
+-      --byte_ix;
+-      ix -= bitmaplen;
+-      if (switch_signal[ix + (cur_id >> 3)] & mask) {
+-        if (cur_id != block_id[byte_ix]) {
+-          cur_id = block_id[byte_ix];
+-          ++num_blocks;
+-        }
+-      }
+-      block_id[byte_ix] = cur_id;
+-    }
+-  }
+-  return num_blocks;
+-}
+-
+-static size_t FN(RemapBlockIds)(uint8_t* block_ids, const size_t length,
+-                                uint16_t* new_id, const size_t num_histograms) {
+-  static const uint16_t kInvalidId = 256;
+-  uint16_t next_id = 0;
+-  size_t i;
+-  for (i = 0; i < num_histograms; ++i) {
+-    new_id[i] = kInvalidId;
+-  }
+-  for (i = 0; i < length; ++i) {
+-    BROTLI_DCHECK(block_ids[i] < num_histograms);
+-    if (new_id[block_ids[i]] == kInvalidId) {
+-      new_id[block_ids[i]] = next_id++;
+-    }
+-  }
+-  for (i = 0; i < length; ++i) {
+-    block_ids[i] = (uint8_t)new_id[block_ids[i]];
+-    BROTLI_DCHECK(block_ids[i] < num_histograms);
+-  }
+-  BROTLI_DCHECK(next_id <= num_histograms);
+-  return next_id;
+-}
+-
+-static void FN(BuildBlockHistograms)(const DataType* data, const size_t length,
+-                                     const uint8_t* block_ids,
+-                                     const size_t num_histograms,
+-                                     HistogramType* histograms) {
+-  size_t i;
+-  FN(ClearHistograms)(histograms, num_histograms);
+-  for (i = 0; i < length; ++i) {
+-    FN(HistogramAdd)(&histograms[block_ids[i]], data[i]);
+-  }
+-}
+-
+-static void FN(ClusterBlocks)(MemoryManager* m,
+-                              const DataType* data, const size_t length,
+-                              const size_t num_blocks,
+-                              uint8_t* block_ids,
+-                              BlockSplit* split) {
+-  uint32_t* histogram_symbols = BROTLI_ALLOC(m, uint32_t, num_blocks);
+-  uint32_t* block_lengths = BROTLI_ALLOC(m, uint32_t, num_blocks);
+-  const size_t expected_num_clusters = CLUSTERS_PER_BATCH *
+-      (num_blocks + HISTOGRAMS_PER_BATCH - 1) / HISTOGRAMS_PER_BATCH;
+-  size_t all_histograms_size = 0;
+-  size_t all_histograms_capacity = expected_num_clusters;
+-  HistogramType* all_histograms =
+-      BROTLI_ALLOC(m, HistogramType, all_histograms_capacity);
+-  size_t cluster_size_size = 0;
+-  size_t cluster_size_capacity = expected_num_clusters;
+-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, cluster_size_capacity);
+-  size_t num_clusters = 0;
+-  HistogramType* histograms = BROTLI_ALLOC(m, HistogramType,
+-      BROTLI_MIN(size_t, num_blocks, HISTOGRAMS_PER_BATCH));
+-  size_t max_num_pairs =
+-      HISTOGRAMS_PER_BATCH * HISTOGRAMS_PER_BATCH / 2;
+-  size_t pairs_capacity = max_num_pairs + 1;
+-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity);
+-  size_t pos = 0;
+-  uint32_t* clusters;
+-  size_t num_final_clusters;
+-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
+-  uint32_t* new_index;
+-  size_t i;
+-  uint32_t sizes[HISTOGRAMS_PER_BATCH] = { 0 };
+-  uint32_t new_clusters[HISTOGRAMS_PER_BATCH] = { 0 };
+-  uint32_t symbols[HISTOGRAMS_PER_BATCH] = { 0 };
+-  uint32_t remap[HISTOGRAMS_PER_BATCH] = { 0 };
+-
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histogram_symbols) ||
+-      BROTLI_IS_NULL(block_lengths) || BROTLI_IS_NULL(all_histograms) ||
+-      BROTLI_IS_NULL(cluster_size) || BROTLI_IS_NULL(histograms) ||
+-      BROTLI_IS_NULL(pairs)) {
+-    return;
+-  }
+-
+-  memset(block_lengths, 0, num_blocks * sizeof(uint32_t));
+-
+-  {
+-    size_t block_idx = 0;
+-    for (i = 0; i < length; ++i) {
+-      BROTLI_DCHECK(block_idx < num_blocks);
+-      ++block_lengths[block_idx];
+-      if (i + 1 == length || block_ids[i] != block_ids[i + 1]) {
+-        ++block_idx;
+-      }
+-    }
+-    BROTLI_DCHECK(block_idx == num_blocks);
+-  }
+-
+-  for (i = 0; i < num_blocks; i += HISTOGRAMS_PER_BATCH) {
+-    const size_t num_to_combine =
+-        BROTLI_MIN(size_t, num_blocks - i, HISTOGRAMS_PER_BATCH);
+-    size_t num_new_clusters;
+-    size_t j;
+-    for (j = 0; j < num_to_combine; ++j) {
+-      size_t k;
+-      FN(HistogramClear)(&histograms[j]);
+-      for (k = 0; k < block_lengths[i + j]; ++k) {
+-        FN(HistogramAdd)(&histograms[j], data[pos++]);
+-      }
+-      histograms[j].bit_cost_ = FN(BrotliPopulationCost)(&histograms[j]);
+-      new_clusters[j] = (uint32_t)j;
+-      symbols[j] = (uint32_t)j;
+-      sizes[j] = 1;
+-    }
+-    num_new_clusters = FN(BrotliHistogramCombine)(
+-        histograms, sizes, symbols, new_clusters, pairs, num_to_combine,
+-        num_to_combine, HISTOGRAMS_PER_BATCH, max_num_pairs);
+-    BROTLI_ENSURE_CAPACITY(m, HistogramType, all_histograms,
+-        all_histograms_capacity, all_histograms_size + num_new_clusters);
+-    BROTLI_ENSURE_CAPACITY(m, uint32_t, cluster_size,
+-        cluster_size_capacity, cluster_size_size + num_new_clusters);
+-    if (BROTLI_IS_OOM(m)) return;
+-    for (j = 0; j < num_new_clusters; ++j) {
+-      all_histograms[all_histograms_size++] = histograms[new_clusters[j]];
+-      cluster_size[cluster_size_size++] = sizes[new_clusters[j]];
+-      remap[new_clusters[j]] = (uint32_t)j;
+-    }
+-    for (j = 0; j < num_to_combine; ++j) {
+-      histogram_symbols[i + j] = (uint32_t)num_clusters + remap[symbols[j]];
+-    }
+-    num_clusters += num_new_clusters;
+-    BROTLI_DCHECK(num_clusters == cluster_size_size);
+-    BROTLI_DCHECK(num_clusters == all_histograms_size);
+-  }
+-  BROTLI_FREE(m, histograms);
+-
+-  max_num_pairs =
+-      BROTLI_MIN(size_t, 64 * num_clusters, (num_clusters / 2) * num_clusters);
+-  if (pairs_capacity < max_num_pairs + 1) {
+-    BROTLI_FREE(m, pairs);
+-    pairs = BROTLI_ALLOC(m, HistogramPair, max_num_pairs + 1);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(pairs)) return;
+-  }
+-
+-  clusters = BROTLI_ALLOC(m, uint32_t, num_clusters);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(clusters)) return;
+-  for (i = 0; i < num_clusters; ++i) {
+-    clusters[i] = (uint32_t)i;
+-  }
+-  num_final_clusters = FN(BrotliHistogramCombine)(
+-      all_histograms, cluster_size, histogram_symbols, clusters, pairs,
+-      num_clusters, num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES,
+-      max_num_pairs);
+-  BROTLI_FREE(m, pairs);
+-  BROTLI_FREE(m, cluster_size);
+-
+-  new_index = BROTLI_ALLOC(m, uint32_t, num_clusters);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return;
+-  for (i = 0; i < num_clusters; ++i) new_index[i] = kInvalidIndex;
+-  pos = 0;
+-  {
+-    uint32_t next_index = 0;
+-    for (i = 0; i < num_blocks; ++i) {
+-      HistogramType histo;
+-      size_t j;
+-      uint32_t best_out;
+-      double best_bits;
+-      FN(HistogramClear)(&histo);
+-      for (j = 0; j < block_lengths[i]; ++j) {
+-        FN(HistogramAdd)(&histo, data[pos++]);
+-      }
+-      best_out = (i == 0) ? histogram_symbols[0] : histogram_symbols[i - 1];
+-      best_bits =
+-          FN(BrotliHistogramBitCostDistance)(&histo, &all_histograms[best_out]);
+-      for (j = 0; j < num_final_clusters; ++j) {
+-        const double cur_bits = FN(BrotliHistogramBitCostDistance)(
+-            &histo, &all_histograms[clusters[j]]);
+-        if (cur_bits < best_bits) {
+-          best_bits = cur_bits;
+-          best_out = clusters[j];
+-        }
+-      }
+-      histogram_symbols[i] = best_out;
+-      if (new_index[best_out] == kInvalidIndex) {
+-        new_index[best_out] = next_index++;
+-      }
+-    }
+-  }
+-  BROTLI_FREE(m, clusters);
+-  BROTLI_FREE(m, all_histograms);
+-  BROTLI_ENSURE_CAPACITY(
+-      m, uint8_t, split->types, split->types_alloc_size, num_blocks);
+-  BROTLI_ENSURE_CAPACITY(
+-      m, uint32_t, split->lengths, split->lengths_alloc_size, num_blocks);
+-  if (BROTLI_IS_OOM(m)) return;
+-  {
+-    uint32_t cur_length = 0;
+-    size_t block_idx = 0;
+-    uint8_t max_type = 0;
+-    for (i = 0; i < num_blocks; ++i) {
+-      cur_length += block_lengths[i];
+-      if (i + 1 == num_blocks ||
+-          histogram_symbols[i] != histogram_symbols[i + 1]) {
+-        const uint8_t id = (uint8_t)new_index[histogram_symbols[i]];
+-        split->types[block_idx] = id;
+-        split->lengths[block_idx] = cur_length;
+-        max_type = BROTLI_MAX(uint8_t, max_type, id);
+-        cur_length = 0;
+-        ++block_idx;
+-      }
+-    }
+-    split->num_blocks = block_idx;
+-    split->num_types = (size_t)max_type + 1;
+-  }
+-  BROTLI_FREE(m, new_index);
+-  BROTLI_FREE(m, block_lengths);
+-  BROTLI_FREE(m, histogram_symbols);
+-}
+-
+-static void FN(SplitByteVector)(MemoryManager* m,
+-                                const DataType* data, const size_t length,
+-                                const size_t literals_per_histogram,
+-                                const size_t max_histograms,
+-                                const size_t sampling_stride_length,
+-                                const double block_switch_cost,
+-                                const BrotliEncoderParams* params,
+-                                BlockSplit* split) {
+-  const size_t data_size = FN(HistogramDataSize)();
+-  size_t num_histograms = length / literals_per_histogram + 1;
+-  HistogramType* histograms;
+-  if (num_histograms > max_histograms) {
+-    num_histograms = max_histograms;
+-  }
+-  if (length == 0) {
+-    split->num_types = 1;
+-    return;
+-  } else if (length < kMinLengthForBlockSplitting) {
+-    BROTLI_ENSURE_CAPACITY(m, uint8_t,
+-        split->types, split->types_alloc_size, split->num_blocks + 1);
+-    BROTLI_ENSURE_CAPACITY(m, uint32_t,
+-        split->lengths, split->lengths_alloc_size, split->num_blocks + 1);
+-    if (BROTLI_IS_OOM(m)) return;
+-    split->num_types = 1;
+-    split->types[split->num_blocks] = 0;
+-    split->lengths[split->num_blocks] = (uint32_t)length;
+-    split->num_blocks++;
+-    return;
+-  }
+-  histograms = BROTLI_ALLOC(m, HistogramType, num_histograms);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(histograms)) return;
+-  /* Find good entropy codes. */
+-  FN(InitialEntropyCodes)(data, length,
+-                          sampling_stride_length,
+-                          num_histograms, histograms);
+-  FN(RefineEntropyCodes)(data, length,
+-                         sampling_stride_length,
+-                         num_histograms, histograms);
+-  {
+-    /* Find a good path through literals with the good entropy codes. */
+-    uint8_t* block_ids = BROTLI_ALLOC(m, uint8_t, length);
+-    size_t num_blocks = 0;
+-    const size_t bitmaplen = (num_histograms + 7) >> 3;
+-    double* insert_cost = BROTLI_ALLOC(m, double, data_size * num_histograms);
+-    double* cost = BROTLI_ALLOC(m, double, num_histograms);
+-    uint8_t* switch_signal = BROTLI_ALLOC(m, uint8_t, length * bitmaplen);
+-    uint16_t* new_id = BROTLI_ALLOC(m, uint16_t, num_histograms);
+-    const size_t iters = params->quality < HQ_ZOPFLIFICATION_QUALITY ? 3 : 10;
+-    size_t i;
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(block_ids) ||
+-        BROTLI_IS_NULL(insert_cost) || BROTLI_IS_NULL(cost) ||
+-        BROTLI_IS_NULL(switch_signal) || BROTLI_IS_NULL(new_id)) {
+-      return;
+-    }
+-    for (i = 0; i < iters; ++i) {
+-      num_blocks = FN(FindBlocks)(data, length,
+-                                  block_switch_cost,
+-                                  num_histograms, histograms,
+-                                  insert_cost, cost, switch_signal,
+-                                  block_ids);
+-      num_histograms = FN(RemapBlockIds)(block_ids, length,
+-                                         new_id, num_histograms);
+-      FN(BuildBlockHistograms)(data, length, block_ids,
+-                               num_histograms, histograms);
+-    }
+-    BROTLI_FREE(m, insert_cost);
+-    BROTLI_FREE(m, cost);
+-    BROTLI_FREE(m, switch_signal);
+-    BROTLI_FREE(m, new_id);
+-    BROTLI_FREE(m, histograms);
+-    FN(ClusterBlocks)(m, data, length, num_blocks, block_ids, split);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BROTLI_FREE(m, block_ids);
+-  }
+-}
+-
+-#undef HistogramType
+diff --git a/modules/brotli/enc/brotli_bit_stream.c b/modules/brotli/enc/brotli_bit_stream.c
+deleted file mode 100644
+--- a/modules/brotli/enc/brotli_bit_stream.c
++++ /dev/null
+@@ -1,1314 +0,0 @@
+-/* Copyright 2014 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Brotli bit stream functions to support the low level format. There are no
+-   compression algorithms here, just the right ordering of bits to match the
+-   specs. */
+-
+-#include "./brotli_bit_stream.h"
+-
+-#include <string.h>  /* memcpy, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./entropy_encode.h"
+-#include "./entropy_encode_static.h"
+-#include "./fast_log.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-#include "./write_bits.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define MAX_HUFFMAN_TREE_SIZE (2 * BROTLI_NUM_COMMAND_SYMBOLS + 1)
+-/* The maximum size of Huffman dictionary for distances assuming that
+-   NPOSTFIX = 0 and NDIRECT = 0. */
+-#define MAX_SIMPLE_DISTANCE_ALPHABET_SIZE \
+-  BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_LARGE_MAX_DISTANCE_BITS)
+-/* MAX_SIMPLE_DISTANCE_ALPHABET_SIZE == 140 */
+-
+-static BROTLI_INLINE uint32_t BlockLengthPrefixCode(uint32_t len) {
+-  uint32_t code = (len >= 177) ? (len >= 753 ? 20 : 14) : (len >= 41 ? 7 : 0);
+-  while (code < (BROTLI_NUM_BLOCK_LEN_SYMBOLS - 1) &&
+-      len >= _kBrotliPrefixCodeRanges[code + 1].offset) ++code;
+-  return code;
+-}
+-
+-static BROTLI_INLINE void GetBlockLengthPrefixCode(uint32_t len, size_t* code,
+-    uint32_t* n_extra, uint32_t* extra) {
+-  *code = BlockLengthPrefixCode(len);
+-  *n_extra = _kBrotliPrefixCodeRanges[*code].nbits;
+-  *extra = len - _kBrotliPrefixCodeRanges[*code].offset;
+-}
+-
+-typedef struct BlockTypeCodeCalculator {
+-  size_t last_type;
+-  size_t second_last_type;
+-} BlockTypeCodeCalculator;
+-
+-static void InitBlockTypeCodeCalculator(BlockTypeCodeCalculator* self) {
+-  self->last_type = 1;
+-  self->second_last_type = 0;
+-}
+-
+-static BROTLI_INLINE size_t NextBlockTypeCode(
+-    BlockTypeCodeCalculator* calculator, uint8_t type) {
+-  size_t type_code = (type == calculator->last_type + 1) ? 1u :
+-      (type == calculator->second_last_type) ? 0u : type + 2u;
+-  calculator->second_last_type = calculator->last_type;
+-  calculator->last_type = type;
+-  return type_code;
+-}
+-
+-/* |nibblesbits| represents the 2 bits to encode MNIBBLES (0-3)
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-static void BrotliEncodeMlen(size_t length, uint64_t* bits,
+-                             size_t* numbits, uint64_t* nibblesbits) {
+-  size_t lg = (length == 1) ? 1 : Log2FloorNonZero((uint32_t)(length - 1)) + 1;
+-  size_t mnibbles = (lg < 16 ? 16 : (lg + 3)) / 4;
+-  BROTLI_DCHECK(length > 0);
+-  BROTLI_DCHECK(length <= (1 << 24));
+-  BROTLI_DCHECK(lg <= 24);
+-  *nibblesbits = mnibbles - 4;
+-  *numbits = mnibbles * 4;
+-  *bits = length - 1;
+-}
+-
+-static BROTLI_INLINE void StoreCommandExtra(
+-    const Command* cmd, size_t* storage_ix, uint8_t* storage) {
+-  uint32_t copylen_code = CommandCopyLenCode(cmd);
+-  uint16_t inscode = GetInsertLengthCode(cmd->insert_len_);
+-  uint16_t copycode = GetCopyLengthCode(copylen_code);
+-  uint32_t insnumextra = GetInsertExtra(inscode);
+-  uint64_t insextraval = cmd->insert_len_ - GetInsertBase(inscode);
+-  uint64_t copyextraval = copylen_code - GetCopyBase(copycode);
+-  uint64_t bits = (copyextraval << insnumextra) | insextraval;
+-  BrotliWriteBits(
+-      insnumextra + GetCopyExtra(copycode), bits, storage_ix, storage);
+-}
+-
+-/* Data structure that stores almost everything that is needed to encode each
+-   block switch command. */
+-typedef struct BlockSplitCode {
+-  BlockTypeCodeCalculator type_code_calculator;
+-  uint8_t type_depths[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
+-  uint16_t type_bits[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
+-  uint8_t length_depths[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
+-  uint16_t length_bits[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
+-} BlockSplitCode;
+-
+-/* Stores a number between 0 and 255. */
+-static void StoreVarLenUint8(size_t n, size_t* storage_ix, uint8_t* storage) {
+-  if (n == 0) {
+-    BrotliWriteBits(1, 0, storage_ix, storage);
+-  } else {
+-    size_t nbits = Log2FloorNonZero(n);
+-    BrotliWriteBits(1, 1, storage_ix, storage);
+-    BrotliWriteBits(3, nbits, storage_ix, storage);
+-    BrotliWriteBits(nbits, n - ((size_t)1 << nbits), storage_ix, storage);
+-  }
+-}
+-
+-/* Stores the compressed meta-block header.
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-static void StoreCompressedMetaBlockHeader(BROTLI_BOOL is_final_block,
+-                                           size_t length,
+-                                           size_t* storage_ix,
+-                                           uint8_t* storage) {
+-  uint64_t lenbits;
+-  size_t nlenbits;
+-  uint64_t nibblesbits;
+-
+-  /* Write ISLAST bit. */
+-  BrotliWriteBits(1, (uint64_t)is_final_block, storage_ix, storage);
+-  /* Write ISEMPTY bit. */
+-  if (is_final_block) {
+-    BrotliWriteBits(1, 0, storage_ix, storage);
+-  }
+-
+-  BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits);
+-  BrotliWriteBits(2, nibblesbits, storage_ix, storage);
+-  BrotliWriteBits(nlenbits, lenbits, storage_ix, storage);
+-
+-  if (!is_final_block) {
+-    /* Write ISUNCOMPRESSED bit. */
+-    BrotliWriteBits(1, 0, storage_ix, storage);
+-  }
+-}
+-
+-/* Stores the uncompressed meta-block header.
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-static void BrotliStoreUncompressedMetaBlockHeader(size_t length,
+-                                                   size_t* storage_ix,
+-                                                   uint8_t* storage) {
+-  uint64_t lenbits;
+-  size_t nlenbits;
+-  uint64_t nibblesbits;
+-
+-  /* Write ISLAST bit.
+-     Uncompressed block cannot be the last one, so set to 0. */
+-  BrotliWriteBits(1, 0, storage_ix, storage);
+-  BrotliEncodeMlen(length, &lenbits, &nlenbits, &nibblesbits);
+-  BrotliWriteBits(2, nibblesbits, storage_ix, storage);
+-  BrotliWriteBits(nlenbits, lenbits, storage_ix, storage);
+-  /* Write ISUNCOMPRESSED bit. */
+-  BrotliWriteBits(1, 1, storage_ix, storage);
+-}
+-
+-static void BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(
+-    const int num_codes, const uint8_t* code_length_bitdepth,
+-    size_t* storage_ix, uint8_t* storage) {
+-  static const uint8_t kStorageOrder[BROTLI_CODE_LENGTH_CODES] = {
+-    1, 2, 3, 4, 0, 5, 17, 6, 16, 7, 8, 9, 10, 11, 12, 13, 14, 15
+-  };
+-  /* The bit lengths of the Huffman code over the code length alphabet
+-     are compressed with the following static Huffman code:
+-       Symbol   Code
+-       ------   ----
+-       0          00
+-       1        1110
+-       2         110
+-       3          01
+-       4          10
+-       5        1111 */
+-  static const uint8_t kHuffmanBitLengthHuffmanCodeSymbols[6] = {
+-     0, 7, 3, 2, 1, 15
+-  };
+-  static const uint8_t kHuffmanBitLengthHuffmanCodeBitLengths[6] = {
+-    2, 4, 3, 2, 2, 4
+-  };
+-
+-  size_t skip_some = 0;  /* skips none. */
+-
+-  /* Throw away trailing zeros: */
+-  size_t codes_to_store = BROTLI_CODE_LENGTH_CODES;
+-  if (num_codes > 1) {
+-    for (; codes_to_store > 0; --codes_to_store) {
+-      if (code_length_bitdepth[kStorageOrder[codes_to_store - 1]] != 0) {
+-        break;
+-      }
+-    }
+-  }
+-  if (code_length_bitdepth[kStorageOrder[0]] == 0 &&
+-      code_length_bitdepth[kStorageOrder[1]] == 0) {
+-    skip_some = 2;  /* skips two. */
+-    if (code_length_bitdepth[kStorageOrder[2]] == 0) {
+-      skip_some = 3;  /* skips three. */
+-    }
+-  }
+-  BrotliWriteBits(2, skip_some, storage_ix, storage);
+-  {
+-    size_t i;
+-    for (i = skip_some; i < codes_to_store; ++i) {
+-      size_t l = code_length_bitdepth[kStorageOrder[i]];
+-      BrotliWriteBits(kHuffmanBitLengthHuffmanCodeBitLengths[l],
+-          kHuffmanBitLengthHuffmanCodeSymbols[l], storage_ix, storage);
+-    }
+-  }
+-}
+-
+-static void BrotliStoreHuffmanTreeToBitMask(
+-    const size_t huffman_tree_size, const uint8_t* huffman_tree,
+-    const uint8_t* huffman_tree_extra_bits, const uint8_t* code_length_bitdepth,
+-    const uint16_t* code_length_bitdepth_symbols,
+-    size_t* BROTLI_RESTRICT storage_ix, uint8_t* BROTLI_RESTRICT storage) {
+-  size_t i;
+-  for (i = 0; i < huffman_tree_size; ++i) {
+-    size_t ix = huffman_tree[i];
+-    BrotliWriteBits(code_length_bitdepth[ix], code_length_bitdepth_symbols[ix],
+-                    storage_ix, storage);
+-    /* Extra bits */
+-    switch (ix) {
+-      case BROTLI_REPEAT_PREVIOUS_CODE_LENGTH:
+-        BrotliWriteBits(2, huffman_tree_extra_bits[i], storage_ix, storage);
+-        break;
+-      case BROTLI_REPEAT_ZERO_CODE_LENGTH:
+-        BrotliWriteBits(3, huffman_tree_extra_bits[i], storage_ix, storage);
+-        break;
+-    }
+-  }
+-}
+-
+-static void StoreSimpleHuffmanTree(const uint8_t* depths,
+-                                   size_t symbols[4],
+-                                   size_t num_symbols,
+-                                   size_t max_bits,
+-                                   size_t* storage_ix, uint8_t* storage) {
+-  /* value of 1 indicates a simple Huffman code */
+-  BrotliWriteBits(2, 1, storage_ix, storage);
+-  BrotliWriteBits(2, num_symbols - 1, storage_ix, storage);  /* NSYM - 1 */
+-
+-  {
+-    /* Sort */
+-    size_t i;
+-    for (i = 0; i < num_symbols; i++) {
+-      size_t j;
+-      for (j = i + 1; j < num_symbols; j++) {
+-        if (depths[symbols[j]] < depths[symbols[i]]) {
+-          BROTLI_SWAP(size_t, symbols, j, i);
+-        }
+-      }
+-    }
+-  }
+-
+-  if (num_symbols == 2) {
+-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-  } else if (num_symbols == 3) {
+-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
+-  } else {
+-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[3], storage_ix, storage);
+-    /* tree-select */
+-    BrotliWriteBits(1, depths[symbols[0]] == 1 ? 1 : 0, storage_ix, storage);
+-  }
+-}
+-
+-/* num = alphabet size
+-   depths = symbol depths */
+-void BrotliStoreHuffmanTree(const uint8_t* depths, size_t num,
+-                            HuffmanTree* tree,
+-                            size_t* storage_ix, uint8_t* storage) {
+-  /* Write the Huffman tree into the brotli-representation.
+-     The command alphabet is the largest, so this allocation will fit all
+-     alphabets. */
+-  uint8_t huffman_tree[BROTLI_NUM_COMMAND_SYMBOLS];
+-  uint8_t huffman_tree_extra_bits[BROTLI_NUM_COMMAND_SYMBOLS];
+-  size_t huffman_tree_size = 0;
+-  uint8_t code_length_bitdepth[BROTLI_CODE_LENGTH_CODES] = { 0 };
+-  uint16_t code_length_bitdepth_symbols[BROTLI_CODE_LENGTH_CODES];
+-  uint32_t huffman_tree_histogram[BROTLI_CODE_LENGTH_CODES] = { 0 };
+-  size_t i;
+-  int num_codes = 0;
+-  size_t code = 0;
+-
+-  BROTLI_DCHECK(num <= BROTLI_NUM_COMMAND_SYMBOLS);
+-
+-  BrotliWriteHuffmanTree(depths, num, &huffman_tree_size, huffman_tree,
+-                         huffman_tree_extra_bits);
+-
+-  /* Calculate the statistics of the Huffman tree in brotli-representation. */
+-  for (i = 0; i < huffman_tree_size; ++i) {
+-    ++huffman_tree_histogram[huffman_tree[i]];
+-  }
+-
+-  for (i = 0; i < BROTLI_CODE_LENGTH_CODES; ++i) {
+-    if (huffman_tree_histogram[i]) {
+-      if (num_codes == 0) {
+-        code = i;
+-        num_codes = 1;
+-      } else if (num_codes == 1) {
+-        num_codes = 2;
+-        break;
+-      }
+-    }
+-  }
+-
+-  /* Calculate another Huffman tree to use for compressing both the
+-     earlier Huffman tree with. */
+-  BrotliCreateHuffmanTree(huffman_tree_histogram, BROTLI_CODE_LENGTH_CODES,
+-                          5, tree, code_length_bitdepth);
+-  BrotliConvertBitDepthsToSymbols(code_length_bitdepth,
+-                                  BROTLI_CODE_LENGTH_CODES,
+-                                  code_length_bitdepth_symbols);
+-
+-  /* Now, we have all the data, let's start storing it */
+-  BrotliStoreHuffmanTreeOfHuffmanTreeToBitMask(num_codes, code_length_bitdepth,
+-                                               storage_ix, storage);
+-
+-  if (num_codes == 1) {
+-    code_length_bitdepth[code] = 0;
+-  }
+-
+-  /* Store the real Huffman tree now. */
+-  BrotliStoreHuffmanTreeToBitMask(huffman_tree_size,
+-                                  huffman_tree,
+-                                  huffman_tree_extra_bits,
+-                                  code_length_bitdepth,
+-                                  code_length_bitdepth_symbols,
+-                                  storage_ix, storage);
+-}
+-
+-/* Builds a Huffman tree from histogram[0:length] into depth[0:length] and
+-   bits[0:length] and stores the encoded tree to the bit stream. */
+-static void BuildAndStoreHuffmanTree(const uint32_t* histogram,
+-                                     const size_t histogram_length,
+-                                     const size_t alphabet_size,
+-                                     HuffmanTree* tree,
+-                                     uint8_t* depth,
+-                                     uint16_t* bits,
+-                                     size_t* storage_ix,
+-                                     uint8_t* storage) {
+-  size_t count = 0;
+-  size_t s4[4] = { 0 };
+-  size_t i;
+-  size_t max_bits = 0;
+-  for (i = 0; i < histogram_length; i++) {
+-    if (histogram[i]) {
+-      if (count < 4) {
+-        s4[count] = i;
+-      } else if (count > 4) {
+-        break;
+-      }
+-      count++;
+-    }
+-  }
+-
+-  {
+-    size_t max_bits_counter = alphabet_size - 1;
+-    while (max_bits_counter) {
+-      max_bits_counter >>= 1;
+-      ++max_bits;
+-    }
+-  }
+-
+-  if (count <= 1) {
+-    BrotliWriteBits(4, 1, storage_ix, storage);
+-    BrotliWriteBits(max_bits, s4[0], storage_ix, storage);
+-    depth[s4[0]] = 0;
+-    bits[s4[0]] = 0;
+-    return;
+-  }
+-
+-  memset(depth, 0, histogram_length * sizeof(depth[0]));
+-  BrotliCreateHuffmanTree(histogram, histogram_length, 15, tree, depth);
+-  BrotliConvertBitDepthsToSymbols(depth, histogram_length, bits);
+-
+-  if (count <= 4) {
+-    StoreSimpleHuffmanTree(depth, s4, count, max_bits, storage_ix, storage);
+-  } else {
+-    BrotliStoreHuffmanTree(depth, histogram_length, tree, storage_ix, storage);
+-  }
+-}
+-
+-static BROTLI_INLINE BROTLI_BOOL SortHuffmanTree(
+-    const HuffmanTree* v0, const HuffmanTree* v1) {
+-  return TO_BROTLI_BOOL(v0->total_count_ < v1->total_count_);
+-}
+-
+-void BrotliBuildAndStoreHuffmanTreeFast(MemoryManager* m,
+-                                        const uint32_t* histogram,
+-                                        const size_t histogram_total,
+-                                        const size_t max_bits,
+-                                        uint8_t* depth, uint16_t* bits,
+-                                        size_t* storage_ix,
+-                                        uint8_t* storage) {
+-  size_t count = 0;
+-  size_t symbols[4] = { 0 };
+-  size_t length = 0;
+-  size_t total = histogram_total;
+-  while (total != 0) {
+-    if (histogram[length]) {
+-      if (count < 4) {
+-        symbols[count] = length;
+-      }
+-      ++count;
+-      total -= histogram[length];
+-    }
+-    ++length;
+-  }
+-
+-  if (count <= 1) {
+-    BrotliWriteBits(4, 1, storage_ix, storage);
+-    BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-    depth[symbols[0]] = 0;
+-    bits[symbols[0]] = 0;
+-    return;
+-  }
+-
+-  memset(depth, 0, length * sizeof(depth[0]));
+-  {
+-    const size_t max_tree_size = 2 * length + 1;
+-    HuffmanTree* tree = BROTLI_ALLOC(m, HuffmanTree, max_tree_size);
+-    uint32_t count_limit;
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tree)) return;
+-    for (count_limit = 1; ; count_limit *= 2) {
+-      HuffmanTree* node = tree;
+-      size_t l;
+-      for (l = length; l != 0;) {
+-        --l;
+-        if (histogram[l]) {
+-          if (BROTLI_PREDICT_TRUE(histogram[l] >= count_limit)) {
+-            InitHuffmanTree(node, histogram[l], -1, (int16_t)l);
+-          } else {
+-            InitHuffmanTree(node, count_limit, -1, (int16_t)l);
+-          }
+-          ++node;
+-        }
+-      }
+-      {
+-        const int n = (int)(node - tree);
+-        HuffmanTree sentinel;
+-        int i = 0;      /* Points to the next leaf node. */
+-        int j = n + 1;  /* Points to the next non-leaf node. */
+-        int k;
+-
+-        SortHuffmanTreeItems(tree, (size_t)n, SortHuffmanTree);
+-        /* The nodes are:
+-           [0, n): the sorted leaf nodes that we start with.
+-           [n]: we add a sentinel here.
+-           [n + 1, 2n): new parent nodes are added here, starting from
+-                        (n+1). These are naturally in ascending order.
+-           [2n]: we add a sentinel at the end as well.
+-           There will be (2n+1) elements at the end. */
+-        InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1);
+-        *node++ = sentinel;
+-        *node++ = sentinel;
+-
+-        for (k = n - 1; k > 0; --k) {
+-          int left, right;
+-          if (tree[i].total_count_ <= tree[j].total_count_) {
+-            left = i;
+-            ++i;
+-          } else {
+-            left = j;
+-            ++j;
+-          }
+-          if (tree[i].total_count_ <= tree[j].total_count_) {
+-            right = i;
+-            ++i;
+-          } else {
+-            right = j;
+-            ++j;
+-          }
+-          /* The sentinel node becomes the parent node. */
+-          node[-1].total_count_ =
+-              tree[left].total_count_ + tree[right].total_count_;
+-          node[-1].index_left_ = (int16_t)left;
+-          node[-1].index_right_or_value_ = (int16_t)right;
+-          /* Add back the last sentinel node. */
+-          *node++ = sentinel;
+-        }
+-        if (BrotliSetDepth(2 * n - 1, tree, depth, 14)) {
+-          /* We need to pack the Huffman tree in 14 bits. If this was not
+-             successful, add fake entities to the lowest values and retry. */
+-          break;
+-        }
+-      }
+-    }
+-    BROTLI_FREE(m, tree);
+-  }
+-  BrotliConvertBitDepthsToSymbols(depth, length, bits);
+-  if (count <= 4) {
+-    size_t i;
+-    /* value of 1 indicates a simple Huffman code */
+-    BrotliWriteBits(2, 1, storage_ix, storage);
+-    BrotliWriteBits(2, count - 1, storage_ix, storage);  /* NSYM - 1 */
+-
+-    /* Sort */
+-    for (i = 0; i < count; i++) {
+-      size_t j;
+-      for (j = i + 1; j < count; j++) {
+-        if (depth[symbols[j]] < depth[symbols[i]]) {
+-          BROTLI_SWAP(size_t, symbols, j, i);
+-        }
+-      }
+-    }
+-
+-    if (count == 2) {
+-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-    } else if (count == 3) {
+-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
+-    } else {
+-      BrotliWriteBits(max_bits, symbols[0], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[1], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[2], storage_ix, storage);
+-      BrotliWriteBits(max_bits, symbols[3], storage_ix, storage);
+-      /* tree-select */
+-      BrotliWriteBits(1, depth[symbols[0]] == 1 ? 1 : 0, storage_ix, storage);
+-    }
+-  } else {
+-    uint8_t previous_value = 8;
+-    size_t i;
+-    /* Complex Huffman Tree */
+-    StoreStaticCodeLengthCode(storage_ix, storage);
+-
+-    /* Actual RLE coding. */
+-    for (i = 0; i < length;) {
+-      const uint8_t value = depth[i];
+-      size_t reps = 1;
+-      size_t k;
+-      for (k = i + 1; k < length && depth[k] == value; ++k) {
+-        ++reps;
+-      }
+-      i += reps;
+-      if (value == 0) {
+-        BrotliWriteBits(kZeroRepsDepth[reps], kZeroRepsBits[reps],
+-                        storage_ix, storage);
+-      } else {
+-        if (previous_value != value) {
+-          BrotliWriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
+-                          storage_ix, storage);
+-          --reps;
+-        }
+-        if (reps < 3) {
+-          while (reps != 0) {
+-            reps--;
+-            BrotliWriteBits(kCodeLengthDepth[value], kCodeLengthBits[value],
+-                            storage_ix, storage);
+-          }
+-        } else {
+-          reps -= 3;
+-          BrotliWriteBits(kNonZeroRepsDepth[reps], kNonZeroRepsBits[reps],
+-                          storage_ix, storage);
+-        }
+-        previous_value = value;
+-      }
+-    }
+-  }
+-}
+-
+-static size_t IndexOf(const uint8_t* v, size_t v_size, uint8_t value) {
+-  size_t i = 0;
+-  for (; i < v_size; ++i) {
+-    if (v[i] == value) return i;
+-  }
+-  return i;
+-}
+-
+-static void MoveToFront(uint8_t* v, size_t index) {
+-  uint8_t value = v[index];
+-  size_t i;
+-  for (i = index; i != 0; --i) {
+-    v[i] = v[i - 1];
+-  }
+-  v[0] = value;
+-}
+-
+-static void MoveToFrontTransform(const uint32_t* BROTLI_RESTRICT v_in,
+-                                 const size_t v_size,
+-                                 uint32_t* v_out) {
+-  size_t i;
+-  uint8_t mtf[256];
+-  uint32_t max_value;
+-  if (v_size == 0) {
+-    return;
+-  }
+-  max_value = v_in[0];
+-  for (i = 1; i < v_size; ++i) {
+-    if (v_in[i] > max_value) max_value = v_in[i];
+-  }
+-  BROTLI_DCHECK(max_value < 256u);
+-  for (i = 0; i <= max_value; ++i) {
+-    mtf[i] = (uint8_t)i;
+-  }
+-  {
+-    size_t mtf_size = max_value + 1;
+-    for (i = 0; i < v_size; ++i) {
+-      size_t index = IndexOf(mtf, mtf_size, (uint8_t)v_in[i]);
+-      BROTLI_DCHECK(index < mtf_size);
+-      v_out[i] = (uint32_t)index;
+-      MoveToFront(mtf, index);
+-    }
+-  }
+-}
+-
+-/* Finds runs of zeros in v[0..in_size) and replaces them with a prefix code of
+-   the run length plus extra bits (lower 9 bits is the prefix code and the rest
+-   are the extra bits). Non-zero values in v[] are shifted by
+-   *max_length_prefix. Will not create prefix codes bigger than the initial
+-   value of *max_run_length_prefix. The prefix code of run length L is simply
+-   Log2Floor(L) and the number of extra bits is the same as the prefix code. */
+-static void RunLengthCodeZeros(const size_t in_size,
+-    uint32_t* BROTLI_RESTRICT v, size_t* BROTLI_RESTRICT out_size,
+-    uint32_t* BROTLI_RESTRICT max_run_length_prefix) {
+-  uint32_t max_reps = 0;
+-  size_t i;
+-  uint32_t max_prefix;
+-  for (i = 0; i < in_size;) {
+-    uint32_t reps = 0;
+-    for (; i < in_size && v[i] != 0; ++i) ;
+-    for (; i < in_size && v[i] == 0; ++i) {
+-      ++reps;
+-    }
+-    max_reps = BROTLI_MAX(uint32_t, reps, max_reps);
+-  }
+-  max_prefix = max_reps > 0 ? Log2FloorNonZero(max_reps) : 0;
+-  max_prefix = BROTLI_MIN(uint32_t, max_prefix, *max_run_length_prefix);
+-  *max_run_length_prefix = max_prefix;
+-  *out_size = 0;
+-  for (i = 0; i < in_size;) {
+-    BROTLI_DCHECK(*out_size <= i);
+-    if (v[i] != 0) {
+-      v[*out_size] = v[i] + *max_run_length_prefix;
+-      ++i;
+-      ++(*out_size);
+-    } else {
+-      uint32_t reps = 1;
+-      size_t k;
+-      for (k = i + 1; k < in_size && v[k] == 0; ++k) {
+-        ++reps;
+-      }
+-      i += reps;
+-      while (reps != 0) {
+-        if (reps < (2u << max_prefix)) {
+-          uint32_t run_length_prefix = Log2FloorNonZero(reps);
+-          const uint32_t extra_bits = reps - (1u << run_length_prefix);
+-          v[*out_size] = run_length_prefix + (extra_bits << 9);
+-          ++(*out_size);
+-          break;
+-        } else {
+-          const uint32_t extra_bits = (1u << max_prefix) - 1u;
+-          v[*out_size] = max_prefix + (extra_bits << 9);
+-          reps -= (2u << max_prefix) - 1u;
+-          ++(*out_size);
+-        }
+-      }
+-    }
+-  }
+-}
+-
+-#define SYMBOL_BITS 9
+-
+-static void EncodeContextMap(MemoryManager* m,
+-                             const uint32_t* context_map,
+-                             size_t context_map_size,
+-                             size_t num_clusters,
+-                             HuffmanTree* tree,
+-                             size_t* storage_ix, uint8_t* storage) {
+-  size_t i;
+-  uint32_t* rle_symbols;
+-  uint32_t max_run_length_prefix = 6;
+-  size_t num_rle_symbols = 0;
+-  uint32_t histogram[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-  static const uint32_t kSymbolMask = (1u << SYMBOL_BITS) - 1u;
+-  uint8_t depths[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-  uint16_t bits[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-
+-  StoreVarLenUint8(num_clusters - 1, storage_ix, storage);
+-
+-  if (num_clusters == 1) {
+-    return;
+-  }
+-
+-  rle_symbols = BROTLI_ALLOC(m, uint32_t, context_map_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(rle_symbols)) return;
+-  MoveToFrontTransform(context_map, context_map_size, rle_symbols);
+-  RunLengthCodeZeros(context_map_size, rle_symbols,
+-                     &num_rle_symbols, &max_run_length_prefix);
+-  memset(histogram, 0, sizeof(histogram));
+-  for (i = 0; i < num_rle_symbols; ++i) {
+-    ++histogram[rle_symbols[i] & kSymbolMask];
+-  }
+-  {
+-    BROTLI_BOOL use_rle = TO_BROTLI_BOOL(max_run_length_prefix > 0);
+-    BrotliWriteBits(1, (uint64_t)use_rle, storage_ix, storage);
+-    if (use_rle) {
+-      BrotliWriteBits(4, max_run_length_prefix - 1, storage_ix, storage);
+-    }
+-  }
+-  BuildAndStoreHuffmanTree(histogram, num_clusters + max_run_length_prefix,
+-                           num_clusters + max_run_length_prefix,
+-                           tree, depths, bits, storage_ix, storage);
+-  for (i = 0; i < num_rle_symbols; ++i) {
+-    const uint32_t rle_symbol = rle_symbols[i] & kSymbolMask;
+-    const uint32_t extra_bits_val = rle_symbols[i] >> SYMBOL_BITS;
+-    BrotliWriteBits(depths[rle_symbol], bits[rle_symbol], storage_ix, storage);
+-    if (rle_symbol > 0 && rle_symbol <= max_run_length_prefix) {
+-      BrotliWriteBits(rle_symbol, extra_bits_val, storage_ix, storage);
+-    }
+-  }
+-  BrotliWriteBits(1, 1, storage_ix, storage);  /* use move-to-front */
+-  BROTLI_FREE(m, rle_symbols);
+-}
+-
+-/* Stores the block switch command with index block_ix to the bit stream. */
+-static BROTLI_INLINE void StoreBlockSwitch(BlockSplitCode* code,
+-                                           const uint32_t block_len,
+-                                           const uint8_t block_type,
+-                                           BROTLI_BOOL is_first_block,
+-                                           size_t* storage_ix,
+-                                           uint8_t* storage) {
+-  size_t typecode = NextBlockTypeCode(&code->type_code_calculator, block_type);
+-  size_t lencode;
+-  uint32_t len_nextra;
+-  uint32_t len_extra;
+-  if (!is_first_block) {
+-    BrotliWriteBits(code->type_depths[typecode], code->type_bits[typecode],
+-                    storage_ix, storage);
+-  }
+-  GetBlockLengthPrefixCode(block_len, &lencode, &len_nextra, &len_extra);
+-
+-  BrotliWriteBits(code->length_depths[lencode], code->length_bits[lencode],
+-                  storage_ix, storage);
+-  BrotliWriteBits(len_nextra, len_extra, storage_ix, storage);
+-}
+-
+-/* Builds a BlockSplitCode data structure from the block split given by the
+-   vector of block types and block lengths and stores it to the bit stream. */
+-static void BuildAndStoreBlockSplitCode(const uint8_t* types,
+-                                        const uint32_t* lengths,
+-                                        const size_t num_blocks,
+-                                        const size_t num_types,
+-                                        HuffmanTree* tree,
+-                                        BlockSplitCode* code,
+-                                        size_t* storage_ix,
+-                                        uint8_t* storage) {
+-  uint32_t type_histo[BROTLI_MAX_BLOCK_TYPE_SYMBOLS];
+-  uint32_t length_histo[BROTLI_NUM_BLOCK_LEN_SYMBOLS];
+-  size_t i;
+-  BlockTypeCodeCalculator type_code_calculator;
+-  memset(type_histo, 0, (num_types + 2) * sizeof(type_histo[0]));
+-  memset(length_histo, 0, sizeof(length_histo));
+-  InitBlockTypeCodeCalculator(&type_code_calculator);
+-  for (i = 0; i < num_blocks; ++i) {
+-    size_t type_code = NextBlockTypeCode(&type_code_calculator, types[i]);
+-    if (i != 0) ++type_histo[type_code];
+-    ++length_histo[BlockLengthPrefixCode(lengths[i])];
+-  }
+-  StoreVarLenUint8(num_types - 1, storage_ix, storage);
+-  if (num_types > 1) {  /* TODO: else? could StoreBlockSwitch occur? */
+-    BuildAndStoreHuffmanTree(&type_histo[0], num_types + 2, num_types + 2, tree,
+-                             &code->type_depths[0], &code->type_bits[0],
+-                             storage_ix, storage);
+-    BuildAndStoreHuffmanTree(&length_histo[0], BROTLI_NUM_BLOCK_LEN_SYMBOLS,
+-                             BROTLI_NUM_BLOCK_LEN_SYMBOLS,
+-                             tree, &code->length_depths[0],
+-                             &code->length_bits[0], storage_ix, storage);
+-    StoreBlockSwitch(code, lengths[0], types[0], 1, storage_ix, storage);
+-  }
+-}
+-
+-/* Stores a context map where the histogram type is always the block type. */
+-static void StoreTrivialContextMap(size_t num_types,
+-                                   size_t context_bits,
+-                                   HuffmanTree* tree,
+-                                   size_t* storage_ix,
+-                                   uint8_t* storage) {
+-  StoreVarLenUint8(num_types - 1, storage_ix, storage);
+-  if (num_types > 1) {
+-    size_t repeat_code = context_bits - 1u;
+-    size_t repeat_bits = (1u << repeat_code) - 1u;
+-    size_t alphabet_size = num_types + repeat_code;
+-    uint32_t histogram[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-    uint8_t depths[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-    uint16_t bits[BROTLI_MAX_CONTEXT_MAP_SYMBOLS];
+-    size_t i;
+-    memset(histogram, 0, alphabet_size * sizeof(histogram[0]));
+-    /* Write RLEMAX. */
+-    BrotliWriteBits(1, 1, storage_ix, storage);
+-    BrotliWriteBits(4, repeat_code - 1, storage_ix, storage);
+-    histogram[repeat_code] = (uint32_t)num_types;
+-    histogram[0] = 1;
+-    for (i = context_bits; i < alphabet_size; ++i) {
+-      histogram[i] = 1;
+-    }
+-    BuildAndStoreHuffmanTree(histogram, alphabet_size, alphabet_size,
+-                             tree, depths, bits, storage_ix, storage);
+-    for (i = 0; i < num_types; ++i) {
+-      size_t code = (i == 0 ? 0 : i + context_bits - 1);
+-      BrotliWriteBits(depths[code], bits[code], storage_ix, storage);
+-      BrotliWriteBits(
+-          depths[repeat_code], bits[repeat_code], storage_ix, storage);
+-      BrotliWriteBits(repeat_code, repeat_bits, storage_ix, storage);
+-    }
+-    /* Write IMTF (inverse-move-to-front) bit. */
+-    BrotliWriteBits(1, 1, storage_ix, storage);
+-  }
+-}
+-
+-/* Manages the encoding of one block category (literal, command or distance). */
+-typedef struct BlockEncoder {
+-  size_t histogram_length_;
+-  size_t num_block_types_;
+-  const uint8_t* block_types_;  /* Not owned. */
+-  const uint32_t* block_lengths_;  /* Not owned. */
+-  size_t num_blocks_;
+-  BlockSplitCode block_split_code_;
+-  size_t block_ix_;
+-  size_t block_len_;
+-  size_t entropy_ix_;
+-  uint8_t* depths_;
+-  uint16_t* bits_;
+-} BlockEncoder;
+-
+-static void InitBlockEncoder(BlockEncoder* self, size_t histogram_length,
+-    size_t num_block_types, const uint8_t* block_types,
+-    const uint32_t* block_lengths, const size_t num_blocks) {
+-  self->histogram_length_ = histogram_length;
+-  self->num_block_types_ = num_block_types;
+-  self->block_types_ = block_types;
+-  self->block_lengths_ = block_lengths;
+-  self->num_blocks_ = num_blocks;
+-  InitBlockTypeCodeCalculator(&self->block_split_code_.type_code_calculator);
+-  self->block_ix_ = 0;
+-  self->block_len_ = num_blocks == 0 ? 0 : block_lengths[0];
+-  self->entropy_ix_ = 0;
+-  self->depths_ = 0;
+-  self->bits_ = 0;
+-}
+-
+-static void CleanupBlockEncoder(MemoryManager* m, BlockEncoder* self) {
+-  BROTLI_FREE(m, self->depths_);
+-  BROTLI_FREE(m, self->bits_);
+-}
+-
+-/* Creates entropy codes of block lengths and block types and stores them
+-   to the bit stream. */
+-static void BuildAndStoreBlockSwitchEntropyCodes(BlockEncoder* self,
+-    HuffmanTree* tree, size_t* storage_ix, uint8_t* storage) {
+-  BuildAndStoreBlockSplitCode(self->block_types_, self->block_lengths_,
+-      self->num_blocks_, self->num_block_types_, tree, &self->block_split_code_,
+-      storage_ix, storage);
+-}
+-
+-/* Stores the next symbol with the entropy code of the current block type.
+-   Updates the block type and block length at block boundaries. */
+-static void StoreSymbol(BlockEncoder* self, size_t symbol, size_t* storage_ix,
+-    uint8_t* storage) {
+-  if (self->block_len_ == 0) {
+-    size_t block_ix = ++self->block_ix_;
+-    uint32_t block_len = self->block_lengths_[block_ix];
+-    uint8_t block_type = self->block_types_[block_ix];
+-    self->block_len_ = block_len;
+-    self->entropy_ix_ = block_type * self->histogram_length_;
+-    StoreBlockSwitch(&self->block_split_code_, block_len, block_type, 0,
+-        storage_ix, storage);
+-  }
+-  --self->block_len_;
+-  {
+-    size_t ix = self->entropy_ix_ + symbol;
+-    BrotliWriteBits(self->depths_[ix], self->bits_[ix], storage_ix, storage);
+-  }
+-}
+-
+-/* Stores the next symbol with the entropy code of the current block type and
+-   context value.
+-   Updates the block type and block length at block boundaries. */
+-static void StoreSymbolWithContext(BlockEncoder* self, size_t symbol,
+-    size_t context, const uint32_t* context_map, size_t* storage_ix,
+-    uint8_t* storage, const size_t context_bits) {
+-  if (self->block_len_ == 0) {
+-    size_t block_ix = ++self->block_ix_;
+-    uint32_t block_len = self->block_lengths_[block_ix];
+-    uint8_t block_type = self->block_types_[block_ix];
+-    self->block_len_ = block_len;
+-    self->entropy_ix_ = (size_t)block_type << context_bits;
+-    StoreBlockSwitch(&self->block_split_code_, block_len, block_type, 0,
+-        storage_ix, storage);
+-  }
+-  --self->block_len_;
+-  {
+-    size_t histo_ix = context_map[self->entropy_ix_ + context];
+-    size_t ix = histo_ix * self->histogram_length_ + symbol;
+-    BrotliWriteBits(self->depths_[ix], self->bits_[ix], storage_ix, storage);
+-  }
+-}
+-
+-#define FN(X) X ## Literal
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_encoder_inc.h"
+-#undef FN
+-
+-#define FN(X) X ## Command
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_encoder_inc.h"
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-/* NOLINTNEXTLINE(build/include) */
+-#include "./block_encoder_inc.h"
+-#undef FN
+-
+-static void JumpToByteBoundary(size_t* storage_ix, uint8_t* storage) {
+-  *storage_ix = (*storage_ix + 7u) & ~7u;
+-  storage[*storage_ix >> 3] = 0;
+-}
+-
+-void BrotliStoreMetaBlock(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    uint8_t prev_byte, uint8_t prev_byte2, BROTLI_BOOL is_last,
+-    const BrotliEncoderParams* params, ContextType literal_context_mode,
+-    const Command* commands, size_t n_commands, const MetaBlockSplit* mb,
+-    size_t* storage_ix, uint8_t* storage) {
+-
+-  size_t pos = start_pos;
+-  size_t i;
+-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
+-  uint32_t num_effective_distance_symbols = params->dist.alphabet_size_limit;
+-  HuffmanTree* tree;
+-  ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
+-  BlockEncoder literal_enc;
+-  BlockEncoder command_enc;
+-  BlockEncoder distance_enc;
+-  const BrotliDistanceParams* dist = &params->dist;
+-  BROTLI_DCHECK(
+-      num_effective_distance_symbols <= BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS);
+-
+-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
+-
+-  tree = BROTLI_ALLOC(m, HuffmanTree, MAX_HUFFMAN_TREE_SIZE);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tree)) return;
+-  InitBlockEncoder(&literal_enc, BROTLI_NUM_LITERAL_SYMBOLS,
+-      mb->literal_split.num_types, mb->literal_split.types,
+-      mb->literal_split.lengths, mb->literal_split.num_blocks);
+-  InitBlockEncoder(&command_enc, BROTLI_NUM_COMMAND_SYMBOLS,
+-      mb->command_split.num_types, mb->command_split.types,
+-      mb->command_split.lengths, mb->command_split.num_blocks);
+-  InitBlockEncoder(&distance_enc, num_effective_distance_symbols,
+-      mb->distance_split.num_types, mb->distance_split.types,
+-      mb->distance_split.lengths, mb->distance_split.num_blocks);
+-
+-  BuildAndStoreBlockSwitchEntropyCodes(&literal_enc, tree, storage_ix, storage);
+-  BuildAndStoreBlockSwitchEntropyCodes(&command_enc, tree, storage_ix, storage);
+-  BuildAndStoreBlockSwitchEntropyCodes(
+-      &distance_enc, tree, storage_ix, storage);
+-
+-  BrotliWriteBits(2, dist->distance_postfix_bits, storage_ix, storage);
+-  BrotliWriteBits(
+-      4, dist->num_direct_distance_codes >> dist->distance_postfix_bits,
+-      storage_ix, storage);
+-  for (i = 0; i < mb->literal_split.num_types; ++i) {
+-    BrotliWriteBits(2, literal_context_mode, storage_ix, storage);
+-  }
+-
+-  if (mb->literal_context_map_size == 0) {
+-    StoreTrivialContextMap(mb->literal_histograms_size,
+-        BROTLI_LITERAL_CONTEXT_BITS, tree, storage_ix, storage);
+-  } else {
+-    EncodeContextMap(m,
+-        mb->literal_context_map, mb->literal_context_map_size,
+-        mb->literal_histograms_size, tree, storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-  }
+-
+-  if (mb->distance_context_map_size == 0) {
+-    StoreTrivialContextMap(mb->distance_histograms_size,
+-        BROTLI_DISTANCE_CONTEXT_BITS, tree, storage_ix, storage);
+-  } else {
+-    EncodeContextMap(m,
+-        mb->distance_context_map, mb->distance_context_map_size,
+-        mb->distance_histograms_size, tree, storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-  }
+-
+-  BuildAndStoreEntropyCodesLiteral(m, &literal_enc, mb->literal_histograms,
+-      mb->literal_histograms_size, BROTLI_NUM_LITERAL_SYMBOLS, tree,
+-      storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BuildAndStoreEntropyCodesCommand(m, &command_enc, mb->command_histograms,
+-      mb->command_histograms_size, BROTLI_NUM_COMMAND_SYMBOLS, tree,
+-      storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BuildAndStoreEntropyCodesDistance(m, &distance_enc, mb->distance_histograms,
+-      mb->distance_histograms_size, num_distance_symbols, tree,
+-      storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BROTLI_FREE(m, tree);
+-
+-  for (i = 0; i < n_commands; ++i) {
+-    const Command cmd = commands[i];
+-    size_t cmd_code = cmd.cmd_prefix_;
+-    StoreSymbol(&command_enc, cmd_code, storage_ix, storage);
+-    StoreCommandExtra(&cmd, storage_ix, storage);
+-    if (mb->literal_context_map_size == 0) {
+-      size_t j;
+-      for (j = cmd.insert_len_; j != 0; --j) {
+-        StoreSymbol(&literal_enc, input[pos & mask], storage_ix, storage);
+-        ++pos;
+-      }
+-    } else {
+-      size_t j;
+-      for (j = cmd.insert_len_; j != 0; --j) {
+-        size_t context =
+-            BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut);
+-        uint8_t literal = input[pos & mask];
+-        StoreSymbolWithContext(&literal_enc, literal, context,
+-            mb->literal_context_map, storage_ix, storage,
+-            BROTLI_LITERAL_CONTEXT_BITS);
+-        prev_byte2 = prev_byte;
+-        prev_byte = literal;
+-        ++pos;
+-      }
+-    }
+-    pos += CommandCopyLen(&cmd);
+-    if (CommandCopyLen(&cmd)) {
+-      prev_byte2 = input[(pos - 2) & mask];
+-      prev_byte = input[(pos - 1) & mask];
+-      if (cmd.cmd_prefix_ >= 128) {
+-        size_t dist_code = cmd.dist_prefix_ & 0x3FF;
+-        uint32_t distnumextra = cmd.dist_prefix_ >> 10;
+-        uint64_t distextra = cmd.dist_extra_;
+-        if (mb->distance_context_map_size == 0) {
+-          StoreSymbol(&distance_enc, dist_code, storage_ix, storage);
+-        } else {
+-          size_t context = CommandDistanceContext(&cmd);
+-          StoreSymbolWithContext(&distance_enc, dist_code, context,
+-              mb->distance_context_map, storage_ix, storage,
+-              BROTLI_DISTANCE_CONTEXT_BITS);
+-        }
+-        BrotliWriteBits(distnumextra, distextra, storage_ix, storage);
+-      }
+-    }
+-  }
+-  CleanupBlockEncoder(m, &distance_enc);
+-  CleanupBlockEncoder(m, &command_enc);
+-  CleanupBlockEncoder(m, &literal_enc);
+-  if (is_last) {
+-    JumpToByteBoundary(storage_ix, storage);
+-  }
+-}
+-
+-static void BuildHistograms(const uint8_t* input,
+-                            size_t start_pos,
+-                            size_t mask,
+-                            const Command* commands,
+-                            size_t n_commands,
+-                            HistogramLiteral* lit_histo,
+-                            HistogramCommand* cmd_histo,
+-                            HistogramDistance* dist_histo) {
+-  size_t pos = start_pos;
+-  size_t i;
+-  for (i = 0; i < n_commands; ++i) {
+-    const Command cmd = commands[i];
+-    size_t j;
+-    HistogramAddCommand(cmd_histo, cmd.cmd_prefix_);
+-    for (j = cmd.insert_len_; j != 0; --j) {
+-      HistogramAddLiteral(lit_histo, input[pos & mask]);
+-      ++pos;
+-    }
+-    pos += CommandCopyLen(&cmd);
+-    if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {
+-      HistogramAddDistance(dist_histo, cmd.dist_prefix_ & 0x3FF);
+-    }
+-  }
+-}
+-
+-static void StoreDataWithHuffmanCodes(const uint8_t* input,
+-                                      size_t start_pos,
+-                                      size_t mask,
+-                                      const Command* commands,
+-                                      size_t n_commands,
+-                                      const uint8_t* lit_depth,
+-                                      const uint16_t* lit_bits,
+-                                      const uint8_t* cmd_depth,
+-                                      const uint16_t* cmd_bits,
+-                                      const uint8_t* dist_depth,
+-                                      const uint16_t* dist_bits,
+-                                      size_t* storage_ix,
+-                                      uint8_t* storage) {
+-  size_t pos = start_pos;
+-  size_t i;
+-  for (i = 0; i < n_commands; ++i) {
+-    const Command cmd = commands[i];
+-    const size_t cmd_code = cmd.cmd_prefix_;
+-    size_t j;
+-    BrotliWriteBits(
+-        cmd_depth[cmd_code], cmd_bits[cmd_code], storage_ix, storage);
+-    StoreCommandExtra(&cmd, storage_ix, storage);
+-    for (j = cmd.insert_len_; j != 0; --j) {
+-      const uint8_t literal = input[pos & mask];
+-      BrotliWriteBits(
+-          lit_depth[literal], lit_bits[literal], storage_ix, storage);
+-      ++pos;
+-    }
+-    pos += CommandCopyLen(&cmd);
+-    if (CommandCopyLen(&cmd) && cmd.cmd_prefix_ >= 128) {
+-      const size_t dist_code = cmd.dist_prefix_ & 0x3FF;
+-      const uint32_t distnumextra = cmd.dist_prefix_ >> 10;
+-      const uint32_t distextra = cmd.dist_extra_;
+-      BrotliWriteBits(dist_depth[dist_code], dist_bits[dist_code],
+-                      storage_ix, storage);
+-      BrotliWriteBits(distnumextra, distextra, storage_ix, storage);
+-    }
+-  }
+-}
+-
+-void BrotliStoreMetaBlockTrivial(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
+-    const Command* commands, size_t n_commands,
+-    size_t* storage_ix, uint8_t* storage) {
+-  HistogramLiteral lit_histo;
+-  HistogramCommand cmd_histo;
+-  HistogramDistance dist_histo;
+-  uint8_t lit_depth[BROTLI_NUM_LITERAL_SYMBOLS];
+-  uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];
+-  uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS];
+-  uint16_t cmd_bits[BROTLI_NUM_COMMAND_SYMBOLS];
+-  uint8_t dist_depth[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
+-  uint16_t dist_bits[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
+-  HuffmanTree* tree;
+-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
+-
+-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
+-
+-  HistogramClearLiteral(&lit_histo);
+-  HistogramClearCommand(&cmd_histo);
+-  HistogramClearDistance(&dist_histo);
+-
+-  BuildHistograms(input, start_pos, mask, commands, n_commands,
+-                  &lit_histo, &cmd_histo, &dist_histo);
+-
+-  BrotliWriteBits(13, 0, storage_ix, storage);
+-
+-  tree = BROTLI_ALLOC(m, HuffmanTree, MAX_HUFFMAN_TREE_SIZE);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tree)) return;
+-  BuildAndStoreHuffmanTree(lit_histo.data_, BROTLI_NUM_LITERAL_SYMBOLS,
+-                           BROTLI_NUM_LITERAL_SYMBOLS, tree,
+-                           lit_depth, lit_bits,
+-                           storage_ix, storage);
+-  BuildAndStoreHuffmanTree(cmd_histo.data_, BROTLI_NUM_COMMAND_SYMBOLS,
+-                           BROTLI_NUM_COMMAND_SYMBOLS, tree,
+-                           cmd_depth, cmd_bits,
+-                           storage_ix, storage);
+-  BuildAndStoreHuffmanTree(dist_histo.data_, MAX_SIMPLE_DISTANCE_ALPHABET_SIZE,
+-                           num_distance_symbols, tree,
+-                           dist_depth, dist_bits,
+-                           storage_ix, storage);
+-  BROTLI_FREE(m, tree);
+-  StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
+-                            n_commands, lit_depth, lit_bits,
+-                            cmd_depth, cmd_bits,
+-                            dist_depth, dist_bits,
+-                            storage_ix, storage);
+-  if (is_last) {
+-    JumpToByteBoundary(storage_ix, storage);
+-  }
+-}
+-
+-void BrotliStoreMetaBlockFast(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
+-    const Command* commands, size_t n_commands,
+-    size_t* storage_ix, uint8_t* storage) {
+-  uint32_t num_distance_symbols = params->dist.alphabet_size_max;
+-  uint32_t distance_alphabet_bits =
+-      Log2FloorNonZero(num_distance_symbols - 1) + 1;
+-
+-  StoreCompressedMetaBlockHeader(is_last, length, storage_ix, storage);
+-
+-  BrotliWriteBits(13, 0, storage_ix, storage);
+-
+-  if (n_commands <= 128) {
+-    uint32_t histogram[BROTLI_NUM_LITERAL_SYMBOLS] = { 0 };
+-    size_t pos = start_pos;
+-    size_t num_literals = 0;
+-    size_t i;
+-    uint8_t lit_depth[BROTLI_NUM_LITERAL_SYMBOLS];
+-    uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];
+-    for (i = 0; i < n_commands; ++i) {
+-      const Command cmd = commands[i];
+-      size_t j;
+-      for (j = cmd.insert_len_; j != 0; --j) {
+-        ++histogram[input[pos & mask]];
+-        ++pos;
+-      }
+-      num_literals += cmd.insert_len_;
+-      pos += CommandCopyLen(&cmd);
+-    }
+-    BrotliBuildAndStoreHuffmanTreeFast(m, histogram, num_literals,
+-                                       /* max_bits = */ 8,
+-                                       lit_depth, lit_bits,
+-                                       storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    StoreStaticCommandHuffmanTree(storage_ix, storage);
+-    StoreStaticDistanceHuffmanTree(storage_ix, storage);
+-    StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
+-                              n_commands, lit_depth, lit_bits,
+-                              kStaticCommandCodeDepth,
+-                              kStaticCommandCodeBits,
+-                              kStaticDistanceCodeDepth,
+-                              kStaticDistanceCodeBits,
+-                              storage_ix, storage);
+-  } else {
+-    HistogramLiteral lit_histo;
+-    HistogramCommand cmd_histo;
+-    HistogramDistance dist_histo;
+-    uint8_t lit_depth[BROTLI_NUM_LITERAL_SYMBOLS];
+-    uint16_t lit_bits[BROTLI_NUM_LITERAL_SYMBOLS];
+-    uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS];
+-    uint16_t cmd_bits[BROTLI_NUM_COMMAND_SYMBOLS];
+-    uint8_t dist_depth[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
+-    uint16_t dist_bits[MAX_SIMPLE_DISTANCE_ALPHABET_SIZE];
+-    HistogramClearLiteral(&lit_histo);
+-    HistogramClearCommand(&cmd_histo);
+-    HistogramClearDistance(&dist_histo);
+-    BuildHistograms(input, start_pos, mask, commands, n_commands,
+-                    &lit_histo, &cmd_histo, &dist_histo);
+-    BrotliBuildAndStoreHuffmanTreeFast(m, lit_histo.data_,
+-                                       lit_histo.total_count_,
+-                                       /* max_bits = */ 8,
+-                                       lit_depth, lit_bits,
+-                                       storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BrotliBuildAndStoreHuffmanTreeFast(m, cmd_histo.data_,
+-                                       cmd_histo.total_count_,
+-                                       /* max_bits = */ 10,
+-                                       cmd_depth, cmd_bits,
+-                                       storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BrotliBuildAndStoreHuffmanTreeFast(m, dist_histo.data_,
+-                                       dist_histo.total_count_,
+-                                       /* max_bits = */
+-                                       distance_alphabet_bits,
+-                                       dist_depth, dist_bits,
+-                                       storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    StoreDataWithHuffmanCodes(input, start_pos, mask, commands,
+-                              n_commands, lit_depth, lit_bits,
+-                              cmd_depth, cmd_bits,
+-                              dist_depth, dist_bits,
+-                              storage_ix, storage);
+-  }
+-
+-  if (is_last) {
+-    JumpToByteBoundary(storage_ix, storage);
+-  }
+-}
+-
+-/* This is for storing uncompressed blocks (simple raw storage of
+-   bytes-as-bytes). */
+-void BrotliStoreUncompressedMetaBlock(BROTLI_BOOL is_final_block,
+-                                      const uint8_t* BROTLI_RESTRICT input,
+-                                      size_t position, size_t mask,
+-                                      size_t len,
+-                                      size_t* BROTLI_RESTRICT storage_ix,
+-                                      uint8_t* BROTLI_RESTRICT storage) {
+-  size_t masked_pos = position & mask;
+-  BrotliStoreUncompressedMetaBlockHeader(len, storage_ix, storage);
+-  JumpToByteBoundary(storage_ix, storage);
+-
+-  if (masked_pos + len > mask + 1) {
+-    size_t len1 = mask + 1 - masked_pos;
+-    memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len1);
+-    *storage_ix += len1 << 3;
+-    len -= len1;
+-    masked_pos = 0;
+-  }
+-  memcpy(&storage[*storage_ix >> 3], &input[masked_pos], len);
+-  *storage_ix += len << 3;
+-
+-  /* We need to clear the next 4 bytes to continue to be
+-     compatible with BrotliWriteBits. */
+-  BrotliWriteBitsPrepareStorage(*storage_ix, storage);
+-
+-  /* Since the uncompressed block itself may not be the final block, add an
+-     empty one after this. */
+-  if (is_final_block) {
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+-    JumpToByteBoundary(storage_ix, storage);
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/brotli_bit_stream.h b/modules/brotli/enc/brotli_bit_stream.h
+deleted file mode 100644
+--- a/modules/brotli/enc/brotli_bit_stream.h
++++ /dev/null
+@@ -1,84 +0,0 @@
+-/* Copyright 2014 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions to convert brotli-related data structures into the
+-   brotli bit stream. The functions here operate under
+-   assumption that there is enough space in the storage, i.e., there are
+-   no out-of-range checks anywhere.
+-
+-   These functions do bit addressing into a byte array. The byte array
+-   is called "storage" and the index to the bit is called storage_ix
+-   in function arguments. */
+-
+-#ifndef BROTLI_ENC_BROTLI_BIT_STREAM_H_
+-#define BROTLI_ENC_BROTLI_BIT_STREAM_H_
+-
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./command.h"
+-#include "./entropy_encode.h"
+-#include "./memory.h"
+-#include "./metablock.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* All Store functions here will use a storage_ix, which is always the bit
+-   position for the current storage. */
+-
+-BROTLI_INTERNAL void BrotliStoreHuffmanTree(const uint8_t* depths, size_t num,
+-    HuffmanTree* tree, size_t* storage_ix, uint8_t* storage);
+-
+-BROTLI_INTERNAL void BrotliBuildAndStoreHuffmanTreeFast(
+-    MemoryManager* m, const uint32_t* histogram, const size_t histogram_total,
+-    const size_t max_bits, uint8_t* depth, uint16_t* bits, size_t* storage_ix,
+-    uint8_t* storage);
+-
+-/* REQUIRES: length > 0 */
+-/* REQUIRES: length <= (1 << 24) */
+-BROTLI_INTERNAL void BrotliStoreMetaBlock(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    uint8_t prev_byte, uint8_t prev_byte2, BROTLI_BOOL is_last,
+-    const BrotliEncoderParams* params, ContextType literal_context_mode,
+-    const Command* commands, size_t n_commands, const MetaBlockSplit* mb,
+-    size_t* storage_ix, uint8_t* storage);
+-
+-/* Stores the meta-block without doing any block splitting, just collects
+-   one histogram per block category and uses that for entropy coding.
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-BROTLI_INTERNAL void BrotliStoreMetaBlockTrivial(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
+-    const Command* commands, size_t n_commands,
+-    size_t* storage_ix, uint8_t* storage);
+-
+-/* Same as above, but uses static prefix codes for histograms with a only a few
+-   symbols, and uses static code length prefix codes for all other histograms.
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-BROTLI_INTERNAL void BrotliStoreMetaBlockFast(MemoryManager* m,
+-    const uint8_t* input, size_t start_pos, size_t length, size_t mask,
+-    BROTLI_BOOL is_last, const BrotliEncoderParams* params,
+-    const Command* commands, size_t n_commands,
+-    size_t* storage_ix, uint8_t* storage);
+-
+-/* This is for storing uncompressed blocks (simple raw storage of
+-   bytes-as-bytes).
+-   REQUIRES: length > 0
+-   REQUIRES: length <= (1 << 24) */
+-BROTLI_INTERNAL void BrotliStoreUncompressedMetaBlock(
+-    BROTLI_BOOL is_final_block, const uint8_t* BROTLI_RESTRICT input,
+-    size_t position, size_t mask, size_t len,
+-    size_t* BROTLI_RESTRICT storage_ix, uint8_t* BROTLI_RESTRICT storage);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_BROTLI_BIT_STREAM_H_ */
+diff --git a/modules/brotli/enc/cluster.c b/modules/brotli/enc/cluster.c
+deleted file mode 100644
+--- a/modules/brotli/enc/cluster.c
++++ /dev/null
+@@ -1,56 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions for clustering similar histograms together. */
+-
+-#include "./cluster.h"
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./bit_cost.h"  /* BrotliPopulationCost */
+-#include "./fast_log.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static BROTLI_INLINE BROTLI_BOOL HistogramPairIsLess(
+-    const HistogramPair* p1, const HistogramPair* p2) {
+-  if (p1->cost_diff != p2->cost_diff) {
+-    return TO_BROTLI_BOOL(p1->cost_diff > p2->cost_diff);
+-  }
+-  return TO_BROTLI_BOOL((p1->idx2 - p1->idx1) > (p2->idx2 - p2->idx1));
+-}
+-
+-/* Returns entropy reduction of the context map when we combine two clusters. */
+-static BROTLI_INLINE double ClusterCostDiff(size_t size_a, size_t size_b) {
+-  size_t size_c = size_a + size_b;
+-  return (double)size_a * FastLog2(size_a) +
+-    (double)size_b * FastLog2(size_b) -
+-    (double)size_c * FastLog2(size_c);
+-}
+-
+-#define CODE(X) X
+-
+-#define FN(X) X ## Literal
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#undef CODE
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/cluster.h b/modules/brotli/enc/cluster.h
+deleted file mode 100644
+--- a/modules/brotli/enc/cluster.h
++++ /dev/null
+@@ -1,48 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions for clustering similar histograms together. */
+-
+-#ifndef BROTLI_ENC_CLUSTER_H_
+-#define BROTLI_ENC_CLUSTER_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./histogram.h"
+-#include "./memory.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct HistogramPair {
+-  uint32_t idx1;
+-  uint32_t idx2;
+-  double cost_combo;
+-  double cost_diff;
+-} HistogramPair;
+-
+-#define CODE(X) /* Declaration */;
+-
+-#define FN(X) X ## Literal
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-#include "./cluster_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#undef CODE
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_CLUSTER_H_ */
+diff --git a/modules/brotli/enc/cluster_inc.h b/modules/brotli/enc/cluster_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/cluster_inc.h
++++ /dev/null
+@@ -1,320 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, CODE */
+-
+-#define HistogramType FN(Histogram)
+-
+-/* Computes the bit cost reduction by combining out[idx1] and out[idx2] and if
+-   it is below a threshold, stores the pair (idx1, idx2) in the *pairs queue. */
+-BROTLI_INTERNAL void FN(BrotliCompareAndPushToQueue)(
+-    const HistogramType* out, const uint32_t* cluster_size, uint32_t idx1,
+-    uint32_t idx2, size_t max_num_pairs, HistogramPair* pairs,
+-    size_t* num_pairs) CODE({
+-  BROTLI_BOOL is_good_pair = BROTLI_FALSE;
+-  HistogramPair p;
+-  p.idx1 = p.idx2 = 0;
+-  p.cost_diff = p.cost_combo = 0;
+-  if (idx1 == idx2) {
+-    return;
+-  }
+-  if (idx2 < idx1) {
+-    uint32_t t = idx2;
+-    idx2 = idx1;
+-    idx1 = t;
+-  }
+-  p.idx1 = idx1;
+-  p.idx2 = idx2;
+-  p.cost_diff = 0.5 * ClusterCostDiff(cluster_size[idx1], cluster_size[idx2]);
+-  p.cost_diff -= out[idx1].bit_cost_;
+-  p.cost_diff -= out[idx2].bit_cost_;
+-
+-  if (out[idx1].total_count_ == 0) {
+-    p.cost_combo = out[idx2].bit_cost_;
+-    is_good_pair = BROTLI_TRUE;
+-  } else if (out[idx2].total_count_ == 0) {
+-    p.cost_combo = out[idx1].bit_cost_;
+-    is_good_pair = BROTLI_TRUE;
+-  } else {
+-    double threshold = *num_pairs == 0 ? 1e99 :
+-        BROTLI_MAX(double, 0.0, pairs[0].cost_diff);
+-    HistogramType combo = out[idx1];
+-    double cost_combo;
+-    FN(HistogramAddHistogram)(&combo, &out[idx2]);
+-    cost_combo = FN(BrotliPopulationCost)(&combo);
+-    if (cost_combo < threshold - p.cost_diff) {
+-      p.cost_combo = cost_combo;
+-      is_good_pair = BROTLI_TRUE;
+-    }
+-  }
+-  if (is_good_pair) {
+-    p.cost_diff += p.cost_combo;
+-    if (*num_pairs > 0 && HistogramPairIsLess(&pairs[0], &p)) {
+-      /* Replace the top of the queue if needed. */
+-      if (*num_pairs < max_num_pairs) {
+-        pairs[*num_pairs] = pairs[0];
+-        ++(*num_pairs);
+-      }
+-      pairs[0] = p;
+-    } else if (*num_pairs < max_num_pairs) {
+-      pairs[*num_pairs] = p;
+-      ++(*num_pairs);
+-    }
+-  }
+-})
+-
+-BROTLI_INTERNAL size_t FN(BrotliHistogramCombine)(HistogramType* out,
+-                                                  uint32_t* cluster_size,
+-                                                  uint32_t* symbols,
+-                                                  uint32_t* clusters,
+-                                                  HistogramPair* pairs,
+-                                                  size_t num_clusters,
+-                                                  size_t symbols_size,
+-                                                  size_t max_clusters,
+-                                                  size_t max_num_pairs) CODE({
+-  double cost_diff_threshold = 0.0;
+-  size_t min_cluster_size = 1;
+-  size_t num_pairs = 0;
+-
+-  {
+-    /* We maintain a vector of histogram pairs, with the property that the pair
+-       with the maximum bit cost reduction is the first. */
+-    size_t idx1;
+-    for (idx1 = 0; idx1 < num_clusters; ++idx1) {
+-      size_t idx2;
+-      for (idx2 = idx1 + 1; idx2 < num_clusters; ++idx2) {
+-        FN(BrotliCompareAndPushToQueue)(out, cluster_size, clusters[idx1],
+-            clusters[idx2], max_num_pairs, &pairs[0], &num_pairs);
+-      }
+-    }
+-  }
+-
+-  while (num_clusters > min_cluster_size) {
+-    uint32_t best_idx1;
+-    uint32_t best_idx2;
+-    size_t i;
+-    if (pairs[0].cost_diff >= cost_diff_threshold) {
+-      cost_diff_threshold = 1e99;
+-      min_cluster_size = max_clusters;
+-      continue;
+-    }
+-    /* Take the best pair from the top of heap. */
+-    best_idx1 = pairs[0].idx1;
+-    best_idx2 = pairs[0].idx2;
+-    FN(HistogramAddHistogram)(&out[best_idx1], &out[best_idx2]);
+-    out[best_idx1].bit_cost_ = pairs[0].cost_combo;
+-    cluster_size[best_idx1] += cluster_size[best_idx2];
+-    for (i = 0; i < symbols_size; ++i) {
+-      if (symbols[i] == best_idx2) {
+-        symbols[i] = best_idx1;
+-      }
+-    }
+-    for (i = 0; i < num_clusters; ++i) {
+-      if (clusters[i] == best_idx2) {
+-        memmove(&clusters[i], &clusters[i + 1],
+-                (num_clusters - i - 1) * sizeof(clusters[0]));
+-        break;
+-      }
+-    }
+-    --num_clusters;
+-    {
+-      /* Remove pairs intersecting the just combined best pair. */
+-      size_t copy_to_idx = 0;
+-      for (i = 0; i < num_pairs; ++i) {
+-        HistogramPair* p = &pairs[i];
+-        if (p->idx1 == best_idx1 || p->idx2 == best_idx1 ||
+-            p->idx1 == best_idx2 || p->idx2 == best_idx2) {
+-          /* Remove invalid pair from the queue. */
+-          continue;
+-        }
+-        if (HistogramPairIsLess(&pairs[0], p)) {
+-          /* Replace the top of the queue if needed. */
+-          HistogramPair front = pairs[0];
+-          pairs[0] = *p;
+-          pairs[copy_to_idx] = front;
+-        } else {
+-          pairs[copy_to_idx] = *p;
+-        }
+-        ++copy_to_idx;
+-      }
+-      num_pairs = copy_to_idx;
+-    }
+-
+-    /* Push new pairs formed with the combined histogram to the heap. */
+-    for (i = 0; i < num_clusters; ++i) {
+-      FN(BrotliCompareAndPushToQueue)(out, cluster_size, best_idx1, clusters[i],
+-                                      max_num_pairs, &pairs[0], &num_pairs);
+-    }
+-  }
+-  return num_clusters;
+-})
+-
+-/* What is the bit cost of moving histogram from cur_symbol to candidate. */
+-BROTLI_INTERNAL double FN(BrotliHistogramBitCostDistance)(
+-    const HistogramType* histogram, const HistogramType* candidate) CODE({
+-  if (histogram->total_count_ == 0) {
+-    return 0.0;
+-  } else {
+-    HistogramType tmp = *histogram;
+-    FN(HistogramAddHistogram)(&tmp, candidate);
+-    return FN(BrotliPopulationCost)(&tmp) - candidate->bit_cost_;
+-  }
+-})
+-
+-/* Find the best 'out' histogram for each of the 'in' histograms.
+-   When called, clusters[0..num_clusters) contains the unique values from
+-   symbols[0..in_size), but this property is not preserved in this function.
+-   Note: we assume that out[]->bit_cost_ is already up-to-date. */
+-BROTLI_INTERNAL void FN(BrotliHistogramRemap)(const HistogramType* in,
+-    size_t in_size, const uint32_t* clusters, size_t num_clusters,
+-    HistogramType* out, uint32_t* symbols) CODE({
+-  size_t i;
+-  for (i = 0; i < in_size; ++i) {
+-    uint32_t best_out = i == 0 ? symbols[0] : symbols[i - 1];
+-    double best_bits =
+-        FN(BrotliHistogramBitCostDistance)(&in[i], &out[best_out]);
+-    size_t j;
+-    for (j = 0; j < num_clusters; ++j) {
+-      const double cur_bits =
+-          FN(BrotliHistogramBitCostDistance)(&in[i], &out[clusters[j]]);
+-      if (cur_bits < best_bits) {
+-        best_bits = cur_bits;
+-        best_out = clusters[j];
+-      }
+-    }
+-    symbols[i] = best_out;
+-  }
+-
+-  /* Recompute each out based on raw and symbols. */
+-  for (i = 0; i < num_clusters; ++i) {
+-    FN(HistogramClear)(&out[clusters[i]]);
+-  }
+-  for (i = 0; i < in_size; ++i) {
+-    FN(HistogramAddHistogram)(&out[symbols[i]], &in[i]);
+-  }
+-})
+-
+-/* Reorders elements of the out[0..length) array and changes values in
+-   symbols[0..length) array in the following way:
+-     * when called, symbols[] contains indexes into out[], and has N unique
+-       values (possibly N < length)
+-     * on return, symbols'[i] = f(symbols[i]) and
+-                  out'[symbols'[i]] = out[symbols[i]], for each 0 <= i < length,
+-       where f is a bijection between the range of symbols[] and [0..N), and
+-       the first occurrences of values in symbols'[i] come in consecutive
+-       increasing order.
+-   Returns N, the number of unique values in symbols[]. */
+-BROTLI_INTERNAL size_t FN(BrotliHistogramReindex)(MemoryManager* m,
+-    HistogramType* out, uint32_t* symbols, size_t length) CODE({
+-  static const uint32_t kInvalidIndex = BROTLI_UINT32_MAX;
+-  uint32_t* new_index = BROTLI_ALLOC(m, uint32_t, length);
+-  uint32_t next_index;
+-  HistogramType* tmp;
+-  size_t i;
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_index)) return 0;
+-  for (i = 0; i < length; ++i) {
+-      new_index[i] = kInvalidIndex;
+-  }
+-  next_index = 0;
+-  for (i = 0; i < length; ++i) {
+-    if (new_index[symbols[i]] == kInvalidIndex) {
+-      new_index[symbols[i]] = next_index;
+-      ++next_index;
+-    }
+-  }
+-  /* TODO: by using idea of "cycle-sort" we can avoid allocation of
+-     tmp and reduce the number of copying by the factor of 2. */
+-  tmp = BROTLI_ALLOC(m, HistogramType, next_index);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp)) return 0;
+-  next_index = 0;
+-  for (i = 0; i < length; ++i) {
+-    if (new_index[symbols[i]] == next_index) {
+-      tmp[next_index] = out[symbols[i]];
+-      ++next_index;
+-    }
+-    symbols[i] = new_index[symbols[i]];
+-  }
+-  BROTLI_FREE(m, new_index);
+-  for (i = 0; i < next_index; ++i) {
+-    out[i] = tmp[i];
+-  }
+-  BROTLI_FREE(m, tmp);
+-  return next_index;
+-})
+-
+-BROTLI_INTERNAL void FN(BrotliClusterHistograms)(
+-    MemoryManager* m, const HistogramType* in, const size_t in_size,
+-    size_t max_histograms, HistogramType* out, size_t* out_size,
+-    uint32_t* histogram_symbols) CODE({
+-  uint32_t* cluster_size = BROTLI_ALLOC(m, uint32_t, in_size);
+-  uint32_t* clusters = BROTLI_ALLOC(m, uint32_t, in_size);
+-  size_t num_clusters = 0;
+-  const size_t max_input_histograms = 64;
+-  size_t pairs_capacity = max_input_histograms * max_input_histograms / 2;
+-  /* For the first pass of clustering, we allow all pairs. */
+-  HistogramPair* pairs = BROTLI_ALLOC(m, HistogramPair, pairs_capacity + 1);
+-  size_t i;
+-
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(cluster_size) ||
+-      BROTLI_IS_NULL(clusters) || BROTLI_IS_NULL(pairs)) {
+-    return;
+-  }
+-
+-  for (i = 0; i < in_size; ++i) {
+-    cluster_size[i] = 1;
+-  }
+-
+-  for (i = 0; i < in_size; ++i) {
+-    out[i] = in[i];
+-    out[i].bit_cost_ = FN(BrotliPopulationCost)(&in[i]);
+-    histogram_symbols[i] = (uint32_t)i;
+-  }
+-
+-  for (i = 0; i < in_size; i += max_input_histograms) {
+-    size_t num_to_combine =
+-        BROTLI_MIN(size_t, in_size - i, max_input_histograms);
+-    size_t num_new_clusters;
+-    size_t j;
+-    for (j = 0; j < num_to_combine; ++j) {
+-      clusters[num_clusters + j] = (uint32_t)(i + j);
+-    }
+-    num_new_clusters =
+-        FN(BrotliHistogramCombine)(out, cluster_size,
+-                                   &histogram_symbols[i],
+-                                   &clusters[num_clusters], pairs,
+-                                   num_to_combine, num_to_combine,
+-                                   max_histograms, pairs_capacity);
+-    num_clusters += num_new_clusters;
+-  }
+-
+-  {
+-    /* For the second pass, we limit the total number of histogram pairs.
+-       After this limit is reached, we only keep searching for the best pair. */
+-    size_t max_num_pairs = BROTLI_MIN(size_t,
+-        64 * num_clusters, (num_clusters / 2) * num_clusters);
+-    BROTLI_ENSURE_CAPACITY(
+-        m, HistogramPair, pairs, pairs_capacity, max_num_pairs + 1);
+-    if (BROTLI_IS_OOM(m)) return;
+-
+-    /* Collapse similar histograms. */
+-    num_clusters = FN(BrotliHistogramCombine)(out, cluster_size,
+-                                              histogram_symbols, clusters,
+-                                              pairs, num_clusters, in_size,
+-                                              max_histograms, max_num_pairs);
+-  }
+-  BROTLI_FREE(m, pairs);
+-  BROTLI_FREE(m, cluster_size);
+-  /* Find the optimal map from original histograms to the final ones. */
+-  FN(BrotliHistogramRemap)(in, in_size, clusters, num_clusters,
+-                           out, histogram_symbols);
+-  BROTLI_FREE(m, clusters);
+-  /* Convert the context map to a canonical form. */
+-  *out_size = FN(BrotliHistogramReindex)(m, out, histogram_symbols, in_size);
+-  if (BROTLI_IS_OOM(m)) return;
+-})
+-
+-#undef HistogramType
+diff --git a/modules/brotli/enc/command.c b/modules/brotli/enc/command.c
+deleted file mode 100644
+--- a/modules/brotli/enc/command.c
++++ /dev/null
+@@ -1,28 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-#include "./command.h"
+-
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-const uint32_t kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES] = {
+-    0,  1,  2,  3,  4,   5,   6,   8,   10,   14,   18,   26,
+-    34, 50, 66, 98, 130, 194, 322, 578, 1090, 2114, 6210, 22594};
+-const uint32_t kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES] = {
+-    0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 14, 24};
+-const uint32_t kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES] = {
+-    2,  3,  4,  5,  6,  7,   8,   9,   10,  12,  14,   18,
+-    22, 30, 38, 54, 70, 102, 134, 198, 326, 582, 1094, 2118};
+-const uint32_t kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES] = {
+-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 24};
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/command.h b/modules/brotli/enc/command.h
+deleted file mode 100644
+--- a/modules/brotli/enc/command.h
++++ /dev/null
+@@ -1,190 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* This class models a sequence of literals and a backward reference copy. */
+-
+-#ifndef BROTLI_ENC_COMMAND_H_
+-#define BROTLI_ENC_COMMAND_H_
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./fast_log.h"
+-#include "./params.h"
+-#include "./prefix.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-BROTLI_INTERNAL extern const uint32_t
+-    kBrotliInsBase[BROTLI_NUM_INS_COPY_CODES];
+-BROTLI_INTERNAL extern const uint32_t
+-    kBrotliInsExtra[BROTLI_NUM_INS_COPY_CODES];
+-BROTLI_INTERNAL extern const uint32_t
+-    kBrotliCopyBase[BROTLI_NUM_INS_COPY_CODES];
+-BROTLI_INTERNAL extern const uint32_t
+-    kBrotliCopyExtra[BROTLI_NUM_INS_COPY_CODES];
+-
+-static BROTLI_INLINE uint16_t GetInsertLengthCode(size_t insertlen) {
+-  if (insertlen < 6) {
+-    return (uint16_t)insertlen;
+-  } else if (insertlen < 130) {
+-    uint32_t nbits = Log2FloorNonZero(insertlen - 2) - 1u;
+-    return (uint16_t)((nbits << 1) + ((insertlen - 2) >> nbits) + 2);
+-  } else if (insertlen < 2114) {
+-    return (uint16_t)(Log2FloorNonZero(insertlen - 66) + 10);
+-  } else if (insertlen < 6210) {
+-    return 21u;
+-  } else if (insertlen < 22594) {
+-    return 22u;
+-  } else {
+-    return 23u;
+-  }
+-}
+-
+-static BROTLI_INLINE uint16_t GetCopyLengthCode(size_t copylen) {
+-  if (copylen < 10) {
+-    return (uint16_t)(copylen - 2);
+-  } else if (copylen < 134) {
+-    uint32_t nbits = Log2FloorNonZero(copylen - 6) - 1u;
+-    return (uint16_t)((nbits << 1) + ((copylen - 6) >> nbits) + 4);
+-  } else if (copylen < 2118) {
+-    return (uint16_t)(Log2FloorNonZero(copylen - 70) + 12);
+-  } else {
+-    return 23u;
+-  }
+-}
+-
+-static BROTLI_INLINE uint16_t CombineLengthCodes(
+-    uint16_t inscode, uint16_t copycode, BROTLI_BOOL use_last_distance) {
+-  uint16_t bits64 =
+-      (uint16_t)((copycode & 0x7u) | ((inscode & 0x7u) << 3u));
+-  if (use_last_distance && inscode < 8u && copycode < 16u) {
+-    return (copycode < 8u) ? bits64 : (bits64 | 64u);
+-  } else {
+-    /* Specification: 5 Encoding of ... (last table) */
+-    /* offset = 2 * index, where index is in range [0..8] */
+-    uint32_t offset = 2u * ((copycode >> 3u) + 3u * (inscode >> 3u));
+-    /* All values in specification are K * 64,
+-       where   K = [2, 3, 6, 4, 5, 8, 7, 9, 10],
+-           i + 1 = [1, 2, 3, 4, 5, 6, 7, 8,  9],
+-       K - i - 1 = [1, 1, 3, 0, 0, 2, 0, 1,  2] = D.
+-       All values in D require only 2 bits to encode.
+-       Magic constant is shifted 6 bits left, to avoid final multiplication. */
+-    offset = (offset << 5u) + 0x40u + ((0x520D40u >> offset) & 0xC0u);
+-    return (uint16_t)(offset | bits64);
+-  }
+-}
+-
+-static BROTLI_INLINE void GetLengthCode(size_t insertlen, size_t copylen,
+-                                        BROTLI_BOOL use_last_distance,
+-                                        uint16_t* code) {
+-  uint16_t inscode = GetInsertLengthCode(insertlen);
+-  uint16_t copycode = GetCopyLengthCode(copylen);
+-  *code = CombineLengthCodes(inscode, copycode, use_last_distance);
+-}
+-
+-static BROTLI_INLINE uint32_t GetInsertBase(uint16_t inscode) {
+-  return kBrotliInsBase[inscode];
+-}
+-
+-static BROTLI_INLINE uint32_t GetInsertExtra(uint16_t inscode) {
+-  return kBrotliInsExtra[inscode];
+-}
+-
+-static BROTLI_INLINE uint32_t GetCopyBase(uint16_t copycode) {
+-  return kBrotliCopyBase[copycode];
+-}
+-
+-static BROTLI_INLINE uint32_t GetCopyExtra(uint16_t copycode) {
+-  return kBrotliCopyExtra[copycode];
+-}
+-
+-typedef struct Command {
+-  uint32_t insert_len_;
+-  /* Stores copy_len in low 25 bits and copy_code - copy_len in high 7 bit. */
+-  uint32_t copy_len_;
+-  /* Stores distance extra bits. */
+-  uint32_t dist_extra_;
+-  uint16_t cmd_prefix_;
+-  /* Stores distance code in low 10 bits
+-     and number of extra bits in high 6 bits. */
+-  uint16_t dist_prefix_;
+-} Command;
+-
+-/* distance_code is e.g. 0 for same-as-last short code, or 16 for offset 1. */
+-static BROTLI_INLINE void InitCommand(Command* self,
+-    const BrotliDistanceParams* dist, size_t insertlen,
+-    size_t copylen, int copylen_code_delta, size_t distance_code) {
+-  /* Don't rely on signed int representation, use honest casts. */
+-  uint32_t delta = (uint8_t)((int8_t)copylen_code_delta);
+-  self->insert_len_ = (uint32_t)insertlen;
+-  self->copy_len_ = (uint32_t)(copylen | (delta << 25));
+-  /* The distance prefix and extra bits are stored in this Command as if
+-     npostfix and ndirect were 0, they are only recomputed later after the
+-     clustering if needed. */
+-  PrefixEncodeCopyDistance(
+-      distance_code, dist->num_direct_distance_codes,
+-      dist->distance_postfix_bits, &self->dist_prefix_, &self->dist_extra_);
+-  GetLengthCode(
+-      insertlen, (size_t)((int)copylen + copylen_code_delta),
+-      TO_BROTLI_BOOL((self->dist_prefix_ & 0x3FF) == 0), &self->cmd_prefix_);
+-}
+-
+-static BROTLI_INLINE void InitInsertCommand(Command* self, size_t insertlen) {
+-  self->insert_len_ = (uint32_t)insertlen;
+-  self->copy_len_ = 4 << 25;
+-  self->dist_extra_ = 0;
+-  self->dist_prefix_ = BROTLI_NUM_DISTANCE_SHORT_CODES;
+-  GetLengthCode(insertlen, 4, BROTLI_FALSE, &self->cmd_prefix_);
+-}
+-
+-static BROTLI_INLINE uint32_t CommandRestoreDistanceCode(
+-    const Command* self, const BrotliDistanceParams* dist) {
+-  if ((self->dist_prefix_ & 0x3FFu) <
+-      BROTLI_NUM_DISTANCE_SHORT_CODES + dist->num_direct_distance_codes) {
+-    return self->dist_prefix_ & 0x3FFu;
+-  } else {
+-    uint32_t dcode = self->dist_prefix_ & 0x3FFu;
+-    uint32_t nbits = self->dist_prefix_ >> 10;
+-    uint32_t extra = self->dist_extra_;
+-    uint32_t postfix_mask = (1U << dist->distance_postfix_bits) - 1U;
+-    uint32_t hcode = (dcode - dist->num_direct_distance_codes -
+-        BROTLI_NUM_DISTANCE_SHORT_CODES) >>
+-        dist->distance_postfix_bits;
+-    uint32_t lcode = (dcode - dist->num_direct_distance_codes -
+-        BROTLI_NUM_DISTANCE_SHORT_CODES) & postfix_mask;
+-    uint32_t offset = ((2U + (hcode & 1U)) << nbits) - 4U;
+-    return ((offset + extra) << dist->distance_postfix_bits) + lcode +
+-        dist->num_direct_distance_codes + BROTLI_NUM_DISTANCE_SHORT_CODES;
+-  }
+-}
+-
+-static BROTLI_INLINE uint32_t CommandDistanceContext(const Command* self) {
+-  uint32_t r = self->cmd_prefix_ >> 6;
+-  uint32_t c = self->cmd_prefix_ & 7;
+-  if ((r == 0 || r == 2 || r == 4 || r == 7) && (c <= 2)) {
+-    return c;
+-  }
+-  return 3;
+-}
+-
+-static BROTLI_INLINE uint32_t CommandCopyLen(const Command* self) {
+-  return self->copy_len_ & 0x1FFFFFF;
+-}
+-
+-static BROTLI_INLINE uint32_t CommandCopyLenCode(const Command* self) {
+-  uint32_t modifier = self->copy_len_ >> 25;
+-  int32_t delta = (int8_t)((uint8_t)(modifier | ((modifier & 0x40) << 1)));
+-  return (uint32_t)((int32_t)(self->copy_len_ & 0x1FFFFFF) + delta);
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_COMMAND_H_ */
+diff --git a/modules/brotli/enc/compress_fragment.c b/modules/brotli/enc/compress_fragment.c
+deleted file mode 100644
+--- a/modules/brotli/enc/compress_fragment.c
++++ /dev/null
+@@ -1,790 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function for fast encoding of an input fragment, independently from the input
+-   history. This function uses one-pass processing: when we find a backward
+-   match, we immediately emit the corresponding command and literal codes to
+-   the bit stream.
+-
+-   Adapted from the CompressFragment() function in
+-   https://github.com/google/snappy/blob/master/snappy.cc */
+-
+-#include "./compress_fragment.h"
+-
+-#include <string.h>  /* memcmp, memcpy, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./brotli_bit_stream.h"
+-#include "./entropy_encode.h"
+-#include "./fast_log.h"
+-#include "./find_match_length.h"
+-#include "./memory.h"
+-#include "./write_bits.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define MAX_DISTANCE (long)BROTLI_MAX_BACKWARD_LIMIT(18)
+-
+-/* kHashMul32 multiplier has these properties:
+-   * The multiplier must be odd. Otherwise we may lose the highest bit.
+-   * No long streaks of ones or zeros.
+-   * There is no effort to ensure that it is a prime, the oddity is enough
+-     for this use.
+-   * The number has been tuned heuristically against compression benchmarks. */
+-static const uint32_t kHashMul32 = 0x1E35A7BD;
+-
+-static BROTLI_INLINE uint32_t Hash(const uint8_t* p, size_t shift) {
+-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(p) << 24) * kHashMul32;
+-  return (uint32_t)(h >> shift);
+-}
+-
+-static BROTLI_INLINE uint32_t HashBytesAtOffset(
+-    uint64_t v, int offset, size_t shift) {
+-  BROTLI_DCHECK(offset >= 0);
+-  BROTLI_DCHECK(offset <= 3);
+-  {
+-    const uint64_t h = ((v >> (8 * offset)) << 24) * kHashMul32;
+-    return (uint32_t)(h >> shift);
+-  }
+-}
+-
+-static BROTLI_INLINE BROTLI_BOOL IsMatch(const uint8_t* p1, const uint8_t* p2) {
+-  return TO_BROTLI_BOOL(
+-      BrotliUnalignedRead32(p1) == BrotliUnalignedRead32(p2) &&
+-      p1[4] == p2[4]);
+-}
+-
+-/* Builds a literal prefix code into "depths" and "bits" based on the statistics
+-   of the "input" string and stores it into the bit stream.
+-   Note that the prefix code here is built from the pre-LZ77 input, therefore
+-   we can only approximate the statistics of the actual literal stream.
+-   Moreover, for long inputs we build a histogram from a sample of the input
+-   and thus have to assign a non-zero depth for each literal.
+-   Returns estimated compression ratio millibytes/char for encoding given input
+-   with generated code. */
+-static size_t BuildAndStoreLiteralPrefixCode(MemoryManager* m,
+-                                             const uint8_t* input,
+-                                             const size_t input_size,
+-                                             uint8_t depths[256],
+-                                             uint16_t bits[256],
+-                                             size_t* storage_ix,
+-                                             uint8_t* storage) {
+-  uint32_t histogram[256] = { 0 };
+-  size_t histogram_total;
+-  size_t i;
+-  if (input_size < (1 << 15)) {
+-    for (i = 0; i < input_size; ++i) {
+-      ++histogram[input[i]];
+-    }
+-    histogram_total = input_size;
+-    for (i = 0; i < 256; ++i) {
+-      /* We weigh the first 11 samples with weight 3 to account for the
+-         balancing effect of the LZ77 phase on the histogram. */
+-      const uint32_t adjust = 2 * BROTLI_MIN(uint32_t, histogram[i], 11u);
+-      histogram[i] += adjust;
+-      histogram_total += adjust;
+-    }
+-  } else {
+-    static const size_t kSampleRate = 29;
+-    for (i = 0; i < input_size; i += kSampleRate) {
+-      ++histogram[input[i]];
+-    }
+-    histogram_total = (input_size + kSampleRate - 1) / kSampleRate;
+-    for (i = 0; i < 256; ++i) {
+-      /* We add 1 to each population count to avoid 0 bit depths (since this is
+-         only a sample and we don't know if the symbol appears or not), and we
+-         weigh the first 11 samples with weight 3 to account for the balancing
+-         effect of the LZ77 phase on the histogram (more frequent symbols are
+-         more likely to be in backward references instead as literals). */
+-      const uint32_t adjust = 1 + 2 * BROTLI_MIN(uint32_t, histogram[i], 11u);
+-      histogram[i] += adjust;
+-      histogram_total += adjust;
+-    }
+-  }
+-  BrotliBuildAndStoreHuffmanTreeFast(m, histogram, histogram_total,
+-                                     /* max_bits = */ 8,
+-                                     depths, bits, storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return 0;
+-  {
+-    size_t literal_ratio = 0;
+-    for (i = 0; i < 256; ++i) {
+-      if (histogram[i]) literal_ratio += histogram[i] * depths[i];
+-    }
+-    /* Estimated encoding ratio, millibytes per symbol. */
+-    return (literal_ratio * 125) / histogram_total;
+-  }
+-}
+-
+-/* Builds a command and distance prefix code (each 64 symbols) into "depth" and
+-   "bits" based on "histogram" and stores it into the bit stream. */
+-static void BuildAndStoreCommandPrefixCode(const uint32_t histogram[128],
+-    uint8_t depth[128], uint16_t bits[128], size_t* storage_ix,
+-    uint8_t* storage) {
+-  /* Tree size for building a tree over 64 symbols is 2 * 64 + 1. */
+-  HuffmanTree tree[129];
+-  uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS] = { 0 };
+-  uint16_t cmd_bits[64];
+-
+-  BrotliCreateHuffmanTree(histogram, 64, 15, tree, depth);
+-  BrotliCreateHuffmanTree(&histogram[64], 64, 14, tree, &depth[64]);
+-  /* We have to jump through a few hoops here in order to compute
+-     the command bits because the symbols are in a different order than in
+-     the full alphabet. This looks complicated, but having the symbols
+-     in this order in the command bits saves a few branches in the Emit*
+-     functions. */
+-  memcpy(cmd_depth, depth, 24);
+-  memcpy(cmd_depth + 24, depth + 40, 8);
+-  memcpy(cmd_depth + 32, depth + 24, 8);
+-  memcpy(cmd_depth + 40, depth + 48, 8);
+-  memcpy(cmd_depth + 48, depth + 32, 8);
+-  memcpy(cmd_depth + 56, depth + 56, 8);
+-  BrotliConvertBitDepthsToSymbols(cmd_depth, 64, cmd_bits);
+-  memcpy(bits, cmd_bits, 48);
+-  memcpy(bits + 24, cmd_bits + 32, 16);
+-  memcpy(bits + 32, cmd_bits + 48, 16);
+-  memcpy(bits + 40, cmd_bits + 24, 16);
+-  memcpy(bits + 48, cmd_bits + 40, 16);
+-  memcpy(bits + 56, cmd_bits + 56, 16);
+-  BrotliConvertBitDepthsToSymbols(&depth[64], 64, &bits[64]);
+-  {
+-    /* Create the bit length array for the full command alphabet. */
+-    size_t i;
+-    memset(cmd_depth, 0, 64);  /* only 64 first values were used */
+-    memcpy(cmd_depth, depth, 8);
+-    memcpy(cmd_depth + 64, depth + 8, 8);
+-    memcpy(cmd_depth + 128, depth + 16, 8);
+-    memcpy(cmd_depth + 192, depth + 24, 8);
+-    memcpy(cmd_depth + 384, depth + 32, 8);
+-    for (i = 0; i < 8; ++i) {
+-      cmd_depth[128 + 8 * i] = depth[40 + i];
+-      cmd_depth[256 + 8 * i] = depth[48 + i];
+-      cmd_depth[448 + 8 * i] = depth[56 + i];
+-    }
+-    BrotliStoreHuffmanTree(
+-        cmd_depth, BROTLI_NUM_COMMAND_SYMBOLS, tree, storage_ix, storage);
+-  }
+-  BrotliStoreHuffmanTree(&depth[64], 64, tree, storage_ix, storage);
+-}
+-
+-/* REQUIRES: insertlen < 6210 */
+-static BROTLI_INLINE void EmitInsertLen(size_t insertlen,
+-                                        const uint8_t depth[128],
+-                                        const uint16_t bits[128],
+-                                        uint32_t histo[128],
+-                                        size_t* storage_ix,
+-                                        uint8_t* storage) {
+-  if (insertlen < 6) {
+-    const size_t code = insertlen + 40;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    ++histo[code];
+-  } else if (insertlen < 130) {
+-    const size_t tail = insertlen - 2;
+-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
+-    const size_t prefix = tail >> nbits;
+-    const size_t inscode = (nbits << 1) + prefix + 42;
+-    BrotliWriteBits(depth[inscode], bits[inscode], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
+-    ++histo[inscode];
+-  } else if (insertlen < 2114) {
+-    const size_t tail = insertlen - 66;
+-    const uint32_t nbits = Log2FloorNonZero(tail);
+-    const size_t code = nbits + 50;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
+-    ++histo[code];
+-  } else {
+-    BrotliWriteBits(depth[61], bits[61], storage_ix, storage);
+-    BrotliWriteBits(12, insertlen - 2114, storage_ix, storage);
+-    ++histo[61];
+-  }
+-}
+-
+-static BROTLI_INLINE void EmitLongInsertLen(size_t insertlen,
+-                                            const uint8_t depth[128],
+-                                            const uint16_t bits[128],
+-                                            uint32_t histo[128],
+-                                            size_t* storage_ix,
+-                                            uint8_t* storage) {
+-  if (insertlen < 22594) {
+-    BrotliWriteBits(depth[62], bits[62], storage_ix, storage);
+-    BrotliWriteBits(14, insertlen - 6210, storage_ix, storage);
+-    ++histo[62];
+-  } else {
+-    BrotliWriteBits(depth[63], bits[63], storage_ix, storage);
+-    BrotliWriteBits(24, insertlen - 22594, storage_ix, storage);
+-    ++histo[63];
+-  }
+-}
+-
+-static BROTLI_INLINE void EmitCopyLen(size_t copylen,
+-                                      const uint8_t depth[128],
+-                                      const uint16_t bits[128],
+-                                      uint32_t histo[128],
+-                                      size_t* storage_ix,
+-                                      uint8_t* storage) {
+-  if (copylen < 10) {
+-    BrotliWriteBits(
+-        depth[copylen + 14], bits[copylen + 14], storage_ix, storage);
+-    ++histo[copylen + 14];
+-  } else if (copylen < 134) {
+-    const size_t tail = copylen - 6;
+-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
+-    const size_t prefix = tail >> nbits;
+-    const size_t code = (nbits << 1) + prefix + 20;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
+-    ++histo[code];
+-  } else if (copylen < 2118) {
+-    const size_t tail = copylen - 70;
+-    const uint32_t nbits = Log2FloorNonZero(tail);
+-    const size_t code = nbits + 28;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
+-    ++histo[code];
+-  } else {
+-    BrotliWriteBits(depth[39], bits[39], storage_ix, storage);
+-    BrotliWriteBits(24, copylen - 2118, storage_ix, storage);
+-    ++histo[39];
+-  }
+-}
+-
+-static BROTLI_INLINE void EmitCopyLenLastDistance(size_t copylen,
+-                                                  const uint8_t depth[128],
+-                                                  const uint16_t bits[128],
+-                                                  uint32_t histo[128],
+-                                                  size_t* storage_ix,
+-                                                  uint8_t* storage) {
+-  if (copylen < 12) {
+-    BrotliWriteBits(depth[copylen - 4], bits[copylen - 4], storage_ix, storage);
+-    ++histo[copylen - 4];
+-  } else if (copylen < 72) {
+-    const size_t tail = copylen - 8;
+-    const uint32_t nbits = Log2FloorNonZero(tail) - 1;
+-    const size_t prefix = tail >> nbits;
+-    const size_t code = (nbits << 1) + prefix + 4;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - (prefix << nbits), storage_ix, storage);
+-    ++histo[code];
+-  } else if (copylen < 136) {
+-    const size_t tail = copylen - 8;
+-    const size_t code = (tail >> 5) + 30;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(5, tail & 31, storage_ix, storage);
+-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
+-    ++histo[code];
+-    ++histo[64];
+-  } else if (copylen < 2120) {
+-    const size_t tail = copylen - 72;
+-    const uint32_t nbits = Log2FloorNonZero(tail);
+-    const size_t code = nbits + 28;
+-    BrotliWriteBits(depth[code], bits[code], storage_ix, storage);
+-    BrotliWriteBits(nbits, tail - ((size_t)1 << nbits), storage_ix, storage);
+-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
+-    ++histo[code];
+-    ++histo[64];
+-  } else {
+-    BrotliWriteBits(depth[39], bits[39], storage_ix, storage);
+-    BrotliWriteBits(24, copylen - 2120, storage_ix, storage);
+-    BrotliWriteBits(depth[64], bits[64], storage_ix, storage);
+-    ++histo[39];
+-    ++histo[64];
+-  }
+-}
+-
+-static BROTLI_INLINE void EmitDistance(size_t distance,
+-                                       const uint8_t depth[128],
+-                                       const uint16_t bits[128],
+-                                       uint32_t histo[128],
+-                                       size_t* storage_ix, uint8_t* storage) {
+-  const size_t d = distance + 3;
+-  const uint32_t nbits = Log2FloorNonZero(d) - 1u;
+-  const size_t prefix = (d >> nbits) & 1;
+-  const size_t offset = (2 + prefix) << nbits;
+-  const size_t distcode = 2 * (nbits - 1) + prefix + 80;
+-  BrotliWriteBits(depth[distcode], bits[distcode], storage_ix, storage);
+-  BrotliWriteBits(nbits, d - offset, storage_ix, storage);
+-  ++histo[distcode];
+-}
+-
+-static BROTLI_INLINE void EmitLiterals(const uint8_t* input, const size_t len,
+-                                       const uint8_t depth[256],
+-                                       const uint16_t bits[256],
+-                                       size_t* storage_ix, uint8_t* storage) {
+-  size_t j;
+-  for (j = 0; j < len; j++) {
+-    const uint8_t lit = input[j];
+-    BrotliWriteBits(depth[lit], bits[lit], storage_ix, storage);
+-  }
+-}
+-
+-/* REQUIRES: len <= 1 << 24. */
+-static void BrotliStoreMetaBlockHeader(
+-    size_t len, BROTLI_BOOL is_uncompressed, size_t* storage_ix,
+-    uint8_t* storage) {
+-  size_t nibbles = 6;
+-  /* ISLAST */
+-  BrotliWriteBits(1, 0, storage_ix, storage);
+-  if (len <= (1U << 16)) {
+-    nibbles = 4;
+-  } else if (len <= (1U << 20)) {
+-    nibbles = 5;
+-  }
+-  BrotliWriteBits(2, nibbles - 4, storage_ix, storage);
+-  BrotliWriteBits(nibbles * 4, len - 1, storage_ix, storage);
+-  /* ISUNCOMPRESSED */
+-  BrotliWriteBits(1, (uint64_t)is_uncompressed, storage_ix, storage);
+-}
+-
+-static void UpdateBits(size_t n_bits, uint32_t bits, size_t pos,
+-    uint8_t* array) {
+-  while (n_bits > 0) {
+-    size_t byte_pos = pos >> 3;
+-    size_t n_unchanged_bits = pos & 7;
+-    size_t n_changed_bits = BROTLI_MIN(size_t, n_bits, 8 - n_unchanged_bits);
+-    size_t total_bits = n_unchanged_bits + n_changed_bits;
+-    uint32_t mask =
+-        (~((1u << total_bits) - 1u)) | ((1u << n_unchanged_bits) - 1u);
+-    uint32_t unchanged_bits = array[byte_pos] & mask;
+-    uint32_t changed_bits = bits & ((1u << n_changed_bits) - 1u);
+-    array[byte_pos] =
+-        (uint8_t)((changed_bits << n_unchanged_bits) | unchanged_bits);
+-    n_bits -= n_changed_bits;
+-    bits >>= n_changed_bits;
+-    pos += n_changed_bits;
+-  }
+-}
+-
+-static void RewindBitPosition(const size_t new_storage_ix,
+-                              size_t* storage_ix, uint8_t* storage) {
+-  const size_t bitpos = new_storage_ix & 7;
+-  const size_t mask = (1u << bitpos) - 1;
+-  storage[new_storage_ix >> 3] &= (uint8_t)mask;
+-  *storage_ix = new_storage_ix;
+-}
+-
+-static BROTLI_BOOL ShouldMergeBlock(
+-    const uint8_t* data, size_t len, const uint8_t* depths) {
+-  size_t histo[256] = { 0 };
+-  static const size_t kSampleRate = 43;
+-  size_t i;
+-  for (i = 0; i < len; i += kSampleRate) {
+-    ++histo[data[i]];
+-  }
+-  {
+-    const size_t total = (len + kSampleRate - 1) / kSampleRate;
+-    double r = (FastLog2(total) + 0.5) * (double)total + 200;
+-    for (i = 0; i < 256; ++i) {
+-      r -= (double)histo[i] * (depths[i] + FastLog2(histo[i]));
+-    }
+-    return TO_BROTLI_BOOL(r >= 0.0);
+-  }
+-}
+-
+-/* Acceptable loss for uncompressible speedup is 2% */
+-#define MIN_RATIO 980
+-
+-static BROTLI_INLINE BROTLI_BOOL ShouldUseUncompressedMode(
+-    const uint8_t* metablock_start, const uint8_t* next_emit,
+-    const size_t insertlen, const size_t literal_ratio) {
+-  const size_t compressed = (size_t)(next_emit - metablock_start);
+-  if (compressed * 50 > insertlen) {
+-    return BROTLI_FALSE;
+-  } else {
+-    return TO_BROTLI_BOOL(literal_ratio > MIN_RATIO);
+-  }
+-}
+-
+-static void EmitUncompressedMetaBlock(const uint8_t* begin, const uint8_t* end,
+-                                      const size_t storage_ix_start,
+-                                      size_t* storage_ix, uint8_t* storage) {
+-  const size_t len = (size_t)(end - begin);
+-  RewindBitPosition(storage_ix_start, storage_ix, storage);
+-  BrotliStoreMetaBlockHeader(len, 1, storage_ix, storage);
+-  *storage_ix = (*storage_ix + 7u) & ~7u;
+-  memcpy(&storage[*storage_ix >> 3], begin, len);
+-  *storage_ix += len << 3;
+-  storage[*storage_ix >> 3] = 0;
+-}
+-
+-static uint32_t kCmdHistoSeed[128] = {
+-  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1,
+-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1,
+-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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,
+-  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+-  1, 1, 1, 1, 0, 0, 0, 0,
+-};
+-
+-static BROTLI_INLINE void BrotliCompressFragmentFastImpl(
+-    MemoryManager* m, const uint8_t* input, size_t input_size,
+-    BROTLI_BOOL is_last, int* table, size_t table_bits, uint8_t cmd_depth[128],
+-    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,
+-    size_t* storage_ix, uint8_t* storage) {
+-  uint32_t cmd_histo[128];
+-  const uint8_t* ip_end;
+-
+-  /* "next_emit" is a pointer to the first byte that is not covered by a
+-     previous copy. Bytes between "next_emit" and the start of the next copy or
+-     the end of the input will be emitted as literal bytes. */
+-  const uint8_t* next_emit = input;
+-  /* Save the start of the first block for position and distance computations.
+-  */
+-  const uint8_t* base_ip = input;
+-
+-  static const size_t kFirstBlockSize = 3 << 15;
+-  static const size_t kMergeBlockSize = 1 << 16;
+-
+-  const size_t kInputMarginBytes = BROTLI_WINDOW_GAP;
+-  const size_t kMinMatchLen = 5;
+-
+-  const uint8_t* metablock_start = input;
+-  size_t block_size = BROTLI_MIN(size_t, input_size, kFirstBlockSize);
+-  size_t total_block_size = block_size;
+-  /* Save the bit position of the MLEN field of the meta-block header, so that
+-     we can update it later if we decide to extend this meta-block. */
+-  size_t mlen_storage_ix = *storage_ix + 3;
+-
+-  uint8_t lit_depth[256];
+-  uint16_t lit_bits[256];
+-
+-  size_t literal_ratio;
+-
+-  const uint8_t* ip;
+-  int last_distance;
+-
+-  const size_t shift = 64u - table_bits;
+-
+-  BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
+-  /* No block splits, no contexts. */
+-  BrotliWriteBits(13, 0, storage_ix, storage);
+-
+-  literal_ratio = BuildAndStoreLiteralPrefixCode(
+-      m, input, block_size, lit_depth, lit_bits, storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return;
+-
+-  {
+-    /* Store the pre-compressed command and distance prefix codes. */
+-    size_t i;
+-    for (i = 0; i + 7 < *cmd_code_numbits; i += 8) {
+-      BrotliWriteBits(8, cmd_code[i >> 3], storage_ix, storage);
+-    }
+-  }
+-  BrotliWriteBits(*cmd_code_numbits & 7, cmd_code[*cmd_code_numbits >> 3],
+-                  storage_ix, storage);
+-
+- emit_commands:
+-  /* Initialize the command and distance histograms. We will gather
+-     statistics of command and distance codes during the processing
+-     of this block and use it to update the command and distance
+-     prefix codes for the next block. */
+-  memcpy(cmd_histo, kCmdHistoSeed, sizeof(kCmdHistoSeed));
+-
+-  /* "ip" is the input pointer. */
+-  ip = input;
+-  last_distance = -1;
+-  ip_end = input + block_size;
+-
+-  if (BROTLI_PREDICT_TRUE(block_size >= kInputMarginBytes)) {
+-    /* For the last block, we need to keep a 16 bytes margin so that we can be
+-       sure that all distances are at most window size - 16.
+-       For all other blocks, we only need to keep a margin of 5 bytes so that
+-       we don't go over the block size with a copy. */
+-    const size_t len_limit = BROTLI_MIN(size_t, block_size - kMinMatchLen,
+-                                        input_size - kInputMarginBytes);
+-    const uint8_t* ip_limit = input + len_limit;
+-
+-    uint32_t next_hash;
+-    for (next_hash = Hash(++ip, shift); ; ) {
+-      /* Step 1: Scan forward in the input looking for a 5-byte-long match.
+-         If we get close to exhausting the input then goto emit_remainder.
+-
+-         Heuristic match skipping: If 32 bytes are scanned with no matches
+-         found, start looking only at every other byte. If 32 more bytes are
+-         scanned, look at every third byte, etc.. When a match is found,
+-         immediately go back to looking at every byte. This is a small loss
+-         (~5% performance, ~0.1% density) for compressible data due to more
+-         bookkeeping, but for non-compressible data (such as JPEG) it's a huge
+-         win since the compressor quickly "realizes" the data is incompressible
+-         and doesn't bother looking for matches everywhere.
+-
+-         The "skip" variable keeps track of how many bytes there are since the
+-         last match; dividing it by 32 (i.e. right-shifting by five) gives the
+-         number of bytes to move ahead for each iteration. */
+-      uint32_t skip = 32;
+-
+-      const uint8_t* next_ip = ip;
+-      const uint8_t* candidate;
+-      BROTLI_DCHECK(next_emit < ip);
+-trawl:
+-      do {
+-        uint32_t hash = next_hash;
+-        uint32_t bytes_between_hash_lookups = skip++ >> 5;
+-        BROTLI_DCHECK(hash == Hash(next_ip, shift));
+-        ip = next_ip;
+-        next_ip = ip + bytes_between_hash_lookups;
+-        if (BROTLI_PREDICT_FALSE(next_ip > ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        next_hash = Hash(next_ip, shift);
+-        candidate = ip - last_distance;
+-        if (IsMatch(ip, candidate)) {
+-          if (BROTLI_PREDICT_TRUE(candidate < ip)) {
+-            table[hash] = (int)(ip - base_ip);
+-            break;
+-          }
+-        }
+-        candidate = base_ip + table[hash];
+-        BROTLI_DCHECK(candidate >= base_ip);
+-        BROTLI_DCHECK(candidate < ip);
+-
+-        table[hash] = (int)(ip - base_ip);
+-      } while (BROTLI_PREDICT_TRUE(!IsMatch(ip, candidate)));
+-
+-      /* Check copy distance. If candidate is not feasible, continue search.
+-         Checking is done outside of hot loop to reduce overhead. */
+-      if (ip - candidate > MAX_DISTANCE) goto trawl;
+-
+-      /* Step 2: Emit the found match together with the literal bytes from
+-         "next_emit" to the bit stream, and then see if we can find a next match
+-         immediately afterwards. Repeat until we find no match for the input
+-         without emitting some literal bytes. */
+-
+-      {
+-        /* We have a 5-byte match at ip, and we need to emit bytes in
+-           [next_emit, ip). */
+-        const uint8_t* base = ip;
+-        size_t matched = 5 + FindMatchLengthWithLimit(
+-            candidate + 5, ip + 5, (size_t)(ip_end - ip) - 5);
+-        int distance = (int)(base - candidate);  /* > 0 */
+-        size_t insert = (size_t)(base - next_emit);
+-        ip += matched;
+-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
+-        if (BROTLI_PREDICT_TRUE(insert < 6210)) {
+-          EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
+-                        storage_ix, storage);
+-        } else if (ShouldUseUncompressedMode(metablock_start, next_emit, insert,
+-                                             literal_ratio)) {
+-          EmitUncompressedMetaBlock(metablock_start, base, mlen_storage_ix - 3,
+-                                    storage_ix, storage);
+-          input_size -= (size_t)(base - input);
+-          input = base;
+-          next_emit = input;
+-          goto next_block;
+-        } else {
+-          EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
+-                            storage_ix, storage);
+-        }
+-        EmitLiterals(next_emit, insert, lit_depth, lit_bits,
+-                     storage_ix, storage);
+-        if (distance == last_distance) {
+-          BrotliWriteBits(cmd_depth[64], cmd_bits[64], storage_ix, storage);
+-          ++cmd_histo[64];
+-        } else {
+-          EmitDistance((size_t)distance, cmd_depth, cmd_bits,
+-                       cmd_histo, storage_ix, storage);
+-          last_distance = distance;
+-        }
+-        EmitCopyLenLastDistance(matched, cmd_depth, cmd_bits, cmd_histo,
+-                                storage_ix, storage);
+-
+-        next_emit = ip;
+-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        /* We could immediately start working at ip now, but to improve
+-           compression we first update "table" with the hashes of some positions
+-           within the last copy. */
+-        {
+-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
+-          uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
+-          uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 3);
+-          prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 2);
+-          prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 1);
+-
+-          candidate = base_ip + table[cur_hash];
+-          table[cur_hash] = (int)(ip - base_ip);
+-        }
+-      }
+-
+-      while (IsMatch(ip, candidate)) {
+-        /* We have a 5-byte match at ip, and no need to emit any literal bytes
+-           prior to ip. */
+-        const uint8_t* base = ip;
+-        size_t matched = 5 + FindMatchLengthWithLimit(
+-            candidate + 5, ip + 5, (size_t)(ip_end - ip) - 5);
+-        if (ip - candidate > MAX_DISTANCE) break;
+-        ip += matched;
+-        last_distance = (int)(base - candidate);  /* > 0 */
+-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
+-        EmitCopyLen(matched, cmd_depth, cmd_bits, cmd_histo,
+-                    storage_ix, storage);
+-        EmitDistance((size_t)last_distance, cmd_depth, cmd_bits,
+-                     cmd_histo, storage_ix, storage);
+-
+-        next_emit = ip;
+-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        /* We could immediately start working at ip now, but to improve
+-           compression we first update "table" with the hashes of some positions
+-           within the last copy. */
+-        {
+-          uint64_t input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
+-          uint32_t prev_hash = HashBytesAtOffset(input_bytes, 0, shift);
+-          uint32_t cur_hash = HashBytesAtOffset(input_bytes, 3, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 3);
+-          prev_hash = HashBytesAtOffset(input_bytes, 1, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 2);
+-          prev_hash = HashBytesAtOffset(input_bytes, 2, shift);
+-          table[prev_hash] = (int)(ip - base_ip - 1);
+-
+-          candidate = base_ip + table[cur_hash];
+-          table[cur_hash] = (int)(ip - base_ip);
+-        }
+-      }
+-
+-      next_hash = Hash(++ip, shift);
+-    }
+-  }
+-
+- emit_remainder:
+-  BROTLI_DCHECK(next_emit <= ip_end);
+-  input += block_size;
+-  input_size -= block_size;
+-  block_size = BROTLI_MIN(size_t, input_size, kMergeBlockSize);
+-
+-  /* Decide if we want to continue this meta-block instead of emitting the
+-     last insert-only command. */
+-  if (input_size > 0 &&
+-      total_block_size + block_size <= (1 << 20) &&
+-      ShouldMergeBlock(input, block_size, lit_depth)) {
+-    BROTLI_DCHECK(total_block_size > (1 << 16));
+-    /* Update the size of the current meta-block and continue emitting commands.
+-       We can do this because the current size and the new size both have 5
+-       nibbles. */
+-    total_block_size += block_size;
+-    UpdateBits(20, (uint32_t)(total_block_size - 1), mlen_storage_ix, storage);
+-    goto emit_commands;
+-  }
+-
+-  /* Emit the remaining bytes as literals. */
+-  if (next_emit < ip_end) {
+-    const size_t insert = (size_t)(ip_end - next_emit);
+-    if (BROTLI_PREDICT_TRUE(insert < 6210)) {
+-      EmitInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
+-                    storage_ix, storage);
+-      EmitLiterals(next_emit, insert, lit_depth, lit_bits, storage_ix, storage);
+-    } else if (ShouldUseUncompressedMode(metablock_start, next_emit, insert,
+-                                         literal_ratio)) {
+-      EmitUncompressedMetaBlock(metablock_start, ip_end, mlen_storage_ix - 3,
+-                                storage_ix, storage);
+-    } else {
+-      EmitLongInsertLen(insert, cmd_depth, cmd_bits, cmd_histo,
+-                        storage_ix, storage);
+-      EmitLiterals(next_emit, insert, lit_depth, lit_bits,
+-                   storage_ix, storage);
+-    }
+-  }
+-  next_emit = ip_end;
+-
+-next_block:
+-  /* If we have more data, write a new meta-block header and prefix codes and
+-     then continue emitting commands. */
+-  if (input_size > 0) {
+-    metablock_start = input;
+-    block_size = BROTLI_MIN(size_t, input_size, kFirstBlockSize);
+-    total_block_size = block_size;
+-    /* Save the bit position of the MLEN field of the meta-block header, so that
+-       we can update it later if we decide to extend this meta-block. */
+-    mlen_storage_ix = *storage_ix + 3;
+-    BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
+-    /* No block splits, no contexts. */
+-    BrotliWriteBits(13, 0, storage_ix, storage);
+-    literal_ratio = BuildAndStoreLiteralPrefixCode(
+-        m, input, block_size, lit_depth, lit_bits, storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    BuildAndStoreCommandPrefixCode(cmd_histo, cmd_depth, cmd_bits,
+-                                   storage_ix, storage);
+-    goto emit_commands;
+-  }
+-
+-  if (!is_last) {
+-    /* If this is not the last block, update the command and distance prefix
+-       codes for the next block and store the compressed forms. */
+-    cmd_code[0] = 0;
+-    *cmd_code_numbits = 0;
+-    BuildAndStoreCommandPrefixCode(cmd_histo, cmd_depth, cmd_bits,
+-                                   cmd_code_numbits, cmd_code);
+-  }
+-}
+-
+-#define FOR_TABLE_BITS_(X) X(9) X(11) X(13) X(15)
+-
+-#define BAKE_METHOD_PARAM_(B) \
+-static BROTLI_NOINLINE void BrotliCompressFragmentFastImpl ## B(             \
+-    MemoryManager* m, const uint8_t* input, size_t input_size,               \
+-    BROTLI_BOOL is_last, int* table, uint8_t cmd_depth[128],                 \
+-    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,     \
+-    size_t* storage_ix, uint8_t* storage) {                                  \
+-  BrotliCompressFragmentFastImpl(m, input, input_size, is_last, table, B,    \
+-      cmd_depth, cmd_bits, cmd_code_numbits, cmd_code, storage_ix, storage); \
+-}
+-FOR_TABLE_BITS_(BAKE_METHOD_PARAM_)
+-#undef BAKE_METHOD_PARAM_
+-
+-void BrotliCompressFragmentFast(
+-    MemoryManager* m, const uint8_t* input, size_t input_size,
+-    BROTLI_BOOL is_last, int* table, size_t table_size, uint8_t cmd_depth[128],
+-    uint16_t cmd_bits[128], size_t* cmd_code_numbits, uint8_t* cmd_code,
+-    size_t* storage_ix, uint8_t* storage) {
+-  const size_t initial_storage_ix = *storage_ix;
+-  const size_t table_bits = Log2FloorNonZero(table_size);
+-
+-  if (input_size == 0) {
+-    BROTLI_DCHECK(is_last);
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+-    *storage_ix = (*storage_ix + 7u) & ~7u;
+-    return;
+-  }
+-
+-  switch (table_bits) {
+-#define CASE_(B)                                                     \
+-    case B:                                                          \
+-      BrotliCompressFragmentFastImpl ## B(                           \
+-          m, input, input_size, is_last, table, cmd_depth, cmd_bits, \
+-          cmd_code_numbits, cmd_code, storage_ix, storage);          \
+-      break;
+-    FOR_TABLE_BITS_(CASE_)
+-#undef CASE_
+-    default: BROTLI_DCHECK(0); break;
+-  }
+-
+-  /* If output is larger than single uncompressed block, rewrite it. */
+-  if (*storage_ix - initial_storage_ix > 31 + (input_size << 3)) {
+-    EmitUncompressedMetaBlock(input, input + input_size, initial_storage_ix,
+-                              storage_ix, storage);
+-  }
+-
+-  if (is_last) {
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+-    *storage_ix = (*storage_ix + 7u) & ~7u;
+-  }
+-}
+-
+-#undef FOR_TABLE_BITS_
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/compress_fragment.h b/modules/brotli/enc/compress_fragment.h
+deleted file mode 100644
+--- a/modules/brotli/enc/compress_fragment.h
++++ /dev/null
+@@ -1,61 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function for fast encoding of an input fragment, independently from the input
+-   history. This function uses one-pass processing: when we find a backward
+-   match, we immediately emit the corresponding command and literal codes to
+-   the bit stream. */
+-
+-#ifndef BROTLI_ENC_COMPRESS_FRAGMENT_H_
+-#define BROTLI_ENC_COMPRESS_FRAGMENT_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./memory.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* Compresses "input" string to the "*storage" buffer as one or more complete
+-   meta-blocks, and updates the "*storage_ix" bit position.
+-
+-   If "is_last" is 1, emits an additional empty last meta-block.
+-
+-   "cmd_depth" and "cmd_bits" contain the command and distance prefix codes
+-   (see comment in encode.h) used for the encoding of this input fragment.
+-   If "is_last" is 0, they are updated to reflect the statistics
+-   of this input fragment, to be used for the encoding of the next fragment.
+-
+-   "*cmd_code_numbits" is the number of bits of the compressed representation
+-   of the command and distance prefix codes, and "cmd_code" is an array of
+-   at least "(*cmd_code_numbits + 7) >> 3" size that contains the compressed
+-   command and distance prefix codes. If "is_last" is 0, these are also
+-   updated to represent the updated "cmd_depth" and "cmd_bits".
+-
+-   REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
+-   REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
+-   REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+-   REQUIRES: "table_size" is an odd (9, 11, 13, 15) power of two
+-   OUTPUT: maximal copy distance <= |input_size|
+-   OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */
+-BROTLI_INTERNAL void BrotliCompressFragmentFast(MemoryManager* m,
+-                                                const uint8_t* input,
+-                                                size_t input_size,
+-                                                BROTLI_BOOL is_last,
+-                                                int* table, size_t table_size,
+-                                                uint8_t cmd_depth[128],
+-                                                uint16_t cmd_bits[128],
+-                                                size_t* cmd_code_numbits,
+-                                                uint8_t* cmd_code,
+-                                                size_t* storage_ix,
+-                                                uint8_t* storage);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_COMPRESS_FRAGMENT_H_ */
+diff --git a/modules/brotli/enc/compress_fragment_two_pass.c b/modules/brotli/enc/compress_fragment_two_pass.c
+deleted file mode 100644
+--- a/modules/brotli/enc/compress_fragment_two_pass.c
++++ /dev/null
+@@ -1,645 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function for fast encoding of an input fragment, independently from the input
+-   history. This function uses two-pass processing: in the first pass we save
+-   the found backward matches and literal bytes into a buffer, and in the
+-   second pass we emit them into the bit stream using prefix codes built based
+-   on the actual command and literal byte histograms. */
+-
+-#include "./compress_fragment_two_pass.h"
+-
+-#include <string.h>  /* memcmp, memcpy, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./bit_cost.h"
+-#include "./brotli_bit_stream.h"
+-#include "./entropy_encode.h"
+-#include "./fast_log.h"
+-#include "./find_match_length.h"
+-#include "./memory.h"
+-#include "./write_bits.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define MAX_DISTANCE (long)BROTLI_MAX_BACKWARD_LIMIT(18)
+-
+-/* kHashMul32 multiplier has these properties:
+-   * The multiplier must be odd. Otherwise we may lose the highest bit.
+-   * No long streaks of ones or zeros.
+-   * There is no effort to ensure that it is a prime, the oddity is enough
+-     for this use.
+-   * The number has been tuned heuristically against compression benchmarks. */
+-static const uint32_t kHashMul32 = 0x1E35A7BD;
+-
+-static BROTLI_INLINE uint32_t Hash(const uint8_t* p,
+-    size_t shift, size_t length) {
+-  const uint64_t h =
+-      (BROTLI_UNALIGNED_LOAD64LE(p) << ((8 - length) * 8)) * kHashMul32;
+-  return (uint32_t)(h >> shift);
+-}
+-
+-static BROTLI_INLINE uint32_t HashBytesAtOffset(uint64_t v, size_t offset,
+-    size_t shift, size_t length) {
+-  BROTLI_DCHECK(offset <= 8 - length);
+-  {
+-    const uint64_t h = ((v >> (8 * offset)) << ((8 - length) * 8)) * kHashMul32;
+-    return (uint32_t)(h >> shift);
+-  }
+-}
+-
+-static BROTLI_INLINE BROTLI_BOOL IsMatch(const uint8_t* p1, const uint8_t* p2,
+-    size_t length) {
+-  if (BrotliUnalignedRead32(p1) == BrotliUnalignedRead32(p2)) {
+-    if (length == 4) return BROTLI_TRUE;
+-    return TO_BROTLI_BOOL(p1[4] == p2[4] && p1[5] == p2[5]);
+-  }
+-  return BROTLI_FALSE;
+-}
+-
+-/* Builds a command and distance prefix code (each 64 symbols) into "depth" and
+-   "bits" based on "histogram" and stores it into the bit stream. */
+-static void BuildAndStoreCommandPrefixCode(
+-    const uint32_t histogram[128],
+-    uint8_t depth[128], uint16_t bits[128],
+-    size_t* storage_ix, uint8_t* storage) {
+-  /* Tree size for building a tree over 64 symbols is 2 * 64 + 1. */
+-  HuffmanTree tree[129];
+-  uint8_t cmd_depth[BROTLI_NUM_COMMAND_SYMBOLS] = { 0 };
+-  uint16_t cmd_bits[64];
+-  BrotliCreateHuffmanTree(histogram, 64, 15, tree, depth);
+-  BrotliCreateHuffmanTree(&histogram[64], 64, 14, tree, &depth[64]);
+-  /* We have to jump through a few hoops here in order to compute
+-     the command bits because the symbols are in a different order than in
+-     the full alphabet. This looks complicated, but having the symbols
+-     in this order in the command bits saves a few branches in the Emit*
+-     functions. */
+-  memcpy(cmd_depth, depth + 24, 24);
+-  memcpy(cmd_depth + 24, depth, 8);
+-  memcpy(cmd_depth + 32, depth + 48, 8);
+-  memcpy(cmd_depth + 40, depth + 8, 8);
+-  memcpy(cmd_depth + 48, depth + 56, 8);
+-  memcpy(cmd_depth + 56, depth + 16, 8);
+-  BrotliConvertBitDepthsToSymbols(cmd_depth, 64, cmd_bits);
+-  memcpy(bits, cmd_bits + 24, 16);
+-  memcpy(bits + 8, cmd_bits + 40, 16);
+-  memcpy(bits + 16, cmd_bits + 56, 16);
+-  memcpy(bits + 24, cmd_bits, 48);
+-  memcpy(bits + 48, cmd_bits + 32, 16);
+-  memcpy(bits + 56, cmd_bits + 48, 16);
+-  BrotliConvertBitDepthsToSymbols(&depth[64], 64, &bits[64]);
+-  {
+-    /* Create the bit length array for the full command alphabet. */
+-    size_t i;
+-    memset(cmd_depth, 0, 64);  /* only 64 first values were used */
+-    memcpy(cmd_depth, depth + 24, 8);
+-    memcpy(cmd_depth + 64, depth + 32, 8);
+-    memcpy(cmd_depth + 128, depth + 40, 8);
+-    memcpy(cmd_depth + 192, depth + 48, 8);
+-    memcpy(cmd_depth + 384, depth + 56, 8);
+-    for (i = 0; i < 8; ++i) {
+-      cmd_depth[128 + 8 * i] = depth[i];
+-      cmd_depth[256 + 8 * i] = depth[8 + i];
+-      cmd_depth[448 + 8 * i] = depth[16 + i];
+-    }
+-    BrotliStoreHuffmanTree(
+-        cmd_depth, BROTLI_NUM_COMMAND_SYMBOLS, tree, storage_ix, storage);
+-  }
+-  BrotliStoreHuffmanTree(&depth[64], 64, tree, storage_ix, storage);
+-}
+-
+-static BROTLI_INLINE void EmitInsertLen(
+-    uint32_t insertlen, uint32_t** commands) {
+-  if (insertlen < 6) {
+-    **commands = insertlen;
+-  } else if (insertlen < 130) {
+-    const uint32_t tail = insertlen - 2;
+-    const uint32_t nbits = Log2FloorNonZero(tail) - 1u;
+-    const uint32_t prefix = tail >> nbits;
+-    const uint32_t inscode = (nbits << 1) + prefix + 2;
+-    const uint32_t extra = tail - (prefix << nbits);
+-    **commands = inscode | (extra << 8);
+-  } else if (insertlen < 2114) {
+-    const uint32_t tail = insertlen - 66;
+-    const uint32_t nbits = Log2FloorNonZero(tail);
+-    const uint32_t code = nbits + 10;
+-    const uint32_t extra = tail - (1u << nbits);
+-    **commands = code | (extra << 8);
+-  } else if (insertlen < 6210) {
+-    const uint32_t extra = insertlen - 2114;
+-    **commands = 21 | (extra << 8);
+-  } else if (insertlen < 22594) {
+-    const uint32_t extra = insertlen - 6210;
+-    **commands = 22 | (extra << 8);
+-  } else {
+-    const uint32_t extra = insertlen - 22594;
+-    **commands = 23 | (extra << 8);
+-  }
+-  ++(*commands);
+-}
+-
+-static BROTLI_INLINE void EmitCopyLen(size_t copylen, uint32_t** commands) {
+-  if (copylen < 10) {
+-    **commands = (uint32_t)(copylen + 38);
+-  } else if (copylen < 134) {
+-    const size_t tail = copylen - 6;
+-    const size_t nbits = Log2FloorNonZero(tail) - 1;
+-    const size_t prefix = tail >> nbits;
+-    const size_t code = (nbits << 1) + prefix + 44;
+-    const size_t extra = tail - (prefix << nbits);
+-    **commands = (uint32_t)(code | (extra << 8));
+-  } else if (copylen < 2118) {
+-    const size_t tail = copylen - 70;
+-    const size_t nbits = Log2FloorNonZero(tail);
+-    const size_t code = nbits + 52;
+-    const size_t extra = tail - ((size_t)1 << nbits);
+-    **commands = (uint32_t)(code | (extra << 8));
+-  } else {
+-    const size_t extra = copylen - 2118;
+-    **commands = (uint32_t)(63 | (extra << 8));
+-  }
+-  ++(*commands);
+-}
+-
+-static BROTLI_INLINE void EmitCopyLenLastDistance(
+-    size_t copylen, uint32_t** commands) {
+-  if (copylen < 12) {
+-    **commands = (uint32_t)(copylen + 20);
+-    ++(*commands);
+-  } else if (copylen < 72) {
+-    const size_t tail = copylen - 8;
+-    const size_t nbits = Log2FloorNonZero(tail) - 1;
+-    const size_t prefix = tail >> nbits;
+-    const size_t code = (nbits << 1) + prefix + 28;
+-    const size_t extra = tail - (prefix << nbits);
+-    **commands = (uint32_t)(code | (extra << 8));
+-    ++(*commands);
+-  } else if (copylen < 136) {
+-    const size_t tail = copylen - 8;
+-    const size_t code = (tail >> 5) + 54;
+-    const size_t extra = tail & 31;
+-    **commands = (uint32_t)(code | (extra << 8));
+-    ++(*commands);
+-    **commands = 64;
+-    ++(*commands);
+-  } else if (copylen < 2120) {
+-    const size_t tail = copylen - 72;
+-    const size_t nbits = Log2FloorNonZero(tail);
+-    const size_t code = nbits + 52;
+-    const size_t extra = tail - ((size_t)1 << nbits);
+-    **commands = (uint32_t)(code | (extra << 8));
+-    ++(*commands);
+-    **commands = 64;
+-    ++(*commands);
+-  } else {
+-    const size_t extra = copylen - 2120;
+-    **commands = (uint32_t)(63 | (extra << 8));
+-    ++(*commands);
+-    **commands = 64;
+-    ++(*commands);
+-  }
+-}
+-
+-static BROTLI_INLINE void EmitDistance(uint32_t distance, uint32_t** commands) {
+-  uint32_t d = distance + 3;
+-  uint32_t nbits = Log2FloorNonZero(d) - 1;
+-  const uint32_t prefix = (d >> nbits) & 1;
+-  const uint32_t offset = (2 + prefix) << nbits;
+-  const uint32_t distcode = 2 * (nbits - 1) + prefix + 80;
+-  uint32_t extra = d - offset;
+-  **commands = distcode | (extra << 8);
+-  ++(*commands);
+-}
+-
+-/* REQUIRES: len <= 1 << 24. */
+-static void BrotliStoreMetaBlockHeader(
+-    size_t len, BROTLI_BOOL is_uncompressed, size_t* storage_ix,
+-    uint8_t* storage) {
+-  size_t nibbles = 6;
+-  /* ISLAST */
+-  BrotliWriteBits(1, 0, storage_ix, storage);
+-  if (len <= (1U << 16)) {
+-    nibbles = 4;
+-  } else if (len <= (1U << 20)) {
+-    nibbles = 5;
+-  }
+-  BrotliWriteBits(2, nibbles - 4, storage_ix, storage);
+-  BrotliWriteBits(nibbles * 4, len - 1, storage_ix, storage);
+-  /* ISUNCOMPRESSED */
+-  BrotliWriteBits(1, (uint64_t)is_uncompressed, storage_ix, storage);
+-}
+-
+-static BROTLI_INLINE void CreateCommands(const uint8_t* input,
+-    size_t block_size, size_t input_size, const uint8_t* base_ip, int* table,
+-    size_t table_bits, size_t min_match,
+-    uint8_t** literals, uint32_t** commands) {
+-  /* "ip" is the input pointer. */
+-  const uint8_t* ip = input;
+-  const size_t shift = 64u - table_bits;
+-  const uint8_t* ip_end = input + block_size;
+-  /* "next_emit" is a pointer to the first byte that is not covered by a
+-     previous copy. Bytes between "next_emit" and the start of the next copy or
+-     the end of the input will be emitted as literal bytes. */
+-  const uint8_t* next_emit = input;
+-
+-  int last_distance = -1;
+-  const size_t kInputMarginBytes = BROTLI_WINDOW_GAP;
+-
+-  if (BROTLI_PREDICT_TRUE(block_size >= kInputMarginBytes)) {
+-    /* For the last block, we need to keep a 16 bytes margin so that we can be
+-       sure that all distances are at most window size - 16.
+-       For all other blocks, we only need to keep a margin of 5 bytes so that
+-       we don't go over the block size with a copy. */
+-    const size_t len_limit = BROTLI_MIN(size_t, block_size - min_match,
+-                                        input_size - kInputMarginBytes);
+-    const uint8_t* ip_limit = input + len_limit;
+-
+-    uint32_t next_hash;
+-    for (next_hash = Hash(++ip, shift, min_match); ; ) {
+-      /* Step 1: Scan forward in the input looking for a 6-byte-long match.
+-         If we get close to exhausting the input then goto emit_remainder.
+-
+-         Heuristic match skipping: If 32 bytes are scanned with no matches
+-         found, start looking only at every other byte. If 32 more bytes are
+-         scanned, look at every third byte, etc.. When a match is found,
+-         immediately go back to looking at every byte. This is a small loss
+-         (~5% performance, ~0.1% density) for compressible data due to more
+-         bookkeeping, but for non-compressible data (such as JPEG) it's a huge
+-         win since the compressor quickly "realizes" the data is incompressible
+-         and doesn't bother looking for matches everywhere.
+-
+-         The "skip" variable keeps track of how many bytes there are since the
+-         last match; dividing it by 32 (ie. right-shifting by five) gives the
+-         number of bytes to move ahead for each iteration. */
+-      uint32_t skip = 32;
+-
+-      const uint8_t* next_ip = ip;
+-      const uint8_t* candidate;
+-
+-      BROTLI_DCHECK(next_emit < ip);
+-trawl:
+-      do {
+-        uint32_t hash = next_hash;
+-        uint32_t bytes_between_hash_lookups = skip++ >> 5;
+-        ip = next_ip;
+-        BROTLI_DCHECK(hash == Hash(ip, shift, min_match));
+-        next_ip = ip + bytes_between_hash_lookups;
+-        if (BROTLI_PREDICT_FALSE(next_ip > ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        next_hash = Hash(next_ip, shift, min_match);
+-        candidate = ip - last_distance;
+-        if (IsMatch(ip, candidate, min_match)) {
+-          if (BROTLI_PREDICT_TRUE(candidate < ip)) {
+-            table[hash] = (int)(ip - base_ip);
+-            break;
+-          }
+-        }
+-        candidate = base_ip + table[hash];
+-        BROTLI_DCHECK(candidate >= base_ip);
+-        BROTLI_DCHECK(candidate < ip);
+-
+-        table[hash] = (int)(ip - base_ip);
+-      } while (BROTLI_PREDICT_TRUE(!IsMatch(ip, candidate, min_match)));
+-
+-      /* Check copy distance. If candidate is not feasible, continue search.
+-         Checking is done outside of hot loop to reduce overhead. */
+-      if (ip - candidate > MAX_DISTANCE) goto trawl;
+-
+-      /* Step 2: Emit the found match together with the literal bytes from
+-         "next_emit", and then see if we can find a next match immediately
+-         afterwards. Repeat until we find no match for the input
+-         without emitting some literal bytes. */
+-
+-      {
+-        /* We have a 6-byte match at ip, and we need to emit bytes in
+-           [next_emit, ip). */
+-        const uint8_t* base = ip;
+-        size_t matched = min_match + FindMatchLengthWithLimit(
+-            candidate + min_match, ip + min_match,
+-            (size_t)(ip_end - ip) - min_match);
+-        int distance = (int)(base - candidate);  /* > 0 */
+-        int insert = (int)(base - next_emit);
+-        ip += matched;
+-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
+-        EmitInsertLen((uint32_t)insert, commands);
+-        memcpy(*literals, next_emit, (size_t)insert);
+-        *literals += insert;
+-        if (distance == last_distance) {
+-          **commands = 64;
+-          ++(*commands);
+-        } else {
+-          EmitDistance((uint32_t)distance, commands);
+-          last_distance = distance;
+-        }
+-        EmitCopyLenLastDistance(matched, commands);
+-
+-        next_emit = ip;
+-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        {
+-          /* We could immediately start working at ip now, but to improve
+-             compression we first update "table" with the hashes of some
+-             positions within the last copy. */
+-          uint64_t input_bytes;
+-          uint32_t cur_hash;
+-          uint32_t prev_hash;
+-          if (min_match == 4) {
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
+-            cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 3);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 2);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 1);
+-          } else {
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 5);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 4);
+-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 3);
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
+-            cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 2);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 1);
+-          }
+-
+-          candidate = base_ip + table[cur_hash];
+-          table[cur_hash] = (int)(ip - base_ip);
+-        }
+-      }
+-
+-      while (ip - candidate <= MAX_DISTANCE &&
+-          IsMatch(ip, candidate, min_match)) {
+-        /* We have a 6-byte match at ip, and no need to emit any
+-           literal bytes prior to ip. */
+-        const uint8_t* base = ip;
+-        size_t matched = min_match + FindMatchLengthWithLimit(
+-            candidate + min_match, ip + min_match,
+-            (size_t)(ip_end - ip) - min_match);
+-        ip += matched;
+-        last_distance = (int)(base - candidate);  /* > 0 */
+-        BROTLI_DCHECK(0 == memcmp(base, candidate, matched));
+-        EmitCopyLen(matched, commands);
+-        EmitDistance((uint32_t)last_distance, commands);
+-
+-        next_emit = ip;
+-        if (BROTLI_PREDICT_FALSE(ip >= ip_limit)) {
+-          goto emit_remainder;
+-        }
+-        {
+-          /* We could immediately start working at ip now, but to improve
+-             compression we first update "table" with the hashes of some
+-             positions within the last copy. */
+-          uint64_t input_bytes;
+-          uint32_t cur_hash;
+-          uint32_t prev_hash;
+-          if (min_match == 4) {
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 3);
+-            cur_hash = HashBytesAtOffset(input_bytes, 3, shift, min_match);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 3);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 2);
+-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 1);
+-          } else {
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 5);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 5);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 4);
+-            prev_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 3);
+-            input_bytes = BROTLI_UNALIGNED_LOAD64LE(ip - 2);
+-            cur_hash = HashBytesAtOffset(input_bytes, 2, shift, min_match);
+-            prev_hash = HashBytesAtOffset(input_bytes, 0, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 2);
+-            prev_hash = HashBytesAtOffset(input_bytes, 1, shift, min_match);
+-            table[prev_hash] = (int)(ip - base_ip - 1);
+-          }
+-
+-          candidate = base_ip + table[cur_hash];
+-          table[cur_hash] = (int)(ip - base_ip);
+-        }
+-      }
+-
+-      next_hash = Hash(++ip, shift, min_match);
+-    }
+-  }
+-
+-emit_remainder:
+-  BROTLI_DCHECK(next_emit <= ip_end);
+-  /* Emit the remaining bytes as literals. */
+-  if (next_emit < ip_end) {
+-    const uint32_t insert = (uint32_t)(ip_end - next_emit);
+-    EmitInsertLen(insert, commands);
+-    memcpy(*literals, next_emit, insert);
+-    *literals += insert;
+-  }
+-}
+-
+-static void StoreCommands(MemoryManager* m,
+-                          const uint8_t* literals, const size_t num_literals,
+-                          const uint32_t* commands, const size_t num_commands,
+-                          size_t* storage_ix, uint8_t* storage) {
+-  static const uint32_t kNumExtraBits[128] = {
+-    0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 14, 24,
+-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4,
+-    0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 24,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
+-    9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16,
+-    17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24,
+-  };
+-  static const uint32_t kInsertOffset[24] = {
+-    0, 1, 2, 3, 4, 5, 6, 8, 10, 14, 18, 26, 34, 50, 66, 98, 130, 194, 322, 578,
+-    1090, 2114, 6210, 22594,
+-  };
+-
+-  uint8_t lit_depths[256];
+-  uint16_t lit_bits[256];
+-  uint32_t lit_histo[256] = { 0 };
+-  uint8_t cmd_depths[128] = { 0 };
+-  uint16_t cmd_bits[128] = { 0 };
+-  uint32_t cmd_histo[128] = { 0 };
+-  size_t i;
+-  for (i = 0; i < num_literals; ++i) {
+-    ++lit_histo[literals[i]];
+-  }
+-  BrotliBuildAndStoreHuffmanTreeFast(m, lit_histo, num_literals,
+-                                     /* max_bits = */ 8,
+-                                     lit_depths, lit_bits,
+-                                     storage_ix, storage);
+-  if (BROTLI_IS_OOM(m)) return;
+-
+-  for (i = 0; i < num_commands; ++i) {
+-    const uint32_t code = commands[i] & 0xFF;
+-    BROTLI_DCHECK(code < 128);
+-    ++cmd_histo[code];
+-  }
+-  cmd_histo[1] += 1;
+-  cmd_histo[2] += 1;
+-  cmd_histo[64] += 1;
+-  cmd_histo[84] += 1;
+-  BuildAndStoreCommandPrefixCode(cmd_histo, cmd_depths, cmd_bits,
+-                                 storage_ix, storage);
+-
+-  for (i = 0; i < num_commands; ++i) {
+-    const uint32_t cmd = commands[i];
+-    const uint32_t code = cmd & 0xFF;
+-    const uint32_t extra = cmd >> 8;
+-    BROTLI_DCHECK(code < 128);
+-    BrotliWriteBits(cmd_depths[code], cmd_bits[code], storage_ix, storage);
+-    BrotliWriteBits(kNumExtraBits[code], extra, storage_ix, storage);
+-    if (code < 24) {
+-      const uint32_t insert = kInsertOffset[code] + extra;
+-      uint32_t j;
+-      for (j = 0; j < insert; ++j) {
+-        const uint8_t lit = *literals;
+-        BrotliWriteBits(lit_depths[lit], lit_bits[lit], storage_ix, storage);
+-        ++literals;
+-      }
+-    }
+-  }
+-}
+-
+-/* Acceptable loss for uncompressible speedup is 2% */
+-#define MIN_RATIO 0.98
+-#define SAMPLE_RATE 43
+-
+-static BROTLI_BOOL ShouldCompress(
+-    const uint8_t* input, size_t input_size, size_t num_literals) {
+-  double corpus_size = (double)input_size;
+-  if ((double)num_literals < MIN_RATIO * corpus_size) {
+-    return BROTLI_TRUE;
+-  } else {
+-    uint32_t literal_histo[256] = { 0 };
+-    const double max_total_bit_cost = corpus_size * 8 * MIN_RATIO / SAMPLE_RATE;
+-    size_t i;
+-    for (i = 0; i < input_size; i += SAMPLE_RATE) {
+-      ++literal_histo[input[i]];
+-    }
+-    return TO_BROTLI_BOOL(BitsEntropy(literal_histo, 256) < max_total_bit_cost);
+-  }
+-}
+-
+-static void RewindBitPosition(const size_t new_storage_ix,
+-                              size_t* storage_ix, uint8_t* storage) {
+-  const size_t bitpos = new_storage_ix & 7;
+-  const size_t mask = (1u << bitpos) - 1;
+-  storage[new_storage_ix >> 3] &= (uint8_t)mask;
+-  *storage_ix = new_storage_ix;
+-}
+-
+-static void EmitUncompressedMetaBlock(const uint8_t* input, size_t input_size,
+-                                      size_t* storage_ix, uint8_t* storage) {
+-  BrotliStoreMetaBlockHeader(input_size, 1, storage_ix, storage);
+-  *storage_ix = (*storage_ix + 7u) & ~7u;
+-  memcpy(&storage[*storage_ix >> 3], input, input_size);
+-  *storage_ix += input_size << 3;
+-  storage[*storage_ix >> 3] = 0;
+-}
+-
+-static BROTLI_INLINE void BrotliCompressFragmentTwoPassImpl(
+-    MemoryManager* m, const uint8_t* input, size_t input_size,
+-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,
+-    int* table, size_t table_bits, size_t min_match,
+-    size_t* storage_ix, uint8_t* storage) {
+-  /* Save the start of the first block for position and distance computations.
+-  */
+-  const uint8_t* base_ip = input;
+-  BROTLI_UNUSED(is_last);
+-
+-  while (input_size > 0) {
+-    size_t block_size =
+-        BROTLI_MIN(size_t, input_size, kCompressFragmentTwoPassBlockSize);
+-    uint32_t* commands = command_buf;
+-    uint8_t* literals = literal_buf;
+-    size_t num_literals;
+-    CreateCommands(input, block_size, input_size, base_ip, table,
+-                   table_bits, min_match, &literals, &commands);
+-    num_literals = (size_t)(literals - literal_buf);
+-    if (ShouldCompress(input, block_size, num_literals)) {
+-      const size_t num_commands = (size_t)(commands - command_buf);
+-      BrotliStoreMetaBlockHeader(block_size, 0, storage_ix, storage);
+-      /* No block splits, no contexts. */
+-      BrotliWriteBits(13, 0, storage_ix, storage);
+-      StoreCommands(m, literal_buf, num_literals, command_buf, num_commands,
+-                    storage_ix, storage);
+-      if (BROTLI_IS_OOM(m)) return;
+-    } else {
+-      /* Since we did not find many backward references and the entropy of
+-         the data is close to 8 bits, we can simply emit an uncompressed block.
+-         This makes compression speed of uncompressible data about 3x faster. */
+-      EmitUncompressedMetaBlock(input, block_size, storage_ix, storage);
+-    }
+-    input += block_size;
+-    input_size -= block_size;
+-  }
+-}
+-
+-#define FOR_TABLE_BITS_(X) \
+-  X(8) X(9) X(10) X(11) X(12) X(13) X(14) X(15) X(16) X(17)
+-
+-#define BAKE_METHOD_PARAM_(B)                                                  \
+-static BROTLI_NOINLINE void BrotliCompressFragmentTwoPassImpl ## B(            \
+-    MemoryManager* m, const uint8_t* input, size_t input_size,                 \
+-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,          \
+-    int* table, size_t* storage_ix, uint8_t* storage) {                        \
+-  size_t min_match = (B <= 15) ? 4 : 6;                                        \
+-  BrotliCompressFragmentTwoPassImpl(m, input, input_size, is_last, command_buf,\
+-      literal_buf, table, B, min_match, storage_ix, storage);                  \
+-}
+-FOR_TABLE_BITS_(BAKE_METHOD_PARAM_)
+-#undef BAKE_METHOD_PARAM_
+-
+-void BrotliCompressFragmentTwoPass(
+-    MemoryManager* m, const uint8_t* input, size_t input_size,
+-    BROTLI_BOOL is_last, uint32_t* command_buf, uint8_t* literal_buf,
+-    int* table, size_t table_size, size_t* storage_ix, uint8_t* storage) {
+-  const size_t initial_storage_ix = *storage_ix;
+-  const size_t table_bits = Log2FloorNonZero(table_size);
+-  switch (table_bits) {
+-#define CASE_(B)                                      \
+-    case B:                                           \
+-      BrotliCompressFragmentTwoPassImpl ## B(         \
+-          m, input, input_size, is_last, command_buf, \
+-          literal_buf, table, storage_ix, storage);   \
+-      break;
+-    FOR_TABLE_BITS_(CASE_)
+-#undef CASE_
+-    default: BROTLI_DCHECK(0); break;
+-  }
+-
+-  /* If output is larger than single uncompressed block, rewrite it. */
+-  if (*storage_ix - initial_storage_ix > 31 + (input_size << 3)) {
+-    RewindBitPosition(initial_storage_ix, storage_ix, storage);
+-    EmitUncompressedMetaBlock(input, input_size, storage_ix, storage);
+-  }
+-
+-  if (is_last) {
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* islast */
+-    BrotliWriteBits(1, 1, storage_ix, storage);  /* isempty */
+-    *storage_ix = (*storage_ix + 7u) & ~7u;
+-  }
+-}
+-
+-#undef FOR_TABLE_BITS_
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/compress_fragment_two_pass.h b/modules/brotli/enc/compress_fragment_two_pass.h
+deleted file mode 100644
+--- a/modules/brotli/enc/compress_fragment_two_pass.h
++++ /dev/null
+@@ -1,54 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function for fast encoding of an input fragment, independently from the input
+-   history. This function uses two-pass processing: in the first pass we save
+-   the found backward matches and literal bytes into a buffer, and in the
+-   second pass we emit them into the bit stream using prefix codes built based
+-   on the actual command and literal byte histograms. */
+-
+-#ifndef BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_
+-#define BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./memory.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static const size_t kCompressFragmentTwoPassBlockSize = 1 << 17;
+-
+-/* Compresses "input" string to the "*storage" buffer as one or more complete
+-   meta-blocks, and updates the "*storage_ix" bit position.
+-
+-   If "is_last" is 1, emits an additional empty last meta-block.
+-
+-   REQUIRES: "input_size" is greater than zero, or "is_last" is 1.
+-   REQUIRES: "input_size" is less or equal to maximal metablock size (1 << 24).
+-   REQUIRES: "command_buf" and "literal_buf" point to at least
+-              kCompressFragmentTwoPassBlockSize long arrays.
+-   REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero.
+-   REQUIRES: "table_size" is a power of two
+-   OUTPUT: maximal copy distance <= |input_size|
+-   OUTPUT: maximal copy distance <= BROTLI_MAX_BACKWARD_LIMIT(18) */
+-BROTLI_INTERNAL void BrotliCompressFragmentTwoPass(MemoryManager* m,
+-                                                   const uint8_t* input,
+-                                                   size_t input_size,
+-                                                   BROTLI_BOOL is_last,
+-                                                   uint32_t* command_buf,
+-                                                   uint8_t* literal_buf,
+-                                                   int* table,
+-                                                   size_t table_size,
+-                                                   size_t* storage_ix,
+-                                                   uint8_t* storage);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_COMPRESS_FRAGMENT_TWO_PASS_H_ */
+diff --git a/modules/brotli/enc/dictionary_hash.c b/modules/brotli/enc/dictionary_hash.c
+deleted file mode 100644
+--- a/modules/brotli/enc/dictionary_hash.c
++++ /dev/null
+@@ -1,1846 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Hash table on the 4-byte prefixes of static dictionary words. */
+-
+-#include "../common/platform.h"
+-#include "./dictionary_hash.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-BROTLI_INTERNAL const uint16_t kStaticDictionaryHashWords[32768] = {
+-1002,0,0,0,0,0,0,0,0,683,0,0,0,0,0,0,0,1265,0,0,0,0,0,1431,0,0,0,0,0,0,40,0,0,0,
+-0,155,8,741,0,624,0,0,0,0,0,0,0,0,0,0,0,0,66,503,0,0,0,451,0,0,0,0,0,0,0,835,70,
+-0,0,539,0,0,0,0,0,0,0,0,0,113,0,0,0,0,718,0,0,0,0,0,0,520,0,1070,0,0,0,0,0,1515,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,78,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,610,0,0,750,0,0,0,307,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,964,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,999,0,0,0,0,0,0,0,0,
+-645,75,0,649,52,282,0,200,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1621,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,211,225,0,0,687,718,0,0,110,0,58,0,0,0,0,0,0,345,0,0,301,0,0,
+-0,203,0,0,1154,674,1949,0,0,0,0,0,0,0,0,0,259,0,0,0,0,0,0,0,1275,0,0,0,1231,254,
+-0,0,0,0,0,0,0,277,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,248,0,0,800,0,0,0,29,
+-116,100,490,0,0,0,0,0,1641,0,543,0,0,0,0,41,181,0,657,0,0,202,25,0,0,0,0,0,0,0,
+-0,0,0,423,0,0,0,113,0,0,0,927,963,0,976,0,206,0,0,0,0,0,0,0,0,0,2002,0,0,0,0,0,
+-0,0,0,0,0,0,696,0,1170,0,0,0,0,226,13,0,769,678,551,0,0,0,0,0,0,57,0,0,0,10,188,
+-0,0,0,624,0,0,0,0,0,0,0,0,0,1941,130,0,0,0,0,378,269,0,0,528,0,1146,0,0,0,1105,
+-0,1616,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,656,0,1940,0,0,0,0,0,173,0,0,0,0,0,0,0,0,0,
+-0,0,457,342,810,0,0,0,0,620,0,0,0,0,0,0,0,967,95,447,406,0,0,0,477,0,1268,944,
+-1941,0,0,0,629,0,0,0,0,0,375,0,0,0,1636,0,0,0,0,774,0,1,1034,0,0,0,0,0,824,0,0,
+-0,0,0,118,0,0,560,296,0,0,0,0,0,0,0,0,1009,894,0,0,0,0,0,0,0,0,0,0,0,0,0,1474,
+-366,0,0,0,0,0,0,0,0,0,79,1723,0,0,200,0,0,0,0,0,0,0,0,1759,372,0,16,0,943,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,258,0,0,900,1839,707,30,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,2004,0,0,10,115,0,50,0,0,0,0,0,0,0,0,0,0,520,1,0,738,98,482,0,0,0,0,
+-0,0,0,0,0,0,701,2,0,0,0,0,0,0,0,0,557,0,0,0,0,0,0,0,0,0,347,0,0,0,0,572,0,0,0,0,
+-0,0,0,0,0,832,0,0,797,809,0,0,0,0,0,0,0,0,0,0,0,528,0,0,0,861,0,0,294,0,0,0,109,
+-0,0,0,0,0,0,0,0,1187,290,266,0,0,0,0,49,50,748,0,0,466,399,0,0,0,0,0,0,0,378,0,
+-519,0,0,0,0,0,0,0,0,0,0,0,0,667,351,902,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,180,
+-0,0,869,0,0,0,0,0,0,0,260,0,0,0,0,0,0,0,0,0,0,523,36,0,0,587,510,809,29,260,0,0,
+-0,0,0,0,0,0,570,0,565,0,1464,0,0,0,0,0,0,10,0,0,787,399,380,200,0,0,0,0,516,0,
+-844,887,0,0,0,0,0,0,0,44,0,0,0,305,1655,0,0,0,0,0,0,0,0,0,0,0,0,0,0,786,10,0,0,
+-0,0,0,0,0,0,0,2031,0,0,0,0,0,684,0,0,0,0,0,1480,0,0,0,27,0,0,0,395,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,813,511,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,206,
+-496,0,0,0,0,0,909,0,891,0,0,0,0,0,0,0,0,0,687,0,0,0,1342,0,0,0,0,0,0,0,0,0,0,
+-160,41,0,0,0,0,0,0,0,0,0,0,0,1718,778,0,0,0,0,0,0,0,0,0,0,1610,0,0,0,0,0,115,0,
+-0,0,0,314,294,0,0,0,983,178,193,0,0,0,0,0,0,0,0,0,174,0,0,0,0,0,0,0,0,0,0,848,
+-1796,0,0,0,0,0,0,221,0,687,1660,0,0,0,0,262,0,0,179,0,0,0,0,0,66,0,773,0,352,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,35,0,152,0,0,1197,0,0,0,0,0,0,0,0,0,0,0,0,560,0,0,
+-564,0,0,0,797,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,556,0,819,0,0,0,0,0,0,0,0,719,544,
+-637,5,0,0,0,0,0,0,0,0,0,0,0,101,0,1441,0,0,0,893,0,0,0,0,0,0,0,0,0,238,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,1296,0,0,969,1729,314,60,0,0,0,0,0,1144,0,1147,0,0,0,0,0,
+-0,0,0,0,0,437,1853,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,828,0,176,0,0,0,0,0,0,434,39,0,
+-0,0,0,0,159,0,0,0,902,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,270,0,0,0,0,801,556,0,0,
+-0,0,0,0,0,416,19,197,369,0,0,0,0,0,0,0,0,0,28,34,0,757,0,0,898,1553,0,721,0,0,0,
+-0,1012,0,0,0,0,1102,0,898,183,0,0,0,0,0,0,0,136,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,277,0,0,0,435,0,0,0,0,0,1311,0,0,0,0,
+-0,0,211,437,0,0,0,28,0,0,750,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2012,0,702,
+-0,808,0,0,0,0,739,166,0,0,0,0,0,0,719,170,500,0,0,0,0,0,0,0,0,1500,327,0,0,450,
+-0,0,0,1318,0,0,0,1602,0,0,331,754,0,0,0,0,0,1368,0,0,557,0,0,0,799,850,0,0,0,0,
+-0,0,0,0,908,0,0,0,0,0,19,62,459,0,0,0,0,0,0,0,0,0,0,0,0,1802,0,0,0,0,0,0,0,0,0,
+-1397,0,0,0,0,120,238,0,0,0,0,0,0,0,0,0,0,0,1324,0,0,0,0,0,0,0,0,602,201,0,0,164,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,615,0,0,0,0,0,0,0,0,0,0,0,0,0,1243,0,0,0,0,968,0,0,
+-0,0,0,0,882,0,0,0,907,329,100,0,0,0,0,0,0,0,0,0,0,0,176,26,9,0,0,265,256,0,0,0,
+-0,0,0,0,0,0,643,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,127,610,0,0,0,0,973,2001,0,
+-0,0,0,0,0,522,0,0,0,0,0,0,0,0,0,0,0,553,0,0,0,0,0,0,1582,0,1578,0,0,0,0,0,0,0,0,
+-0,0,0,795,0,0,0,432,0,0,0,0,0,0,84,126,0,0,0,0,790,0,377,64,0,1529,0,0,0,0,530,
+-1857,539,1104,0,0,0,0,0,0,0,0,0,0,0,0,977,0,0,0,34,0,0,0,0,0,0,0,0,0,0,0,24,26,
+-0,0,918,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,183,379,0,0,0,0,0,0,0,792,
+-0,0,0,0,0,0,0,0,0,1920,0,0,0,0,0,0,0,0,0,771,0,0,0,1979,0,901,254,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,140,0,0,0,0,0,440,37,0,
+-508,0,0,0,513,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,533,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,752,920,0,1048,0,153,0,
+-0,391,0,0,1952,0,0,0,0,0,0,0,0,0,0,126,0,0,0,0,640,0,483,69,1616,0,0,0,0,0,734,
+-0,0,0,0,0,0,480,0,495,0,472,0,0,0,0,0,0,0,0,874,229,0,0,0,0,948,0,0,0,0,0,0,0,0,
+-1009,748,0,555,0,0,0,0,0,0,193,0,653,0,0,0,0,0,0,0,0,0,0,984,0,0,0,172,0,0,0,0,
+-0,0,0,0,83,1568,0,0,384,0,0,0,0,0,0,0,164,880,0,0,0,0,0,0,0,0,0,0,0,367,121,0,0,
+-828,0,0,0,0,0,0,0,1541,0,0,0,0,0,0,0,343,0,0,0,0,0,0,0,0,561,57,0,0,0,0,0,0,0,
+-926,0,0,0,0,827,0,194,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,
+-0,0,0,896,1249,0,0,0,0,0,1614,0,0,0,860,0,0,0,0,0,0,0,0,964,102,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,899,0,569,0,0,0,0,795,2045,0,0,0,
+-0,0,0,104,52,0,0,0,0,0,604,0,0,0,0,779,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,
+-494,0,677,0,0,0,0,0,0,0,508,0,0,0,0,0,0,0,0,0,1014,0,957,0,0,630,310,0,0,0,570,
+-0,0,449,0,64,537,0,0,0,0,0,0,0,244,0,0,0,0,0,0,0,0,0,0,0,0,0,0,702,1650,49,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,1279,0,0,0,0,0,0,0,896,0,0,
+-178,0,0,0,0,0,0,0,0,0,0,0,0,0,808,695,0,0,0,0,539,1117,0,0,0,0,0,0,0,0,257,0,
+-1003,0,0,0,1,448,0,516,0,0,960,0,125,4,0,1268,30,748,0,0,852,0,0,0,6,0,0,848,
+-236,1385,862,1811,0,0,0,0,698,803,0,0,0,0,0,0,0,610,992,0,0,878,0,1847,0,0,0,0,
+-0,0,0,383,0,1404,0,0,0,0,986,0,347,0,0,0,0,0,0,0,0,0,0,0,592,572,0,1411,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,606,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,1829,0,0,0,0,0,0,0,0,0,0,0,0,700,748,0,0,0,0,0,0,365,0,0,127,0,0,
+-83,198,0,0,0,0,0,0,864,55,0,0,0,0,726,1752,0,0,0,0,0,0,0,0,0,0,0,0,0,1066,0,764,
+-0,0,0,0,683,0,550,309,0,0,874,1212,0,0,0,1364,0,986,381,723,0,0,0,1573,0,0,0,0,
+-0,1025,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1559,0,0,0,0,493,133,0,0,0,0,148,
+-119,0,0,0,0,0,0,537,14,541,0,635,126,0,0,0,495,0,0,0,0,861,998,1009,0,0,0,0,0,0,
+-0,359,368,0,0,0,0,304,1577,0,0,0,0,0,1107,0,0,0,0,0,929,0,0,0,1142,0,0,0,0,289,
+-175,0,432,0,219,0,0,0,0,0,785,0,0,595,0,0,0,0,0,0,0,0,0,0,0,0,0,80,0,0,0,0,0,0,
+-931,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1323,0,0,0,0,290,0,559,1751,127,0,0,0,
+-934,1167,0,963,0,260,0,0,0,573,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-580,1689,0,0,0,0,0,0,0,0,0,1164,0,0,982,1922,0,63,0,0,0,0,0,793,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,67,790,0,0,0,0,0,0,0,0,0,0,391,443,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,271,0,0,0,0,0,0,0,0,0,0,0,1140,0,0,0,0,340,300,0,897,0,0,0,0,0,0,
+-0,0,0,0,890,0,0,0,0,818,321,53,0,0,0,0,0,0,0,0,0,468,0,243,0,870,0,0,0,1765,121,
+-0,0,0,180,518,0,822,419,634,0,0,0,0,0,0,0,0,0,898,0,0,0,0,454,36,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,806,0,0,0,0,0,0,0,0,0,0,0,0,1326,0,104,0,0,0,0,0,0,0,
+-0,0,260,0,0,0,0,0,0,0,0,0,0,0,0,542,45,0,0,263,1516,42,0,0,0,0,0,468,0,1005,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,288,87,0,0,0,0,0,0,0,0,502,988,133,0,0,0,0,0,0,
+-141,0,0,872,1842,0,0,0,0,0,0,0,0,261,619,0,0,0,0,189,246,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,678,0,0,0,0,0,0,0,0,0,0,0,0,285,35,0,517,0,0,0,0,0,0,0,0,0,0,
+-540,214,667,0,74,0,0,125,0,0,0,0,0,761,131,0,0,0,0,0,0,0,0,0,0,0,0,0,333,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1338,94,0,0,0,0,0,0,0,0,0,0,0,0,449,0,646,103,
+-86,641,2028,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,869,87,277,117,39,0,0,0,0,0,0,0,0,938,
+-297,0,0,0,0,558,464,0,0,0,0,0,0,0,0,0,0,731,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1608,0,
+-0,0,0,0,0,0,1429,0,0,733,1010,0,0,338,1656,0,0,0,1038,979,2010,0,0,0,0,0,0,0,
+-1005,0,0,121,0,0,0,219,20,0,0,0,0,0,0,872,1440,0,0,0,683,0,1070,0,0,522,0,0,0,0,
+-439,669,0,0,0,0,0,0,0,0,1245,0,0,0,0,0,1218,0,0,547,233,0,0,0,0,0,0,0,0,0,482,0,
+-0,0,0,0,0,0,886,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,795,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,371,0,0,0,0,0,0,0,0,0,0,0,0,0,622,0,625,0,0,0,339,29,0,0,338,0,0,0,
+-0,130,0,0,0,0,0,0,0,0,0,307,0,0,0,0,0,0,0,0,0,0,2044,0,0,0,0,0,0,0,0,308,770,0,
+-0,0,0,0,1266,0,0,0,0,0,0,0,0,0,400,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,690,739,0,0,
+-0,0,0,0,0,990,0,0,0,1831,0,0,0,0,0,0,0,0,0,0,0,0,0,613,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,763,0,878,0,0,0,977,0,100,0,0,0,0,0,0,0,0,0,463,0,0,0,0,623,318,0,0,296,463,
+-137,0,0,454,0,0,0,1527,58,0,0,0,0,0,0,0,18,48,0,0,0,0,0,729,0,0,0,442,0,0,0,0,
+-40,449,0,853,0,0,0,0,0,0,227,0,0,0,0,0,0,1491,0,0,0,0,0,0,0,0,0,0,161,55,0,450,
+-0,1174,62,0,207,0,0,0,0,0,0,0,0,869,0,0,0,0,80,213,0,0,0,0,0,0,0,0,0,0,354,820,
+-0,0,747,0,0,0,954,0,0,1073,0,556,0,0,0,692,0,191,0,804,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,831,162,0,0,35,0,0,0,0,0,0,0,0,1235,0,0,0,0,0,1234,0,0,
+-0,0,0,0,0,0,0,0,96,0,0,0,0,0,0,0,149,0,0,0,902,204,0,0,833,0,287,366,0,0,0,0,0,
+-0,992,2020,0,0,0,0,0,0,0,0,0,0,0,356,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,784,0,0,567,
+-630,0,0,0,539,0,0,27,0,0,0,0,0,0,0,0,0,0,755,0,0,0,0,0,0,0,0,0,0,0,0,814,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,987,0,0,255,761,194,0,1086,0,0,0,0,0,0,1016,0,0,1396,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,562,271,913,0,0,0,0,0,0,0,0,320,153,45,475,0,0,
+-0,0,0,0,0,713,0,327,0,0,0,0,0,0,604,552,3,359,0,0,0,0,853,80,0,0,0,0,0,0,0,2016,
+-6,887,0,0,0,0,975,0,961,0,0,0,0,0,916,1891,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,100,101,390,708,0,0,0,587,983,512,0,0,0,0,0,0,0,0,0,0,0,645,0,0,0,851,0,0,0,
+-0,0,498,140,217,0,0,0,1448,0,0,0,0,0,0,0,0,0,905,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-643,105,0,792,0,0,0,0,0,0,0,0,0,0,0,0,56,0,0,0,0,0,0,0,0,0,0,535,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1748,0,0,0,0,0,754,0,0,0,0,0,0,0,0,0,0,0,0,91,0,0,1565,0,91,792,
+-939,3,370,0,0,0,0,95,0,0,0,0,551,7,619,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1150,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,671,0,0,0,0,0,888,368,149,0,0,105,1134,0,983,0,0,458,31,
+-0,643,0,0,0,312,0,740,0,0,0,1642,0,0,0,0,0,0,0,236,0,0,0,0,0,0,0,59,68,0,0,0,0,
+-0,867,795,0,0,0,0,970,1977,0,0,0,0,0,0,0,1148,0,775,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,970,0,0,0,0,0,0,0,0,0,665,71,0,0,0,0,827,0,0,0,0,0,0,0,0,0,
+-0,479,0,0,0,0,0,0,0,0,99,607,0,0,0,0,0,0,0,1960,0,0,0,793,0,0,871,41,0,0,241,94,
+-0,0,0,0,209,0,0,1497,0,0,0,0,0,0,0,0,0,98,0,0,0,463,0,0,0,0,291,0,0,0,0,0,0,0,0,
+-0,0,984,0,0,0,0,0,205,0,0,0,0,0,0,205,42,0,801,0,0,0,0,0,635,0,0,533,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,371,0,1282,0,0,0,825,0,0,0,0,0,0,0,0,0,357,879,467,0,317,0,0,
+-0,0,0,0,0,924,0,0,0,0,849,1795,0,0,0,0,895,1799,43,0,0,0,0,0,0,0,0,0,0,1820,0,0,
+-0,0,0,0,0,525,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,110,0,493,0,174,417,0,0,
+-0,0,0,583,733,0,0,0,0,0,0,481,215,0,0,0,0,477,0,0,0,0,0,0,0,0,308,0,0,0,0,0,0,0,
+-0,297,126,0,0,361,1551,0,0,0,0,0,0,871,1807,0,0,0,0,0,1307,0,685,0,0,0,0,0,0,0,
+-797,0,858,0,565,0,0,0,0,0,0,0,0,0,0,0,0,434,252,826,0,0,0,0,0,0,791,0,0,0,0,509,
+-231,178,601,0,0,0,0,0,0,0,0,43,1591,0,0,0,0,0,1683,0,0,0,0,45,0,0,0,0,0,0,0,0,0,
+-0,1120,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,556,494,0,398,0,0,0,1030,0,0,0,0,0,0,
+-168,0,0,0,0,0,0,0,0,0,0,973,0,642,0,0,0,0,0,0,0,0,0,1615,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,378,594,0,1093,0,679,112,0,0,0,0,1492,540,1374,714,
+-1486,0,0,0,0,825,1511,0,0,0,0,0,0,0,0,0,0,0,0,0,952,0,0,736,143,0,700,0,1540,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1557,0,0,0,860,990,0,0,0,807,0,0,0,0,0,131,
+-515,0,646,0,0,0,0,117,728,508,121,0,0,0,0,0,0,357,0,0,0,0,0,0,237,0,0,0,0,0,0,0,
+-0,0,1784,0,0,0,0,0,0,0,0,0,0,0,713,348,1536,0,738,0,0,0,0,0,0,0,434,0,0,0,0,0,0,
+-366,1877,39,0,0,0,0,0,0,580,0,0,0,0,0,0,0,0,0,0,0,0,0,0,873,0,0,0,0,171,0,625,
+-550,107,343,943,0,0,0,0,0,0,0,768,0,0,0,0,0,0,0,799,0,0,0,894,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1673,0,0,0,0,0,0,0,0,0,0,0,1052,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-272,0,441,0,0,3,9,0,0,0,1182,0,1346,0,0,0,0,0,0,0,0,682,0,0,1004,24,0,0,968,0,0,
+-0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,185,0,0,0,578,
+-474,0,0,0,0,0,0,0,0,0,0,0,0,0,0,113,530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,556,0,0,0,0,0,0,16,1317,0,0,97,0,0,0,703,0,0,0,0,0,0,0,0,892,0,0,0,1571,0,0,
+-426,186,0,1101,0,0,0,0,0,0,0,0,937,585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,644,291,
+-0,0,0,0,749,0,162,0,0,381,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,762,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,628,21,0,0,0,0,0,0,0,0,919,0,0,0,0,0,0,0,0,0,
+-633,0,0,0,0,332,0,0,0,0,0,0,0,0,0,1489,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,832,398,0,645,0,0,0,13,0,0,0,0,0,0,0,0,0,0,20,0,800,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,1993,0,0,0,0,769,0,0,0,665,0,0,0,0,0,0,0,0,0,0,1426,0,0,0,0,60,0,0,0,
+-641,1874,0,644,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1757,0,0,0,0,0,937,0,1652,0,654,0,
+-0,0,0,0,0,0,527,0,0,0,0,0,0,0,0,0,0,0,0,0,226,0,0,0,0,0,1486,0,0,0,0,0,0,0,0,0,
+-0,0,325,0,0,0,0,0,0,0,1345,0,0,91,0,404,0,0,0,0,0,0,0,0,0,0,0,0,973,0,0,0,0,0,0,
+-0,1176,0,549,0,0,0,0,0,0,0,0,0,0,976,0,0,0,0,0,21,0,0,0,0,0,51,0,0,0,0,314,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,198,6,0,1093,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,1776,0,0,0,0,0,1528,0,419,0,0,0,0,0,0,0,0,76,138,0,0,0,0,638,29,0,0,0,0,
+-0,0,0,1418,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1710,0,0,0,0,0,
+-0,0,0,0,0,0,0,532,23,0,0,0,0,0,0,0,862,0,0,946,592,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,70,0,0,0,0,0,0,0,0,0,812,0,0,0,76,0,0,988,0,442,0,0,0,896,0,0,0,0,0,0,
+-483,0,0,0,0,1709,0,0,0,0,0,0,119,0,0,0,117,0,309,0,0,0,0,0,596,976,0,0,0,0,0,0,
+-0,0,0,0,0,768,0,0,0,0,0,0,0,0,0,518,0,0,0,0,0,0,0,0,0,0,0,0,0,0,863,0,0,0,24,
+-145,1020,0,0,1984,0,0,0,0,0,0,0,658,0,0,0,0,0,0,0,0,0,0,106,1827,0,1010,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,582,87,0,0,0,0,0,0,0,267,0,0,0,703,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,496,0,0,0,0,1121,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,249,561,0,0,0,0,0,
+-0,0,760,0,0,154,0,0,0,255,0,419,323,0,0,0,0,0,368,0,0,0,0,0,0,0,0,0,0,522,0,0,0,
+-0,0,0,0,551,562,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,92,0,0,0,0,
+-0,0,0,284,525,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,958,0,0,594,0,0,0,0,0,0,6,479,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,61,0,0,0,0,0,0,0,820,1641,0,1556,0,0,0,0,0,0,0,302,0,0,
+-0,0,0,148,0,0,676,0,0,0,0,0,0,1674,0,0,0,0,0,0,178,0,0,0,0,0,0,0,94,389,0,0,0,0,
+-91,8,0,0,0,0,0,0,0,0,0,0,112,0,0,0,0,0,0,0,0,0,0,747,0,0,0,0,0,0,0,1746,0,0,0,0,
+-0,24,0,1352,158,1530,0,0,718,130,280,1401,0,0,0,0,0,1946,8,0,0,0,0,1607,0,0,0,0,
+-0,0,882,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,417,0,0,0,1597,633,433,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,234,0,0,0,0,0,0,0,0,680,1950,0,0,0,0,249,5,0,0,0,
+-0,0,0,0,0,0,1216,0,1773,0,0,0,0,0,0,0,0,0,0,0,0,0,0,509,180,0,0,0,0,0,0,0,1002,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,931,0,0,0,0,0,0,0,0,747,943,0,1837,0,0,0,0,0,0,0,641,
+-0,0,0,0,280,0,0,0,5,0,0,0,0,0,72,545,0,0,0,0,0,0,0,0,0,742,0,0,254,151,872,0,0,
+-0,0,0,0,0,0,0,0,0,0,921,0,0,517,833,0,1680,0,0,436,251,584,0,0,0,0,0,0,0,0,0,0,
+-0,24,500,0,0,0,0,0,0,0,0,195,1775,514,389,0,0,0,0,0,0,0,743,0,0,0,0,0,0,292,0,0,
+-0,227,1283,774,1805,0,0,0,0,0,0,0,0,0,0,119,81,0,0,0,0,0,0,0,0,0,0,0,0,0,0,913,
+-1910,0,0,0,1826,490,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1162,700,30,
+-0,0,0,721,839,0,0,0,617,0,0,0,0,0,0,0,0,0,169,428,0,0,0,0,0,1648,637,1205,0,0,0,
+-1596,0,0,4,266,0,0,0,0,0,0,0,0,0,0,0,862,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,
+-0,279,157,391,604,0,0,713,945,877,973,0,0,0,0,0,0,0,0,0,0,0,0,0,0,859,567,628,
+-1846,0,0,0,0,0,0,0,0,0,762,0,0,191,0,0,0,0,298,0,0,767,909,0,0,0,0,0,0,0,795,0,
+-0,301,0,0,1970,0,0,0,0,0,0,0,0,0,1236,0,0,0,0,0,0,644,369,15,0,160,71,0,0,0,0,0,
+-1447,0,0,0,0,0,0,0,0,735,1255,76,0,0,0,0,0,0,0,0,0,0,474,0,0,0,0,0,0,0,0,0,0,
+-841,0,0,0,0,0,0,0,0,0,0,836,0,0,0,0,0,1622,0,0,735,0,0,0,0,1601,804,1390,394,0,
+-0,0,0,0,0,96,0,289,0,0,35,688,0,0,0,667,0,513,0,0,0,0,0,0,0,2034,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,704,0,1524,0,1078,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,306,
+-0,0,0,0,0,0,0,431,0,1196,0,0,54,0,15,1448,0,1418,0,0,0,0,0,0,0,0,0,907,0,0,0,0,
+-0,0,194,1767,0,0,0,0,0,840,0,900,0,0,0,0,0,0,0,0,0,0,0,1436,0,0,0,0,642,1560,0,
+-0,0,0,0,0,94,386,0,0,0,0,0,0,0,0,0,0,830,416,0,0,20,731,0,0,0,0,0,0,0,0,697,0,0,
+-662,0,0,0,0,0,0,0,0,0,861,0,0,0,0,0,0,0,871,671,864,0,928,7,0,332,0,0,0,0,1055,
+-0,0,0,0,0,0,986,0,0,0,0,0,44,76,0,0,0,0,0,0,0,0,0,0,300,0,0,0,0,0,0,0,175,518,
+-831,1108,0,0,0,836,0,1852,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,843,1804,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,246,0,0,0,610,202,0,0,36,0,0,0,240,654,13,0,0,0,0,0,0,0,
+-0,391,0,403,0,0,0,0,0,0,0,0,0,0,75,0,366,815,0,0,631,0,0,0,0,0,0,0,0,345,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,952,0,0,0,0,0,0,0,0,0,0,0,673,35,662,0,287,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,5,34,0,0,0,0,0,0,0,0,151,0,427,0,0,382,0,0,0,329,0,0,279,0,0,0,
+-0,0,0,0,0,0,0,906,0,0,366,843,0,1443,0,1372,992,0,36,123,0,649,0,0,0,0,0,767,0,
+-1018,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,995,0,0,0,0,0,0,0,72,368,0,0,1345,0,0,0,
+-589,0,0,0,0,0,0,0,0,0,1988,0,0,220,541,0,0,0,686,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,32,196,0,0,0,0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,0,0,0,1452,0,
+-0,0,616,0,0,0,0,0,0,0,0,0,1229,0,0,0,0,0,0,0,0,0,0,667,120,0,0,0,0,0,0,0,1146,0,
+-0,0,0,0,0,0,0,0,0,0,352,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,935,0,1050,0,
+-147,88,0,0,923,0,0,0,0,0,934,0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,341,222,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,
+-637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1159,0,0,0,847,0,0,0,0,0,0,683,0,867,944,0,0,
+-0,0,0,1809,0,0,0,0,0,0,0,0,0,0,395,170,0,0,0,0,0,0,0,0,0,0,618,535,0,1625,0,0,0,
+-0,0,0,0,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,778,0,0,0,0,0,46,0,2032,0,0,37,
+-1458,0,938,363,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,314,0,0,0,0,0,0,889,0,0,0,0,0,0,0,
+-0,0,0,0,462,0,0,0,0,525,0,0,23,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,0,0,0,0,0,
+-0,498,725,0,0,0,0,7,0,0,0,0,773,0,0,0,164,0,0,0,0,0,0,0,0,936,583,659,1462,0,
+-220,0,0,0,0,803,0,0,544,119,0,0,0,0,0,0,0,0,0,0,0,181,176,0,1192,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,1878,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,0,0,0,0,0,
+-944,0,0,0,0,0,0,0,273,0,0,0,0,0,855,0,0,0,0,5,127,0,0,0,0,0,0,0,0,752,230,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,162,0,654,48,156,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,240,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,197,
+-0,0,0,0,0,0,0,963,0,0,0,0,0,0,0,0,0,0,858,0,0,0,0,0,0,0,0,0,0,676,1978,0,0,102,
+-972,0,0,0,0,0,0,0,361,0,461,0,0,0,472,0,0,0,0,0,0,0,0,0,0,0,0,0,0,747,905,0,0,0,
+-155,0,0,0,0,0,0,0,0,0,0,319,163,0,0,0,0,0,0,0,0,0,848,0,0,36,631,0,0,0,0,0,1769,
+-0,0,0,0,0,144,0,0,0,0,0,0,0,0,0,0,369,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,555,247,0,0,
+-996,0,0,189,0,0,0,0,0,0,0,0,0,0,280,0,0,0,0,0,0,0,0,0,0,0,526,746,0,0,345,0,0,0,
+-1017,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,651,428,0,0,0,1162,230,327,546,792,0,0,0,
+-1203,0,0,0,0,0,0,0,0,0,672,189,0,0,0,0,0,0,99,0,0,0,298,0,0,0,0,0,0,555,397,0,0,
+-0,0,0,1157,0,0,0,0,0,0,0,0,0,0,398,1523,0,366,0,0,787,0,0,0,282,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,157,0,941,0,0,0,0,0,1336,0,0,116,0,0,0,0,0,0,787,0,0,0,0,0,0,0,0,0,
+-0,170,160,0,1815,0,0,0,0,0,866,0,0,0,0,0,0,0,0,0,689,0,0,0,0,820,0,498,108,0,0,
+-0,1119,0,0,0,244,609,1005,0,581,0,0,0,0,0,895,0,0,0,1898,0,0,0,0,0,926,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,538,496,294,301,0,0,0,18,0,0,757,0,0,0,0,0,1263,0,820,0,722,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2028,0,0,0,0,124,1875,0,0,0,881,0,0,0,1348,
+-0,0,0,0,0,0,0,911,0,954,0,0,0,0,414,0,0,0,0,517,0,0,0,0,0,816,0,0,0,0,0,0,0,0,
+-713,0,0,0,0,0,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,593,150,0,0,0,0,
+-0,553,0,0,0,0,0,0,0,0,0,0,108,0,0,0,0,420,0,0,0,0,0,0,0,0,0,0,0,1777,0,0,55,493,
+-0,0,81,0,321,980,0,0,0,0,0,0,0,0,0,0,0,0,0,0,362,112,0,74,0,0,0,0,0,0,0,625,0,0,
+-0,0,0,0,377,16,0,0,61,281,0,0,0,0,0,0,0,0,0,0,0,0,0,0,224,1031,0,0,0,0,0,0,51,0,
+-0,0,0,0,0,0,211,309,15,125,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,789,173,0,439,9,648,
+-0,0,294,0,0,0,0,0,0,0,374,8,0,1099,0,0,0,0,0,0,0,575,0,0,0,518,0,0,0,702,0,0,0,
+-0,0,0,87,0,0,0,438,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,464,122,0,0,0,1802,0,0,0,0,
+-0,0,499,0,0,0,87,476,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,840,283,0,0,0,0,1620,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,609,1160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,600,
+-323,372,0,0,0,0,471,722,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,
+-477,1304,0,1774,0,0,88,0,438,12,0,0,0,0,0,0,0,0,671,997,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,639,22,0,0,782,681,0,0,0,0,0,0,0,0,0,0,1013,664,0,942,0,1349,0,0,0,0,0,0,0,
+-0,0,0,0,0,356,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,215,289,0,1975,
+-109,450,0,0,0,0,0,0,0,0,0,0,705,0,0,664,0,0,0,0,0,0,0,1238,0,0,318,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,960,1872,0,0,0,0,0,0,0,0,0,0,0,0,0,0,103,0,0,0,0,0,0,0,0,0,239,
+-777,0,26,0,0,0,0,0,0,0,0,0,0,0,0,375,414,0,17,0,0,0,1350,0,955,0,0,0,0,0,0,0,0,
+-887,960,0,0,0,0,0,0,0,0,0,0,708,710,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,919,0,0,0,
+-0,502,280,7,45,0,0,0,0,777,0,0,0,0,410,0,1110,0,0,0,0,0,0,414,341,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,787,0,0,0,436,0,0,0,0,0,0,0,1707,613,377,96,0,0,0,0,451,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,680,0,483,916,0,0,0,0,0,0,937,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,739,0,0,0,0,0,0,0,0,82,0,0,663,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,128,0,0,0,0,0,0,0,0,1087,0,0,0,0,0,0,0,503,0,0,0,0,0,0,9,113,104,324,0,460,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,935,702,434,485,1014,949,423,0,900,
+-0,0,0,0,0,0,0,2018,574,0,0,0,0,0,0,0,0,0,0,0,0,1206,0,0,0,0,0,0,0,0,38,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,1022,0,0,0,0,143,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,2029,0,0,0,0,0,0,0,0,0,0,0,0,523,0,0,0,0,0,0,625,0,0,425,37,0,0,0,1943,0,0,0,
+-0,0,765,0,0,0,0,0,0,0,0,0,0,551,0,0,0,0,0,0,0,0,0,0,0,0,168,0,0,1010,0,0,1994,0,
+-0,0,91,0,0,0,0,532,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1884,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,240,15,0,0,0,1227,0,1534,0,0,0,0,0,0,0,0,0,0,0,0,0,0,392,0,
+-0,0,0,0,0,0,0,0,0,0,0,655,562,395,0,0,0,501,1019,0,0,0,0,509,267,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1099,0,0,0,0,0,0,948,0,0,0,0,0,0,0,
+-462,114,0,0,258,404,0,1717,0,0,0,0,82,1061,0,724,0,0,0,0,0,1133,0,0,0,0,0,0,
+-1021,841,0,1021,0,0,0,0,0,0,0,0,0,0,488,373,37,0,0,0,0,564,0,0,0,0,0,513,0,0,0,
+-825,0,0,899,0,0,778,0,0,12,1417,0,1116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,114,545,0,5,
+-0,0,0,0,0,0,0,192,0,0,763,0,0,0,0,0,0,0,755,759,0,0,0,0,0,0,0,0,0,370,0,1237,0,
+-0,0,0,0,0,298,87,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31,0,0,
+-0,0,0,0,814,991,0,757,57,0,0,0,0,0,0,0,0,0,540,0,0,0,0,608,0,0,0,0,0,0,0,0,1014,
+-0,0,0,902,0,0,0,0,553,1668,0,0,0,0,0,0,0,0,0,559,60,0,0,0,0,0,511,0,0,675,0,0,
+-156,0,0,0,0,0,0,709,0,698,0,0,0,1745,0,0,0,0,0,0,0,0,0,714,0,0,0,0,0,0,0,0,206,
+-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,776,0,0,0,0,0,0,0,0,0,1272,0,0,
+-0,0,0,1059,0,0,0,0,0,0,406,0,0,0,0,0,0,0,0,0,0,947,0,0,0,0,0,0,168,0,0,0,0,0,0,
+-870,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,554,0,0,0,0,784,908,0,0,0,0,0,0,
+-0,396,358,0,0,0,0,0,0,0,0,2,228,0,0,0,0,0,0,0,0,0,0,0,845,14,0,716,1820,594,0,
+-81,1428,0,161,0,782,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,998,0,
+-0,0,0,0,0,0,0,0,0,0,0,1043,0,1496,0,0,0,0,0,0,0,0,781,0,0,0,0,0,0,0,817,1114,0,
+-1814,958,0,0,0,0,812,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,139,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,236,643,0,0,0,0,0,0,0,0,0,1172,0,0,0,0,0,0,0,0,0,1338,0,0,0,
+-0,0,0,0,0,0,0,0,54,0,0,0,256,0,0,351,0,955,1885,0,469,0,0,0,1270,0,744,0,313,0,
+-0,0,0,0,0,0,0,402,969,0,0,0,0,0,0,50,0,0,0,0,572,0,0,0,0,847,0,0,0,0,0,0,0,248,
+-43,0,369,0,0,0,0,0,0,0,0,0,0,0,0,0,766,0,363,0,0,0,0,0,0,0,0,0,0,0,678,0,0,409,
+-258,82,249,0,0,0,0,0,0,0,0,0,0,0,0,32,393,0,788,0,0,0,1281,509,1968,0,0,0,0,39,
+-291,0,0,0,589,0,0,54,1059,0,0,0,0,0,0,824,0,0,0,0,0,0,0,0,0,0,1005,0,1598,0,0,0,
+-0,0,919,0,0,0,0,0,0,0,0,52,132,0,0,0,0,0,328,0,0,0,0,173,0,0,0,0,0,65,1411,0,0,
+-0,0,0,0,0,0,0,0,442,0,842,0,0,0,0,0,0,0,0,0,534,0,0,0,0,0,0,0,0,0,0,0,0,0,845,
+-210,0,0,0,0,0,0,0,0,892,0,0,223,0,0,0,0,529,0,0,0,807,0,137,218,0,1444,0,0,0,0,
+-0,332,661,0,0,0,0,0,0,0,76,1517,0,0,0,0,0,0,0,0,0,0,0,418,0,0,0,0,0,0,0,0,481,
+-379,0,0,0,0,0,149,18,0,0,0,0,0,0,0,0,742,304,142,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,799,925,195,51,0,0,0,0,688,0,0,0,0,697,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,1169,751,0,0,0,452,929,0,221,0,1437,0,0,0,0,955,1251,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,0,132,0,0,0,0,0,865,0,0,0,0,0,0,0,767,
+-672,42,0,0,0,1050,0,0,0,0,0,0,0,0,368,44,0,0,0,0,0,0,0,570,29,0,0,0,0,0,0,227,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,522,0,0,0,0,0,0,0,1529,0,0,0,0,0,0,739,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1667,0,0,0,0,0,0,132,511,0,138,208,1020,0,0,23,565,0,344,0,0,0,
+-0,0,922,0,0,0,0,0,0,0,240,0,0,415,171,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,402,0,0,754,31,716,0,982,731,0,0,0,0,0,0,0,888,0,0,0,803,847,0,0,823,
+-0,0,0,0,0,0,785,0,0,2,0,0,0,0,0,0,0,532,0,0,681,0,0,314,0,384,684,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,649,447,0,1818,1007,0,321,0,66,360,0,0,0,385,0,0,0,0,0,0,
+-0,900,73,254,0,0,0,0,683,1959,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,86,0,0,725,0,0,0,0,0,196,0,0,0,0,0,831,0,0,0,0,723,0,0,0,0,0,994,627,0,0,
+-0,0,0,0,0,0,0,0,764,66,0,0,0,0,205,36,0,0,0,0,0,0,0,950,0,0,0,887,111,0,0,831,
+-388,165,0,0,0,0,0,155,0,0,0,0,0,0,0,0,0,0,0,0,0,0,780,755,0,0,0,0,898,146,0,0,0,
+-0,0,0,0,45,7,0,0,0,0,0,0,0,0,607,0,0,0,0,0,0,65,0,0,0,0,0,0,0,0,0,88,0,0,0,0,0,
+-621,600,0,367,0,0,0,0,0,0,0,561,0,559,0,585,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-287,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,672,157,0,0,0,0,714,0,0,0,
+-0,0,456,0,925,0,0,0,0,0,0,0,0,19,0,0,0,0,1473,0,0,0,0,0,0,0,0,0,0,113,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,69,463,0,0,82,193,2,471,0,0,0,0,633,0,0,0,0,0,0,1148,129,1392,
+-542,803,0,0,0,0,0,0,0,0,0,0,0,0,438,0,0,0,0,0,0,875,0,0,0,0,0,237,0,0,0,0,0,0,0,
+-65,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,563,0,0,0,9,444,0,0,43,1260,0,0,0,0,0,0,
+-971,0,0,699,0,0,0,0,0,1116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,829,242,0,
+-0,593,0,0,0,0,0,0,0,0,201,36,224,0,0,0,0,0,0,1430,0,1806,0,523,0,0,212,1889,0,0,
+-0,827,0,0,0,0,0,2043,136,242,0,0,0,0,0,0,284,148,10,0,0,0,0,0,0,1249,0,0,0,807,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,0,0,494,0,0,0,0,0,0,0,0,1510,0,0,0,0,0,
+-0,0,0,0,0,505,1306,0,0,764,268,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,384,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1703,0,0,0,0,159,964,583,0,0,0,
+-0,0,0,515,0,0,854,0,0,0,0,0,0,0,0,0,0,0,0,1123,0,0,0,0,0,0,0,136,0,0,0,0,0,1782,
+-0,0,44,1287,0,0,0,0,0,732,0,0,0,0,313,679,0,0,316,0,0,0,0,595,0,0,0,0,0,0,753,
+-147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,137,0,0,0,0,414,0,1762,0,0,0,0,0,0,0,0,
+-0,0,0,599,0,0,0,0,0,0,0,0,0,1749,0,0,0,1627,0,488,0,0,0,0,0,83,0,0,0,0,676,0,0,
+-1639,0,0,0,0,0,0,0,0,0,278,0,0,0,0,0,0,97,0,14,1085,0,0,0,0,0,0,781,388,0,849,
+-59,229,0,0,0,0,0,1115,0,0,0,0,108,0,0,0,0,700,0,0,0,0,0,0,0,0,0,1414,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,660,737,1035,0,0,0,0,0,0,521,690,0,0,0,0,0,0,0,0,0,0,0,0,272,0,
+-0,0,0,0,0,0,0,0,0,1744,0,0,0,0,0,0,128,733,0,0,277,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,936,1981,40,0,0,0,0,0,0,0,0,775,0,0,0,0,0,0,0,0,0,306,0,0,0,0,
+-0,0,0,979,0,0,0,0,0,611,0,0,0,0,0,178,0,0,0,1969,0,0,0,0,0,0,0,664,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,390,0,0,0,1510,0,0,0,0,0,0,0,0,0,0,0,493,0,0,37,0,0,0,0,724,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,1537,0,0,168,473,0,0,0,105,0,0,0,0,
+-627,438,0,0,0,0,0,0,0,0,0,0,11,1256,0,0,0,1626,0,779,0,0,0,0,25,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,308,0,0,0,0,0,741,0,671,0,0,0,0,649,150,0,0,99,521,0,0,3,339,0,0,0,
+-543,0,0,0,0,0,0,0,0,0,1358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,234,155,
+-0,0,0,0,0,0,0,1628,0,766,0,0,0,0,0,0,0,0,0,0,0,0,0,829,0,0,0,1445,0,0,0,486,0,0,
+-0,0,2,1635,0,0,0,0,558,0,0,0,0,0,0,0,0,0,0,1461,0,0,0,0,0,599,0,0,0,0,0,0,0,0,0,
+-1376,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,93,0,0,0,0,0,0,447,0,0,66,1432,0,0,0,0,
+-0,0,307,0,413,609,0,0,0,930,0,0,0,0,21,939,0,0,0,0,0,962,4,651,0,0,0,0,15,579,0,
+-0,0,0,0,597,0,0,0,0,0,981,0,0,0,545,0,0,0,0,0,0,0,1558,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,800,17,0,0,17,0,907,0,0,0,110,0,0,0,53,458,0,1983,0,0,0,0,0,0,0,0,0,0,443,0,
+-0,0,0,0,0,0,0,0,0,0,924,1844,0,1232,0,0,0,0,70,519,0,993,0,0,0,0,0,0,14,530,0,
+-907,0,0,0,0,0,733,0,0,0,0,0,0,0,0,55,0,188,531,56,0,0,1693,0,0,0,0,0,0,0,0,441,
+-0,192,928,0,0,0,0,0,241,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1525,0,259,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,512,185,0,464,1603,0,0,0,0,0,0,0,0,0,0,0,1113,
+-284,720,0,0,722,0,0,0,0,0,13,0,0,0,0,0,0,0,4,289,43,0,0,0,0,0,0,1694,0,0,0,0,
+-193,0,0,0,0,409,0,0,0,0,0,0,0,0,0,0,0,0,308,0,0,1863,0,0,0,0,0,0,0,0,0,790,0,0,
+-745,1002,0,0,0,0,0,0,0,0,0,289,68,477,13,0,0,0,0,0,0,0,0,0,0,609,0,0,0,0,0,0,0,
+-0,0,0,0,367,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,528,0,0,0,0,0,0,0,0,0,694,58,
+-548,0,0,0,0,0,0,687,0,0,0,0,1749,0,0,0,0,0,0,0,0,1004,661,0,0,0,0,0,0,445,0,0,0,
+-74,0,0,0,0,213,0,0,0,0,0,0,0,0,0,0,0,0,0,834,0,0,189,1672,0,0,0,0,0,0,0,1548,
+-192,0,0,0,0,0,0,0,0,0,0,0,0,0,32,751,0,78,0,0,0,0,0,0,544,1602,105,473,0,0,0,0,
+-0,0,156,1949,0,1779,0,0,0,0,0,0,0,0,0,0,0,763,0,0,0,0,0,0,0,0,29,0,0,0,0,0,0,0,
+-0,0,0,883,0,0,0,0,0,0,0,488,0,617,0,0,50,0,694,1518,785,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,546,0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,1016,0,0,0,577,0,0,0,0,0,0,
+-184,935,114,720,0,0,100,0,0,0,0,0,0,0,0,0,3,0,0,0,0,0,95,14,0,969,0,0,0,0,0,0,0,
+-727,0,1021,0,0,0,0,0,1190,0,0,0,0,0,0,0,0,0,0,0,0,0,153,0,0,0,0,0,0,0,0,0,798,0,
+-587,0,0,695,42,0,1929,141,957,0,465,7,908,0,0,450,148,0,0,0,1166,0,0,0,0,0,0,0,
+-0,0,0,0,0,253,0,1003,0,0,0,0,0,0,0,0,0,0,0,46,0,0,879,0,806,0,1868,0,0,0,0,0,
+-1846,0,0,0,730,0,0,0,0,0,0,0,965,0,0,0,0,506,0,0,0,10,0,0,0,22,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,960,296,0,0,0,0,0,0,0,0,0,0,0,587,0,0,0,0,20,0,0,0,32,982,0,0,0,0,0,0,
+-0,0,0,0,941,0,0,0,0,435,0,0,0,0,0,0,71,419,0,0,0,0,0,0,688,740,94,345,0,0,679,
+-582,0,0,0,0,0,0,0,945,0,0,0,0,0,0,0,0,0,0,0,0,539,0,684,1993,0,0,0,659,0,583,0,
+-803,0,704,0,0,0,0,0,198,181,347,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,481,405,203,0,0,99,826,0,0,0,0,0,0,0,492,0,408,0,0,0,0,0,0,0,0,0,0,4,0,0,
+-0,0,665,349,137,0,0,0,0,612,1270,0,0,0,0,0,371,0,0,0,826,0,0,0,0,21,1535,858,
+-374,0,0,0,0,0,0,311,0,0,0,991,1968,0,0,0,0,494,1647,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,769,0,0,0,0,0,642,0,0,157,123,0,0,0,1435,0,0,0,0,0,0,0,0,0,0,79,0,0,0,
+-0,0,0,1425,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,393,486,1690,0,0,0,0,
+-0,0,0,0,0,0,0,0,756,184,0,0,0,1382,0,0,0,175,0,1493,0,1007,0,0,0,0,0,0,0,0,0,0,
+-0,219,0,0,0,0,515,99,0,851,0,0,0,0,0,1278,0,0,0,0,0,0,0,1000,982,0,762,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,910,1819,0,0,0,0,0,0,906,0,0,0,0,0,0,0,0,0,0,1730,0,0,
+-0,0,0,0,0,0,0,0,0,1185,0,0,0,0,0,0,0,0,40,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-650,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,56,30,0,553,0,0,20,597,0,1614,0,0,0,0,0,327,
+-49,0,0,0,0,0,0,0,78,0,0,786,134,0,0,0,12,496,0,0,0,0,0,0,0,0,0,0,42,204,0,614,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,147,247,0,0,0,0,942,0,0,2023,0,0,0,0,
+-0,0,67,285,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1309,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,41,532,0,0,0,0,0,0,0,
+-1692,0,0,0,0,55,1704,0,0,0,0,988,0,0,0,223,0,0,0,0,0,0,0,57,1123,0,0,0,0,0,1764,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2015,0,0,0,1599,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,129,0,0,0,0,0,0,0,0,0,0,0,534,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,504,621,1248,321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1397,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,441,75,0,0,0,0,0,0,0,0,0,0,841,0,0,0,0,0,693,0,650,314,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,913,0,0,0,0,0,0,0,0,0,0,0,0,0,0,880,0,475,0,
+-0,1016,179,602,111,329,0,0,0,1864,0,0,0,0,846,1888,0,0,780,0,0,0,82,0,0,0,0,821,
+-0,0,0,0,0,0,0,0,0,0,0,956,112,0,0,0,261,455,0,0,0,0,0,0,337,385,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,184,1865,0,0,721,16,0,486,0,0,0,265,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,621,0,0,0,0,0,0,0,0,234,0,0,815,0,0,743,
+-1987,205,197,0,0,0,0,0,0,0,0,0,314,0,0,0,0,0,0,0,0,0,0,0,0,0,0,219,452,589,0,
+-176,333,0,0,0,0,0,0,0,1110,47,0,0,0,0,0,0,0,0,0,0,0,864,0,0,300,0,1237,0,0,0,0,
+-0,0,0,0,0,0,0,1685,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,135,395,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,631,0,0,0,0,0,0,835,0,0,0,606,459,0,979,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,612,0,0,0,0,0,0,0,0,158,372,0,854,0,0,0,0,0,
+-0,0,1492,0,0,0,833,0,0,0,0,0,0,0,1739,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-195,0,0,0,0,0,0,0,0,730,1997,0,0,0,0,0,0,0,0,61,0,0,0,0,0,0,0,266,751,0,0,0,0,0,
+-0,0,821,0,0,0,715,0,0,0,868,0,959,0,0,0,0,0,0,0,0,0,0,0,1053,0,0,0,950,0,1081,0,
+-1595,0,0,0,0,59,0,0,0,0,0,0,0,0,0,0,47,684,0,0,0,0,0,0,1606,0,777,0,1020,0,0,0,
+-1094,0,0,0,0,0,0,0,350,0,0,0,0,0,0,242,1812,0,0,0,967,0,0,0,473,286,0,0,0,0,0,0,
+-798,629,222,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,513,337,306,0,0,0,0,0,0,0,0,0,
+-146,0,0,1646,0,0,0,0,0,465,0,0,0,525,0,0,0,0,0,0,299,165,0,0,0,0,0,0,0,1064,0,0,
+-0,0,0,596,0,0,0,0,0,0,0,0,0,0,0,0,0,0,238,1741,0,1233,451,1824,0,0,0,0,733,495,
+-0,0,0,0,0,1204,0,0,0,559,341,0,224,21,0,0,0,0,0,0,0,0,97,1446,0,0,0,0,0,0,0,729,
+-0,0,565,727,0,1948,0,0,0,519,0,0,0,0,0,0,0,0,0,1193,0,0,0,0,0,0,790,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,323,2,201,0,0,59,0,0,34,0,896,961,0,1285,0,0,46,0,479,0,0,
+-0,0,549,0,663,0,0,0,0,0,783,65,682,0,0,0,0,0,11,0,0,0,0,0,522,0,0,0,52,0,0,0,0,
+-0,383,0,0,0,0,0,0,0,0,127,0,0,0,0,0,397,194,0,0,635,0,0,0,0,0,0,0,0,0,0,975,0,0,
+-0,0,0,0,0,0,0,0,116,0,51,0,0,858,0,1075,535,448,0,0,0,0,0,610,0,0,0,0,0,0,0,0,0,
+-0,191,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,267,673,319,94,92,0,551,0,0,218,
+-1406,69,256,0,0,952,1980,0,833,0,0,0,0,0,0,0,0,0,0,0,0,39,0,0,0,0,0,0,0,81,0,0,
+-0,352,634,0,0,0,0,0,618,0,0,0,0,0,0,73,339,0,0,0,0,0,0,0,0,0,0,0,0,0,0,169,759,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,1075,0,0,0,0,0,0,482,649,0,0,0,0,0,0,0,0,386,336,0,0,
+-0,1035,0,0,0,0,0,0,0,0,0,0,0,924,0,73,0,0,0,0,0,1971,0,0,0,0,0,0,0,0,0,1344,0,
+-501,0,0,0,0,0,0,0,0,46,799,0,0,0,0,0,0,0,276,0,0,0,0,0,0,0,770,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,158,0,0,0,0,0,1432,0,0,0,0,0,0,0,0,0,0,25,0,0,2001,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,478,0,0,0,0,0,0,91,1461,211,602,0,0,0,0,0,0,0,0,0,1068,0,0,124,567,0,0,
+-0,1006,0,0,0,0,0,0,0,0,0,735,812,0,0,323,0,0,0,304,0,0,0,0,0,0,0,0,0,148,0,0,0,
+-0,0,0,0,0,0,523,0,0,144,730,0,0,981,0,0,111,0,0,132,0,0,0,0,0,0,890,0,0,0,0,0,
+-444,0,1787,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,2041,932,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,937,0,995,0,0,255,0,0,138,863,965,0,0,631,0,0,0,0,1394,16,652,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,897,0,321,0,0,0,0,0,922,0,619,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,844,0,0,0,0,0,0,1659,0,1100,0,0,0,1173,0,1930,268,251,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,390,711,0,0,0,0,0,0,0,0,0,0,0,0,0,744,0,0,0,0,0,0,0,0,0,624,0,0,0,
+-1998,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1125,0,0,0,594,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,268,0,0,0,0,0,0,0,563,0,0,0,0,0,0,0,0,2,39,0,0,0,1332,0,0,0,0,0,
+-0,0,508,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,66,796,0,0,0,0,527,0,0,0,0,98,0,0,576,0,
+-0,0,0,0,122,0,276,37,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,645,0,0,0,0,
+-0,0,0,0,0,0,0,290,0,0,762,1292,0,0,0,1315,0,1955,0,0,0,0,0,0,0,0,0,0,210,131,0,
+-0,0,0,797,0,38,0,11,488,0,936,0,441,0,0,0,0,0,595,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-991,0,0,0,0,0,0,0,0,0,0,0,653,0,523,0,0,0,903,0,0,0,0,0,0,0,0,0,0,0,0,80,0,0,0,
+-0,0,0,0,0,0,432,0,0,314,0,0,0,0,232,1368,534,0,0,0,0,0,27,0,0,0,12,0,0,0,0,0,0,
+-0,0,0,264,736,0,1657,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1117,0,127,0,0,0,1208,0,1294,
+-0,0,0,0,364,0,0,0,0,0,125,1334,0,0,0,0,0,0,0,0,0,0,0,0,0,0,792,0,0,0,0,0,0,0,
+-849,699,0,0,0,0,0,968,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1446,
+-124,397,0,0,0,0,0,0,0,0,0,0,0,641,0,0,0,0,0,0,0,0,0,0,0,0,127,346,0,0,517,75,0,
+-0,0,0,0,0,0,0,83,0,0,0,0,0,0,1031,0,0,0,0,0,0,0,1470,0,954,0,0,345,304,410,0,0,
+-0,0,734,0,0,0,0,0,1822,0,0,0,1798,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,161,
+-1865,69,0,0,0,0,0,0,922,0,0,0,0,0,0,0,0,0,0,0,541,0,627,0,0,0,0,0,0,0,0,0,166,0,
+-0,0,0,0,0,0,0,0,849,0,0,0,0,0,0,0,717,0,0,0,0,0,0,0,0,0,0,0,0,0,0,600,0,0,0,0,0,
+-0,654,0,0,188,273,0,0,0,543,0,410,87,0,0,941,0,0,186,250,0,1785,0,0,0,0,0,1339,
+-462,961,0,780,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,529,0,0,0,0,0,0,474,1276,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,24,948,0,0,0,0,657,753,0,0,0,0,941,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,706,985,837,0,1861,0,0,0,0,0,0,0,0,0,0,0,0,0,0,292,933,0,0,0,0,0,
+-0,0,0,0,767,0,0,0,0,0,0,0,641,0,0,0,1233,114,0,883,0,274,2008,0,1794,285,0,0,
+-571,0,0,0,0,0,0,0,0,0,0,823,960,16,617,0,431,0,0,0,0,0,0,0,0,0,0,567,0,401,0,2,
+-781,424,33,0,2006,0,0,274,0,0,1882,0,794,0,0,0,1848,0,0,0,0,0,0,448,47,0,0,0,
+-1199,0,0,0,0,0,0,0,0,417,0,0,0,0,0,0,0,0,0,0,295,0,0,0,0,0,0,0,1019,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,620,0,0,0,0,464,0,0,0,0,208,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,442,0,930,0,0,0,0,0,516,68,0,0,0,0,0,1128,104,0,0,0,0,0,0,0,0,787,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,491,0,0,0,0,0,0,711,0,0,9,0,101,441,0,0,0,0,0,0,0,0,
+-0,0,160,396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,679,326,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,1128,0,0,0,0,0,737,0,1796,0,0,0,0,0,0,0,0,0,0,0,0,338,574,0,0,
+-0,0,0,1096,491,405,0,0,0,0,0,1081,0,0,0,0,0,0,0,0,0,0,0,0,0,1676,0,1207,0,0,0,0,
+-0,0,969,354,0,0,0,0,598,0,297,0,0,0,0,0,0,0,0,1772,751,0,37,0,0,1828,0,0,0,0,0,
+-0,0,0,0,257,191,582,0,0,0,0,0,0,790,0,0,0,0,0,47,0,0,0,0,0,0,0,449,306,1011,0,0,
+-0,0,0,299,0,0,0,0,0,0,837,0,0,0,0,0,0,10,329,0,0,0,0,0,1320,0,0,0,0,0,0,158,657,
+-0,1191,0,0,0,0,0,0,7,0,974,1939,0,1665,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,288,
+-66,0,0,0,0,494,175,0,1643,0,0,0,0,0,0,0,0,570,750,719,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-13,0,0,1247,0,0,221,356,0,0,0,0,0,0,0,0,0,0,694,1809,0,0,0,0,0,0,0,411,0,44,31,
+-0,0,0,0,669,0,673,0,0,0,0,0,0,0,0,0,1303,704,299,0,0,0,275,0,0,216,1761,0,0,0,0,
+-0,0,0,0,0,0,0,1319,0,0,428,0,0,0,0,0,0,0,0,0,0,514,0,0,0,0,0,0,49,55,102,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,364,0,0,0,0,379,0,921,971,52,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1258,0,0,0,1058,0,0,0,0,0,656,0,0,0,0,0,144,0,0,0,0,0,0,0,0,0,0,
+-0,1373,10,605,0,0,0,0,0,0,0,838,0,1012,0,0,0,0,0,0,0,0,0,0,0,0,0,0,154,365,0,0,
+-0,0,0,0,0,0,0,340,0,0,0,0,0,810,0,0,0,0,0,0,495,0,0,0,0,0,0,0,0,0,261,0,535,248,
+-0,358,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,567,445,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,697,0,0,0,1336,0,0,0,0,0,0,0,0,917,174,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,972,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,351,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,286,0,0,56,438,0,0,0,0,0,1950,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,738,0,0,0,0,0,
+-0,0,0,0,0,969,2047,0,0,0,0,0,0,0,818,0,0,0,0,0,0,0,866,0,0,0,0,0,0,0,1467,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,972,0,355,0,0,0,116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,267,189,104,0,0,0,0,1613,0,0,0,0,0,0,0,116,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,886,0,86,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,45,0,0,863,0,0,0,0,0,
+-0,0,1953,450,1773,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,381,0,0,0,0,0,0,0,
+-0,0,0,0,0,1142,0,1189,0,0,0,663,0,0,0,0,0,0,0,846,0,0,528,0,393,378,0,0,0,0,0,0,
+-325,899,680,1880,0,1770,0,0,0,0,0,648,0,0,0,0,0,0,185,167,0,2046,0,0,0,0,0,0,
+-249,1645,0,152,0,0,0,1733,0,0,0,0,0,1006,0,0,0,0,0,420,0,0,0,832,0,0,0,0,0,351,
+-0,0,0,0,6,40,0,0,60,0,0,0,0,1354,745,724,0,0,0,0,0,0,0,0,772,1951,275,108,639,0,
+-0,0,0,0,0,0,0,0,500,1758,0,0,0,0,0,0,0,0,0,0,0,1886,711,205,0,0,965,865,0,0,0,
+-534,0,0,0,0,691,0,0,0,237,443,0,878,0,0,0,0,0,1410,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-995,0,0,0,0,0,0,0,0,0,0,0,0,0,578,0,0,0,0,881,0,0,0,0,0,0,0,0,822,0,923,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,924,0,0,0,665,0,0,0,0,0,1901,0,0,0,0,0,950,498,93,
+-0,0,0,1451,0,0,0,0,0,747,828,788,400,184,0,198,0,0,0,0,0,0,0,0,0,0,0,994,0,0,0,
+-0,0,0,0,0,615,320,0,0,0,978,843,905,0,0,0,0,0,0,0,0,850,974,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,509,0,0,0,0,0,273,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-201,0,0,0,1041,0,0,0,1040,0,0,0,0,0,0,0,0,0,693,234,774,0,336,0,1399,22,0,805,
+-802,777,167,789,0,0,1705,0,0,0,0,0,0,0,0,0,0,0,10,13,11,0,0,204,264,0,0,56,0,0,
+-1917,0,470,0,0,0,0,0,0,0,0,0,0,0,1198,0,0,0,0,0,0,0,0,0,0,1015,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,715,0,0,1002,0,0,0,298,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,867,0,0,724,0,0,0,0,0,0,0,0,0,0,0,0,768,0,0,0,0,0,1066,0,0,0,0,67,0,174,948,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,764,0,0,0,0,75,137,0,756,0,0,0,0,0,0,1008,842,643,0,0,
+-0,67,0,0,0,0,0,0,0,0,0,0,0,135,821,0,0,0,0,0,0,0,0,736,0,389,355,0,0,786,0,0,0,
+-0,0,0,2044,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1030,0,0,0,1083,0,0,0,0,0,
+-1226,0,0,0,0,356,319,8,389,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,474,0,0,0,427,
+-0,413,0,730,0,0,0,0,0,373,0,0,0,0,0,0,0,0,0,799,0,0,0,1793,0,0,0,322,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,89,290,2,0,0,0,0,0,0,0,0,0,0,672,
+-699,1860,0,0,0,737,0,0,0,1612,0,0,0,0,0,0,0,0,0,0,0,145,124,884,0,0,0,0,0,387,0,
+-0,0,0,0,0,0,0,0,0,0,679,0,550,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1305,0,0,0,0,0,0,0,
+-576,0,0,0,0,0,0,0,686,0,607,0,0,37,0,0,0,0,0,0,0,0,0,101,1726,0,0,0,0,0,958,0,0,
+-0,903,0,0,0,0,147,0,0,0,0,0,0,0,0,0,0,0,367,0,0,0,0,690,0,705,273,0,0,887,0,0,0,
+-0,0,0,0,0,0,0,0,90,0,0,0,0,0,0,0,908,0,0,0,0,0,0,0,1261,0,0,497,1235,0,429,0,0,
+-0,0,904,0,12,125,0,0,0,841,0,0,0,0,0,860,946,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,768,0,770,160,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,271,0,0,0,0,0,0,0,719,0,699,581,0,0,0,0,0,0,0,0,0,0,862,304,0,631,0,0,0,0,880,
+-1513,0,0,0,0,0,981,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,434,0,0,0,0,0,550,0,0,476,930,
+-824,553,0,0,452,0,151,0,0,0,0,0,0,772,0,292,135,0,0,0,0,0,0,0,504,0,0,1089,0,0,
+-0,0,0,0,0,0,0,0,0,783,0,0,0,0,0,0,206,393,0,0,0,0,0,0,0,0,232,912,0,0,0,0,0,977,
+-0,0,716,98,0,0,0,0,0,733,0,0,0,0,0,0,0,0,19,0,0,0,0,668,0,360,0,0,0,0,0,0,656,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,726,0,0,0,0,0,0,0,0,0,0,0,0,72,0,0,1269,0,0,463,0,
+-0,0,0,0,0,1454,0,1287,245,0,989,0,0,0,0,0,0,0,0,0,107,164,0,0,0,0,0,0,0,1061,0,
+-0,0,0,2,484,0,0,0,0,0,0,0,1127,0,0,0,0,0,0,0,460,0,0,0,0,0,932,0,0,0,0,0,0,0,
+-588,625,0,0,0,0,76,92,0,0,0,0,0,0,0,0,0,0,0,0,0,104,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-763,0,622,0,0,0,253,0,546,0,0,110,0,256,916,0,0,35,212,0,0,746,0,0,0,150,0,0,
+-1466,0,0,0,1299,0,0,0,0,0,0,0,0,0,1518,0,0,0,0,0,0,0,0,0,0,0,0,0,1229,0,0,0,816,
+-0,0,0,0,0,0,159,0,0,0,0,0,734,869,126,1716,0,0,0,0,0,0,202,232,0,0,0,0,212,0,0,
+-0,0,0,111,1003,0,0,0,0,0,0,0,0,0,0,0,1712,0,0,216,0,0,0,0,516,0,0,0,0,0,650,0,0,
+-0,0,57,99,0,0,0,0,300,574,0,0,0,0,1023,0,0,302,0,1871,0,728,252,0,0,461,0,0,0,
+-323,0,0,0,0,0,0,775,461,0,0,0,0,0,0,172,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,73,727,0,1023,0,0,0,0,0,0,0,0,0,0,577,0,0,0,0,0,0,0,0,1037,0,0,0,0,0,0,
+-0,0,280,677,0,0,0,0,0,0,0,0,0,0,0,799,0,0,0,0,159,0,446,1730,0,0,0,0,0,0,0,0,0,
+-395,0,0,0,0,145,0,0,0,0,0,0,0,20,0,0,426,608,0,0,0,0,0,977,0,250,0,0,0,0,0,100,
+-0,0,0,0,1982,0,0,0,0,0,476,0,0,0,0,0,0,594,76,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,447,0,0,0,0,526,0,0,14,1124,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,188,0,0,0,0,0,0,0,0,362,301,0,0,0,1743,0,178,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,872,0,831,0,0,208,202,0,0,0,0,0,0,0,1954,0,
+-0,0,0,516,872,0,0,313,224,0,0,24,0,11,546,0,0,0,1937,242,241,46,0,0,0,830,1273,
+-0,0,0,0,0,0,0,825,327,1006,0,0,0,0,0,1580,516,366,0,0,0,0,0,1736,0,0,0,0,0,0,0,
+-0,0,0,0,1935,0,826,0,0,0,0,139,331,0,0,0,0,0,0,0,0,0,0,0,288,0,916,0,0,0,0,0,
+-1888,0,0,0,0,0,0,0,1471,0,1570,0,394,0,0,0,0,0,0,0,1931,0,1719,0,658,228,0,0,0,
+-0,0,374,0,0,0,0,735,0,0,0,0,0,0,323,498,0,1063,0,0,0,0,155,0,0,0,0,0,0,0,0,906,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1139,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,108,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,616,
+-902,0,0,0,0,0,692,0,0,0,0,0,0,823,0,0,0,305,0,0,0,0,0,0,0,681,0,0,0,0,0,214,
+-1004,0,0,0,0,0,0,0,23,0,0,1703,0,0,0,0,0,0,0,0,0,1443,0,0,19,714,0,0,0,0,64,737,
+-0,0,345,1758,0,0,579,47,0,0,539,139,0,0,0,0,388,0,0,0,0,253,0,0,0,0,0,0,252,0,
+-745,0,0,0,0,0,0,0,0,0,0,0,504,107,0,871,0,0,0,229,0,0,0,0,0,903,0,0,71,0,0,549,
+-6,47,0,0,0,0,0,0,0,0,0,980,865,705,0,0,0,161,0,0,0,0,143,1331,0,0,0,1388,33,724,
+-0,0,0,19,0,0,0,395,0,0,0,0,0,846,210,0,0,0,122,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,695,937,497,0,0,0,0,0,718,0,0,0,0,0,0,0,1581,0,
+-0,0,0,0,0,161,49,0,0,0,0,0,0,0,0,0,597,0,0,0,1094,0,0,0,811,908,0,0,0,0,0,0,0,0,
+-0,0,1471,0,0,0,0,0,0,0,0,0,0,42,1935,0,0,0,2014,66,2007,0,0,586,0,0,0,0,0,0,0,0,
+-0,28,1077,0,0,0,1221,0,0,62,0,0,0,0,0,0,0,0,0,0,1766,0,0,0,0,0,0,0,0,0,0,0,0,25,
+-0,499,1388,0,0,97,10,0,0,0,0,0,481,0,0,0,0,0,0,0,0,0,0,37,134,155,486,0,1442,0,
+-0,0,0,0,591,0,0,0,0,0,0,310,1173,0,0,0,0,409,1156,0,0,0,482,0,0,263,926,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,804,0,0,0,0,0,0,0,0,0,0,0,0,0,1265,0,415,0,348,0,0,0,1012,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,165,1803,0,0,0,0,0,0,0,408,
+-0,0,0,0,0,0,257,1321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1138,0,0,0,249,0,
+-0,0,576,0,0,0,0,231,0,0,0,288,0,0,0,0,0,0,0,0,0,433,1487,569,1678,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,87,0,0,0,0,0,779,538,0,0,0,413,0,0,0,
+-0,0,0,0,0,0,0,495,0,0,0,0,0,191,54,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,530,567,
+-0,0,0,0,0,1484,0,0,0,0,0,0,815,609,0,0,0,0,0,484,0,0,0,0,0,0,0,0,0,0,900,0,0,0,
+-0,1335,0,1724,0,0,0,0,0,0,0,0,0,0,0,640,0,0,0,0,0,0,0,0,0,0,0,1831,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,474,0,0,0,0,0,0,0,0,0,1103,0,1504,655,1034,0,0,0,0,0,305,0,0,0,0,
+-0,0,0,0,0,1236,0,0,429,217,0,0,0,0,739,278,0,0,0,0,0,0,0,708,0,0,0,0,0,1840,233,
+-0,0,0,0,0,0,0,0,2017,0,0,0,0,0,1488,0,0,0,1590,0,0,0,0,0,1800,28,0,0,0,0,0,0,0,
+-0,0,45,0,36,0,22,1442,378,0,0,0,0,0,0,1507,0,0,0,0,0,0,0,0,0,0,39,0,0,1054,725,
+-1955,0,2036,0,0,0,0,0,0,0,0,0,0,896,1871,0,0,0,0,0,0,0,0,0,0,805,0,0,0,0,2046,0,
+-0,0,0,17,712,0,617,55,320,271,0,0,0,0,0,0,0,0,0,445,0,184,103,0,0,0,0,0,0,0,0,
+-659,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-337,0,0,0,506,0,0,0,0,0,843,77,0,458,0,0,0,0,0,1420,382,109,142,330,0,0,0,0,0,0,
+-0,0,0,0,0,0,87,0,0,0,492,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1239,0,0,0,0,0,0,
+-211,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1049,0,321,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,1985,0,0,122,0,0,234,0,0,0,1098,0,0,0,0,0,0,549,253,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,522,131,0,0,149,0,0,0,0,0,0,0,0,0,0,0,0,0,0,507,0,0,0,0,811,630,0,0,0,343,
+-0,0,0,0,0,448,591,455,0,1381,0,0,0,0,0,0,0,575,0,0,0,0,0,1175,0,0,0,0,0,0,0,0,0,
+-653,0,0,0,1761,0,1198,0,0,0,0,297,1127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,678,0,0,
+-164,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,35,0,45,0,0,0,0,0,121,0,0,0,0,0,0,
+-0,0,125,0,0,0,1622,0,0,0,0,0,721,145,0,0,0,970,792,0,0,0,715,0,0,0,0,0,1999,0,0,
+-74,531,0,0,65,0,0,0,105,220,0,0,0,0,0,0,0,960,0,0,0,0,0,0,428,19,0,0,401,96,0,0,
+-0,0,0,1595,116,0,1021,0,0,0,0,0,750,1961,0,0,148,0,0,0,0,0,0,0,0,0,0,0,0,0,75,0,
+-0,1383,0,0,0,0,0,0,0,0,0,0,0,0,0,0,779,0,0,0,0,0,0,0,0,598,0,424,0,0,0,0,0,0,0,
+-1222,0,0,0,876,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,133,0,0,0,0,187,0,8,0,0,0,0,0,
+-0,0,429,0,685,0,0,0,0,0,0,0,0,0,0,0,132,472,0,0,0,0,0,0,0,0,0,938,0,0,874,0,0,0,
+-0,0,774,0,0,0,0,0,92,0,0,0,0,0,0,830,701,0,0,0,0,0,426,350,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,603,59,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,0,441,163,4,0,
+-0,0,0,0,0,0,0,0,806,0,0,0,0,0,0,233,0,0,0,0,1994,0,1739,0,0,393,0,47,1038,0,0,0,
+-309,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,363,0,0,0,175,0,0,0,0,0,0,0,666,
+-0,0,1675,0,1600,0,0,0,808,0,0,0,0,0,0,0,0,0,0,0,280,54,0,0,0,0,0,0,0,0,421,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,249,0,0,103,254,0,262,1,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,805,0,0,0,0,0,0,0,0,0,1630,0,0,0,0,0,0,0,0,0,0,0,0,0,671,972,989,0,0,
+-0,0,0,0,0,889,0,0,0,1382,0,0,0,0,0,0,0,775,0,0,0,0,0,0,0,0,0,0,388,202,0,0,0,0,
+-16,560,0,0,0,841,0,0,566,0,0,0,938,0,0,0,0,0,0,0,0,0,0,912,0,0,0,1361,0,0,0,0,0,
+-0,618,236,0,1854,0,0,318,190,0,1376,0,0,0,0,0,0,0,349,0,0,0,0,951,1972,0,0,0,0,
+-0,0,344,0,0,0,0,0,0,0,0,850,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,910,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,163,85,0,487,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,145,0,83,0,0,1013,0,0,0,1922,0,0,169,557,66,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,1193,82,0,352,454,57,0,0,1333,396,107,0,370,0,0,0,0,0,0,0,0,0,204,0,0,0,
+-0,0,1706,0,0,0,0,0,0,0,0,0,0,0,0,394,1204,0,0,0,0,0,1007,0,0,0,1696,0,1519,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,981,0,0,0,0,1072,0,0,0,712,0,1629,0,0,0,0,0,0,0,728,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1271,0,0,0,1608,16,0,0,0,0,485,0,0,0,0,0,0,
+-153,27,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1991,0,0,0,0,0,0,0,0,52,0,21,0,
+-0,0,0,0,0,0,0,0,819,0,0,0,0,0,917,0,0,0,0,784,0,0,0,0,135,0,0,0,0,0,454,0,0,0,0,
+-0,0,0,0,0,852,1719,0,0,0,0,0,852,0,0,0,0,0,952,0,0,0,0,568,0,0,0,0,0,448,0,0,0,
+-67,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1826,657,0,729,666,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-669,0,0,0,0,0,0,0,402,0,0,152,0,0,0,0,912,0,0,0,0,0,0,51,320,0,445,0,0,0,0,308,
+-0,0,0,0,0,386,0,0,239,0,0,130,83,0,143,0,348,0,0,0,0,0,0,0,958,0,0,0,0,0,210,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,430,0,0,0,0,0,0,0,0,0,0,0,0,7,213,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,801,0,0,0,0,0,0,0,0,0,936,0,108,0,0,
+-0,0,0,0,0,0,0,885,587,219,398,364,0,1165,0,0,342,241,303,0,0,0,0,0,0,0,0,0,0,
+-1454,0,0,0,0,0,0,0,0,0,0,254,562,0,786,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1294,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,493,216,0,0,0,0,219,341,0,0,0,0,0,
+-0,0,0,0,0,130,1734,154,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,701,604,0,0,879,0,195,
+-666,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1669,0,0,0,1791,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1228,0,0,0,0,0,623,0,0,0,0,0,0,0,798,0,0,0,0,0,0,0,0,0,0,0,0,84,
+-122,0,0,0,837,0,0,0,0,0,0,1013,0,0,577,0,0,0,460,932,0,0,0,0,0,0,0,0,0,0,0,31,
+-131,0,0,0,605,0,0,0,1246,0,0,0,0,68,278,165,307,781,0,0,0,0,0,0,33,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,1113,0,0,720,1953,203,0,0,0,0,0,0,0,425,326,0,0,0,0,0,
+-0,0,0,0,0,241,1316,0,0,0,0,0,416,0,0,0,1300,0,847,0,0,662,358,0,0,0,0,839,1823,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,654,1522,0,0,0,0,0,0,163,0,0,0,0,0,314,978,0,0,0,
+-601,0,0,0,0,0,946,434,0,0,0,402,411,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,1467,
+-410,0,0,0,0,0,0,0,0,0,0,0,0,0,0,483,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,677,0,0,0,0,0,0,0,0,0,0,0,0,70,0,0,0,0,1405,0,0,0,0,0,0,108,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,777,0,0,0,0,0,747,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,505,0,326,0,0,164,628,654,0,0,0,
+-37,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,668,152,0,0,0,0,0,0,0,0,0,0,0,581,
+-0,0,0,0,44,126,89,0,0,0,0,0,0,0,0,1531,0,0,0,0,0,0,0,0,203,1167,0,0,0,0,0,0,0,0,
+-531,1232,0,0,0,0,0,943,0,670,231,880,0,1617,0,0,0,1957,0,0,0,0,0,0,0,975,0,0,0,
+-0,0,0,0,0,0,0,0,242,0,0,0,0,0,0,0,0,0,421,0,0,14,834,0,0,0,0,0,0,0,0,0,0,0,0,
+-465,0,0,0,0,0,834,688,413,855,0,0,0,590,0,0,0,0,0,0,0,0,114,0,0,0,0,0,0,0,0,0,0,
+-0,45,169,0,0,0,0,0,0,0,0,0,0,0,198,0,0,565,585,0,0,0,0,0,0,0,0,0,0,0,0,0,691,0,
+-0,0,593,0,0,0,0,0,0,0,0,0,913,116,0,0,0,0,1360,0,0,0,802,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,673,308,0,709,1006,1895,0,228,0,0,0,1840,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,608,0,0,0,0,0,0,0,0,0,1573,0,2039,136,540,0,0,0,0,0,0,0,
+-897,0,0,938,1878,0,0,0,0,0,0,0,0,0,1469,0,999,0,299,0,0,0,0,0,0,0,578,0,0,0,0,0,
+-456,0,0,0,1679,163,693,0,0,0,0,0,0,48,755,0,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,
+-1091,0,0,0,0,695,0,0,1464,0,0,0,0,0,975,0,0,335,0,0,1979,0,0,0,0,269,1566,630,
+-396,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1815,634,0,0,0,966,0,0,0,0,0,0,0,9,
+-412,0,958,0,0,579,382,0,212,0,0,0,0,965,681,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,655,
+-0,0,0,0,67,0,0,0,0,0,0,751,0,0,0,0,423,231,0,0,1016,300,0,0,0,0,100,237,0,0,0,
+-1370,0,0,0,1208,0,0,0,0,0,1219,129,0,0,0,0,0,0,0,0,0,0,0,0,0,0,199,0,0,427,0,0,
+-0,0,949,665,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,712,0,0,0,0,0,1186,0,0,0,0,0,0,0,0,0,0,295,312,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-151,0,0,0,0,588,4,0,0,0,0,0,414,104,0,0,757,263,0,561,0,0,0,320,0,0,0,0,0,0,0,0,
+-0,0,0,225,0,0,0,0,37,817,0,974,0,0,0,0,0,0,0,0,0,0,0,0,0,2026,131,235,16,0,590,
+-1157,0,0,0,0,0,0,0,0,221,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,140,390,0,0,0,0,
+-0,0,0,1144,0,0,0,464,0,0,0,0,0,0,0,0,0,0,0,0,204,407,303,1218,0,0,0,0,5,325,0,0,
+-0,0,12,800,0,1783,0,0,0,0,0,0,0,0,0,0,504,621,0,0,0,0,0,0,0,0,0,920,0,376,0,0,0,
+-0,0,218,580,0,768,454,0,0,0,0,0,0,0,0,0,0,0,0,676,0,0,0,0,0,0,164,0,0,0,0,0,0,0,
+-0,50,0,0,0,0,0,0,0,0,0,0,0,0,0,120,285,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,226,343,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,29,0,0,1812,0,0,8,0,0,0,21,1125,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,1327,0,0,0,0,575,1598,0,0,0,0,0,0,0,0,0,895,0,0,0,959,0,0,
+-0,0,0,1759,173,0,0,0,0,266,261,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,1427,0,0,300,1033,0,0,0,0,0,0,0,0,0,0,0,584,0,0,0,0,52,734,
+-0,0,217,239,0,1129,0,0,0,0,0,0,0,0,732,20,0,0,0,0,0,0,0,0,0,0,0,418,0,0,0,613,0,
+-0,0,0,0,0,0,0,0,632,0,0,85,984,0,0,0,0,909,694,7,1109,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,167,0,0,0,0,280,62,0,0,33,0,0,359,186,980,0,0,0,0,0,0,0,0,0,0,0,585,0,0,0,
+-211,0,0,336,145,0,1130,0,873,0,0,840,263,0,0,0,0,0,0,0,0,0,916,0,0,0,0,0,0,0,0,
+-0,0,155,0,0,0,461,97,0,0,0,0,0,1356,0,0,0,0,0,0,0,593,0,0,0,0,0,1392,0,0,0,0,
+-126,0,0,0,0,1179,0,0,0,0,0,162,0,0,0,0,0,765,0,187,0,1286,0,0,0,0,0,0,0,0,0,635,
+-0,0,23,215,0,0,0,1306,0,0,97,716,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,657,0,
+-0,0,0,0,0,0,0,299,0,0,0,0,0,0,134,0,0,0,0,0,0,0,0,0,0,0,658,1082,0,0,0,0,0,2002,
+-0,0,0,0,0,0,833,248,0,0,0,0,0,1654,0,0,531,0,0,0,0,0,0,634,0,0,0,0,0,0,0,0,0,
+-853,573,249,0,0,0,0,0,0,0,0,527,0,0,0,0,1419,0,0,0,0,0,0,20,49,0,0,0,992,0,0,0,
+-728,0,0,0,0,0,0,0,0,0,0,0,0,497,1579,0,0,0,0,62,268,0,0,0,0,0,0,0,1201,0,0,0,0,
+-0,0,0,0,0,0,0,0,495,193,0,0,0,0,106,0,0,859,0,0,23,0,0,0,0,0,0,0,813,925,0,0,
+-223,613,953,0,0,0,0,0,0,0,0,666,0,0,0,0,0,0,0,0,0,670,0,0,40,216,0,0,0,0,0,0,
+-259,0,0,0,440,1114,0,0,0,0,0,0,0,0,74,475,0,0,188,139,0,797,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,1572,0,0,0,0,39,0,0,0,0,0,0,0,0,0,0,0,0,1594,0,0,0,0,0,0,0,290,0,232,
+-0,0,887,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,521,14,0,0,0,0,0,741,0,0,0,992,0,
+-0,0,0,0,0,0,0,111,0,0,425,0,0,0,0,0,789,0,0,0,1593,0,1768,0,0,233,0,0,0,0,943,0,
+-0,0,0,0,0,0,955,225,245,0,0,0,0,0,0,241,0,0,0,0,1943,0,0,0,1284,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,709,0,0,0,0,0,0,554,0,0,0,0,0,0,0,0,1564,0,0,0,
+-443,0,0,0,0,0,0,280,0,0,0,0,0,0,0,0,729,0,0,0,348,0,0,0,0,0,0,0,758,848,298,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,829,1422,189,121,0,0,632,812,0,0,556,0,0,0,0,0,436,172,
+-530,844,232,984,0,0,0,0,0,0,0,0,0,0,147,0,0,0,0,0,0,0,0,537,0,0,0,0,0,859,0,0,
+-842,0,0,0,0,0,0,0,0,0,0,1291,0,0,0,0,0,0,0,0,0,0,0,1482,612,392,0,0,0,262,31,0,
+-0,0,0,0,0,0,0,0,0,753,549,0,0,0,0,0,0,696,0,0,0,0,0,0,0,834,0,0,0,0,0,771,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,921,0,0,0,674,0,0,0,0,0,0,0,0,0,0,308,444,0,0,0,0,0,0,805,
+-180,0,0,278,271,0,0,214,505,0,1215,0,0,0,0,0,0,387,271,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,1645,42,92,0,459,0,0,330,1557,0,0,0,0,0,0,0,0,113,18,0,0,0,
+-1742,0,0,0,965,0,0,0,0,0,0,0,0,0,0,0,0,0,182,0,0,65,0,0,0,0,0,0,0,0,0,0,0,0,973,
+-0,0,0,0,0,328,0,0,588,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1786,
+-0,0,962,1985,0,0,0,308,508,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,588,0,0,0,0,0,0,614,793,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,290,0,0,0,0,0,0,0,0,0,0,1136,0,0,0,0,0,0,0,0,0,0,796,719,0,0,
+-326,210,0,0,0,701,758,472,0,0,0,1947,278,1079,0,0,0,0,0,0,497,41,0,0,634,46,961,
+-0,810,524,0,0,33,0,0,0,0,0,0,0,0,0,0,0,0,532,0,997,0,0,0,0,0,0,0,0,0,0,0,1301,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1298,0,671,0,0,0,306,0,0,0,0,0,0,0,0,0,0,
+-693,1823,0,0,0,759,0,0,0,0,0,1932,0,0,0,0,0,0,0,0,0,0,0,0,0,0,88,182,0,0,0,1964,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,521,0,0,0,0,0,0,424,857,0,0,0,0,671,328,0,
+-529,0,0,0,0,0,716,0,1509,80,67,0,0,0,0,59,141,0,0,0,0,0,0,783,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1498,0,0,0,0,343,430,803,1183,677,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1357,53,0,0,0,0,590,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,329,0,0,0,0,0,0,0,469,0,0,0,0,0,0,0,0,0,0,460,0,0,1743,0,0,963,340,0,0,0,
+-0,0,1603,0,0,250,0,0,0,0,0,646,218,0,1794,0,0,0,571,0,455,0,0,0,1012,0,0,0,0,0,
+-0,0,0,0,0,0,0,597,161,0,349,0,524,0,0,0,0,0,0,0,0,0,0,0,0,322,432,0,0,0,0,0,0,
+-325,223,0,0,0,0,0,566,0,0,0,1394,481,436,0,48,457,610,756,618,0,0,0,755,0,1217,
+-0,0,0,0,0,197,0,0,0,0,0,0,0,0,0,0,0,0,0,0,544,492,107,414,0,0,0,0,0,0,0,0,0,0,0,
+-1007,0,0,0,0,5,0,0,1580,0,0,0,0,0,0,0,0,0,0,0,0,0,673,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,1843,0,0,0,0,0,0,0,0,0,165,0,0,0,0,0,0,809,885,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,498,0,0,0,306,9,0,0,0,0,0,0,0,437,721,146,0,0,0,0,0,0,0,0,0,0,0,177,0,0,0,0,
+-0,0,0,1377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,200,0,959,0,0,0,1928,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1435,0,481,0,0,0,0,0,0,142,84,0,0,0,0,0,
+-1015,0,0,0,315,0,0,0,0,0,0,759,0,0,0,0,0,0,0,0,712,0,0,0,1722,0,0,0,0,0,0,0,0,0,
+-0,0,0,222,0,985,1414,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1273,
+-538,706,0,0,0,0,0,0,0,0,115,0,0,0,0,0,0,0,0,0,0,1781,0,0,0,0,0,431,97,665,42,
+-237,0,0,0,264,0,0,213,0,0,0,0,0,0,0,455,0,0,0,906,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-624,0,574,0,0,0,0,0,0,0,0,0,0,0,0,354,0,0,0,1558,0,0,0,0,0,0,0,0,0,0,0,0,0,0,68,
+-235,723,1813,0,0,0,957,0,830,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,496,0,0,0,0,0,0,0,
+-547,239,88,0,0,0,0,0,0,0,0,0,1310,0,0,0,0,0,0,0,0,80,1076,0,0,118,0,0,0,479,274,
+-0,0,0,0,0,0,0,0,0,0,0,497,0,0,669,261,0,0,0,0,13,0,0,0,0,0,0,791,250,642,0,0,0,
+-1429,939,949,0,0,0,0,0,0,0,0,0,0,0,0,0,818,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,982,330,0,0,0,0,545,0,0,0,0,0,0,947,0,1188,0,0,0,0,0,904,0,0,0,0,0,1372,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,693,377,0,0,0,0,0,0,0,0,0,0,0,0,0,0,695,0,0,
+-713,386,0,0,0,0,128,1575,0,0,0,0,0,0,424,893,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,904,0,0,0,0,0,552,322,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28,1808,49,0,0,0,0,
+-1832,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,421,0,0,442,415,0,0,289,
+-0,0,0,0,0,206,110,0,0,0,0,0,205,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-19,1539,0,0,0,0,0,1340,0,1194,0,0,0,0,0,0,0,0,549,0,0,0,0,0,0,0,0,1720,0,0,0,0,
+-0,0,0,0,0,319,0,0,0,0,112,1180,0,0,0,0,0,0,0,0,0,0,0,967,0,0,0,0,0,0,0,0,0,1940,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,735,0,0,0,0,0,0,0,0,0,897,132,0,0,0,0,0,0,0,
+-0,0,0,38,838,0,0,0,379,218,8,660,1017,0,0,0,0,0,0,111,387,647,877,0,0,53,790,0,
+-0,0,0,0,0,0,0,458,0,0,0,0,0,0,954,0,0,0,394,0,1367,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,882,0,0,0,0,0,0,0,1409,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,38,124,342,199,0,0,0,0,
+-0,0,0,0,0,0,724,628,0,0,0,0,804,266,0,0,0,0,0,208,0,79,0,0,0,0,0,0,0,0,741,0,0,
+-0,0,0,0,0,0,0,0,606,0,1494,821,1553,0,0,135,405,0,0,178,100,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,481,0,0,0,1378,0,0,0,0,0,0,0,0,0,0,0,0,0,791,33,1227,857,0,467,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,447,0,0,0,0,0,0,86,128,0,0,0,0,0,0,587,0,0,0,692,1018,0,
+-195,0,0,0,0,0,0,0,1546,0,0,0,0,0,0,0,0,0,0,0,684,0,0,345,0,0,0,0,0,0,365,0,1683,
+-0,0,472,0,433,0,0,0,0,0,0,0,28,0,0,0,997,0,705,3,0,0,0,0,0,0,0,0,0,229,0,0,0,0,
+-102,0,0,0,0,866,1022,0,0,0,0,0,0,0,0,0,55,0,115,0,0,0,0,933,0,0,0,0,0,0,0,702,0,
+-0,0,0,0,0,0,1728,26,484,0,0,0,185,618,417,0,803,0,0,0,0,0,0,0,0,0,0,0,1262,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,633,0,0,0,0,0,0,0,0,0,0,0,0,0,479,262,0,0,0,0,0,0,830,0,0,
+-0,0,26,70,0,0,0,0,0,0,0,0,217,0,640,51,0,0,360,1586,0,0,0,0,0,652,0,0,0,0,0,766,
+-0,0,0,0,298,737,0,0,0,0,0,0,0,0,0,0,655,222,906,0,0,1013,991,2009,0,0,0,0,503,0,
+-0,0,216,154,0,0,0,716,0,844,0,0,0,0,621,252,0,0,0,0,748,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,103,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,576,0,0,0,648,0,0,0,331,0,0,0,
+-0,0,0,0,0,0,0,0,0,632,0,0,0,518,107,0,0,0,0,0,0,0,0,851,0,0,0,0,504,0,0,0,0,0,0,
+-0,0,0,0,0,0,7,883,0,0,0,0,0,0,0,922,0,0,0,0,0,0,0,0,91,993,0,0,0,0,0,0,200,131,
+-10,0,0,0,0,0,0,0,0,0,0,0,0,0,365,1433,0,0,0,0,28,103,0,0,798,1013,0,0,0,0,0,0,0,
+-0,39,1925,0,853,0,0,271,519,0,0,0,0,338,0,0,300,470,419,0,0,0,0,0,0,836,0,0,0,0,
+-0,0,1937,0,0,0,0,0,393,0,0,357,0,0,0,0,0,703,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,387,0,0,0,0,0,0,75,708,453,1351,0,303,0,0,772,0,0,0,0,0,0,0,0,749,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,1065,0,0,717,226,0,0,0,0,0,890,431,626,0,0,0,0,706,0,0,0,
+-51,698,0,0,0,0,0,0,0,0,0,0,0,828,0,0,17,0,0,0,0,1929,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,84,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,871,498,0,101,1793,0,0,0,0,0,0,435,0,
+-0,0,0,0,966,0,129,1644,0,0,0,0,0,0,0,0,0,0,0,0,0,997,502,0,0,0,0,0,0,0,0,0,0,0,
+-0,823,0,1927,0,0,0,0,98,1756,0,0,0,0,0,0,0,0,0,0,0,0,8,0,160,1046,0,492,0,0,0,0,
+-0,0,129,45,0,0,0,0,0,0,353,558,0,0,0,0,0,785,0,0,0,1145,189,0,0,0,26,353,0,0,0,
+-0,0,2024,0,0,0,606,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,855,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,2011,0,0,5,4,0,0,461,764,0,0,0,1449,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1445,0,0,
+-0,1168,0,0,0,233,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,255,0,0,216,0,0,0,286,0,0,0,
+-3,0,0,0,723,536,0,0,0,0,0,285,0,0,0,560,0,0,0,0,0,690,0,0,0,0,0,1246,0,0,63,0,
+-33,0,0,0,0,0,520,1862,0,0,0,0,0,0,0,0,0,0,0,0,630,0,0,0,0,554,0,0,0,0,0,1001,0,
+-0,0,0,0,446,0,0,0,0,0,0,0,1313,0,0,837,636,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,278,
+-0,0,0,0,0,0,0,0,868,0,0,0,0,1010,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-1231,0,304,0,506,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,26,0,93,1408,794,
+-843,704,0,285,114,485,898,145,0,19,2035,0,0,0,1933,0,0,0,0,0,0,0,1728,0,0,0,0,0,
+-0,0,0,746,0,0,0,0,0,0,0,995,1964,0,0,0,0,0,0,0,0,0,0,0,1550,0,874,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,1018,0,0,0,814,126,0,0,1264,0,0,814,955,0,0,0,0,0,0,
+-0,981,0,0,0,0,0,0,0,0,915,56,0,0,100,0,0,0,0,0,0,0,0,0,638,0,0,0,0,738,0,0,0,0,
+-0,0,0,0,0,758,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1112,0,0,214,0,0,0,133,0,196,
+-168,0,0,0,0,0,1152,0,1245,0,0,538,169,871,1816,0,0,413,133,0,0,0,978,0,0,43,93,
+-371,0,0,0,0,0,0,526,25,0,754,335,0,0,0,0,182,0,0,0,0,0,0,0,0,0,0,0,39,601,0,0,0,
+-0,0,0,0,181,370,0,0,1652,358,0,0,0,0,0,0,0,0,0,176,286,0,788,0,0,0,0,0,1223,780,
+-254,1003,896,0,0,0,1447,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,744,0,0,0,0,0,126,0,
+-41,788,0,0,0,629,0,0,0,0,0,0,0,0,0,0,0,293,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,420,37,1900,0,0,0,0,542,1570,957,0,0,0,0,0,0,
+-0,373,31,0,0,0,0,125,325,0,0,0,0,0,0,323,0,0,1547,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-1216,0,0,0,0,0,0,198,1905,629,15,0,0,0,0,0,0,20,75,543,1353,0,0,0,533,0,0,6,0,0,
+-0,0,0,0,538,0,0,0,0,0,0,0,0,0,0,0,338,0,0,0,0,11,0,0,0,284,659,0,989,0,0,0,0,0,
+-0,0,0,0,848,0,0,507,0,0,0,0,0,0,0,0,188,991,884,0,0,0,0,60,959,0,0,0,0,0,1653,0,
+-0,922,337,0,638,0,0,500,0,0,0,0,0,0,0,0,0,0,0,166,0,0,0,0,0,0,0,0,0,0,0,0,418,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,760,0,0,0,0,0,0,1277,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,770,0,0,0,0,0,0,0,243,89,0,0,0,0,0,0,0,0,0,1396,0,
+-560,0,0,3,1658,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,586,0,0,1271,0,0,0,505,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1947,
+-41,445,0,0,0,0,0,0,0,0,57,189,0,0,371,0,0,0,0,552,0,883,0,923,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,875,0,0,0,1788,49,0,0,0,0,0,
+-0,0,0,0,0,0,661,0,0,1945,0,0,0,0,0,794,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,1135,0,0,0,745,0,0,0,0,0,0,0,84,0,0,0,0,0,0,0,410,0,976,0,0,0,0,0,703,0,0,
+-0,0,0,0,187,322,0,0,0,227,0,0,0,0,560,0,31,1395,0,0,0,0,0,466,0,0,0,0,643,167,0,
+-0,0,1428,0,412,0,0,0,0,0,0,0,0,0,1118,562,0,0,0,0,0,256,0,0,0,0,0,0,1771,0,0,0,
+-0,0,1190,132,0,66,0,0,0,0,0,0,0,0,0,0,317,0,0,0,63,0,0,0,0,0,0,0,1475,0,0,0,0,0,
+-0,0,288,0,0,0,0,608,0,0,0,0,0,0,0,0,1225,0,1189,0,0,0,0,0,0,0,1468,0,0,0,0,0,
+-689,120,0,0,0,0,0,0,0,1,0,329,0,0,0,0,226,0,0,0,0,0,1855,0,0,461,0,0,0,0,1346,0,
+-0,0,0,0,85,0,0,299,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1171,0,0,
+-0,980,0,0,0,0,0,0,0,0,637,279,0,0,0,0,0,293,0,0,0,0,528,17,0,0,0,0,5,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,48,0,0,0,0,0,0,0,601,0,0,0,0,0,0,779,0,
+-196,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1322,737,752,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,412,192,80,0,0,8,1470,0,0,0,0,0,0,0,0,0,873,0,0,0,0,0,835,0,0,0,0,256,
+-38,986,0,0,0,0,0,0,0,0,0,91,257,278,911,0,0,0,0,0,0,0,0,749,151,0,0,0,0,0,0,0,0,
+-0,0,0,0,989,0,0,990,0,0,90,194,0,0,0,0,0,425,0,0,0,0,0,774,0,0,0,0,0,0,0,0,0,0,
+-646,827,752,0,0,0,662,0,22,21,0,0,0,0,0,0,95,239,0,0,0,431,0,0,0,0,0,874,0,0,
+-265,65,0,0,0,1350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1887,0,0,0,0,0,0,0,809,
+-0,696,0,1074,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,630,0,0,802,0,0,0,56,776,0,
+-970,0,0,797,0,0,0,0,0,400,0,0,1951,0,0,41,0,11,118,0,0,0,0,0,0,0,0,251,615,0,0,
+-0,1044,0,0,0,0,0,0,0,0,0,0,0,225,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,370,0,0,0,0,
+-104,48,209,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,930,0,0,0,0,
+-0,0,0,0,0,0,0,1286,0,759,0,120,385,0,0,0,429,0,0,0,0,0,0,0,0,820,0,0,0,0,0,0,
+-199,0,10,151,0,0,0,761,365,0,0,0,0,0,0,0,0,0,46,1086,0,0,0,0,11,1624,58,344,0,0,
+-1008,1868,0,0,0,888,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,711,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,440,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,914,1913,0,958,0,885,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,847,276,0,302,65,0,0,0,510,0,1514,0,0,0,0,0,0,152,291,0,0,0,0,0,0,0,0,0,0,0,
+-0,282,589,0,0,0,0,0,0,0,0,0,0,0,0,0,130,0,0,463,42,0,0,0,0,0,372,0,0,0,0,0,0,0,
+-0,0,680,0,0,0,0,0,0,0,0,977,1997,0,0,0,810,0,0,0,0,0,0,0,0,0,1390,0,0,0,644,0,0,
+-867,982,0,0,0,0,0,0,0,540,0,123,0,0,0,1978,0,0,0,0,789,623,0,1723,0,1220,0,0,0,
+-0,0,0,0,480,0,0,0,0,0,0,0,0,0,0,0,888,0,0,0,0,0,0,0,0,0,0,0,0,299,1995,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,788,179,0,0,0,0,0,0,431,156,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1373,39,80,196,0,0,507,0,0,0,646,0,0,0,0,
+-0,1214,0,0,0,0,926,0,0,0,1,114,0,0,0,0,0,446,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,490,0,0,0,491,0,1584,0,0,507,250,0,0,0,158,
+-10,362,1,0,0,0,0,0,0,0,0,0,408,228,860,480,0,779,0,0,0,557,0,0,142,197,0,0,0,0,
+-0,0,0,0,0,0,0,1490,11,378,316,1057,0,0,18,579,299,1546,0,177,0,0,0,0,0,0,0,0,0,
+-411,0,0,0,0,727,439,0,0,0,0,0,1528,0,0,0,0,0,0,58,0,482,0,0,0,505,1952,0,0,0,0,
+-0,0,0,0,0,0,0,242,0,0,0,0,0,0,0,953,0,0,0,0,802,0,0,0,0,0,0,0,0,0,0,290,0,0,791,
+-52,0,0,0,0,0,0,0,0,0,0,0,112,0,0,0,0,0,1028,0,0,138,0,0,0,0,1811,0,0,0,0,0,0,
+-934,1821,0,0,0,0,371,38,0,0,0,1296,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,723,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1330,0,0,0,0,0,0,0,1255,296,109,0,0,0,0,0,660,0,0,0,0,270,591,0,
+-0,0,0,0,0,0,1090,81,0,0,0,0,391,0,0,0,0,249,322,0,0,0,0,0,0,0,1412,0,0,0,0,0,0,
+-0,0,0,0,526,632,0,0,0,0,0,0,235,144,0,0,0,0,0,940,0,0,0,52,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,309,196,0,0,0,0,0,1912,0,1290,0,686,0,0,625,0,0,0,0,0,0,0,0,0,0,0,412,0,
+-0,0,0,43,0,0,0,0,11,967,758,0,0,0,0,0,0,0,0,0,0,0,0,0,0,220,0,0,0,0,0,0,0,0,0,0,
+-873,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,890,0,0,2,0,0,0,0,0,0,0,0,1774,
+-393,263,0,0,0,0,0,0,818,456,0,0,251,178,393,97,0,0,0,0,0,674,168,0,0,0,0,0,0,0,
+-159,1639,0,0,0,0,0,0,0,0,59,934,0,191,0,0,0,0,346,165,0,877,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,128,0,0,0,0,0,0,1297,0,0,0,0,0,0,164,0,0,0,15,132,241,1073,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,228,324,53,0,0,910,0,0,0,0,0,0,0,0,734,705,
+-217,73,0,0,0,0,0,0,0,0,636,389,0,1409,0,0,0,0,0,893,0,0,0,0,21,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,721,0,0,0,959,0,0,0,0,1433,0,0,0,0,0,0,0,0,0,0,0,0,174,189,0,0,0,0,0,
+-0,0,0,0,0,22,2,0,0,815,354,0,0,0,0,425,0,411,60,13,1611,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,1478,596,0,0,398,0,50,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,192,1159,0,0,0,0,0,
+-592,223,0,0,0,0,0,0,0,245,64,0,0,0,0,278,0,604,0,0,1502,265,0,0,0,0,0,0,0,310,
+-1763,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,129,0,0,0,0,0,0,0,0,0,1356,0,0,0,0,0,0,0,
+-0,505,0,0,0,0,0,0,0,1000,0,0,966,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,839,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,637,0,0,0,0,0,0,0,0,0,0,0,0,0,0,590,0,0,0,0,280,0,0,0,1386,0,0,0,
+-281,0,1064,0,0,0,0,0,917,0,0,15,555,0,0,1014,1883,0,0,0,965,0,0,117,33,0,0,0,
+-801,0,0,0,0,0,877,0,824,0,0,0,0,0,0,0,0,0,0,0,365,0,0,0,0,0,0,774,7,0,430,0,0,
+-231,360,0,0,0,0,0,0,0,0,822,740,0,0,929,1485,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,852,0,0,0,0,17,0,0,0,0,0,0,1001,0,0,0,0,35,831,0,0,384,457,0,0,0,1351,0,27,
+-0,0,984,0,264,552,0,401,0,0,0,710,0,1211,0,0,11,205,0,0,0,0,0,0,0,0,0,0,0,0,5,
+-579,0,717,0,0,1011,0,0,0,0,0,0,0,0,0,0,0,0,0,0,805,0,0,0,0,0,0,0,0,0,0,0,489,0,
+-0,0,1024,0,0,0,0,0,0,0,0,0,892,0,0,0,0,0,0,0,0,0,0,0,0,473,0,0,0,659,864,0,0,0,
+-0,0,0,152,819,0,51,0,0,0,0,0,0,0,0,0,0,130,0,0,0,0,0,229,0,0,0,0,674,0,0,0,0,0,
+-0,0,0,0,770,52,79,0,0,0,1666,0,409,0,0,0,0,0,0,0,195,0,688,0,0,0,0,0,0,0,0,0,0,
+-0,889,174,160,0,0,0,0,0,0,0,0,0,0,0,0,0,872,0,918,569,268,0,0,0,1224,0,1361,0,0,
+-0,0,0,0,0,0,0,374,0,0,0,0,0,731,0,0,0,0,190,0,0,0,0,0,0,0,202,506,444,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,835,0,17,1526,0,0,0,0,0,477,0,0,
+-994,1374,76,0,0,0,0,0,0,0,355,287,0,1389,0,0,0,0,0,0,455,384,0,0,0,264,0,0,0,0,
+-0,0,0,0,0,0,0,0,1001,0,0,0,0,0,0,0,0,0,0,0,0,28,0,0,0,851,175,359,0,0,0,0,0,0,0,
+-0,287,740,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,857,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-819,1402,0,0,0,0,0,0,174,224,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1649,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,655,573,0,0,0,0,0,0,0,0,128,351,0,0,0,0,0,0,
+-0,0,0,0,0,918,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,687,0,0,0,0,0,0,0,0,0,1525,
+-0,0,0,1009,0,0,0,0,0,0,0,340,0,0,0,0,0,0,0,0,0,0,861,0,176,0,0,0,0,0,0,0,0,0,96,
+-985,0,615,0,0,0,0,0,0,0,1919,0,0,0,0,0,1131,0,0,0,0,0,0,0,247,0,0,0,0,27,23,0,0,
+-0,0,0,0,0,0,38,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1015,0,0,0,0,0,1088,0,0,
+-0,0,0,1585,0,0,0,0,227,0,0,0,478,360,0,0,0,95,0,0,0,0,0,0,699,0,0,0,26,0,0,0,0,
+-1119,0,0,0,739,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,741,67,0,0,0,0,0,0,464,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,42,0,96,0,0,0,26,342,0,0,0,0,0,0,203,0,0,449,0,
+-0,0,0,0,0,0,0,0,0,256,311,0,0,0,0,0,0,758,0,0,0,0,0,0,0,0,827,0,0,0,0,581,64,0,
+-1047,0,0,0,0,0,288,0,0,0,0,0,1375,0,0,0,0,0,0,0,0,0,0,0,1309,0,0,0,0,0,0,0,0,
+-376,12,0,0,0,0,0,154,0,1520,0,1753,95,502,0,0,0,0,0,0,0,269,291,1197,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,0,0,1341,0,1017,0,0,0,0,0,0,0,
+-0,857,1810,533,0,0,1453,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,836,211,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,19,0,156,0,0,0,0,1009,0,0,0,0,0,0,0,0,0,0,0,0,0,820,0,0,
+-0,0,0,0,0,0,0,228,0,0,0,1131,0,1276,0,0,0,0,0,0,0,0,0,0,0,0,849,1792,0,0,389,
+-291,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,525,0,0,
+-0,453,0,0,0,0,666,0,0,0,422,0,355,0,0,0,0,165,0,260,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,865,0,0,0,0,0,0,0,1625,0,0,0,234,0,1383,0,0,0,0,0,0,0,0,306,0,0,0,802,1921,
+-0,0,0,0,0,0,180,0,0,0,0,1312,814,0,0,0,0,0,0,0,0,0,0,707,0,0,0,1493,11,61,733,0,
+-0,0,341,0,0,0,98,0,0,0,0,0,0,0,0,0,0,0,1014,0,0,0,0,0,0,0,142,102,0,0,30,0,0,
+-823,0,1045,0,0,0,1930,0,1512,0,0,0,0,0,0,0,87,0,1243,245,0,0,0,0,0,0,0,48,68,0,
+-0,0,0,0,0,0,0,126,77,625,938,0,0,351,0,0,0,174,1668,0,707,0,0,0,0,0,0,0,0,0,0,0,
+-403,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,282,0,0,0,0,0,0,8,44,0,0,363,115,0,0,0,0,0,0,
+-0,0,0,0,0,0,545,761,0,0,835,1254,0,0,0,0,930,1936,0,0,0,0,0,0,0,0,653,0,0,0,0,0,
+-344,0,0,1483,673,185,0,0,460,93,753,478,0,0,0,0,0,1020,0,0,0,0,0,0,0,103,0,0,0,
+-499,0,0,0,0,0,0,207,0,0,0,0,0,0,0,0,0,0,0,0,0,0,96,0,968,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,3,0,0,0,0,399,0,0,0,0,224,563,0,0,0,0,0,704,0,0,0,0,0,0,0,0,0,0,0,
+-1559,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,861,0,0,0,0,946,333,746,0,0,0,0,0,
+-0,0,910,0,0,0,0,0,0,0,0,0,0,0,0,0,652,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-1393,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1514,0,0,0,0,201,0,510,717,0,0,528,0,0,0,0,
+-20,0,0,0,1251,0,0,0,1163,0,0,0,307,0,0,0,0,0,1091,0,0,0,0,0,0,0,0,0,0,0,429,0,0,
+-0,881,0,0,0,0,0,621,0,0,0,0,0,0,0,736,0,348,0,868,0,0,0,0,433,0,0,0,771,1495,0,
+-0,0,0,215,0,0,0,0,0,124,0,0,0,0,0,0,0,0,0,0,0,55,0,0,0,0,0,0,0,112,62,0,856,270,
+-0,572,0,0,0,0,939,0,0,0,0,0,0,0,352,0,0,0,0,0,0,0,0,0,647,0,0,0,0,10,0,0,0,0,0,
+-0,0,220,0,0,0,0,0,0,0,0,0,0,0,0,0,464,0,0,109,0,0,0,1746,0,0,0,515,0,0,0,566,0,
+-0,0,0,0,0,67,40,0,0,722,992,0,0,923,0,0,0,0,0,0,1145,0,0,0,0,0,0,0,0,0,0,0,568,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,247,0,0,0,0,645,0,0,328,0,0,0,0,0,0,0,0,0,0,0,0,
+-1363,0,0,0,0,0,1280,0,0,0,0,0,0,0,0,0,0,7,28,360,162,0,0,0,0,0,0,0,0,0,0,0,764,
+-0,0,833,862,0,856,0,0,0,0,0,0,736,92,0,0,948,1944,0,1479,63,590,0,0,0,1521,0,0,
+-0,709,0,0,61,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,483,0,0,0,0,1213,
+-0,0,0,0,29,1022,0,1712,0,466,0,0,0,0,0,0,0,0,0,0,0,0,0,731,0,0,0,0,0,0,171,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,241,0,0,0,0,0,0,0,0,0,0,0,964,2005,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,1100,0,0,0,954,0,0,0,0,0,0,0,0,0,1958,0,0,34,549,994,0,0,449,
+-137,850,0,0,670,146,0,0,0,0,518,159,0,0,0,0,0,0,0,0,151,0,0,1027,0,0,0,0,0,0,0,
+-0,0,0,983,0,0,0,0,993,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,141,501,0,0,0,
+-0,0,0,0,0,0,452,0,0,0,0,0,0,0,0,0,0,233,149,0,0,0,0,0,0,0,0,582,0,0,0,801,0,0,0,
+-0,0,0,70,0,0,369,0,36,0,0,0,0,0,0,0,204,721,430,241,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1817,16,1078,1021,0,0,
+-406,0,0,0,0,0,69,0,0,0,0,0,1830,0,0,0,824,0,0,0,0,0,0,0,0,0,826,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,816,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1000,717,1845,0,423,0,0,
+-0,0,0,0,0,0,510,0,0,1048,0,0,0,618,0,0,0,520,0,0,0,0,990,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,321,0,0,0,0,0,0,0,1135,0,0,921,0,0,0,24,397,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,856,0,0,0,139,282,981,0,288,0,0,0,1890,651,56,0,0,0,0,0,0,0,
+-0,261,0,0,0,0,0,0,0,0,0,0,0,617,1403,0,1205,0,0,563,0,0,0,0,0,0,0,0,333,0,0,0,0,
+-0,369,0,0,0,0,0,0,0,0,0,622,0,0,0,1407,0,0,0,0,0,0,0,0,0,0,0,0,624,160,0,363,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,619,0,174,292,0,0,656,616,0,0,0,685,0,0,0,0,0,0,0,0,0,0,0,0,0,647,0,0,0,631,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1267,0,0,0,1797,0,0,0,1684,0,0,469,0,531,
+-1230,73,0,0,0,0,0,0,0,0,0,268,0,0,0,0,0,102,558,109,65,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,595,0,0,0,0,0,374,1832,0,0,0,0,0,0,16,0,405,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,881,0,1495,0,0,0,0,0,0,0,0,0,142,0,0,0,0,0,0,0,0,0,0,21,466,23,
+-257,0,0,0,0,0,0,77,404,0,0,0,0,0,0,712,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,860,
+-1848,0,0,652,629,0,0,0,0,13,377,0,1842,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1501,0,
+-0,0,1906,0,0,0,0,0,0,0,0,0,0,0,0,0,491,234,171,0,0,0,0,631,1186,0,0,0,0,0,0,0,0,
+-0,0,0,0,931,0,170,0,0,0,0,0,0,0,0,0,0,1587,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-765,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,424,0,0,714,0,0,0,0,685,0,0,0,0,0,
+-0,285,0,0,0,0,0,0,429,0,0,0,0,0,0,0,0,0,0,71,18,0,0,0,0,0,0,0,0,0,0,116,828,0,0,
+-0,0,0,0,289,0,0,0,0,0,0,0,0,675,0,0,0,1424,0,0,0,0,0,647,0,0,0,1334,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,36,209,0,0,0,0,0,0,0,342,0,0,0,928,0,0,0,0,0,1838,118,856,654,
+-318,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,915,895,454,0,0,513,1425,0,0,
+-0,0,0,0,791,0,153,0,0,0,0,0,0,796,909,445,345,0,0,0,0,0,0,0,0,578,0,0,0,1387,0,
+-0,0,555,0,0,0,0,0,0,766,0,0,0,0,0,0,0,0,0,0,541,0,0,0,0,0,0,0,0,0,0,0,0,0,880,0,
+-0,0,0,0,1506,0,0,983,0,768,0,0,0,0,584,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,737,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,226,30,426,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-117,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,462,0,0,0,385,0,398,0,0,0,0,0,0,
+-0,0,0,347,0,0,0,0,125,1259,644,136,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,469,0,0,0,0,0,
+-1367,0,0,0,0,0,0,0,0,0,0,0,719,0,0,0,0,0,0,0,0,0,0,0,0,0,1423,0,0,0,0,0,0,0,0,0,
+-749,0,0,0,0,546,645,0,0,0,0,0,0,277,0,0,1275,0,0,0,0,0,0,0,453,536,555,0,0,987,
+-1107,0,0,90,0,0,0,0,0,0,0,0,860,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-257,0,1768,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1071,0,0,0,0,0,0,0,0,0,0,0,0,0,83,
+-0,835,0,0,0,0,0,0,0,2006,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,696,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,95,1718,0,0,0,0,0,0,0,26,0,550,0,0,0,0,0,901,0,0,0,0,0,
+-0,822,0,0,122,0,0,0,807,0,0,0,0,0,262,0,620,601,34,0,0,170,0,0,0,0,537,0,0,0,0,
+-0,0,0,0,0,332,0,0,208,1909,182,261,0,0,0,1721,0,0,0,0,0,933,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,1609,0,895,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,812,0,0,942,1916,0,0,0,0,
+-0,0,0,778,0,0,0,137,0,1314,0,0,0,0,0,0,0,1661,0,0,0,0,0,0,0,1591,0,0,0,0,0,0,
+-820,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,185,89,0,1160,230,6,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,63,29,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1740,0,0,177,
+-170,0,1961,0,0,0,0,0,0,0,0,0,0,0,0,91,0,17,44,0,0,0,0,0,0,0,0,0,270,0,296,0,0,0,
+-0,0,0,0,1523,0,0,0,0,0,0,0,0,0,0,757,7,0,0,0,0,0,0,0,0,0,0,530,588,0,0,0,0,0,0,
+-0,0,0,786,0,0,0,0,0,580,627,88,447,57,0,0,0,0,0,0,0,0,845,735,0,0,0,0,0,31,15,0,
+-460,521,12,424,0,0,0,1302,0,0,0,0,0,0,0,595,0,0,0,13,548,97,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,1472,452,1767,0,0,0,0,0,0,0,0,0,0,115,0,0,0,0,0,0,1543,0,1111,0,0,0,0,
+-1,0,359,488,0,267,0,0,0,1983,0,0,0,0,0,0,0,1155,0,1575,0,1438,31,0,0,377,101,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,476,0,0,0,0,0,0,0,0,2023,0,0,0,0,0,1836,0,0,0,0,35,843,
+-0,0,0,0,0,0,0,554,0,0,0,536,625,207,0,1371,0,0,0,424,785,336,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,896,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27,750,0,0,0,0,238,0,0,
+-0,0,0,383,0,0,0,0,0,0,0,0,603,725,11,0,0,0,0,0,0,0,0,0,476,0,0,0,0,0,1552,0,0,0,
+-0,0,0,0,680,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,435,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-1431,0,0,13,112,0,0,356,0,0,0,0,0,0,0,0,0,0,1963,0,0,0,1244,18,0,0,0,0,0,0,867,
+-0,0,0,0,0,0,50,708,73,592,0,502,0,0,0,0,0,0,161,347,0,0,0,0,470,33,0,246,571,10,
+-0,465,614,0,237,0,0,0,0,0,24,18,0,506,0,0,0,0,0,0,33,309,0,0,0,0,0,0,0,0,0,0,
+-140,0,0,0,0,1056,0,0,0,1704,0,0,0,0,0,0,0,1036,0,0,0,0,0,0,0,0,0,1315,432,86,
+-264,524,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,107,0,0,0,0,0,123,927,0,0,957,1149,0,0,
+-0,0,0,778,0,502,196,0,0,0,0,1312,0,0,0,0,0,0,0,855,0,0,0,0,0,0,0,0,0,0,45,1400,
+-0,0,0,1003,0,0,0,0,0,1097,0,0,0,0,0,0,0,0,545,612,0,0,0,0,0,0,0,0,0,0,0,0,54,0,
+-0,0,0,172,0,0,0,1029,0,0,0,0,0,0,0,0,0,568,0,0,0,732,617,0,0,974,94,989,733,0,0,
+-0,0,0,0,1789,0,0,665,2015,0,0,0,0,0,0,806,287,0,0,0,0,0,1539,0,0,0,0,0,0,0,0,0,
+-0,182,1563,0,0,0,0,0,0,0,0,0,484,0,0,0,0,0,1623,0,0,0,0,0,0,0,0,878,1833,0,1569,
+-0,0,0,0,0,0,0,0,93,0,715,994,0,0,0,0,0,63,0,591,0,0,0,0,0,0,0,749,0,0,0,0,547,
+-366,0,0,0,1747,0,0,0,0,0,0,0,89,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1463,0,772,
+-893,0,0,0,48,0,0,941,0,0,690,1785,106,440,0,0,0,0,0,0,0,0,0,0,32,0,332,216,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,852,0,
+-0,416,564,0,918,0,1764,0,0,3,0,0,274,0,0,0,0,501,0,0,0,0,0,0,0,851,743,0,49,0,
+-879,0,0,47,0,0,0,0,0,0,865,0,1202,0,0,0,0,0,0,47,272,0,0,0,0,0,0,0,0,0,0,0,1455,
+-0,0,0,0,891,1911,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,761,0,0,0,0,0,0,0,0,0,407,0,
+-183,0,0,490,0,0,0,0,0,0,0,35,731,0,0,0,0,0,0,0,819,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-575,0,0,0,0,45,818,0,0,77,222,0,0,0,0,849,1880,0,0,0,633,0,1308,0,0,0,0,0,0,0,0,
+-0,0,86,0,0,0,0,0,0,0,0,0,0,0,0,0,0,817,0,0,0,0,0,0,0,0,0,882,0,0,0,914,0,0,0,0,
+-0,0,0,0,0,0,865,0,0,426,399,58,0,0,0,0,0,0,538,102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,876,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,139,566,0,63,12,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,3,114,0,0,0,0,0,0,0,0,576,0,0,0,0,0,0,0,0,933,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,692,0,0,0,0,0,0,0,0,0,0,0,0,752,0,0,0,0,
+-0,0,0,0,375,0,1011,0,0,96,0,0,0,0,0,0,0,0,0,148,0,0,0,0,0,0,0,0,0,0,0,337,56,
+-666,0,246,394,0,0,0,0,0,0,0,0,437,0,0,0,506,0,0,0,0,1003,0,1163,0,328,0,0,0,0,0,
+-0,0,0,1000,0,0,0,0,0,744,101,0,0,0,0,0,726,0,0,176,0,146,9,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,839,0,0,0,0,0,0,223,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,246,1931,29,0,0,1771,0,0,0,0,0,846,6,157,0,0,0,0,0,0,0,0,0,875,0,0,477,
+-773,177,639,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1747,0,0,0,0,158,873,0,659,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,391,0,0,0,0,0,0,0,0,0,0,0,0,668,883,0,78,628,0,0,0,
+-0,0,0,0,0,0,0,0,0,1460,0,962,0,0,0,0,0,460,0,0,0,0,0,0,0,0,0,0,0,0,0,0,34,199,0,
+-0,0,388,474,0,271,0,333,608,0,0,0,0,0,0,49,0,988,0,707,617,0,0,0,0,0,0,0,756,0,
+-0,0,0,0,1583,0,0,0,0,0,0,0,0,0,0,285,0,0,0,0,0,0,0,0,0,0,0,0,0,0,344,0,0,0,0,0,
+-0,0,0,515,1709,0,0,0,0,0,0,0,0,404,0,0,0,0,500,0,0,0,0,0,0,0,0,0,68,216,0,0,0,0,
+-0,0,0,488,353,0,0,177,236,0,0,458,490,0,0,0,0,0,0,756,1504,0,757,0,1735,0,0,108,
+-598,0,0,0,0};
+-BROTLI_INTERNAL const uint8_t kStaticDictionaryHashLengths[32768] = {
+-8,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,12,0,0,0,0,4,22,5,0,
+-4,0,0,0,0,0,0,0,0,0,0,0,0,14,6,0,0,0,5,0,0,0,0,0,0,0,7,13,0,0,4,0,0,0,0,0,0,0,0,
+-0,6,0,0,0,0,8,0,0,0,0,0,0,7,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,4,0,0,0,4,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,10,4,0,5,13,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,8,7,0,0,9,0,8,0,0,0,0,0,0,6,0,
+-0,9,0,0,0,11,0,0,6,8,7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,6,8,0,0,0,0,0,
+-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,0,0,0,8,4,13,7,0,0,0,0,0,
+-7,0,5,0,0,0,0,8,5,0,5,0,0,8,7,0,0,0,0,0,0,0,0,0,0,9,0,0,0,8,0,0,0,10,4,0,5,0,4,
+-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,8,7,0,4,9,4,0,0,0,0,0,0,
+-9,0,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,7,18,0,0,0,0,4,9,0,0,4,0,6,0,0,0,6,0,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,8,7,0,0,0,
+-0,9,0,0,0,0,0,0,0,8,6,10,6,0,0,0,4,0,6,8,6,0,0,0,4,0,0,0,0,0,5,0,0,0,6,0,0,0,0,
+-10,0,12,7,0,0,0,0,0,4,0,0,0,0,0,5,0,0,8,7,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,6,11,0,0,0,0,0,0,0,0,0,8,7,0,0,10,0,0,0,0,0,0,0,0,6,10,0,17,0,8,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,8,6,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-7,0,0,11,4,0,5,0,0,0,0,0,0,0,0,0,0,10,5,0,6,8,5,0,0,0,0,0,0,0,0,0,0,11,5,0,0,0,
+-0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,9,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,0,0,0,0,
+-0,0,0,0,0,0,5,0,0,0,6,0,0,10,0,0,0,20,0,0,0,0,0,0,0,0,6,9,5,0,0,0,0,10,4,8,0,0,
+-4,13,0,0,0,0,0,0,0,9,0,9,0,0,0,0,0,0,0,0,0,0,0,0,4,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,12,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,12,5,0,0,10,4,10,7,13,
+-0,0,0,0,0,0,0,0,6,0,6,0,6,0,0,0,0,0,0,19,0,0,4,12,6,9,0,0,0,0,4,0,4,11,0,0,0,0,
+-0,0,0,12,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
+-0,5,0,0,0,0,0,6,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,9,6,0,0,0,0,0,4,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,
+-6,0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,6,0,0,
+-0,0,0,5,0,0,0,0,14,4,0,0,0,4,12,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,6,0,
+-0,0,0,0,0,12,0,9,6,0,0,0,0,13,0,0,5,0,0,0,0,0,4,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,13,0,9,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,8,7,8,4,0,0,0,0,0,0,0,0,0,0,0,7,0,7,0,0,0,4,0,
+-0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,8,4,0,0,0,0,0,6,0,7,0,
+-0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,0,9,5,0,0,
+-0,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,9,4,0,0,0,0,0,0,0,4,
+-12,5,11,0,0,0,0,0,0,0,0,0,8,7,0,5,0,0,8,7,0,5,0,0,0,0,8,0,0,0,0,7,0,4,10,0,0,0,
+-0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-13,5,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,14,5,0,0,0,7,0,0,10,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,6,0,4,0,5,0,0,0,0,8,5,0,0,0,0,0,0,9,5,9,0,0,0,0,0,0,0,0,6,9,0,
+-0,4,0,0,0,7,0,0,0,6,0,0,10,4,0,0,0,0,0,6,0,0,10,0,0,0,8,5,0,0,0,0,0,0,0,0,10,0,
+-0,0,0,0,18,4,12,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,7,0,0,0,
+-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,4,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,8,0,0,0,0,0,0,6,0,0,0,4,10,5,0,0,0,0,0,0,0,0,0,0,
+-0,4,8,7,0,0,8,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,
+-0,0,0,8,6,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,8,7,0,0,0,0,8,0,12,6,0,6,0,0,0,0,9,7,11,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,11,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,10,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,6,0,0,0,7,0,4,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,14,0,0,0,0,0,8,4,0,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,20,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,12,5,0,7,0,5,0,0,10,0,0,7,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,6,0,4,9,7,0,0,0,
+-0,0,7,0,0,0,0,0,0,10,0,9,0,9,0,0,0,0,0,0,0,0,4,9,0,0,0,0,6,0,0,0,0,0,0,0,0,11,4,
+-0,6,0,0,0,0,0,0,8,0,8,0,0,0,0,0,0,0,0,0,0,4,0,0,0,5,0,0,0,0,0,0,0,0,13,6,0,0,11,
+-0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,6,18,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
+-0,5,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,0,0,9,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,11,
+-4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,4,0,0,0,0,8,
+-6,0,0,0,0,0,0,9,6,0,0,0,0,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,
+-0,6,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,6,0,6,0,0,10,6,0,0,0,7,0,0,8,0,8,7,0,
+-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,18,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,
+-0,0,0,8,7,0,0,0,0,0,0,0,0,12,0,12,0,0,0,11,6,0,5,0,0,12,0,12,5,0,7,11,6,0,0,11,
+-0,0,0,12,0,0,4,12,7,8,6,0,0,0,0,8,5,0,0,0,0,0,0,0,4,11,0,0,6,0,7,0,0,0,0,0,0,0,
+-5,0,6,0,0,0,0,8,0,10,0,0,0,0,0,0,0,0,0,0,0,9,7,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,0,10,0,0,5,0,0,12,6,0,0,0,0,0,0,10,6,0,0,0,0,8,
+-6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,5,0,0,0,0,11,0,10,6,0,0,8,6,0,0,0,6,0,7,10,6,0,
+-0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,10,7,0,0,0,0,
+-10,6,0,0,0,0,0,0,8,5,11,0,8,4,0,0,0,4,0,0,0,0,9,4,8,0,0,0,0,0,0,0,11,6,0,0,0,0,
+-10,7,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,9,6,0,5,0,7,0,0,0,0,0,7,0,0,11,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,0,13,0,8,6,13,0,0,0,11,7,0,7,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,0,9,6,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,5,9,0,0,0,0,0,0,0,0,0,0,4,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,9,7,0,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,
+-5,11,5,0,0,0,0,0,0,0,0,0,4,0,7,0,6,0,0,0,6,20,0,0,0,10,7,0,5,14,4,0,0,0,0,0,0,0,
+-0,0,6,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,
+-0,0,6,0,4,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,11,6,15,0,0,0,0,0,
+-10,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,7,0,0,0,0,0,0,0,0,9,7,13,0,0,0,0,0,
+-0,7,0,0,8,6,0,0,0,0,0,0,0,0,9,4,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,5,0,0,0,0,0,0,0,0,0,0,0,0,8,5,0,4,0,0,0,0,0,0,0,0,0,0,12,6,8,0,12,0,0,7,0,0,0,
+-0,0,5,10,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
+-14,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,8,7,10,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,18,6,
+-14,7,0,0,0,0,0,0,0,0,11,6,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,11,7,0,0,10,7,0,0,0,6,8,6,0,0,0,0,0,0,0,6,0,0,
+-19,0,0,0,9,5,0,0,0,0,0,0,11,7,0,0,0,7,0,6,0,0,11,0,0,0,0,4,8,0,0,0,0,0,0,0,0,6,
+-0,0,0,0,0,6,0,0,8,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
+-0,7,0,0,0,7,15,0,0,5,0,0,0,0,10,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,7,0,0,
+-0,0,0,0,0,0,9,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-11,7,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,5,0,4,0,0,0,4,0,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,11,6,0,0,8,5,14,0,0,4,0,0,0,7,
+-17,0,0,0,0,0,0,0,13,5,0,0,0,0,0,5,0,0,0,5,0,0,0,0,16,6,0,4,0,0,0,0,0,0,12,0,0,0,
+-0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,5,0,5,0,6,10,0,12,0,0,0,0,0,0,0,0,7,0,0,0,0,8,4,
+-0,0,0,0,0,0,0,0,0,0,8,7,0,0,8,0,0,0,8,0,0,6,0,7,0,0,0,5,0,6,0,4,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,22,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,18,0,0,0,9,4,0,0,8,0,9,7,0,0,0,0,0,0,8,6,0,0,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,9,7,0,0,0,6,0,0,14,0,0,0,0,
+-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,7,10,4,
+-0,6,0,0,0,0,0,0,8,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,9,6,0,0,0,0,0,0,
+-0,0,11,6,12,7,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,0,9,6,11,6,0,0,0,0,9,5,0,0,0,0,0,0,
+-0,6,8,5,0,0,0,0,8,0,10,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,
+-5,10,7,0,0,0,5,8,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,4,8,7,0,0,0,6,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,22,
+-0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,5,0,0,0,0,0,0,0,
+-0,0,0,0,0,17,0,0,6,0,6,12,4,19,6,0,0,0,0,16,0,0,0,0,7,15,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,4,10,4,0,0,8,7,0,7,0,0,9,
+-4,0,6,0,0,0,4,0,5,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,10,0,0,0,0,0,11,7,0,0,
+-0,0,12,6,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,
+-0,0,0,0,0,0,0,0,0,10,4,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,8,7,0,0,
+-0,0,0,0,0,6,0,0,0,4,0,0,11,4,0,0,12,7,0,0,0,0,9,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,
+-4,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,9,4,0,6,0,0,0,0,0,4,
+-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,7,9,6,0,7,0,
+-0,0,0,0,0,0,6,0,0,0,0,8,6,0,0,0,0,10,6,11,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,5,0,4,8,0,0,0,0,0,9,7,0,0,0,0,0,0,
+-13,5,0,0,0,0,8,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,5,0,0,11,7,0,0,0,0,0,0,8,6,0,
+-0,0,0,0,7,0,4,0,0,0,0,0,0,0,5,0,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,10,4,9,0,0,0,0,0,
+-0,4,0,0,0,0,10,5,10,7,0,0,0,0,0,0,0,0,16,7,0,0,0,0,0,7,0,0,0,0,11,0,0,0,0,0,0,0,
+-0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,4,0,0,0,7,0,0,0,0,0,0,13,0,0,
+-0,0,0,0,0,0,0,0,7,0,4,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,13,7,0,7,0,4,16,0,0,0,0,6,8,7,9,7,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,6,0,0,8,5,0,4,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,11,7,0,0,11,
+-0,0,0,0,0,9,5,0,4,0,0,0,0,9,7,8,6,0,0,0,0,0,0,10,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
+-0,7,0,0,0,0,0,0,0,0,0,0,0,4,10,6,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,0,10,7,10,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,6,8,7,12,4,0,0,0,0,0,0,0,5,14,
+-0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,20,4,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,0,
+-0,6,15,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,12,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,5,0,0,0,0,0,0,8,6,0,0,18,0,0,0,10,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,9,6,0,
+-6,0,0,0,0,0,0,0,0,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,9,0,9,0,0,4,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,9,5,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,7,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,0,8,0,0,0,16,0,0,0,0,0,0,0,
+-0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,0,11,0,0,0,9,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,7,0,7,0,6,
+-0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,0,0,0,0,6,0,0,18,0,8,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,7,0,4,0,0,0,
+-0,0,0,0,0,0,0,8,0,0,0,0,0,16,0,0,0,0,0,16,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,18,0,0,0,0,0,0,0,0,0,9,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,4,0,
+-0,0,0,0,0,0,0,9,4,0,0,0,0,12,5,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,5,0,0,0,0,0,0,0,5,0,0,10,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,9,0,0,0,11,0,0,6,0,6,0,0,
+-0,7,0,0,0,0,0,0,8,0,0,0,0,6,0,0,0,0,0,0,19,0,0,0,12,0,9,0,0,0,0,0,10,7,0,0,0,0,
+-0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,16,7,12,
+-0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,10,5,0,0,0,0,0,0,0,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,4,0,0,9,0,0,0,8,0,12,4,0,0,0,0,
+-0,4,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,5,0,
+-0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,0,8,6,0,6,0,0,0,0,0,0,
+-0,4,0,0,0,0,0,6,0,0,9,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,10,6,0,0,0,0,8,
+-6,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,7,0,6,
+-10,7,0,0,10,5,11,6,0,0,0,0,0,7,16,0,0,0,0,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,
+-0,0,0,0,0,8,7,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-8,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,12,7,0,7,0,0,0,
+-0,0,0,0,6,0,0,0,0,9,0,0,0,23,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,4,0,0,11,7,10,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,7,0,0,8,7,8,0,0,0,0,0,0,0,0,0,0,0,14,5,0,0,0,0,
+-0,0,0,0,18,6,8,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,11,0,0,0,9,7,12,6,0,0,0,0,0,0,0,0,
+-0,0,12,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,7,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,8,7,0,0,0,6,10,0,0,0,9,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,6,
+-10,7,0,0,0,7,0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,
+-0,0,0,8,7,8,6,0,0,11,7,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,4,8,7,0,0,0,0,0,0,0,0,
+-0,5,0,0,13,0,0,0,0,5,0,0,9,7,0,0,0,0,0,0,0,4,0,0,11,0,0,7,0,0,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,0,12,7,19,0,8,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,10,6,8,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,7,0,0,12,0,0,0,0,6,9,6,
+-14,0,0,0,0,0,0,6,0,5,0,0,8,7,0,0,0,6,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,4,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,5,0,
+-7,0,0,10,0,9,7,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,0,0,0,0,5,0,6,0,0,0,0,
+-0,0,0,0,0,0,0,6,0,0,0,0,9,7,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,0,11,7,0,0,13,7,
+-0,0,0,0,0,0,0,0,12,0,0,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,11,5,0,5,13,0,8,0,
+-0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,11,5,
+-9,6,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,10,0,0,0,8,5,0,0,9,0,0,0,8,7,9,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,0,
+-0,11,0,13,6,0,0,9,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,5,21,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24,5,0,0,0,0,0,0,0,0,10,0,8,0,
+-0,6,0,0,0,4,0,0,9,0,0,0,0,0,0,0,0,0,0,4,0,0,8,6,0,6,0,7,10,0,8,4,0,4,0,0,0,0,0,
+-5,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,6,12,0,0,7,0,0,0,5,0,0,
+-0,0,0,0,0,0,0,6,0,0,8,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-15,7,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,24,7,0,0,0,0,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,4,12,0,0,7,0,0,0,0,0,5,0,0,0,0,0,0,0,0,15,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,8,0,0,0,
+-0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,9,0,9,6,
+-0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,8,4,0,7,0,0,0,0,0,0,0,0,
+-22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,4,0,7,0,0,21,7,0,7,9,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,8,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,23,0,0,0,0,7,0,0,0,
+-4,0,0,0,0,0,0,0,0,9,4,11,7,0,5,0,0,0,0,11,0,0,4,20,0,0,0,0,0,0,0,0,0,0,0,11,5,0,
+-7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-21,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,11,6,0,0,0,0,0,0,0,0,9,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,5,0,4,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,
+-0,0,0,10,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,7,0,0,11,7,0,0,0,0,0,0,0,4,
+-0,4,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,7,0,
+-0,0,0,0,0,0,0,0,6,0,0,21,6,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,14,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,8,0,0,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,
+-0,0,0,8,7,0,0,11,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,7,13,7,10,4,0,
+-0,0,6,0,0,0,0,0,0,0,0,0,5,10,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,0,8,4,0,0,0,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,12,7,0,6,0,0,10,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,
+-0,0,0,0,7,0,0,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,10,5,0,6,0,0,0,0,0,4,0,0,0,0,
+-0,0,0,0,0,4,0,0,0,0,9,0,11,4,0,0,0,6,0,0,0,5,12,7,0,5,0,0,0,0,0,4,0,0,0,7,0,0,0,
+-0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,13,6,10,0,0,0,17,0,0,4,0,0,0,0,0,6,0,4,0,5,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,11,7,0,0,0,7,0,0,0,6,0,0,0,0,0,0,
+-0,6,0,4,0,0,0,0,8,0,0,0,0,5,0,0,0,0,0,4,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,9,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,0,0,
+-0,0,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,16,4,0,0,11,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-8,7,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,8,6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
+-7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,12,5,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,
+-5,18,7,0,0,14,0,0,0,0,0,0,0,9,4,0,7,0,0,0,0,0,0,0,5,0,0,0,6,0,0,0,6,0,0,0,0,0,0,
+-8,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,7,0,0,0,0,0,0,11,0,0,0,
+-10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,14,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-11,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,14,6,0,0,0,0,11,4,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,10,7,0,6,0,0,9,0,9,5,0,0,0,0,0,
+-0,0,0,10,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,8,5,0,0,0,0,0,0,0,0,0,0,11,4,0,6,
+-0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,12,4,0,6,8,6,0,0,0,0,0,0,0,0,0,0,8,0,0,5,0,0,0,0,0,0,0,7,0,0,13,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,12,7,0,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,13,4,0,7,0,0,0,7,0,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,0,0,0,
+-9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,10,6,21,5,0,0,0,0,8,0,0,0,0,4,0,
+-7,0,0,0,0,0,0,11,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,4,0,0,0,0,0,0,
+-0,7,9,6,11,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,7,10,0,0,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,19,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,18,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,9,4,10,4,0,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,9,7,9,7,10,4,0,7,0,0,0,0,0,0,0,6,12,0,
+-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+-0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,8,0,
+-0,0,0,0,0,5,0,0,8,7,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,
+-0,0,0,0,4,0,0,8,0,0,6,0,0,0,7,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,7,9,7,0,0,0,4,8,0,0,0,0,6,11,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,13,4,0,0,
+-12,6,0,6,0,0,0,0,8,7,0,7,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,4,0,0,0,0,0,0,0,0,0,0,9,
+-7,22,0,0,0,0,4,0,0,0,0,0,6,0,0,0,4,0,0,9,0,0,6,0,0,24,7,0,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,10,6,0,5,0,0,0,0,0,0,0,7,0,0,8,0,0,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,7,0,
+-7,0,0,0,0,0,0,13,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,0,
+-0,0,0,0,0,7,12,0,9,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,4,0,0,0,7,0,
+-0,0,0,8,7,0,0,0,0,0,0,0,0,0,4,18,0,0,0,0,0,10,0,0,5,0,0,11,0,0,0,0,0,0,5,0,6,0,
+-0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,
+-4,0,0,0,0,0,0,10,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,
+-0,0,0,5,8,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,20,7,0,0,0,0,0,0,0,0,0,0,0,4,9,0,12,
+-6,8,0,14,7,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,10,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,9,6,0,7,12,0,0,0,0,4,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,
+-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,4,0,0,9,0,
+-12,6,0,5,0,0,0,6,0,4,0,6,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,0,8,0,0,0,0,4,0,0,0,0,
+-10,0,0,0,0,0,0,0,8,6,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,12,6,20,5,0,0,0,0,0,0,0,0,0,0,0,0,9,5,0,5,0,0,0,6,13,7,0,0,0,0,15,6,0,0,0,
+-6,0,0,13,7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,
+-10,6,0,0,0,0,0,6,0,0,0,0,9,0,0,0,0,0,19,6,0,0,0,0,0,0,0,0,0,0,13,0,11,0,0,0,0,0,
+-0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,10,0,0,6,0,0,0,0,8,0,0,
+-0,9,0,15,4,0,6,0,0,0,0,0,6,12,0,0,0,0,0,0,0,14,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,
+-0,0,0,0,0,8,7,0,0,0,0,0,6,10,0,0,0,0,0,0,0,0,7,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,10,5,0,0,0,0,8,0,0,0,0,4,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,6,12,0,0,0,10,7,0,5,0,6,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,4,0,0,0,0,0,7,0,0,0,0,0,0,0,4,9,6,0,0,0,7,0,0,0,0,0,0,0,0,8,6,0,0,
+-0,0,0,0,0,4,12,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,7,0,
+-0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,6,0,6,9,4,0,0,8,4,0,6,
+-0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,8,0,0,6,13,4,0,5,8,0,0,0,0,0,0,0,8,0,0,0,10,5,0,0,9,0,0,0,0,0,0,6,0,0,
+-24,0,0,0,0,0,0,0,8,0,0,7,0,0,12,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,
+-6,8,0,10,0,9,7,0,0,0,5,0,0,0,0,0,0,0,4,8,5,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,4,0,0,0,0,0,6,0,0,0,0,0,5,0,0,0,0,8,0,0,
+-0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,10,4,0,0,0,0,0,0,0,6,0,0,0,4,20,0,0,7,
+-10,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,9,6,0,0,0,0,0,0,0,4,
+-12,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,9,4,0,5,0,0,
+-0,0,0,0,0,6,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,6,9,0,0,0,0,7,0,0,0,0,0,6,0,5,0,0,0,0,0,0,0,0,9,0,0,0,
+-0,6,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,17,7,0,0,13,6,14,6,0,0,0,0,
+-8,0,0,0,0,0,0,7,12,7,8,7,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,4,0,0,0,0,0,4,0,
+-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,12,4,0,0,10,7,0,0,0,
+-0,0,0,10,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,12,0,0,6,
+-0,0,0,0,0,0,0,0,8,7,12,0,0,0,0,0,0,6,0,6,0,4,0,0,18,6,0,0,0,6,0,0,0,0,0,6,10,6,
+-0,0,0,0,0,0,8,7,14,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,
+-0,0,0,8,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,8,7,0,0,10,5,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
+-0,0,9,4,8,0,0,0,0,0,0,4,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,
+-0,6,0,0,9,7,0,0,0,0,0,5,0,0,0,0,8,7,0,0,14,0,0,0,0,6,0,0,0,0,0,0,9,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,5,0,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
+-0,0,0,6,0,0,0,6,0,4,0,0,0,0,0,4,0,0,0,0,12,0,0,7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
+-0,12,0,16,6,0,0,0,0,0,0,11,7,0,4,8,7,0,0,0,0,0,6,0,0,0,0,16,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,10,7,0,0,0,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,13,4,0,0,10,0,0,0,0,0,0,0,0,0,19,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,8,6,22,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,
+-5,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-4,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,18,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,14,7,0,0,11,5,0,0,0,5,0,0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,24,6,0,0,
+-0,7,0,4,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,7,0,4,0,0,0,0,8,7,0,0,
+-9,6,0,0,14,5,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,12,6,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,7,0,0,0,5,0,0,
+-0,0,12,7,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,6,0,0,13,7,0,0,0,0,0,0,14,0,11,4,0,
+-0,0,4,0,0,0,0,14,5,0,0,0,0,0,5,11,5,0,0,0,0,22,5,0,0,0,0,0,7,0,0,0,0,0,4,0,0,0,
+-4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,17,0,10,0,0,0,8,0,0,0,19,
+-5,18,7,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,10,6,0,6,0,0,0,0,10,4,0,4,0,
+-0,0,0,0,0,14,7,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,0,9,6,12,0,0,6,0,0,0,0,0,0,0,0,
+-12,0,10,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,5,13,0,9,7,0,0,0,0,0,0,0,0,0,0,0,7,9,7,0,0,8,0,0,0,0,0,
+-22,0,0,0,0,0,0,0,23,6,14,0,0,0,0,0,0,7,0,0,0,0,11,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,10,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,8,5,0,0,0,0,0,0,0,0,0,7,11,6,21,0,0,0,0,0,
+-0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
+-0,0,0,0,0,0,0,4,9,7,0,0,0,0,0,0,12,0,0,0,0,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,9,
+-0,0,0,20,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,11,7,0,0,0,0,0,0,0,6,15,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,12,4,0,5,0,0,0,0,0,0,11,7,17,6,0,0,0,0,0,0,15,6,0,7,0,0,0,
+-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,6,0,5,
+-0,0,11,0,11,7,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,
+-17,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,8,7,9,6,0,0,14,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,
+-8,7,0,4,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,
+-0,0,0,5,0,4,0,0,8,7,0,6,12,5,0,7,18,7,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-10,0,11,0,0,0,0,0,0,0,0,0,0,0,9,0,0,4,0,6,0,7,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,
+-7,0,0,0,0,8,0,0,0,15,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,0,
+-0,0,6,0,0,0,0,23,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,5,0,0,0,0,0,0,8,6,0,0,
+-0,0,0,0,12,7,9,7,0,0,10,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,9,0,8,7,0,0,0,
+-6,0,6,0,4,0,5,0,0,0,0,0,5,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,7,10,5,0,0,11,6,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,4,9,7,0,
+-0,0,0,11,7,0,0,0,0,0,5,0,0,0,7,0,0,0,0,23,6,11,4,0,0,0,0,0,0,9,0,0,0,10,6,0,0,0,
+-0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,10,6,0,0,0,7,0,0,
+-0,0,0,0,0,0,0,0,20,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,
+-6,11,7,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,6,0,0,0,5,0,6,0,6,0,0,0,0,0,0,0,0,0,0,
+-0,6,0,0,0,0,8,7,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,4,10,0,8,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,10,6,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
+-0,0,0,0,0,0,10,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,11,6,0,4,0,0,14,5,0,7,0,0,0,0,0,6,16,0,0,0,0,0,0,0,10,0,0,7,15,0,0,0,11,7,0,0,
+-0,0,0,0,0,0,0,0,8,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,5,0,0,0,
+-0,8,0,0,6,0,0,0,0,0,0,9,5,0,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,6,0,
+-0,0,0,0,0,0,7,0,0,0,0,15,7,0,0,0,0,8,0,0,0,14,0,0,0,0,0,0,0,16,7,0,0,0,0,0,7,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,12,6,11,7,
+-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,
+-7,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,12,0,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,8,0,0,5,8,7,10,6,0,0,0,7,0,0,0,0,12,6,
+-0,0,9,0,0,0,12,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,10,0,0,0,10,5,0,0,0,0,0,0,9,6,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,0,0,9,5,0,4,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,9,0,0,5,0,0,8,7,8,
+-6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,10,0,9,4,0,0,0,0,0,0,0,6,
+-11,0,0,0,0,0,0,0,0,0,0,0,8,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,8,7,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,
+-0,0,0,10,0,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,
+-0,0,8,4,0,5,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,8,5,0,0,0,
+-0,0,0,0,7,0,0,0,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,6,0,7,0,0,0,0,
+-20,0,0,0,0,0,0,0,0,0,0,7,9,0,0,0,0,0,0,6,0,6,0,7,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,
+-0,0,0,14,7,0,0,0,5,0,0,22,4,10,0,0,0,0,0,0,4,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,11,5,13,0,0,0,0,0,0,0,0,0,8,0,0,7,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,10,7,0,
+-0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,7,14,6,0,0,0,0,9,5,
+-0,0,0,0,0,6,0,0,0,5,10,0,8,6,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,8,4,0,6,0,
+-0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,
+-14,0,0,5,0,0,18,0,8,4,0,6,0,0,20,0,13,0,0,0,0,7,0,4,0,0,0,0,0,4,8,4,0,0,0,0,0,6,
+-0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,0,14,0,0,0,0,0,9,7,0,0,9,0,0,0,0,
+-0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,20,0,14,0,0,4,0,6,8,5,0,0,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,4,12,7,0,6,0,0,9,7,10,5,
+-0,0,8,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,0,18,0,0,0,14,7,0,0,0,0,0,4,
+-0,0,0,0,0,0,17,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,
+-0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,8,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,7,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,5,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,23,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,4,0,0,0,0,0,0,12,7,8,4,0,0,0,0,0,0,0,0,0,6,0,0,9,5,0,0,0,7,0,0,0,
+-0,0,0,0,0,0,4,10,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,0,0,18,7,
+-0,0,8,0,0,5,0,0,10,0,0,0,0,0,0,6,0,0,0,0,0,5,0,7,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,
+-6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,6,0,0,10,0,0,5,10,4,0,0,12,0,0,0,0,
+-6,22,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,7,0,5,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,6,0,7,0,0,0,6,0,6,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,
+-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,16,6,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,12,7,0,0,0,0,9,0,0,0,0,6,0,0,11,0,0,0,0,0,13,0,9,6,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,10,7,0,0,0,7,0,6,0,
+-0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,11,0,15,0,22,7,0,4,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-18,0,0,0,0,0,0,0,0,0,14,0,0,4,0,0,0,0,8,7,9,0,0,0,0,0,9,0,0,0,14,0,0,0,0,0,0,0,
+-0,0,11,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,7,0,0,0,6,0,6,0,0,0,0,8,0,0,0,0,
+-0,11,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,9,4,0,0,0,0,0,4,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,8,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,
+-0,0,0,0,0,0,8,6,0,0,9,5,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,5,0,
+-0,10,6,9,0,0,0,0,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
+-11,7,12,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,4,0,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,
+-0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,5,0,0,10,6,
+-0,0,0,4,0,7,13,0,0,4,0,0,11,4,0,6,0,0,0,0,0,6,8,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,5,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,5,0,0,0,0,12,6,0,0,0,0,
+-11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,11,5,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,
+-7,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,6,17,0,9,0,10,6,0,6,12,0,0,4,0,0,0,
+-0,0,0,0,0,0,0,8,5,12,7,0,4,0,0,0,0,0,0,0,0,0,0,11,0,9,0,10,6,11,5,0,7,0,0,8,0,0,
+-7,0,4,0,0,0,7,0,0,0,0,0,0,8,6,0,0,0,6,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,11,0,0,0,0,6,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,10,0,0,0,0,0,8,6,0,0,0,0,0,6,12,0,0,0,0,0,
+-0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,6,0,0,16,0,11,5,0,0,0,0,0,
+-0,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,9,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,6,10,
+-7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,0,9,5,0,0,0,0,8,0,9,0,0,
+-0,0,0,0,0,0,7,10,0,13,0,0,6,0,0,0,0,0,0,0,0,0,6,9,4,0,0,0,0,0,0,10,0,0,0,0,0,10,
+-0,0,0,0,0,0,0,10,6,11,0,0,0,0,0,9,0,0,0,0,0,0,4,0,0,0,0,0,0,10,5,0,0,0,0,0,6,0,
+-0,0,0,0,0,18,4,0,7,0,0,0,0,0,0,24,0,8,6,0,7,0,0,0,0,15,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,8,5,0,0,0,0,10,7,0,6,0,0,0,0,0,0,0,0,8,5,10,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,
+-6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,4,0,5,15,0,0,0,0,7,0,7,0,0,0,0,
+-0,0,0,0,0,6,10,5,0,0,0,6,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,12,0,0,0,0,0,0,0,0,
+-0,0,5,0,0,0,0,0,0,14,4,18,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,11,0,10,4,9,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,7,0,0,0,
+-0,0,0,0,0,0,0,0,7,13,7,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,8,0,10,6,0,4,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,
+-0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,9,7,0,0,0,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,0,5,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,11,0,0,0,0,6,0,0,0,0,0,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22,0,0,
+-6,0,0,0,0,0,0,0,6,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,
+-0,0,0,0,0,0,0,6,0,6,0,0,0,5,0,0,0,0,0,0,0,5,0,0,10,0,11,5,0,0,0,0,0,0,14,7,9,7,
+-0,6,0,0,0,0,0,4,0,0,0,0,0,0,11,7,0,6,0,0,0,0,0,0,9,7,0,4,0,0,0,7,0,0,0,0,0,5,0,
+-0,0,0,0,5,0,0,0,7,0,0,0,0,0,5,0,0,0,0,17,5,0,0,8,0,0,0,0,6,9,4,0,0,0,0,0,0,0,0,
+-8,7,11,7,9,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,6,9,5,0,0,8,6,0,0,0,5,0,
+-0,0,0,9,0,0,0,9,6,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,4,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,4,0,0,0,5,0,0,0,0,0,7,0,0,0,0,0,7,13,5,0,0,0,7,0,0,0,0,0,7,9,6,11,7,0,7,0,0,0,
+-0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,8,5,0,0,0,5,9,4,0,0,0,0,0,0,0,0,8,4,0,0,0,0,
+-24,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,6,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,5,11,6,0,4,0,7,20,0,8,5,9,5,9,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,7,23,5,0,0,8,4,0,0,10,0,0,6,0,5,0,0,0,0,0,0,0,0,0,0,0,7,0,
+-0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,0,0,0,
+-10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,
+-6,0,0,0,0,14,0,18,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,6,0,4,0,0,0,0,0,0,8,4,
+-11,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,12,0,10,7,0,0,10,0,0,0,0,
+-0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,6,0,0,0,0,8,
+-6,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,4,0,6,0,4,0,0,0,0,0,5,0,0,
+-0,0,0,0,0,0,0,7,0,0,0,7,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,17,7,11,0,0,0,0,0,0,0,0,0,0,4,12,6,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+-0,5,12,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,6,0,0,20,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,4,
+-0,0,0,5,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,6,0,4,13,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,12,6,0,7,0,0,0,0,10,0,23,6,0,0,
+-0,4,0,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-10,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,11,0,9,7,0,0,
+-0,0,0,0,0,0,0,0,9,7,0,4,0,0,0,0,8,7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
+-0,0,0,0,0,6,0,0,10,7,10,5,0,0,8,0,8,0,0,0,0,0,0,4,0,5,10,0,0,0,0,0,0,0,9,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,11,7,0,0,0,0,0,0,0,0,9,4,0,0,0,0,0,6,0,0,8,
+-7,0,0,0,0,0,5,0,0,0,0,0,0,0,0,10,0,0,0,0,5,0,4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,24,7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,6,0,0,9,0,0,0,0,0,0,7,0,6,13,0,8,
+-0,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,6,0,0,0,0,8,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,
+-4,0,0,0,0,0,4,0,0,0,0,0,0,0,6,8,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,4,0,4,0,0,0,5,0,7,0,0,10,0,10,7,0,0,12,5,0,0,9,0,0,0,10,0,
+-0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,
+-12,0,0,0,0,0,8,5,13,6,0,0,0,0,0,0,9,4,0,0,0,0,8,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,
+-0,0,6,0,0,14,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,17,6,0,0,0,0,12,6,0,0,0,0,8,0,0,7,0,
+-7,0,4,9,0,0,6,0,0,0,6,0,0,0,0,0,0,8,7,0,0,0,0,0,0,11,0,0,4,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,18,7,0,4,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,8,0,11,7,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
+-11,0,0,0,0,0,0,0,21,0,0,6,10,0,0,0,0,0,9,0,10,0,0,0,0,0,11,0,0,0,0,6,0,0,0,0,0,
+-5,0,0,0,0,0,0,10,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,4,0,0,23,7,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,9,7,0,0,0,7,
+-0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,6,0,0,
+-11,6,0,0,0,0,0,0,0,6,0,0,0,0,10,7,0,0,9,4,0,0,11,0,8,5,0,0,0,7,8,5,22,0,0,0,9,6,
+-0,0,0,0,0,0,0,6,10,4,0,0,0,0,0,7,9,4,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,
+-0,0,0,11,6,0,0,0,0,0,0,0,0,0,0,0,7,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,6,0,6,0,4,0,0,
+-0,0,0,0,0,7,0,7,0,4,13,0,0,0,0,0,8,0,0,0,0,7,0,0,0,0,0,0,11,6,0,7,0,0,0,0,9,0,0,
+-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,8,0,0,0,0,0,8,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,6,0,0,0,0,13,5,8,0,0,
+-0,0,0,0,0,14,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,17,6,0,0,0,0,13,4,0,0,9,6,0,0,10,5,0,
+-0,10,5,0,0,0,0,13,0,0,0,0,6,0,0,0,0,0,0,10,0,12,0,0,0,0,0,0,0,0,0,0,0,8,4,0,4,0,
+-0,0,4,0,0,0,0,0,4,0,0,12,0,0,5,9,4,0,0,0,0,0,0,0,0,0,5,8,5,0,0,0,7,0,0,0,0,8,7,
+-0,0,0,6,12,5,0,0,0,5,0,0,0,5,0,0,0,0,0,4,12,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,7,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,
+-0,9,6,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,4,11,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,12,7,0,0,0,7,10,7,0,0,11,0,0,0,0,0,0,0,0,0,11,7,0,0,0,6,0,0,11,0,0,0,0,
+-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,22,0,10,7,0,0,8,5,0,0,0,0,0,5,0,0,0,0,0,0,
+-0,0,0,0,9,6,8,7,0,6,0,0,0,0,0,5,0,0,0,0,0,0,8,7,0,0,0,0,9,7,0,0,0,6,0,0,8,7,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,5,0,0,0,4,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,
+-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,5,0,0,0,0,14,0,0,0,
+-9,0,0,0,0,0,0,0,0,0,9,7,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,12,0,0,0,0,0,12,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,10,7,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,6,0,0,0,0,0,0,9,6,0,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,9,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,6,0,7,12,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,
+-0,7,0,0,8,6,0,0,0,0,10,7,0,0,0,0,0,0,0,6,0,0,0,0,0,6,12,0,0,0,0,0,0,0,0,6,0,0,0,
+-0,0,6,0,0,0,6,0,0,0,0,0,6,16,0,0,0,0,0,0,0,0,0,9,0,17,0,14,7,8,0,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,0,0,0,11,0,0,6,8,7,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,
+-9,0,0,0,0,7,0,0,0,0,11,5,0,4,9,6,8,0,0,0,0,0,0,0,0,0,10,0,11,7,0,0,0,0,0,0,0,0,
+-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,
+-0,0,0,12,0,0,0,0,0,10,5,0,4,0,0,0,0,0,7,10,6,11,6,0,0,0,0,0,0,0,0,0,0,0,0,17,0,
+-0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,8,0,0,4,0,0,0,6,0,0,0,
+-0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,4,0,0,0,0,9,6,0,0,0,4,0,0,0,0,0,4,10,7,0,7,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,
+-0,0,0,0,0,0,6,0,0,0,6,0,6,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,18,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,13,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,
+-0,0,0,6,0,0,0,0,0,4,8,0,0,0,11,7,0,0,0,4,0,0,0,0,0,7,0,0,8,5,0,0,16,0,0,0,13,6,
+-0,0,0,0,0,0,0,6,0,0,0,0,20,0,11,6,0,0,8,7,0,0,0,0,0,6,17,0,8,0,0,0,0,0,8,7,0,0,
+-9,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,
+-0,0,4,0,7,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,8,
+-0,8,0,0,0,0,0,0,0,11,0,8,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,6,0,0,9,0,
+-0,0,0,0,8,0,0,0,0,0,18,0,0,0,0,0,0,4,9,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,9,6,0,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,8,7,0,0,0,0,0,0,0,0,
+-0,4,0,0,0,0,0,0,14,0,0,0,0,7,0,6,0,0,8,0,20,7,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,8,0,0,0,14,0,0,0,0,0,0,0,8,0,0,7,0,6,0,0,0,7,0,0,0,0,0,0,0,0,
+-0,0,0,4,12,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,10,6,0,
+-5,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,5,8,4,0,0,0,0,0,0,0,4,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,12,7,0,
+-0,0,0,13,6,0,0,0,7,0,0,8,0,0,0,8,0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,0,0,0,0,0,0,11,5,
+-0,6,0,0,8,5,0,7,0,0,0,0,0,0,0,7,0,0,0,0,8,6,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,4,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-14,0,10,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,19,0,0,4,0,0,0,7,
+-0,0,11,5,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,16,0,10,5,18,0,0,7,9,6,0,5,0,0,0,0,0,
+-0,0,0,0,5,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,5,0,0,0,7,0,6,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,4,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,23,0,0,0,0,5,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,14,0,20,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,
+-11,0,0,0,0,7,0,0,0,0,15,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,7,0,0,0,0,
+-0,4,0,0,0,0,10,0,0,0,0,0,9,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,10,0,11,6,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,5,0,0,11,0,0,0,0,7,0,0,0,0,0,0,8,7,0,
+-4,0,0,0,0,11,0,0,0,0,0,11,0,0,5,0,0,8,7,0,4,0,7,0,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,10,5,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,6,0,5,0,0,0,0,0,0,0,
+-0,0,4,11,5,10,7,0,7,0,0,9,6,9,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,9,4,0,4,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,8,6,0,0,0,0,11,7,0,0,0,0,0,0,0,0,0,0,11,7,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,8,5,0,0,8,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,
+-10,7,0,0,0,6,0,0,0,0,0,0,8,0,0,6,0,0,0,6,10,0,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,6,0,
+-0,0,6,0,0,0,0,9,5,8,5,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,
+-0,8,7,10,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,0,5,0,0,0,6,0,7,0,0,
+-10,5,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,11,0,0,0,0,0,13,4,
+-0,0,0,4,0,0,0,0,0,5,8,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,7,14,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,7,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,5,0,0,15,6,10,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,14,6,10,0,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,6,0,5,11,4,0,6,0,0,0,7,0,0,0,0,
+-0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,5,0,0,8,5,0,0,0,0,0,0,0,0,0,0,
+-0,0,10,0,0,0,0,0,9,6,9,4,0,0,0,4,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,5,0,
+-0,0,0,0,0,0,0,0,0,0,4,0,0,11,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,
+-0,0,0,7,12,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,
+-4,9,6,0,4,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,6,0,
+-7,8,6,0,0,0,0,0,0,0,4,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,5,0,4,0,0,0,0,0,0,0,5,0,0,0,
+-0,0,5,0,0,0,7,12,7,0,0,0,0,0,0,18,4,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,6,0,0,0,
+-0,12,0,0,7,0,0,0,0,0,7,0,0,13,0,0,6,0,0,0,0,8,7,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,7,10,5,0,0,8,0,0,0,0,0,0,0,8,6,0,7,0,0,8,4,0,4,0,0,0,0,10,4,0,0,14,0,
+-0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,17,0,0,0,0,0,0,6,0,0,0,0,8,6,0,0,10,5,0,0,0,0,8,
+-6,0,0,0,6,0,0,0,7,0,0,0,0,0,6,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,12,0,0,0,0,6,
+-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
+-0,0,0,6,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,4,24,0,0,
+-0,0,0,12,6,0,0,10,6,0,5,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,17,7,0,5,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,11,5,9,0,8,7,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,10,7,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,5,8,7,0,0,0,
+-0,8,5,0,0,0,0,10,7,0,7,0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,
+-0,6,12,0,8,7,0,0,0,0,0,0,0,0,0,0,16,0,10,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,22,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,13,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,22,0,0,6,0,0,21,0,0,0,22,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,7,8,0,0,0,0,6,14,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,0,8,5,0,0,11,7,0,6,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,5,0,0,0,0,0,0,0,0,0,4,0,0,8,7,0,0,0,0,8,5,11,7,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,8,5,0,0,10,0,0,4,13,7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,0,13,6,
+-0,6,0,7,0,0,8,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,15,0,0,0,10,7,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,19,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,6,0,5,
+-0,7,0,0,0,0,0,0,0,0,0,6,0,0,11,4,0,0,0,6,0,0,13,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,12,6,0,0,0,0,
+-0,7,0,0,0,0,0,0,11,7,0,0,0,0,0,6,0,0,10,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,11,6,
+-0,0,0,0,0,0,0,0,10,0,0,0,0,6,0,0,0,0,0,0,8,7,0,0,0,5,0,0,0,5,0,0,0,0,0,0,0,0,0,
+-0,0,0,8,7,0,0,0,0,9,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,10,0,
+-0,6,0,0,13,0,0,0,0,0,0,0,9,6,0,0,8,6,8,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,
+-0,9,7,0,0,0,0,0,0,11,0,0,0,10,7,0,0,0,0,0,0,0,0,9,6,0,0,12,4,0,4,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,6,0,0,0,0,21,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,5,0,0,
+-9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,
+-16,0,0,4,0,0,0,0,0,7,0,0,0,6,0,6,0,0,11,0,0,0,0,5,0,0,0,0,0,0,0,4,8,5,0,0,0,0,0,
+-0,14,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,
+-0,0,8,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,
+-0,0,0,0,6,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,14,7,0,0,9,7,0,0,11,0,0,0,0,0,10,
+-4,11,5,13,6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,5,0,0,0,0,0,4,0,0,9,0,0,0,0,
+-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,6,12,5,0,0,0,6,14,0,0,0,0,0,0,0,0,0,0,4,9,4,
+-0,0,0,0,0,5,0,0,0,0,0,0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,5,0,0,
+-0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,11,6,0,0,13,7,0,0,13,6,0,7,0,0,0,0,0,0,8,6,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,10,6,0,4,0,0,12,6,0,0,0,0,0,0,0,0,10,6,
+-0,0,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,7,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,6,0,
+-0,0,7,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,
+-0,0,0,5,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,
+-0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,8,7,0,0,8,5,0,0,0,4,9,5,0,0,0,7,10,6,0,0,
+-0,0,0,0,9,7,0,0,8,5,8,0,8,4,0,0,13,0,0,0,0,0,0,0,0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,
+-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,4,0,0,0,0,0,0,0,0,0,
+-0,11,7,0,0,0,7,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17,5,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,7,0,0,0,0,8,5,0,4,0,0,0,0,0,6,0,6,14,
+-6,0,0,0,0,9,6,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,6,0,0,0,0,14,7,9,7,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,16,
+-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,14,0,
+-0,6,0,0,8,6,0,0,0,0,0,6,0,0,12,0,0,0,0,0,8,5,0,7,11,0,0,5,0,4,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,9,6,0,4,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,10,5,0,0,0,0,
+-0,4,0,0,0,7,11,6,0,4,8,5,9,5,0,0,0,5,0,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,8,5,14,7,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,16,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,9,6,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,9,0,0,0,12,5,0,0,0,0,0,0,0,4,10,5,0,0,0,0,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,4,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,10,4,0,0,0,0,0,5,0,0,0,4,
+-0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,0,10,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,7,0,0,0,0,0,0,0,0,15,0,0,0,
+-0,0,0,0,0,0,0,7,0,0,0,0,0,7,10,7,9,7,0,0,0,7,0,0,8,0,0,0,0,0,0,0,9,0,0,0,8,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,8,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,7,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,15,7,12,6,0,0,0,7,0,5,0,0,0,0,0,0,0,0,0,0,0,0,18,0,0,5,0,0,0,0,
+-0,0,0,6,9,5,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,9,7,0,0,14,0,0,0,11,7,0,0,0,0,0,
+-0,0,0,0,0,0,4,0,0,11,7,0,0,0,0,8,0,0,0,0,0,0,6,8,7,0,0,0,7,10,4,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,10,0,0,0,0,0,0,
+-6,0,6,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,11,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,7,0,0,10,7,0,0,0,0,9,7,0,0,0,0,0,0,13,7,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,12,0,
+-0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,9,6,0,0,11,0,0,
+-0,0,0,14,4,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,23,7,0,0,
+-0,0,0,6,0,7,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,20,
+-7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,8,0,0,0,0,0,0,0,0,0,11,5,0,0,0,0,0,0,0,0,0,0,10,4,0,0,0,5,8,5,10,4,0,0,0,0,0,
+-0,13,6,9,7,0,0,10,7,0,0,0,0,0,0,0,0,14,0,0,0,0,0,0,6,0,0,0,7,0,6,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,7,10,7,0,0,
+-0,0,0,0,0,0,0,0,12,4,0,0,0,0,8,7,0,0,0,0,0,7,0,6,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,
+-0,0,0,0,6,0,6,9,6,0,0,12,5,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,5,8,7,9,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,11,
+-4,0,0,0,0,0,0,8,0,0,0,10,7,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,0,
+-0,0,0,0,0,5,0,6,0,0,10,0,14,0,0,0,0,0,0,0,23,0,0,0,12,0,10,5,0,0,0,0,0,0,0,0,0,
+-5,0,0,0,0,8,0,0,0,0,6,8,0,0,0,0,0,0,0,0,0,22,0,8,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,
+-0,0,0,0,0,6,18,4,0,0,0,7,10,6,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,7,10,0,0,0,0,0,0,6,0,0,0,0,11,5,0,0,0,0,0,0,0,0,
+-15,0,8,6,0,0,13,7,0,0,0,0,0,7,0,0,0,0,0,7,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,9,5,9,
+-0,0,6,8,6,0,0,0,0,10,0,0,0,18,5,0,0,0,5,0,7,0,0,0,0,8,6,0,0,0,0,9,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,14,0,23,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,6,0,0,0,5,0,
+-0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,8,5,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,0,0,0,0,0,0,
+-0,0,0,0,20,5,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,9,5,0,0,0,0,0,0,8,4,24,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,9,7,0,0,0,0,10,5,0,0,8,5,0,0,0,0,0,0,0,0,12,7,0,6,0,0,10,6,0,0,0,
+-0,14,0,0,4,9,5,0,0,0,0,0,0,9,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,8,0,0,0,0,0,11,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,8,5,11,7,0,4,0,0,10,0,0,0,0,
+-0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,11,6,0,0,0,0,0,5,14,6,0,0,0,0,10,0,0,
+-0,13,4,0,0,0,0,0,0,0,0,0,0,0,6,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,7,12,0,10,6,0,0,0,0,0,0,10,0,0,0,0,0,10,0,9,
+-7,0,0,0,0,0,0,0,0,0,0,0,0,0,7,8,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,9,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,24,0,11,7,0,7,0,0,0,0,0,0,8,6,0,0,0,0,0,0,8,7,0,0,0,0,0,5,0,0,
+-0,6,9,0,0,0,23,5,0,0,0,0,0,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,7,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,0,18,4,0,0,11,7,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,9,0,0,0,11,0,0,0,23,0,0,
+-0,10,4,0,0,0,0,0,7,0,0,0,7,0,0,0,0,0,4,0,0,0,0,0,7,0,0,19,0,11,0,0,0,0,0,12,7,0,
+-0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,
+-9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,4,0,0,0,0,10,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,22,0,8,7,10,4,11,0,13,5,8,7,9,0,8,7,0,0,0,7,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,
+-0,8,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,4,0,0,0,4,11,0,0,6,0,0,8,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,5,0,0,
+-20,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,7,0,0,14,0,0,0,9,0,13,7,0,0,0,0,0,6,0,7,0,0,8,6,10,6,0,0,8,6,0,0,0,6,0,
+-0,12,6,9,0,0,0,0,0,0,5,9,0,12,4,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,
+-0,0,4,8,0,0,6,8,0,0,0,0,0,0,0,0,0,13,6,0,7,0,0,0,0,0,6,8,7,8,6,0,0,0,7,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,18,0,11,4,0,0,0,5,0,0,0,0,0,0,0,0,0,0,
+-0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,14,
+-6,0,0,0,0,12,7,8,0,0,0,0,0,0,0,8,7,0,0,0,0,10,4,0,0,0,0,0,0,10,0,0,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,15,6,9,7,0,0,0,0,0,0,15,6,11,7,0,0,0,7,0,0,21,0,0,
+-0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,17,6,0,0,10,5,0,5,0,0,0,0,0,0,0,0,0,7,
+-0,0,10,0,0,0,0,0,0,0,0,4,11,5,0,0,0,0,16,7,0,0,0,0,0,6,0,0,8,7,0,4,0,0,10,0,0,0,
+-0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,8,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,
+-0,0,0,10,4,0,0,0,0,0,0,0,0,0,6,0,5,0,0,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,
+-0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,6,10,7,0,0,0,0,0,0,0,0,8,4,0,0,10,0,0,0,0,4,0,6,0,6,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,7,17,0,0,0,0,0,
+-0,0,0,0,0,0,10,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-6,0,0,0,5,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,5,0,4,0,0,0,0,0,6,0,0,0,0,0,0,10,5,0,0,
+-0,5,0,0,0,0,9,0,19,7,0,0,0,0,0,7,0,0,0,0,10,6,0,0,0,6,0,5,0,0,0,0,0,0,0,0,0,6,8,
+-0,0,0,0,0,11,0,0,0,0,0,0,6,0,0,0,0,0,7,9,0,15,0,0,0,0,0,0,0,0,0,0,4,0,0,0,5,0,0,
+-0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,9,0,0,0,0,0,0,0,0,6,0,7,0,0,0,0,0,0,0,6,0,0,
+-0,0,0,6,10,0,0,0,0,0,0,0,23,0,14,0,0,0,0,7,0,0,0,0,0,7,0,0,9,0,0,0,0,7,0,0,0,0,
+-0,6,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,4,0,0,0,
+-0,0,0,0,0,9,5,0,0,0,0,0,4,0,0,0,0,9,5,0,0,0,0,22,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,22,0,0,0,0,0,0,0,10,0,0,0,0,0,0,5,0,4,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,11,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,14,7,0,0,12,7,0,0,0,
+-0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,8,6,10,0,0,0,0,0,0,0,0,0,10,7,8,5,0,0,0,0,0,0,
+-0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,5,0,0,9,5,0,0,0,0,0,5,0,0,0,0,0,4,0,0,0,
+-0,0,0,0,0,0,0,12,4,11,0,0,0,9,0,11,7,0,0,0,0,0,0,10,6,0,0,0,6,0,0,0,0,15,5,0,0,
+-11,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,4,0,4,0,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,8,0,0,0,19,7,0,4,0,0,9,0,0,0,0,0,10,0,
+-0,6,0,0,13,0,12,6,0,0,0,0,0,0,0,0,10,7,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,13,7,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,4,9,0,0,0,10,0,0,0,0,0,0,0,
+-0,5,0,0,0,0,0,0,10,0,23,6,0,0,0,6,8,0,0,0,0,0,0,0,0,0,17,7,0,0,0,0,11,6,22,5,0,
+-0,9,6,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,5,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,4,11,0,9,4,0,0,
+-0,7,0,7,0,0,0,0,0,0,12,4,0,0,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-4,0,0,11,5,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,8,6,0,0,0,4,0,0,0,0,
+-0,0,0,0,0,7,0,0,0,4,0,0,10,4,0,0,0,0,0,0,0,7,0,7,0,0,0,6,0,0,0,0,8,6,0,6,0,6,0,
+-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,6,22,6,12,0,0,6,0,0,0,6,0,0,0,0,0,7,0,0,0,0,11,0,0,0,
+-9,7,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,6,0,0,0,6,0,6,0,0,8,7,0,0,0,4,9,7,19,0,0,0,0,0,0,0,0,0,9,6,10,6,0,6,0,0,0,
+-4,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,6,16,7,10,6,0,0,23,6,11,7,0,4,0,0,0,0,0,0,0,0,0,
+-5,0,0,0,0,10,7,0,0,0,0,0,7,0,0,0,0,0,0,15,0,10,0,0,0,14,6,0,0,0,0,0,0,0,0,0,0,0,
+-5,0,0,0,0,0,0,0,5,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,5,0,0,11,5,0,0,0,0,0,0,0,0,0,0,
+-0,4,0,0,0,0,0,6,0,0,10,0,0,0,0,7,0,0,0,0,0,0,10,6,0,0,0,0,8,4,0,0,0,7,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,7,12,5,0,0,0,0,
+-0,6,0,0,0,0,9,6,0,0,0,0,0,0,0,6,9,0,0,0,0,6,0,0,0,0,8,7,0,0,0,0,0,0,0,6,0,0,0,0,
+-0,0,0,0,0,0,10,5,0,0,0,0,0,0,8,6,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,8,5,0,0,0,0,0,7,0,7,0,4,0,0,10,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,5,0,0,0,0,13,
+-7,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,7,0,0,13,0,0,0,0,0,0,0,0,7,10,5,0,0,0,0,0,0,9,7,0,0,8,6,9,
+-5,0,0,0,0,0,6,12,0,0,0,0,0,0,0,18,6,0,0,0,0,0,0,0,0,19,7,0,4,0,0,0,0,9,5,0,5,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,7,0,0,0,0,0,0,14,0,0,0,23,7,8,7,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,22,0,0,7,0,0,0,0,0,0,0,0,9,7,8,4,0,
+-0,0,0,0,0,0,0,8,5,0,6,0,0,0,0,0,6,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,
+-8,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,12,5,0,0,0,0,0,0,0,0,0,0,8,6,0,0,11,7,0,0,0,
+-0,12,0,8,6,19,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,11,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,11,7,0,0,0,0,0,4,10,0,0,0,0,0,0,0,8,7,0,0,0,0,14,0,8,0,0,6,10,0,0,
+-0,0,0,0,0,12,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
+-0,0,0,0,13,0,0,0,0,0,0,0,11,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,5,0,0,0,6,0,0,0,5,0,7,0,0,0,
+-0,0,6,0,0,21,7,0,0,9,6,0,0,0,6,0,0,13,7,0,0,0,5,0,0,0,0,0,4,0,6,0,0,0,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,11,5,0,6,0,0,10,5,0,0,0,0,0,0,0,0,9,6,0,0,8,7,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,0,0,0,0,0,0,6,0,0,0,0,15,4,0,0,12,7,0,0,0,6,
+-0,7,0,0,8,0,9,5,0,4,0,0,0,6,0,6,0,0,23,4,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,4,0,0,8,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,12,6,0,0,0,0,0,0,10,7,0,7,0,0,0,0,0,0,0,0,0,0,
+-9,0,0,0,0,0,8,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,11,5,0,0,0,6,0,6,0,0,0,0,0,0,0,6,0,
+-4,0,0,0,0,0,0,0,0,0,0,0,5,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,8,7,0,0,0,6,0,6,0,
+-0,0,0,0,0,0,0,0,5,0,0,0,0,0,5,0,0,0,0,11,0,0,0,0,0,0,0,10,5,9,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,23,7,0,0,0,0,0,7,0,0,10,6,18,0,0,0,
+-0,0,0,0,8,7,0,6,0,0,0,0,0,0,8,5,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,4,12,7,0,0,0,0,0,0,0,0,10,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,13,5,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,
+-11,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,
+-0,0,0,0,6,0,0,0,4,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,0,11,0,0,0,0,0,0,0,0,0,
+-17,5,0,4,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,0,0,0,8,7,0,0,0,0,0,0,0,
+-0,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,
+-10,0,0,0,8,6,0,0,0,7,0,0,0,0,0,0,8,0,0,0,14,0,0,0,0,7,0,0,0,4,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,9,4,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,14,0,
+-10,0,0,0,16,5,0,0,0,0,0,0,8,0,0,4,0,0,0,0,0,0,0,0,0,0,9,6,0,0,0,0,0,0,10,0,0,0,
+-0,0,0,0,0,5,0,0,0,0,12,5,0,7,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,7,0,
+-0,0,0,0,0,0,0,12,6,0,0,0,0,0,7,0,6,0,6,12,6,0,0,0,0,0,0,0,4,8,7,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20,0,0,0,0,6,0,6,0,0,0,0,0,0,0,0,10,6,8,0,0,
+-6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-16,0,8,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,23,5,0,0,0,7,0,6,0,
+-0,0,0,0,0,0,0,0,0,0,0,10,6,0,0,9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,14,0,0,0,0,7,0,0,0,4,17,5,0,0,0,0,11,0,9,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,6,0,0,0,5,0,7,0,0,0,0,0,0,0,0,8,0,0,0,
+-12,6,0,0,0,0,0,0,13,0,0,0,0,7,9,0,0,0,0,0,0,0,0,0,0,5,0,0,0,7,10,7,12,0,0,0,9,0,
+-0,0,14,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,15,6,0,0,23,0,0,7,0,6,0,0,0,7,0,6,
+-0,0,0,0,0,0,0,6,0,6,9,0,0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,8,7,9,4,0,0,10,0,0,0,10,
+-6,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,23,0,0,6,0,0,0,0,0,0,9,4,
+-0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,9,6,0,0,0,0,8,6,0,0,0,0,0,0,0,0,12,0,0,
+-0,0,0,8,0,0,6,11,6,0,0,8,7,8,5,0,0,0,0,0,5,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,0,
+-10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,
+-7,0,0,0,0,9,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,8,0,0,0,0,6,12,5,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,10,0,10,
+-7,0,0,8,0,0,0,0,4,0,0,0,6,0,0,0,6,0,0,0,6,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,
+-0,0,4,0,0,0,0,0,4,0,0,0,0,0,0,0,6,0,6,0,5,0,0,0,0,8,0,0,0,10,7,0,0,0,0,10,0,0,0,
+-0,0,13,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,19,7,0,4,12,0,8,0,0,0,0,6,0,0,0,0,
+-0,0,0,6,0,0,0,0,0,0,0,0,0,4,0,0,0,0,18,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,14,0,0,4,0,0,0,6,0,0,0,6,0,0,0,7,0,0,0,0,0,0,10,4,0,0,9,7,0,0,11,0,0,0,0,0,0,
+-7,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,12,0,0,0,
+-0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,22,5,9,7,0,0,0,0,0,0,0,0,0,
+-0,0,6,0,0,9,6,0,5,0,0,0,0,0,0,10,5,0,0,8,6,0,6,10,5,0,0,0,6,0,0,0,6,0,0,20,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,0,17,4,0,7,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,14,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,
+-0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,
+-0,0,7,0,0,8,6,12,0,0,7,18,7,0,0,8,4,0,0,0,0,9,6,0,0,0,0,0,0,0,0,13,0,0,6,0,0,0,
+-0,0,0,0,0,0,0,10,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,0,
+-0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,8,5,0,0,0,0,0,0,0,0,12,0,0,0,8,0,0,0,0,0,0,
+-4,0,0,10,0,16,0,0,0,0,0,0,0,12,7,10,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,16,6,10,0,0,5,0,0,0,0,0,6,0,0,0,0,
+-0,7,0,0,0,7,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,5,8,7,0,7,0,0,0,0,0,0,0,0,8,0,0,6,0,0,0,6,0,0,0,4,0,0,0,0,
+-8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,7,0,0,8,0,0,0,
+-9,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,13,5,0,5,0,0,0,7,8,4,0,0,0,0,0,0,0,
+-0,12,0,0,0,0,0,0,0,0,0,0,0,8,6,0,6,0,0,11,0,0,0,0,0,0,0,0,6,0,0,0,0,0,4,0,0,0,0,
+-0,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,10,7,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,11,6,0,0,10,6,0,0,
+-0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,6,0,0,0,7,0,0,9,0,8,7,11,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,9,6,10,5,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,0,0,0,0,0,10,7,0,0,0,0,0,0,11,0,9,6,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,5,0,6,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,15,5,12,5,
+-0,0,0,0,0,0,12,7,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,12,6,0,
+-0,0,0,24,4,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,4,10,4,0,0,0,0,10,7,0,0,0,0,0,0,0,0,0,0,0,0,9,0,11,0,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,
+-0,0,8,0,0,0,0,7,0,0,0,0,0,0,10,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,0,0,
+-0,0,0,0,0,14,7,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,0,0,6,0,0,0,0,0,6,0,0,0,6,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,4,0,0,0,4,0,0,0,0,0,7,20,7,11,4,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19,7,9,6,0,0,12,7,0,0,0,0,0,0,10,0,12,0,
+-0,0,0,0,0,4,9,6,13,0,0,0,0,0,0,0,0,6,0,0,0,6,0,0,0,5,0,0,0,0,0,0,8,0,0,0,0,0,0,
+-0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,6,0,0,11,0,9,0,0,0,0,4,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,8,5,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,19,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
+-0,4,0,5,0,0,0,0,0,0,0,0,0,4,0,0,0,0,9,7,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,
+-0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,
+-0,0,0,0,8,7,0,0,0,0,0,0,12,0,0,6,0,0,0,0,0,0,0,6,8,4,0,0,10,7,0,0,10,0,0,0,0,0,
+-0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,7,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,4,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,7,0,0,0,0,0,0,0,5,
+-0,4,0,0,0,0,0,6,0,0,0,0,0,0,8,0,0,6,0,0,0,6,0,0,0,0,0,7,0,5,8,4,0,0,9,0,0,0,0,4,
+-0,0,0,0,0,0,0,0,0,5,0,0,15,6,8,6,0,0,0,6,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,6,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,9,6,0,0,0,0,0,0,0,7,0,0,0,4,0,
+-6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,9,5,0,6,12,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,8,7,0,6,0,0,0,0,0,0,0,0,0,0,0,0,11,0,12,7,0,0,0,0,
+-0,0,0,0,0,5,0,5,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,11,4,0,0,0,0,0,0,0,0,0,0,10,
+-7,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,7,8,7,9,6,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,5,12,0,
+-10,5,12,6,0,0,0,7,0,0,0,0,0,0,0,5,0,0,0,5,9,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,
+-11,7,0,0,0,0,0,0,0,0,0,0,17,0,0,0,0,0,0,6,0,7,0,0,0,0,8,0,8,5,0,6,0,0,0,6,0,0,0,
+-0,0,0,0,6,0,6,0,6,9,0,0,5,17,0,0,0,0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,0,0,0,0,7,0,0,
+-0,0,0,7,0,0,0,0,16,5,0,0,0,0,0,0,0,4,0,0,0,5,11,5,0,7,0,0,0,4,8,7,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,7,0,0,0,0,12,0,0,0,
+-0,0,12,0,0,0,0,0,0,0,0,4,10,4,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,6,0,0,0,0,0,0,0,4,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,20,5,0,0,
+-10,0,0,0,0,0,0,0,0,0,0,6,0,0,0,6,12,0,0,0,0,0,0,6,0,0,0,0,0,0,9,4,10,7,0,4,0,0,
+-0,0,0,0,10,6,0,0,0,0,8,4,0,7,8,6,0,6,8,0,10,0,0,0,0,0,13,5,0,6,0,0,0,0,0,0,22,4,
+-0,0,0,0,0,0,0,0,0,0,9,0,0,0,0,6,0,0,0,6,0,0,0,0,0,0,0,6,0,0,0,0,0,0,0,0,0,6,10,
+-5,8,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,10,4,0,0,10,7,0,0,0,0,0,5,0,
+-5,8,0,0,0,0,6,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,10,7,0,0,0,4,0,0,0,0,0,6,0,0,
+-0,0,0,0,0,0,8,7,0,0,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,7,0,0,0,6,0,0,0,0,0,0,0,0,0,
+-4,0,0,0,4,10,0,0,6,13,7,8,0,0,0,0,0,0,7,0,0,12,7,0,0,0,0,0,0,10,5,0,0,0,0,0,6,0,
+-0,0,0,0,0,0,0,0,0,13,7,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,6,0,0,0,0,0,0,0,0,8,6,0,6,
+-0,0,0,0,0,0,0,0,12,0,8,4,0,0,0,0,0,4,0,4,0,0,0,0,0,0,0,5,0,0,0,0,12,5,0,0,0,7,0,
+-0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,10,0,0,0,20,0,0,5,0,0,10,
+-7,11,7,0,0,0,0,0,0,0,0,0,0,17,0,9,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,10,7,0,4,0,6,0,0,24,0,0,5,0,0,0,0,8,0,0,
+-0,0,0,0,0,10,5,0,4,0,6,0,0,8,0,0,0,0,0,0,4,0,6,0,0,0,0,0,0,9,5,0,0,0,0,0,0,0,0,
+-0,0,0,6,0,0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,4,0,7,
+-0,0,13,0,0,0,0,0,0,0,11,6,0,0,0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,4,0,0,0,0,
+-17,7,0,0,11,6,0,0,0,0,12,6,0,0,0,6,0,6,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,0,0,0,6,0,0,0,0,0,0,0,0,0,0,10,0,0,4,8,6,0,0,0,
+-0,0,0,9,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,9,5,0,7,18,0,0,0,0,0,0,0,0,0,0,0,0,0,8,6,0,0,0,0,0,0,0,0,8,0,0,0,
+-0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6,0,0,0,0,0,0,
+-0,0,0,0,0,0,10,0,0,0,0,0,0,0,0,4,0,6,0,0,9,0,0,0,0,0,0,0,0,0,13,0,0,0,0,0,0,0,0,
+-0,0,0,8,7,10,0,8,5,0,0,0,0,0,0,0,0,9,0,0,0,10,0,0,0,0,6,0,7,0,4,0,0,0,0,0,0,0,0,
+-8,0,0,0,0,0,8,4,0,0,0,0,0,5,0,0,10,0,12,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-4,0,0,0,0,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,18,6,11,0,0,
+-7,0,0,0,0,0,6,10,5,0,0,0,0,0,0,0,0,0,5,0,0,9,5,12,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,6,0,0,0,0,13,6,0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,
+-0,0,0,8,4,0,6,12,0,0,0,0,0,0,0,0,0,0,0,0,6,0,6,0,0,0,0,0,5,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,11,4,0,0,0,6,14,0,11,0,9,6,0,0,0,0,0,0,22,0,12,0,8,6,0,0,0,0,0,0,0,6,0,
+-0,0,0,0,6,0,0,0,0,0,0,0,0,0,0,11,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7,0,0,0,0,0,0,0,0,
+-10,7,0,0,0,0,0,0,0,0,9,0,0,0,0,4,0,0,0,0,0,0,0,0,0,5,11,0,0,0,0,0,0,0,8,6,0,0,9,
+-7,0,0,12,4,0,0,0,0,0,0,12,6,0,6,0,7,0,0,8,5,0,0,0,0};
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/dictionary_hash.h b/modules/brotli/enc/dictionary_hash.h
+deleted file mode 100644
+--- a/modules/brotli/enc/dictionary_hash.h
++++ /dev/null
+@@ -1,25 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Hash table on the 4-byte prefixes of static dictionary words. */
+-
+-#ifndef BROTLI_ENC_DICTIONARY_HASH_H_
+-#define BROTLI_ENC_DICTIONARY_HASH_H_
+-
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-extern const uint16_t kStaticDictionaryHashWords[32768];
+-extern const uint8_t kStaticDictionaryHashLengths[32768];
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_DICTIONARY_HASH_H_ */
+diff --git a/modules/brotli/enc/encode.c b/modules/brotli/enc/encode.c
+deleted file mode 100644
+--- a/modules/brotli/enc/encode.c
++++ /dev/null
+@@ -1,1927 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Implementation of Brotli compressor. */
+-
+-#include <brotli/encode.h>
+-
+-#include <stdlib.h>  /* free, malloc */
+-#include <string.h>  /* memcpy, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include "../common/version.h"
+-#include "./backward_references.h"
+-#include "./backward_references_hq.h"
+-#include "./bit_cost.h"
+-#include "./brotli_bit_stream.h"
+-#include "./compress_fragment.h"
+-#include "./compress_fragment_two_pass.h"
+-#include "./encoder_dict.h"
+-#include "./entropy_encode.h"
+-#include "./fast_log.h"
+-#include "./hash.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-#include "./metablock.h"
+-#include "./prefix.h"
+-#include "./quality.h"
+-#include "./ringbuffer.h"
+-#include "./utf8_util.h"
+-#include "./write_bits.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define COPY_ARRAY(dst, src) memcpy(dst, src, sizeof(src));
+-
+-typedef enum BrotliEncoderStreamState {
+-  /* Default state. */
+-  BROTLI_STREAM_PROCESSING = 0,
+-  /* Intermediate state; after next block is emitted, byte-padding should be
+-     performed before getting back to default state. */
+-  BROTLI_STREAM_FLUSH_REQUESTED = 1,
+-  /* Last metablock was produced; no more input is acceptable. */
+-  BROTLI_STREAM_FINISHED = 2,
+-  /* Flushing compressed block and writing meta-data block header. */
+-  BROTLI_STREAM_METADATA_HEAD = 3,
+-  /* Writing metadata block body. */
+-  BROTLI_STREAM_METADATA_BODY = 4
+-} BrotliEncoderStreamState;
+-
+-typedef enum BrotliEncoderFlintState {
+-  BROTLI_FLINT_NEEDS_2_BYTES = 2,
+-  BROTLI_FLINT_NEEDS_1_BYTE = 1,
+-  BROTLI_FLINT_WAITING_FOR_PROCESSING = 0,
+-  BROTLI_FLINT_WAITING_FOR_FLUSHING = -1,
+-  BROTLI_FLINT_DONE = -2
+-} BrotliEncoderFlintState;
+-
+-typedef struct BrotliEncoderStateStruct {
+-  BrotliEncoderParams params;
+-
+-  MemoryManager memory_manager_;
+-
+-  uint64_t input_pos_;
+-  RingBuffer ringbuffer_;
+-  size_t cmd_alloc_size_;
+-  Command* commands_;
+-  size_t num_commands_;
+-  size_t num_literals_;
+-  size_t last_insert_len_;
+-  uint64_t last_flush_pos_;
+-  uint64_t last_processed_pos_;
+-  int dist_cache_[BROTLI_NUM_DISTANCE_SHORT_CODES];
+-  int saved_dist_cache_[4];
+-  uint16_t last_bytes_;
+-  uint8_t last_bytes_bits_;
+-  /* "Flint" is a tiny uncompressed block emitted before the continuation
+-     block to unwire literal context from previous data. Despite being int8_t,
+-     field is actually BrotliEncoderFlintState enum. */
+-  int8_t flint_;
+-  uint8_t prev_byte_;
+-  uint8_t prev_byte2_;
+-  size_t storage_size_;
+-  uint8_t* storage_;
+-
+-  Hasher hasher_;
+-
+-  /* Hash table for FAST_ONE_PASS_COMPRESSION_QUALITY mode. */
+-  int small_table_[1 << 10];  /* 4KiB */
+-  int* large_table_;          /* Allocated only when needed */
+-  size_t large_table_size_;
+-  /* Command and distance prefix codes (each 64 symbols, stored back-to-back)
+-     used for the next block in FAST_ONE_PASS_COMPRESSION_QUALITY. The command
+-     prefix code is over a smaller alphabet with the following 64 symbols:
+-        0 - 15: insert length code 0, copy length code 0 - 15, same distance
+-       16 - 39: insert length code 0, copy length code 0 - 23
+-       40 - 63: insert length code 0 - 23, copy length code 0
+-     Note that symbols 16 and 40 represent the same code in the full alphabet,
+-     but we do not use either of them in FAST_ONE_PASS_COMPRESSION_QUALITY. */
+-  uint8_t cmd_depths_[128];
+-  uint16_t cmd_bits_[128];
+-  /* The compressed form of the command and distance prefix codes for the next
+-     block in FAST_ONE_PASS_COMPRESSION_QUALITY. */
+-  uint8_t cmd_code_[512];
+-  size_t cmd_code_numbits_;
+-  /* Command and literal buffers for FAST_TWO_PASS_COMPRESSION_QUALITY. */
+-  uint32_t* command_buf_;
+-  uint8_t* literal_buf_;
+-
+-  uint8_t* next_out_;
+-  size_t available_out_;
+-  size_t total_out_;
+-  /* Temporary buffer for padding flush bits or metadata block header / body. */
+-  union {
+-    uint64_t u64[2];
+-    uint8_t u8[16];
+-  } tiny_buf_;
+-  uint32_t remaining_metadata_bytes_;
+-  BrotliEncoderStreamState stream_state_;
+-
+-  BROTLI_BOOL is_last_block_emitted_;
+-  BROTLI_BOOL is_initialized_;
+-} BrotliEncoderStateStruct;
+-
+-static size_t InputBlockSize(BrotliEncoderState* s) {
+-  return (size_t)1 << s->params.lgblock;
+-}
+-
+-static uint64_t UnprocessedInputSize(BrotliEncoderState* s) {
+-  return s->input_pos_ - s->last_processed_pos_;
+-}
+-
+-static size_t RemainingInputBlockSize(BrotliEncoderState* s) {
+-  const uint64_t delta = UnprocessedInputSize(s);
+-  size_t block_size = InputBlockSize(s);
+-  if (delta >= block_size) return 0;
+-  return block_size - (size_t)delta;
+-}
+-
+-BROTLI_BOOL BrotliEncoderSetParameter(
+-    BrotliEncoderState* state, BrotliEncoderParameter p, uint32_t value) {
+-  /* Changing parameters on the fly is not implemented yet. */
+-  if (state->is_initialized_) return BROTLI_FALSE;
+-  /* TODO: Validate/clamp parameters here. */
+-  switch (p) {
+-    case BROTLI_PARAM_MODE:
+-      state->params.mode = (BrotliEncoderMode)value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_QUALITY:
+-      state->params.quality = (int)value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_LGWIN:
+-      state->params.lgwin = (int)value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_LGBLOCK:
+-      state->params.lgblock = (int)value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING:
+-      if ((value != 0) && (value != 1)) return BROTLI_FALSE;
+-      state->params.disable_literal_context_modeling = TO_BROTLI_BOOL(!!value);
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_SIZE_HINT:
+-      state->params.size_hint = value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_LARGE_WINDOW:
+-      state->params.large_window = TO_BROTLI_BOOL(!!value);
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_NPOSTFIX:
+-      state->params.dist.distance_postfix_bits = value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_NDIRECT:
+-      state->params.dist.num_direct_distance_codes = value;
+-      return BROTLI_TRUE;
+-
+-    case BROTLI_PARAM_STREAM_OFFSET:
+-      if (value > (1u << 30)) return BROTLI_FALSE;
+-      state->params.stream_offset = value;
+-      return BROTLI_TRUE;
+-
+-    default: return BROTLI_FALSE;
+-  }
+-}
+-
+-/* Wraps 64-bit input position to 32-bit ring-buffer position preserving
+-   "not-a-first-lap" feature. */
+-static uint32_t WrapPosition(uint64_t position) {
+-  uint32_t result = (uint32_t)position;
+-  uint64_t gb = position >> 30;
+-  if (gb > 2) {
+-    /* Wrap every 2GiB; The first 3GB are continuous. */
+-    result = (result & ((1u << 30) - 1)) | ((uint32_t)((gb - 1) & 1) + 1) << 30;
+-  }
+-  return result;
+-}
+-
+-static uint8_t* GetBrotliStorage(BrotliEncoderState* s, size_t size) {
+-  MemoryManager* m = &s->memory_manager_;
+-  if (s->storage_size_ < size) {
+-    BROTLI_FREE(m, s->storage_);
+-    s->storage_ = BROTLI_ALLOC(m, uint8_t, size);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->storage_)) return NULL;
+-    s->storage_size_ = size;
+-  }
+-  return s->storage_;
+-}
+-
+-static size_t HashTableSize(size_t max_table_size, size_t input_size) {
+-  size_t htsize = 256;
+-  while (htsize < max_table_size && htsize < input_size) {
+-    htsize <<= 1;
+-  }
+-  return htsize;
+-}
+-
+-static int* GetHashTable(BrotliEncoderState* s, int quality,
+-                         size_t input_size, size_t* table_size) {
+-  /* Use smaller hash table when input.size() is smaller, since we
+-     fill the table, incurring O(hash table size) overhead for
+-     compression, and if the input is short, we won't need that
+-     many hash table entries anyway. */
+-  MemoryManager* m = &s->memory_manager_;
+-  const size_t max_table_size = MaxHashTableSize(quality);
+-  size_t htsize = HashTableSize(max_table_size, input_size);
+-  int* table;
+-  BROTLI_DCHECK(max_table_size >= 256);
+-  if (quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
+-    /* Only odd shifts are supported by fast-one-pass. */
+-    if ((htsize & 0xAAAAA) == 0) {
+-      htsize <<= 1;
+-    }
+-  }
+-
+-  if (htsize <= sizeof(s->small_table_) / sizeof(s->small_table_[0])) {
+-    table = s->small_table_;
+-  } else {
+-    if (htsize > s->large_table_size_) {
+-      s->large_table_size_ = htsize;
+-      BROTLI_FREE(m, s->large_table_);
+-      s->large_table_ = BROTLI_ALLOC(m, int, htsize);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->large_table_)) return 0;
+-    }
+-    table = s->large_table_;
+-  }
+-
+-  *table_size = htsize;
+-  memset(table, 0, htsize * sizeof(*table));
+-  return table;
+-}
+-
+-static void EncodeWindowBits(int lgwin, BROTLI_BOOL large_window,
+-    uint16_t* last_bytes, uint8_t* last_bytes_bits) {
+-  if (large_window) {
+-    *last_bytes = (uint16_t)(((lgwin & 0x3F) << 8) | 0x11);
+-    *last_bytes_bits = 14;
+-  } else {
+-    if (lgwin == 16) {
+-      *last_bytes = 0;
+-      *last_bytes_bits = 1;
+-    } else if (lgwin == 17) {
+-      *last_bytes = 1;
+-      *last_bytes_bits = 7;
+-    } else if (lgwin > 17) {
+-      *last_bytes = (uint16_t)(((lgwin - 17) << 1) | 0x01);
+-      *last_bytes_bits = 4;
+-    } else {
+-      *last_bytes = (uint16_t)(((lgwin - 8) << 4) | 0x01);
+-      *last_bytes_bits = 7;
+-    }
+-  }
+-}
+-
+-/* Initializes the command and distance prefix codes for the first block. */
+-static void InitCommandPrefixCodes(uint8_t cmd_depths[128],
+-                                   uint16_t cmd_bits[128],
+-                                   uint8_t cmd_code[512],
+-                                   size_t* cmd_code_numbits) {
+-  static const uint8_t kDefaultCommandDepths[128] = {
+-    0, 4, 4, 5, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8,
+-    0, 0, 0, 4, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7,
+-    7, 7, 10, 10, 10, 10, 10, 10, 0, 4, 4, 5, 5, 5, 6, 6,
+-    7, 8, 8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+-    5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4,
+-    4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 8, 10,
+-    12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+-  };
+-  static const uint16_t kDefaultCommandBits[128] = {
+-    0,   0,   8,   9,   3,  35,   7,   71,
+-    39, 103,  23,  47, 175, 111, 239,   31,
+-    0,   0,   0,   4,  12,   2,  10,    6,
+-    13,  29,  11,  43,  27,  59,  87,   55,
+-    15,  79, 319, 831, 191, 703, 447,  959,
+-    0,  14,   1,  25,   5,  21,  19,   51,
+-    119, 159,  95, 223, 479, 991,  63,  575,
+-    127, 639, 383, 895, 255, 767, 511, 1023,
+-    14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    27, 59, 7, 39, 23, 55, 30, 1, 17, 9, 25, 5, 0, 8, 4, 12,
+-    2, 10, 6, 21, 13, 29, 3, 19, 11, 15, 47, 31, 95, 63, 127, 255,
+-    767, 2815, 1791, 3839, 511, 2559, 1535, 3583, 1023, 3071, 2047, 4095,
+-  };
+-  static const uint8_t kDefaultCommandCode[] = {
+-    0xff, 0x77, 0xd5, 0xbf, 0xe7, 0xde, 0xea, 0x9e, 0x51, 0x5d, 0xde, 0xc6,
+-    0x70, 0x57, 0xbc, 0x58, 0x58, 0x58, 0xd8, 0xd8, 0x58, 0xd5, 0xcb, 0x8c,
+-    0xea, 0xe0, 0xc3, 0x87, 0x1f, 0x83, 0xc1, 0x60, 0x1c, 0x67, 0xb2, 0xaa,
+-    0x06, 0x83, 0xc1, 0x60, 0x30, 0x18, 0xcc, 0xa1, 0xce, 0x88, 0x54, 0x94,
+-    0x46, 0xe1, 0xb0, 0xd0, 0x4e, 0xb2, 0xf7, 0x04, 0x00,
+-  };
+-  static const size_t kDefaultCommandCodeNumBits = 448;
+-  COPY_ARRAY(cmd_depths, kDefaultCommandDepths);
+-  COPY_ARRAY(cmd_bits, kDefaultCommandBits);
+-
+-  /* Initialize the pre-compressed form of the command and distance prefix
+-     codes. */
+-  COPY_ARRAY(cmd_code, kDefaultCommandCode);
+-  *cmd_code_numbits = kDefaultCommandCodeNumBits;
+-}
+-
+-/* Decide about the context map based on the ability of the prediction
+-   ability of the previous byte UTF8-prefix on the next byte. The
+-   prediction ability is calculated as Shannon entropy. Here we need
+-   Shannon entropy instead of 'BitsEntropy' since the prefix will be
+-   encoded with the remaining 6 bits of the following byte, and
+-   BitsEntropy will assume that symbol to be stored alone using Huffman
+-   coding. */
+-static void ChooseContextMap(int quality,
+-                             uint32_t* bigram_histo,
+-                             size_t* num_literal_contexts,
+-                             const uint32_t** literal_context_map) {
+-  static const uint32_t kStaticContextMapContinuation[64] = {
+-    1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-  };
+-  static const uint32_t kStaticContextMapSimpleUTF8[64] = {
+-    0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+-  };
+-
+-  uint32_t monogram_histo[3] = { 0 };
+-  uint32_t two_prefix_histo[6] = { 0 };
+-  size_t total;
+-  size_t i;
+-  size_t dummy;
+-  double entropy[4];
+-  for (i = 0; i < 9; ++i) {
+-    monogram_histo[i % 3] += bigram_histo[i];
+-    two_prefix_histo[i % 6] += bigram_histo[i];
+-  }
+-  entropy[1] = ShannonEntropy(monogram_histo, 3, &dummy);
+-  entropy[2] = (ShannonEntropy(two_prefix_histo, 3, &dummy) +
+-                ShannonEntropy(two_prefix_histo + 3, 3, &dummy));
+-  entropy[3] = 0;
+-  for (i = 0; i < 3; ++i) {
+-    entropy[3] += ShannonEntropy(bigram_histo + 3 * i, 3, &dummy);
+-  }
+-
+-  total = monogram_histo[0] + monogram_histo[1] + monogram_histo[2];
+-  BROTLI_DCHECK(total != 0);
+-  entropy[0] = 1.0 / (double)total;
+-  entropy[1] *= entropy[0];
+-  entropy[2] *= entropy[0];
+-  entropy[3] *= entropy[0];
+-
+-  if (quality < MIN_QUALITY_FOR_HQ_CONTEXT_MODELING) {
+-    /* 3 context models is a bit slower, don't use it at lower qualities. */
+-    entropy[3] = entropy[1] * 10;
+-  }
+-  /* If expected savings by symbol are less than 0.2 bits, skip the
+-     context modeling -- in exchange for faster decoding speed. */
+-  if (entropy[1] - entropy[2] < 0.2 &&
+-      entropy[1] - entropy[3] < 0.2) {
+-    *num_literal_contexts = 1;
+-  } else if (entropy[2] - entropy[3] < 0.02) {
+-    *num_literal_contexts = 2;
+-    *literal_context_map = kStaticContextMapSimpleUTF8;
+-  } else {
+-    *num_literal_contexts = 3;
+-    *literal_context_map = kStaticContextMapContinuation;
+-  }
+-}
+-
+-/* Decide if we want to use a more complex static context map containing 13
+-   context values, based on the entropy reduction of histograms over the
+-   first 5 bits of literals. */
+-static BROTLI_BOOL ShouldUseComplexStaticContextMap(const uint8_t* input,
+-    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
+-    size_t* num_literal_contexts, const uint32_t** literal_context_map) {
+-  static const uint32_t kStaticContextMapComplexUTF8[64] = {
+-    11, 11, 12, 12, /* 0 special */
+-    0, 0, 0, 0, /* 4 lf */
+-    1, 1, 9, 9, /* 8 space */
+-    2, 2, 2, 2, /* !, first after space/lf and after something else. */
+-    1, 1, 1, 1, /* " */
+-    8, 3, 3, 3, /* % */
+-    1, 1, 1, 1, /* ({[ */
+-    2, 2, 2, 2, /* }]) */
+-    8, 4, 4, 4, /* :; */
+-    8, 7, 4, 4, /* . */
+-    8, 0, 0, 0, /* > */
+-    3, 3, 3, 3, /* [0..9] */
+-    5, 5, 10, 5, /* [A-Z] */
+-    5, 5, 10, 5,
+-    6, 6, 6, 6, /* [a-z] */
+-    6, 6, 6, 6,
+-  };
+-  BROTLI_UNUSED(quality);
+-  /* Try the more complex static context map only for long data. */
+-  if (size_hint < (1 << 20)) {
+-    return BROTLI_FALSE;
+-  } else {
+-    const size_t end_pos = start_pos + length;
+-    /* To make entropy calculations faster and to fit on the stack, we collect
+-       histograms over the 5 most significant bits of literals. One histogram
+-       without context and 13 additional histograms for each context value. */
+-    uint32_t combined_histo[32] = { 0 };
+-    uint32_t context_histo[13][32] = { { 0 } };
+-    uint32_t total = 0;
+-    double entropy[3];
+-    size_t dummy;
+-    size_t i;
+-    ContextLut utf8_lut = BROTLI_CONTEXT_LUT(CONTEXT_UTF8);
+-    for (; start_pos + 64 <= end_pos; start_pos += 4096) {
+-      const size_t stride_end_pos = start_pos + 64;
+-      uint8_t prev2 = input[start_pos & mask];
+-      uint8_t prev1 = input[(start_pos + 1) & mask];
+-      size_t pos;
+-      /* To make the analysis of the data faster we only examine 64 byte long
+-         strides at every 4kB intervals. */
+-      for (pos = start_pos + 2; pos < stride_end_pos; ++pos) {
+-        const uint8_t literal = input[pos & mask];
+-        const uint8_t context = (uint8_t)kStaticContextMapComplexUTF8[
+-            BROTLI_CONTEXT(prev1, prev2, utf8_lut)];
+-        ++total;
+-        ++combined_histo[literal >> 3];
+-        ++context_histo[context][literal >> 3];
+-        prev2 = prev1;
+-        prev1 = literal;
+-      }
+-    }
+-    entropy[1] = ShannonEntropy(combined_histo, 32, &dummy);
+-    entropy[2] = 0;
+-    for (i = 0; i < 13; ++i) {
+-      entropy[2] += ShannonEntropy(&context_histo[i][0], 32, &dummy);
+-    }
+-    entropy[0] = 1.0 / (double)total;
+-    entropy[1] *= entropy[0];
+-    entropy[2] *= entropy[0];
+-    /* The triggering heuristics below were tuned by compressing the individual
+-       files of the silesia corpus. If we skip this kind of context modeling
+-       for not very well compressible input (i.e. entropy using context modeling
+-       is 60% of maximal entropy) or if expected savings by symbol are less
+-       than 0.2 bits, then in every case when it triggers, the final compression
+-       ratio is improved. Note however that this heuristics might be too strict
+-       for some cases and could be tuned further. */
+-    if (entropy[2] > 3.0 || entropy[1] - entropy[2] < 0.2) {
+-      return BROTLI_FALSE;
+-    } else {
+-      *num_literal_contexts = 13;
+-      *literal_context_map = kStaticContextMapComplexUTF8;
+-      return BROTLI_TRUE;
+-    }
+-  }
+-}
+-
+-static void DecideOverLiteralContextModeling(const uint8_t* input,
+-    size_t start_pos, size_t length, size_t mask, int quality, size_t size_hint,
+-    size_t* num_literal_contexts, const uint32_t** literal_context_map) {
+-  if (quality < MIN_QUALITY_FOR_CONTEXT_MODELING || length < 64) {
+-    return;
+-  } else if (ShouldUseComplexStaticContextMap(
+-      input, start_pos, length, mask, quality, size_hint,
+-      num_literal_contexts, literal_context_map)) {
+-    /* Context map was already set, nothing else to do. */
+-  } else {
+-    /* Gather bi-gram data of the UTF8 byte prefixes. To make the analysis of
+-       UTF8 data faster we only examine 64 byte long strides at every 4kB
+-       intervals. */
+-    const size_t end_pos = start_pos + length;
+-    uint32_t bigram_prefix_histo[9] = { 0 };
+-    for (; start_pos + 64 <= end_pos; start_pos += 4096) {
+-      static const int lut[4] = { 0, 0, 1, 2 };
+-      const size_t stride_end_pos = start_pos + 64;
+-      int prev = lut[input[start_pos & mask] >> 6] * 3;
+-      size_t pos;
+-      for (pos = start_pos + 1; pos < stride_end_pos; ++pos) {
+-        const uint8_t literal = input[pos & mask];
+-        ++bigram_prefix_histo[prev + lut[literal >> 6]];
+-        prev = lut[literal >> 6] * 3;
+-      }
+-    }
+-    ChooseContextMap(quality, &bigram_prefix_histo[0], num_literal_contexts,
+-                     literal_context_map);
+-  }
+-}
+-
+-static BROTLI_BOOL ShouldCompress(
+-    const uint8_t* data, const size_t mask, const uint64_t last_flush_pos,
+-    const size_t bytes, const size_t num_literals, const size_t num_commands) {
+-  /* TODO: find more precise minimal block overhead. */
+-  if (bytes <= 2) return BROTLI_FALSE;
+-  if (num_commands < (bytes >> 8) + 2) {
+-    if ((double)num_literals > 0.99 * (double)bytes) {
+-      uint32_t literal_histo[256] = { 0 };
+-      static const uint32_t kSampleRate = 13;
+-      static const double kMinEntropy = 7.92;
+-      const double bit_cost_threshold =
+-          (double)bytes * kMinEntropy / kSampleRate;
+-      size_t t = (bytes + kSampleRate - 1) / kSampleRate;
+-      uint32_t pos = (uint32_t)last_flush_pos;
+-      size_t i;
+-      for (i = 0; i < t; i++) {
+-        ++literal_histo[data[pos & mask]];
+-        pos += kSampleRate;
+-      }
+-      if (BitsEntropy(literal_histo, 256) > bit_cost_threshold) {
+-        return BROTLI_FALSE;
+-      }
+-    }
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-/* Chooses the literal context mode for a metablock */
+-static ContextType ChooseContextMode(const BrotliEncoderParams* params,
+-    const uint8_t* data, const size_t pos, const size_t mask,
+-    const size_t length) {
+-  /* We only do the computation for the option of something else than
+-     CONTEXT_UTF8 for the highest qualities */
+-  if (params->quality >= MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING &&
+-      !BrotliIsMostlyUTF8(data, pos, mask, length, kMinUTF8Ratio)) {
+-    return CONTEXT_SIGNED;
+-  }
+-  return CONTEXT_UTF8;
+-}
+-
+-static void WriteMetaBlockInternal(MemoryManager* m,
+-                                   const uint8_t* data,
+-                                   const size_t mask,
+-                                   const uint64_t last_flush_pos,
+-                                   const size_t bytes,
+-                                   const BROTLI_BOOL is_last,
+-                                   ContextType literal_context_mode,
+-                                   const BrotliEncoderParams* params,
+-                                   const uint8_t prev_byte,
+-                                   const uint8_t prev_byte2,
+-                                   const size_t num_literals,
+-                                   const size_t num_commands,
+-                                   Command* commands,
+-                                   const int* saved_dist_cache,
+-                                   int* dist_cache,
+-                                   size_t* storage_ix,
+-                                   uint8_t* storage) {
+-  const uint32_t wrapped_last_flush_pos = WrapPosition(last_flush_pos);
+-  uint16_t last_bytes;
+-  uint8_t last_bytes_bits;
+-  ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
+-  BrotliEncoderParams block_params = *params;
+-
+-  if (bytes == 0) {
+-    /* Write the ISLAST and ISEMPTY bits. */
+-    BrotliWriteBits(2, 3, storage_ix, storage);
+-    *storage_ix = (*storage_ix + 7u) & ~7u;
+-    return;
+-  }
+-
+-  if (!ShouldCompress(data, mask, last_flush_pos, bytes,
+-                      num_literals, num_commands)) {
+-    /* Restore the distance cache, as its last update by
+-       CreateBackwardReferences is now unused. */
+-    memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
+-    BrotliStoreUncompressedMetaBlock(is_last, data,
+-                                     wrapped_last_flush_pos, mask, bytes,
+-                                     storage_ix, storage);
+-    return;
+-  }
+-
+-  BROTLI_DCHECK(*storage_ix <= 14);
+-  last_bytes = (uint16_t)((storage[1] << 8) | storage[0]);
+-  last_bytes_bits = (uint8_t)(*storage_ix);
+-  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
+-    BrotliStoreMetaBlockFast(m, data, wrapped_last_flush_pos,
+-                             bytes, mask, is_last, params,
+-                             commands, num_commands,
+-                             storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-  } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
+-    BrotliStoreMetaBlockTrivial(m, data, wrapped_last_flush_pos,
+-                                bytes, mask, is_last, params,
+-                                commands, num_commands,
+-                                storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-  } else {
+-    MetaBlockSplit mb;
+-    InitMetaBlockSplit(&mb);
+-    if (params->quality < MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING) {
+-      size_t num_literal_contexts = 1;
+-      const uint32_t* literal_context_map = NULL;
+-      if (!params->disable_literal_context_modeling) {
+-        DecideOverLiteralContextModeling(
+-            data, wrapped_last_flush_pos, bytes, mask, params->quality,
+-            params->size_hint, &num_literal_contexts,
+-            &literal_context_map);
+-      }
+-      BrotliBuildMetaBlockGreedy(m, data, wrapped_last_flush_pos, mask,
+-          prev_byte, prev_byte2, literal_context_lut, num_literal_contexts,
+-          literal_context_map, commands, num_commands, &mb);
+-      if (BROTLI_IS_OOM(m)) return;
+-    } else {
+-      BrotliBuildMetaBlock(m, data, wrapped_last_flush_pos, mask, &block_params,
+-                           prev_byte, prev_byte2,
+-                           commands, num_commands,
+-                           literal_context_mode,
+-                           &mb);
+-      if (BROTLI_IS_OOM(m)) return;
+-    }
+-    if (params->quality >= MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS) {
+-      /* The number of distance symbols effectively used for distance
+-         histograms. It might be less than distance alphabet size
+-         for "Large Window Brotli" (32-bit). */
+-      BrotliOptimizeHistograms(block_params.dist.alphabet_size_limit, &mb);
+-    }
+-    BrotliStoreMetaBlock(m, data, wrapped_last_flush_pos, bytes, mask,
+-                         prev_byte, prev_byte2,
+-                         is_last,
+-                         &block_params,
+-                         literal_context_mode,
+-                         commands, num_commands,
+-                         &mb,
+-                         storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return;
+-    DestroyMetaBlockSplit(m, &mb);
+-  }
+-  if (bytes + 4 < (*storage_ix >> 3)) {
+-    /* Restore the distance cache and last byte. */
+-    memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
+-    storage[0] = (uint8_t)last_bytes;
+-    storage[1] = (uint8_t)(last_bytes >> 8);
+-    *storage_ix = last_bytes_bits;
+-    BrotliStoreUncompressedMetaBlock(is_last, data,
+-                                     wrapped_last_flush_pos, mask,
+-                                     bytes, storage_ix, storage);
+-  }
+-}
+-
+-static void ChooseDistanceParams(BrotliEncoderParams* params) {
+-  uint32_t distance_postfix_bits = 0;
+-  uint32_t num_direct_distance_codes = 0;
+-
+-  if (params->quality >= MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS) {
+-    uint32_t ndirect_msb;
+-    if (params->mode == BROTLI_MODE_FONT) {
+-      distance_postfix_bits = 1;
+-      num_direct_distance_codes = 12;
+-    } else {
+-      distance_postfix_bits = params->dist.distance_postfix_bits;
+-      num_direct_distance_codes = params->dist.num_direct_distance_codes;
+-    }
+-    ndirect_msb = (num_direct_distance_codes >> distance_postfix_bits) & 0x0F;
+-    if (distance_postfix_bits > BROTLI_MAX_NPOSTFIX ||
+-        num_direct_distance_codes > BROTLI_MAX_NDIRECT ||
+-        (ndirect_msb << distance_postfix_bits) != num_direct_distance_codes) {
+-      distance_postfix_bits = 0;
+-      num_direct_distance_codes = 0;
+-    }
+-  }
+-
+-  BrotliInitDistanceParams(
+-      params, distance_postfix_bits, num_direct_distance_codes);
+-}
+-
+-static BROTLI_BOOL EnsureInitialized(BrotliEncoderState* s) {
+-  if (BROTLI_IS_OOM(&s->memory_manager_)) return BROTLI_FALSE;
+-  if (s->is_initialized_) return BROTLI_TRUE;
+-
+-  s->last_bytes_bits_ = 0;
+-  s->last_bytes_ = 0;
+-  s->flint_ = BROTLI_FLINT_DONE;
+-  s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
+-
+-  SanitizeParams(&s->params);
+-  s->params.lgblock = ComputeLgBlock(&s->params);
+-  ChooseDistanceParams(&s->params);
+-
+-  if (s->params.stream_offset != 0) {
+-    s->flint_ = BROTLI_FLINT_NEEDS_2_BYTES;
+-    /* Poison the distance cache. -16 +- 3 is still less than zero (invalid). */
+-    s->dist_cache_[0] = -16;
+-    s->dist_cache_[1] = -16;
+-    s->dist_cache_[2] = -16;
+-    s->dist_cache_[3] = -16;
+-    memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
+-  }
+-
+-  RingBufferSetup(&s->params, &s->ringbuffer_);
+-
+-  /* Initialize last byte with stream header. */
+-  {
+-    int lgwin = s->params.lgwin;
+-    if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
+-        s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-      lgwin = BROTLI_MAX(int, lgwin, 18);
+-    }
+-    if (s->params.stream_offset == 0) {
+-      EncodeWindowBits(lgwin, s->params.large_window,
+-                       &s->last_bytes_, &s->last_bytes_bits_);
+-    } else {
+-      /* Bigger values have the same effect, but could cause overflows. */
+-      s->params.stream_offset = BROTLI_MIN(size_t,
+-          s->params.stream_offset, BROTLI_MAX_BACKWARD_LIMIT(lgwin));
+-    }
+-  }
+-
+-  if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
+-    InitCommandPrefixCodes(s->cmd_depths_, s->cmd_bits_,
+-                           s->cmd_code_, &s->cmd_code_numbits_);
+-  }
+-
+-  s->is_initialized_ = BROTLI_TRUE;
+-  return BROTLI_TRUE;
+-}
+-
+-static void BrotliEncoderInitParams(BrotliEncoderParams* params) {
+-  params->mode = BROTLI_DEFAULT_MODE;
+-  params->large_window = BROTLI_FALSE;
+-  params->quality = BROTLI_DEFAULT_QUALITY;
+-  params->lgwin = BROTLI_DEFAULT_WINDOW;
+-  params->lgblock = 0;
+-  params->stream_offset = 0;
+-  params->size_hint = 0;
+-  params->disable_literal_context_modeling = BROTLI_FALSE;
+-  BrotliInitEncoderDictionary(&params->dictionary);
+-  params->dist.distance_postfix_bits = 0;
+-  params->dist.num_direct_distance_codes = 0;
+-  params->dist.alphabet_size_max =
+-      BROTLI_DISTANCE_ALPHABET_SIZE(0, 0, BROTLI_MAX_DISTANCE_BITS);
+-  params->dist.alphabet_size_limit = params->dist.alphabet_size_max;
+-  params->dist.max_distance = BROTLI_MAX_DISTANCE;
+-}
+-
+-static void BrotliEncoderInitState(BrotliEncoderState* s) {
+-  BrotliEncoderInitParams(&s->params);
+-  s->input_pos_ = 0;
+-  s->num_commands_ = 0;
+-  s->num_literals_ = 0;
+-  s->last_insert_len_ = 0;
+-  s->last_flush_pos_ = 0;
+-  s->last_processed_pos_ = 0;
+-  s->prev_byte_ = 0;
+-  s->prev_byte2_ = 0;
+-  s->storage_size_ = 0;
+-  s->storage_ = 0;
+-  HasherInit(&s->hasher_);
+-  s->large_table_ = NULL;
+-  s->large_table_size_ = 0;
+-  s->cmd_code_numbits_ = 0;
+-  s->command_buf_ = NULL;
+-  s->literal_buf_ = NULL;
+-  s->next_out_ = NULL;
+-  s->available_out_ = 0;
+-  s->total_out_ = 0;
+-  s->stream_state_ = BROTLI_STREAM_PROCESSING;
+-  s->is_last_block_emitted_ = BROTLI_FALSE;
+-  s->is_initialized_ = BROTLI_FALSE;
+-
+-  RingBufferInit(&s->ringbuffer_);
+-
+-  s->commands_ = 0;
+-  s->cmd_alloc_size_ = 0;
+-
+-  /* Initialize distance cache. */
+-  s->dist_cache_[0] = 4;
+-  s->dist_cache_[1] = 11;
+-  s->dist_cache_[2] = 15;
+-  s->dist_cache_[3] = 16;
+-  /* Save the state of the distance cache in case we need to restore it for
+-     emitting an uncompressed block. */
+-  memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
+-}
+-
+-BrotliEncoderState* BrotliEncoderCreateInstance(
+-    brotli_alloc_func alloc_func, brotli_free_func free_func, void* opaque) {
+-  BrotliEncoderState* state = 0;
+-  if (!alloc_func && !free_func) {
+-    state = (BrotliEncoderState*)malloc(sizeof(BrotliEncoderState));
+-  } else if (alloc_func && free_func) {
+-    state = (BrotliEncoderState*)alloc_func(opaque, sizeof(BrotliEncoderState));
+-  }
+-  if (state == 0) {
+-    /* BROTLI_DUMP(); */
+-    return 0;
+-  }
+-  BrotliInitMemoryManager(
+-      &state->memory_manager_, alloc_func, free_func, opaque);
+-  BrotliEncoderInitState(state);
+-  return state;
+-}
+-
+-static void BrotliEncoderCleanupState(BrotliEncoderState* s) {
+-  MemoryManager* m = &s->memory_manager_;
+-  if (BROTLI_IS_OOM(m)) {
+-    BrotliWipeOutMemoryManager(m);
+-    return;
+-  }
+-  BROTLI_FREE(m, s->storage_);
+-  BROTLI_FREE(m, s->commands_);
+-  RingBufferFree(m, &s->ringbuffer_);
+-  DestroyHasher(m, &s->hasher_);
+-  BROTLI_FREE(m, s->large_table_);
+-  BROTLI_FREE(m, s->command_buf_);
+-  BROTLI_FREE(m, s->literal_buf_);
+-}
+-
+-/* Deinitializes and frees BrotliEncoderState instance. */
+-void BrotliEncoderDestroyInstance(BrotliEncoderState* state) {
+-  if (!state) {
+-    return;
+-  } else {
+-    MemoryManager* m = &state->memory_manager_;
+-    brotli_free_func free_func = m->free_func;
+-    void* opaque = m->opaque;
+-    BrotliEncoderCleanupState(state);
+-    free_func(opaque, state);
+-  }
+-}
+-
+-/*
+-   Copies the given input data to the internal ring buffer of the compressor.
+-   No processing of the data occurs at this time and this function can be
+-   called multiple times before calling WriteBrotliData() to process the
+-   accumulated input. At most input_block_size() bytes of input data can be
+-   copied to the ring buffer, otherwise the next WriteBrotliData() will fail.
+- */
+-static void CopyInputToRingBuffer(BrotliEncoderState* s,
+-                                  const size_t input_size,
+-                                  const uint8_t* input_buffer) {
+-  RingBuffer* ringbuffer_ = &s->ringbuffer_;
+-  MemoryManager* m = &s->memory_manager_;
+-  RingBufferWrite(m, input_buffer, input_size, ringbuffer_);
+-  if (BROTLI_IS_OOM(m)) return;
+-  s->input_pos_ += input_size;
+-
+-  /* TL;DR: If needed, initialize 7 more bytes in the ring buffer to make the
+-     hashing not depend on uninitialized data. This makes compression
+-     deterministic and it prevents uninitialized memory warnings in Valgrind.
+-     Even without erasing, the output would be valid (but nondeterministic).
+-
+-     Background information: The compressor stores short (at most 8 bytes)
+-     substrings of the input already read in a hash table, and detects
+-     repetitions by looking up such substrings in the hash table. If it
+-     can find a substring, it checks whether the substring is really there
+-     in the ring buffer (or it's just a hash collision). Should the hash
+-     table become corrupt, this check makes sure that the output is
+-     still valid, albeit the compression ratio would be bad.
+-
+-     The compressor populates the hash table from the ring buffer as it's
+-     reading new bytes from the input. However, at the last few indexes of
+-     the ring buffer, there are not enough bytes to build full-length
+-     substrings from. Since the hash table always contains full-length
+-     substrings, we erase with dummy zeros here to make sure that those
+-     substrings will contain zeros at the end instead of uninitialized
+-     data.
+-
+-     Please note that erasing is not necessary (because the
+-     memory region is already initialized since he ring buffer
+-     has a `tail' that holds a copy of the beginning,) so we
+-     skip erasing if we have already gone around at least once in
+-     the ring buffer.
+-
+-     Only clear during the first round of ring-buffer writes. On
+-     subsequent rounds data in the ring-buffer would be affected. */
+-  if (ringbuffer_->pos_ <= ringbuffer_->mask_) {
+-    /* This is the first time when the ring buffer is being written.
+-       We clear 7 bytes just after the bytes that have been copied from
+-       the input buffer.
+-
+-       The ring-buffer has a "tail" that holds a copy of the beginning,
+-       but only once the ring buffer has been fully written once, i.e.,
+-       pos <= mask. For the first time, we need to write values
+-       in this tail (where index may be larger than mask), so that
+-       we have exactly defined behavior and don't read uninitialized
+-       memory. Due to performance reasons, hashing reads data using a
+-       LOAD64, which can go 7 bytes beyond the bytes written in the
+-       ring-buffer. */
+-    memset(ringbuffer_->buffer_ + ringbuffer_->pos_, 0, 7);
+-  }
+-}
+-
+-/* Marks all input as processed.
+-   Returns true if position wrapping occurs. */
+-static BROTLI_BOOL UpdateLastProcessedPos(BrotliEncoderState* s) {
+-  uint32_t wrapped_last_processed_pos = WrapPosition(s->last_processed_pos_);
+-  uint32_t wrapped_input_pos = WrapPosition(s->input_pos_);
+-  s->last_processed_pos_ = s->input_pos_;
+-  return TO_BROTLI_BOOL(wrapped_input_pos < wrapped_last_processed_pos);
+-}
+-
+-static void ExtendLastCommand(BrotliEncoderState* s, uint32_t* bytes,
+-                              uint32_t* wrapped_last_processed_pos) {
+-  Command* last_command = &s->commands_[s->num_commands_ - 1];
+-  const uint8_t* data = s->ringbuffer_.buffer_;
+-  const uint32_t mask = s->ringbuffer_.mask_;
+-  uint64_t max_backward_distance =
+-      (((uint64_t)1) << s->params.lgwin) - BROTLI_WINDOW_GAP;
+-  uint64_t last_copy_len = last_command->copy_len_ & 0x1FFFFFF;
+-  uint64_t last_processed_pos = s->last_processed_pos_ - last_copy_len;
+-  uint64_t max_distance = last_processed_pos < max_backward_distance ?
+-      last_processed_pos : max_backward_distance;
+-  uint64_t cmd_dist = (uint64_t)s->dist_cache_[0];
+-  uint32_t distance_code = CommandRestoreDistanceCode(last_command,
+-                                                      &s->params.dist);
+-  if (distance_code < BROTLI_NUM_DISTANCE_SHORT_CODES ||
+-      distance_code - (BROTLI_NUM_DISTANCE_SHORT_CODES - 1) == cmd_dist) {
+-    if (cmd_dist <= max_distance) {
+-      while (*bytes != 0 && data[*wrapped_last_processed_pos & mask] ==
+-             data[(*wrapped_last_processed_pos - cmd_dist) & mask]) {
+-        last_command->copy_len_++;
+-        (*bytes)--;
+-        (*wrapped_last_processed_pos)++;
+-      }
+-    } else {
+-    }
+-    /* The copy length is at most the metablock size, and thus expressible. */
+-    GetLengthCode(last_command->insert_len_,
+-                  (size_t)((int)(last_command->copy_len_ & 0x1FFFFFF) +
+-                           (int)(last_command->copy_len_ >> 25)),
+-                  TO_BROTLI_BOOL((last_command->dist_prefix_ & 0x3FF) == 0),
+-                  &last_command->cmd_prefix_);
+-  }
+-}
+-
+-/*
+-   Processes the accumulated input data and sets |*out_size| to the length of
+-   the new output meta-block, or to zero if no new output meta-block has been
+-   created (in this case the processed input data is buffered internally).
+-   If |*out_size| is positive, |*output| points to the start of the output
+-   data. If |is_last| or |force_flush| is BROTLI_TRUE, an output meta-block is
+-   always created. However, until |is_last| is BROTLI_TRUE encoder may retain up
+-   to 7 bits of the last byte of output. To force encoder to dump the remaining
+-   bits use WriteMetadata() to append an empty meta-data block.
+-   Returns BROTLI_FALSE if the size of the input data is larger than
+-   input_block_size().
+- */
+-static BROTLI_BOOL EncodeData(
+-    BrotliEncoderState* s, const BROTLI_BOOL is_last,
+-    const BROTLI_BOOL force_flush, size_t* out_size, uint8_t** output) {
+-  const uint64_t delta = UnprocessedInputSize(s);
+-  uint32_t bytes = (uint32_t)delta;
+-  uint32_t wrapped_last_processed_pos = WrapPosition(s->last_processed_pos_);
+-  uint8_t* data;
+-  uint32_t mask;
+-  MemoryManager* m = &s->memory_manager_;
+-  ContextType literal_context_mode;
+-  ContextLut literal_context_lut;
+-
+-  data = s->ringbuffer_.buffer_;
+-  mask = s->ringbuffer_.mask_;
+-
+-  /* Adding more blocks after "last" block is forbidden. */
+-  if (s->is_last_block_emitted_) return BROTLI_FALSE;
+-  if (is_last) s->is_last_block_emitted_ = BROTLI_TRUE;
+-
+-  if (delta > InputBlockSize(s)) {
+-    return BROTLI_FALSE;
+-  }
+-  if (s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY &&
+-      !s->command_buf_) {
+-    s->command_buf_ =
+-        BROTLI_ALLOC(m, uint32_t, kCompressFragmentTwoPassBlockSize);
+-    s->literal_buf_ =
+-        BROTLI_ALLOC(m, uint8_t, kCompressFragmentTwoPassBlockSize);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->command_buf_) ||
+-        BROTLI_IS_NULL(s->literal_buf_)) {
+-      return BROTLI_FALSE;
+-    }
+-  }
+-
+-  if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
+-      s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-    uint8_t* storage;
+-    size_t storage_ix = s->last_bytes_bits_;
+-    size_t table_size;
+-    int* table;
+-
+-    if (delta == 0 && !is_last) {
+-      /* We have no new input data and we don't have to finish the stream, so
+-         nothing to do. */
+-      *out_size = 0;
+-      return BROTLI_TRUE;
+-    }
+-    storage = GetBrotliStorage(s, 2 * bytes + 503);
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    storage[0] = (uint8_t)s->last_bytes_;
+-    storage[1] = (uint8_t)(s->last_bytes_ >> 8);
+-    table = GetHashTable(s, s->params.quality, bytes, &table_size);
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
+-      BrotliCompressFragmentFast(
+-          m, &data[wrapped_last_processed_pos & mask],
+-          bytes, is_last,
+-          table, table_size,
+-          s->cmd_depths_, s->cmd_bits_,
+-          &s->cmd_code_numbits_, s->cmd_code_,
+-          &storage_ix, storage);
+-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    } else {
+-      BrotliCompressFragmentTwoPass(
+-          m, &data[wrapped_last_processed_pos & mask],
+-          bytes, is_last,
+-          s->command_buf_, s->literal_buf_,
+-          table, table_size,
+-          &storage_ix, storage);
+-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    }
+-    s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
+-    s->last_bytes_bits_ = storage_ix & 7u;
+-    UpdateLastProcessedPos(s);
+-    *output = &storage[0];
+-    *out_size = storage_ix >> 3;
+-    return BROTLI_TRUE;
+-  }
+-
+-  {
+-    /* Theoretical max number of commands is 1 per 2 bytes. */
+-    size_t newsize = s->num_commands_ + bytes / 2 + 1;
+-    if (newsize > s->cmd_alloc_size_) {
+-      Command* new_commands;
+-      /* Reserve a bit more memory to allow merging with a next block
+-         without reallocation: that would impact speed. */
+-      newsize += (bytes / 4) + 16;
+-      s->cmd_alloc_size_ = newsize;
+-      new_commands = BROTLI_ALLOC(m, Command, newsize);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_commands)) return BROTLI_FALSE;
+-      if (s->commands_) {
+-        memcpy(new_commands, s->commands_, sizeof(Command) * s->num_commands_);
+-        BROTLI_FREE(m, s->commands_);
+-      }
+-      s->commands_ = new_commands;
+-    }
+-  }
+-
+-  InitOrStitchToPreviousBlock(m, &s->hasher_, data, mask, &s->params,
+-      wrapped_last_processed_pos, bytes, is_last);
+-
+-  literal_context_mode = ChooseContextMode(
+-      &s->params, data, WrapPosition(s->last_flush_pos_),
+-      mask, (size_t)(s->input_pos_ - s->last_flush_pos_));
+-  literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
+-
+-  if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-
+-  if (s->num_commands_ && s->last_insert_len_ == 0) {
+-    ExtendLastCommand(s, &bytes, &wrapped_last_processed_pos);
+-  }
+-
+-  if (s->params.quality == ZOPFLIFICATION_QUALITY) {
+-    BROTLI_DCHECK(s->params.hasher.type == 10);
+-    BrotliCreateZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
+-        data, mask, literal_context_lut, &s->params,
+-        &s->hasher_, s->dist_cache_,
+-        &s->last_insert_len_, &s->commands_[s->num_commands_],
+-        &s->num_commands_, &s->num_literals_);
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-  } else if (s->params.quality == HQ_ZOPFLIFICATION_QUALITY) {
+-    BROTLI_DCHECK(s->params.hasher.type == 10);
+-    BrotliCreateHqZopfliBackwardReferences(m, bytes, wrapped_last_processed_pos,
+-        data, mask, literal_context_lut, &s->params,
+-        &s->hasher_, s->dist_cache_,
+-        &s->last_insert_len_, &s->commands_[s->num_commands_],
+-        &s->num_commands_, &s->num_literals_);
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-  } else {
+-    BrotliCreateBackwardReferences(bytes, wrapped_last_processed_pos,
+-        data, mask, literal_context_lut, &s->params,
+-        &s->hasher_, s->dist_cache_,
+-        &s->last_insert_len_, &s->commands_[s->num_commands_],
+-        &s->num_commands_, &s->num_literals_);
+-  }
+-
+-  {
+-    const size_t max_length = MaxMetablockSize(&s->params);
+-    const size_t max_literals = max_length / 8;
+-    const size_t max_commands = max_length / 8;
+-    const size_t processed_bytes = (size_t)(s->input_pos_ - s->last_flush_pos_);
+-    /* If maximal possible additional block doesn't fit metablock, flush now. */
+-    /* TODO: Postpone decision until next block arrives? */
+-    const BROTLI_BOOL next_input_fits_metablock = TO_BROTLI_BOOL(
+-        processed_bytes + InputBlockSize(s) <= max_length);
+-    /* If block splitting is not used, then flush as soon as there is some
+-       amount of commands / literals produced. */
+-    const BROTLI_BOOL should_flush = TO_BROTLI_BOOL(
+-        s->params.quality < MIN_QUALITY_FOR_BLOCK_SPLIT &&
+-        s->num_literals_ + s->num_commands_ >= MAX_NUM_DELAYED_SYMBOLS);
+-    if (!is_last && !force_flush && !should_flush &&
+-        next_input_fits_metablock &&
+-        s->num_literals_ < max_literals &&
+-        s->num_commands_ < max_commands) {
+-      /* Merge with next input block. Everything will happen later. */
+-      if (UpdateLastProcessedPos(s)) {
+-        HasherReset(&s->hasher_);
+-      }
+-      *out_size = 0;
+-      return BROTLI_TRUE;
+-    }
+-  }
+-
+-  /* Create the last insert-only command. */
+-  if (s->last_insert_len_ > 0) {
+-    InitInsertCommand(&s->commands_[s->num_commands_++], s->last_insert_len_);
+-    s->num_literals_ += s->last_insert_len_;
+-    s->last_insert_len_ = 0;
+-  }
+-
+-  if (!is_last && s->input_pos_ == s->last_flush_pos_) {
+-    /* We have no new input data and we don't have to finish the stream, so
+-       nothing to do. */
+-    *out_size = 0;
+-    return BROTLI_TRUE;
+-  }
+-  BROTLI_DCHECK(s->input_pos_ >= s->last_flush_pos_);
+-  BROTLI_DCHECK(s->input_pos_ > s->last_flush_pos_ || is_last);
+-  BROTLI_DCHECK(s->input_pos_ - s->last_flush_pos_ <= 1u << 24);
+-  {
+-    const uint32_t metablock_size =
+-        (uint32_t)(s->input_pos_ - s->last_flush_pos_);
+-    uint8_t* storage = GetBrotliStorage(s, 2 * metablock_size + 503);
+-    size_t storage_ix = s->last_bytes_bits_;
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    storage[0] = (uint8_t)s->last_bytes_;
+-    storage[1] = (uint8_t)(s->last_bytes_ >> 8);
+-    WriteMetaBlockInternal(
+-        m, data, mask, s->last_flush_pos_, metablock_size, is_last,
+-        literal_context_mode, &s->params, s->prev_byte_, s->prev_byte2_,
+-        s->num_literals_, s->num_commands_, s->commands_, s->saved_dist_cache_,
+-        s->dist_cache_, &storage_ix, storage);
+-    if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-    s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
+-    s->last_bytes_bits_ = storage_ix & 7u;
+-    s->last_flush_pos_ = s->input_pos_;
+-    if (UpdateLastProcessedPos(s)) {
+-      HasherReset(&s->hasher_);
+-    }
+-    if (s->last_flush_pos_ > 0) {
+-      s->prev_byte_ = data[((uint32_t)s->last_flush_pos_ - 1) & mask];
+-    }
+-    if (s->last_flush_pos_ > 1) {
+-      s->prev_byte2_ = data[(uint32_t)(s->last_flush_pos_ - 2) & mask];
+-    }
+-    s->num_commands_ = 0;
+-    s->num_literals_ = 0;
+-    /* Save the state of the distance cache in case we need to restore it for
+-       emitting an uncompressed block. */
+-    memcpy(s->saved_dist_cache_, s->dist_cache_, sizeof(s->saved_dist_cache_));
+-    *output = &storage[0];
+-    *out_size = storage_ix >> 3;
+-    return BROTLI_TRUE;
+-  }
+-}
+-
+-/* Dumps remaining output bits and metadata header to |header|.
+-   Returns number of produced bytes.
+-   REQUIRED: |header| should be 8-byte aligned and at least 16 bytes long.
+-   REQUIRED: |block_size| <= (1 << 24). */
+-static size_t WriteMetadataHeader(
+-    BrotliEncoderState* s, const size_t block_size, uint8_t* header) {
+-  size_t storage_ix;
+-  storage_ix = s->last_bytes_bits_;
+-  header[0] = (uint8_t)s->last_bytes_;
+-  header[1] = (uint8_t)(s->last_bytes_ >> 8);
+-  s->last_bytes_ = 0;
+-  s->last_bytes_bits_ = 0;
+-
+-  BrotliWriteBits(1, 0, &storage_ix, header);
+-  BrotliWriteBits(2, 3, &storage_ix, header);
+-  BrotliWriteBits(1, 0, &storage_ix, header);
+-  if (block_size == 0) {
+-    BrotliWriteBits(2, 0, &storage_ix, header);
+-  } else {
+-    uint32_t nbits = (block_size == 1) ? 0 :
+-        (Log2FloorNonZero((uint32_t)block_size - 1) + 1);
+-    uint32_t nbytes = (nbits + 7) / 8;
+-    BrotliWriteBits(2, nbytes, &storage_ix, header);
+-    BrotliWriteBits(8 * nbytes, block_size - 1, &storage_ix, header);
+-  }
+-  return (storage_ix + 7u) >> 3;
+-}
+-
+-static BROTLI_BOOL BrotliCompressBufferQuality10(
+-    int lgwin, size_t input_size, const uint8_t* input_buffer,
+-    size_t* encoded_size, uint8_t* encoded_buffer) {
+-  MemoryManager memory_manager;
+-  MemoryManager* m = &memory_manager;
+-
+-  const size_t mask = BROTLI_SIZE_MAX >> 1;
+-  int dist_cache[4] = { 4, 11, 15, 16 };
+-  int saved_dist_cache[4] = { 4, 11, 15, 16 };
+-  BROTLI_BOOL ok = BROTLI_TRUE;
+-  const size_t max_out_size = *encoded_size;
+-  size_t total_out_size = 0;
+-  uint16_t last_bytes;
+-  uint8_t last_bytes_bits;
+-
+-  const size_t hasher_eff_size = BROTLI_MIN(size_t,
+-      input_size, BROTLI_MAX_BACKWARD_LIMIT(lgwin) + BROTLI_WINDOW_GAP);
+-
+-  BrotliEncoderParams params;
+-
+-  const int lgmetablock = BROTLI_MIN(int, 24, lgwin + 1);
+-  size_t max_block_size;
+-  const size_t max_metablock_size = (size_t)1 << lgmetablock;
+-  const size_t max_literals_per_metablock = max_metablock_size / 8;
+-  const size_t max_commands_per_metablock = max_metablock_size / 8;
+-  size_t metablock_start = 0;
+-  uint8_t prev_byte = 0;
+-  uint8_t prev_byte2 = 0;
+-
+-  Hasher hasher;
+-  HasherInit(&hasher);
+-
+-  BrotliEncoderInitParams(&params);
+-  params.quality = 10;
+-  params.lgwin = lgwin;
+-  if (lgwin > BROTLI_MAX_WINDOW_BITS) {
+-    params.large_window = BROTLI_TRUE;
+-  }
+-  SanitizeParams(&params);
+-  params.lgblock = ComputeLgBlock(&params);
+-  ChooseDistanceParams(&params);
+-  max_block_size = (size_t)1 << params.lgblock;
+-
+-  BrotliInitMemoryManager(m, 0, 0, 0);
+-
+-  BROTLI_DCHECK(input_size <= mask + 1);
+-  EncodeWindowBits(lgwin, params.large_window, &last_bytes, &last_bytes_bits);
+-  InitOrStitchToPreviousBlock(m, &hasher, input_buffer, mask, &params,
+-      0, hasher_eff_size, BROTLI_TRUE);
+-  if (BROTLI_IS_OOM(m)) goto oom;
+-
+-  while (ok && metablock_start < input_size) {
+-    const size_t metablock_end =
+-        BROTLI_MIN(size_t, input_size, metablock_start + max_metablock_size);
+-    const size_t expected_num_commands =
+-        (metablock_end - metablock_start) / 12 + 16;
+-    Command* commands = 0;
+-    size_t num_commands = 0;
+-    size_t last_insert_len = 0;
+-    size_t num_literals = 0;
+-    size_t metablock_size = 0;
+-    size_t cmd_alloc_size = 0;
+-    BROTLI_BOOL is_last;
+-    uint8_t* storage;
+-    size_t storage_ix;
+-
+-    ContextType literal_context_mode = ChooseContextMode(&params,
+-        input_buffer, metablock_start, mask, metablock_end - metablock_start);
+-    ContextLut literal_context_lut = BROTLI_CONTEXT_LUT(literal_context_mode);
+-
+-    size_t block_start;
+-    for (block_start = metablock_start; block_start < metablock_end; ) {
+-      size_t block_size =
+-          BROTLI_MIN(size_t, metablock_end - block_start, max_block_size);
+-      ZopfliNode* nodes = BROTLI_ALLOC(m, ZopfliNode, block_size + 1);
+-      size_t path_size;
+-      size_t new_cmd_alloc_size;
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(nodes)) goto oom;
+-      BrotliInitZopfliNodes(nodes, block_size + 1);
+-      StitchToPreviousBlockH10(&hasher.privat._H10, block_size, block_start,
+-                               input_buffer, mask);
+-      path_size = BrotliZopfliComputeShortestPath(m, block_size, block_start,
+-          input_buffer, mask, literal_context_lut, &params, dist_cache, &hasher,
+-          nodes);
+-      if (BROTLI_IS_OOM(m)) goto oom;
+-      /* We allocate a command buffer in the first iteration of this loop that
+-         will be likely big enough for the whole metablock, so that for most
+-         inputs we will not have to reallocate in later iterations. We do the
+-         allocation here and not before the loop, because if the input is small,
+-         this will be allocated after the Zopfli cost model is freed, so this
+-         will not increase peak memory usage.
+-         TODO: If the first allocation is too small, increase command
+-         buffer size exponentially. */
+-      new_cmd_alloc_size = BROTLI_MAX(size_t, expected_num_commands,
+-                                      num_commands + path_size + 1);
+-      if (cmd_alloc_size != new_cmd_alloc_size) {
+-        Command* new_commands = BROTLI_ALLOC(m, Command, new_cmd_alloc_size);
+-        if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_commands)) goto oom;
+-        cmd_alloc_size = new_cmd_alloc_size;
+-        if (commands) {
+-          memcpy(new_commands, commands, sizeof(Command) * num_commands);
+-          BROTLI_FREE(m, commands);
+-        }
+-        commands = new_commands;
+-      }
+-      BrotliZopfliCreateCommands(block_size, block_start, &nodes[0], dist_cache,
+-          &last_insert_len, &params, &commands[num_commands], &num_literals);
+-      num_commands += path_size;
+-      block_start += block_size;
+-      metablock_size += block_size;
+-      BROTLI_FREE(m, nodes);
+-      if (num_literals > max_literals_per_metablock ||
+-          num_commands > max_commands_per_metablock) {
+-        break;
+-      }
+-    }
+-
+-    if (last_insert_len > 0) {
+-      InitInsertCommand(&commands[num_commands++], last_insert_len);
+-      num_literals += last_insert_len;
+-    }
+-
+-    is_last = TO_BROTLI_BOOL(metablock_start + metablock_size == input_size);
+-    storage = NULL;
+-    storage_ix = last_bytes_bits;
+-
+-    if (metablock_size == 0) {
+-      /* Write the ISLAST and ISEMPTY bits. */
+-      storage = BROTLI_ALLOC(m, uint8_t, 16);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(storage)) goto oom;
+-      storage[0] = (uint8_t)last_bytes;
+-      storage[1] = (uint8_t)(last_bytes >> 8);
+-      BrotliWriteBits(2, 3, &storage_ix, storage);
+-      storage_ix = (storage_ix + 7u) & ~7u;
+-    } else if (!ShouldCompress(input_buffer, mask, metablock_start,
+-                               metablock_size, num_literals, num_commands)) {
+-      /* Restore the distance cache, as its last update by
+-         CreateBackwardReferences is now unused. */
+-      memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
+-      storage = BROTLI_ALLOC(m, uint8_t, metablock_size + 16);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(storage)) goto oom;
+-      storage[0] = (uint8_t)last_bytes;
+-      storage[1] = (uint8_t)(last_bytes >> 8);
+-      BrotliStoreUncompressedMetaBlock(is_last, input_buffer,
+-                                       metablock_start, mask, metablock_size,
+-                                       &storage_ix, storage);
+-    } else {
+-      MetaBlockSplit mb;
+-      BrotliEncoderParams block_params = params;
+-      InitMetaBlockSplit(&mb);
+-      BrotliBuildMetaBlock(m, input_buffer, metablock_start, mask,
+-                           &block_params,
+-                           prev_byte, prev_byte2,
+-                           commands, num_commands,
+-                           literal_context_mode,
+-                           &mb);
+-      if (BROTLI_IS_OOM(m)) goto oom;
+-      {
+-        /* The number of distance symbols effectively used for distance
+-           histograms. It might be less than distance alphabet size
+-           for "Large Window Brotli" (32-bit). */
+-        BrotliOptimizeHistograms(block_params.dist.alphabet_size_limit, &mb);
+-      }
+-      storage = BROTLI_ALLOC(m, uint8_t, 2 * metablock_size + 503);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(storage)) goto oom;
+-      storage[0] = (uint8_t)last_bytes;
+-      storage[1] = (uint8_t)(last_bytes >> 8);
+-      BrotliStoreMetaBlock(m, input_buffer, metablock_start, metablock_size,
+-                           mask, prev_byte, prev_byte2,
+-                           is_last,
+-                           &block_params,
+-                           literal_context_mode,
+-                           commands, num_commands,
+-                           &mb,
+-                           &storage_ix, storage);
+-      if (BROTLI_IS_OOM(m)) goto oom;
+-      if (metablock_size + 4 < (storage_ix >> 3)) {
+-        /* Restore the distance cache and last byte. */
+-        memcpy(dist_cache, saved_dist_cache, 4 * sizeof(dist_cache[0]));
+-        storage[0] = (uint8_t)last_bytes;
+-        storage[1] = (uint8_t)(last_bytes >> 8);
+-        storage_ix = last_bytes_bits;
+-        BrotliStoreUncompressedMetaBlock(is_last, input_buffer,
+-                                         metablock_start, mask,
+-                                         metablock_size, &storage_ix, storage);
+-      }
+-      DestroyMetaBlockSplit(m, &mb);
+-    }
+-    last_bytes = (uint16_t)(storage[storage_ix >> 3]);
+-    last_bytes_bits = storage_ix & 7u;
+-    metablock_start += metablock_size;
+-    if (metablock_start < input_size) {
+-      prev_byte = input_buffer[metablock_start - 1];
+-      prev_byte2 = input_buffer[metablock_start - 2];
+-    }
+-    /* Save the state of the distance cache in case we need to restore it for
+-       emitting an uncompressed block. */
+-    memcpy(saved_dist_cache, dist_cache, 4 * sizeof(dist_cache[0]));
+-
+-    {
+-      const size_t out_size = storage_ix >> 3;
+-      total_out_size += out_size;
+-      if (total_out_size <= max_out_size) {
+-        memcpy(encoded_buffer, storage, out_size);
+-        encoded_buffer += out_size;
+-      } else {
+-        ok = BROTLI_FALSE;
+-      }
+-    }
+-    BROTLI_FREE(m, storage);
+-    BROTLI_FREE(m, commands);
+-  }
+-
+-  *encoded_size = total_out_size;
+-  DestroyHasher(m, &hasher);
+-  return ok;
+-
+-oom:
+-  BrotliWipeOutMemoryManager(m);
+-  return BROTLI_FALSE;
+-}
+-
+-size_t BrotliEncoderMaxCompressedSize(size_t input_size) {
+-  /* [window bits / empty metadata] + N * [uncompressed] + [last empty] */
+-  size_t num_large_blocks = input_size >> 14;
+-  size_t overhead = 2 + (4 * num_large_blocks) + 3 + 1;
+-  size_t result = input_size + overhead;
+-  if (input_size == 0) return 2;
+-  return (result < input_size) ? 0 : result;
+-}
+-
+-/* Wraps data to uncompressed brotli stream with minimal window size.
+-   |output| should point at region with at least BrotliEncoderMaxCompressedSize
+-   addressable bytes.
+-   Returns the length of stream. */
+-static size_t MakeUncompressedStream(
+-    const uint8_t* input, size_t input_size, uint8_t* output) {
+-  size_t size = input_size;
+-  size_t result = 0;
+-  size_t offset = 0;
+-  if (input_size == 0) {
+-    output[0] = 6;
+-    return 1;
+-  }
+-  output[result++] = 0x21;  /* window bits = 10, is_last = false */
+-  output[result++] = 0x03;  /* empty metadata, padding */
+-  while (size > 0) {
+-    uint32_t nibbles = 0;
+-    uint32_t chunk_size;
+-    uint32_t bits;
+-    chunk_size = (size > (1u << 24)) ? (1u << 24) : (uint32_t)size;
+-    if (chunk_size > (1u << 16)) nibbles = (chunk_size > (1u << 20)) ? 2 : 1;
+-    bits =
+-        (nibbles << 1) | ((chunk_size - 1) << 3) | (1u << (19 + 4 * nibbles));
+-    output[result++] = (uint8_t)bits;
+-    output[result++] = (uint8_t)(bits >> 8);
+-    output[result++] = (uint8_t)(bits >> 16);
+-    if (nibbles == 2) output[result++] = (uint8_t)(bits >> 24);
+-    memcpy(&output[result], &input[offset], chunk_size);
+-    result += chunk_size;
+-    offset += chunk_size;
+-    size -= chunk_size;
+-  }
+-  output[result++] = 3;
+-  return result;
+-}
+-
+-BROTLI_BOOL BrotliEncoderCompress(
+-    int quality, int lgwin, BrotliEncoderMode mode, size_t input_size,
+-    const uint8_t* input_buffer, size_t* encoded_size,
+-    uint8_t* encoded_buffer) {
+-  BrotliEncoderState* s;
+-  size_t out_size = *encoded_size;
+-  const uint8_t* input_start = input_buffer;
+-  uint8_t* output_start = encoded_buffer;
+-  size_t max_out_size = BrotliEncoderMaxCompressedSize(input_size);
+-  if (out_size == 0) {
+-    /* Output buffer needs at least one byte. */
+-    return BROTLI_FALSE;
+-  }
+-  if (input_size == 0) {
+-    /* Handle the special case of empty input. */
+-    *encoded_size = 1;
+-    *encoded_buffer = 6;
+-    return BROTLI_TRUE;
+-  }
+-  if (quality == 10) {
+-    /* TODO: Implement this direct path for all quality levels. */
+-    const int lg_win = BROTLI_MIN(int, BROTLI_LARGE_MAX_WINDOW_BITS,
+-                                       BROTLI_MAX(int, 16, lgwin));
+-    int ok = BrotliCompressBufferQuality10(lg_win, input_size, input_buffer,
+-                                           encoded_size, encoded_buffer);
+-    if (!ok || (max_out_size && *encoded_size > max_out_size)) {
+-      goto fallback;
+-    }
+-    return BROTLI_TRUE;
+-  }
+-
+-  s = BrotliEncoderCreateInstance(0, 0, 0);
+-  if (!s) {
+-    return BROTLI_FALSE;
+-  } else {
+-    size_t available_in = input_size;
+-    const uint8_t* next_in = input_buffer;
+-    size_t available_out = *encoded_size;
+-    uint8_t* next_out = encoded_buffer;
+-    size_t total_out = 0;
+-    BROTLI_BOOL result = BROTLI_FALSE;
+-    BrotliEncoderSetParameter(s, BROTLI_PARAM_QUALITY, (uint32_t)quality);
+-    BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, (uint32_t)lgwin);
+-    BrotliEncoderSetParameter(s, BROTLI_PARAM_MODE, (uint32_t)mode);
+-    BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, (uint32_t)input_size);
+-    if (lgwin > BROTLI_MAX_WINDOW_BITS) {
+-      BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, BROTLI_TRUE);
+-    }
+-    result = BrotliEncoderCompressStream(s, BROTLI_OPERATION_FINISH,
+-        &available_in, &next_in, &available_out, &next_out, &total_out);
+-    if (!BrotliEncoderIsFinished(s)) result = 0;
+-    *encoded_size = total_out;
+-    BrotliEncoderDestroyInstance(s);
+-    if (!result || (max_out_size && *encoded_size > max_out_size)) {
+-      goto fallback;
+-    }
+-    return BROTLI_TRUE;
+-  }
+-fallback:
+-  *encoded_size = 0;
+-  if (!max_out_size) return BROTLI_FALSE;
+-  if (out_size >= max_out_size) {
+-    *encoded_size =
+-        MakeUncompressedStream(input_start, input_size, output_start);
+-    return BROTLI_TRUE;
+-  }
+-  return BROTLI_FALSE;
+-}
+-
+-static void InjectBytePaddingBlock(BrotliEncoderState* s) {
+-  uint32_t seal = s->last_bytes_;
+-  size_t seal_bits = s->last_bytes_bits_;
+-  uint8_t* destination;
+-  s->last_bytes_ = 0;
+-  s->last_bytes_bits_ = 0;
+-  /* is_last = 0, data_nibbles = 11, reserved = 0, meta_nibbles = 00 */
+-  seal |= 0x6u << seal_bits;
+-  seal_bits += 6;
+-  /* If we have already created storage, then append to it.
+-     Storage is valid until next block is being compressed. */
+-  if (s->next_out_) {
+-    destination = s->next_out_ + s->available_out_;
+-  } else {
+-    destination = s->tiny_buf_.u8;
+-    s->next_out_ = destination;
+-  }
+-  destination[0] = (uint8_t)seal;
+-  if (seal_bits > 8) destination[1] = (uint8_t)(seal >> 8);
+-  if (seal_bits > 16) destination[2] = (uint8_t)(seal >> 16);
+-  s->available_out_ += (seal_bits + 7) >> 3;
+-}
+-
+-/* Injects padding bits or pushes compressed data to output.
+-   Returns false if nothing is done. */
+-static BROTLI_BOOL InjectFlushOrPushOutput(BrotliEncoderState* s,
+-    size_t* available_out, uint8_t** next_out, size_t* total_out) {
+-  if (s->stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED &&
+-      s->last_bytes_bits_ != 0) {
+-    InjectBytePaddingBlock(s);
+-    return BROTLI_TRUE;
+-  }
+-
+-  if (s->available_out_ != 0 && *available_out != 0) {
+-    size_t copy_output_size =
+-        BROTLI_MIN(size_t, s->available_out_, *available_out);
+-    memcpy(*next_out, s->next_out_, copy_output_size);
+-    *next_out += copy_output_size;
+-    *available_out -= copy_output_size;
+-    s->next_out_ += copy_output_size;
+-    s->available_out_ -= copy_output_size;
+-    s->total_out_ += copy_output_size;
+-    if (total_out) *total_out = s->total_out_;
+-    return BROTLI_TRUE;
+-  }
+-
+-  return BROTLI_FALSE;
+-}
+-
+-static void CheckFlushComplete(BrotliEncoderState* s) {
+-  if (s->stream_state_ == BROTLI_STREAM_FLUSH_REQUESTED &&
+-      s->available_out_ == 0) {
+-    s->stream_state_ = BROTLI_STREAM_PROCESSING;
+-    s->next_out_ = 0;
+-  }
+-}
+-
+-static BROTLI_BOOL BrotliEncoderCompressStreamFast(
+-    BrotliEncoderState* s, BrotliEncoderOperation op, size_t* available_in,
+-    const uint8_t** next_in, size_t* available_out, uint8_t** next_out,
+-    size_t* total_out) {
+-  const size_t block_size_limit = (size_t)1 << s->params.lgwin;
+-  const size_t buf_size = BROTLI_MIN(size_t, kCompressFragmentTwoPassBlockSize,
+-      BROTLI_MIN(size_t, *available_in, block_size_limit));
+-  uint32_t* tmp_command_buf = NULL;
+-  uint32_t* command_buf = NULL;
+-  uint8_t* tmp_literal_buf = NULL;
+-  uint8_t* literal_buf = NULL;
+-  MemoryManager* m = &s->memory_manager_;
+-  if (s->params.quality != FAST_ONE_PASS_COMPRESSION_QUALITY &&
+-      s->params.quality != FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-    return BROTLI_FALSE;
+-  }
+-  if (s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-    if (!s->command_buf_ && buf_size == kCompressFragmentTwoPassBlockSize) {
+-      s->command_buf_ =
+-          BROTLI_ALLOC(m, uint32_t, kCompressFragmentTwoPassBlockSize);
+-      s->literal_buf_ =
+-          BROTLI_ALLOC(m, uint8_t, kCompressFragmentTwoPassBlockSize);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(s->command_buf_) ||
+-          BROTLI_IS_NULL(s->literal_buf_)) {
+-        return BROTLI_FALSE;
+-      }
+-    }
+-    if (s->command_buf_) {
+-      command_buf = s->command_buf_;
+-      literal_buf = s->literal_buf_;
+-    } else {
+-      tmp_command_buf = BROTLI_ALLOC(m, uint32_t, buf_size);
+-      tmp_literal_buf = BROTLI_ALLOC(m, uint8_t, buf_size);
+-      if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(tmp_command_buf) ||
+-          BROTLI_IS_NULL(tmp_literal_buf)) {
+-        return BROTLI_FALSE;
+-      }
+-      command_buf = tmp_command_buf;
+-      literal_buf = tmp_literal_buf;
+-    }
+-  }
+-
+-  while (BROTLI_TRUE) {
+-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
+-      continue;
+-    }
+-
+-    /* Compress block only when internal output buffer is empty, stream is not
+-       finished, there is no pending flush request, and there is either
+-       additional input or pending operation. */
+-    if (s->available_out_ == 0 &&
+-        s->stream_state_ == BROTLI_STREAM_PROCESSING &&
+-        (*available_in != 0 || op != BROTLI_OPERATION_PROCESS)) {
+-      size_t block_size = BROTLI_MIN(size_t, block_size_limit, *available_in);
+-      BROTLI_BOOL is_last =
+-          (*available_in == block_size) && (op == BROTLI_OPERATION_FINISH);
+-      BROTLI_BOOL force_flush =
+-          (*available_in == block_size) && (op == BROTLI_OPERATION_FLUSH);
+-      size_t max_out_size = 2 * block_size + 503;
+-      BROTLI_BOOL inplace = BROTLI_TRUE;
+-      uint8_t* storage = NULL;
+-      size_t storage_ix = s->last_bytes_bits_;
+-      size_t table_size;
+-      int* table;
+-
+-      if (force_flush && block_size == 0) {
+-        s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
+-        continue;
+-      }
+-      if (max_out_size <= *available_out) {
+-        storage = *next_out;
+-      } else {
+-        inplace = BROTLI_FALSE;
+-        storage = GetBrotliStorage(s, max_out_size);
+-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-      }
+-      storage[0] = (uint8_t)s->last_bytes_;
+-      storage[1] = (uint8_t)(s->last_bytes_ >> 8);
+-      table = GetHashTable(s, s->params.quality, block_size, &table_size);
+-      if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-
+-      if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY) {
+-        BrotliCompressFragmentFast(m, *next_in, block_size, is_last, table,
+-            table_size, s->cmd_depths_, s->cmd_bits_, &s->cmd_code_numbits_,
+-            s->cmd_code_, &storage_ix, storage);
+-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-      } else {
+-        BrotliCompressFragmentTwoPass(m, *next_in, block_size, is_last,
+-            command_buf, literal_buf, table, table_size,
+-            &storage_ix, storage);
+-        if (BROTLI_IS_OOM(m)) return BROTLI_FALSE;
+-      }
+-      if (block_size != 0) {
+-        *next_in += block_size;
+-        *available_in -= block_size;
+-      }
+-      if (inplace) {
+-        size_t out_bytes = storage_ix >> 3;
+-        BROTLI_DCHECK(out_bytes <= *available_out);
+-        BROTLI_DCHECK((storage_ix & 7) == 0 || out_bytes < *available_out);
+-        *next_out += out_bytes;
+-        *available_out -= out_bytes;
+-        s->total_out_ += out_bytes;
+-        if (total_out) *total_out = s->total_out_;
+-      } else {
+-        size_t out_bytes = storage_ix >> 3;
+-        s->next_out_ = storage;
+-        s->available_out_ = out_bytes;
+-      }
+-      s->last_bytes_ = (uint16_t)(storage[storage_ix >> 3]);
+-      s->last_bytes_bits_ = storage_ix & 7u;
+-
+-      if (force_flush) s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
+-      if (is_last) s->stream_state_ = BROTLI_STREAM_FINISHED;
+-      continue;
+-    }
+-    break;
+-  }
+-  BROTLI_FREE(m, tmp_command_buf);
+-  BROTLI_FREE(m, tmp_literal_buf);
+-  CheckFlushComplete(s);
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL ProcessMetadata(
+-    BrotliEncoderState* s, size_t* available_in, const uint8_t** next_in,
+-    size_t* available_out, uint8_t** next_out, size_t* total_out) {
+-  if (*available_in > (1u << 24)) return BROTLI_FALSE;
+-  /* Switch to metadata block workflow, if required. */
+-  if (s->stream_state_ == BROTLI_STREAM_PROCESSING) {
+-    s->remaining_metadata_bytes_ = (uint32_t)*available_in;
+-    s->stream_state_ = BROTLI_STREAM_METADATA_HEAD;
+-  }
+-  if (s->stream_state_ != BROTLI_STREAM_METADATA_HEAD &&
+-      s->stream_state_ != BROTLI_STREAM_METADATA_BODY) {
+-    return BROTLI_FALSE;
+-  }
+-
+-  while (BROTLI_TRUE) {
+-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
+-      continue;
+-    }
+-    if (s->available_out_ != 0) break;
+-
+-    if (s->input_pos_ != s->last_flush_pos_) {
+-      BROTLI_BOOL result = EncodeData(s, BROTLI_FALSE, BROTLI_TRUE,
+-          &s->available_out_, &s->next_out_);
+-      if (!result) return BROTLI_FALSE;
+-      continue;
+-    }
+-
+-    if (s->stream_state_ == BROTLI_STREAM_METADATA_HEAD) {
+-      s->next_out_ = s->tiny_buf_.u8;
+-      s->available_out_ =
+-          WriteMetadataHeader(s, s->remaining_metadata_bytes_, s->next_out_);
+-      s->stream_state_ = BROTLI_STREAM_METADATA_BODY;
+-      continue;
+-    } else {
+-      /* Exit workflow only when there is no more input and no more output.
+-         Otherwise client may continue producing empty metadata blocks. */
+-      if (s->remaining_metadata_bytes_ == 0) {
+-        s->remaining_metadata_bytes_ = BROTLI_UINT32_MAX;
+-        s->stream_state_ = BROTLI_STREAM_PROCESSING;
+-        break;
+-      }
+-      if (*available_out) {
+-        /* Directly copy input to output. */
+-        uint32_t copy = (uint32_t)BROTLI_MIN(
+-            size_t, s->remaining_metadata_bytes_, *available_out);
+-        memcpy(*next_out, *next_in, copy);
+-        *next_in += copy;
+-        *available_in -= copy;
+-        s->remaining_metadata_bytes_ -= copy;
+-        *next_out += copy;
+-        *available_out -= copy;
+-      } else {
+-        /* This guarantees progress in "TakeOutput" workflow. */
+-        uint32_t copy = BROTLI_MIN(uint32_t, s->remaining_metadata_bytes_, 16);
+-        s->next_out_ = s->tiny_buf_.u8;
+-        memcpy(s->next_out_, *next_in, copy);
+-        *next_in += copy;
+-        *available_in -= copy;
+-        s->remaining_metadata_bytes_ -= copy;
+-        s->available_out_ = copy;
+-      }
+-      continue;
+-    }
+-  }
+-
+-  return BROTLI_TRUE;
+-}
+-
+-static void UpdateSizeHint(BrotliEncoderState* s, size_t available_in) {
+-  if (s->params.size_hint == 0) {
+-    uint64_t delta = UnprocessedInputSize(s);
+-    uint64_t tail = available_in;
+-    uint32_t limit = 1u << 30;
+-    uint32_t total;
+-    if ((delta >= limit) || (tail >= limit) || ((delta + tail) >= limit)) {
+-      total = limit;
+-    } else {
+-      total = (uint32_t)(delta + tail);
+-    }
+-    s->params.size_hint = total;
+-  }
+-}
+-
+-BROTLI_BOOL BrotliEncoderCompressStream(
+-    BrotliEncoderState* s, BrotliEncoderOperation op, size_t* available_in,
+-    const uint8_t** next_in, size_t* available_out,uint8_t** next_out,
+-    size_t* total_out) {
+-  if (!EnsureInitialized(s)) return BROTLI_FALSE;
+-
+-  /* Unfinished metadata block; check requirements. */
+-  if (s->remaining_metadata_bytes_ != BROTLI_UINT32_MAX) {
+-    if (*available_in != s->remaining_metadata_bytes_) return BROTLI_FALSE;
+-    if (op != BROTLI_OPERATION_EMIT_METADATA) return BROTLI_FALSE;
+-  }
+-
+-  if (op == BROTLI_OPERATION_EMIT_METADATA) {
+-    UpdateSizeHint(s, 0);  /* First data metablock might be emitted here. */
+-    return ProcessMetadata(
+-        s, available_in, next_in, available_out, next_out, total_out);
+-  }
+-
+-  if (s->stream_state_ == BROTLI_STREAM_METADATA_HEAD ||
+-      s->stream_state_ == BROTLI_STREAM_METADATA_BODY) {
+-    return BROTLI_FALSE;
+-  }
+-
+-  if (s->stream_state_ != BROTLI_STREAM_PROCESSING && *available_in != 0) {
+-    return BROTLI_FALSE;
+-  }
+-  if (s->params.quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
+-      s->params.quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-    return BrotliEncoderCompressStreamFast(s, op, available_in, next_in,
+-        available_out, next_out, total_out);
+-  }
+-  while (BROTLI_TRUE) {
+-    size_t remaining_block_size = RemainingInputBlockSize(s);
+-    /* Shorten input to flint size. */
+-    if (s->flint_ >= 0 && remaining_block_size > (size_t)s->flint_) {
+-      remaining_block_size = (size_t)s->flint_;
+-    }
+-
+-    if (remaining_block_size != 0 && *available_in != 0) {
+-      size_t copy_input_size =
+-          BROTLI_MIN(size_t, remaining_block_size, *available_in);
+-      CopyInputToRingBuffer(s, copy_input_size, *next_in);
+-      *next_in += copy_input_size;
+-      *available_in -= copy_input_size;
+-      if (s->flint_ > 0) s->flint_ = (int8_t)(s->flint_ - (int)copy_input_size);
+-      continue;
+-    }
+-
+-    if (InjectFlushOrPushOutput(s, available_out, next_out, total_out)) {
+-      /* Exit the "emit flint" workflow. */
+-      if (s->flint_ == BROTLI_FLINT_WAITING_FOR_FLUSHING) {
+-        CheckFlushComplete(s);
+-        if (s->stream_state_ == BROTLI_STREAM_PROCESSING) {
+-          s->flint_ = BROTLI_FLINT_DONE;
+-        }
+-      }
+-      continue;
+-    }
+-
+-    /* Compress data only when internal output buffer is empty, stream is not
+-       finished and there is no pending flush request. */
+-    if (s->available_out_ == 0 &&
+-        s->stream_state_ == BROTLI_STREAM_PROCESSING) {
+-      if (remaining_block_size == 0 || op != BROTLI_OPERATION_PROCESS) {
+-        BROTLI_BOOL is_last = TO_BROTLI_BOOL(
+-            (*available_in == 0) && op == BROTLI_OPERATION_FINISH);
+-        BROTLI_BOOL force_flush = TO_BROTLI_BOOL(
+-            (*available_in == 0) && op == BROTLI_OPERATION_FLUSH);
+-        BROTLI_BOOL result;
+-        /* Force emitting (uncompressed) piece containing flint. */
+-        if (!is_last && s->flint_ == 0) {
+-          s->flint_ = BROTLI_FLINT_WAITING_FOR_FLUSHING;
+-          force_flush = BROTLI_TRUE;
+-        }
+-        UpdateSizeHint(s, *available_in);
+-        result = EncodeData(s, is_last, force_flush,
+-            &s->available_out_, &s->next_out_);
+-        if (!result) return BROTLI_FALSE;
+-        if (force_flush) s->stream_state_ = BROTLI_STREAM_FLUSH_REQUESTED;
+-        if (is_last) s->stream_state_ = BROTLI_STREAM_FINISHED;
+-        continue;
+-      }
+-    }
+-    break;
+-  }
+-  CheckFlushComplete(s);
+-  return BROTLI_TRUE;
+-}
+-
+-BROTLI_BOOL BrotliEncoderIsFinished(BrotliEncoderState* s) {
+-  return TO_BROTLI_BOOL(s->stream_state_ == BROTLI_STREAM_FINISHED &&
+-      !BrotliEncoderHasMoreOutput(s));
+-}
+-
+-BROTLI_BOOL BrotliEncoderHasMoreOutput(BrotliEncoderState* s) {
+-  return TO_BROTLI_BOOL(s->available_out_ != 0);
+-}
+-
+-const uint8_t* BrotliEncoderTakeOutput(BrotliEncoderState* s, size_t* size) {
+-  size_t consumed_size = s->available_out_;
+-  uint8_t* result = s->next_out_;
+-  if (*size) {
+-    consumed_size = BROTLI_MIN(size_t, *size, s->available_out_);
+-  }
+-  if (consumed_size) {
+-    s->next_out_ += consumed_size;
+-    s->available_out_ -= consumed_size;
+-    s->total_out_ += consumed_size;
+-    CheckFlushComplete(s);
+-    *size = consumed_size;
+-  } else {
+-    *size = 0;
+-    result = 0;
+-  }
+-  return result;
+-}
+-
+-uint32_t BrotliEncoderVersion(void) {
+-  return BROTLI_VERSION;
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/encoder_dict.c b/modules/brotli/enc/encoder_dict.c
+deleted file mode 100644
+--- a/modules/brotli/enc/encoder_dict.c
++++ /dev/null
+@@ -1,33 +0,0 @@
+-/* Copyright 2017 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-#include "./encoder_dict.h"
+-
+-#include "../common/dictionary.h"
+-#include "../common/transform.h"
+-#include "./dictionary_hash.h"
+-#include "./hash.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-void BrotliInitEncoderDictionary(BrotliEncoderDictionary* dict) {
+-  dict->words = BrotliGetDictionary();
+-  dict->num_transforms = (uint32_t)BrotliGetTransforms()->num_transforms;
+-
+-  dict->hash_table_words = kStaticDictionaryHashWords;
+-  dict->hash_table_lengths = kStaticDictionaryHashLengths;
+-  dict->buckets = kStaticDictionaryBuckets;
+-  dict->dict_words = kStaticDictionaryWords;
+-
+-  dict->cutoffTransformsCount = kCutoffTransformsCount;
+-  dict->cutoffTransforms = kCutoffTransforms;
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/encoder_dict.h b/modules/brotli/enc/encoder_dict.h
+deleted file mode 100644
+--- a/modules/brotli/enc/encoder_dict.h
++++ /dev/null
+@@ -1,43 +0,0 @@
+-/* Copyright 2017 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-#ifndef BROTLI_ENC_ENCODER_DICT_H_
+-#define BROTLI_ENC_ENCODER_DICT_H_
+-
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./static_dict_lut.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* Dictionary data (words and transforms) for 1 possible context */
+-typedef struct BrotliEncoderDictionary {
+-  const BrotliDictionary* words;
+-  uint32_t num_transforms;
+-
+-  /* cut off for fast encoder */
+-  uint32_t cutoffTransformsCount;
+-  uint64_t cutoffTransforms;
+-
+-  /* from dictionary_hash.h, for fast encoder */
+-  const uint16_t* hash_table_words;
+-  const uint8_t* hash_table_lengths;
+-
+-  /* from static_dict_lut.h, for slow encoder */
+-  const uint16_t* buckets;
+-  const DictWord* dict_words;
+-} BrotliEncoderDictionary;
+-
+-BROTLI_INTERNAL void BrotliInitEncoderDictionary(BrotliEncoderDictionary* dict);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_ENCODER_DICT_H_ */
+diff --git a/modules/brotli/enc/entropy_encode.c b/modules/brotli/enc/entropy_encode.c
+deleted file mode 100644
+--- a/modules/brotli/enc/entropy_encode.c
++++ /dev/null
+@@ -1,503 +0,0 @@
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Entropy encoding (Huffman) utilities. */
+-
+-#include "./entropy_encode.h"
+-
+-#include <string.h>  /* memset */
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-const size_t kBrotliShellGaps[] = {132, 57, 23, 10, 4, 1};
+-
+-BROTLI_BOOL BrotliSetDepth(
+-    int p0, HuffmanTree* pool, uint8_t* depth, int max_depth) {
+-  int stack[16];
+-  int level = 0;
+-  int p = p0;
+-  BROTLI_DCHECK(max_depth <= 15);
+-  stack[0] = -1;
+-  while (BROTLI_TRUE) {
+-    if (pool[p].index_left_ >= 0) {
+-      level++;
+-      if (level > max_depth) return BROTLI_FALSE;
+-      stack[level] = pool[p].index_right_or_value_;
+-      p = pool[p].index_left_;
+-      continue;
+-    } else {
+-      depth[pool[p].index_right_or_value_] = (uint8_t)level;
+-    }
+-    while (level >= 0 && stack[level] == -1) level--;
+-    if (level < 0) return BROTLI_TRUE;
+-    p = stack[level];
+-    stack[level] = -1;
+-  }
+-}
+-
+-/* Sort the root nodes, least popular first. */
+-static BROTLI_INLINE BROTLI_BOOL SortHuffmanTree(
+-    const HuffmanTree* v0, const HuffmanTree* v1) {
+-  if (v0->total_count_ != v1->total_count_) {
+-    return TO_BROTLI_BOOL(v0->total_count_ < v1->total_count_);
+-  }
+-  return TO_BROTLI_BOOL(v0->index_right_or_value_ > v1->index_right_or_value_);
+-}
+-
+-/* This function will create a Huffman tree.
+-
+-   The catch here is that the tree cannot be arbitrarily deep.
+-   Brotli specifies a maximum depth of 15 bits for "code trees"
+-   and 7 bits for "code length code trees."
+-
+-   count_limit is the value that is to be faked as the minimum value
+-   and this minimum value is raised until the tree matches the
+-   maximum length requirement.
+-
+-   This algorithm is not of excellent performance for very long data blocks,
+-   especially when population counts are longer than 2**tree_limit, but
+-   we are not planning to use this with extremely long blocks.
+-
+-   See http://en.wikipedia.org/wiki/Huffman_coding */
+-void BrotliCreateHuffmanTree(const uint32_t* data,
+-                             const size_t length,
+-                             const int tree_limit,
+-                             HuffmanTree* tree,
+-                             uint8_t* depth) {
+-  uint32_t count_limit;
+-  HuffmanTree sentinel;
+-  InitHuffmanTree(&sentinel, BROTLI_UINT32_MAX, -1, -1);
+-  /* For block sizes below 64 kB, we never need to do a second iteration
+-     of this loop. Probably all of our block sizes will be smaller than
+-     that, so this loop is mostly of academic interest. If we actually
+-     would need this, we would be better off with the Katajainen algorithm. */
+-  for (count_limit = 1; ; count_limit *= 2) {
+-    size_t n = 0;
+-    size_t i;
+-    size_t j;
+-    size_t k;
+-    for (i = length; i != 0;) {
+-      --i;
+-      if (data[i]) {
+-        const uint32_t count = BROTLI_MAX(uint32_t, data[i], count_limit);
+-        InitHuffmanTree(&tree[n++], count, -1, (int16_t)i);
+-      }
+-    }
+-
+-    if (n == 1) {
+-      depth[tree[0].index_right_or_value_] = 1;  /* Only one element. */
+-      break;
+-    }
+-
+-    SortHuffmanTreeItems(tree, n, SortHuffmanTree);
+-
+-    /* The nodes are:
+-       [0, n): the sorted leaf nodes that we start with.
+-       [n]: we add a sentinel here.
+-       [n + 1, 2n): new parent nodes are added here, starting from
+-                    (n+1). These are naturally in ascending order.
+-       [2n]: we add a sentinel at the end as well.
+-       There will be (2n+1) elements at the end. */
+-    tree[n] = sentinel;
+-    tree[n + 1] = sentinel;
+-
+-    i = 0;      /* Points to the next leaf node. */
+-    j = n + 1;  /* Points to the next non-leaf node. */
+-    for (k = n - 1; k != 0; --k) {
+-      size_t left, right;
+-      if (tree[i].total_count_ <= tree[j].total_count_) {
+-        left = i;
+-        ++i;
+-      } else {
+-        left = j;
+-        ++j;
+-      }
+-      if (tree[i].total_count_ <= tree[j].total_count_) {
+-        right = i;
+-        ++i;
+-      } else {
+-        right = j;
+-        ++j;
+-      }
+-
+-      {
+-        /* The sentinel node becomes the parent node. */
+-        size_t j_end = 2 * n - k;
+-        tree[j_end].total_count_ =
+-            tree[left].total_count_ + tree[right].total_count_;
+-        tree[j_end].index_left_ = (int16_t)left;
+-        tree[j_end].index_right_or_value_ = (int16_t)right;
+-
+-        /* Add back the last sentinel node. */
+-        tree[j_end + 1] = sentinel;
+-      }
+-    }
+-    if (BrotliSetDepth((int)(2 * n - 1), &tree[0], depth, tree_limit)) {
+-      /* We need to pack the Huffman tree in tree_limit bits. If this was not
+-         successful, add fake entities to the lowest values and retry. */
+-      break;
+-    }
+-  }
+-}
+-
+-static void Reverse(uint8_t* v, size_t start, size_t end) {
+-  --end;
+-  while (start < end) {
+-    uint8_t tmp = v[start];
+-    v[start] = v[end];
+-    v[end] = tmp;
+-    ++start;
+-    --end;
+-  }
+-}
+-
+-static void BrotliWriteHuffmanTreeRepetitions(
+-    const uint8_t previous_value,
+-    const uint8_t value,
+-    size_t repetitions,
+-    size_t* tree_size,
+-    uint8_t* tree,
+-    uint8_t* extra_bits_data) {
+-  BROTLI_DCHECK(repetitions > 0);
+-  if (previous_value != value) {
+-    tree[*tree_size] = value;
+-    extra_bits_data[*tree_size] = 0;
+-    ++(*tree_size);
+-    --repetitions;
+-  }
+-  if (repetitions == 7) {
+-    tree[*tree_size] = value;
+-    extra_bits_data[*tree_size] = 0;
+-    ++(*tree_size);
+-    --repetitions;
+-  }
+-  if (repetitions < 3) {
+-    size_t i;
+-    for (i = 0; i < repetitions; ++i) {
+-      tree[*tree_size] = value;
+-      extra_bits_data[*tree_size] = 0;
+-      ++(*tree_size);
+-    }
+-  } else {
+-    size_t start = *tree_size;
+-    repetitions -= 3;
+-    while (BROTLI_TRUE) {
+-      tree[*tree_size] = BROTLI_REPEAT_PREVIOUS_CODE_LENGTH;
+-      extra_bits_data[*tree_size] = repetitions & 0x3;
+-      ++(*tree_size);
+-      repetitions >>= 2;
+-      if (repetitions == 0) {
+-        break;
+-      }
+-      --repetitions;
+-    }
+-    Reverse(tree, start, *tree_size);
+-    Reverse(extra_bits_data, start, *tree_size);
+-  }
+-}
+-
+-static void BrotliWriteHuffmanTreeRepetitionsZeros(
+-    size_t repetitions,
+-    size_t* tree_size,
+-    uint8_t* tree,
+-    uint8_t* extra_bits_data) {
+-  if (repetitions == 11) {
+-    tree[*tree_size] = 0;
+-    extra_bits_data[*tree_size] = 0;
+-    ++(*tree_size);
+-    --repetitions;
+-  }
+-  if (repetitions < 3) {
+-    size_t i;
+-    for (i = 0; i < repetitions; ++i) {
+-      tree[*tree_size] = 0;
+-      extra_bits_data[*tree_size] = 0;
+-      ++(*tree_size);
+-    }
+-  } else {
+-    size_t start = *tree_size;
+-    repetitions -= 3;
+-    while (BROTLI_TRUE) {
+-      tree[*tree_size] = BROTLI_REPEAT_ZERO_CODE_LENGTH;
+-      extra_bits_data[*tree_size] = repetitions & 0x7;
+-      ++(*tree_size);
+-      repetitions >>= 3;
+-      if (repetitions == 0) {
+-        break;
+-      }
+-      --repetitions;
+-    }
+-    Reverse(tree, start, *tree_size);
+-    Reverse(extra_bits_data, start, *tree_size);
+-  }
+-}
+-
+-void BrotliOptimizeHuffmanCountsForRle(size_t length, uint32_t* counts,
+-                                       uint8_t* good_for_rle) {
+-  size_t nonzero_count = 0;
+-  size_t stride;
+-  size_t limit;
+-  size_t sum;
+-  const size_t streak_limit = 1240;
+-  /* Let's make the Huffman code more compatible with RLE encoding. */
+-  size_t i;
+-  for (i = 0; i < length; i++) {
+-    if (counts[i]) {
+-      ++nonzero_count;
+-    }
+-  }
+-  if (nonzero_count < 16) {
+-    return;
+-  }
+-  while (length != 0 && counts[length - 1] == 0) {
+-    --length;
+-  }
+-  if (length == 0) {
+-    return;  /* All zeros. */
+-  }
+-  /* Now counts[0..length - 1] does not have trailing zeros. */
+-  {
+-    size_t nonzeros = 0;
+-    uint32_t smallest_nonzero = 1 << 30;
+-    for (i = 0; i < length; ++i) {
+-      if (counts[i] != 0) {
+-        ++nonzeros;
+-        if (smallest_nonzero > counts[i]) {
+-          smallest_nonzero = counts[i];
+-        }
+-      }
+-    }
+-    if (nonzeros < 5) {
+-      /* Small histogram will model it well. */
+-      return;
+-    }
+-    if (smallest_nonzero < 4) {
+-      size_t zeros = length - nonzeros;
+-      if (zeros < 6) {
+-        for (i = 1; i < length - 1; ++i) {
+-          if (counts[i - 1] != 0 && counts[i] == 0 && counts[i + 1] != 0) {
+-            counts[i] = 1;
+-          }
+-        }
+-      }
+-    }
+-    if (nonzeros < 28) {
+-      return;
+-    }
+-  }
+-  /* 2) Let's mark all population counts that already can be encoded
+-     with an RLE code. */
+-  memset(good_for_rle, 0, length);
+-  {
+-    /* Let's not spoil any of the existing good RLE codes.
+-       Mark any seq of 0's that is longer as 5 as a good_for_rle.
+-       Mark any seq of non-0's that is longer as 7 as a good_for_rle. */
+-    uint32_t symbol = counts[0];
+-    size_t step = 0;
+-    for (i = 0; i <= length; ++i) {
+-      if (i == length || counts[i] != symbol) {
+-        if ((symbol == 0 && step >= 5) ||
+-            (symbol != 0 && step >= 7)) {
+-          size_t k;
+-          for (k = 0; k < step; ++k) {
+-            good_for_rle[i - k - 1] = 1;
+-          }
+-        }
+-        step = 1;
+-        if (i != length) {
+-          symbol = counts[i];
+-        }
+-      } else {
+-        ++step;
+-      }
+-    }
+-  }
+-  /* 3) Let's replace those population counts that lead to more RLE codes.
+-     Math here is in 24.8 fixed point representation. */
+-  stride = 0;
+-  limit = 256 * (counts[0] + counts[1] + counts[2]) / 3 + 420;
+-  sum = 0;
+-  for (i = 0; i <= length; ++i) {
+-    if (i == length || good_for_rle[i] ||
+-        (i != 0 && good_for_rle[i - 1]) ||
+-        (256 * counts[i] - limit + streak_limit) >= 2 * streak_limit) {
+-      if (stride >= 4 || (stride >= 3 && sum == 0)) {
+-        size_t k;
+-        /* The stride must end, collapse what we have, if we have enough (4). */
+-        size_t count = (sum + stride / 2) / stride;
+-        if (count == 0) {
+-          count = 1;
+-        }
+-        if (sum == 0) {
+-          /* Don't make an all zeros stride to be upgraded to ones. */
+-          count = 0;
+-        }
+-        for (k = 0; k < stride; ++k) {
+-          /* We don't want to change value at counts[i],
+-             that is already belonging to the next stride. Thus - 1. */
+-          counts[i - k - 1] = (uint32_t)count;
+-        }
+-      }
+-      stride = 0;
+-      sum = 0;
+-      if (i < length - 2) {
+-        /* All interesting strides have a count of at least 4, */
+-        /* at least when non-zeros. */
+-        limit = 256 * (counts[i] + counts[i + 1] + counts[i + 2]) / 3 + 420;
+-      } else if (i < length) {
+-        limit = 256 * counts[i];
+-      } else {
+-        limit = 0;
+-      }
+-    }
+-    ++stride;
+-    if (i != length) {
+-      sum += counts[i];
+-      if (stride >= 4) {
+-        limit = (256 * sum + stride / 2) / stride;
+-      }
+-      if (stride == 4) {
+-        limit += 120;
+-      }
+-    }
+-  }
+-}
+-
+-static void DecideOverRleUse(const uint8_t* depth, const size_t length,
+-                             BROTLI_BOOL* use_rle_for_non_zero,
+-                             BROTLI_BOOL* use_rle_for_zero) {
+-  size_t total_reps_zero = 0;
+-  size_t total_reps_non_zero = 0;
+-  size_t count_reps_zero = 1;
+-  size_t count_reps_non_zero = 1;
+-  size_t i;
+-  for (i = 0; i < length;) {
+-    const uint8_t value = depth[i];
+-    size_t reps = 1;
+-    size_t k;
+-    for (k = i + 1; k < length && depth[k] == value; ++k) {
+-      ++reps;
+-    }
+-    if (reps >= 3 && value == 0) {
+-      total_reps_zero += reps;
+-      ++count_reps_zero;
+-    }
+-    if (reps >= 4 && value != 0) {
+-      total_reps_non_zero += reps;
+-      ++count_reps_non_zero;
+-    }
+-    i += reps;
+-  }
+-  *use_rle_for_non_zero =
+-      TO_BROTLI_BOOL(total_reps_non_zero > count_reps_non_zero * 2);
+-  *use_rle_for_zero = TO_BROTLI_BOOL(total_reps_zero > count_reps_zero * 2);
+-}
+-
+-void BrotliWriteHuffmanTree(const uint8_t* depth,
+-                            size_t length,
+-                            size_t* tree_size,
+-                            uint8_t* tree,
+-                            uint8_t* extra_bits_data) {
+-  uint8_t previous_value = BROTLI_INITIAL_REPEATED_CODE_LENGTH;
+-  size_t i;
+-  BROTLI_BOOL use_rle_for_non_zero = BROTLI_FALSE;
+-  BROTLI_BOOL use_rle_for_zero = BROTLI_FALSE;
+-
+-  /* Throw away trailing zeros. */
+-  size_t new_length = length;
+-  for (i = 0; i < length; ++i) {
+-    if (depth[length - i - 1] == 0) {
+-      --new_length;
+-    } else {
+-      break;
+-    }
+-  }
+-
+-  /* First gather statistics on if it is a good idea to do RLE. */
+-  if (length > 50) {
+-    /* Find RLE coding for longer codes.
+-       Shorter codes seem not to benefit from RLE. */
+-    DecideOverRleUse(depth, new_length,
+-                     &use_rle_for_non_zero, &use_rle_for_zero);
+-  }
+-
+-  /* Actual RLE coding. */
+-  for (i = 0; i < new_length;) {
+-    const uint8_t value = depth[i];
+-    size_t reps = 1;
+-    if ((value != 0 && use_rle_for_non_zero) ||
+-        (value == 0 && use_rle_for_zero)) {
+-      size_t k;
+-      for (k = i + 1; k < new_length && depth[k] == value; ++k) {
+-        ++reps;
+-      }
+-    }
+-    if (value == 0) {
+-      BrotliWriteHuffmanTreeRepetitionsZeros(
+-          reps, tree_size, tree, extra_bits_data);
+-    } else {
+-      BrotliWriteHuffmanTreeRepetitions(previous_value,
+-                                        value, reps, tree_size,
+-                                        tree, extra_bits_data);
+-      previous_value = value;
+-    }
+-    i += reps;
+-  }
+-}
+-
+-static uint16_t BrotliReverseBits(size_t num_bits, uint16_t bits) {
+-  static const size_t kLut[16] = {  /* Pre-reversed 4-bit values. */
+-    0x00, 0x08, 0x04, 0x0C, 0x02, 0x0A, 0x06, 0x0E,
+-    0x01, 0x09, 0x05, 0x0D, 0x03, 0x0B, 0x07, 0x0F
+-  };
+-  size_t retval = kLut[bits & 0x0F];
+-  size_t i;
+-  for (i = 4; i < num_bits; i += 4) {
+-    retval <<= 4;
+-    bits = (uint16_t)(bits >> 4);
+-    retval |= kLut[bits & 0x0F];
+-  }
+-  retval >>= ((0 - num_bits) & 0x03);
+-  return (uint16_t)retval;
+-}
+-
+-/* 0..15 are values for bits */
+-#define MAX_HUFFMAN_BITS 16
+-
+-void BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
+-                                     size_t len,
+-                                     uint16_t* bits) {
+-  /* In Brotli, all bit depths are [1..15]
+-     0 bit depth means that the symbol does not exist. */
+-  uint16_t bl_count[MAX_HUFFMAN_BITS] = { 0 };
+-  uint16_t next_code[MAX_HUFFMAN_BITS];
+-  size_t i;
+-  int code = 0;
+-  for (i = 0; i < len; ++i) {
+-    ++bl_count[depth[i]];
+-  }
+-  bl_count[0] = 0;
+-  next_code[0] = 0;
+-  for (i = 1; i < MAX_HUFFMAN_BITS; ++i) {
+-    code = (code + bl_count[i - 1]) << 1;
+-    next_code[i] = (uint16_t)code;
+-  }
+-  for (i = 0; i < len; ++i) {
+-    if (depth[i]) {
+-      bits[i] = BrotliReverseBits(depth[i], next_code[depth[i]]++);
+-    }
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/entropy_encode.h b/modules/brotli/enc/entropy_encode.h
+deleted file mode 100644
+--- a/modules/brotli/enc/entropy_encode.h
++++ /dev/null
+@@ -1,122 +0,0 @@
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Entropy encoding (Huffman) utilities. */
+-
+-#ifndef BROTLI_ENC_ENTROPY_ENCODE_H_
+-#define BROTLI_ENC_ENTROPY_ENCODE_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* A node of a Huffman tree. */
+-typedef struct HuffmanTree {
+-  uint32_t total_count_;
+-  int16_t index_left_;
+-  int16_t index_right_or_value_;
+-} HuffmanTree;
+-
+-static BROTLI_INLINE void InitHuffmanTree(HuffmanTree* self, uint32_t count,
+-    int16_t left, int16_t right) {
+-  self->total_count_ = count;
+-  self->index_left_ = left;
+-  self->index_right_or_value_ = right;
+-}
+-
+-/* Returns 1 is assignment of depths succeeded, otherwise 0. */
+-BROTLI_INTERNAL BROTLI_BOOL BrotliSetDepth(
+-    int p, HuffmanTree* pool, uint8_t* depth, int max_depth);
+-
+-/* This function will create a Huffman tree.
+-
+-   The (data,length) contains the population counts.
+-   The tree_limit is the maximum bit depth of the Huffman codes.
+-
+-   The depth contains the tree, i.e., how many bits are used for
+-   the symbol.
+-
+-   The actual Huffman tree is constructed in the tree[] array, which has to
+-   be at least 2 * length + 1 long.
+-
+-   See http://en.wikipedia.org/wiki/Huffman_coding */
+-BROTLI_INTERNAL void BrotliCreateHuffmanTree(const uint32_t* data,
+-                                             const size_t length,
+-                                             const int tree_limit,
+-                                             HuffmanTree* tree,
+-                                             uint8_t* depth);
+-
+-/* Change the population counts in a way that the consequent
+-   Huffman tree compression, especially its RLE-part will be more
+-   likely to compress this data more efficiently.
+-
+-   length contains the size of the histogram.
+-   counts contains the population counts.
+-   good_for_rle is a buffer of at least length size */
+-BROTLI_INTERNAL void BrotliOptimizeHuffmanCountsForRle(
+-    size_t length, uint32_t* counts, uint8_t* good_for_rle);
+-
+-/* Write a Huffman tree from bit depths into the bit-stream representation
+-   of a Huffman tree. The generated Huffman tree is to be compressed once
+-   more using a Huffman tree */
+-BROTLI_INTERNAL void BrotliWriteHuffmanTree(const uint8_t* depth,
+-                                            size_t num,
+-                                            size_t* tree_size,
+-                                            uint8_t* tree,
+-                                            uint8_t* extra_bits_data);
+-
+-/* Get the actual bit values for a tree of bit depths. */
+-BROTLI_INTERNAL void BrotliConvertBitDepthsToSymbols(const uint8_t* depth,
+-                                                     size_t len,
+-                                                     uint16_t* bits);
+-
+-BROTLI_INTERNAL extern const size_t kBrotliShellGaps[6];
+-/* Input size optimized Shell sort. */
+-typedef BROTLI_BOOL (*HuffmanTreeComparator)(
+-    const HuffmanTree*, const HuffmanTree*);
+-static BROTLI_INLINE void SortHuffmanTreeItems(HuffmanTree* items,
+-    const size_t n, HuffmanTreeComparator comparator) {
+-  if (n < 13) {
+-    /* Insertion sort. */
+-    size_t i;
+-    for (i = 1; i < n; ++i) {
+-      HuffmanTree tmp = items[i];
+-      size_t k = i;
+-      size_t j = i - 1;
+-      while (comparator(&tmp, &items[j])) {
+-        items[k] = items[j];
+-        k = j;
+-        if (!j--) break;
+-      }
+-      items[k] = tmp;
+-    }
+-    return;
+-  } else {
+-    /* Shell sort. */
+-    int g = n < 57 ? 2 : 0;
+-    for (; g < 6; ++g) {
+-      size_t gap = kBrotliShellGaps[g];
+-      size_t i;
+-      for (i = gap; i < n; ++i) {
+-        size_t j = i;
+-        HuffmanTree tmp = items[i];
+-        for (; j >= gap && comparator(&tmp, &items[j - gap]); j -= gap) {
+-          items[j] = items[j - gap];
+-        }
+-        items[j] = tmp;
+-      }
+-    }
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_ENTROPY_ENCODE_H_ */
+diff --git a/modules/brotli/enc/entropy_encode_static.h b/modules/brotli/enc/entropy_encode_static.h
+deleted file mode 100644
+--- a/modules/brotli/enc/entropy_encode_static.h
++++ /dev/null
+@@ -1,539 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Static entropy codes used for faster meta-block encoding. */
+-
+-#ifndef BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
+-#define BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./write_bits.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static const uint8_t kCodeLengthDepth[18] = {
+-  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 0, 4, 4,
+-};
+-
+-static const uint8_t kStaticCommandCodeDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-   9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+-};
+-
+-static const uint8_t kStaticDistanceCodeDepth[64] = {
+-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+-  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+-};
+-
+-static const uint32_t kCodeLengthBits[18] = {
+-  0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 15, 31, 0, 11, 7,
+-};
+-
+-static BROTLI_INLINE void StoreStaticCodeLengthCode(
+-    size_t* storage_ix, uint8_t* storage) {
+-  BrotliWriteBits(
+-      40, BROTLI_MAKE_UINT64_T(0x0000FFu, 0x55555554u), storage_ix, storage);
+-}
+-
+-static const uint64_t kZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-  0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00000017, 0x00000027,
+-  0x00000037, 0x00000047, 0x00000057, 0x00000067, 0x00000077, 0x00000770,
+-  0x00000b87, 0x00001387, 0x00001b87, 0x00002387, 0x00002b87, 0x00003387,
+-  0x00003b87, 0x00000397, 0x00000b97, 0x00001397, 0x00001b97, 0x00002397,
+-  0x00002b97, 0x00003397, 0x00003b97, 0x000003a7, 0x00000ba7, 0x000013a7,
+-  0x00001ba7, 0x000023a7, 0x00002ba7, 0x000033a7, 0x00003ba7, 0x000003b7,
+-  0x00000bb7, 0x000013b7, 0x00001bb7, 0x000023b7, 0x00002bb7, 0x000033b7,
+-  0x00003bb7, 0x000003c7, 0x00000bc7, 0x000013c7, 0x00001bc7, 0x000023c7,
+-  0x00002bc7, 0x000033c7, 0x00003bc7, 0x000003d7, 0x00000bd7, 0x000013d7,
+-  0x00001bd7, 0x000023d7, 0x00002bd7, 0x000033d7, 0x00003bd7, 0x000003e7,
+-  0x00000be7, 0x000013e7, 0x00001be7, 0x000023e7, 0x00002be7, 0x000033e7,
+-  0x00003be7, 0x000003f7, 0x00000bf7, 0x000013f7, 0x00001bf7, 0x000023f7,
+-  0x00002bf7, 0x000033f7, 0x00003bf7, 0x0001c387, 0x0005c387, 0x0009c387,
+-  0x000dc387, 0x0011c387, 0x0015c387, 0x0019c387, 0x001dc387, 0x0001cb87,
+-  0x0005cb87, 0x0009cb87, 0x000dcb87, 0x0011cb87, 0x0015cb87, 0x0019cb87,
+-  0x001dcb87, 0x0001d387, 0x0005d387, 0x0009d387, 0x000dd387, 0x0011d387,
+-  0x0015d387, 0x0019d387, 0x001dd387, 0x0001db87, 0x0005db87, 0x0009db87,
+-  0x000ddb87, 0x0011db87, 0x0015db87, 0x0019db87, 0x001ddb87, 0x0001e387,
+-  0x0005e387, 0x0009e387, 0x000de387, 0x0011e387, 0x0015e387, 0x0019e387,
+-  0x001de387, 0x0001eb87, 0x0005eb87, 0x0009eb87, 0x000deb87, 0x0011eb87,
+-  0x0015eb87, 0x0019eb87, 0x001deb87, 0x0001f387, 0x0005f387, 0x0009f387,
+-  0x000df387, 0x0011f387, 0x0015f387, 0x0019f387, 0x001df387, 0x0001fb87,
+-  0x0005fb87, 0x0009fb87, 0x000dfb87, 0x0011fb87, 0x0015fb87, 0x0019fb87,
+-  0x001dfb87, 0x0001c397, 0x0005c397, 0x0009c397, 0x000dc397, 0x0011c397,
+-  0x0015c397, 0x0019c397, 0x001dc397, 0x0001cb97, 0x0005cb97, 0x0009cb97,
+-  0x000dcb97, 0x0011cb97, 0x0015cb97, 0x0019cb97, 0x001dcb97, 0x0001d397,
+-  0x0005d397, 0x0009d397, 0x000dd397, 0x0011d397, 0x0015d397, 0x0019d397,
+-  0x001dd397, 0x0001db97, 0x0005db97, 0x0009db97, 0x000ddb97, 0x0011db97,
+-  0x0015db97, 0x0019db97, 0x001ddb97, 0x0001e397, 0x0005e397, 0x0009e397,
+-  0x000de397, 0x0011e397, 0x0015e397, 0x0019e397, 0x001de397, 0x0001eb97,
+-  0x0005eb97, 0x0009eb97, 0x000deb97, 0x0011eb97, 0x0015eb97, 0x0019eb97,
+-  0x001deb97, 0x0001f397, 0x0005f397, 0x0009f397, 0x000df397, 0x0011f397,
+-  0x0015f397, 0x0019f397, 0x001df397, 0x0001fb97, 0x0005fb97, 0x0009fb97,
+-  0x000dfb97, 0x0011fb97, 0x0015fb97, 0x0019fb97, 0x001dfb97, 0x0001c3a7,
+-  0x0005c3a7, 0x0009c3a7, 0x000dc3a7, 0x0011c3a7, 0x0015c3a7, 0x0019c3a7,
+-  0x001dc3a7, 0x0001cba7, 0x0005cba7, 0x0009cba7, 0x000dcba7, 0x0011cba7,
+-  0x0015cba7, 0x0019cba7, 0x001dcba7, 0x0001d3a7, 0x0005d3a7, 0x0009d3a7,
+-  0x000dd3a7, 0x0011d3a7, 0x0015d3a7, 0x0019d3a7, 0x001dd3a7, 0x0001dba7,
+-  0x0005dba7, 0x0009dba7, 0x000ddba7, 0x0011dba7, 0x0015dba7, 0x0019dba7,
+-  0x001ddba7, 0x0001e3a7, 0x0005e3a7, 0x0009e3a7, 0x000de3a7, 0x0011e3a7,
+-  0x0015e3a7, 0x0019e3a7, 0x001de3a7, 0x0001eba7, 0x0005eba7, 0x0009eba7,
+-  0x000deba7, 0x0011eba7, 0x0015eba7, 0x0019eba7, 0x001deba7, 0x0001f3a7,
+-  0x0005f3a7, 0x0009f3a7, 0x000df3a7, 0x0011f3a7, 0x0015f3a7, 0x0019f3a7,
+-  0x001df3a7, 0x0001fba7, 0x0005fba7, 0x0009fba7, 0x000dfba7, 0x0011fba7,
+-  0x0015fba7, 0x0019fba7, 0x001dfba7, 0x0001c3b7, 0x0005c3b7, 0x0009c3b7,
+-  0x000dc3b7, 0x0011c3b7, 0x0015c3b7, 0x0019c3b7, 0x001dc3b7, 0x0001cbb7,
+-  0x0005cbb7, 0x0009cbb7, 0x000dcbb7, 0x0011cbb7, 0x0015cbb7, 0x0019cbb7,
+-  0x001dcbb7, 0x0001d3b7, 0x0005d3b7, 0x0009d3b7, 0x000dd3b7, 0x0011d3b7,
+-  0x0015d3b7, 0x0019d3b7, 0x001dd3b7, 0x0001dbb7, 0x0005dbb7, 0x0009dbb7,
+-  0x000ddbb7, 0x0011dbb7, 0x0015dbb7, 0x0019dbb7, 0x001ddbb7, 0x0001e3b7,
+-  0x0005e3b7, 0x0009e3b7, 0x000de3b7, 0x0011e3b7, 0x0015e3b7, 0x0019e3b7,
+-  0x001de3b7, 0x0001ebb7, 0x0005ebb7, 0x0009ebb7, 0x000debb7, 0x0011ebb7,
+-  0x0015ebb7, 0x0019ebb7, 0x001debb7, 0x0001f3b7, 0x0005f3b7, 0x0009f3b7,
+-  0x000df3b7, 0x0011f3b7, 0x0015f3b7, 0x0019f3b7, 0x001df3b7, 0x0001fbb7,
+-  0x0005fbb7, 0x0009fbb7, 0x000dfbb7, 0x0011fbb7, 0x0015fbb7, 0x0019fbb7,
+-  0x001dfbb7, 0x0001c3c7, 0x0005c3c7, 0x0009c3c7, 0x000dc3c7, 0x0011c3c7,
+-  0x0015c3c7, 0x0019c3c7, 0x001dc3c7, 0x0001cbc7, 0x0005cbc7, 0x0009cbc7,
+-  0x000dcbc7, 0x0011cbc7, 0x0015cbc7, 0x0019cbc7, 0x001dcbc7, 0x0001d3c7,
+-  0x0005d3c7, 0x0009d3c7, 0x000dd3c7, 0x0011d3c7, 0x0015d3c7, 0x0019d3c7,
+-  0x001dd3c7, 0x0001dbc7, 0x0005dbc7, 0x0009dbc7, 0x000ddbc7, 0x0011dbc7,
+-  0x0015dbc7, 0x0019dbc7, 0x001ddbc7, 0x0001e3c7, 0x0005e3c7, 0x0009e3c7,
+-  0x000de3c7, 0x0011e3c7, 0x0015e3c7, 0x0019e3c7, 0x001de3c7, 0x0001ebc7,
+-  0x0005ebc7, 0x0009ebc7, 0x000debc7, 0x0011ebc7, 0x0015ebc7, 0x0019ebc7,
+-  0x001debc7, 0x0001f3c7, 0x0005f3c7, 0x0009f3c7, 0x000df3c7, 0x0011f3c7,
+-  0x0015f3c7, 0x0019f3c7, 0x001df3c7, 0x0001fbc7, 0x0005fbc7, 0x0009fbc7,
+-  0x000dfbc7, 0x0011fbc7, 0x0015fbc7, 0x0019fbc7, 0x001dfbc7, 0x0001c3d7,
+-  0x0005c3d7, 0x0009c3d7, 0x000dc3d7, 0x0011c3d7, 0x0015c3d7, 0x0019c3d7,
+-  0x001dc3d7, 0x0001cbd7, 0x0005cbd7, 0x0009cbd7, 0x000dcbd7, 0x0011cbd7,
+-  0x0015cbd7, 0x0019cbd7, 0x001dcbd7, 0x0001d3d7, 0x0005d3d7, 0x0009d3d7,
+-  0x000dd3d7, 0x0011d3d7, 0x0015d3d7, 0x0019d3d7, 0x001dd3d7, 0x0001dbd7,
+-  0x0005dbd7, 0x0009dbd7, 0x000ddbd7, 0x0011dbd7, 0x0015dbd7, 0x0019dbd7,
+-  0x001ddbd7, 0x0001e3d7, 0x0005e3d7, 0x0009e3d7, 0x000de3d7, 0x0011e3d7,
+-  0x0015e3d7, 0x0019e3d7, 0x001de3d7, 0x0001ebd7, 0x0005ebd7, 0x0009ebd7,
+-  0x000debd7, 0x0011ebd7, 0x0015ebd7, 0x0019ebd7, 0x001debd7, 0x0001f3d7,
+-  0x0005f3d7, 0x0009f3d7, 0x000df3d7, 0x0011f3d7, 0x0015f3d7, 0x0019f3d7,
+-  0x001df3d7, 0x0001fbd7, 0x0005fbd7, 0x0009fbd7, 0x000dfbd7, 0x0011fbd7,
+-  0x0015fbd7, 0x0019fbd7, 0x001dfbd7, 0x0001c3e7, 0x0005c3e7, 0x0009c3e7,
+-  0x000dc3e7, 0x0011c3e7, 0x0015c3e7, 0x0019c3e7, 0x001dc3e7, 0x0001cbe7,
+-  0x0005cbe7, 0x0009cbe7, 0x000dcbe7, 0x0011cbe7, 0x0015cbe7, 0x0019cbe7,
+-  0x001dcbe7, 0x0001d3e7, 0x0005d3e7, 0x0009d3e7, 0x000dd3e7, 0x0011d3e7,
+-  0x0015d3e7, 0x0019d3e7, 0x001dd3e7, 0x0001dbe7, 0x0005dbe7, 0x0009dbe7,
+-  0x000ddbe7, 0x0011dbe7, 0x0015dbe7, 0x0019dbe7, 0x001ddbe7, 0x0001e3e7,
+-  0x0005e3e7, 0x0009e3e7, 0x000de3e7, 0x0011e3e7, 0x0015e3e7, 0x0019e3e7,
+-  0x001de3e7, 0x0001ebe7, 0x0005ebe7, 0x0009ebe7, 0x000debe7, 0x0011ebe7,
+-  0x0015ebe7, 0x0019ebe7, 0x001debe7, 0x0001f3e7, 0x0005f3e7, 0x0009f3e7,
+-  0x000df3e7, 0x0011f3e7, 0x0015f3e7, 0x0019f3e7, 0x001df3e7, 0x0001fbe7,
+-  0x0005fbe7, 0x0009fbe7, 0x000dfbe7, 0x0011fbe7, 0x0015fbe7, 0x0019fbe7,
+-  0x001dfbe7, 0x0001c3f7, 0x0005c3f7, 0x0009c3f7, 0x000dc3f7, 0x0011c3f7,
+-  0x0015c3f7, 0x0019c3f7, 0x001dc3f7, 0x0001cbf7, 0x0005cbf7, 0x0009cbf7,
+-  0x000dcbf7, 0x0011cbf7, 0x0015cbf7, 0x0019cbf7, 0x001dcbf7, 0x0001d3f7,
+-  0x0005d3f7, 0x0009d3f7, 0x000dd3f7, 0x0011d3f7, 0x0015d3f7, 0x0019d3f7,
+-  0x001dd3f7, 0x0001dbf7, 0x0005dbf7, 0x0009dbf7, 0x000ddbf7, 0x0011dbf7,
+-  0x0015dbf7, 0x0019dbf7, 0x001ddbf7, 0x0001e3f7, 0x0005e3f7, 0x0009e3f7,
+-  0x000de3f7, 0x0011e3f7, 0x0015e3f7, 0x0019e3f7, 0x001de3f7, 0x0001ebf7,
+-  0x0005ebf7, 0x0009ebf7, 0x000debf7, 0x0011ebf7, 0x0015ebf7, 0x0019ebf7,
+-  0x001debf7, 0x0001f3f7, 0x0005f3f7, 0x0009f3f7, 0x000df3f7, 0x0011f3f7,
+-  0x0015f3f7, 0x0019f3f7, 0x001df3f7, 0x0001fbf7, 0x0005fbf7, 0x0009fbf7,
+-  0x000dfbf7, 0x0011fbf7, 0x0015fbf7, 0x0019fbf7, 0x001dfbf7, 0x00e1c387,
+-  0x02e1c387, 0x04e1c387, 0x06e1c387, 0x08e1c387, 0x0ae1c387, 0x0ce1c387,
+-  0x0ee1c387, 0x00e5c387, 0x02e5c387, 0x04e5c387, 0x06e5c387, 0x08e5c387,
+-  0x0ae5c387, 0x0ce5c387, 0x0ee5c387, 0x00e9c387, 0x02e9c387, 0x04e9c387,
+-  0x06e9c387, 0x08e9c387, 0x0ae9c387, 0x0ce9c387, 0x0ee9c387, 0x00edc387,
+-  0x02edc387, 0x04edc387, 0x06edc387, 0x08edc387, 0x0aedc387, 0x0cedc387,
+-  0x0eedc387, 0x00f1c387, 0x02f1c387, 0x04f1c387, 0x06f1c387, 0x08f1c387,
+-  0x0af1c387, 0x0cf1c387, 0x0ef1c387, 0x00f5c387, 0x02f5c387, 0x04f5c387,
+-  0x06f5c387, 0x08f5c387, 0x0af5c387, 0x0cf5c387, 0x0ef5c387, 0x00f9c387,
+-  0x02f9c387, 0x04f9c387, 0x06f9c387, 0x08f9c387, 0x0af9c387, 0x0cf9c387,
+-  0x0ef9c387, 0x00fdc387, 0x02fdc387, 0x04fdc387, 0x06fdc387, 0x08fdc387,
+-  0x0afdc387, 0x0cfdc387, 0x0efdc387, 0x00e1cb87, 0x02e1cb87, 0x04e1cb87,
+-  0x06e1cb87, 0x08e1cb87, 0x0ae1cb87, 0x0ce1cb87, 0x0ee1cb87, 0x00e5cb87,
+-  0x02e5cb87, 0x04e5cb87, 0x06e5cb87, 0x08e5cb87, 0x0ae5cb87, 0x0ce5cb87,
+-  0x0ee5cb87, 0x00e9cb87, 0x02e9cb87, 0x04e9cb87, 0x06e9cb87, 0x08e9cb87,
+-  0x0ae9cb87, 0x0ce9cb87, 0x0ee9cb87, 0x00edcb87, 0x02edcb87, 0x04edcb87,
+-  0x06edcb87, 0x08edcb87, 0x0aedcb87, 0x0cedcb87, 0x0eedcb87, 0x00f1cb87,
+-  0x02f1cb87, 0x04f1cb87, 0x06f1cb87, 0x08f1cb87, 0x0af1cb87, 0x0cf1cb87,
+-  0x0ef1cb87, 0x00f5cb87, 0x02f5cb87, 0x04f5cb87, 0x06f5cb87, 0x08f5cb87,
+-  0x0af5cb87, 0x0cf5cb87, 0x0ef5cb87, 0x00f9cb87, 0x02f9cb87, 0x04f9cb87,
+-  0x06f9cb87, 0x08f9cb87,
+-};
+-
+-static const uint32_t kZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-   0,  4,  8,  7,  7,  7,  7,  7,  7,  7,  7, 11, 14, 14, 14, 14,
+-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+-  14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+-  21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-  28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+-};
+-
+-static const uint64_t kNonZeroRepsBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-  0x0000000b, 0x0000001b, 0x0000002b, 0x0000003b, 0x000002cb, 0x000006cb,
+-  0x00000acb, 0x00000ecb, 0x000002db, 0x000006db, 0x00000adb, 0x00000edb,
+-  0x000002eb, 0x000006eb, 0x00000aeb, 0x00000eeb, 0x000002fb, 0x000006fb,
+-  0x00000afb, 0x00000efb, 0x0000b2cb, 0x0001b2cb, 0x0002b2cb, 0x0003b2cb,
+-  0x0000b6cb, 0x0001b6cb, 0x0002b6cb, 0x0003b6cb, 0x0000bacb, 0x0001bacb,
+-  0x0002bacb, 0x0003bacb, 0x0000becb, 0x0001becb, 0x0002becb, 0x0003becb,
+-  0x0000b2db, 0x0001b2db, 0x0002b2db, 0x0003b2db, 0x0000b6db, 0x0001b6db,
+-  0x0002b6db, 0x0003b6db, 0x0000badb, 0x0001badb, 0x0002badb, 0x0003badb,
+-  0x0000bedb, 0x0001bedb, 0x0002bedb, 0x0003bedb, 0x0000b2eb, 0x0001b2eb,
+-  0x0002b2eb, 0x0003b2eb, 0x0000b6eb, 0x0001b6eb, 0x0002b6eb, 0x0003b6eb,
+-  0x0000baeb, 0x0001baeb, 0x0002baeb, 0x0003baeb, 0x0000beeb, 0x0001beeb,
+-  0x0002beeb, 0x0003beeb, 0x0000b2fb, 0x0001b2fb, 0x0002b2fb, 0x0003b2fb,
+-  0x0000b6fb, 0x0001b6fb, 0x0002b6fb, 0x0003b6fb, 0x0000bafb, 0x0001bafb,
+-  0x0002bafb, 0x0003bafb, 0x0000befb, 0x0001befb, 0x0002befb, 0x0003befb,
+-  0x002cb2cb, 0x006cb2cb, 0x00acb2cb, 0x00ecb2cb, 0x002db2cb, 0x006db2cb,
+-  0x00adb2cb, 0x00edb2cb, 0x002eb2cb, 0x006eb2cb, 0x00aeb2cb, 0x00eeb2cb,
+-  0x002fb2cb, 0x006fb2cb, 0x00afb2cb, 0x00efb2cb, 0x002cb6cb, 0x006cb6cb,
+-  0x00acb6cb, 0x00ecb6cb, 0x002db6cb, 0x006db6cb, 0x00adb6cb, 0x00edb6cb,
+-  0x002eb6cb, 0x006eb6cb, 0x00aeb6cb, 0x00eeb6cb, 0x002fb6cb, 0x006fb6cb,
+-  0x00afb6cb, 0x00efb6cb, 0x002cbacb, 0x006cbacb, 0x00acbacb, 0x00ecbacb,
+-  0x002dbacb, 0x006dbacb, 0x00adbacb, 0x00edbacb, 0x002ebacb, 0x006ebacb,
+-  0x00aebacb, 0x00eebacb, 0x002fbacb, 0x006fbacb, 0x00afbacb, 0x00efbacb,
+-  0x002cbecb, 0x006cbecb, 0x00acbecb, 0x00ecbecb, 0x002dbecb, 0x006dbecb,
+-  0x00adbecb, 0x00edbecb, 0x002ebecb, 0x006ebecb, 0x00aebecb, 0x00eebecb,
+-  0x002fbecb, 0x006fbecb, 0x00afbecb, 0x00efbecb, 0x002cb2db, 0x006cb2db,
+-  0x00acb2db, 0x00ecb2db, 0x002db2db, 0x006db2db, 0x00adb2db, 0x00edb2db,
+-  0x002eb2db, 0x006eb2db, 0x00aeb2db, 0x00eeb2db, 0x002fb2db, 0x006fb2db,
+-  0x00afb2db, 0x00efb2db, 0x002cb6db, 0x006cb6db, 0x00acb6db, 0x00ecb6db,
+-  0x002db6db, 0x006db6db, 0x00adb6db, 0x00edb6db, 0x002eb6db, 0x006eb6db,
+-  0x00aeb6db, 0x00eeb6db, 0x002fb6db, 0x006fb6db, 0x00afb6db, 0x00efb6db,
+-  0x002cbadb, 0x006cbadb, 0x00acbadb, 0x00ecbadb, 0x002dbadb, 0x006dbadb,
+-  0x00adbadb, 0x00edbadb, 0x002ebadb, 0x006ebadb, 0x00aebadb, 0x00eebadb,
+-  0x002fbadb, 0x006fbadb, 0x00afbadb, 0x00efbadb, 0x002cbedb, 0x006cbedb,
+-  0x00acbedb, 0x00ecbedb, 0x002dbedb, 0x006dbedb, 0x00adbedb, 0x00edbedb,
+-  0x002ebedb, 0x006ebedb, 0x00aebedb, 0x00eebedb, 0x002fbedb, 0x006fbedb,
+-  0x00afbedb, 0x00efbedb, 0x002cb2eb, 0x006cb2eb, 0x00acb2eb, 0x00ecb2eb,
+-  0x002db2eb, 0x006db2eb, 0x00adb2eb, 0x00edb2eb, 0x002eb2eb, 0x006eb2eb,
+-  0x00aeb2eb, 0x00eeb2eb, 0x002fb2eb, 0x006fb2eb, 0x00afb2eb, 0x00efb2eb,
+-  0x002cb6eb, 0x006cb6eb, 0x00acb6eb, 0x00ecb6eb, 0x002db6eb, 0x006db6eb,
+-  0x00adb6eb, 0x00edb6eb, 0x002eb6eb, 0x006eb6eb, 0x00aeb6eb, 0x00eeb6eb,
+-  0x002fb6eb, 0x006fb6eb, 0x00afb6eb, 0x00efb6eb, 0x002cbaeb, 0x006cbaeb,
+-  0x00acbaeb, 0x00ecbaeb, 0x002dbaeb, 0x006dbaeb, 0x00adbaeb, 0x00edbaeb,
+-  0x002ebaeb, 0x006ebaeb, 0x00aebaeb, 0x00eebaeb, 0x002fbaeb, 0x006fbaeb,
+-  0x00afbaeb, 0x00efbaeb, 0x002cbeeb, 0x006cbeeb, 0x00acbeeb, 0x00ecbeeb,
+-  0x002dbeeb, 0x006dbeeb, 0x00adbeeb, 0x00edbeeb, 0x002ebeeb, 0x006ebeeb,
+-  0x00aebeeb, 0x00eebeeb, 0x002fbeeb, 0x006fbeeb, 0x00afbeeb, 0x00efbeeb,
+-  0x002cb2fb, 0x006cb2fb, 0x00acb2fb, 0x00ecb2fb, 0x002db2fb, 0x006db2fb,
+-  0x00adb2fb, 0x00edb2fb, 0x002eb2fb, 0x006eb2fb, 0x00aeb2fb, 0x00eeb2fb,
+-  0x002fb2fb, 0x006fb2fb, 0x00afb2fb, 0x00efb2fb, 0x002cb6fb, 0x006cb6fb,
+-  0x00acb6fb, 0x00ecb6fb, 0x002db6fb, 0x006db6fb, 0x00adb6fb, 0x00edb6fb,
+-  0x002eb6fb, 0x006eb6fb, 0x00aeb6fb, 0x00eeb6fb, 0x002fb6fb, 0x006fb6fb,
+-  0x00afb6fb, 0x00efb6fb, 0x002cbafb, 0x006cbafb, 0x00acbafb, 0x00ecbafb,
+-  0x002dbafb, 0x006dbafb, 0x00adbafb, 0x00edbafb, 0x002ebafb, 0x006ebafb,
+-  0x00aebafb, 0x00eebafb, 0x002fbafb, 0x006fbafb, 0x00afbafb, 0x00efbafb,
+-  0x002cbefb, 0x006cbefb, 0x00acbefb, 0x00ecbefb, 0x002dbefb, 0x006dbefb,
+-  0x00adbefb, 0x00edbefb, 0x002ebefb, 0x006ebefb, 0x00aebefb, 0x00eebefb,
+-  0x002fbefb, 0x006fbefb, 0x00afbefb, 0x00efbefb, 0x0b2cb2cb, 0x1b2cb2cb,
+-  0x2b2cb2cb, 0x3b2cb2cb, 0x0b6cb2cb, 0x1b6cb2cb, 0x2b6cb2cb, 0x3b6cb2cb,
+-  0x0bacb2cb, 0x1bacb2cb, 0x2bacb2cb, 0x3bacb2cb, 0x0becb2cb, 0x1becb2cb,
+-  0x2becb2cb, 0x3becb2cb, 0x0b2db2cb, 0x1b2db2cb, 0x2b2db2cb, 0x3b2db2cb,
+-  0x0b6db2cb, 0x1b6db2cb, 0x2b6db2cb, 0x3b6db2cb, 0x0badb2cb, 0x1badb2cb,
+-  0x2badb2cb, 0x3badb2cb, 0x0bedb2cb, 0x1bedb2cb, 0x2bedb2cb, 0x3bedb2cb,
+-  0x0b2eb2cb, 0x1b2eb2cb, 0x2b2eb2cb, 0x3b2eb2cb, 0x0b6eb2cb, 0x1b6eb2cb,
+-  0x2b6eb2cb, 0x3b6eb2cb, 0x0baeb2cb, 0x1baeb2cb, 0x2baeb2cb, 0x3baeb2cb,
+-  0x0beeb2cb, 0x1beeb2cb, 0x2beeb2cb, 0x3beeb2cb, 0x0b2fb2cb, 0x1b2fb2cb,
+-  0x2b2fb2cb, 0x3b2fb2cb, 0x0b6fb2cb, 0x1b6fb2cb, 0x2b6fb2cb, 0x3b6fb2cb,
+-  0x0bafb2cb, 0x1bafb2cb, 0x2bafb2cb, 0x3bafb2cb, 0x0befb2cb, 0x1befb2cb,
+-  0x2befb2cb, 0x3befb2cb, 0x0b2cb6cb, 0x1b2cb6cb, 0x2b2cb6cb, 0x3b2cb6cb,
+-  0x0b6cb6cb, 0x1b6cb6cb, 0x2b6cb6cb, 0x3b6cb6cb, 0x0bacb6cb, 0x1bacb6cb,
+-  0x2bacb6cb, 0x3bacb6cb, 0x0becb6cb, 0x1becb6cb, 0x2becb6cb, 0x3becb6cb,
+-  0x0b2db6cb, 0x1b2db6cb, 0x2b2db6cb, 0x3b2db6cb, 0x0b6db6cb, 0x1b6db6cb,
+-  0x2b6db6cb, 0x3b6db6cb, 0x0badb6cb, 0x1badb6cb, 0x2badb6cb, 0x3badb6cb,
+-  0x0bedb6cb, 0x1bedb6cb, 0x2bedb6cb, 0x3bedb6cb, 0x0b2eb6cb, 0x1b2eb6cb,
+-  0x2b2eb6cb, 0x3b2eb6cb, 0x0b6eb6cb, 0x1b6eb6cb, 0x2b6eb6cb, 0x3b6eb6cb,
+-  0x0baeb6cb, 0x1baeb6cb, 0x2baeb6cb, 0x3baeb6cb, 0x0beeb6cb, 0x1beeb6cb,
+-  0x2beeb6cb, 0x3beeb6cb, 0x0b2fb6cb, 0x1b2fb6cb, 0x2b2fb6cb, 0x3b2fb6cb,
+-  0x0b6fb6cb, 0x1b6fb6cb, 0x2b6fb6cb, 0x3b6fb6cb, 0x0bafb6cb, 0x1bafb6cb,
+-  0x2bafb6cb, 0x3bafb6cb, 0x0befb6cb, 0x1befb6cb, 0x2befb6cb, 0x3befb6cb,
+-  0x0b2cbacb, 0x1b2cbacb, 0x2b2cbacb, 0x3b2cbacb, 0x0b6cbacb, 0x1b6cbacb,
+-  0x2b6cbacb, 0x3b6cbacb, 0x0bacbacb, 0x1bacbacb, 0x2bacbacb, 0x3bacbacb,
+-  0x0becbacb, 0x1becbacb, 0x2becbacb, 0x3becbacb, 0x0b2dbacb, 0x1b2dbacb,
+-  0x2b2dbacb, 0x3b2dbacb, 0x0b6dbacb, 0x1b6dbacb, 0x2b6dbacb, 0x3b6dbacb,
+-  0x0badbacb, 0x1badbacb, 0x2badbacb, 0x3badbacb, 0x0bedbacb, 0x1bedbacb,
+-  0x2bedbacb, 0x3bedbacb, 0x0b2ebacb, 0x1b2ebacb, 0x2b2ebacb, 0x3b2ebacb,
+-  0x0b6ebacb, 0x1b6ebacb, 0x2b6ebacb, 0x3b6ebacb, 0x0baebacb, 0x1baebacb,
+-  0x2baebacb, 0x3baebacb, 0x0beebacb, 0x1beebacb, 0x2beebacb, 0x3beebacb,
+-  0x0b2fbacb, 0x1b2fbacb, 0x2b2fbacb, 0x3b2fbacb, 0x0b6fbacb, 0x1b6fbacb,
+-  0x2b6fbacb, 0x3b6fbacb, 0x0bafbacb, 0x1bafbacb, 0x2bafbacb, 0x3bafbacb,
+-  0x0befbacb, 0x1befbacb, 0x2befbacb, 0x3befbacb, 0x0b2cbecb, 0x1b2cbecb,
+-  0x2b2cbecb, 0x3b2cbecb, 0x0b6cbecb, 0x1b6cbecb, 0x2b6cbecb, 0x3b6cbecb,
+-  0x0bacbecb, 0x1bacbecb, 0x2bacbecb, 0x3bacbecb, 0x0becbecb, 0x1becbecb,
+-  0x2becbecb, 0x3becbecb, 0x0b2dbecb, 0x1b2dbecb, 0x2b2dbecb, 0x3b2dbecb,
+-  0x0b6dbecb, 0x1b6dbecb, 0x2b6dbecb, 0x3b6dbecb, 0x0badbecb, 0x1badbecb,
+-  0x2badbecb, 0x3badbecb, 0x0bedbecb, 0x1bedbecb, 0x2bedbecb, 0x3bedbecb,
+-  0x0b2ebecb, 0x1b2ebecb, 0x2b2ebecb, 0x3b2ebecb, 0x0b6ebecb, 0x1b6ebecb,
+-  0x2b6ebecb, 0x3b6ebecb, 0x0baebecb, 0x1baebecb, 0x2baebecb, 0x3baebecb,
+-  0x0beebecb, 0x1beebecb, 0x2beebecb, 0x3beebecb, 0x0b2fbecb, 0x1b2fbecb,
+-  0x2b2fbecb, 0x3b2fbecb, 0x0b6fbecb, 0x1b6fbecb, 0x2b6fbecb, 0x3b6fbecb,
+-  0x0bafbecb, 0x1bafbecb, 0x2bafbecb, 0x3bafbecb, 0x0befbecb, 0x1befbecb,
+-  0x2befbecb, 0x3befbecb, 0x0b2cb2db, 0x1b2cb2db, 0x2b2cb2db, 0x3b2cb2db,
+-  0x0b6cb2db, 0x1b6cb2db, 0x2b6cb2db, 0x3b6cb2db, 0x0bacb2db, 0x1bacb2db,
+-  0x2bacb2db, 0x3bacb2db, 0x0becb2db, 0x1becb2db, 0x2becb2db, 0x3becb2db,
+-  0x0b2db2db, 0x1b2db2db, 0x2b2db2db, 0x3b2db2db, 0x0b6db2db, 0x1b6db2db,
+-  0x2b6db2db, 0x3b6db2db, 0x0badb2db, 0x1badb2db, 0x2badb2db, 0x3badb2db,
+-  0x0bedb2db, 0x1bedb2db, 0x2bedb2db, 0x3bedb2db, 0x0b2eb2db, 0x1b2eb2db,
+-  0x2b2eb2db, 0x3b2eb2db, 0x0b6eb2db, 0x1b6eb2db, 0x2b6eb2db, 0x3b6eb2db,
+-  0x0baeb2db, 0x1baeb2db, 0x2baeb2db, 0x3baeb2db, 0x0beeb2db, 0x1beeb2db,
+-  0x2beeb2db, 0x3beeb2db, 0x0b2fb2db, 0x1b2fb2db, 0x2b2fb2db, 0x3b2fb2db,
+-  0x0b6fb2db, 0x1b6fb2db, 0x2b6fb2db, 0x3b6fb2db, 0x0bafb2db, 0x1bafb2db,
+-  0x2bafb2db, 0x3bafb2db, 0x0befb2db, 0x1befb2db, 0x2befb2db, 0x3befb2db,
+-  0x0b2cb6db, 0x1b2cb6db, 0x2b2cb6db, 0x3b2cb6db, 0x0b6cb6db, 0x1b6cb6db,
+-  0x2b6cb6db, 0x3b6cb6db, 0x0bacb6db, 0x1bacb6db, 0x2bacb6db, 0x3bacb6db,
+-  0x0becb6db, 0x1becb6db, 0x2becb6db, 0x3becb6db, 0x0b2db6db, 0x1b2db6db,
+-  0x2b2db6db, 0x3b2db6db, 0x0b6db6db, 0x1b6db6db, 0x2b6db6db, 0x3b6db6db,
+-  0x0badb6db, 0x1badb6db, 0x2badb6db, 0x3badb6db, 0x0bedb6db, 0x1bedb6db,
+-  0x2bedb6db, 0x3bedb6db, 0x0b2eb6db, 0x1b2eb6db, 0x2b2eb6db, 0x3b2eb6db,
+-  0x0b6eb6db, 0x1b6eb6db, 0x2b6eb6db, 0x3b6eb6db, 0x0baeb6db, 0x1baeb6db,
+-  0x2baeb6db, 0x3baeb6db,
+-};
+-
+-static const uint32_t kNonZeroRepsDepth[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-   6,  6,  6,  6, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+-  12, 12, 12, 12, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+-  18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+-  18, 18, 18, 18, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+-  24, 24, 24, 24, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-  30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+-};
+-
+-static const uint16_t kStaticCommandCodeBits[BROTLI_NUM_COMMAND_SYMBOLS] = {
+-    0,  256,  128,  384,   64,  320,  192,  448,
+-   32,  288,  160,  416,   96,  352,  224,  480,
+-   16,  272,  144,  400,   80,  336,  208,  464,
+-   48,  304,  176,  432,  112,  368,  240,  496,
+-    8,  264,  136,  392,   72,  328,  200,  456,
+-   40,  296,  168,  424,  104,  360,  232,  488,
+-   24,  280,  152,  408,   88,  344,  216,  472,
+-   56,  312,  184,  440,  120,  376,  248,  504,
+-    4,  260,  132,  388,   68,  324,  196,  452,
+-   36,  292,  164,  420,  100,  356,  228,  484,
+-   20,  276,  148,  404,   84,  340,  212,  468,
+-   52,  308,  180,  436,  116,  372,  244,  500,
+-   12,  268,  140,  396,   76,  332,  204,  460,
+-   44,  300,  172,  428,  108,  364,  236,  492,
+-   28,  284,  156,  412,   92,  348,  220,  476,
+-   60,  316,  188,  444,  124,  380,  252,  508,
+-    2,  258,  130,  386,   66,  322,  194,  450,
+-   34,  290,  162,  418,   98,  354,  226,  482,
+-   18,  274,  146,  402,   82,  338,  210,  466,
+-   50,  306,  178,  434,  114,  370,  242,  498,
+-   10,  266,  138,  394,   74,  330,  202,  458,
+-   42,  298,  170,  426,  106,  362,  234,  490,
+-   26,  282,  154,  410,   90,  346,  218,  474,
+-   58,  314,  186,  442,  122,  378,  250,  506,
+-    6,  262,  134,  390,   70,  326,  198,  454,
+-   38,  294,  166,  422,  102,  358,  230,  486,
+-   22,  278,  150,  406,   86,  342,  214,  470,
+-   54,  310,  182,  438,  118,  374,  246,  502,
+-   14,  270,  142,  398,   78,  334,  206,  462,
+-   46,  302,  174,  430,  110,  366,  238,  494,
+-   30,  286,  158,  414,   94,  350,  222,  478,
+-   62,  318,  190,  446,  126,  382,  254,  510,
+-    1,  257,  129,  385,   65,  321,  193,  449,
+-   33,  289,  161,  417,   97,  353,  225,  481,
+-   17,  273,  145,  401,   81,  337,  209,  465,
+-   49,  305,  177,  433,  113,  369,  241,  497,
+-    9,  265,  137,  393,   73,  329,  201,  457,
+-   41,  297,  169,  425,  105,  361,  233,  489,
+-   25,  281,  153,  409,   89,  345,  217,  473,
+-   57,  313,  185,  441,  121,  377,  249,  505,
+-    5,  261,  133,  389,   69,  325,  197,  453,
+-   37,  293,  165,  421,  101,  357,  229,  485,
+-   21,  277,  149,  405,   85,  341,  213,  469,
+-   53,  309,  181,  437,  117,  373,  245,  501,
+-   13,  269,  141,  397,   77,  333,  205,  461,
+-   45,  301,  173,  429,  109,  365,  237,  493,
+-   29,  285,  157,  413,   93,  349,  221,  477,
+-   61,  317,  189,  445,  125,  381,  253,  509,
+-    3,  259,  131,  387,   67,  323,  195,  451,
+-   35,  291,  163,  419,   99,  355,  227,  483,
+-   19,  275,  147,  403,   83,  339,  211,  467,
+-   51,  307,  179,  435,  115,  371,  243,  499,
+-   11,  267,  139,  395,   75,  331,  203,  459,
+-   43,  299,  171,  427,  107,  363,  235,  491,
+-   27,  283,  155,  411,   91,  347,  219,  475,
+-   59,  315,  187,  443,  123,  379,  251,  507,
+-    7, 1031,  519, 1543,  263, 1287,  775, 1799,
+-  135, 1159,  647, 1671,  391, 1415,  903, 1927,
+-   71, 1095,  583, 1607,  327, 1351,  839, 1863,
+-  199, 1223,  711, 1735,  455, 1479,  967, 1991,
+-   39, 1063,  551, 1575,  295, 1319,  807, 1831,
+-  167, 1191,  679, 1703,  423, 1447,  935, 1959,
+-  103, 1127,  615, 1639,  359, 1383,  871, 1895,
+-  231, 1255,  743, 1767,  487, 1511,  999, 2023,
+-   23, 1047,  535, 1559,  279, 1303,  791, 1815,
+-  151, 1175,  663, 1687,  407, 1431,  919, 1943,
+-   87, 1111,  599, 1623,  343, 1367,  855, 1879,
+-  215, 1239,  727, 1751,  471, 1495,  983, 2007,
+-   55, 1079,  567, 1591,  311, 1335,  823, 1847,
+-  183, 1207,  695, 1719,  439, 1463,  951, 1975,
+-  119, 1143,  631, 1655,  375, 1399,  887, 1911,
+-  247, 1271,  759, 1783,  503, 1527, 1015, 2039,
+-   15, 1039,  527, 1551,  271, 1295,  783, 1807,
+-  143, 1167,  655, 1679,  399, 1423,  911, 1935,
+-   79, 1103,  591, 1615,  335, 1359,  847, 1871,
+-  207, 1231,  719, 1743,  463, 1487,  975, 1999,
+-   47, 1071,  559, 1583,  303, 1327,  815, 1839,
+-  175, 1199,  687, 1711,  431, 1455,  943, 1967,
+-  111, 1135,  623, 1647,  367, 1391,  879, 1903,
+-  239, 1263,  751, 1775,  495, 1519, 1007, 2031,
+-   31, 1055,  543, 1567,  287, 1311,  799, 1823,
+-  159, 1183,  671, 1695,  415, 1439,  927, 1951,
+-   95, 1119,  607, 1631,  351, 1375,  863, 1887,
+-  223, 1247,  735, 1759,  479, 1503,  991, 2015,
+-   63, 1087,  575, 1599,  319, 1343,  831, 1855,
+-  191, 1215,  703, 1727,  447, 1471,  959, 1983,
+-  127, 1151,  639, 1663,  383, 1407,  895, 1919,
+-  255, 1279,  767, 1791,  511, 1535, 1023, 2047,
+-};
+-
+-static BROTLI_INLINE void StoreStaticCommandHuffmanTree(
+-    size_t* storage_ix, uint8_t* storage) {
+-  BrotliWriteBits(
+-      56, BROTLI_MAKE_UINT64_T(0x926244U, 0x16307003U), storage_ix, storage);
+-  BrotliWriteBits(3, 0x00000000U, storage_ix, storage);
+-}
+-
+-static const uint16_t kStaticDistanceCodeBits[64] = {
+-   0, 32, 16, 48,  8, 40, 24, 56,  4, 36, 20, 52, 12, 44, 28, 60,
+-   2, 34, 18, 50, 10, 42, 26, 58,  6, 38, 22, 54, 14, 46, 30, 62,
+-   1, 33, 17, 49,  9, 41, 25, 57,  5, 37, 21, 53, 13, 45, 29, 61,
+-   3, 35, 19, 51, 11, 43, 27, 59,  7, 39, 23, 55, 15, 47, 31, 63,
+-};
+-
+-static BROTLI_INLINE void StoreStaticDistanceHuffmanTree(
+-    size_t* storage_ix, uint8_t* storage) {
+-  BrotliWriteBits(28, 0x0369DC03u, storage_ix, storage);
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_ENTROPY_ENCODE_STATIC_H_ */
+diff --git a/modules/brotli/enc/fast_log.c b/modules/brotli/enc/fast_log.c
+deleted file mode 100644
+--- a/modules/brotli/enc/fast_log.c
++++ /dev/null
+@@ -1,105 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-#include "./fast_log.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* ", ".join(["%.16ff" % x for x in [0.0]+[log2(x) for x in range(1, 256)]]) */
+-const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE] = {
+-  0.0000000000000000f, 0.0000000000000000f, 1.0000000000000000f,
+-  1.5849625007211563f, 2.0000000000000000f, 2.3219280948873622f,
+-  2.5849625007211561f, 2.8073549220576042f, 3.0000000000000000f,
+-  3.1699250014423126f, 3.3219280948873626f, 3.4594316186372978f,
+-  3.5849625007211565f, 3.7004397181410922f, 3.8073549220576037f,
+-  3.9068905956085187f, 4.0000000000000000f, 4.0874628412503400f,
+-  4.1699250014423122f, 4.2479275134435852f, 4.3219280948873626f,
+-  4.3923174227787607f, 4.4594316186372973f, 4.5235619560570131f,
+-  4.5849625007211570f, 4.6438561897747244f, 4.7004397181410926f,
+-  4.7548875021634691f, 4.8073549220576037f, 4.8579809951275728f,
+-  4.9068905956085187f, 4.9541963103868758f, 5.0000000000000000f,
+-  5.0443941193584534f, 5.0874628412503400f, 5.1292830169449664f,
+-  5.1699250014423122f, 5.2094533656289501f, 5.2479275134435852f,
+-  5.2854022188622487f, 5.3219280948873626f, 5.3575520046180838f,
+-  5.3923174227787607f, 5.4262647547020979f, 5.4594316186372973f,
+-  5.4918530963296748f, 5.5235619560570131f, 5.5545888516776376f,
+-  5.5849625007211570f, 5.6147098441152083f, 5.6438561897747244f,
+-  5.6724253419714961f, 5.7004397181410926f, 5.7279204545631996f,
+-  5.7548875021634691f, 5.7813597135246599f, 5.8073549220576046f,
+-  5.8328900141647422f, 5.8579809951275719f, 5.8826430493618416f,
+-  5.9068905956085187f, 5.9307373375628867f, 5.9541963103868758f,
+-  5.9772799234999168f, 6.0000000000000000f, 6.0223678130284544f,
+-  6.0443941193584534f, 6.0660891904577721f, 6.0874628412503400f,
+-  6.1085244567781700f, 6.1292830169449672f, 6.1497471195046822f,
+-  6.1699250014423122f, 6.1898245588800176f, 6.2094533656289510f,
+-  6.2288186904958804f, 6.2479275134435861f, 6.2667865406949019f,
+-  6.2854022188622487f, 6.3037807481771031f, 6.3219280948873617f,
+-  6.3398500028846252f, 6.3575520046180847f, 6.3750394313469254f,
+-  6.3923174227787598f, 6.4093909361377026f, 6.4262647547020979f,
+-  6.4429434958487288f, 6.4594316186372982f, 6.4757334309663976f,
+-  6.4918530963296748f, 6.5077946401986964f, 6.5235619560570131f,
+-  6.5391588111080319f, 6.5545888516776376f, 6.5698556083309478f,
+-  6.5849625007211561f, 6.5999128421871278f, 6.6147098441152092f,
+-  6.6293566200796095f, 6.6438561897747253f, 6.6582114827517955f,
+-  6.6724253419714952f, 6.6865005271832185f, 6.7004397181410917f,
+-  6.7142455176661224f, 6.7279204545631988f, 6.7414669864011465f,
+-  6.7548875021634691f, 6.7681843247769260f, 6.7813597135246599f,
+-  6.7944158663501062f, 6.8073549220576037f, 6.8201789624151887f,
+-  6.8328900141647422f, 6.8454900509443757f, 6.8579809951275719f,
+-  6.8703647195834048f, 6.8826430493618416f, 6.8948177633079437f,
+-  6.9068905956085187f, 6.9188632372745955f, 6.9307373375628867f,
+-  6.9425145053392399f, 6.9541963103868758f, 6.9657842846620879f,
+-  6.9772799234999168f, 6.9886846867721664f, 7.0000000000000000f,
+-  7.0112272554232540f, 7.0223678130284544f, 7.0334230015374501f,
+-  7.0443941193584534f, 7.0552824355011898f, 7.0660891904577721f,
+-  7.0768155970508317f, 7.0874628412503400f, 7.0980320829605272f,
+-  7.1085244567781700f, 7.1189410727235076f, 7.1292830169449664f,
+-  7.1395513523987937f, 7.1497471195046822f, 7.1598713367783891f,
+-  7.1699250014423130f, 7.1799090900149345f, 7.1898245588800176f,
+-  7.1996723448363644f, 7.2094533656289492f, 7.2191685204621621f,
+-  7.2288186904958804f, 7.2384047393250794f, 7.2479275134435861f,
+-  7.2573878426926521f, 7.2667865406949019f, 7.2761244052742384f,
+-  7.2854022188622487f, 7.2946207488916270f, 7.3037807481771031f,
+-  7.3128829552843557f, 7.3219280948873617f, 7.3309168781146177f,
+-  7.3398500028846243f, 7.3487281542310781f, 7.3575520046180847f,
+-  7.3663222142458151f, 7.3750394313469254f, 7.3837042924740528f,
+-  7.3923174227787607f, 7.4008794362821844f, 7.4093909361377026f,
+-  7.4178525148858991f, 7.4262647547020979f, 7.4346282276367255f,
+-  7.4429434958487288f, 7.4512111118323299f, 7.4594316186372973f,
+-  7.4676055500829976f, 7.4757334309663976f, 7.4838157772642564f,
+-  7.4918530963296748f, 7.4998458870832057f, 7.5077946401986964f,
+-  7.5156998382840436f, 7.5235619560570131f, 7.5313814605163119f,
+-  7.5391588111080319f, 7.5468944598876373f, 7.5545888516776376f,
+-  7.5622424242210728f, 7.5698556083309478f, 7.5774288280357487f,
+-  7.5849625007211561f, 7.5924570372680806f, 7.5999128421871278f,
+-  7.6073303137496113f, 7.6147098441152075f, 7.6220518194563764f,
+-  7.6293566200796095f, 7.6366246205436488f, 7.6438561897747244f,
+-  7.6510516911789290f, 7.6582114827517955f, 7.6653359171851765f,
+-  7.6724253419714952f, 7.6794800995054464f, 7.6865005271832185f,
+-  7.6934869574993252f, 7.7004397181410926f, 7.7073591320808825f,
+-  7.7142455176661224f, 7.7210991887071856f, 7.7279204545631996f,
+-  7.7347096202258392f, 7.7414669864011465f, 7.7481928495894596f,
+-  7.7548875021634691f, 7.7615512324444795f, 7.7681843247769260f,
+-  7.7747870596011737f, 7.7813597135246608f, 7.7879025593914317f,
+-  7.7944158663501062f, 7.8008998999203047f, 7.8073549220576037f,
+-  7.8137811912170374f, 7.8201789624151887f, 7.8265484872909159f,
+-  7.8328900141647422f, 7.8392037880969445f, 7.8454900509443757f,
+-  7.8517490414160571f, 7.8579809951275719f, 7.8641861446542798f,
+-  7.8703647195834048f, 7.8765169465650002f, 7.8826430493618425f,
+-  7.8887432488982601f, 7.8948177633079446f, 7.9008668079807496f,
+-  7.9068905956085187f, 7.9128893362299619f, 7.9188632372745955f,
+-  7.9248125036057813f, 7.9307373375628867f, 7.9366379390025719f,
+-  7.9425145053392399f, 7.9483672315846778f, 7.9541963103868758f,
+-  7.9600019320680806f, 7.9657842846620870f, 7.9715435539507720f,
+-  7.9772799234999168f, 7.9829935746943104f, 7.9886846867721664f,
+-  7.9943534368588578f
+-};
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/fast_log.h b/modules/brotli/enc/fast_log.h
+deleted file mode 100644
+--- a/modules/brotli/enc/fast_log.h
++++ /dev/null
+@@ -1,66 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Utilities for fast computation of logarithms. */
+-
+-#ifndef BROTLI_ENC_FAST_LOG_H_
+-#define BROTLI_ENC_FAST_LOG_H_
+-
+-#include <math.h>
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static BROTLI_INLINE uint32_t Log2FloorNonZero(size_t n) {
+-#if defined(BROTLI_BSR32)
+-  return BROTLI_BSR32((uint32_t)n);
+-#else
+-  uint32_t result = 0;
+-  while (n >>= 1) result++;
+-  return result;
+-#endif
+-}
+-
+-#define BROTLI_LOG2_TABLE_SIZE 256
+-
+-/* A lookup table for small values of log2(int) to be used in entropy
+-   computation. */
+-BROTLI_INTERNAL extern const double kBrotliLog2Table[BROTLI_LOG2_TABLE_SIZE];
+-
+-/* Visual Studio 2012 and Android API levels < 18 do not have the log2()
+- * function defined, so we use log() and a multiplication instead. */
+-#if !defined(BROTLI_HAVE_LOG2)
+-#if ((defined(_MSC_VER) && _MSC_VER <= 1700) || \
+-     (defined(__ANDROID_API__) && __ANDROID_API__ < 18))
+-#define BROTLI_HAVE_LOG2 0
+-#else
+-#define BROTLI_HAVE_LOG2 1
+-#endif
+-#endif
+-
+-#define LOG_2_INV 1.4426950408889634
+-
+-/* Faster logarithm for small integers, with the property of log2(0) == 0. */
+-static BROTLI_INLINE double FastLog2(size_t v) {
+-  if (v < BROTLI_LOG2_TABLE_SIZE) {
+-    return kBrotliLog2Table[v];
+-  }
+-#if !(BROTLI_HAVE_LOG2)
+-  return log((double)v) * LOG_2_INV;
+-#else
+-  return log2((double)v);
+-#endif
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_FAST_LOG_H_ */
+diff --git a/modules/brotli/enc/find_match_length.h b/modules/brotli/enc/find_match_length.h
+deleted file mode 100644
+--- a/modules/brotli/enc/find_match_length.h
++++ /dev/null
+@@ -1,79 +0,0 @@
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Function to find maximal matching prefixes of strings. */
+-
+-#ifndef BROTLI_ENC_FIND_MATCH_LENGTH_H_
+-#define BROTLI_ENC_FIND_MATCH_LENGTH_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* Separate implementation for little-endian 64-bit targets, for speed. */
+-#if defined(BROTLI_TZCNT64) && BROTLI_64_BITS && BROTLI_LITTLE_ENDIAN
+-static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+-                                                     const uint8_t* s2,
+-                                                     size_t limit) {
+-  size_t matched = 0;
+-  size_t limit2 = (limit >> 3) + 1;  /* + 1 is for pre-decrement in while */
+-  while (BROTLI_PREDICT_TRUE(--limit2)) {
+-    if (BROTLI_PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64LE(s2) ==
+-                      BROTLI_UNALIGNED_LOAD64LE(s1 + matched))) {
+-      s2 += 8;
+-      matched += 8;
+-    } else {
+-      uint64_t x = BROTLI_UNALIGNED_LOAD64LE(s2) ^
+-          BROTLI_UNALIGNED_LOAD64LE(s1 + matched);
+-      size_t matching_bits = (size_t)BROTLI_TZCNT64(x);
+-      matched += matching_bits >> 3;
+-      return matched;
+-    }
+-  }
+-  limit = (limit & 7) + 1;  /* + 1 is for pre-decrement in while */
+-  while (--limit) {
+-    if (BROTLI_PREDICT_TRUE(s1[matched] == *s2)) {
+-      ++s2;
+-      ++matched;
+-    } else {
+-      return matched;
+-    }
+-  }
+-  return matched;
+-}
+-#else
+-static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+-                                                     const uint8_t* s2,
+-                                                     size_t limit) {
+-  size_t matched = 0;
+-  const uint8_t* s2_limit = s2 + limit;
+-  const uint8_t* s2_ptr = s2;
+-  /* Find out how long the match is. We loop over the data 32 bits at a
+-     time until we find a 32-bit block that doesn't match; then we find
+-     the first non-matching bit and use that to calculate the total
+-     length of the match. */
+-  while (s2_ptr <= s2_limit - 4 &&
+-         BrotliUnalignedRead32(s2_ptr) ==
+-         BrotliUnalignedRead32(s1 + matched)) {
+-    s2_ptr += 4;
+-    matched += 4;
+-  }
+-  while ((s2_ptr < s2_limit) && (s1[matched] == *s2_ptr)) {
+-    ++s2_ptr;
+-    ++matched;
+-  }
+-  return matched;
+-}
+-#endif
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_FIND_MATCH_LENGTH_H_ */
+diff --git a/modules/brotli/enc/hash.h b/modules/brotli/enc/hash.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash.h
++++ /dev/null
+@@ -1,488 +0,0 @@
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* A (forgetful) hash table to the data seen by the compressor, to
+-   help create backward references to previous data. */
+-
+-#ifndef BROTLI_ENC_HASH_H_
+-#define BROTLI_ENC_HASH_H_
+-
+-#include <string.h>  /* memcmp, memset */
+-
+-#include "../common/constants.h"
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./encoder_dict.h"
+-#include "./fast_log.h"
+-#include "./find_match_length.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-#include "./static_dict.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct {
+-  /* Dynamically allocated area; first member for quickest access. */
+-  void* extra;
+-
+-  size_t dict_num_lookups;
+-  size_t dict_num_matches;
+-
+-  BrotliHasherParams params;
+-
+-  /* False if hasher needs to be "prepared" before use. */
+-  BROTLI_BOOL is_prepared_;
+-} HasherCommon;
+-
+-#define score_t size_t
+-
+-static const uint32_t kCutoffTransformsCount = 10;
+-/*   0,  12,   27,    23,    42,    63,    56,    48,    59,    64 */
+-/* 0+0, 4+8, 8+19, 12+11, 16+26, 20+43, 24+32, 28+20, 32+27, 36+28 */
+-static const uint64_t kCutoffTransforms =
+-    BROTLI_MAKE_UINT64_T(0x071B520A, 0xDA2D3200);
+-
+-typedef struct HasherSearchResult {
+-  size_t len;
+-  size_t distance;
+-  score_t score;
+-  int len_code_delta; /* == len_code - len */
+-} HasherSearchResult;
+-
+-/* kHashMul32 multiplier has these properties:
+-   * The multiplier must be odd. Otherwise we may lose the highest bit.
+-   * No long streaks of ones or zeros.
+-   * There is no effort to ensure that it is a prime, the oddity is enough
+-     for this use.
+-   * The number has been tuned heuristically against compression benchmarks. */
+-static const uint32_t kHashMul32 = 0x1E35A7BD;
+-static const uint64_t kHashMul64 = BROTLI_MAKE_UINT64_T(0x1E35A7BD, 0x1E35A7BD);
+-static const uint64_t kHashMul64Long =
+-    BROTLI_MAKE_UINT64_T(0x1FE35A7Bu, 0xD3579BD3u);
+-
+-static BROTLI_INLINE uint32_t Hash14(const uint8_t* data) {
+-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return h >> (32 - 14);
+-}
+-
+-static BROTLI_INLINE void PrepareDistanceCache(
+-    int* BROTLI_RESTRICT distance_cache, const int num_distances) {
+-  if (num_distances > 4) {
+-    int last_distance = distance_cache[0];
+-    distance_cache[4] = last_distance - 1;
+-    distance_cache[5] = last_distance + 1;
+-    distance_cache[6] = last_distance - 2;
+-    distance_cache[7] = last_distance + 2;
+-    distance_cache[8] = last_distance - 3;
+-    distance_cache[9] = last_distance + 3;
+-    if (num_distances > 10) {
+-      int next_last_distance = distance_cache[1];
+-      distance_cache[10] = next_last_distance - 1;
+-      distance_cache[11] = next_last_distance + 1;
+-      distance_cache[12] = next_last_distance - 2;
+-      distance_cache[13] = next_last_distance + 2;
+-      distance_cache[14] = next_last_distance - 3;
+-      distance_cache[15] = next_last_distance + 3;
+-    }
+-  }
+-}
+-
+-#define BROTLI_LITERAL_BYTE_SCORE 135
+-#define BROTLI_DISTANCE_BIT_PENALTY 30
+-/* Score must be positive after applying maximal penalty. */
+-#define BROTLI_SCORE_BASE (BROTLI_DISTANCE_BIT_PENALTY * 8 * sizeof(size_t))
+-
+-/* Usually, we always choose the longest backward reference. This function
+-   allows for the exception of that rule.
+-
+-   If we choose a backward reference that is further away, it will
+-   usually be coded with more bits. We approximate this by assuming
+-   log2(distance). If the distance can be expressed in terms of the
+-   last four distances, we use some heuristic constants to estimate
+-   the bits cost. For the first up to four literals we use the bit
+-   cost of the literals from the literal cost model, after that we
+-   use the average bit cost of the cost model.
+-
+-   This function is used to sometimes discard a longer backward reference
+-   when it is not much longer and the bit cost for encoding it is more
+-   than the saved literals.
+-
+-   backward_reference_offset MUST be positive. */
+-static BROTLI_INLINE score_t BackwardReferenceScore(
+-    size_t copy_length, size_t backward_reference_offset) {
+-  return BROTLI_SCORE_BASE + BROTLI_LITERAL_BYTE_SCORE * (score_t)copy_length -
+-      BROTLI_DISTANCE_BIT_PENALTY * Log2FloorNonZero(backward_reference_offset);
+-}
+-
+-static BROTLI_INLINE score_t BackwardReferenceScoreUsingLastDistance(
+-    size_t copy_length) {
+-  return BROTLI_LITERAL_BYTE_SCORE * (score_t)copy_length +
+-      BROTLI_SCORE_BASE + 15;
+-}
+-
+-static BROTLI_INLINE score_t BackwardReferencePenaltyUsingLastDistance(
+-    size_t distance_short_code) {
+-  return (score_t)39 + ((0x1CA10 >> (distance_short_code & 0xE)) & 0xE);
+-}
+-
+-static BROTLI_INLINE BROTLI_BOOL TestStaticDictionaryItem(
+-    const BrotliEncoderDictionary* dictionary, size_t len, size_t word_idx,
+-    const uint8_t* data, size_t max_length, size_t max_backward,
+-    size_t max_distance, HasherSearchResult* out) {
+-  size_t offset;
+-  size_t matchlen;
+-  size_t backward;
+-  score_t score;
+-  offset = dictionary->words->offsets_by_length[len] + len * word_idx;
+-  if (len > max_length) {
+-    return BROTLI_FALSE;
+-  }
+-
+-  matchlen =
+-      FindMatchLengthWithLimit(data, &dictionary->words->data[offset], len);
+-  if (matchlen + dictionary->cutoffTransformsCount <= len || matchlen == 0) {
+-    return BROTLI_FALSE;
+-  }
+-  {
+-    size_t cut = len - matchlen;
+-    size_t transform_id = (cut << 2) +
+-        (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
+-    backward = max_backward + 1 + word_idx +
+-        (transform_id << dictionary->words->size_bits_by_length[len]);
+-  }
+-  if (backward > max_distance) {
+-    return BROTLI_FALSE;
+-  }
+-  score = BackwardReferenceScore(matchlen, backward);
+-  if (score < out->score) {
+-    return BROTLI_FALSE;
+-  }
+-  out->len = matchlen;
+-  out->len_code_delta = (int)len - (int)matchlen;
+-  out->distance = backward;
+-  out->score = score;
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_INLINE void SearchInStaticDictionary(
+-    const BrotliEncoderDictionary* dictionary,
+-    HasherCommon* common, const uint8_t* data, size_t max_length,
+-    size_t max_backward, size_t max_distance,
+-    HasherSearchResult* out, BROTLI_BOOL shallow) {
+-  size_t key;
+-  size_t i;
+-  if (common->dict_num_matches < (common->dict_num_lookups >> 7)) {
+-    return;
+-  }
+-  key = Hash14(data) << 1;
+-  for (i = 0; i < (shallow ? 1u : 2u); ++i, ++key) {
+-    common->dict_num_lookups++;
+-    if (dictionary->hash_table_lengths[key] != 0) {
+-      BROTLI_BOOL item_matches = TestStaticDictionaryItem(
+-          dictionary, dictionary->hash_table_lengths[key],
+-          dictionary->hash_table_words[key], data,
+-          max_length, max_backward, max_distance, out);
+-      if (item_matches) {
+-        common->dict_num_matches++;
+-      }
+-    }
+-  }
+-}
+-
+-typedef struct BackwardMatch {
+-  uint32_t distance;
+-  uint32_t length_and_code;
+-} BackwardMatch;
+-
+-static BROTLI_INLINE void InitBackwardMatch(BackwardMatch* self,
+-    size_t dist, size_t len) {
+-  self->distance = (uint32_t)dist;
+-  self->length_and_code = (uint32_t)(len << 5);
+-}
+-
+-static BROTLI_INLINE void InitDictionaryBackwardMatch(BackwardMatch* self,
+-    size_t dist, size_t len, size_t len_code) {
+-  self->distance = (uint32_t)dist;
+-  self->length_and_code =
+-      (uint32_t)((len << 5) | (len == len_code ? 0 : len_code));
+-}
+-
+-static BROTLI_INLINE size_t BackwardMatchLength(const BackwardMatch* self) {
+-  return self->length_and_code >> 5;
+-}
+-
+-static BROTLI_INLINE size_t BackwardMatchLengthCode(const BackwardMatch* self) {
+-  size_t code = self->length_and_code & 31;
+-  return code ? code : BackwardMatchLength(self);
+-}
+-
+-#define EXPAND_CAT(a, b) CAT(a, b)
+-#define CAT(a, b) a ## b
+-#define FN(X) EXPAND_CAT(X, HASHER())
+-
+-#define HASHER() H10
+-#define BUCKET_BITS 17
+-#define MAX_TREE_SEARCH_DEPTH 64
+-#define MAX_TREE_COMP_LENGTH 128
+-#include "./hash_to_binary_tree_inc.h"  /* NOLINT(build/include) */
+-#undef MAX_TREE_SEARCH_DEPTH
+-#undef MAX_TREE_COMP_LENGTH
+-#undef BUCKET_BITS
+-#undef HASHER
+-/* MAX_NUM_MATCHES == 64 + MAX_TREE_SEARCH_DEPTH */
+-#define MAX_NUM_MATCHES_H10 128
+-
+-/* For BUCKET_SWEEP_BITS == 0, enabling the dictionary lookup makes compression
+-   a little faster (0.5% - 1%) and it compresses 0.15% better on small text
+-   and HTML inputs. */
+-
+-#define HASHER() H2
+-#define BUCKET_BITS 16
+-#define BUCKET_SWEEP_BITS 0
+-#define HASH_LEN 5
+-#define USE_DICTIONARY 1
+-#include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
+-#undef BUCKET_SWEEP_BITS
+-#undef USE_DICTIONARY
+-#undef HASHER
+-
+-#define HASHER() H3
+-#define BUCKET_SWEEP_BITS 1
+-#define USE_DICTIONARY 0
+-#include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
+-#undef USE_DICTIONARY
+-#undef BUCKET_SWEEP_BITS
+-#undef BUCKET_BITS
+-#undef HASHER
+-
+-#define HASHER() H4
+-#define BUCKET_BITS 17
+-#define BUCKET_SWEEP_BITS 2
+-#define USE_DICTIONARY 1
+-#include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
+-#undef USE_DICTIONARY
+-#undef HASH_LEN
+-#undef BUCKET_SWEEP_BITS
+-#undef BUCKET_BITS
+-#undef HASHER
+-
+-#define HASHER() H5
+-#include "./hash_longest_match_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER
+-
+-#define HASHER() H6
+-#include "./hash_longest_match64_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER
+-
+-#define BUCKET_BITS 15
+-
+-#define NUM_LAST_DISTANCES_TO_CHECK 4
+-#define NUM_BANKS 1
+-#define BANK_BITS 16
+-#define HASHER() H40
+-#include "./hash_forgetful_chain_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER
+-#undef NUM_LAST_DISTANCES_TO_CHECK
+-
+-#define NUM_LAST_DISTANCES_TO_CHECK 10
+-#define HASHER() H41
+-#include "./hash_forgetful_chain_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER
+-#undef NUM_LAST_DISTANCES_TO_CHECK
+-#undef NUM_BANKS
+-#undef BANK_BITS
+-
+-#define NUM_LAST_DISTANCES_TO_CHECK 16
+-#define NUM_BANKS 512
+-#define BANK_BITS 9
+-#define HASHER() H42
+-#include "./hash_forgetful_chain_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER
+-#undef NUM_LAST_DISTANCES_TO_CHECK
+-#undef NUM_BANKS
+-#undef BANK_BITS
+-
+-#undef BUCKET_BITS
+-
+-#define HASHER() H54
+-#define BUCKET_BITS 20
+-#define BUCKET_SWEEP_BITS 2
+-#define HASH_LEN 7
+-#define USE_DICTIONARY 0
+-#include "./hash_longest_match_quickly_inc.h"  /* NOLINT(build/include) */
+-#undef USE_DICTIONARY
+-#undef HASH_LEN
+-#undef BUCKET_SWEEP_BITS
+-#undef BUCKET_BITS
+-#undef HASHER
+-
+-/* fast large window hashers */
+-
+-#define HASHER() HROLLING_FAST
+-#define CHUNKLEN 32
+-#define JUMP 4
+-#define NUMBUCKETS 16777216
+-#define MASK ((NUMBUCKETS * 64) - 1)
+-#include "./hash_rolling_inc.h"  /* NOLINT(build/include) */
+-#undef JUMP
+-#undef HASHER
+-
+-
+-#define HASHER() HROLLING
+-#define JUMP 1
+-#include "./hash_rolling_inc.h"  /* NOLINT(build/include) */
+-#undef MASK
+-#undef NUMBUCKETS
+-#undef JUMP
+-#undef CHUNKLEN
+-#undef HASHER
+-
+-#define HASHER() H35
+-#define HASHER_A H3
+-#define HASHER_B HROLLING_FAST
+-#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER_A
+-#undef HASHER_B
+-#undef HASHER
+-
+-#define HASHER() H55
+-#define HASHER_A H54
+-#define HASHER_B HROLLING_FAST
+-#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER_A
+-#undef HASHER_B
+-#undef HASHER
+-
+-#define HASHER() H65
+-#define HASHER_A H6
+-#define HASHER_B HROLLING
+-#include "./hash_composite_inc.h"  /* NOLINT(build/include) */
+-#undef HASHER_A
+-#undef HASHER_B
+-#undef HASHER
+-
+-#undef FN
+-#undef CAT
+-#undef EXPAND_CAT
+-
+-#define FOR_SIMPLE_HASHERS(H) H(2) H(3) H(4) H(5) H(6) H(40) H(41) H(42) H(54)
+-#define FOR_COMPOSITE_HASHERS(H) H(35) H(55) H(65)
+-#define FOR_GENERIC_HASHERS(H) FOR_SIMPLE_HASHERS(H) FOR_COMPOSITE_HASHERS(H)
+-#define FOR_ALL_HASHERS(H) FOR_GENERIC_HASHERS(H) H(10)
+-
+-typedef struct {
+-  HasherCommon common;
+-
+-  union {
+-#define MEMBER_(N) \
+-    H ## N _H ## N;
+-    FOR_ALL_HASHERS(MEMBER_)
+-#undef MEMBER_
+-  } privat;
+-} Hasher;
+-
+-/* MUST be invoked before any other method. */
+-static BROTLI_INLINE void HasherInit(Hasher* hasher) {
+-  hasher->common.extra = NULL;
+-}
+-
+-static BROTLI_INLINE void DestroyHasher(MemoryManager* m, Hasher* hasher) {
+-  if (hasher->common.extra == NULL) return;
+-  BROTLI_FREE(m, hasher->common.extra);
+-}
+-
+-static BROTLI_INLINE void HasherReset(Hasher* hasher) {
+-  hasher->common.is_prepared_ = BROTLI_FALSE;
+-}
+-
+-static BROTLI_INLINE size_t HasherSize(const BrotliEncoderParams* params,
+-    BROTLI_BOOL one_shot, const size_t input_size) {
+-  switch (params->hasher.type) {
+-#define SIZE_(N)                                                      \
+-    case N:                                                           \
+-      return HashMemAllocInBytesH ## N(params, one_shot, input_size);
+-    FOR_ALL_HASHERS(SIZE_)
+-#undef SIZE_
+-    default:
+-      break;
+-  }
+-  return 0;  /* Default case. */
+-}
+-
+-static BROTLI_INLINE void HasherSetup(MemoryManager* m, Hasher* hasher,
+-    BrotliEncoderParams* params, const uint8_t* data, size_t position,
+-    size_t input_size, BROTLI_BOOL is_last) {
+-  BROTLI_BOOL one_shot = (position == 0 && is_last);
+-  if (hasher->common.extra == NULL) {
+-    size_t alloc_size;
+-    ChooseHasher(params, &params->hasher);
+-    alloc_size = HasherSize(params, one_shot, input_size);
+-    hasher->common.extra = BROTLI_ALLOC(m, uint8_t, alloc_size);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(hasher->common.extra)) return;
+-    hasher->common.params = params->hasher;
+-    switch (hasher->common.params.type) {
+-#define INITIALIZE_(N)                        \
+-      case N:                                 \
+-        InitializeH ## N(&hasher->common,     \
+-            &hasher->privat._H ## N, params); \
+-        break;
+-      FOR_ALL_HASHERS(INITIALIZE_);
+-#undef INITIALIZE_
+-      default:
+-        break;
+-    }
+-    HasherReset(hasher);
+-  }
+-
+-  if (!hasher->common.is_prepared_) {
+-    switch (hasher->common.params.type) {
+-#define PREPARE_(N)                      \
+-      case N:                            \
+-        PrepareH ## N(                   \
+-            &hasher->privat._H ## N,     \
+-            one_shot, input_size, data); \
+-        break;
+-      FOR_ALL_HASHERS(PREPARE_)
+-#undef PREPARE_
+-      default: break;
+-    }
+-    if (position == 0) {
+-      hasher->common.dict_num_lookups = 0;
+-      hasher->common.dict_num_matches = 0;
+-    }
+-    hasher->common.is_prepared_ = BROTLI_TRUE;
+-  }
+-}
+-
+-static BROTLI_INLINE void InitOrStitchToPreviousBlock(
+-    MemoryManager* m, Hasher* hasher, const uint8_t* data, size_t mask,
+-    BrotliEncoderParams* params, size_t position, size_t input_size,
+-    BROTLI_BOOL is_last) {
+-  HasherSetup(m, hasher, params, data, position, input_size, is_last);
+-  if (BROTLI_IS_OOM(m)) return;
+-  switch (hasher->common.params.type) {
+-#define INIT_(N)                             \
+-    case N:                                  \
+-      StitchToPreviousBlockH ## N(           \
+-          &hasher->privat._H ## N,           \
+-          input_size, position, data, mask); \
+-    break;
+-    FOR_ALL_HASHERS(INIT_)
+-#undef INIT_
+-    default: break;
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_HASH_H_ */
+diff --git a/modules/brotli/enc/hash_composite_inc.h b/modules/brotli/enc/hash_composite_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_composite_inc.h
++++ /dev/null
+@@ -1,125 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2018 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, HASHER_A, HASHER_B */
+-
+-/* Composite hasher: This hasher allows to combine two other hashers, HASHER_A
+-   and HASHER_B. */
+-
+-#define HashComposite HASHER()
+-
+-#define FN_A(X) EXPAND_CAT(X, HASHER_A)
+-#define FN_B(X) EXPAND_CAT(X, HASHER_B)
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) {
+-  size_t a =  FN_A(HashTypeLength)();
+-  size_t b =  FN_B(HashTypeLength)();
+-  return a > b ? a : b;
+-}
+-
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
+-  size_t a =  FN_A(StoreLookahead)();
+-  size_t b =  FN_B(StoreLookahead)();
+-  return a > b ? a : b;
+-}
+-
+-typedef struct HashComposite {
+-  HASHER_A ha;
+-  HASHER_B hb;
+-  HasherCommon hb_common;
+-
+-  /* Shortcuts. */
+-  void* extra;
+-  HasherCommon* common;
+-
+-  BROTLI_BOOL fresh;
+-  const BrotliEncoderParams* params;
+-} HashComposite;
+-
+-static void FN(Initialize)(HasherCommon* common,
+-    HashComposite* BROTLI_RESTRICT self, const BrotliEncoderParams* params) {
+-  self->common = common;
+-  self->extra = common->extra;
+-
+-  self->hb_common = *self->common;
+-  self->fresh = BROTLI_TRUE;
+-  self->params = params;
+-  /* TODO: Initialize of the hashers is defered to Prepare (and params
+-     remembered here) because we don't get the one_shot and input_size params
+-     here that are needed to know the memory size of them. Instead provide
+-     those params to all hashers FN(Initialize) */
+-}
+-
+-static void FN(Prepare)(
+-    HashComposite* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  if (self->fresh) {
+-    self->fresh = BROTLI_FALSE;
+-    self->hb_common.extra = (uint8_t*)self->extra +
+-        FN_A(HashMemAllocInBytes)(self->params, one_shot, input_size);
+-
+-    FN_A(Initialize)(self->common, &self->ha, self->params);
+-    FN_B(Initialize)(&self->hb_common, &self->hb, self->params);
+-  }
+-  FN_A(Prepare)(&self->ha, one_shot, input_size, data);
+-  FN_B(Prepare)(&self->hb, one_shot, input_size, data);
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  return FN_A(HashMemAllocInBytes)(params, one_shot, input_size) +
+-      FN_B(HashMemAllocInBytes)(params, one_shot, input_size);
+-}
+-
+-static BROTLI_INLINE void FN(Store)(HashComposite* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+-  FN_A(Store)(&self->ha, data, mask, ix);
+-  FN_B(Store)(&self->hb, data, mask, ix);
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(
+-    HashComposite* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+-    const size_t mask, const size_t ix_start,
+-    const size_t ix_end) {
+-  FN_A(StoreRange)(&self->ha, data, mask, ix_start, ix_end);
+-  FN_B(StoreRange)(&self->hb, data, mask, ix_start, ix_end);
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashComposite* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ring_buffer_mask) {
+-  FN_A(StitchToPreviousBlock)(&self->ha, num_bytes, position,
+-      ringbuffer, ring_buffer_mask);
+-  FN_B(StitchToPreviousBlock)(&self->hb, num_bytes, position,
+-      ringbuffer, ring_buffer_mask);
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashComposite* BROTLI_RESTRICT self, int* BROTLI_RESTRICT distance_cache) {
+-  FN_A(PrepareDistanceCache)(&self->ha, distance_cache);
+-  FN_B(PrepareDistanceCache)(&self->hb, distance_cache);
+-}
+-
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashComposite* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+-    const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  FN_A(FindLongestMatch)(&self->ha, dictionary, data, ring_buffer_mask,
+-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
+-      max_distance, out);
+-  FN_B(FindLongestMatch)(&self->hb, dictionary, data, ring_buffer_mask,
+-      distance_cache, cur_ix, max_length, max_backward, dictionary_distance,
+-      max_distance, out);
+-}
+-
+-#undef HashComposite
+diff --git a/modules/brotli/enc/hash_forgetful_chain_inc.h b/modules/brotli/enc/hash_forgetful_chain_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_forgetful_chain_inc.h
++++ /dev/null
+@@ -1,293 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2016 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, BUCKET_BITS, NUM_BANKS, BANK_BITS,
+-                        NUM_LAST_DISTANCES_TO_CHECK */
+-
+-/* A (forgetful) hash table to the data seen by the compressor, to
+-   help create backward references to previous data.
+-
+-   Hashes are stored in chains which are bucketed to groups. Group of chains
+-   share a storage "bank". When more than "bank size" chain nodes are added,
+-   oldest nodes are replaced; this way several chains may share a tail. */
+-
+-#define HashForgetfulChain HASHER()
+-
+-#define BANK_SIZE (1 << BANK_BITS)
+-
+-/* Number of hash buckets. */
+-#define BUCKET_SIZE (1 << BUCKET_BITS)
+-
+-#define CAPPED_CHAINS 0
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
+-
+-/* HashBytes is the function that chooses the bucket to place the address in.*/
+-static BROTLI_INLINE size_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
+-  const uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return h >> (32 - BUCKET_BITS);
+-}
+-
+-typedef struct FN(Slot) {
+-  uint16_t delta;
+-  uint16_t next;
+-} FN(Slot);
+-
+-typedef struct FN(Bank) {
+-  FN(Slot) slots[BANK_SIZE];
+-} FN(Bank);
+-
+-typedef struct HashForgetfulChain {
+-  uint16_t free_slot_idx[NUM_BANKS];  /* Up to 1KiB. Move to dynamic? */
+-  size_t max_hops;
+-
+-  /* Shortcuts. */
+-  void* extra;
+-  HasherCommon* common;
+-
+-  /* --- Dynamic size members --- */
+-
+-  /* uint32_t addr[BUCKET_SIZE]; */
+-
+-  /* uint16_t head[BUCKET_SIZE]; */
+-
+-  /* Truncated hash used for quick rejection of "distance cache" candidates. */
+-  /* uint8_t tiny_hash[65536];*/
+-
+-  /* FN(Bank) banks[NUM_BANKS]; */
+-} HashForgetfulChain;
+-
+-static uint32_t* FN(Addr)(void* extra) {
+-  return (uint32_t*)extra;
+-}
+-
+-static uint16_t* FN(Head)(void* extra) {
+-  return (uint16_t*)(&FN(Addr)(extra)[BUCKET_SIZE]);
+-}
+-
+-static uint8_t* FN(TinyHash)(void* extra) {
+-  return (uint8_t*)(&FN(Head)(extra)[BUCKET_SIZE]);
+-}
+-
+-static FN(Bank)* FN(Banks)(void* extra) {
+-  return (FN(Bank)*)(&FN(TinyHash)(extra)[65536]);
+-}
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashForgetfulChain* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  self->common = common;
+-  self->extra = common->extra;
+-
+-  self->max_hops = (params->quality > 6 ? 7u : 8u) << (params->quality - 4);
+-}
+-
+-static void FN(Prepare)(
+-    HashForgetfulChain* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra);
+-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra);
+-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra);
+-  /* Partial preparation is 100 times slower (per socket). */
+-  size_t partial_prepare_threshold = BUCKET_SIZE >> 6;
+-  if (one_shot && input_size <= partial_prepare_threshold) {
+-    size_t i;
+-    for (i = 0; i < input_size; ++i) {
+-      size_t bucket = FN(HashBytes)(&data[i]);
+-      /* See InitEmpty comment. */
+-      addr[bucket] = 0xCCCCCCCC;
+-      head[bucket] = 0xCCCC;
+-    }
+-  } else {
+-    /* Fill |addr| array with 0xCCCCCCCC value. Because of wrapping, position
+-       processed by hasher never reaches 3GB + 64M; this makes all new chains
+-       to be terminated after the first node. */
+-    memset(addr, 0xCC, sizeof(uint32_t) * BUCKET_SIZE);
+-    memset(head, 0, sizeof(uint16_t) * BUCKET_SIZE);
+-  }
+-  memset(tiny_hash, 0, sizeof(uint8_t) * 65536);
+-  memset(self->free_slot_idx, 0, sizeof(self->free_slot_idx));
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  BROTLI_UNUSED(params);
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-  return sizeof(uint32_t) * BUCKET_SIZE + sizeof(uint16_t) * BUCKET_SIZE +
+-         sizeof(uint8_t) * 65536 + sizeof(FN(Bank)) * NUM_BANKS;
+-}
+-
+-/* Look at 4 bytes at &data[ix & mask]. Compute a hash from these, and prepend
+-   node to corresponding chain; also update tiny_hash for current position. */
+-static BROTLI_INLINE void FN(Store)(HashForgetfulChain* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra);
+-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra);
+-  uint8_t* BROTLI_RESTRICT tiny_hash = FN(TinyHash)(self->extra);
+-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra);
+-  const size_t key = FN(HashBytes)(&data[ix & mask]);
+-  const size_t bank = key & (NUM_BANKS - 1);
+-  const size_t idx = self->free_slot_idx[bank]++ & (BANK_SIZE - 1);
+-  size_t delta = ix - addr[key];
+-  tiny_hash[(uint16_t)ix] = (uint8_t)key;
+-  if (delta > 0xFFFF) delta = CAPPED_CHAINS ? 0 : 0xFFFF;
+-  banks[bank].slots[idx].delta = (uint16_t)delta;
+-  banks[bank].slots[idx].next = head[key];
+-  addr[key] = (uint32_t)ix;
+-  head[key] = (uint16_t)idx;
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(
+-    HashForgetfulChain* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  size_t i;
+-  for (i = ix_start; i < ix_end; ++i) {
+-    FN(Store)(self, data, mask, i);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashForgetfulChain* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ring_buffer_mask) {
+-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
+-    /* Prepare the hashes for three last bytes of the last write.
+-       These could not be calculated before, since they require knowledge
+-       of both the previous and the current block. */
+-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 3);
+-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 2);
+-    FN(Store)(self, ringbuffer, ring_buffer_mask, position - 1);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashForgetfulChain* BROTLI_RESTRICT self,
+-    int* BROTLI_RESTRICT distance_cache) {
+-  BROTLI_UNUSED(self);
+-  PrepareDistanceCache(distance_cache, NUM_LAST_DISTANCES_TO_CHECK);
+-}
+-
+-/* Find a longest backward match of &data[cur_ix] up to the length of
+-   max_length and stores the position cur_ix in the hash table.
+-
+-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
+-             values; if this method is invoked repeatedly with the same distance
+-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
+-
+-   Does not look for matches longer than max_length.
+-   Does not look for matches further away than max_backward.
+-   Writes the best match into |out|.
+-   |out|->score is updated only if a better match is found. */
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashForgetfulChain* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+-    const int* BROTLI_RESTRICT distance_cache,
+-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  uint32_t* BROTLI_RESTRICT addr = FN(Addr)(self->extra);
+-  uint16_t* BROTLI_RESTRICT head = FN(Head)(self->extra);
+-  uint8_t* BROTLI_RESTRICT tiny_hashes = FN(TinyHash)(self->extra);
+-  FN(Bank)* BROTLI_RESTRICT banks = FN(Banks)(self->extra);
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  /* Don't accept a short copy from far away. */
+-  score_t min_score = out->score;
+-  score_t best_score = out->score;
+-  size_t best_len = out->len;
+-  size_t i;
+-  const size_t key = FN(HashBytes)(&data[cur_ix_masked]);
+-  const uint8_t tiny_hash = (uint8_t)(key);
+-  out->len = 0;
+-  out->len_code_delta = 0;
+-  /* Try last distance first. */
+-  for (i = 0; i < NUM_LAST_DISTANCES_TO_CHECK; ++i) {
+-    const size_t backward = (size_t)distance_cache[i];
+-    size_t prev_ix = (cur_ix - backward);
+-    /* For distance code 0 we want to consider 2-byte matches. */
+-    if (i > 0 && tiny_hashes[(uint16_t)prev_ix] != tiny_hash) continue;
+-    if (prev_ix >= cur_ix || backward > max_backward) {
+-      continue;
+-    }
+-    prev_ix &= ring_buffer_mask;
+-    {
+-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                  &data[cur_ix_masked],
+-                                                  max_length);
+-      if (len >= 2) {
+-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
+-        if (best_score < score) {
+-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-  }
+-  {
+-    const size_t bank = key & (NUM_BANKS - 1);
+-    size_t backward = 0;
+-    size_t hops = self->max_hops;
+-    size_t delta = cur_ix - addr[key];
+-    size_t slot = head[key];
+-    while (hops--) {
+-      size_t prev_ix;
+-      size_t last = slot;
+-      backward += delta;
+-      if (backward > max_backward || (CAPPED_CHAINS && !delta)) break;
+-      prev_ix = (cur_ix - backward) & ring_buffer_mask;
+-      slot = banks[bank].slots[last].next;
+-      delta = banks[bank].slots[last].delta;
+-      if (cur_ix_masked + best_len > ring_buffer_mask ||
+-          prev_ix + best_len > ring_buffer_mask ||
+-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+-        continue;
+-      }
+-      {
+-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                    &data[cur_ix_masked],
+-                                                    max_length);
+-        if (len >= 4) {
+-          /* Comparing for >= 3 does not change the semantics, but just saves
+-             for a few unnecessary binary logarithms in backward reference
+-             score, since we are not interested in such short matches. */
+-          score_t score = BackwardReferenceScore(len, backward);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-    FN(Store)(self, data, ring_buffer_mask, cur_ix);
+-  }
+-  if (out->score == min_score) {
+-    SearchInStaticDictionary(dictionary,
+-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
+-        max_distance, out, BROTLI_FALSE);
+-  }
+-}
+-
+-#undef BANK_SIZE
+-#undef BUCKET_SIZE
+-#undef CAPPED_CHAINS
+-
+-#undef HashForgetfulChain
+diff --git a/modules/brotli/enc/hash_longest_match64_inc.h b/modules/brotli/enc/hash_longest_match64_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_longest_match64_inc.h
++++ /dev/null
+@@ -1,267 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN */
+-
+-/* A (forgetful) hash table to the data seen by the compressor, to
+-   help create backward references to previous data.
+-
+-   This is a hash map of fixed size (bucket_size_) to a ring buffer of
+-   fixed size (block_size_). The ring buffer contains the last block_size_
+-   index positions of the given hash key in the compressed data. */
+-
+-#define HashLongestMatch HASHER()
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
+-
+-/* HashBytes is the function that chooses the bucket to place the address in. */
+-static BROTLI_INLINE uint32_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data,
+-                                            const uint64_t mask,
+-                                            const int shift) {
+-  const uint64_t h = (BROTLI_UNALIGNED_LOAD64LE(data) & mask) * kHashMul64Long;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return (uint32_t)(h >> shift);
+-}
+-
+-typedef struct HashLongestMatch {
+-  /* Number of hash buckets. */
+-  size_t bucket_size_;
+-  /* Only block_size_ newest backward references are kept,
+-     and the older are forgotten. */
+-  size_t block_size_;
+-  /* Left-shift for computing hash bucket index from hash value. */
+-  int hash_shift_;
+-  /* Mask for selecting the next 4-8 bytes of input */
+-  uint64_t hash_mask_;
+-  /* Mask for accessing entries in a block (in a ring-buffer manner). */
+-  uint32_t block_mask_;
+-
+-  int block_bits_;
+-  int num_last_distances_to_check_;
+-
+-  /* Shortcuts. */
+-  HasherCommon* common_;
+-
+-  /* --- Dynamic size members --- */
+-
+-  /* Number of entries in a particular bucket. */
+-  uint16_t* num_;  /* uint16_t[bucket_size]; */
+-
+-  /* Buckets containing block_size_ of backward references. */
+-  uint32_t* buckets_;  /* uint32_t[bucket_size * block_size]; */
+-} HashLongestMatch;
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  self->common_ = common;
+-
+-  BROTLI_UNUSED(params);
+-  self->hash_shift_ = 64 - common->params.bucket_bits;
+-  self->hash_mask_ = (~((uint64_t)0U)) >> (64 - 8 * common->params.hash_len);
+-  self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
+-  self->block_bits_ = common->params.block_bits;
+-  self->block_size_ = (size_t)1 << common->params.block_bits;
+-  self->block_mask_ = (uint32_t)(self->block_size_ - 1);
+-  self->num_last_distances_to_check_ =
+-      common->params.num_last_distances_to_check;
+-  self->num_ = (uint16_t*)common->extra;
+-  self->buckets_ = (uint32_t*)&self->num_[self->bucket_size_];
+-}
+-
+-static void FN(Prepare)(
+-    HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  uint16_t* BROTLI_RESTRICT num = self->num_;
+-  /* Partial preparation is 100 times slower (per socket). */
+-  size_t partial_prepare_threshold = self->bucket_size_ >> 6;
+-  if (one_shot && input_size <= partial_prepare_threshold) {
+-    size_t i;
+-    for (i = 0; i < input_size; ++i) {
+-      const uint32_t key = FN(HashBytes)(&data[i], self->hash_mask_,
+-                                         self->hash_shift_);
+-      num[key] = 0;
+-    }
+-  } else {
+-    memset(num, 0, self->bucket_size_ * sizeof(num[0]));
+-  }
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
+-  size_t block_size = (size_t)1 << params->hasher.block_bits;
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-  return sizeof(uint16_t) * bucket_size +
+-         sizeof(uint32_t) * bucket_size * block_size;
+-}
+-
+-/* Look at 4 bytes at &data[ix & mask].
+-   Compute a hash from these, and store the value of ix at that position. */
+-static BROTLI_INLINE void FN(Store)(
+-    HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+-    const size_t mask, const size_t ix) {
+-  uint16_t* BROTLI_RESTRICT num = self->num_;
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  const uint32_t key = FN(HashBytes)(&data[ix & mask], self->hash_mask_,
+-                                     self->hash_shift_);
+-  const size_t minor_ix = num[key] & self->block_mask_;
+-  const size_t offset = minor_ix + (key << self->block_bits_);
+-  ++num[key];
+-  buckets[offset] = (uint32_t)ix;
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  size_t i;
+-  for (i = ix_start; i < ix_end; ++i) {
+-    FN(Store)(self, data, mask, i);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ringbuffer_mask) {
+-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
+-    /* Prepare the hashes for three last bytes of the last write.
+-       These could not be calculated before, since they require knowledge
+-       of both the previous and the current block. */
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    int* BROTLI_RESTRICT distance_cache) {
+-  PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
+-}
+-
+-/* Find a longest backward match of &data[cur_ix] up to the length of
+-   max_length and stores the position cur_ix in the hash table.
+-
+-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
+-             values; if this method is invoked repeatedly with the same distance
+-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
+-
+-   Does not look for matches longer than max_length.
+-   Does not look for matches further away than max_backward.
+-   Writes the best match into |out|.
+-   |out|->score is updated only if a better match is found. */
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+-    const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  uint16_t* BROTLI_RESTRICT num = self->num_;
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  /* Don't accept a short copy from far away. */
+-  score_t min_score = out->score;
+-  score_t best_score = out->score;
+-  size_t best_len = out->len;
+-  size_t i;
+-  out->len = 0;
+-  out->len_code_delta = 0;
+-  /* Try last distance first. */
+-  for (i = 0; i < (size_t)self->num_last_distances_to_check_; ++i) {
+-    const size_t backward = (size_t)distance_cache[i];
+-    size_t prev_ix = (size_t)(cur_ix - backward);
+-    if (prev_ix >= cur_ix) {
+-      continue;
+-    }
+-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+-      continue;
+-    }
+-    prev_ix &= ring_buffer_mask;
+-
+-    if (cur_ix_masked + best_len > ring_buffer_mask ||
+-        prev_ix + best_len > ring_buffer_mask ||
+-        data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+-      continue;
+-    }
+-    {
+-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                  &data[cur_ix_masked],
+-                                                  max_length);
+-      if (len >= 3 || (len == 2 && i < 2)) {
+-        /* Comparing for >= 2 does not change the semantics, but just saves for
+-           a few unnecessary binary logarithms in backward reference score,
+-           since we are not interested in such short matches. */
+-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
+-        if (best_score < score) {
+-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-  }
+-  {
+-    const uint32_t key = FN(HashBytes)(
+-        &data[cur_ix_masked], self->hash_mask_, self->hash_shift_);
+-    uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
+-    const size_t down =
+-        (num[key] > self->block_size_) ?
+-        (num[key] - self->block_size_) : 0u;
+-    for (i = num[key]; i > down;) {
+-      size_t prev_ix = bucket[--i & self->block_mask_];
+-      const size_t backward = cur_ix - prev_ix;
+-      if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+-        break;
+-      }
+-      prev_ix &= ring_buffer_mask;
+-      if (cur_ix_masked + best_len > ring_buffer_mask ||
+-          prev_ix + best_len > ring_buffer_mask ||
+-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+-        continue;
+-      }
+-      {
+-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                    &data[cur_ix_masked],
+-                                                    max_length);
+-        if (len >= 4) {
+-          /* Comparing for >= 3 does not change the semantics, but just saves
+-             for a few unnecessary binary logarithms in backward reference
+-             score, since we are not interested in such short matches. */
+-          score_t score = BackwardReferenceScore(len, backward);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
+-    ++num[key];
+-  }
+-  if (min_score == out->score) {
+-    SearchInStaticDictionary(dictionary,
+-        self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
+-        max_distance, out, BROTLI_FALSE);
+-  }
+-}
+-
+-#undef HashLongestMatch
+diff --git a/modules/brotli/enc/hash_longest_match_inc.h b/modules/brotli/enc/hash_longest_match_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_longest_match_inc.h
++++ /dev/null
+@@ -1,262 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN */
+-
+-/* A (forgetful) hash table to the data seen by the compressor, to
+-   help create backward references to previous data.
+-
+-   This is a hash map of fixed size (bucket_size_) to a ring buffer of
+-   fixed size (block_size_). The ring buffer contains the last block_size_
+-   index positions of the given hash key in the compressed data. */
+-
+-#define HashLongestMatch HASHER()
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
+-
+-/* HashBytes is the function that chooses the bucket to place the address in. */
+-static uint32_t FN(HashBytes)(
+-    const uint8_t* BROTLI_RESTRICT data, const int shift) {
+-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return (uint32_t)(h >> shift);
+-}
+-
+-typedef struct HashLongestMatch {
+-  /* Number of hash buckets. */
+-  size_t bucket_size_;
+-  /* Only block_size_ newest backward references are kept,
+-     and the older are forgotten. */
+-  size_t block_size_;
+-  /* Left-shift for computing hash bucket index from hash value. */
+-  int hash_shift_;
+-  /* Mask for accessing entries in a block (in a ring-buffer manner). */
+-  uint32_t block_mask_;
+-
+-  int block_bits_;
+-  int num_last_distances_to_check_;
+-
+-  /* Shortcuts. */
+-  HasherCommon* common_;
+-
+-  /* --- Dynamic size members --- */
+-
+-  /* Number of entries in a particular bucket. */
+-  uint16_t* num_;  /* uint16_t[bucket_size]; */
+-
+-  /* Buckets containing block_size_ of backward references. */
+-  uint32_t* buckets_;  /* uint32_t[bucket_size * block_size]; */
+-} HashLongestMatch;
+-
+-static BROTLI_INLINE uint16_t* FN(Num)(void* extra) {
+-  return (uint16_t*)extra;
+-}
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashLongestMatch* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  self->common_ = common;
+-
+-  BROTLI_UNUSED(params);
+-  self->hash_shift_ = 32 - common->params.bucket_bits;
+-  self->bucket_size_ = (size_t)1 << common->params.bucket_bits;
+-  self->block_size_ = (size_t)1 << common->params.block_bits;
+-  self->block_mask_ = (uint32_t)(self->block_size_ - 1);
+-  self->num_ = (uint16_t*)common->extra;
+-  self->buckets_ = (uint32_t*)(&self->num_[self->bucket_size_]);
+-  self->block_bits_ = common->params.block_bits;
+-  self->num_last_distances_to_check_ =
+-      common->params.num_last_distances_to_check;
+-}
+-
+-static void FN(Prepare)(
+-    HashLongestMatch* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  uint16_t* BROTLI_RESTRICT num = self->num_;
+-  /* Partial preparation is 100 times slower (per socket). */
+-  size_t partial_prepare_threshold = self->bucket_size_ >> 6;
+-  if (one_shot && input_size <= partial_prepare_threshold) {
+-    size_t i;
+-    for (i = 0; i < input_size; ++i) {
+-      const uint32_t key = FN(HashBytes)(&data[i], self->hash_shift_);
+-      num[key] = 0;
+-    }
+-  } else {
+-    memset(num, 0, self->bucket_size_ * sizeof(num[0]));
+-  }
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  size_t bucket_size = (size_t)1 << params->hasher.bucket_bits;
+-  size_t block_size = (size_t)1 << params->hasher.block_bits;
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-  return sizeof(uint16_t) * bucket_size +
+-         sizeof(uint32_t) * bucket_size * block_size;
+-}
+-
+-/* Look at 4 bytes at &data[ix & mask].
+-   Compute a hash from these, and store the value of ix at that position. */
+-static BROTLI_INLINE void FN(Store)(
+-    HashLongestMatch* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+-    const size_t mask, const size_t ix) {
+-  const uint32_t key = FN(HashBytes)(&data[ix & mask], self->hash_shift_);
+-  const size_t minor_ix = self->num_[key] & self->block_mask_;
+-  const size_t offset = minor_ix + (key << self->block_bits_);
+-  self->buckets_[offset] = (uint32_t)ix;
+-  ++self->num_[key];
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(HashLongestMatch* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  size_t i;
+-  for (i = ix_start; i < ix_end; ++i) {
+-    FN(Store)(self, data, mask, i);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ringbuffer_mask) {
+-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
+-    /* Prepare the hashes for three last bytes of the last write.
+-       These could not be calculated before, since they require knowledge
+-       of both the previous and the current block. */
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    int* BROTLI_RESTRICT distance_cache) {
+-  PrepareDistanceCache(distance_cache, self->num_last_distances_to_check_);
+-}
+-
+-/* Find a longest backward match of &data[cur_ix] up to the length of
+-   max_length and stores the position cur_ix in the hash table.
+-
+-   REQUIRES: FN(PrepareDistanceCache) must be invoked for current distance cache
+-             values; if this method is invoked repeatedly with the same distance
+-             cache values, it is enough to invoke FN(PrepareDistanceCache) once.
+-
+-   Does not look for matches longer than max_length.
+-   Does not look for matches further away than max_backward.
+-   Writes the best match into |out|.
+-   |out|->score is updated only if a better match is found. */
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashLongestMatch* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+-    const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  uint16_t* BROTLI_RESTRICT num = self->num_;
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  /* Don't accept a short copy from far away. */
+-  score_t min_score = out->score;
+-  score_t best_score = out->score;
+-  size_t best_len = out->len;
+-  size_t i;
+-  out->len = 0;
+-  out->len_code_delta = 0;
+-  /* Try last distance first. */
+-  for (i = 0; i < (size_t)self->num_last_distances_to_check_; ++i) {
+-    const size_t backward = (size_t)distance_cache[i];
+-    size_t prev_ix = (size_t)(cur_ix - backward);
+-    if (prev_ix >= cur_ix) {
+-      continue;
+-    }
+-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+-      continue;
+-    }
+-    prev_ix &= ring_buffer_mask;
+-
+-    if (cur_ix_masked + best_len > ring_buffer_mask ||
+-        prev_ix + best_len > ring_buffer_mask ||
+-        data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+-      continue;
+-    }
+-    {
+-      const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                  &data[cur_ix_masked],
+-                                                  max_length);
+-      if (len >= 3 || (len == 2 && i < 2)) {
+-        /* Comparing for >= 2 does not change the semantics, but just saves for
+-           a few unnecessary binary logarithms in backward reference score,
+-           since we are not interested in such short matches. */
+-        score_t score = BackwardReferenceScoreUsingLastDistance(len);
+-        if (best_score < score) {
+-          if (i != 0) score -= BackwardReferencePenaltyUsingLastDistance(i);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-  }
+-  {
+-    const uint32_t key =
+-        FN(HashBytes)(&data[cur_ix_masked], self->hash_shift_);
+-    uint32_t* BROTLI_RESTRICT bucket = &buckets[key << self->block_bits_];
+-    const size_t down =
+-        (num[key] > self->block_size_) ? (num[key] - self->block_size_) : 0u;
+-    for (i = num[key]; i > down;) {
+-      size_t prev_ix = bucket[--i & self->block_mask_];
+-      const size_t backward = cur_ix - prev_ix;
+-      if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+-        break;
+-      }
+-      prev_ix &= ring_buffer_mask;
+-      if (cur_ix_masked + best_len > ring_buffer_mask ||
+-          prev_ix + best_len > ring_buffer_mask ||
+-          data[cur_ix_masked + best_len] != data[prev_ix + best_len]) {
+-        continue;
+-      }
+-      {
+-        const size_t len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                                    &data[cur_ix_masked],
+-                                                    max_length);
+-        if (len >= 4) {
+-          /* Comparing for >= 3 does not change the semantics, but just saves
+-             for a few unnecessary binary logarithms in backward reference
+-             score, since we are not interested in such short matches. */
+-          score_t score = BackwardReferenceScore(len, backward);
+-          if (best_score < score) {
+-            best_score = score;
+-            best_len = len;
+-            out->len = best_len;
+-            out->distance = backward;
+-            out->score = best_score;
+-          }
+-        }
+-      }
+-    }
+-    bucket[num[key] & self->block_mask_] = (uint32_t)cur_ix;
+-    ++num[key];
+-  }
+-  if (min_score == out->score) {
+-    SearchInStaticDictionary(dictionary,
+-        self->common_, &data[cur_ix_masked], max_length, dictionary_distance,
+-        max_distance, out, BROTLI_FALSE);
+-  }
+-}
+-
+-#undef HashLongestMatch
+diff --git a/modules/brotli/enc/hash_longest_match_quickly_inc.h b/modules/brotli/enc/hash_longest_match_quickly_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_longest_match_quickly_inc.h
++++ /dev/null
+@@ -1,266 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, BUCKET_BITS, BUCKET_SWEEP_BITS, HASH_LEN,
+-                        USE_DICTIONARY
+- */
+-
+-#define HashLongestMatchQuickly HASHER()
+-
+-#define BUCKET_SIZE (1 << BUCKET_BITS)
+-#define BUCKET_MASK (BUCKET_SIZE - 1)
+-#define BUCKET_SWEEP (1 << BUCKET_SWEEP_BITS)
+-#define BUCKET_SWEEP_MASK ((BUCKET_SWEEP - 1) << 3)
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 8; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 8; }
+-
+-/* HashBytes is the function that chooses the bucket to place
+-   the address in. The HashLongestMatch and HashLongestMatchQuickly
+-   classes have separate, different implementations of hashing. */
+-static uint32_t FN(HashBytes)(const uint8_t* data) {
+-  const uint64_t h = ((BROTLI_UNALIGNED_LOAD64LE(data) << (64 - 8 * HASH_LEN)) *
+-                      kHashMul64);
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return (uint32_t)(h >> (64 - BUCKET_BITS));
+-}
+-
+-/* A (forgetful) hash table to the data seen by the compressor, to
+-   help create backward references to previous data.
+-
+-   This is a hash map of fixed size (BUCKET_SIZE). */
+-typedef struct HashLongestMatchQuickly {
+-  /* Shortcuts. */
+-  HasherCommon* common;
+-
+-  /* --- Dynamic size members --- */
+-
+-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
+-} HashLongestMatchQuickly;
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  self->common = common;
+-
+-  BROTLI_UNUSED(params);
+-  self->buckets_ = (uint32_t*)common->extra;
+-}
+-
+-static void FN(Prepare)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  /* Partial preparation is 100 times slower (per socket). */
+-  size_t partial_prepare_threshold = BUCKET_SIZE >> 5;
+-  if (one_shot && input_size <= partial_prepare_threshold) {
+-    size_t i;
+-    for (i = 0; i < input_size; ++i) {
+-      const uint32_t key = FN(HashBytes)(&data[i]);
+-      if (BUCKET_SWEEP == 1) {
+-        buckets[key] = 0;
+-      } else {
+-        uint32_t j;
+-        for (j = 0; j < BUCKET_SWEEP; ++j) {
+-          buckets[(key + (j << 3)) & BUCKET_MASK] = 0;
+-        }
+-      }
+-    }
+-  } else {
+-    /* It is not strictly necessary to fill this buffer here, but
+-       not filling will make the results of the compression stochastic
+-       (but correct). This is because random data would cause the
+-       system to find accidentally good backward references here and there. */
+-    memset(buckets, 0, sizeof(uint32_t) * BUCKET_SIZE);
+-  }
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  BROTLI_UNUSED(params);
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-  return sizeof(uint32_t) * BUCKET_SIZE;
+-}
+-
+-/* Look at 5 bytes at &data[ix & mask].
+-   Compute a hash from these, and store the value somewhere within
+-   [ix .. ix+3]. */
+-static BROTLI_INLINE void FN(Store)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+-  const uint32_t key = FN(HashBytes)(&data[ix & mask]);
+-  if (BUCKET_SWEEP == 1) {
+-    self->buckets_[key] = (uint32_t)ix;
+-  } else {
+-    /* Wiggle the value with the bucket sweep range. */
+-    const uint32_t off = ix & BUCKET_SWEEP_MASK;
+-    self->buckets_[(key + off) & BUCKET_MASK] = (uint32_t)ix;
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  size_t i;
+-  for (i = ix_start; i < ix_end; ++i) {
+-    FN(Store)(self, data, mask, i);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position,
+-    const uint8_t* ringbuffer, size_t ringbuffer_mask) {
+-  if (num_bytes >= FN(HashTypeLength)() - 1 && position >= 3) {
+-    /* Prepare the hashes for three last bytes of the last write.
+-       These could not be calculated before, since they require knowledge
+-       of both the previous and the current block. */
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 3);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 2);
+-    FN(Store)(self, ringbuffer, ringbuffer_mask, position - 1);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    int* BROTLI_RESTRICT distance_cache) {
+-  BROTLI_UNUSED(self);
+-  BROTLI_UNUSED(distance_cache);
+-}
+-
+-/* Find a longest backward match of &data[cur_ix & ring_buffer_mask]
+-   up to the length of max_length and stores the position cur_ix in the
+-   hash table.
+-
+-   Does not look for matches longer than max_length.
+-   Does not look for matches further away than max_backward.
+-   Writes the best match into |out|.
+-   |out|->score is updated only if a better match is found. */
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashLongestMatchQuickly* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data,
+-    const size_t ring_buffer_mask, const int* BROTLI_RESTRICT distance_cache,
+-    const size_t cur_ix, const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  const size_t best_len_in = out->len;
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  int compare_char = data[cur_ix_masked + best_len_in];
+-  size_t key = FN(HashBytes)(&data[cur_ix_masked]);
+-  size_t key_out;
+-  score_t min_score = out->score;
+-  score_t best_score = out->score;
+-  size_t best_len = best_len_in;
+-  size_t cached_backward = (size_t)distance_cache[0];
+-  size_t prev_ix = cur_ix - cached_backward;
+-  out->len_code_delta = 0;
+-  if (prev_ix < cur_ix) {
+-    prev_ix &= (uint32_t)ring_buffer_mask;
+-    if (compare_char == data[prev_ix + best_len]) {
+-      const size_t len = FindMatchLengthWithLimit(
+-          &data[prev_ix], &data[cur_ix_masked], max_length);
+-      if (len >= 4) {
+-        const score_t score = BackwardReferenceScoreUsingLastDistance(len);
+-        if (best_score < score) {
+-          out->len = len;
+-          out->distance = cached_backward;
+-          out->score = score;
+-          if (BUCKET_SWEEP == 1) {
+-            buckets[key] = (uint32_t)cur_ix;
+-            return;
+-          } else {
+-            best_len = len;
+-            best_score = score;
+-            compare_char = data[cur_ix_masked + len];
+-          }
+-        }
+-      }
+-    }
+-  }
+-  if (BUCKET_SWEEP == 1) {
+-    size_t backward;
+-    size_t len;
+-    /* Only one to look for, don't bother to prepare for a loop. */
+-    prev_ix = buckets[key];
+-    buckets[key] = (uint32_t)cur_ix;
+-    backward = cur_ix - prev_ix;
+-    prev_ix &= (uint32_t)ring_buffer_mask;
+-    if (compare_char != data[prev_ix + best_len_in]) {
+-      return;
+-    }
+-    if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+-      return;
+-    }
+-    len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                   &data[cur_ix_masked],
+-                                   max_length);
+-    if (len >= 4) {
+-      const score_t score = BackwardReferenceScore(len, backward);
+-      if (best_score < score) {
+-        out->len = len;
+-        out->distance = backward;
+-        out->score = score;
+-        return;
+-      }
+-    }
+-  } else {
+-    size_t keys[BUCKET_SWEEP];
+-    size_t i;
+-    for (i = 0; i < BUCKET_SWEEP; ++i) {
+-      keys[i] = (key + (i << 3)) & BUCKET_MASK;
+-    }
+-    key_out = keys[(cur_ix & BUCKET_SWEEP_MASK) >> 3];
+-    for (i = 0; i < BUCKET_SWEEP; ++i) {
+-      size_t len;
+-      size_t backward;
+-      prev_ix = buckets[keys[i]];
+-      backward = cur_ix - prev_ix;
+-      prev_ix &= (uint32_t)ring_buffer_mask;
+-      if (compare_char != data[prev_ix + best_len]) {
+-        continue;
+-      }
+-      if (BROTLI_PREDICT_FALSE(backward == 0 || backward > max_backward)) {
+-        continue;
+-      }
+-      len = FindMatchLengthWithLimit(&data[prev_ix],
+-                                     &data[cur_ix_masked],
+-                                     max_length);
+-      if (len >= 4) {
+-        const score_t score = BackwardReferenceScore(len, backward);
+-        if (best_score < score) {
+-          best_len = len;
+-          out->len = len;
+-          compare_char = data[cur_ix_masked + len];
+-          best_score = score;
+-          out->score = score;
+-          out->distance = backward;
+-        }
+-      }
+-    }
+-  }
+-  if (USE_DICTIONARY && min_score == out->score) {
+-    SearchInStaticDictionary(dictionary,
+-        self->common, &data[cur_ix_masked], max_length, dictionary_distance,
+-        max_distance, out, BROTLI_TRUE);
+-  }
+-  if (BUCKET_SWEEP != 1) {
+-    buckets[key_out] = (uint32_t)cur_ix;
+-  }
+-}
+-
+-#undef BUCKET_SWEEP_MASK
+-#undef BUCKET_SWEEP
+-#undef BUCKET_MASK
+-#undef BUCKET_SIZE
+-
+-#undef HashLongestMatchQuickly
+diff --git a/modules/brotli/enc/hash_rolling_inc.h b/modules/brotli/enc/hash_rolling_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_rolling_inc.h
++++ /dev/null
+@@ -1,212 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2018 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, JUMP, NUMBUCKETS, MASK, CHUNKLEN */
+-/* NUMBUCKETS / (MASK + 1) = probability of storing and using hash code. */
+-/* JUMP = skip bytes for speedup */
+-
+-/* Rolling hash for long distance long string matches. Stores one position
+-   per bucket, bucket key is computed over a long region. */
+-
+-#define HashRolling HASHER()
+-
+-static const uint32_t FN(kRollingHashMul32) = 69069;
+-static const uint32_t FN(kInvalidPos) = 0xffffffff;
+-
+-/* This hasher uses a longer forward length, but returning a higher value here
+-   will hurt compression by the main hasher when combined with a composite
+-   hasher. The hasher tests for forward itself instead. */
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) { return 4; }
+-
+-/* Computes a code from a single byte. A lookup table of 256 values could be
+-   used, but simply adding 1 works about as good. */
+-static uint32_t FN(HashByte)(uint8_t byte) {
+-  return (uint32_t)byte + 1u;
+-}
+-
+-static uint32_t FN(HashRollingFunctionInitial)(uint32_t state, uint8_t add,
+-                                               uint32_t factor) {
+-  return (uint32_t)(factor * state + FN(HashByte)(add));
+-}
+-
+-static uint32_t FN(HashRollingFunction)(uint32_t state, uint8_t add,
+-                                        uint8_t rem, uint32_t factor,
+-                                        uint32_t factor_remove) {
+-  return (uint32_t)(factor * state +
+-      FN(HashByte)(add) - factor_remove * FN(HashByte)(rem));
+-}
+-
+-typedef struct HashRolling {
+-  uint32_t state;
+-  uint32_t* table;
+-  size_t next_ix;
+-
+-  uint32_t chunk_len;
+-  uint32_t factor;
+-  uint32_t factor_remove;
+-} HashRolling;
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashRolling* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  size_t i;
+-  self->state = 0;
+-  self->next_ix = 0;
+-
+-  self->factor = FN(kRollingHashMul32);
+-
+-  /* Compute the factor of the oldest byte to remove: factor**steps modulo
+-     0xffffffff (the multiplications rely on 32-bit overflow) */
+-  self->factor_remove = 1;
+-  for (i = 0; i < CHUNKLEN; i += JUMP) {
+-    self->factor_remove *= self->factor;
+-  }
+-
+-  self->table = (uint32_t*)common->extra;
+-  for (i = 0; i < NUMBUCKETS; i++) {
+-    self->table[i] = FN(kInvalidPos);
+-  }
+-
+-  BROTLI_UNUSED(params);
+-}
+-
+-static void FN(Prepare)(HashRolling* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  size_t i;
+-  /* Too small size, cannot use this hasher. */
+-  if (input_size < CHUNKLEN) return;
+-  self->state = 0;
+-  for (i = 0; i < CHUNKLEN; i += JUMP) {
+-    self->state = FN(HashRollingFunctionInitial)(
+-        self->state, data[i], self->factor);
+-  }
+-  BROTLI_UNUSED(one_shot);
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  return NUMBUCKETS * sizeof(uint32_t);
+-  BROTLI_UNUSED(params);
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-}
+-
+-static BROTLI_INLINE void FN(Store)(HashRolling* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask, const size_t ix) {
+-  BROTLI_UNUSED(self);
+-  BROTLI_UNUSED(data);
+-  BROTLI_UNUSED(mask);
+-  BROTLI_UNUSED(ix);
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(HashRolling* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  BROTLI_UNUSED(self);
+-  BROTLI_UNUSED(data);
+-  BROTLI_UNUSED(mask);
+-  BROTLI_UNUSED(ix_start);
+-  BROTLI_UNUSED(ix_end);
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashRolling* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ring_buffer_mask) {
+-  /* In this case we must re-initialize the hasher from scratch from the
+-     current position. */
+-  size_t position_masked;
+-  size_t available = num_bytes;
+-  if ((position & (JUMP - 1)) != 0) {
+-    size_t diff = JUMP - (position & (JUMP - 1));
+-    available = (diff > available) ? 0 : (available - diff);
+-    position += diff;
+-  }
+-  position_masked = position & ring_buffer_mask;
+-  /* wrapping around ringbuffer not handled. */
+-  if (available > ring_buffer_mask - position_masked) {
+-    available = ring_buffer_mask - position_masked;
+-  }
+-
+-  FN(Prepare)(self, BROTLI_FALSE, available,
+-      ringbuffer + (position & ring_buffer_mask));
+-  self->next_ix = position;
+-  BROTLI_UNUSED(num_bytes);
+-}
+-
+-static BROTLI_INLINE void FN(PrepareDistanceCache)(
+-    HashRolling* BROTLI_RESTRICT self,
+-    int* BROTLI_RESTRICT distance_cache) {
+-  BROTLI_UNUSED(self);
+-  BROTLI_UNUSED(distance_cache);
+-}
+-
+-static BROTLI_INLINE void FN(FindLongestMatch)(
+-    HashRolling* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t ring_buffer_mask,
+-    const int* BROTLI_RESTRICT distance_cache, const size_t cur_ix,
+-    const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const size_t max_distance,
+-    HasherSearchResult* BROTLI_RESTRICT out) {
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  size_t pos;
+-
+-  if ((cur_ix & (JUMP - 1)) != 0) return;
+-
+-  /* Not enough lookahead */
+-  if (max_length < CHUNKLEN) return;
+-
+-  for (pos = self->next_ix; pos <= cur_ix; pos += JUMP) {
+-    uint32_t code = self->state & MASK;
+-
+-    uint8_t rem = data[pos & ring_buffer_mask];
+-    uint8_t add = data[(pos + CHUNKLEN) & ring_buffer_mask];
+-    size_t found_ix = FN(kInvalidPos);
+-
+-    self->state = FN(HashRollingFunction)(
+-        self->state, add, rem, self->factor, self->factor_remove);
+-
+-    if (code < NUMBUCKETS) {
+-      found_ix = self->table[code];
+-      self->table[code] = (uint32_t)pos;
+-      if (pos == cur_ix && found_ix != FN(kInvalidPos)) {
+-        /* The cast to 32-bit makes backward distances up to 4GB work even
+-           if cur_ix is above 4GB, despite using 32-bit values in the table. */
+-        size_t backward = (uint32_t)(cur_ix - found_ix);
+-        if (backward <= max_backward) {
+-          const size_t found_ix_masked = found_ix & ring_buffer_mask;
+-          const size_t len = FindMatchLengthWithLimit(&data[found_ix_masked],
+-                                                      &data[cur_ix_masked],
+-                                                      max_length);
+-          if (len >= 4 && len > out->len) {
+-            score_t score = BackwardReferenceScore(len, backward);
+-            if (score > out->score) {
+-              out->len = len;
+-              out->distance = backward;
+-              out->score = score;
+-              out->len_code_delta = 0;
+-            }
+-          }
+-        }
+-      }
+-    }
+-  }
+-
+-  self->next_ix = cur_ix + JUMP;
+-
+-  /* NOTE: this hasher does not search in the dictionary. It is used as
+-     backup-hasher, the main hasher already searches in it. */
+-  BROTLI_UNUSED(dictionary);
+-  BROTLI_UNUSED(distance_cache);
+-  BROTLI_UNUSED(dictionary_distance);
+-  BROTLI_UNUSED(max_distance);
+-}
+-
+-#undef HashRolling
+diff --git a/modules/brotli/enc/hash_to_binary_tree_inc.h b/modules/brotli/enc/hash_to_binary_tree_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/hash_to_binary_tree_inc.h
++++ /dev/null
+@@ -1,329 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2016 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN, BUCKET_BITS, MAX_TREE_COMP_LENGTH,
+-                        MAX_TREE_SEARCH_DEPTH */
+-
+-/* A (forgetful) hash table where each hash bucket contains a binary tree of
+-   sequences whose first 4 bytes share the same hash code.
+-   Each sequence is MAX_TREE_COMP_LENGTH long and is identified by its starting
+-   position in the input data. The binary tree is sorted by the lexicographic
+-   order of the sequences, and it is also a max-heap with respect to the
+-   starting positions. */
+-
+-#define HashToBinaryTree HASHER()
+-
+-#define BUCKET_SIZE (1 << BUCKET_BITS)
+-
+-static BROTLI_INLINE size_t FN(HashTypeLength)(void) { return 4; }
+-static BROTLI_INLINE size_t FN(StoreLookahead)(void) {
+-  return MAX_TREE_COMP_LENGTH;
+-}
+-
+-static uint32_t FN(HashBytes)(const uint8_t* BROTLI_RESTRICT data) {
+-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kHashMul32;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return h >> (32 - BUCKET_BITS);
+-}
+-
+-typedef struct HashToBinaryTree {
+-  /* The window size minus 1 */
+-  size_t window_mask_;
+-
+-  /* Hash table that maps the 4-byte hashes of the sequence to the last
+-     position where this hash was found, which is the root of the binary
+-     tree of sequences that share this hash bucket. */
+-  uint32_t* buckets_;  /* uint32_t[BUCKET_SIZE]; */
+-
+-  /* A position used to mark a non-existent sequence, i.e. a tree is empty if
+-     its root is at invalid_pos_ and a node is a leaf if both its children
+-     are at invalid_pos_. */
+-  uint32_t invalid_pos_;
+-
+-  /* --- Dynamic size members --- */
+-
+-  /* The union of the binary trees of each hash bucket. The root of the tree
+-     corresponding to a hash is a sequence starting at buckets_[hash] and
+-     the left and right children of a sequence starting at pos are
+-     forest_[2 * pos] and forest_[2 * pos + 1]. */
+-  uint32_t* forest_;  /* uint32_t[2 * num_nodes] */
+-} HashToBinaryTree;
+-
+-static void FN(Initialize)(
+-    HasherCommon* common, HashToBinaryTree* BROTLI_RESTRICT self,
+-    const BrotliEncoderParams* params) {
+-  self->buckets_ = (uint32_t*)common->extra;
+-  self->forest_ = &self->buckets_[BUCKET_SIZE];
+-
+-  self->window_mask_ = (1u << params->lgwin) - 1u;
+-  self->invalid_pos_ = (uint32_t)(0 - self->window_mask_);
+-}
+-
+-static void FN(Prepare)
+-    (HashToBinaryTree* BROTLI_RESTRICT self, BROTLI_BOOL one_shot,
+-    size_t input_size, const uint8_t* BROTLI_RESTRICT data) {
+-  uint32_t invalid_pos = self->invalid_pos_;
+-  uint32_t i;
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  BROTLI_UNUSED(data);
+-  BROTLI_UNUSED(one_shot);
+-  BROTLI_UNUSED(input_size);
+-  for (i = 0; i < BUCKET_SIZE; i++) {
+-    buckets[i] = invalid_pos;
+-  }
+-}
+-
+-static BROTLI_INLINE size_t FN(HashMemAllocInBytes)(
+-    const BrotliEncoderParams* params, BROTLI_BOOL one_shot,
+-    size_t input_size) {
+-  size_t num_nodes = (size_t)1 << params->lgwin;
+-  if (one_shot && input_size < num_nodes) {
+-    num_nodes = input_size;
+-  }
+-  return sizeof(uint32_t) * BUCKET_SIZE + 2 * sizeof(uint32_t) * num_nodes;
+-}
+-
+-static BROTLI_INLINE size_t FN(LeftChildIndex)(
+-    HashToBinaryTree* BROTLI_RESTRICT self,
+-    const size_t pos) {
+-  return 2 * (pos & self->window_mask_);
+-}
+-
+-static BROTLI_INLINE size_t FN(RightChildIndex)(
+-    HashToBinaryTree* BROTLI_RESTRICT self,
+-    const size_t pos) {
+-  return 2 * (pos & self->window_mask_) + 1;
+-}
+-
+-/* Stores the hash of the next 4 bytes and in a single tree-traversal, the
+-   hash bucket's binary tree is searched for matches and is re-rooted at the
+-   current position.
+-
+-   If less than MAX_TREE_COMP_LENGTH data is available, the hash bucket of the
+-   current position is searched for matches, but the state of the hash table
+-   is not changed, since we can not know the final sorting order of the
+-   current (incomplete) sequence.
+-
+-   This function must be called with increasing cur_ix positions. */
+-static BROTLI_INLINE BackwardMatch* FN(StoreAndFindMatches)(
+-    HashToBinaryTree* BROTLI_RESTRICT self, const uint8_t* BROTLI_RESTRICT data,
+-    const size_t cur_ix, const size_t ring_buffer_mask, const size_t max_length,
+-    const size_t max_backward, size_t* const BROTLI_RESTRICT best_len,
+-    BackwardMatch* BROTLI_RESTRICT matches) {
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  const size_t max_comp_len =
+-      BROTLI_MIN(size_t, max_length, MAX_TREE_COMP_LENGTH);
+-  const BROTLI_BOOL should_reroot_tree =
+-      TO_BROTLI_BOOL(max_length >= MAX_TREE_COMP_LENGTH);
+-  const uint32_t key = FN(HashBytes)(&data[cur_ix_masked]);
+-  uint32_t* BROTLI_RESTRICT buckets = self->buckets_;
+-  uint32_t* BROTLI_RESTRICT forest = self->forest_;
+-  size_t prev_ix = buckets[key];
+-  /* The forest index of the rightmost node of the left subtree of the new
+-     root, updated as we traverse and re-root the tree of the hash bucket. */
+-  size_t node_left = FN(LeftChildIndex)(self, cur_ix);
+-  /* The forest index of the leftmost node of the right subtree of the new
+-     root, updated as we traverse and re-root the tree of the hash bucket. */
+-  size_t node_right = FN(RightChildIndex)(self, cur_ix);
+-  /* The match length of the rightmost node of the left subtree of the new
+-     root, updated as we traverse and re-root the tree of the hash bucket. */
+-  size_t best_len_left = 0;
+-  /* The match length of the leftmost node of the right subtree of the new
+-     root, updated as we traverse and re-root the tree of the hash bucket. */
+-  size_t best_len_right = 0;
+-  size_t depth_remaining;
+-  if (should_reroot_tree) {
+-    buckets[key] = (uint32_t)cur_ix;
+-  }
+-  for (depth_remaining = MAX_TREE_SEARCH_DEPTH; ; --depth_remaining) {
+-    const size_t backward = cur_ix - prev_ix;
+-    const size_t prev_ix_masked = prev_ix & ring_buffer_mask;
+-    if (backward == 0 || backward > max_backward || depth_remaining == 0) {
+-      if (should_reroot_tree) {
+-        forest[node_left] = self->invalid_pos_;
+-        forest[node_right] = self->invalid_pos_;
+-      }
+-      break;
+-    }
+-    {
+-      const size_t cur_len = BROTLI_MIN(size_t, best_len_left, best_len_right);
+-      size_t len;
+-      BROTLI_DCHECK(cur_len <= MAX_TREE_COMP_LENGTH);
+-      len = cur_len +
+-          FindMatchLengthWithLimit(&data[cur_ix_masked + cur_len],
+-                                   &data[prev_ix_masked + cur_len],
+-                                   max_length - cur_len);
+-      BROTLI_DCHECK(
+-          0 == memcmp(&data[cur_ix_masked], &data[prev_ix_masked], len));
+-      if (matches && len > *best_len) {
+-        *best_len = len;
+-        InitBackwardMatch(matches++, backward, len);
+-      }
+-      if (len >= max_comp_len) {
+-        if (should_reroot_tree) {
+-          forest[node_left] = forest[FN(LeftChildIndex)(self, prev_ix)];
+-          forest[node_right] = forest[FN(RightChildIndex)(self, prev_ix)];
+-        }
+-        break;
+-      }
+-      if (data[cur_ix_masked + len] > data[prev_ix_masked + len]) {
+-        best_len_left = len;
+-        if (should_reroot_tree) {
+-          forest[node_left] = (uint32_t)prev_ix;
+-        }
+-        node_left = FN(RightChildIndex)(self, prev_ix);
+-        prev_ix = forest[node_left];
+-      } else {
+-        best_len_right = len;
+-        if (should_reroot_tree) {
+-          forest[node_right] = (uint32_t)prev_ix;
+-        }
+-        node_right = FN(LeftChildIndex)(self, prev_ix);
+-        prev_ix = forest[node_right];
+-      }
+-    }
+-  }
+-  return matches;
+-}
+-
+-/* Finds all backward matches of &data[cur_ix & ring_buffer_mask] up to the
+-   length of max_length and stores the position cur_ix in the hash table.
+-
+-   Sets *num_matches to the number of matches found, and stores the found
+-   matches in matches[0] to matches[*num_matches - 1]. The matches will be
+-   sorted by strictly increasing length and (non-strictly) increasing
+-   distance. */
+-static BROTLI_INLINE size_t FN(FindAllMatches)(
+-    HashToBinaryTree* BROTLI_RESTRICT self,
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* BROTLI_RESTRICT data,
+-    const size_t ring_buffer_mask, const size_t cur_ix,
+-    const size_t max_length, const size_t max_backward,
+-    const size_t dictionary_distance, const BrotliEncoderParams* params,
+-    BackwardMatch* matches) {
+-  BackwardMatch* const orig_matches = matches;
+-  const size_t cur_ix_masked = cur_ix & ring_buffer_mask;
+-  size_t best_len = 1;
+-  const size_t short_match_max_backward =
+-      params->quality != HQ_ZOPFLIFICATION_QUALITY ? 16 : 64;
+-  size_t stop = cur_ix - short_match_max_backward;
+-  uint32_t dict_matches[BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1];
+-  size_t i;
+-  if (cur_ix < short_match_max_backward) { stop = 0; }
+-  for (i = cur_ix - 1; i > stop && best_len <= 2; --i) {
+-    size_t prev_ix = i;
+-    const size_t backward = cur_ix - prev_ix;
+-    if (BROTLI_PREDICT_FALSE(backward > max_backward)) {
+-      break;
+-    }
+-    prev_ix &= ring_buffer_mask;
+-    if (data[cur_ix_masked] != data[prev_ix] ||
+-        data[cur_ix_masked + 1] != data[prev_ix + 1]) {
+-      continue;
+-    }
+-    {
+-      const size_t len =
+-          FindMatchLengthWithLimit(&data[prev_ix], &data[cur_ix_masked],
+-                                   max_length);
+-      if (len > best_len) {
+-        best_len = len;
+-        InitBackwardMatch(matches++, backward, len);
+-      }
+-    }
+-  }
+-  if (best_len < max_length) {
+-    matches = FN(StoreAndFindMatches)(self, data, cur_ix,
+-        ring_buffer_mask, max_length, max_backward, &best_len, matches);
+-  }
+-  for (i = 0; i <= BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN; ++i) {
+-    dict_matches[i] = kInvalidMatch;
+-  }
+-  {
+-    size_t minlen = BROTLI_MAX(size_t, 4, best_len + 1);
+-    if (BrotliFindAllStaticDictionaryMatches(dictionary,
+-        &data[cur_ix_masked], minlen, max_length, &dict_matches[0])) {
+-      size_t maxlen = BROTLI_MIN(
+-          size_t, BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN, max_length);
+-      size_t l;
+-      for (l = minlen; l <= maxlen; ++l) {
+-        uint32_t dict_id = dict_matches[l];
+-        if (dict_id < kInvalidMatch) {
+-          size_t distance = dictionary_distance + (dict_id >> 5) + 1;
+-          if (distance <= params->dist.max_distance) {
+-            InitDictionaryBackwardMatch(matches++, distance, l, dict_id & 31);
+-          }
+-        }
+-      }
+-    }
+-  }
+-  return (size_t)(matches - orig_matches);
+-}
+-
+-/* Stores the hash of the next 4 bytes and re-roots the binary tree at the
+-   current sequence, without returning any matches.
+-   REQUIRES: ix + MAX_TREE_COMP_LENGTH <= end-of-current-block */
+-static BROTLI_INLINE void FN(Store)(HashToBinaryTree* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data,
+-    const size_t mask, const size_t ix) {
+-  /* Maximum distance is window size - 16, see section 9.1. of the spec. */
+-  const size_t max_backward = self->window_mask_ - BROTLI_WINDOW_GAP + 1;
+-  FN(StoreAndFindMatches)(self, data, ix, mask, MAX_TREE_COMP_LENGTH,
+-      max_backward, NULL, NULL);
+-}
+-
+-static BROTLI_INLINE void FN(StoreRange)(HashToBinaryTree* BROTLI_RESTRICT self,
+-    const uint8_t* BROTLI_RESTRICT data, const size_t mask,
+-    const size_t ix_start, const size_t ix_end) {
+-  size_t i = ix_start;
+-  size_t j = ix_start;
+-  if (ix_start + 63 <= ix_end) {
+-    i = ix_end - 63;
+-  }
+-  if (ix_start + 512 <= i) {
+-    for (; j < i; j += 8) {
+-      FN(Store)(self, data, mask, j);
+-    }
+-  }
+-  for (; i < ix_end; ++i) {
+-    FN(Store)(self, data, mask, i);
+-  }
+-}
+-
+-static BROTLI_INLINE void FN(StitchToPreviousBlock)(
+-    HashToBinaryTree* BROTLI_RESTRICT self,
+-    size_t num_bytes, size_t position, const uint8_t* ringbuffer,
+-    size_t ringbuffer_mask) {
+-  if (num_bytes >= FN(HashTypeLength)() - 1 &&
+-      position >= MAX_TREE_COMP_LENGTH) {
+-    /* Store the last `MAX_TREE_COMP_LENGTH - 1` positions in the hasher.
+-       These could not be calculated before, since they require knowledge
+-       of both the previous and the current block. */
+-    const size_t i_start = position - MAX_TREE_COMP_LENGTH + 1;
+-    const size_t i_end = BROTLI_MIN(size_t, position, i_start + num_bytes);
+-    size_t i;
+-    for (i = i_start; i < i_end; ++i) {
+-      /* Maximum distance is window size - 16, see section 9.1. of the spec.
+-         Furthermore, we have to make sure that we don't look further back
+-         from the start of the next block than the window size, otherwise we
+-         could access already overwritten areas of the ring-buffer. */
+-      const size_t max_backward =
+-          self->window_mask_ - BROTLI_MAX(size_t,
+-                                          BROTLI_WINDOW_GAP - 1,
+-                                          position - i);
+-      /* We know that i + MAX_TREE_COMP_LENGTH <= position + num_bytes, i.e. the
+-         end of the current block and that we have at least
+-         MAX_TREE_COMP_LENGTH tail in the ring-buffer. */
+-      FN(StoreAndFindMatches)(self, ringbuffer, i, ringbuffer_mask,
+-          MAX_TREE_COMP_LENGTH, max_backward, NULL, NULL);
+-    }
+-  }
+-}
+-
+-#undef BUCKET_SIZE
+-
+-#undef HashToBinaryTree
+diff --git a/modules/brotli/enc/histogram.c b/modules/brotli/enc/histogram.c
+deleted file mode 100644
+--- a/modules/brotli/enc/histogram.c
++++ /dev/null
+@@ -1,100 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Build per-context histograms of literals, commands and distance codes. */
+-
+-#include "./histogram.h"
+-
+-#include "../common/context.h"
+-#include "./block_splitter.h"
+-#include "./command.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct BlockSplitIterator {
+-  const BlockSplit* split_;  /* Not owned. */
+-  size_t idx_;
+-  size_t type_;
+-  size_t length_;
+-} BlockSplitIterator;
+-
+-static void InitBlockSplitIterator(BlockSplitIterator* self,
+-    const BlockSplit* split) {
+-  self->split_ = split;
+-  self->idx_ = 0;
+-  self->type_ = 0;
+-  self->length_ = split->lengths ? split->lengths[0] : 0;
+-}
+-
+-static void BlockSplitIteratorNext(BlockSplitIterator* self) {
+-  if (self->length_ == 0) {
+-    ++self->idx_;
+-    self->type_ = self->split_->types[self->idx_];
+-    self->length_ = self->split_->lengths[self->idx_];
+-  }
+-  --self->length_;
+-}
+-
+-void BrotliBuildHistogramsWithContext(
+-    const Command* cmds, const size_t num_commands,
+-    const BlockSplit* literal_split, const BlockSplit* insert_and_copy_split,
+-    const BlockSplit* dist_split, const uint8_t* ringbuffer, size_t start_pos,
+-    size_t mask, uint8_t prev_byte, uint8_t prev_byte2,
+-    const ContextType* context_modes, HistogramLiteral* literal_histograms,
+-    HistogramCommand* insert_and_copy_histograms,
+-    HistogramDistance* copy_dist_histograms) {
+-  size_t pos = start_pos;
+-  BlockSplitIterator literal_it;
+-  BlockSplitIterator insert_and_copy_it;
+-  BlockSplitIterator dist_it;
+-  size_t i;
+-
+-  InitBlockSplitIterator(&literal_it, literal_split);
+-  InitBlockSplitIterator(&insert_and_copy_it, insert_and_copy_split);
+-  InitBlockSplitIterator(&dist_it, dist_split);
+-  for (i = 0; i < num_commands; ++i) {
+-    const Command* cmd = &cmds[i];
+-    size_t j;
+-    BlockSplitIteratorNext(&insert_and_copy_it);
+-    HistogramAddCommand(&insert_and_copy_histograms[insert_and_copy_it.type_],
+-        cmd->cmd_prefix_);
+-    /* TODO: unwrap iterator blocks. */
+-    for (j = cmd->insert_len_; j != 0; --j) {
+-      size_t context;
+-      BlockSplitIteratorNext(&literal_it);
+-      context = literal_it.type_;
+-      if (context_modes) {
+-        ContextLut lut = BROTLI_CONTEXT_LUT(context_modes[context]);
+-        context = (context << BROTLI_LITERAL_CONTEXT_BITS) +
+-            BROTLI_CONTEXT(prev_byte, prev_byte2, lut);
+-      }
+-      HistogramAddLiteral(&literal_histograms[context],
+-          ringbuffer[pos & mask]);
+-      prev_byte2 = prev_byte;
+-      prev_byte = ringbuffer[pos & mask];
+-      ++pos;
+-    }
+-    pos += CommandCopyLen(cmd);
+-    if (CommandCopyLen(cmd)) {
+-      prev_byte2 = ringbuffer[(pos - 2) & mask];
+-      prev_byte = ringbuffer[(pos - 1) & mask];
+-      if (cmd->cmd_prefix_ >= 128) {
+-        size_t context;
+-        BlockSplitIteratorNext(&dist_it);
+-        context = (dist_it.type_ << BROTLI_DISTANCE_CONTEXT_BITS) +
+-            CommandDistanceContext(cmd);
+-        HistogramAddDistance(&copy_dist_histograms[context],
+-            cmd->dist_prefix_ & 0x3FF);
+-      }
+-    }
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/histogram.h b/modules/brotli/enc/histogram.h
+deleted file mode 100644
+--- a/modules/brotli/enc/histogram.h
++++ /dev/null
+@@ -1,63 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Models the histograms of literals, commands and distance codes. */
+-
+-#ifndef BROTLI_ENC_HISTOGRAM_H_
+-#define BROTLI_ENC_HISTOGRAM_H_
+-
+-#include <string.h>  /* memset */
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./block_splitter.h"
+-#include "./command.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* The distance symbols effectively used by "Large Window Brotli" (32-bit). */
+-#define BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS 544
+-
+-#define FN(X) X ## Literal
+-#define DATA_SIZE BROTLI_NUM_LITERAL_SYMBOLS
+-#define DataType uint8_t
+-#include "./histogram_inc.h"  /* NOLINT(build/include) */
+-#undef DataType
+-#undef DATA_SIZE
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#define DataType uint16_t
+-#define DATA_SIZE BROTLI_NUM_COMMAND_SYMBOLS
+-#include "./histogram_inc.h"  /* NOLINT(build/include) */
+-#undef DATA_SIZE
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-#define DATA_SIZE BROTLI_NUM_HISTOGRAM_DISTANCE_SYMBOLS
+-#include "./histogram_inc.h"  /* NOLINT(build/include) */
+-#undef DataType
+-#undef DATA_SIZE
+-#undef FN
+-
+-BROTLI_INTERNAL void BrotliBuildHistogramsWithContext(
+-    const Command* cmds, const size_t num_commands,
+-    const BlockSplit* literal_split, const BlockSplit* insert_and_copy_split,
+-    const BlockSplit* dist_split, const uint8_t* ringbuffer, size_t pos,
+-    size_t mask, uint8_t prev_byte, uint8_t prev_byte2,
+-    const ContextType* context_modes, HistogramLiteral* literal_histograms,
+-    HistogramCommand* insert_and_copy_histograms,
+-    HistogramDistance* copy_dist_histograms);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_HISTOGRAM_H_ */
+diff --git a/modules/brotli/enc/histogram_inc.h b/modules/brotli/enc/histogram_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/histogram_inc.h
++++ /dev/null
+@@ -1,51 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: Histogram, DATA_SIZE, DataType */
+-
+-/* A simple container for histograms of data in blocks. */
+-
+-typedef struct FN(Histogram) {
+-  uint32_t data_[DATA_SIZE];
+-  size_t total_count_;
+-  double bit_cost_;
+-} FN(Histogram);
+-
+-static BROTLI_INLINE void FN(HistogramClear)(FN(Histogram)* self) {
+-  memset(self->data_, 0, sizeof(self->data_));
+-  self->total_count_ = 0;
+-  self->bit_cost_ = HUGE_VAL;
+-}
+-
+-static BROTLI_INLINE void FN(ClearHistograms)(
+-    FN(Histogram)* array, size_t length) {
+-  size_t i;
+-  for (i = 0; i < length; ++i) FN(HistogramClear)(array + i);
+-}
+-
+-static BROTLI_INLINE void FN(HistogramAdd)(FN(Histogram)* self, size_t val) {
+-  ++self->data_[val];
+-  ++self->total_count_;
+-}
+-
+-static BROTLI_INLINE void FN(HistogramAddVector)(FN(Histogram)* self,
+-    const DataType* p, size_t n) {
+-  self->total_count_ += n;
+-  n += 1;
+-  while (--n) ++self->data_[*p++];
+-}
+-
+-static BROTLI_INLINE void FN(HistogramAddHistogram)(FN(Histogram)* self,
+-    const FN(Histogram)* v) {
+-  size_t i;
+-  self->total_count_ += v->total_count_;
+-  for (i = 0; i < DATA_SIZE; ++i) {
+-    self->data_[i] += v->data_[i];
+-  }
+-}
+-
+-static BROTLI_INLINE size_t FN(HistogramDataSize)(void) { return DATA_SIZE; }
+diff --git a/modules/brotli/enc/literal_cost.c b/modules/brotli/enc/literal_cost.c
+deleted file mode 100644
+--- a/modules/brotli/enc/literal_cost.c
++++ /dev/null
+@@ -1,175 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Literal cost model to allow backward reference replacement to be efficient.
+-*/
+-
+-#include "./literal_cost.h"
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./fast_log.h"
+-#include "./utf8_util.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static size_t UTF8Position(size_t last, size_t c, size_t clamp) {
+-  if (c < 128) {
+-    return 0;  /* Next one is the 'Byte 1' again. */
+-  } else if (c >= 192) {  /* Next one is the 'Byte 2' of utf-8 encoding. */
+-    return BROTLI_MIN(size_t, 1, clamp);
+-  } else {
+-    /* Let's decide over the last byte if this ends the sequence. */
+-    if (last < 0xE0) {
+-      return 0;  /* Completed two or three byte coding. */
+-    } else {  /* Next one is the 'Byte 3' of utf-8 encoding. */
+-      return BROTLI_MIN(size_t, 2, clamp);
+-    }
+-  }
+-}
+-
+-static size_t DecideMultiByteStatsLevel(size_t pos, size_t len, size_t mask,
+-                                        const uint8_t* data) {
+-  size_t counts[3] = { 0 };
+-  size_t max_utf8 = 1;  /* should be 2, but 1 compresses better. */
+-  size_t last_c = 0;
+-  size_t i;
+-  for (i = 0; i < len; ++i) {
+-    size_t c = data[(pos + i) & mask];
+-    ++counts[UTF8Position(last_c, c, 2)];
+-    last_c = c;
+-  }
+-  if (counts[2] < 500) {
+-    max_utf8 = 1;
+-  }
+-  if (counts[1] + counts[2] < 25) {
+-    max_utf8 = 0;
+-  }
+-  return max_utf8;
+-}
+-
+-static void EstimateBitCostsForLiteralsUTF8(size_t pos, size_t len, size_t mask,
+-                                            const uint8_t* data, float* cost) {
+-  /* max_utf8 is 0 (normal ASCII single byte modeling),
+-     1 (for 2-byte UTF-8 modeling), or 2 (for 3-byte UTF-8 modeling). */
+-  const size_t max_utf8 = DecideMultiByteStatsLevel(pos, len, mask, data);
+-  size_t histogram[3][256] = { { 0 } };
+-  size_t window_half = 495;
+-  size_t in_window = BROTLI_MIN(size_t, window_half, len);
+-  size_t in_window_utf8[3] = { 0 };
+-
+-  size_t i;
+-  {  /* Bootstrap histograms. */
+-    size_t last_c = 0;
+-    size_t utf8_pos = 0;
+-    for (i = 0; i < in_window; ++i) {
+-      size_t c = data[(pos + i) & mask];
+-      ++histogram[utf8_pos][c];
+-      ++in_window_utf8[utf8_pos];
+-      utf8_pos = UTF8Position(last_c, c, max_utf8);
+-      last_c = c;
+-    }
+-  }
+-
+-  /* Compute bit costs with sliding window. */
+-  for (i = 0; i < len; ++i) {
+-    if (i >= window_half) {
+-      /* Remove a byte in the past. */
+-      size_t c =
+-          i < window_half + 1 ? 0 : data[(pos + i - window_half - 1) & mask];
+-      size_t last_c =
+-          i < window_half + 2 ? 0 : data[(pos + i - window_half - 2) & mask];
+-      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
+-      --histogram[utf8_pos2][data[(pos + i - window_half) & mask]];
+-      --in_window_utf8[utf8_pos2];
+-    }
+-    if (i + window_half < len) {
+-      /* Add a byte in the future. */
+-      size_t c = data[(pos + i + window_half - 1) & mask];
+-      size_t last_c = data[(pos + i + window_half - 2) & mask];
+-      size_t utf8_pos2 = UTF8Position(last_c, c, max_utf8);
+-      ++histogram[utf8_pos2][data[(pos + i + window_half) & mask]];
+-      ++in_window_utf8[utf8_pos2];
+-    }
+-    {
+-      size_t c = i < 1 ? 0 : data[(pos + i - 1) & mask];
+-      size_t last_c = i < 2 ? 0 : data[(pos + i - 2) & mask];
+-      size_t utf8_pos = UTF8Position(last_c, c, max_utf8);
+-      size_t masked_pos = (pos + i) & mask;
+-      size_t histo = histogram[utf8_pos][data[masked_pos]];
+-      double lit_cost;
+-      if (histo == 0) {
+-        histo = 1;
+-      }
+-      lit_cost = FastLog2(in_window_utf8[utf8_pos]) - FastLog2(histo);
+-      lit_cost += 0.02905;
+-      if (lit_cost < 1.0) {
+-        lit_cost *= 0.5;
+-        lit_cost += 0.5;
+-      }
+-      /* Make the first bytes more expensive -- seems to help, not sure why.
+-         Perhaps because the entropy source is changing its properties
+-         rapidly in the beginning of the file, perhaps because the beginning
+-         of the data is a statistical "anomaly". */
+-      if (i < 2000) {
+-        lit_cost += 0.7 - ((double)(2000 - i) / 2000.0 * 0.35);
+-      }
+-      cost[i] = (float)lit_cost;
+-    }
+-  }
+-}
+-
+-void BrotliEstimateBitCostsForLiterals(size_t pos, size_t len, size_t mask,
+-                                       const uint8_t* data, float* cost) {
+-  if (BrotliIsMostlyUTF8(data, pos, mask, len, kMinUTF8Ratio)) {
+-    EstimateBitCostsForLiteralsUTF8(pos, len, mask, data, cost);
+-    return;
+-  } else {
+-    size_t histogram[256] = { 0 };
+-    size_t window_half = 2000;
+-    size_t in_window = BROTLI_MIN(size_t, window_half, len);
+-
+-    /* Bootstrap histogram. */
+-    size_t i;
+-    for (i = 0; i < in_window; ++i) {
+-      ++histogram[data[(pos + i) & mask]];
+-    }
+-
+-    /* Compute bit costs with sliding window. */
+-    for (i = 0; i < len; ++i) {
+-      size_t histo;
+-      if (i >= window_half) {
+-        /* Remove a byte in the past. */
+-        --histogram[data[(pos + i - window_half) & mask]];
+-        --in_window;
+-      }
+-      if (i + window_half < len) {
+-        /* Add a byte in the future. */
+-        ++histogram[data[(pos + i + window_half) & mask]];
+-        ++in_window;
+-      }
+-      histo = histogram[data[(pos + i) & mask]];
+-      if (histo == 0) {
+-        histo = 1;
+-      }
+-      {
+-        double lit_cost = FastLog2(in_window) - FastLog2(histo);
+-        lit_cost += 0.029;
+-        if (lit_cost < 1.0) {
+-          lit_cost *= 0.5;
+-          lit_cost += 0.5;
+-        }
+-        cost[i] = (float)lit_cost;
+-      }
+-    }
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/literal_cost.h b/modules/brotli/enc/literal_cost.h
+deleted file mode 100644
+--- a/modules/brotli/enc/literal_cost.h
++++ /dev/null
+@@ -1,30 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Literal cost model to allow backward reference replacement to be efficient.
+-*/
+-
+-#ifndef BROTLI_ENC_LITERAL_COST_H_
+-#define BROTLI_ENC_LITERAL_COST_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* Estimates how many bits the literals in the interval [pos, pos + len) in the
+-   ring-buffer (data, mask) will take entropy coded and writes these estimates
+-   to the cost[0..len) array. */
+-BROTLI_INTERNAL void BrotliEstimateBitCostsForLiterals(
+-    size_t pos, size_t len, size_t mask, const uint8_t* data, float* cost);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_LITERAL_COST_H_ */
+diff --git a/modules/brotli/enc/memory.c b/modules/brotli/enc/memory.c
+deleted file mode 100644
+--- a/modules/brotli/enc/memory.c
++++ /dev/null
+@@ -1,170 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Algorithms for distributing the literals and commands of a metablock between
+-   block types and contexts. */
+-
+-#include "./memory.h"
+-
+-#include <stdlib.h>  /* exit, free, malloc */
+-#include <string.h>  /* memcpy */
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define MAX_PERM_ALLOCATED 128
+-#define MAX_NEW_ALLOCATED 64
+-#define MAX_NEW_FREED 64
+-
+-#define PERM_ALLOCATED_OFFSET 0
+-#define NEW_ALLOCATED_OFFSET MAX_PERM_ALLOCATED
+-#define NEW_FREED_OFFSET (MAX_PERM_ALLOCATED + MAX_NEW_ALLOCATED)
+-
+-void BrotliInitMemoryManager(
+-    MemoryManager* m, brotli_alloc_func alloc_func, brotli_free_func free_func,
+-    void* opaque) {
+-  if (!alloc_func) {
+-    m->alloc_func = BrotliDefaultAllocFunc;
+-    m->free_func = BrotliDefaultFreeFunc;
+-    m->opaque = 0;
+-  } else {
+-    m->alloc_func = alloc_func;
+-    m->free_func = free_func;
+-    m->opaque = opaque;
+-  }
+-#if !defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-  m->is_oom = BROTLI_FALSE;
+-  m->perm_allocated = 0;
+-  m->new_allocated = 0;
+-  m->new_freed = 0;
+-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-}
+-
+-#if defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-
+-void* BrotliAllocate(MemoryManager* m, size_t n) {
+-  void* result = m->alloc_func(m->opaque, n);
+-  if (!result) exit(EXIT_FAILURE);
+-  return result;
+-}
+-
+-void BrotliFree(MemoryManager* m, void* p) {
+-  m->free_func(m->opaque, p);
+-}
+-
+-void BrotliWipeOutMemoryManager(MemoryManager* m) {
+-  BROTLI_UNUSED(m);
+-}
+-
+-#else  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-
+-static void SortPointers(void** items, const size_t n) {
+-  /* Shell sort. */
+-  static const size_t gaps[] = {23, 10, 4, 1};
+-  int g = 0;
+-  for (; g < 4; ++g) {
+-    size_t gap = gaps[g];
+-    size_t i;
+-    for (i = gap; i < n; ++i) {
+-      size_t j = i;
+-      void* tmp = items[i];
+-      for (; j >= gap && tmp < items[j - gap]; j -= gap) {
+-        items[j] = items[j - gap];
+-      }
+-      items[j] = tmp;
+-    }
+-  }
+-}
+-
+-static size_t Annihilate(void** a, size_t a_len, void** b, size_t b_len) {
+-  size_t a_read_index = 0;
+-  size_t b_read_index = 0;
+-  size_t a_write_index = 0;
+-  size_t b_write_index = 0;
+-  size_t annihilated = 0;
+-  while (a_read_index < a_len && b_read_index < b_len) {
+-    if (a[a_read_index] == b[b_read_index]) {
+-      a_read_index++;
+-      b_read_index++;
+-      annihilated++;
+-    } else if (a[a_read_index] < b[b_read_index]) {
+-      a[a_write_index++] = a[a_read_index++];
+-    } else {
+-      b[b_write_index++] = b[b_read_index++];
+-    }
+-  }
+-  while (a_read_index < a_len) a[a_write_index++] = a[a_read_index++];
+-  while (b_read_index < b_len) b[b_write_index++] = b[b_read_index++];
+-  return annihilated;
+-}
+-
+-static void CollectGarbagePointers(MemoryManager* m) {
+-  size_t annihilated;
+-  SortPointers(m->pointers + NEW_ALLOCATED_OFFSET, m->new_allocated);
+-  SortPointers(m->pointers + NEW_FREED_OFFSET, m->new_freed);
+-  annihilated = Annihilate(
+-      m->pointers + NEW_ALLOCATED_OFFSET, m->new_allocated,
+-      m->pointers + NEW_FREED_OFFSET, m->new_freed);
+-  m->new_allocated -= annihilated;
+-  m->new_freed -= annihilated;
+-
+-  if (m->new_freed != 0) {
+-    annihilated = Annihilate(
+-        m->pointers + PERM_ALLOCATED_OFFSET, m->perm_allocated,
+-        m->pointers + NEW_FREED_OFFSET, m->new_freed);
+-    m->perm_allocated -= annihilated;
+-    m->new_freed -= annihilated;
+-    BROTLI_DCHECK(m->new_freed == 0);
+-  }
+-
+-  if (m->new_allocated != 0) {
+-    BROTLI_DCHECK(m->perm_allocated + m->new_allocated <= MAX_PERM_ALLOCATED);
+-    memcpy(m->pointers + PERM_ALLOCATED_OFFSET + m->perm_allocated,
+-           m->pointers + NEW_ALLOCATED_OFFSET,
+-           sizeof(void*) * m->new_allocated);
+-    m->perm_allocated += m->new_allocated;
+-    m->new_allocated = 0;
+-    SortPointers(m->pointers + PERM_ALLOCATED_OFFSET, m->perm_allocated);
+-  }
+-}
+-
+-void* BrotliAllocate(MemoryManager* m, size_t n) {
+-  void* result = m->alloc_func(m->opaque, n);
+-  if (!result) {
+-    m->is_oom = BROTLI_TRUE;
+-    return NULL;
+-  }
+-  if (m->new_allocated == MAX_NEW_ALLOCATED) CollectGarbagePointers(m);
+-  m->pointers[NEW_ALLOCATED_OFFSET + (m->new_allocated++)] = result;
+-  return result;
+-}
+-
+-void BrotliFree(MemoryManager* m, void* p) {
+-  if (!p) return;
+-  m->free_func(m->opaque, p);
+-  if (m->new_freed == MAX_NEW_FREED) CollectGarbagePointers(m);
+-  m->pointers[NEW_FREED_OFFSET + (m->new_freed++)] = p;
+-}
+-
+-void BrotliWipeOutMemoryManager(MemoryManager* m) {
+-  size_t i;
+-  CollectGarbagePointers(m);
+-  /* Now all unfreed pointers are in perm-allocated list. */
+-  for (i = 0; i < m->perm_allocated; ++i) {
+-    m->free_func(m->opaque, m->pointers[PERM_ALLOCATED_OFFSET + i]);
+-  }
+-  m->perm_allocated = 0;
+-}
+-
+-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/memory.h b/modules/brotli/enc/memory.h
+deleted file mode 100644
+--- a/modules/brotli/enc/memory.h
++++ /dev/null
+@@ -1,114 +0,0 @@
+-/* Copyright 2016 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Macros for memory management. */
+-
+-#ifndef BROTLI_ENC_MEMORY_H_
+-#define BROTLI_ENC_MEMORY_H_
+-
+-#include <string.h>  /* memcpy */
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#if !defined(BROTLI_ENCODER_CLEANUP_ON_OOM) && \
+-    !defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-#define BROTLI_ENCODER_EXIT_ON_OOM
+-#endif
+-
+-typedef struct MemoryManager {
+-  brotli_alloc_func alloc_func;
+-  brotli_free_func free_func;
+-  void* opaque;
+-#if !defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-  BROTLI_BOOL is_oom;
+-  size_t perm_allocated;
+-  size_t new_allocated;
+-  size_t new_freed;
+-  void* pointers[256];
+-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-} MemoryManager;
+-
+-BROTLI_INTERNAL void BrotliInitMemoryManager(
+-    MemoryManager* m, brotli_alloc_func alloc_func, brotli_free_func free_func,
+-    void* opaque);
+-
+-BROTLI_INTERNAL void* BrotliAllocate(MemoryManager* m, size_t n);
+-#define BROTLI_ALLOC(M, T, N)                               \
+-  ((N) > 0 ? ((T*)BrotliAllocate((M), (N) * sizeof(T))) : NULL)
+-
+-BROTLI_INTERNAL void BrotliFree(MemoryManager* m, void* p);
+-#define BROTLI_FREE(M, P) { \
+-  BrotliFree((M), (P));     \
+-  P = NULL;                 \
+-}
+-
+-#if defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-#define BROTLI_IS_OOM(M) (!!0)
+-#else  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-#define BROTLI_IS_OOM(M) (!!(M)->is_oom)
+-#endif  /* BROTLI_ENCODER_EXIT_ON_OOM */
+-
+-/*
+-BROTLI_IS_NULL is a fake check, BROTLI_IS_OOM does the heavy lifting.
+-The only purpose of it is to explain static analyzers the state of things.
+-NB: use ONLY together with BROTLI_IS_OOM
+-    AND ONLY for allocations in the current scope.
+- */
+-#if defined(__clang_analyzer__) && !defined(BROTLI_ENCODER_EXIT_ON_OOM)
+-#define BROTLI_IS_NULL(A) ((A) == nullptr)
+-#else  /* defined(__clang_analyzer__) */
+-#define BROTLI_IS_NULL(A) (!!0)
+-#endif  /* defined(__clang_analyzer__) */
+-
+-BROTLI_INTERNAL void BrotliWipeOutMemoryManager(MemoryManager* m);
+-
+-/*
+-Dynamically grows array capacity to at least the requested size
+-M: MemoryManager
+-T: data type
+-A: array
+-C: capacity
+-R: requested size
+-*/
+-#define BROTLI_ENSURE_CAPACITY(M, T, A, C, R) {                    \
+-  if (C < (R)) {                                                   \
+-    size_t _new_size = (C == 0) ? (R) : C;                         \
+-    T* new_array;                                                  \
+-    while (_new_size < (R)) _new_size *= 2;                        \
+-    new_array = BROTLI_ALLOC((M), T, _new_size);                   \
+-    if (!BROTLI_IS_OOM(M) && !BROTLI_IS_NULL(new_array) && C != 0) \
+-      memcpy(new_array, A, C * sizeof(T));                         \
+-    BROTLI_FREE((M), A);                                           \
+-    A = new_array;                                                 \
+-    C = _new_size;                                                 \
+-  }                                                                \
+-}
+-
+-/*
+-Appends value and dynamically grows array capacity when needed
+-M: MemoryManager
+-T: data type
+-A: array
+-C: array capacity
+-S: array size
+-V: value to append
+-*/
+-#define BROTLI_ENSURE_CAPACITY_APPEND(M, T, A, C, S, V) { \
+-  (S)++;                                                  \
+-  BROTLI_ENSURE_CAPACITY(M, T, A, C, S);                  \
+-  A[(S) - 1] = (V);                                       \
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_MEMORY_H_ */
+diff --git a/modules/brotli/enc/metablock.c b/modules/brotli/enc/metablock.c
+deleted file mode 100644
+--- a/modules/brotli/enc/metablock.c
++++ /dev/null
+@@ -1,663 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Algorithms for distributing the literals and commands of a metablock between
+-   block types and contexts. */
+-
+-#include "./metablock.h"
+-
+-#include "../common/constants.h"
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./bit_cost.h"
+-#include "./block_splitter.h"
+-#include "./cluster.h"
+-#include "./entropy_encode.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-void BrotliInitDistanceParams(BrotliEncoderParams* params,
+-    uint32_t npostfix, uint32_t ndirect) {
+-  BrotliDistanceParams* dist_params = &params->dist;
+-  uint32_t alphabet_size_max;
+-  uint32_t alphabet_size_limit;
+-  uint32_t max_distance;
+-
+-  dist_params->distance_postfix_bits = npostfix;
+-  dist_params->num_direct_distance_codes = ndirect;
+-
+-  alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE(
+-      npostfix, ndirect, BROTLI_MAX_DISTANCE_BITS);
+-  alphabet_size_limit = alphabet_size_max;
+-  max_distance = ndirect + (1U << (BROTLI_MAX_DISTANCE_BITS + npostfix + 2)) -
+-      (1U << (npostfix + 2));
+-
+-  if (params->large_window) {
+-    BrotliDistanceCodeLimit limit = BrotliCalculateDistanceCodeLimit(
+-        BROTLI_MAX_ALLOWED_DISTANCE, npostfix, ndirect);
+-    alphabet_size_max = BROTLI_DISTANCE_ALPHABET_SIZE(
+-        npostfix, ndirect, BROTLI_LARGE_MAX_DISTANCE_BITS);
+-    alphabet_size_limit = limit.max_alphabet_size;
+-    max_distance = limit.max_distance;
+-  }
+-
+-  dist_params->alphabet_size_max = alphabet_size_max;
+-  dist_params->alphabet_size_limit = alphabet_size_limit;
+-  dist_params->max_distance = max_distance;
+-}
+-
+-static void RecomputeDistancePrefixes(Command* cmds,
+-                                      size_t num_commands,
+-                                      const BrotliDistanceParams* orig_params,
+-                                      const BrotliDistanceParams* new_params) {
+-  size_t i;
+-
+-  if (orig_params->distance_postfix_bits == new_params->distance_postfix_bits &&
+-      orig_params->num_direct_distance_codes ==
+-      new_params->num_direct_distance_codes) {
+-    return;
+-  }
+-
+-  for (i = 0; i < num_commands; ++i) {
+-    Command* cmd = &cmds[i];
+-    if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
+-      PrefixEncodeCopyDistance(CommandRestoreDistanceCode(cmd, orig_params),
+-                               new_params->num_direct_distance_codes,
+-                               new_params->distance_postfix_bits,
+-                               &cmd->dist_prefix_,
+-                               &cmd->dist_extra_);
+-    }
+-  }
+-}
+-
+-static BROTLI_BOOL ComputeDistanceCost(const Command* cmds,
+-                                       size_t num_commands,
+-                                       const BrotliDistanceParams* orig_params,
+-                                       const BrotliDistanceParams* new_params,
+-                                       double* cost) {
+-  size_t i;
+-  BROTLI_BOOL equal_params = BROTLI_FALSE;
+-  uint16_t dist_prefix;
+-  uint32_t dist_extra;
+-  double extra_bits = 0.0;
+-  HistogramDistance histo;
+-  HistogramClearDistance(&histo);
+-
+-  if (orig_params->distance_postfix_bits == new_params->distance_postfix_bits &&
+-      orig_params->num_direct_distance_codes ==
+-      new_params->num_direct_distance_codes) {
+-    equal_params = BROTLI_TRUE;
+-  }
+-
+-  for (i = 0; i < num_commands; i++) {
+-    const Command* cmd = &cmds[i];
+-    if (CommandCopyLen(cmd) && cmd->cmd_prefix_ >= 128) {
+-      if (equal_params) {
+-        dist_prefix = cmd->dist_prefix_;
+-      } else {
+-        uint32_t distance = CommandRestoreDistanceCode(cmd, orig_params);
+-        if (distance > new_params->max_distance) {
+-          return BROTLI_FALSE;
+-        }
+-        PrefixEncodeCopyDistance(distance,
+-                                 new_params->num_direct_distance_codes,
+-                                 new_params->distance_postfix_bits,
+-                                 &dist_prefix,
+-                                 &dist_extra);
+-      }
+-      HistogramAddDistance(&histo, dist_prefix & 0x3FF);
+-      extra_bits += dist_prefix >> 10;
+-    }
+-  }
+-
+-  *cost = BrotliPopulationCostDistance(&histo) + extra_bits;
+-  return BROTLI_TRUE;
+-}
+-
+-void BrotliBuildMetaBlock(MemoryManager* m,
+-                          const uint8_t* ringbuffer,
+-                          const size_t pos,
+-                          const size_t mask,
+-                          BrotliEncoderParams* params,
+-                          uint8_t prev_byte,
+-                          uint8_t prev_byte2,
+-                          Command* cmds,
+-                          size_t num_commands,
+-                          ContextType literal_context_mode,
+-                          MetaBlockSplit* mb) {
+-  /* Histogram ids need to fit in one byte. */
+-  static const size_t kMaxNumberOfHistograms = 256;
+-  HistogramDistance* distance_histograms;
+-  HistogramLiteral* literal_histograms;
+-  ContextType* literal_context_modes = NULL;
+-  size_t literal_histograms_size;
+-  size_t distance_histograms_size;
+-  size_t i;
+-  size_t literal_context_multiplier = 1;
+-  uint32_t npostfix;
+-  uint32_t ndirect_msb = 0;
+-  BROTLI_BOOL check_orig = BROTLI_TRUE;
+-  double best_dist_cost = 1e99;
+-  BrotliEncoderParams orig_params = *params;
+-  BrotliEncoderParams new_params = *params;
+-
+-  for (npostfix = 0; npostfix <= BROTLI_MAX_NPOSTFIX; npostfix++) {
+-    for (; ndirect_msb < 16; ndirect_msb++) {
+-      uint32_t ndirect = ndirect_msb << npostfix;
+-      BROTLI_BOOL skip;
+-      double dist_cost;
+-      BrotliInitDistanceParams(&new_params, npostfix, ndirect);
+-      if (npostfix == orig_params.dist.distance_postfix_bits &&
+-          ndirect == orig_params.dist.num_direct_distance_codes) {
+-        check_orig = BROTLI_FALSE;
+-      }
+-      skip = !ComputeDistanceCost(
+-          cmds, num_commands,
+-          &orig_params.dist, &new_params.dist, &dist_cost);
+-      if (skip || (dist_cost > best_dist_cost)) {
+-        break;
+-      }
+-      best_dist_cost = dist_cost;
+-      params->dist = new_params.dist;
+-    }
+-    if (ndirect_msb > 0) ndirect_msb--;
+-    ndirect_msb /= 2;
+-  }
+-  if (check_orig) {
+-    double dist_cost;
+-    ComputeDistanceCost(cmds, num_commands,
+-                        &orig_params.dist, &orig_params.dist, &dist_cost);
+-    if (dist_cost < best_dist_cost) {
+-      /* NB: currently unused; uncomment when more param tuning is added. */
+-      /* best_dist_cost = dist_cost; */
+-      params->dist = orig_params.dist;
+-    }
+-  }
+-  RecomputeDistancePrefixes(cmds, num_commands,
+-                            &orig_params.dist, &params->dist);
+-
+-  BrotliSplitBlock(m, cmds, num_commands,
+-                   ringbuffer, pos, mask, params,
+-                   &mb->literal_split,
+-                   &mb->command_split,
+-                   &mb->distance_split);
+-  if (BROTLI_IS_OOM(m)) return;
+-
+-  if (!params->disable_literal_context_modeling) {
+-    literal_context_multiplier = 1 << BROTLI_LITERAL_CONTEXT_BITS;
+-    literal_context_modes =
+-        BROTLI_ALLOC(m, ContextType, mb->literal_split.num_types);
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literal_context_modes)) return;
+-    for (i = 0; i < mb->literal_split.num_types; ++i) {
+-      literal_context_modes[i] = literal_context_mode;
+-    }
+-  }
+-
+-  literal_histograms_size =
+-      mb->literal_split.num_types * literal_context_multiplier;
+-  literal_histograms =
+-      BROTLI_ALLOC(m, HistogramLiteral, literal_histograms_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(literal_histograms)) return;
+-  ClearHistogramsLiteral(literal_histograms, literal_histograms_size);
+-
+-  distance_histograms_size =
+-      mb->distance_split.num_types << BROTLI_DISTANCE_CONTEXT_BITS;
+-  distance_histograms =
+-      BROTLI_ALLOC(m, HistogramDistance, distance_histograms_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(distance_histograms)) return;
+-  ClearHistogramsDistance(distance_histograms, distance_histograms_size);
+-
+-  BROTLI_DCHECK(mb->command_histograms == 0);
+-  mb->command_histograms_size = mb->command_split.num_types;
+-  mb->command_histograms =
+-      BROTLI_ALLOC(m, HistogramCommand, mb->command_histograms_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->command_histograms)) return;
+-  ClearHistogramsCommand(mb->command_histograms, mb->command_histograms_size);
+-
+-  BrotliBuildHistogramsWithContext(cmds, num_commands,
+-      &mb->literal_split, &mb->command_split, &mb->distance_split,
+-      ringbuffer, pos, mask, prev_byte, prev_byte2, literal_context_modes,
+-      literal_histograms, mb->command_histograms, distance_histograms);
+-  BROTLI_FREE(m, literal_context_modes);
+-
+-  BROTLI_DCHECK(mb->literal_context_map == 0);
+-  mb->literal_context_map_size =
+-      mb->literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS;
+-  mb->literal_context_map =
+-      BROTLI_ALLOC(m, uint32_t, mb->literal_context_map_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_context_map)) return;
+-
+-  BROTLI_DCHECK(mb->literal_histograms == 0);
+-  mb->literal_histograms_size = mb->literal_context_map_size;
+-  mb->literal_histograms =
+-      BROTLI_ALLOC(m, HistogramLiteral, mb->literal_histograms_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_histograms)) return;
+-
+-  BrotliClusterHistogramsLiteral(m, literal_histograms, literal_histograms_size,
+-      kMaxNumberOfHistograms, mb->literal_histograms,
+-      &mb->literal_histograms_size, mb->literal_context_map);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BROTLI_FREE(m, literal_histograms);
+-
+-  if (params->disable_literal_context_modeling) {
+-    /* Distribute assignment to all contexts. */
+-    for (i = mb->literal_split.num_types; i != 0;) {
+-      size_t j = 0;
+-      i--;
+-      for (; j < (1 << BROTLI_LITERAL_CONTEXT_BITS); j++) {
+-        mb->literal_context_map[(i << BROTLI_LITERAL_CONTEXT_BITS) + j] =
+-            mb->literal_context_map[i];
+-      }
+-    }
+-  }
+-
+-  BROTLI_DCHECK(mb->distance_context_map == 0);
+-  mb->distance_context_map_size =
+-      mb->distance_split.num_types << BROTLI_DISTANCE_CONTEXT_BITS;
+-  mb->distance_context_map =
+-      BROTLI_ALLOC(m, uint32_t, mb->distance_context_map_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->distance_context_map)) return;
+-
+-  BROTLI_DCHECK(mb->distance_histograms == 0);
+-  mb->distance_histograms_size = mb->distance_context_map_size;
+-  mb->distance_histograms =
+-      BROTLI_ALLOC(m, HistogramDistance, mb->distance_histograms_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->distance_histograms)) return;
+-
+-  BrotliClusterHistogramsDistance(m, distance_histograms,
+-                                  mb->distance_context_map_size,
+-                                  kMaxNumberOfHistograms,
+-                                  mb->distance_histograms,
+-                                  &mb->distance_histograms_size,
+-                                  mb->distance_context_map);
+-  if (BROTLI_IS_OOM(m)) return;
+-  BROTLI_FREE(m, distance_histograms);
+-}
+-
+-#define FN(X) X ## Literal
+-#include "./metablock_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Command
+-#include "./metablock_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define FN(X) X ## Distance
+-#include "./metablock_inc.h"  /* NOLINT(build/include) */
+-#undef FN
+-
+-#define BROTLI_MAX_STATIC_CONTEXTS 13
+-
+-/* Greedy block splitter for one block category (literal, command or distance).
+-   Gathers histograms for all context buckets. */
+-typedef struct ContextBlockSplitter {
+-  /* Alphabet size of particular block category. */
+-  size_t alphabet_size_;
+-  size_t num_contexts_;
+-  size_t max_block_types_;
+-  /* We collect at least this many symbols for each block. */
+-  size_t min_block_size_;
+-  /* We merge histograms A and B if
+-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
+-     where A is the current histogram and B is the histogram of the last or the
+-     second last block type. */
+-  double split_threshold_;
+-
+-  size_t num_blocks_;
+-  BlockSplit* split_;  /* not owned */
+-  HistogramLiteral* histograms_;  /* not owned */
+-  size_t* histograms_size_;  /* not owned */
+-
+-  /* The number of symbols that we want to collect before deciding on whether
+-     or not to merge the block with a previous one or emit a new block. */
+-  size_t target_block_size_;
+-  /* The number of symbols in the current histogram. */
+-  size_t block_size_;
+-  /* Offset of the current histogram. */
+-  size_t curr_histogram_ix_;
+-  /* Offset of the histograms of the previous two block types. */
+-  size_t last_histogram_ix_[2];
+-  /* Entropy of the previous two block types. */
+-  double last_entropy_[2 * BROTLI_MAX_STATIC_CONTEXTS];
+-  /* The number of times we merged the current block with the last one. */
+-  size_t merge_last_count_;
+-} ContextBlockSplitter;
+-
+-static void InitContextBlockSplitter(
+-    MemoryManager* m, ContextBlockSplitter* self, size_t alphabet_size,
+-    size_t num_contexts, size_t min_block_size, double split_threshold,
+-    size_t num_symbols, BlockSplit* split, HistogramLiteral** histograms,
+-    size_t* histograms_size) {
+-  size_t max_num_blocks = num_symbols / min_block_size + 1;
+-  size_t max_num_types;
+-  BROTLI_DCHECK(num_contexts <= BROTLI_MAX_STATIC_CONTEXTS);
+-
+-  self->alphabet_size_ = alphabet_size;
+-  self->num_contexts_ = num_contexts;
+-  self->max_block_types_ = BROTLI_MAX_NUMBER_OF_BLOCK_TYPES / num_contexts;
+-  self->min_block_size_ = min_block_size;
+-  self->split_threshold_ = split_threshold;
+-  self->num_blocks_ = 0;
+-  self->split_ = split;
+-  self->histograms_size_ = histograms_size;
+-  self->target_block_size_ = min_block_size;
+-  self->block_size_ = 0;
+-  self->curr_histogram_ix_ = 0;
+-  self->merge_last_count_ = 0;
+-
+-  /* We have to allocate one more histogram than the maximum number of block
+-     types for the current histogram when the meta-block is too big. */
+-  max_num_types =
+-      BROTLI_MIN(size_t, max_num_blocks, self->max_block_types_ + 1);
+-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
+-      split->types, split->types_alloc_size, max_num_blocks);
+-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
+-      split->lengths, split->lengths_alloc_size, max_num_blocks);
+-  if (BROTLI_IS_OOM(m)) return;
+-  split->num_blocks = max_num_blocks;
+-  if (BROTLI_IS_OOM(m)) return;
+-  BROTLI_DCHECK(*histograms == 0);
+-  *histograms_size = max_num_types * num_contexts;
+-  *histograms = BROTLI_ALLOC(m, HistogramLiteral, *histograms_size);
+-  self->histograms_ = *histograms;
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
+-  /* Clear only current histogram. */
+-  ClearHistogramsLiteral(&self->histograms_[0], num_contexts);
+-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
+-}
+-
+-/* Does either of three things:
+-     (1) emits the current block with a new block type;
+-     (2) emits the current block with the type of the second last block;
+-     (3) merges the current block with the last block. */
+-static void ContextBlockSplitterFinishBlock(
+-    ContextBlockSplitter* self, MemoryManager* m, BROTLI_BOOL is_final) {
+-  BlockSplit* split = self->split_;
+-  const size_t num_contexts = self->num_contexts_;
+-  double* last_entropy = self->last_entropy_;
+-  HistogramLiteral* histograms = self->histograms_;
+-
+-  if (self->block_size_ < self->min_block_size_) {
+-    self->block_size_ = self->min_block_size_;
+-  }
+-  if (self->num_blocks_ == 0) {
+-    size_t i;
+-    /* Create first block. */
+-    split->lengths[0] = (uint32_t)self->block_size_;
+-    split->types[0] = 0;
+-
+-    for (i = 0; i < num_contexts; ++i) {
+-      last_entropy[i] =
+-          BitsEntropy(histograms[i].data_, self->alphabet_size_);
+-      last_entropy[num_contexts + i] = last_entropy[i];
+-    }
+-    ++self->num_blocks_;
+-    ++split->num_types;
+-    self->curr_histogram_ix_ += num_contexts;
+-    if (self->curr_histogram_ix_ < *self->histograms_size_) {
+-      ClearHistogramsLiteral(
+-          &self->histograms_[self->curr_histogram_ix_], self->num_contexts_);
+-    }
+-    self->block_size_ = 0;
+-  } else if (self->block_size_ > 0) {
+-    /* Try merging the set of histograms for the current block type with the
+-       respective set of histograms for the last and second last block types.
+-       Decide over the split based on the total reduction of entropy across
+-       all contexts. */
+-    double entropy[BROTLI_MAX_STATIC_CONTEXTS];
+-    HistogramLiteral* combined_histo =
+-        BROTLI_ALLOC(m, HistogramLiteral, 2 * num_contexts);
+-    double combined_entropy[2 * BROTLI_MAX_STATIC_CONTEXTS];
+-    double diff[2] = { 0.0 };
+-    size_t i;
+-    if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(combined_histo)) return;
+-    for (i = 0; i < num_contexts; ++i) {
+-      size_t curr_histo_ix = self->curr_histogram_ix_ + i;
+-      size_t j;
+-      entropy[i] = BitsEntropy(histograms[curr_histo_ix].data_,
+-                               self->alphabet_size_);
+-      for (j = 0; j < 2; ++j) {
+-        size_t jx = j * num_contexts + i;
+-        size_t last_histogram_ix = self->last_histogram_ix_[j] + i;
+-        combined_histo[jx] = histograms[curr_histo_ix];
+-        HistogramAddHistogramLiteral(&combined_histo[jx],
+-            &histograms[last_histogram_ix]);
+-        combined_entropy[jx] = BitsEntropy(
+-            &combined_histo[jx].data_[0], self->alphabet_size_);
+-        diff[j] += combined_entropy[jx] - entropy[i] - last_entropy[jx];
+-      }
+-    }
+-
+-    if (split->num_types < self->max_block_types_ &&
+-        diff[0] > self->split_threshold_ &&
+-        diff[1] > self->split_threshold_) {
+-      /* Create new block. */
+-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
+-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
+-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
+-      self->last_histogram_ix_[0] = split->num_types * num_contexts;
+-      for (i = 0; i < num_contexts; ++i) {
+-        last_entropy[num_contexts + i] = last_entropy[i];
+-        last_entropy[i] = entropy[i];
+-      }
+-      ++self->num_blocks_;
+-      ++split->num_types;
+-      self->curr_histogram_ix_ += num_contexts;
+-      if (self->curr_histogram_ix_ < *self->histograms_size_) {
+-        ClearHistogramsLiteral(
+-            &self->histograms_[self->curr_histogram_ix_], self->num_contexts_);
+-      }
+-      self->block_size_ = 0;
+-      self->merge_last_count_ = 0;
+-      self->target_block_size_ = self->min_block_size_;
+-    } else if (diff[1] < diff[0] - 20.0) {
+-      /* Combine this block with second last block. */
+-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
+-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
+-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
+-      for (i = 0; i < num_contexts; ++i) {
+-        histograms[self->last_histogram_ix_[0] + i] =
+-            combined_histo[num_contexts + i];
+-        last_entropy[num_contexts + i] = last_entropy[i];
+-        last_entropy[i] = combined_entropy[num_contexts + i];
+-        HistogramClearLiteral(&histograms[self->curr_histogram_ix_ + i]);
+-      }
+-      ++self->num_blocks_;
+-      self->block_size_ = 0;
+-      self->merge_last_count_ = 0;
+-      self->target_block_size_ = self->min_block_size_;
+-    } else {
+-      /* Combine this block with last block. */
+-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
+-      for (i = 0; i < num_contexts; ++i) {
+-        histograms[self->last_histogram_ix_[0] + i] = combined_histo[i];
+-        last_entropy[i] = combined_entropy[i];
+-        if (split->num_types == 1) {
+-          last_entropy[num_contexts + i] = last_entropy[i];
+-        }
+-        HistogramClearLiteral(&histograms[self->curr_histogram_ix_ + i]);
+-      }
+-      self->block_size_ = 0;
+-      if (++self->merge_last_count_ > 1) {
+-        self->target_block_size_ += self->min_block_size_;
+-      }
+-    }
+-    BROTLI_FREE(m, combined_histo);
+-  }
+-  if (is_final) {
+-    *self->histograms_size_ = split->num_types * num_contexts;
+-    split->num_blocks = self->num_blocks_;
+-  }
+-}
+-
+-/* Adds the next symbol to the current block type and context. When the
+-   current block reaches the target size, decides on merging the block. */
+-static void ContextBlockSplitterAddSymbol(
+-    ContextBlockSplitter* self, MemoryManager* m,
+-    size_t symbol, size_t context) {
+-  HistogramAddLiteral(&self->histograms_[self->curr_histogram_ix_ + context],
+-      symbol);
+-  ++self->block_size_;
+-  if (self->block_size_ == self->target_block_size_) {
+-    ContextBlockSplitterFinishBlock(self, m, /* is_final = */ BROTLI_FALSE);
+-    if (BROTLI_IS_OOM(m)) return;
+-  }
+-}
+-
+-static void MapStaticContexts(MemoryManager* m,
+-                              size_t num_contexts,
+-                              const uint32_t* static_context_map,
+-                              MetaBlockSplit* mb) {
+-  size_t i;
+-  BROTLI_DCHECK(mb->literal_context_map == 0);
+-  mb->literal_context_map_size =
+-      mb->literal_split.num_types << BROTLI_LITERAL_CONTEXT_BITS;
+-  mb->literal_context_map =
+-      BROTLI_ALLOC(m, uint32_t, mb->literal_context_map_size);
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(mb->literal_context_map)) return;
+-
+-  for (i = 0; i < mb->literal_split.num_types; ++i) {
+-    uint32_t offset = (uint32_t)(i * num_contexts);
+-    size_t j;
+-    for (j = 0; j < (1u << BROTLI_LITERAL_CONTEXT_BITS); ++j) {
+-      mb->literal_context_map[(i << BROTLI_LITERAL_CONTEXT_BITS) + j] =
+-          offset + static_context_map[j];
+-    }
+-  }
+-}
+-
+-static BROTLI_INLINE void BrotliBuildMetaBlockGreedyInternal(
+-    MemoryManager* m, const uint8_t* ringbuffer, size_t pos, size_t mask,
+-    uint8_t prev_byte, uint8_t prev_byte2, ContextLut literal_context_lut,
+-    const size_t num_contexts, const uint32_t* static_context_map,
+-    const Command* commands, size_t n_commands, MetaBlockSplit* mb) {
+-  union {
+-    BlockSplitterLiteral plain;
+-    ContextBlockSplitter ctx;
+-  } lit_blocks;
+-  BlockSplitterCommand cmd_blocks;
+-  BlockSplitterDistance dist_blocks;
+-  size_t num_literals = 0;
+-  size_t i;
+-  for (i = 0; i < n_commands; ++i) {
+-    num_literals += commands[i].insert_len_;
+-  }
+-
+-  if (num_contexts == 1) {
+-    InitBlockSplitterLiteral(m, &lit_blocks.plain, 256, 512, 400.0,
+-        num_literals, &mb->literal_split, &mb->literal_histograms,
+-        &mb->literal_histograms_size);
+-  } else {
+-    InitContextBlockSplitter(m, &lit_blocks.ctx, 256, num_contexts, 512, 400.0,
+-        num_literals, &mb->literal_split, &mb->literal_histograms,
+-        &mb->literal_histograms_size);
+-  }
+-  if (BROTLI_IS_OOM(m)) return;
+-  InitBlockSplitterCommand(m, &cmd_blocks, BROTLI_NUM_COMMAND_SYMBOLS, 1024,
+-      500.0, n_commands, &mb->command_split, &mb->command_histograms,
+-      &mb->command_histograms_size);
+-  if (BROTLI_IS_OOM(m)) return;
+-  InitBlockSplitterDistance(m, &dist_blocks, 64, 512, 100.0, n_commands,
+-      &mb->distance_split, &mb->distance_histograms,
+-      &mb->distance_histograms_size);
+-  if (BROTLI_IS_OOM(m)) return;
+-
+-  for (i = 0; i < n_commands; ++i) {
+-    const Command cmd = commands[i];
+-    size_t j;
+-    BlockSplitterAddSymbolCommand(&cmd_blocks, cmd.cmd_prefix_);
+-    for (j = cmd.insert_len_; j != 0; --j) {
+-      uint8_t literal = ringbuffer[pos & mask];
+-      if (num_contexts == 1) {
+-        BlockSplitterAddSymbolLiteral(&lit_blocks.plain, literal);
+-      } else {
+-        size_t context =
+-            BROTLI_CONTEXT(prev_byte, prev_byte2, literal_context_lut);
+-        ContextBlockSplitterAddSymbol(&lit_blocks.ctx, m, literal,
+-                                      static_context_map[context]);
+-        if (BROTLI_IS_OOM(m)) return;
+-      }
+-      prev_byte2 = prev_byte;
+-      prev_byte = literal;
+-      ++pos;
+-    }
+-    pos += CommandCopyLen(&cmd);
+-    if (CommandCopyLen(&cmd)) {
+-      prev_byte2 = ringbuffer[(pos - 2) & mask];
+-      prev_byte = ringbuffer[(pos - 1) & mask];
+-      if (cmd.cmd_prefix_ >= 128) {
+-        BlockSplitterAddSymbolDistance(&dist_blocks, cmd.dist_prefix_ & 0x3FF);
+-      }
+-    }
+-  }
+-
+-  if (num_contexts == 1) {
+-    BlockSplitterFinishBlockLiteral(
+-        &lit_blocks.plain, /* is_final = */ BROTLI_TRUE);
+-  } else {
+-    ContextBlockSplitterFinishBlock(
+-        &lit_blocks.ctx, m, /* is_final = */ BROTLI_TRUE);
+-    if (BROTLI_IS_OOM(m)) return;
+-  }
+-  BlockSplitterFinishBlockCommand(&cmd_blocks, /* is_final = */ BROTLI_TRUE);
+-  BlockSplitterFinishBlockDistance(&dist_blocks, /* is_final = */ BROTLI_TRUE);
+-
+-  if (num_contexts > 1) {
+-    MapStaticContexts(m, num_contexts, static_context_map, mb);
+-  }
+-}
+-
+-void BrotliBuildMetaBlockGreedy(MemoryManager* m,
+-                                const uint8_t* ringbuffer,
+-                                size_t pos,
+-                                size_t mask,
+-                                uint8_t prev_byte,
+-                                uint8_t prev_byte2,
+-                                ContextLut literal_context_lut,
+-                                size_t num_contexts,
+-                                const uint32_t* static_context_map,
+-                                const Command* commands,
+-                                size_t n_commands,
+-                                MetaBlockSplit* mb) {
+-  if (num_contexts == 1) {
+-    BrotliBuildMetaBlockGreedyInternal(m, ringbuffer, pos, mask, prev_byte,
+-        prev_byte2, literal_context_lut, 1, NULL, commands, n_commands, mb);
+-  } else {
+-    BrotliBuildMetaBlockGreedyInternal(m, ringbuffer, pos, mask, prev_byte,
+-        prev_byte2, literal_context_lut, num_contexts, static_context_map,
+-        commands, n_commands, mb);
+-  }
+-}
+-
+-void BrotliOptimizeHistograms(uint32_t num_distance_codes,
+-                              MetaBlockSplit* mb) {
+-  uint8_t good_for_rle[BROTLI_NUM_COMMAND_SYMBOLS];
+-  size_t i;
+-  for (i = 0; i < mb->literal_histograms_size; ++i) {
+-    BrotliOptimizeHuffmanCountsForRle(256, mb->literal_histograms[i].data_,
+-                                      good_for_rle);
+-  }
+-  for (i = 0; i < mb->command_histograms_size; ++i) {
+-    BrotliOptimizeHuffmanCountsForRle(BROTLI_NUM_COMMAND_SYMBOLS,
+-                                      mb->command_histograms[i].data_,
+-                                      good_for_rle);
+-  }
+-  for (i = 0; i < mb->distance_histograms_size; ++i) {
+-    BrotliOptimizeHuffmanCountsForRle(num_distance_codes,
+-                                      mb->distance_histograms[i].data_,
+-                                      good_for_rle);
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/metablock.h b/modules/brotli/enc/metablock.h
+deleted file mode 100644
+--- a/modules/brotli/enc/metablock.h
++++ /dev/null
+@@ -1,105 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Algorithms for distributing the literals and commands of a metablock between
+-   block types and contexts. */
+-
+-#ifndef BROTLI_ENC_METABLOCK_H_
+-#define BROTLI_ENC_METABLOCK_H_
+-
+-#include "../common/context.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./block_splitter.h"
+-#include "./command.h"
+-#include "./histogram.h"
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct MetaBlockSplit {
+-  BlockSplit literal_split;
+-  BlockSplit command_split;
+-  BlockSplit distance_split;
+-  uint32_t* literal_context_map;
+-  size_t literal_context_map_size;
+-  uint32_t* distance_context_map;
+-  size_t distance_context_map_size;
+-  HistogramLiteral* literal_histograms;
+-  size_t literal_histograms_size;
+-  HistogramCommand* command_histograms;
+-  size_t command_histograms_size;
+-  HistogramDistance* distance_histograms;
+-  size_t distance_histograms_size;
+-} MetaBlockSplit;
+-
+-static BROTLI_INLINE void InitMetaBlockSplit(MetaBlockSplit* mb) {
+-  BrotliInitBlockSplit(&mb->literal_split);
+-  BrotliInitBlockSplit(&mb->command_split);
+-  BrotliInitBlockSplit(&mb->distance_split);
+-  mb->literal_context_map = 0;
+-  mb->literal_context_map_size = 0;
+-  mb->distance_context_map = 0;
+-  mb->distance_context_map_size = 0;
+-  mb->literal_histograms = 0;
+-  mb->literal_histograms_size = 0;
+-  mb->command_histograms = 0;
+-  mb->command_histograms_size = 0;
+-  mb->distance_histograms = 0;
+-  mb->distance_histograms_size = 0;
+-}
+-
+-static BROTLI_INLINE void DestroyMetaBlockSplit(
+-    MemoryManager* m, MetaBlockSplit* mb) {
+-  BrotliDestroyBlockSplit(m, &mb->literal_split);
+-  BrotliDestroyBlockSplit(m, &mb->command_split);
+-  BrotliDestroyBlockSplit(m, &mb->distance_split);
+-  BROTLI_FREE(m, mb->literal_context_map);
+-  BROTLI_FREE(m, mb->distance_context_map);
+-  BROTLI_FREE(m, mb->literal_histograms);
+-  BROTLI_FREE(m, mb->command_histograms);
+-  BROTLI_FREE(m, mb->distance_histograms);
+-}
+-
+-/* Uses the slow shortest-path block splitter and does context clustering.
+-   The distance parameters are dynamically selected based on the commands
+-   which get recomputed under the new distance parameters. The new distance
+-   parameters are stored into *params. */
+-BROTLI_INTERNAL void BrotliBuildMetaBlock(MemoryManager* m,
+-                                          const uint8_t* ringbuffer,
+-                                          const size_t pos,
+-                                          const size_t mask,
+-                                          BrotliEncoderParams* params,
+-                                          uint8_t prev_byte,
+-                                          uint8_t prev_byte2,
+-                                          Command* cmds,
+-                                          size_t num_commands,
+-                                          ContextType literal_context_mode,
+-                                          MetaBlockSplit* mb);
+-
+-/* Uses a fast greedy block splitter that tries to merge current block with the
+-   last or the second last block and uses a static context clustering which
+-   is the same for all block types. */
+-BROTLI_INTERNAL void BrotliBuildMetaBlockGreedy(
+-    MemoryManager* m, const uint8_t* ringbuffer, size_t pos, size_t mask,
+-    uint8_t prev_byte, uint8_t prev_byte2, ContextLut literal_context_lut,
+-    size_t num_contexts, const uint32_t* static_context_map,
+-    const Command* commands, size_t n_commands, MetaBlockSplit* mb);
+-
+-BROTLI_INTERNAL void BrotliOptimizeHistograms(uint32_t num_distance_codes,
+-                                              MetaBlockSplit* mb);
+-
+-BROTLI_INTERNAL void BrotliInitDistanceParams(BrotliEncoderParams* params,
+-    uint32_t npostfix, uint32_t ndirect);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_METABLOCK_H_ */
+diff --git a/modules/brotli/enc/metablock_inc.h b/modules/brotli/enc/metablock_inc.h
+deleted file mode 100644
+--- a/modules/brotli/enc/metablock_inc.h
++++ /dev/null
+@@ -1,183 +0,0 @@
+-/* NOLINT(build/header_guard) */
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* template parameters: FN */
+-
+-#define HistogramType FN(Histogram)
+-
+-/* Greedy block splitter for one block category (literal, command or distance).
+-*/
+-typedef struct FN(BlockSplitter) {
+-  /* Alphabet size of particular block category. */
+-  size_t alphabet_size_;
+-  /* We collect at least this many symbols for each block. */
+-  size_t min_block_size_;
+-  /* We merge histograms A and B if
+-       entropy(A+B) < entropy(A) + entropy(B) + split_threshold_,
+-     where A is the current histogram and B is the histogram of the last or the
+-     second last block type. */
+-  double split_threshold_;
+-
+-  size_t num_blocks_;
+-  BlockSplit* split_;  /* not owned */
+-  HistogramType* histograms_;  /* not owned */
+-  size_t* histograms_size_;  /* not owned */
+-
+-  /* The number of symbols that we want to collect before deciding on whether
+-     or not to merge the block with a previous one or emit a new block. */
+-  size_t target_block_size_;
+-  /* The number of symbols in the current histogram. */
+-  size_t block_size_;
+-  /* Offset of the current histogram. */
+-  size_t curr_histogram_ix_;
+-  /* Offset of the histograms of the previous two block types. */
+-  size_t last_histogram_ix_[2];
+-  /* Entropy of the previous two block types. */
+-  double last_entropy_[2];
+-  /* The number of times we merged the current block with the last one. */
+-  size_t merge_last_count_;
+-} FN(BlockSplitter);
+-
+-static void FN(InitBlockSplitter)(
+-    MemoryManager* m, FN(BlockSplitter)* self, size_t alphabet_size,
+-    size_t min_block_size, double split_threshold, size_t num_symbols,
+-    BlockSplit* split, HistogramType** histograms, size_t* histograms_size) {
+-  size_t max_num_blocks = num_symbols / min_block_size + 1;
+-  /* We have to allocate one more histogram than the maximum number of block
+-     types for the current histogram when the meta-block is too big. */
+-  size_t max_num_types =
+-      BROTLI_MIN(size_t, max_num_blocks, BROTLI_MAX_NUMBER_OF_BLOCK_TYPES + 1);
+-  self->alphabet_size_ = alphabet_size;
+-  self->min_block_size_ = min_block_size;
+-  self->split_threshold_ = split_threshold;
+-  self->num_blocks_ = 0;
+-  self->split_ = split;
+-  self->histograms_size_ = histograms_size;
+-  self->target_block_size_ = min_block_size;
+-  self->block_size_ = 0;
+-  self->curr_histogram_ix_ = 0;
+-  self->merge_last_count_ = 0;
+-  BROTLI_ENSURE_CAPACITY(m, uint8_t,
+-      split->types, split->types_alloc_size, max_num_blocks);
+-  BROTLI_ENSURE_CAPACITY(m, uint32_t,
+-      split->lengths, split->lengths_alloc_size, max_num_blocks);
+-  if (BROTLI_IS_OOM(m)) return;
+-  self->split_->num_blocks = max_num_blocks;
+-  BROTLI_DCHECK(*histograms == 0);
+-  *histograms_size = max_num_types;
+-  *histograms = BROTLI_ALLOC(m, HistogramType, *histograms_size);
+-  self->histograms_ = *histograms;
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(*histograms)) return;
+-  /* Clear only current histogram. */
+-  FN(HistogramClear)(&self->histograms_[0]);
+-  self->last_histogram_ix_[0] = self->last_histogram_ix_[1] = 0;
+-}
+-
+-/* Does either of three things:
+-     (1) emits the current block with a new block type;
+-     (2) emits the current block with the type of the second last block;
+-     (3) merges the current block with the last block. */
+-static void FN(BlockSplitterFinishBlock)(
+-    FN(BlockSplitter)* self, BROTLI_BOOL is_final) {
+-  BlockSplit* split = self->split_;
+-  double* last_entropy = self->last_entropy_;
+-  HistogramType* histograms = self->histograms_;
+-  self->block_size_ =
+-      BROTLI_MAX(size_t, self->block_size_, self->min_block_size_);
+-  if (self->num_blocks_ == 0) {
+-    /* Create first block. */
+-    split->lengths[0] = (uint32_t)self->block_size_;
+-    split->types[0] = 0;
+-    last_entropy[0] =
+-        BitsEntropy(histograms[0].data_, self->alphabet_size_);
+-    last_entropy[1] = last_entropy[0];
+-    ++self->num_blocks_;
+-    ++split->num_types;
+-    ++self->curr_histogram_ix_;
+-    if (self->curr_histogram_ix_ < *self->histograms_size_)
+-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
+-    self->block_size_ = 0;
+-  } else if (self->block_size_ > 0) {
+-    double entropy = BitsEntropy(histograms[self->curr_histogram_ix_].data_,
+-                                 self->alphabet_size_);
+-    HistogramType combined_histo[2];
+-    double combined_entropy[2];
+-    double diff[2];
+-    size_t j;
+-    for (j = 0; j < 2; ++j) {
+-      size_t last_histogram_ix = self->last_histogram_ix_[j];
+-      combined_histo[j] = histograms[self->curr_histogram_ix_];
+-      FN(HistogramAddHistogram)(&combined_histo[j],
+-          &histograms[last_histogram_ix]);
+-      combined_entropy[j] = BitsEntropy(
+-          &combined_histo[j].data_[0], self->alphabet_size_);
+-      diff[j] = combined_entropy[j] - entropy - last_entropy[j];
+-    }
+-
+-    if (split->num_types < BROTLI_MAX_NUMBER_OF_BLOCK_TYPES &&
+-        diff[0] > self->split_threshold_ &&
+-        diff[1] > self->split_threshold_) {
+-      /* Create new block. */
+-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
+-      split->types[self->num_blocks_] = (uint8_t)split->num_types;
+-      self->last_histogram_ix_[1] = self->last_histogram_ix_[0];
+-      self->last_histogram_ix_[0] = (uint8_t)split->num_types;
+-      last_entropy[1] = last_entropy[0];
+-      last_entropy[0] = entropy;
+-      ++self->num_blocks_;
+-      ++split->num_types;
+-      ++self->curr_histogram_ix_;
+-      if (self->curr_histogram_ix_ < *self->histograms_size_)
+-        FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
+-      self->block_size_ = 0;
+-      self->merge_last_count_ = 0;
+-      self->target_block_size_ = self->min_block_size_;
+-    } else if (diff[1] < diff[0] - 20.0) {
+-      /* Combine this block with second last block. */
+-      split->lengths[self->num_blocks_] = (uint32_t)self->block_size_;
+-      split->types[self->num_blocks_] = split->types[self->num_blocks_ - 2];
+-      BROTLI_SWAP(size_t, self->last_histogram_ix_, 0, 1);
+-      histograms[self->last_histogram_ix_[0]] = combined_histo[1];
+-      last_entropy[1] = last_entropy[0];
+-      last_entropy[0] = combined_entropy[1];
+-      ++self->num_blocks_;
+-      self->block_size_ = 0;
+-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
+-      self->merge_last_count_ = 0;
+-      self->target_block_size_ = self->min_block_size_;
+-    } else {
+-      /* Combine this block with last block. */
+-      split->lengths[self->num_blocks_ - 1] += (uint32_t)self->block_size_;
+-      histograms[self->last_histogram_ix_[0]] = combined_histo[0];
+-      last_entropy[0] = combined_entropy[0];
+-      if (split->num_types == 1) {
+-        last_entropy[1] = last_entropy[0];
+-      }
+-      self->block_size_ = 0;
+-      FN(HistogramClear)(&histograms[self->curr_histogram_ix_]);
+-      if (++self->merge_last_count_ > 1) {
+-        self->target_block_size_ += self->min_block_size_;
+-      }
+-    }
+-  }
+-  if (is_final) {
+-    *self->histograms_size_ = split->num_types;
+-    split->num_blocks = self->num_blocks_;
+-  }
+-}
+-
+-/* Adds the next symbol to the current histogram. When the current histogram
+-   reaches the target size, decides on merging the block. */
+-static void FN(BlockSplitterAddSymbol)(FN(BlockSplitter)* self, size_t symbol) {
+-  FN(HistogramAdd)(&self->histograms_[self->curr_histogram_ix_], symbol);
+-  ++self->block_size_;
+-  if (self->block_size_ == self->target_block_size_) {
+-    FN(BlockSplitterFinishBlock)(self, /* is_final = */ BROTLI_FALSE);
+-  }
+-}
+-
+-#undef HistogramType
+diff --git a/modules/brotli/enc/params.h b/modules/brotli/enc/params.h
+deleted file mode 100644
+--- a/modules/brotli/enc/params.h
++++ /dev/null
+@@ -1,46 +0,0 @@
+-/* Copyright 2017 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Parameters for the Brotli encoder with chosen quality levels. */
+-
+-#ifndef BROTLI_ENC_PARAMS_H_
+-#define BROTLI_ENC_PARAMS_H_
+-
+-#include <brotli/encode.h>
+-#include "./encoder_dict.h"
+-
+-typedef struct BrotliHasherParams {
+-  int type;
+-  int bucket_bits;
+-  int block_bits;
+-  int hash_len;
+-  int num_last_distances_to_check;
+-} BrotliHasherParams;
+-
+-typedef struct BrotliDistanceParams {
+-  uint32_t distance_postfix_bits;
+-  uint32_t num_direct_distance_codes;
+-  uint32_t alphabet_size_max;
+-  uint32_t alphabet_size_limit;
+-  size_t max_distance;
+-} BrotliDistanceParams;
+-
+-/* Encoding parameters */
+-typedef struct BrotliEncoderParams {
+-  BrotliEncoderMode mode;
+-  int quality;
+-  int lgwin;
+-  int lgblock;
+-  size_t stream_offset;
+-  size_t size_hint;
+-  BROTLI_BOOL disable_literal_context_modeling;
+-  BROTLI_BOOL large_window;
+-  BrotliHasherParams hasher;
+-  BrotliDistanceParams dist;
+-  BrotliEncoderDictionary dictionary;
+-} BrotliEncoderParams;
+-
+-#endif  /* BROTLI_ENC_PARAMS_H_ */
+diff --git a/modules/brotli/enc/prefix.h b/modules/brotli/enc/prefix.h
+deleted file mode 100644
+--- a/modules/brotli/enc/prefix.h
++++ /dev/null
+@@ -1,53 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Functions for encoding of integers into prefix codes the amount of extra
+-   bits, and the actual values of the extra bits. */
+-
+-#ifndef BROTLI_ENC_PREFIX_H_
+-#define BROTLI_ENC_PREFIX_H_
+-
+-#include "../common/constants.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./fast_log.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* Here distance_code is an intermediate code, i.e. one of the special codes or
+-   the actual distance increased by BROTLI_NUM_DISTANCE_SHORT_CODES - 1. */
+-static BROTLI_INLINE void PrefixEncodeCopyDistance(size_t distance_code,
+-                                                   size_t num_direct_codes,
+-                                                   size_t postfix_bits,
+-                                                   uint16_t* code,
+-                                                   uint32_t* extra_bits) {
+-  if (distance_code < BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes) {
+-    *code = (uint16_t)distance_code;
+-    *extra_bits = 0;
+-    return;
+-  } else {
+-    size_t dist = ((size_t)1 << (postfix_bits + 2u)) +
+-        (distance_code - BROTLI_NUM_DISTANCE_SHORT_CODES - num_direct_codes);
+-    size_t bucket = Log2FloorNonZero(dist) - 1;
+-    size_t postfix_mask = (1u << postfix_bits) - 1;
+-    size_t postfix = dist & postfix_mask;
+-    size_t prefix = (dist >> bucket) & 1;
+-    size_t offset = (2 + prefix) << bucket;
+-    size_t nbits = bucket - postfix_bits;
+-    *code = (uint16_t)((nbits << 10) |
+-        (BROTLI_NUM_DISTANCE_SHORT_CODES + num_direct_codes +
+-         ((2 * (nbits - 1) + prefix) << postfix_bits) + postfix));
+-    *extra_bits = (uint32_t)((dist - offset) >> postfix_bits);
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_PREFIX_H_ */
+diff --git a/modules/brotli/enc/quality.h b/modules/brotli/enc/quality.h
+deleted file mode 100644
+--- a/modules/brotli/enc/quality.h
++++ /dev/null
+@@ -1,165 +0,0 @@
+-/* Copyright 2016 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Constants and formulas that affect speed-ratio trade-offs and thus define
+-   quality levels. */
+-
+-#ifndef BROTLI_ENC_QUALITY_H_
+-#define BROTLI_ENC_QUALITY_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/encode.h>
+-#include "./params.h"
+-
+-#define FAST_ONE_PASS_COMPRESSION_QUALITY 0
+-#define FAST_TWO_PASS_COMPRESSION_QUALITY 1
+-#define ZOPFLIFICATION_QUALITY 10
+-#define HQ_ZOPFLIFICATION_QUALITY 11
+-
+-#define MAX_QUALITY_FOR_STATIC_ENTROPY_CODES 2
+-#define MIN_QUALITY_FOR_BLOCK_SPLIT 4
+-#define MIN_QUALITY_FOR_NONZERO_DISTANCE_PARAMS 4
+-#define MIN_QUALITY_FOR_OPTIMIZE_HISTOGRAMS 4
+-#define MIN_QUALITY_FOR_EXTENSIVE_REFERENCE_SEARCH 5
+-#define MIN_QUALITY_FOR_CONTEXT_MODELING 5
+-#define MIN_QUALITY_FOR_HQ_CONTEXT_MODELING 7
+-#define MIN_QUALITY_FOR_HQ_BLOCK_SPLITTING 10
+-
+-/* For quality below MIN_QUALITY_FOR_BLOCK_SPLIT there is no block splitting,
+-   so we buffer at most this much literals and commands. */
+-#define MAX_NUM_DELAYED_SYMBOLS 0x2FFF
+-
+-/* Returns hash-table size for quality levels 0 and 1. */
+-static BROTLI_INLINE size_t MaxHashTableSize(int quality) {
+-  return quality == FAST_ONE_PASS_COMPRESSION_QUALITY ? 1 << 15 : 1 << 17;
+-}
+-
+-/* The maximum length for which the zopflification uses distinct distances. */
+-#define MAX_ZOPFLI_LEN_QUALITY_10 150
+-#define MAX_ZOPFLI_LEN_QUALITY_11 325
+-
+-/* Do not thoroughly search when a long copy is found. */
+-#define BROTLI_LONG_COPY_QUICK_STEP 16384
+-
+-static BROTLI_INLINE size_t MaxZopfliLen(const BrotliEncoderParams* params) {
+-  return params->quality <= 10 ?
+-      MAX_ZOPFLI_LEN_QUALITY_10 :
+-      MAX_ZOPFLI_LEN_QUALITY_11;
+-}
+-
+-/* Number of best candidates to evaluate to expand Zopfli chain. */
+-static BROTLI_INLINE size_t MaxZopfliCandidates(
+-  const BrotliEncoderParams* params) {
+-  return params->quality <= 10 ? 1 : 5;
+-}
+-
+-static BROTLI_INLINE void SanitizeParams(BrotliEncoderParams* params) {
+-  params->quality = BROTLI_MIN(int, BROTLI_MAX_QUALITY,
+-      BROTLI_MAX(int, BROTLI_MIN_QUALITY, params->quality));
+-  if (params->quality <= MAX_QUALITY_FOR_STATIC_ENTROPY_CODES) {
+-    params->large_window = BROTLI_FALSE;
+-  }
+-  if (params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+-    params->lgwin = BROTLI_MIN_WINDOW_BITS;
+-  } else {
+-    int max_lgwin = params->large_window ? BROTLI_LARGE_MAX_WINDOW_BITS :
+-                                           BROTLI_MAX_WINDOW_BITS;
+-    if (params->lgwin > max_lgwin) params->lgwin = max_lgwin;
+-  }
+-}
+-
+-/* Returns optimized lg_block value. */
+-static BROTLI_INLINE int ComputeLgBlock(const BrotliEncoderParams* params) {
+-  int lgblock = params->lgblock;
+-  if (params->quality == FAST_ONE_PASS_COMPRESSION_QUALITY ||
+-      params->quality == FAST_TWO_PASS_COMPRESSION_QUALITY) {
+-    lgblock = params->lgwin;
+-  } else if (params->quality < MIN_QUALITY_FOR_BLOCK_SPLIT) {
+-    lgblock = 14;
+-  } else if (lgblock == 0) {
+-    lgblock = 16;
+-    if (params->quality >= 9 && params->lgwin > lgblock) {
+-      lgblock = BROTLI_MIN(int, 18, params->lgwin);
+-    }
+-  } else {
+-    lgblock = BROTLI_MIN(int, BROTLI_MAX_INPUT_BLOCK_BITS,
+-        BROTLI_MAX(int, BROTLI_MIN_INPUT_BLOCK_BITS, lgblock));
+-  }
+-  return lgblock;
+-}
+-
+-/* Returns log2 of the size of main ring buffer area.
+-   Allocate at least lgwin + 1 bits for the ring buffer so that the newly
+-   added block fits there completely and we still get lgwin bits and at least
+-   read_block_size_bits + 1 bits because the copy tail length needs to be
+-   smaller than ring-buffer size. */
+-static BROTLI_INLINE int ComputeRbBits(const BrotliEncoderParams* params) {
+-  return 1 + BROTLI_MAX(int, params->lgwin, params->lgblock);
+-}
+-
+-static BROTLI_INLINE size_t MaxMetablockSize(
+-    const BrotliEncoderParams* params) {
+-  int bits =
+-      BROTLI_MIN(int, ComputeRbBits(params), BROTLI_MAX_INPUT_BLOCK_BITS);
+-  return (size_t)1 << bits;
+-}
+-
+-/* When searching for backward references and have not seen matches for a long
+-   time, we can skip some match lookups. Unsuccessful match lookups are very
+-   expensive and this kind of a heuristic speeds up compression quite a lot.
+-   At first 8 byte strides are taken and every second byte is put to hasher.
+-   After 4x more literals stride by 16 bytes, every put 4-th byte to hasher.
+-   Applied only to qualities 2 to 9. */
+-static BROTLI_INLINE size_t LiteralSpreeLengthForSparseSearch(
+-    const BrotliEncoderParams* params) {
+-  return params->quality < 9 ? 64 : 512;
+-}
+-
+-static BROTLI_INLINE void ChooseHasher(const BrotliEncoderParams* params,
+-                                       BrotliHasherParams* hparams) {
+-  if (params->quality > 9) {
+-    hparams->type = 10;
+-  } else if (params->quality == 4 && params->size_hint >= (1 << 20)) {
+-    hparams->type = 54;
+-  } else if (params->quality < 5) {
+-    hparams->type = params->quality;
+-  } else if (params->lgwin <= 16) {
+-    hparams->type = params->quality < 7 ? 40 : params->quality < 9 ? 41 : 42;
+-  } else if (params->size_hint >= (1 << 20) && params->lgwin >= 19) {
+-    hparams->type = 6;
+-    hparams->block_bits = params->quality - 1;
+-    hparams->bucket_bits = 15;
+-    hparams->hash_len = 5;
+-    hparams->num_last_distances_to_check =
+-        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
+-  } else {
+-    hparams->type = 5;
+-    hparams->block_bits = params->quality - 1;
+-    hparams->bucket_bits = params->quality < 7 ? 14 : 15;
+-    hparams->num_last_distances_to_check =
+-        params->quality < 7 ? 4 : params->quality < 9 ? 10 : 16;
+-  }
+-
+-  if (params->lgwin > 24) {
+-    /* Different hashers for large window brotli: not for qualities <= 2,
+-       these are too fast for large window. Not for qualities >= 10: their
+-       hasher already works well with large window. So the changes are:
+-       H3 --> H35: for quality 3.
+-       H54 --> H55: for quality 4 with size hint > 1MB
+-       H6 --> H65: for qualities 5, 6, 7, 8, 9. */
+-    if (hparams->type == 3) {
+-      hparams->type = 35;
+-    }
+-    if (hparams->type == 54) {
+-      hparams->type = 55;
+-    }
+-    if (hparams->type == 6) {
+-      hparams->type = 65;
+-    }
+-  }
+-}
+-
+-#endif  /* BROTLI_ENC_QUALITY_H_ */
+diff --git a/modules/brotli/enc/ringbuffer.h b/modules/brotli/enc/ringbuffer.h
+deleted file mode 100644
+--- a/modules/brotli/enc/ringbuffer.h
++++ /dev/null
+@@ -1,167 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Sliding window over the input data. */
+-
+-#ifndef BROTLI_ENC_RINGBUFFER_H_
+-#define BROTLI_ENC_RINGBUFFER_H_
+-
+-#include <string.h>  /* memcpy */
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./memory.h"
+-#include "./quality.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* A RingBuffer(window_bits, tail_bits) contains `1 << window_bits' bytes of
+-   data in a circular manner: writing a byte writes it to:
+-     `position() % (1 << window_bits)'.
+-   For convenience, the RingBuffer array contains another copy of the
+-   first `1 << tail_bits' bytes:
+-     buffer_[i] == buffer_[i + (1 << window_bits)], if i < (1 << tail_bits),
+-   and another copy of the last two bytes:
+-     buffer_[-1] == buffer_[(1 << window_bits) - 1] and
+-     buffer_[-2] == buffer_[(1 << window_bits) - 2]. */
+-typedef struct RingBuffer {
+-  /* Size of the ring-buffer is (1 << window_bits) + tail_size_. */
+-  const uint32_t size_;
+-  const uint32_t mask_;
+-  const uint32_t tail_size_;
+-  const uint32_t total_size_;
+-
+-  uint32_t cur_size_;
+-  /* Position to write in the ring buffer. */
+-  uint32_t pos_;
+-  /* The actual ring buffer containing the copy of the last two bytes, the data,
+-     and the copy of the beginning as a tail. */
+-  uint8_t* data_;
+-  /* The start of the ring-buffer. */
+-  uint8_t* buffer_;
+-} RingBuffer;
+-
+-static BROTLI_INLINE void RingBufferInit(RingBuffer* rb) {
+-  rb->cur_size_ = 0;
+-  rb->pos_ = 0;
+-  rb->data_ = 0;
+-  rb->buffer_ = 0;
+-}
+-
+-static BROTLI_INLINE void RingBufferSetup(
+-    const BrotliEncoderParams* params, RingBuffer* rb) {
+-  int window_bits = ComputeRbBits(params);
+-  int tail_bits = params->lgblock;
+-  *(uint32_t*)&rb->size_ = 1u << window_bits;
+-  *(uint32_t*)&rb->mask_ = (1u << window_bits) - 1;
+-  *(uint32_t*)&rb->tail_size_ = 1u << tail_bits;
+-  *(uint32_t*)&rb->total_size_ = rb->size_ + rb->tail_size_;
+-}
+-
+-static BROTLI_INLINE void RingBufferFree(MemoryManager* m, RingBuffer* rb) {
+-  BROTLI_FREE(m, rb->data_);
+-}
+-
+-/* Allocates or re-allocates data_ to the given length + plus some slack
+-   region before and after. Fills the slack regions with zeros. */
+-static BROTLI_INLINE void RingBufferInitBuffer(
+-    MemoryManager* m, const uint32_t buflen, RingBuffer* rb) {
+-  static const size_t kSlackForEightByteHashingEverywhere = 7;
+-  uint8_t* new_data = BROTLI_ALLOC(
+-      m, uint8_t, 2 + buflen + kSlackForEightByteHashingEverywhere);
+-  size_t i;
+-  if (BROTLI_IS_OOM(m) || BROTLI_IS_NULL(new_data)) return;
+-  if (rb->data_) {
+-    memcpy(new_data, rb->data_,
+-        2 + rb->cur_size_ + kSlackForEightByteHashingEverywhere);
+-    BROTLI_FREE(m, rb->data_);
+-  }
+-  rb->data_ = new_data;
+-  rb->cur_size_ = buflen;
+-  rb->buffer_ = rb->data_ + 2;
+-  rb->buffer_[-2] = rb->buffer_[-1] = 0;
+-  for (i = 0; i < kSlackForEightByteHashingEverywhere; ++i) {
+-    rb->buffer_[rb->cur_size_ + i] = 0;
+-  }
+-}
+-
+-static BROTLI_INLINE void RingBufferWriteTail(
+-    const uint8_t* bytes, size_t n, RingBuffer* rb) {
+-  const size_t masked_pos = rb->pos_ & rb->mask_;
+-  if (BROTLI_PREDICT_FALSE(masked_pos < rb->tail_size_)) {
+-    /* Just fill the tail buffer with the beginning data. */
+-    const size_t p = rb->size_ + masked_pos;
+-    memcpy(&rb->buffer_[p], bytes,
+-        BROTLI_MIN(size_t, n, rb->tail_size_ - masked_pos));
+-  }
+-}
+-
+-/* Push bytes into the ring buffer. */
+-static BROTLI_INLINE void RingBufferWrite(
+-    MemoryManager* m, const uint8_t* bytes, size_t n, RingBuffer* rb) {
+-  if (rb->pos_ == 0 && n < rb->tail_size_) {
+-    /* Special case for the first write: to process the first block, we don't
+-       need to allocate the whole ring-buffer and we don't need the tail
+-       either. However, we do this memory usage optimization only if the
+-       first write is less than the tail size, which is also the input block
+-       size, otherwise it is likely that other blocks will follow and we
+-       will need to reallocate to the full size anyway. */
+-    rb->pos_ = (uint32_t)n;
+-    RingBufferInitBuffer(m, rb->pos_, rb);
+-    if (BROTLI_IS_OOM(m)) return;
+-    memcpy(rb->buffer_, bytes, n);
+-    return;
+-  }
+-  if (rb->cur_size_ < rb->total_size_) {
+-    /* Lazily allocate the full buffer. */
+-    RingBufferInitBuffer(m, rb->total_size_, rb);
+-    if (BROTLI_IS_OOM(m)) return;
+-    /* Initialize the last two bytes to zero, so that we don't have to worry
+-       later when we copy the last two bytes to the first two positions. */
+-    rb->buffer_[rb->size_ - 2] = 0;
+-    rb->buffer_[rb->size_ - 1] = 0;
+-    /* Initialize tail; might be touched by "best_len++" optimization when
+-       ring buffer is "full". */
+-    rb->buffer_[rb->size_] = 241;
+-  }
+-  {
+-    const size_t masked_pos = rb->pos_ & rb->mask_;
+-    /* The length of the writes is limited so that we do not need to worry
+-       about a write */
+-    RingBufferWriteTail(bytes, n, rb);
+-    if (BROTLI_PREDICT_TRUE(masked_pos + n <= rb->size_)) {
+-      /* A single write fits. */
+-      memcpy(&rb->buffer_[masked_pos], bytes, n);
+-    } else {
+-      /* Split into two writes.
+-         Copy into the end of the buffer, including the tail buffer. */
+-      memcpy(&rb->buffer_[masked_pos], bytes,
+-             BROTLI_MIN(size_t, n, rb->total_size_ - masked_pos));
+-      /* Copy into the beginning of the buffer */
+-      memcpy(&rb->buffer_[0], bytes + (rb->size_ - masked_pos),
+-             n - (rb->size_ - masked_pos));
+-    }
+-  }
+-  {
+-    BROTLI_BOOL not_first_lap = (rb->pos_ & (1u << 31)) != 0;
+-    uint32_t rb_pos_mask = (1u << 31) - 1;
+-    rb->buffer_[-2] = rb->buffer_[rb->size_ - 2];
+-    rb->buffer_[-1] = rb->buffer_[rb->size_ - 1];
+-    rb->pos_ = (rb->pos_ & rb_pos_mask) + (uint32_t)(n & rb_pos_mask);
+-    if (not_first_lap) {
+-      /* Wrap, but preserve not-a-first-lap feature. */
+-      rb->pos_ |= 1u << 31;
+-    }
+-  }
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_RINGBUFFER_H_ */
+diff --git a/modules/brotli/enc/static_dict.c b/modules/brotli/enc/static_dict.c
+deleted file mode 100644
+--- a/modules/brotli/enc/static_dict.c
++++ /dev/null
+@@ -1,486 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-#include "./static_dict.h"
+-
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include "../common/transform.h"
+-#include "./encoder_dict.h"
+-#include "./find_match_length.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static BROTLI_INLINE uint32_t Hash(const uint8_t* data) {
+-  uint32_t h = BROTLI_UNALIGNED_LOAD32LE(data) * kDictHashMul32;
+-  /* The higher bits contain more mixture from the multiplication,
+-     so we take our results from there. */
+-  return h >> (32 - kDictNumBits);
+-}
+-
+-static BROTLI_INLINE void AddMatch(size_t distance, size_t len, size_t len_code,
+-                                   uint32_t* matches) {
+-  uint32_t match = (uint32_t)((distance << 5) + len_code);
+-  matches[len] = BROTLI_MIN(uint32_t, matches[len], match);
+-}
+-
+-static BROTLI_INLINE size_t DictMatchLength(const BrotliDictionary* dictionary,
+-                                            const uint8_t* data,
+-                                            size_t id,
+-                                            size_t len,
+-                                            size_t maxlen) {
+-  const size_t offset = dictionary->offsets_by_length[len] + len * id;
+-  return FindMatchLengthWithLimit(&dictionary->data[offset], data,
+-                                  BROTLI_MIN(size_t, len, maxlen));
+-}
+-
+-static BROTLI_INLINE BROTLI_BOOL IsMatch(const BrotliDictionary* dictionary,
+-    DictWord w, const uint8_t* data, size_t max_length) {
+-  if (w.len > max_length) {
+-    return BROTLI_FALSE;
+-  } else {
+-    const size_t offset = dictionary->offsets_by_length[w.len] +
+-        (size_t)w.len * (size_t)w.idx;
+-    const uint8_t* dict = &dictionary->data[offset];
+-    if (w.transform == 0) {
+-      /* Match against base dictionary word. */
+-      return
+-          TO_BROTLI_BOOL(FindMatchLengthWithLimit(dict, data, w.len) == w.len);
+-    } else if (w.transform == 10) {
+-      /* Match against uppercase first transform.
+-         Note that there are only ASCII uppercase words in the lookup table. */
+-      return TO_BROTLI_BOOL(dict[0] >= 'a' && dict[0] <= 'z' &&
+-              (dict[0] ^ 32) == data[0] &&
+-              FindMatchLengthWithLimit(&dict[1], &data[1], w.len - 1u) ==
+-              w.len - 1u);
+-    } else {
+-      /* Match against uppercase all transform.
+-         Note that there are only ASCII uppercase words in the lookup table. */
+-      size_t i;
+-      for (i = 0; i < w.len; ++i) {
+-        if (dict[i] >= 'a' && dict[i] <= 'z') {
+-          if ((dict[i] ^ 32) != data[i]) return BROTLI_FALSE;
+-        } else {
+-          if (dict[i] != data[i]) return BROTLI_FALSE;
+-        }
+-      }
+-      return BROTLI_TRUE;
+-    }
+-  }
+-}
+-
+-BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
+-    const BrotliEncoderDictionary* dictionary, const uint8_t* data,
+-    size_t min_length, size_t max_length, uint32_t* matches) {
+-  BROTLI_BOOL has_found_match = BROTLI_FALSE;
+-  {
+-    size_t offset = dictionary->buckets[Hash(data)];
+-    BROTLI_BOOL end = !offset;
+-    while (!end) {
+-      DictWord w = dictionary->dict_words[offset++];
+-      const size_t l = w.len & 0x1F;
+-      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
+-      const size_t id = w.idx;
+-      end = !!(w.len & 0x80);
+-      w.len = (uint8_t)l;
+-      if (w.transform == 0) {
+-        const size_t matchlen =
+-            DictMatchLength(dictionary->words, data, id, l, max_length);
+-        const uint8_t* s;
+-        size_t minlen;
+-        size_t maxlen;
+-        size_t len;
+-        /* Transform "" + BROTLI_TRANSFORM_IDENTITY + "" */
+-        if (matchlen == l) {
+-          AddMatch(id, l, l, matches);
+-          has_found_match = BROTLI_TRUE;
+-        }
+-        /* Transforms "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "" and
+-                      "" + BROTLI_TRANSFORM_OMIT_LAST_1 + "ing " */
+-        if (matchlen >= l - 1) {
+-          AddMatch(id + 12 * n, l - 1, l, matches);
+-          if (l + 2 < max_length &&
+-              data[l - 1] == 'i' && data[l] == 'n' && data[l + 1] == 'g' &&
+-              data[l + 2] == ' ') {
+-            AddMatch(id + 49 * n, l + 3, l, matches);
+-          }
+-          has_found_match = BROTLI_TRUE;
+-        }
+-        /* Transform "" + BROTLI_TRANSFORM_OMIT_LAST_# + "" (# = 2 .. 9) */
+-        minlen = min_length;
+-        if (l > 9) minlen = BROTLI_MAX(size_t, minlen, l - 9);
+-        maxlen = BROTLI_MIN(size_t, matchlen, l - 2);
+-        for (len = minlen; len <= maxlen; ++len) {
+-          size_t cut = l - len;
+-          size_t transform_id = (cut << 2) +
+-              (size_t)((dictionary->cutoffTransforms >> (cut * 6)) & 0x3F);
+-          AddMatch(id + transform_id * n, len, l, matches);
+-          has_found_match = BROTLI_TRUE;
+-        }
+-        if (matchlen < l || l + 6 >= max_length) {
+-          continue;
+-        }
+-        s = &data[l];
+-        /* Transforms "" + BROTLI_TRANSFORM_IDENTITY + <suffix> */
+-        if (s[0] == ' ') {
+-          AddMatch(id + n, l + 1, l, matches);
+-          if (s[1] == 'a') {
+-            if (s[2] == ' ') {
+-              AddMatch(id + 28 * n, l + 3, l, matches);
+-            } else if (s[2] == 's') {
+-              if (s[3] == ' ') AddMatch(id + 46 * n, l + 4, l, matches);
+-            } else if (s[2] == 't') {
+-              if (s[3] == ' ') AddMatch(id + 60 * n, l + 4, l, matches);
+-            } else if (s[2] == 'n') {
+-              if (s[3] == 'd' && s[4] == ' ') {
+-                AddMatch(id + 10 * n, l + 5, l, matches);
+-              }
+-            }
+-          } else if (s[1] == 'b') {
+-            if (s[2] == 'y' && s[3] == ' ') {
+-              AddMatch(id + 38 * n, l + 4, l, matches);
+-            }
+-          } else if (s[1] == 'i') {
+-            if (s[2] == 'n') {
+-              if (s[3] == ' ') AddMatch(id + 16 * n, l + 4, l, matches);
+-            } else if (s[2] == 's') {
+-              if (s[3] == ' ') AddMatch(id + 47 * n, l + 4, l, matches);
+-            }
+-          } else if (s[1] == 'f') {
+-            if (s[2] == 'o') {
+-              if (s[3] == 'r' && s[4] == ' ') {
+-                AddMatch(id + 25 * n, l + 5, l, matches);
+-              }
+-            } else if (s[2] == 'r') {
+-              if (s[3] == 'o' && s[4] == 'm' && s[5] == ' ') {
+-                AddMatch(id + 37 * n, l + 6, l, matches);
+-              }
+-            }
+-          } else if (s[1] == 'o') {
+-            if (s[2] == 'f') {
+-              if (s[3] == ' ') AddMatch(id + 8 * n, l + 4, l, matches);
+-            } else if (s[2] == 'n') {
+-              if (s[3] == ' ') AddMatch(id + 45 * n, l + 4, l, matches);
+-            }
+-          } else if (s[1] == 'n') {
+-            if (s[2] == 'o' && s[3] == 't' && s[4] == ' ') {
+-              AddMatch(id + 80 * n, l + 5, l, matches);
+-            }
+-          } else if (s[1] == 't') {
+-            if (s[2] == 'h') {
+-              if (s[3] == 'e') {
+-                if (s[4] == ' ') AddMatch(id + 5 * n, l + 5, l, matches);
+-              } else if (s[3] == 'a') {
+-                if (s[4] == 't' && s[5] == ' ') {
+-                  AddMatch(id + 29 * n, l + 6, l, matches);
+-                }
+-              }
+-            } else if (s[2] == 'o') {
+-              if (s[3] == ' ') AddMatch(id + 17 * n, l + 4, l, matches);
+-            }
+-          } else if (s[1] == 'w') {
+-            if (s[2] == 'i' && s[3] == 't' && s[4] == 'h' && s[5] == ' ') {
+-              AddMatch(id + 35 * n, l + 6, l, matches);
+-            }
+-          }
+-        } else if (s[0] == '"') {
+-          AddMatch(id + 19 * n, l + 1, l, matches);
+-          if (s[1] == '>') {
+-            AddMatch(id + 21 * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == '.') {
+-          AddMatch(id + 20 * n, l + 1, l, matches);
+-          if (s[1] == ' ') {
+-            AddMatch(id + 31 * n, l + 2, l, matches);
+-            if (s[2] == 'T' && s[3] == 'h') {
+-              if (s[4] == 'e') {
+-                if (s[5] == ' ') AddMatch(id + 43 * n, l + 6, l, matches);
+-              } else if (s[4] == 'i') {
+-                if (s[5] == 's' && s[6] == ' ') {
+-                  AddMatch(id + 75 * n, l + 7, l, matches);
+-                }
+-              }
+-            }
+-          }
+-        } else if (s[0] == ',') {
+-          AddMatch(id + 76 * n, l + 1, l, matches);
+-          if (s[1] == ' ') {
+-            AddMatch(id + 14 * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == '\n') {
+-          AddMatch(id + 22 * n, l + 1, l, matches);
+-          if (s[1] == '\t') {
+-            AddMatch(id + 50 * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == ']') {
+-          AddMatch(id + 24 * n, l + 1, l, matches);
+-        } else if (s[0] == '\'') {
+-          AddMatch(id + 36 * n, l + 1, l, matches);
+-        } else if (s[0] == ':') {
+-          AddMatch(id + 51 * n, l + 1, l, matches);
+-        } else if (s[0] == '(') {
+-          AddMatch(id + 57 * n, l + 1, l, matches);
+-        } else if (s[0] == '=') {
+-          if (s[1] == '"') {
+-            AddMatch(id + 70 * n, l + 2, l, matches);
+-          } else if (s[1] == '\'') {
+-            AddMatch(id + 86 * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == 'a') {
+-          if (s[1] == 'l' && s[2] == ' ') {
+-            AddMatch(id + 84 * n, l + 3, l, matches);
+-          }
+-        } else if (s[0] == 'e') {
+-          if (s[1] == 'd') {
+-            if (s[2] == ' ') AddMatch(id + 53 * n, l + 3, l, matches);
+-          } else if (s[1] == 'r') {
+-            if (s[2] == ' ') AddMatch(id + 82 * n, l + 3, l, matches);
+-          } else if (s[1] == 's') {
+-            if (s[2] == 't' && s[3] == ' ') {
+-              AddMatch(id + 95 * n, l + 4, l, matches);
+-            }
+-          }
+-        } else if (s[0] == 'f') {
+-          if (s[1] == 'u' && s[2] == 'l' && s[3] == ' ') {
+-            AddMatch(id + 90 * n, l + 4, l, matches);
+-          }
+-        } else if (s[0] == 'i') {
+-          if (s[1] == 'v') {
+-            if (s[2] == 'e' && s[3] == ' ') {
+-              AddMatch(id + 92 * n, l + 4, l, matches);
+-            }
+-          } else if (s[1] == 'z') {
+-            if (s[2] == 'e' && s[3] == ' ') {
+-              AddMatch(id + 100 * n, l + 4, l, matches);
+-            }
+-          }
+-        } else if (s[0] == 'l') {
+-          if (s[1] == 'e') {
+-            if (s[2] == 's' && s[3] == 's' && s[4] == ' ') {
+-              AddMatch(id + 93 * n, l + 5, l, matches);
+-            }
+-          } else if (s[1] == 'y') {
+-            if (s[2] == ' ') AddMatch(id + 61 * n, l + 3, l, matches);
+-          }
+-        } else if (s[0] == 'o') {
+-          if (s[1] == 'u' && s[2] == 's' && s[3] == ' ') {
+-            AddMatch(id + 106 * n, l + 4, l, matches);
+-          }
+-        }
+-      } else {
+-        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
+-               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
+-           transform. */
+-        const BROTLI_BOOL is_all_caps =
+-            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
+-        const uint8_t* s;
+-        if (!IsMatch(dictionary->words, w, data, max_length)) {
+-          continue;
+-        }
+-        /* Transform "" + kUppercase{First,All} + "" */
+-        AddMatch(id + (is_all_caps ? 44 : 9) * n, l, l, matches);
+-        has_found_match = BROTLI_TRUE;
+-        if (l + 1 >= max_length) {
+-          continue;
+-        }
+-        /* Transforms "" + kUppercase{First,All} + <suffix> */
+-        s = &data[l];
+-        if (s[0] == ' ') {
+-          AddMatch(id + (is_all_caps ? 68 : 4) * n, l + 1, l, matches);
+-        } else if (s[0] == '"') {
+-          AddMatch(id + (is_all_caps ? 87 : 66) * n, l + 1, l, matches);
+-          if (s[1] == '>') {
+-            AddMatch(id + (is_all_caps ? 97 : 69) * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == '.') {
+-          AddMatch(id + (is_all_caps ? 101 : 79) * n, l + 1, l, matches);
+-          if (s[1] == ' ') {
+-            AddMatch(id + (is_all_caps ? 114 : 88) * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == ',') {
+-          AddMatch(id + (is_all_caps ? 112 : 99) * n, l + 1, l, matches);
+-          if (s[1] == ' ') {
+-            AddMatch(id + (is_all_caps ? 107 : 58) * n, l + 2, l, matches);
+-          }
+-        } else if (s[0] == '\'') {
+-          AddMatch(id + (is_all_caps ? 94 : 74) * n, l + 1, l, matches);
+-        } else if (s[0] == '(') {
+-          AddMatch(id + (is_all_caps ? 113 : 78) * n, l + 1, l, matches);
+-        } else if (s[0] == '=') {
+-          if (s[1] == '"') {
+-            AddMatch(id + (is_all_caps ? 105 : 104) * n, l + 2, l, matches);
+-          } else if (s[1] == '\'') {
+-            AddMatch(id + (is_all_caps ? 116 : 108) * n, l + 2, l, matches);
+-          }
+-        }
+-      }
+-    }
+-  }
+-  /* Transforms with prefixes " " and "." */
+-  if (max_length >= 5 && (data[0] == ' ' || data[0] == '.')) {
+-    BROTLI_BOOL is_space = TO_BROTLI_BOOL(data[0] == ' ');
+-    size_t offset = dictionary->buckets[Hash(&data[1])];
+-    BROTLI_BOOL end = !offset;
+-    while (!end) {
+-      DictWord w = dictionary->dict_words[offset++];
+-      const size_t l = w.len & 0x1F;
+-      const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
+-      const size_t id = w.idx;
+-      end = !!(w.len & 0x80);
+-      w.len = (uint8_t)l;
+-      if (w.transform == 0) {
+-        const uint8_t* s;
+-        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
+-          continue;
+-        }
+-        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + "" and
+-                      "." + BROTLI_TRANSFORM_IDENTITY + "" */
+-        AddMatch(id + (is_space ? 6 : 32) * n, l + 1, l, matches);
+-        has_found_match = BROTLI_TRUE;
+-        if (l + 2 >= max_length) {
+-          continue;
+-        }
+-        /* Transforms " " + BROTLI_TRANSFORM_IDENTITY + <suffix> and
+-                      "." + BROTLI_TRANSFORM_IDENTITY + <suffix>
+-        */
+-        s = &data[l + 1];
+-        if (s[0] == ' ') {
+-          AddMatch(id + (is_space ? 2 : 77) * n, l + 2, l, matches);
+-        } else if (s[0] == '(') {
+-          AddMatch(id + (is_space ? 89 : 67) * n, l + 2, l, matches);
+-        } else if (is_space) {
+-          if (s[0] == ',') {
+-            AddMatch(id + 103 * n, l + 2, l, matches);
+-            if (s[1] == ' ') {
+-              AddMatch(id + 33 * n, l + 3, l, matches);
+-            }
+-          } else if (s[0] == '.') {
+-            AddMatch(id + 71 * n, l + 2, l, matches);
+-            if (s[1] == ' ') {
+-              AddMatch(id + 52 * n, l + 3, l, matches);
+-            }
+-          } else if (s[0] == '=') {
+-            if (s[1] == '"') {
+-              AddMatch(id + 81 * n, l + 3, l, matches);
+-            } else if (s[1] == '\'') {
+-              AddMatch(id + 98 * n, l + 3, l, matches);
+-            }
+-          }
+-        }
+-      } else if (is_space) {
+-        /* Set is_all_caps=0 for BROTLI_TRANSFORM_UPPERCASE_FIRST and
+-               is_all_caps=1 otherwise (BROTLI_TRANSFORM_UPPERCASE_ALL)
+-           transform. */
+-        const BROTLI_BOOL is_all_caps =
+-            TO_BROTLI_BOOL(w.transform != BROTLI_TRANSFORM_UPPERCASE_FIRST);
+-        const uint8_t* s;
+-        if (!IsMatch(dictionary->words, w, &data[1], max_length - 1)) {
+-          continue;
+-        }
+-        /* Transforms " " + kUppercase{First,All} + "" */
+-        AddMatch(id + (is_all_caps ? 85 : 30) * n, l + 1, l, matches);
+-        has_found_match = BROTLI_TRUE;
+-        if (l + 2 >= max_length) {
+-          continue;
+-        }
+-        /* Transforms " " + kUppercase{First,All} + <suffix> */
+-        s = &data[l + 1];
+-        if (s[0] == ' ') {
+-          AddMatch(id + (is_all_caps ? 83 : 15) * n, l + 2, l, matches);
+-        } else if (s[0] == ',') {
+-          if (!is_all_caps) {
+-            AddMatch(id + 109 * n, l + 2, l, matches);
+-          }
+-          if (s[1] == ' ') {
+-            AddMatch(id + (is_all_caps ? 111 : 65) * n, l + 3, l, matches);
+-          }
+-        } else if (s[0] == '.') {
+-          AddMatch(id + (is_all_caps ? 115 : 96) * n, l + 2, l, matches);
+-          if (s[1] == ' ') {
+-            AddMatch(id + (is_all_caps ? 117 : 91) * n, l + 3, l, matches);
+-          }
+-        } else if (s[0] == '=') {
+-          if (s[1] == '"') {
+-            AddMatch(id + (is_all_caps ? 110 : 118) * n, l + 3, l, matches);
+-          } else if (s[1] == '\'') {
+-            AddMatch(id + (is_all_caps ? 119 : 120) * n, l + 3, l, matches);
+-          }
+-        }
+-      }
+-    }
+-  }
+-  if (max_length >= 6) {
+-    /* Transforms with prefixes "e ", "s ", ", " and "\xC2\xA0" */
+-    if ((data[1] == ' ' &&
+-         (data[0] == 'e' || data[0] == 's' || data[0] == ',')) ||
+-        (data[0] == 0xC2 && data[1] == 0xA0)) {
+-      size_t offset = dictionary->buckets[Hash(&data[2])];
+-      BROTLI_BOOL end = !offset;
+-      while (!end) {
+-        DictWord w = dictionary->dict_words[offset++];
+-        const size_t l = w.len & 0x1F;
+-        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
+-        const size_t id = w.idx;
+-        end = !!(w.len & 0x80);
+-        w.len = (uint8_t)l;
+-        if (w.transform == 0 &&
+-            IsMatch(dictionary->words, w, &data[2], max_length - 2)) {
+-          if (data[0] == 0xC2) {
+-            AddMatch(id + 102 * n, l + 2, l, matches);
+-            has_found_match = BROTLI_TRUE;
+-          } else if (l + 2 < max_length && data[l + 2] == ' ') {
+-            size_t t = data[0] == 'e' ? 18 : (data[0] == 's' ? 7 : 13);
+-            AddMatch(id + t * n, l + 3, l, matches);
+-            has_found_match = BROTLI_TRUE;
+-          }
+-        }
+-      }
+-    }
+-  }
+-  if (max_length >= 9) {
+-    /* Transforms with prefixes " the " and ".com/" */
+-    if ((data[0] == ' ' && data[1] == 't' && data[2] == 'h' &&
+-         data[3] == 'e' && data[4] == ' ') ||
+-        (data[0] == '.' && data[1] == 'c' && data[2] == 'o' &&
+-         data[3] == 'm' && data[4] == '/')) {
+-      size_t offset = dictionary->buckets[Hash(&data[5])];
+-      BROTLI_BOOL end = !offset;
+-      while (!end) {
+-        DictWord w = dictionary->dict_words[offset++];
+-        const size_t l = w.len & 0x1F;
+-        const size_t n = (size_t)1 << dictionary->words->size_bits_by_length[l];
+-        const size_t id = w.idx;
+-        end = !!(w.len & 0x80);
+-        w.len = (uint8_t)l;
+-        if (w.transform == 0 &&
+-            IsMatch(dictionary->words, w, &data[5], max_length - 5)) {
+-          AddMatch(id + (data[0] == ' ' ? 41 : 72) * n, l + 5, l, matches);
+-          has_found_match = BROTLI_TRUE;
+-          if (l + 5 < max_length) {
+-            const uint8_t* s = &data[l + 5];
+-            if (data[0] == ' ') {
+-              if (l + 8 < max_length &&
+-                  s[0] == ' ' && s[1] == 'o' && s[2] == 'f' && s[3] == ' ') {
+-                AddMatch(id + 62 * n, l + 9, l, matches);
+-                if (l + 12 < max_length &&
+-                    s[4] == 't' && s[5] == 'h' && s[6] == 'e' && s[7] == ' ') {
+-                  AddMatch(id + 73 * n, l + 13, l, matches);
+-                }
+-              }
+-            }
+-          }
+-        }
+-      }
+-    }
+-  }
+-  return has_found_match;
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/static_dict.h b/modules/brotli/enc/static_dict.h
+deleted file mode 100644
+--- a/modules/brotli/enc/static_dict.h
++++ /dev/null
+@@ -1,40 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Class to model the static dictionary. */
+-
+-#ifndef BROTLI_ENC_STATIC_DICT_H_
+-#define BROTLI_ENC_STATIC_DICT_H_
+-
+-#include "../common/dictionary.h"
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-#include "./encoder_dict.h"
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-#define BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN 37
+-static const uint32_t kInvalidMatch = 0xFFFFFFF;
+-
+-/* Matches data against static dictionary words, and for each length l,
+-   for which a match is found, updates matches[l] to be the minimum possible
+-     (distance << 5) + len_code.
+-   Returns 1 if matches have been found, otherwise 0.
+-   Prerequisites:
+-     matches array is at least BROTLI_MAX_STATIC_DICTIONARY_MATCH_LEN + 1 long
+-     all elements are initialized to kInvalidMatch */
+-BROTLI_INTERNAL BROTLI_BOOL BrotliFindAllStaticDictionaryMatches(
+-    const BrotliEncoderDictionary* dictionary,
+-    const uint8_t* data, size_t min_length, size_t max_length,
+-    uint32_t* matches);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_STATIC_DICT_H_ */
+diff --git a/modules/brotli/enc/static_dict_lut.h b/modules/brotli/enc/static_dict_lut.h
+deleted file mode 100644
+--- a/modules/brotli/enc/static_dict_lut.h
++++ /dev/null
+@@ -1,5864 +0,0 @@
+-/* Copyright 2015 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Lookup table for static dictionary and transforms. */
+-
+-#ifndef BROTLI_ENC_STATIC_DICT_LUT_H_
+-#define BROTLI_ENC_STATIC_DICT_LUT_H_
+-
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-typedef struct DictWord {
+-  /* Highest bit is used to indicate end of bucket. */
+-  uint8_t len;
+-  uint8_t transform;
+-  uint16_t idx;
+-} DictWord;
+-
+-static const int kDictNumBits = 15;
+-static const uint32_t kDictHashMul32 = 0x1E35A7BD;
+-
+-static const uint16_t kStaticDictionaryBuckets[32768] = {
+-1,0,0,0,0,0,0,0,0,3,6,0,0,0,0,0,20,0,0,0,21,0,22,0,0,0,0,0,0,0,0,23,0,0,25,0,29,
+-0,53,0,0,0,0,0,0,55,0,0,0,0,0,0,61,76,0,0,0,94,0,0,0,0,0,0,96,0,97,0,98,0,0,0,0,
+-0,0,0,99,101,106,108,0,0,0,0,0,110,0,111,112,0,113,118,124,0,0,0,0,0,125,128,0,0
+-,0,0,129,0,0,131,0,0,0,0,0,0,132,0,0,135,0,0,0,137,0,0,0,0,0,138,139,0,0,0,0,0,0
+-,0,142,143,144,0,0,0,0,0,145,0,0,0,146,149,151,152,0,0,153,0,0,0,0,0,0,0,0,0,0,0
+-,0,0,0,0,154,0,0,0,0,0,0,155,0,0,0,0,160,182,0,0,0,0,0,0,183,0,0,0,188,189,0,0,
+-192,0,0,0,0,0,0,194,0,0,0,0,0,0,0,0,197,202,209,0,0,210,0,224,0,0,0,225,0,0,0,0,
+-0,0,0,0,0,0,231,0,0,0,232,0,240,0,0,242,0,0,0,0,0,0,0,0,0,0,0,244,0,0,0,246,0,0,
+-249,251,253,0,0,0,0,0,258,0,0,261,263,0,0,0,267,0,0,268,0,269,0,0,0,0,0,0,0,0,0,
+-271,0,0,0,0,0,0,272,0,273,0,277,0,278,286,0,0,0,0,287,0,289,290,291,0,0,0,295,0,
+-0,296,297,0,0,0,0,0,0,0,0,0,0,298,0,0,0,299,0,0,305,0,324,0,0,0,0,0,327,0,328,
+-329,0,0,0,0,336,0,0,340,0,341,342,343,0,0,346,0,348,0,0,0,0,0,0,349,351,0,0,355,
+-0,363,0,364,0,368,369,0,370,0,0,0,0,0,0,0,372,0,0,0,0,0,0,0,0,0,0,0,373,0,375,0,
+-0,0,0,376,377,0,0,394,395,396,0,0,398,0,0,0,0,400,0,0,408,0,0,0,0,420,0,0,0,0,0,
+-0,421,0,0,422,423,0,0,429,435,436,442,0,0,443,0,444,445,453,456,0,457,0,0,0,0,0,
+-458,0,0,0,459,0,0,0,460,0,462,463,465,0,0,0,0,0,0,466,469,0,0,0,0,0,0,470,0,0,0,
+-474,0,476,0,0,0,0,483,0,485,0,0,0,486,0,0,488,491,492,0,0,497,499,500,0,501,0,0,
+-0,505,0,0,506,0,0,0,507,0,0,0,509,0,0,0,0,511,512,519,0,0,0,0,0,0,529,530,0,0,0,
+-534,0,0,0,0,543,0,0,0,0,0,0,0,0,0,553,0,0,0,0,557,560,0,0,0,0,0,0,561,0,564,0,0,
+-0,0,0,0,565,566,0,575,0,619,0,620,0,0,623,624,0,0,0,625,0,0,626,627,0,0,628,0,0,
+-0,0,630,0,631,0,0,0,0,0,0,0,0,0,641,0,0,0,0,643,656,668,0,0,0,673,0,0,0,674,0,0,
+-0,0,0,0,0,0,682,0,687,0,690,0,693,699,700,0,0,0,0,0,0,704,705,0,0,0,0,707,710,0,
+-711,0,0,0,0,726,0,0,729,0,0,0,730,731,0,0,0,0,0,752,0,0,0,762,0,763,0,0,767,0,0,
+-0,770,774,0,0,775,0,0,0,0,0,0,0,0,0,0,776,0,0,0,777,783,0,0,0,785,788,0,0,0,0,
+-790,0,0,0,793,0,0,0,0,794,0,0,804,819,821,0,827,0,0,0,834,0,0,835,0,0,0,841,0,
+-844,0,850,851,859,0,860,0,0,0,0,0,0,0,874,0,876,0,877,890,0,0,0,0,0,0,0,0,893,
+-894,898,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,899,0,0,0,900,904,906,0,0,0,907,0,908,909,
+-0,910,0,0,0,0,911,0,0,0,0,0,916,0,0,0,922,925,0,930,0,934,0,0,0,0,0,943,0,0,944,
+-0,953,954,0,0,0,0,0,0,955,0,962,963,0,0,976,0,0,977,978,979,980,0,981,0,0,0,0,
+-984,0,0,985,0,0,987,989,991,0,0,0,0,0,0,0,0,0,992,0,0,0,993,0,0,0,0,0,0,996,0,0,
+-0,1000,0,0,0,0,0,1002,0,0,0,0,1005,1007,0,0,0,1009,0,0,0,1010,0,0,0,0,0,0,1011,0
+-,1012,0,0,0,0,1014,1016,0,0,0,1020,0,1021,0,0,0,0,1022,0,0,0,1024,0,0,0,0,0,0,
+-1025,0,0,1026,1027,0,0,0,0,0,1031,0,1033,0,0,0,0,1034,0,0,0,1037,1040,0,0,0,1042
+-,1043,0,0,1053,0,1054,0,0,1057,0,0,0,1058,0,0,1060,0,0,0,0,0,0,0,1061,0,0,1062,0
+-,0,0,0,1063,0,0,0,0,1064,0,0,0,0,0,1065,0,0,0,0,1066,1067,0,0,0,1069,1070,1072,0
+-,0,0,0,0,0,1073,0,1075,0,0,0,0,0,0,1080,1084,0,0,0,0,1088,0,0,0,0,0,0,1094,0,
+-1095,0,1107,0,0,0,1112,1114,0,1119,0,1122,0,0,1126,0,1129,0,1130,0,0,0,0,0,1132,
+-0,0,0,0,0,0,1144,0,0,1145,1146,0,1148,1149,0,0,1150,1151,0,0,0,0,1152,0,1153,0,0
+-,0,0,0,1154,0,1163,0,0,0,1164,0,0,0,0,0,1165,0,1167,0,1170,0,0,0,0,0,1171,1172,0
+-,0,0,0,0,0,0,0,1173,1175,1177,0,1186,0,0,0,0,0,0,0,0,0,0,1195,0,0,1221,0,0,1224,
+-0,0,1227,0,0,0,0,0,1228,1229,0,0,1230,0,0,0,0,0,0,0,0,0,1231,0,0,0,1233,0,0,1243
+-,1244,1246,1248,0,0,0,0,1254,1255,1258,1259,0,0,0,1260,0,0,1261,0,0,0,1262,1264,
+-0,0,1265,0,0,0,0,0,0,0,0,0,0,0,0,1266,0,1267,0,0,0,0,1273,1274,1276,1289,0,0,
+-1291,1292,1293,0,0,1294,1295,1296,0,0,0,0,1302,0,1304,0,0,0,0,0,0,0,0,0,1311,
+-1312,0,1314,0,1316,1320,1321,0,0,0,0,0,0,0,1322,1323,1324,0,1335,0,1336,0,0,0,0,
+-1341,1342,0,1346,0,1357,0,0,0,1358,1360,0,0,0,0,0,0,1361,0,0,0,1362,1365,0,1366,
+-0,0,0,0,0,0,0,1379,0,0,0,0,0,0,0,0,0,0,0,0,1386,0,1388,0,0,0,0,0,0,0,0,0,0,0,0,0
+-,0,1395,0,0,0,0,1403,0,1405,0,0,1407,0,0,0,0,0,1408,1409,0,1410,0,0,0,1412,1413,
+-1416,0,0,1429,1451,0,0,1454,0,0,0,0,0,0,0,1455,0,0,0,0,0,0,0,1456,0,0,0,0,1459,
+-1460,1461,1475,0,0,0,0,0,0,1477,0,1480,0,1481,0,0,1486,0,0,1495,0,0,0,1496,0,0,
+-1498,1499,1501,1520,1521,0,0,0,1526,0,0,0,0,1528,1529,0,1533,1536,0,0,0,1537,
+-1538,1549,0,1550,1558,1559,1572,0,1573,0,0,0,0,0,0,0,0,0,1575,0,0,0,0,0,1579,0,
+-1599,0,1603,0,1604,0,1605,0,0,0,0,0,1608,1610,0,0,0,0,1611,0,1615,0,1616,1618,0,
+-1619,0,0,1622,0,0,0,0,1634,0,0,0,1635,0,0,0,1641,0,0,0,0,0,0,0,0,0,1643,0,0,0,
+-1650,0,0,1652,0,0,0,0,0,1653,0,0,0,1654,0,0,0,0,1655,0,1662,0,0,1663,1664,0,0,
+-1668,0,0,1669,1670,0,1672,1673,0,0,0,0,0,1674,0,0,0,1675,1676,1680,0,1682,0,0,
+-1687,0,0,0,0,0,1704,0,0,1705,0,0,1721,0,0,0,0,1734,1735,0,0,0,0,1737,0,0,0,0,
+-1739,0,0,1740,0,0,0,0,0,0,0,0,0,0,1741,1743,0,0,0,0,1745,0,0,0,1749,0,0,0,1751,0
+-,0,0,0,0,0,1760,0,0,0,0,1765,0,0,0,0,0,1784,0,1785,1787,0,0,0,0,1788,1789,0,0,0,
+-0,1790,1791,1793,0,1798,1799,0,0,0,0,1801,0,1803,1805,0,0,0,1806,1811,0,1812,
+-1814,0,1821,0,0,0,0,0,1822,1833,0,0,0,0,0,0,1848,0,0,0,0,0,0,1857,0,0,0,1859,0,0
+-,0,0,1861,0,0,0,0,0,0,0,1866,0,1921,1925,0,0,0,1929,1930,0,0,0,0,0,0,0,0,0,1931,
+-0,0,0,0,1932,0,0,0,1934,0,0,0,0,0,0,0,0,1946,0,0,1948,0,0,0,0,1950,0,1957,0,1958
+-,0,0,0,0,0,1965,1967,0,0,0,0,1968,0,1969,0,1971,1972,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+-,0,1973,0,0,0,0,1975,0,0,0,0,1976,1979,0,1982,0,0,0,0,1984,1988,0,0,0,0,1990,
+-2004,2008,0,0,0,2012,2013,0,0,0,0,0,0,0,0,0,0,2015,0,2016,2017,0,0,0,0,2021,0,0,
+-2025,0,0,0,0,0,2029,2036,2040,0,2042,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2043,0,0,0,0,0,
+-2045,0,0,0,0,0,0,0,2046,2047,0,2048,2049,0,2059,0,0,2063,0,2064,2065,0,0,2066,0,
+-0,0,0,0,0,2069,0,0,0,0,2070,0,2071,0,2072,0,0,0,0,2080,2082,2083,0,0,0,0,0,2085,
+-0,2086,2088,2089,2105,0,0,0,0,2107,0,0,2116,2117,0,2120,0,0,2122,0,0,0,0,0,2123,
+-0,0,2125,2127,2128,0,0,0,2130,0,0,0,2137,2139,2140,2141,0,0,0,0,0,0,0,0,0,2144,
+-2145,0,0,2146,2149,0,0,0,0,2150,0,0,2151,2158,0,2159,0,2160,0,0,0,0,0,0,2161,
+-2162,0,0,2194,2202,0,0,0,0,0,0,2205,2217,0,2220,0,2221,0,2222,2224,0,0,0,0,2237,
+-0,0,0,0,0,2238,0,2239,2241,0,0,2242,0,0,0,0,0,2243,0,0,0,0,0,0,2252,0,0,2253,0,0
+-,0,2257,2258,0,0,0,2260,0,0,0,0,0,0,0,2262,0,2264,0,0,0,0,0,2269,2270,0,0,0,0,0,
+-0,0,0,0,2271,0,2273,0,0,0,0,2277,0,0,0,0,2278,0,0,0,0,2279,0,2280,0,2283,0,0,0,0
+-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2287,0,0,0,0,0,0,0,2289,2290,0,0,0,0,2291,0,2292,0,
+-0,0,2293,2295,2296,0,0,0,0,0,0,0,2298,0,0,0,0,0,2303,0,2305,0,0,2306,0,2307,0,0,
+-0,0,0,0,0,0,0,0,0,0,2313,2314,2315,2316,0,0,2318,0,2319,0,2322,0,0,2323,0,2324,0
+-,2326,0,0,0,0,0,0,0,2335,0,2336,2338,2339,0,2340,0,0,0,2355,0,2375,0,2382,2386,0
+-,2387,0,0,2394,0,0,0,0,2395,0,2397,0,0,0,0,0,2398,0,0,0,0,0,0,0,2399,2402,2404,
+-2408,2411,0,0,0,2413,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2415,0,0,2416,2417,2419,0,2420,
+-0,0,0,0,0,2425,0,0,0,2426,0,0,0,0,0,0,0,0,0,0,0,0,2427,2428,0,2429,0,0,2430,2434
+-,0,2436,0,0,0,0,0,0,2441,2442,0,2445,0,0,2446,2457,0,2459,0,0,2462,0,2464,0,2477
+-,0,2478,2486,0,0,0,2491,0,0,2493,0,0,2494,0,2495,0,2513,2523,0,0,0,0,2524,0,0,0,
+-0,0,0,2528,2529,2530,0,0,2531,0,2533,0,0,2534,2535,0,2536,2537,0,2538,0,2539,
+-2540,0,0,0,2545,2546,0,0,0,0,0,0,0,2548,0,0,2549,0,2550,2555,0,0,0,0,0,2557,0,
+-2560,0,0,0,0,0,0,0,0,0,0,0,2561,0,2576,0,0,0,0,0,0,0,0,0,2577,2578,0,0,0,2579,0,
+-0,0,0,0,0,0,2580,0,0,0,0,2581,0,0,0,0,2583,0,2584,0,2588,2590,0,0,0,2591,0,0,0,0
+-,2593,2594,0,2595,0,2601,2602,0,0,2603,0,2605,0,0,0,2606,2607,2611,0,2615,0,0,0,
+-2617,0,0,0,0,0,0,0,0,0,0,0,0,0,2619,0,0,2620,0,0,0,2621,0,2623,0,2625,0,0,2628,
+-2629,0,0,2635,2636,2637,0,0,2639,0,0,0,2642,0,0,0,0,2643,0,2644,0,2649,0,0,0,0,0
+-,0,2655,2656,0,0,2657,0,0,0,0,0,2658,0,0,0,0,0,2659,0,0,0,0,2664,2685,0,2687,0,
+-2688,0,0,2689,0,0,2694,0,2695,0,0,2698,0,2701,2706,0,0,0,2707,0,2709,2710,2711,0
+-,0,0,2720,2730,2735,0,0,0,0,2738,2740,0,0,0,0,2747,0,0,0,0,0,0,2748,0,0,2749,0,0
+-,0,0,0,2750,0,0,2752,2754,0,0,0,0,0,2758,0,0,0,0,2762,0,0,0,0,2763,0,0,0,0,0,0,0
+-,2764,2767,0,0,0,0,2768,0,0,2770,0,0,0,0,0,0,0,2771,0,0,0,0,0,0,0,0,0,2772,0,0,0
+-,0,0,2773,2776,0,0,2783,0,0,2784,0,2789,0,2790,0,0,0,2792,0,0,0,0,0,0,0,0,0,0,
+-2793,2795,0,0,0,0,0,0,2796,0,0,0,0,0,0,2797,2799,0,0,0,0,2803,0,0,0,0,2806,0,
+-2807,2808,2817,2819,0,0,0,0,0,2821,0,0,0,0,2822,2823,0,0,0,0,0,0,0,2824,0,0,2828
+-,0,2834,0,0,0,0,0,0,2836,0,2838,0,0,2839,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2841,
+-0,0,0,2842,0,0,0,0,0,2843,2844,0,0,0,0,2846,0,0,2847,0,2849,0,2853,0,0,0,0,0,
+-2857,0,0,0,0,2858,0,2859,0,0,2860,0,2862,2868,0,0,0,0,2875,0,2876,0,0,2877,2878,
+-2884,2889,2890,0,0,2891,0,0,2892,0,0,0,2906,2912,0,2913,0,0,0,0,0,0,0,0,2916,0,
+-2934,0,0,0,0,0,2935,0,0,0,0,2939,0,2940,0,0,0,0,0,0,0,2941,0,0,0,2946,0,2949,0,0
+-,2950,2954,2955,0,0,0,2959,2961,0,0,2962,0,2963,0,0,0,0,0,0,2964,2965,2966,2967,
+-0,0,0,0,0,0,0,2969,0,0,0,0,0,2970,2975,0,2982,2983,2984,0,0,0,0,0,2989,0,0,2990,
+-0,0,0,0,0,0,0,2991,0,0,0,0,0,0,0,0,2998,0,3000,3001,0,0,3002,0,0,0,3003,0,0,3012
+-,0,0,3022,0,0,3024,0,0,3025,3027,0,0,0,3030,0,0,0,0,3034,3035,0,0,3036,0,3039,0,
+-3049,0,0,3050,0,0,0,0,0,0,3051,0,3053,0,0,0,0,3057,0,3058,0,0,0,0,0,0,0,0,3063,0
+-,0,3073,3074,3078,3079,0,3080,3086,0,0,0,0,0,0,0,0,3087,0,3092,0,3095,0,3099,0,0
+-,0,3100,0,3101,3102,0,3122,0,0,0,3124,0,3125,0,0,0,0,0,0,3132,3134,0,0,3136,0,0,
+-0,0,0,0,0,3147,0,0,3149,0,0,0,0,0,3150,3151,3152,0,0,0,0,3158,0,0,3160,0,0,3161,
+-0,0,3162,0,3163,3166,3168,0,0,3169,3170,0,0,3171,0,0,0,0,0,0,0,3182,0,3184,0,0,
+-3188,0,0,3194,0,0,0,0,0,0,3204,0,0,0,0,3209,0,0,0,0,0,0,0,0,0,0,0,3216,3217,0,0,
+-0,0,0,0,0,3219,0,0,3220,3222,0,3223,0,0,0,0,3224,0,3225,3226,0,3228,3233,0,3239,
+-3241,3242,0,0,3251,3252,3253,3255,0,0,0,0,0,0,0,0,3260,0,0,3261,0,0,0,3267,0,0,0
+-,0,0,0,0,0,3271,0,0,0,3278,0,3282,0,0,0,3284,0,0,0,3285,3286,0,0,0,0,0,0,0,3287,
+-3292,0,0,0,0,3294,3296,0,0,3299,3300,3301,0,3302,0,0,0,0,0,3304,3306,0,0,0,0,0,0
+-,3308,0,0,0,0,0,0,0,0,0,3311,0,0,0,0,0,0,0,0,3312,3314,3315,0,3318,0,0,0,0,0,0,0
+-,0,3319,0,0,0,0,0,3321,0,0,0,0,0,0,0,0,0,3322,0,0,3324,3325,0,0,3326,0,0,3328,
+-3329,3331,0,0,3335,0,0,3337,0,3338,0,0,0,0,3343,3347,0,0,0,3348,0,0,3351,0,0,0,0
+-,0,0,3354,0,0,0,0,0,0,0,0,0,0,3355,0,0,3365,3366,3367,0,0,0,0,0,0,3368,3369,0,
+-3370,0,0,3373,0,0,3376,0,0,3377,0,3379,3387,0,0,0,0,0,3390,0,0,0,0,0,0,0,3402,0,
+-3403,3436,3437,3439,0,0,3441,0,0,0,3442,0,0,3449,0,0,0,3450,0,0,0,0,0,0,0,3451,0
+-,0,3452,0,3453,3456,0,3457,0,0,3458,0,3459,0,0,0,0,0,0,0,0,0,3460,0,0,3469,3470,
+-0,0,3475,0,0,0,3480,3487,3489,0,3490,0,0,3491,3499,0,3500,0,0,3501,0,0,0,3502,0,
+-3514,0,0,0,3516,3517,0,0,0,3518,0,0,0,0,3520,3521,3522,0,0,3526,3530,0,0,0,0,
+-3531,0,0,0,0,3536,0,0,0,0,0,0,0,3539,3541,0,0,3542,3544,0,3547,3548,0,0,3550,0,
+-3553,0,0,0,0,0,0,0,3554,0,3555,0,3558,0,3559,0,0,0,0,0,0,0,0,3563,0,3581,0,0,0,
+-3599,0,0,0,3600,0,3601,0,3602,3603,0,0,3606,3608,0,3610,3611,0,0,0,0,0,0,0,0,0,
+-3612,3616,3619,0,0,0,0,0,0,0,0,0,0,0,0,0,3624,3628,0,3629,3634,3635,0,0,0,0,0,0,
+-3636,0,3637,0,0,3638,3651,0,0,0,0,0,0,3652,3653,0,0,0,0,3656,3657,0,0,0,0,0,3658
+-,0,0,0,0,3659,0,3661,3663,3664,0,3665,0,3692,0,0,0,3694,3696,0,0,0,0,0,0,0,0,0,0
+-,0,0,3698,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3700,0,0,3701,0,0,0,3708,3709,0,0,0,3711
+-,3712,0,0,0,0,0,3723,0,3724,3725,0,0,3726,0,0,0,0,0,0,3728,3729,0,3734,3735,3737
+-,0,0,0,3743,0,3745,0,0,3746,0,0,3747,3748,0,3757,0,3759,3766,3767,0,3768,0,0,0,0
+-,3769,0,0,3771,0,3774,0,0,0,0,0,0,3775,0,0,0,0,0,0,3776,0,3777,3786,0,3788,3789,
+-0,0,0,0,0,0,0,0,0,3791,0,3811,0,0,0,0,0,3814,3815,3816,3820,0,0,0,0,0,0,0,3821,0
+-,0,3825,0,0,0,0,3835,0,0,3848,3849,0,0,0,0,3850,3851,3853,0,0,0,0,3859,0,3860,
+-3862,0,0,0,0,0,3863,0,0,0,0,0,0,0,0,3873,0,3874,0,3875,3886,0,3887,0,0,0,0,3892,
+-3913,0,3914,0,0,0,3925,3931,0,0,0,0,3934,3941,3942,0,0,0,0,3943,0,0,0,3944,0,0,0
+-,0,0,3945,0,3947,0,0,0,3956,3957,0,0,0,0,0,0,0,0,0,3958,0,3959,3965,0,0,0,0,3966
+-,0,0,0,3967,0,0,0,3968,3974,0,0,0,0,0,3975,3977,3978,0,0,0,0,3980,0,3985,0,0,0,0
+-,0,0,0,0,3986,4011,0,0,4017,0,0,0,0,0,0,0,0,0,0,0,4018,0,0,0,0,4019,0,4023,0,0,0
+-,4027,4028,0,0,0,0,0,0,0,0,4031,4034,0,0,4035,4037,4039,4040,0,0,0,0,0,4059,0,
+-4060,4061,0,4062,4063,4066,0,0,4072,0,0,0,0,0,0,0,0,0,0,0,0,0,4088,0,0,0,0,0,
+-4091,0,0,0,0,4094,4095,0,0,4096,0,0,0,0,0,4098,4099,0,0,0,4101,0,4104,0,0,0,4105
+-,4108,0,4113,0,0,4115,4116,0,4126,0,0,4127,0,0,0,0,0,0,0,4128,4132,4133,0,4134,0
+-,0,0,4137,0,0,4141,0,0,0,0,4144,4146,4147,0,0,0,0,4148,0,0,4311,0,0,0,4314,4329,
+-0,4331,4332,0,4333,0,4334,0,0,0,4335,0,4336,0,0,0,4337,0,0,0,4342,4345,4346,4350
+-,0,4351,4352,0,4354,4355,0,0,4364,0,0,0,0,4369,0,0,0,4373,0,4374,0,0,0,0,4377,0,
+-0,0,0,4378,0,0,0,4380,0,0,0,4381,4382,0,0,0,0,0,0,0,4384,0,0,0,0,4385,0,0,0,4386
+-,0,0,0,4391,4398,0,0,0,0,4407,4409,0,0,0,0,4410,0,0,4411,0,4414,4415,4418,0,4427
+-,4428,4430,0,4431,0,4448,0,0,0,0,0,4449,0,0,0,4451,4452,0,4453,4454,0,4456,0,0,0
+-,0,0,0,0,4459,0,4463,0,0,0,0,0,4466,0,4467,0,4469,0,0,0,0,0,0,0,0,0,0,0,0,0,4470
+-,4471,0,4473,0,0,4475,0,0,0,0,4477,4478,0,0,0,4479,4481,0,4482,0,4484,0,0,0,0,0,
+-0,0,4486,0,0,4488,0,0,4497,0,4508,0,0,4510,4511,0,4520,4523,0,4524,0,4525,0,4527
+-,0,0,4528,0,0,0,0,4530,0,4531,0,0,4532,0,0,0,4533,0,0,0,0,0,4535,0,0,0,4536,0,0,
+-0,0,0,4541,4543,4544,4545,4547,0,4548,0,0,0,0,4550,4551,0,4553,0,0,0,0,4562,0,0,
+-4571,0,0,0,4574,0,0,0,4575,0,4576,0,4577,0,0,0,4581,0,0,0,0,0,4582,0,0,4586,0,0,
+-0,4588,0,0,4597,0,4598,0,0,0,0,4616,4617,0,4618,0,0,0,0,4619,0,4620,0,0,4621,0,
+-4624,0,0,0,0,0,4625,0,0,0,0,4657,0,4659,0,4667,0,0,0,4668,4670,0,4672,0,0,0,0,0,
+-4673,4676,0,0,0,0,4687,0,0,0,0,4697,0,0,0,0,4699,0,4701,0,0,0,0,4702,0,0,4706,0,
+-0,4713,0,0,0,4714,4715,4716,0,0,0,0,0,0,0,0,0,0,0,0,4717,0,0,4720,0,4721,4729,
+-4735,0,0,0,4737,0,0,0,4739,0,0,0,4740,0,0,0,4741,0,0,0,0,0,4742,0,4745,4746,4747
+-,0,0,0,0,0,0,0,0,4748,0,0,0,4749,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4751,
+-4786,0,4787,0,4788,4796,0,0,4797,4798,0,4799,4806,4807,0,0,0,0,4809,4810,0,0,0,0
+-,0,0,4811,0,0,0,0,0,4812,0,4813,0,0,4815,0,4821,4822,0,0,0,0,4823,0,0,0,0,0,0,0,
+-0,0,0,4824,0,0,0,0,4826,0,0,0,4828,0,4829,0,0,0,4843,0,0,4847,0,4853,4855,4858,0
+-,0,0,0,0,4859,0,4864,0,0,4879,0,0,0,0,4880,0,0,0,0,4881,0,4882,0,0,0,0,0,0,0,0,0
+-,4883,0,0,0,0,4884,0,0,0,0,0,4886,4887,4888,4894,4896,0,4902,0,0,4905,0,0,4915,0
+-,0,0,0,0,0,0,4916,4917,4919,4921,0,0,0,0,0,4926,0,0,0,0,4927,0,0,0,0,0,0,0,0,
+-4929,0,4930,4931,0,4938,0,4952,0,4953,4957,4960,4964,0,0,0,0,0,0,0,5019,5020,
+-5022,0,0,0,0,0,5023,0,0,0,5024,0,0,0,5025,0,0,0,0,5028,0,0,0,0,5029,5030,5031,0,
+-5033,0,0,0,0,0,0,0,0,0,5034,5035,0,5036,0,0,5037,0,0,0,0,5038,0,0,5039,0,0,0,
+-5041,5042,0,0,0,0,5044,5049,5054,0,5055,0,5057,0,0,0,5060,0,0,0,0,0,5063,0,5064,
+-5065,0,5067,0,0,0,5068,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5076,0,0,0,0,0,0,
+-0,5077,0,0,5078,5080,0,0,5083,0,0,0,0,0,0,0,0,5085,0,0,0,0,0,0,5098,5099,5101,
+-5105,5107,0,5108,0,5109,0,0,0,0,0,0,0,5110,0,0,0,0,0,5117,5118,0,5121,0,5122,0,0
+-,5130,0,0,0,5137,0,0,0,5148,0,0,0,0,0,0,0,5151,5154,0,0,0,5155,0,0,5156,5159,
+-5161,0,0,0,0,5162,0,0,0,0,5163,5164,0,5166,0,0,0,0,0,0,0,0,0,0,5167,0,0,0,5172,0
+-,0,0,0,0,0,5178,5179,0,0,5190,0,0,5191,5192,5194,0,0,5198,5201,0,0,0,0,0,5203,0,
+-5206,5209,0,0,0,0,0,0,5213,0,5214,5216,0,0,0,0,0,5217,0,0,0,0,0,0,0,0,5218,5219,
+-0,5231,0,0,5244,5249,0,5254,0,5255,0,0,5257,0,0,0,0,0,5258,0,5260,5270,0,5277,0,
+-0,0,0,0,0,5280,5281,5282,5283,0,0,0,0,0,5284,0,5285,0,0,0,0,0,5287,5288,0,0,0,0,
+-0,0,0,0,0,0,5289,5291,0,0,5294,0,0,5295,0,0,0,0,0,0,0,5304,0,0,5306,5307,5308,0,
+-5309,0,0,5310,0,0,0,0,5311,5312,0,5313,0,0,0,0,0,5316,0,0,0,5317,0,0,0,0,0,0,0,0
+-,0,5325,0,0,0,0,0,0,5326,0,5327,5329,0,5332,0,0,0,0,5338,0,0,0,0,0,0,0,0,5340,0,
+-0,5341,0,0,0,5342,0,5343,5344,0,0,5345,0,0,0,0,0,0,5347,5348,0,0,0,0,0,0,0,0,0,
+-5349,0,5350,0,5354,0,0,0,0,5358,0,0,5359,0,0,5361,0,0,5365,0,5367,0,5373,0,0,0,
+-5379,0,0,0,5380,0,0,0,5382,0,5384,0,0,0,0,0,0,5385,0,0,0,0,5387,0,0,0,0,0,0,5388
+-,5390,5393,0,0,0,0,0,0,0,0,0,0,0,5396,0,0,0,0,5397,5402,0,0,0,0,0,5403,0,0,0,
+-5404,5405,0,0,0,0,0,0,0,0,0,0,0,0,5406,0,0,0,0,5410,0,0,5411,0,5415,0,0,0,0,5416
+-,5434,0,0,0,0,0,0,0,0,0,0,0,5438,0,5440,0,0,0,0,0,0,5441,5442,0,0,0,5443,5444,
+-5447,0,0,5448,5449,5451,0,0,0,5456,5457,0,0,0,5459,0,0,0,5461,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,5464,0,5466,0,0,5467,0,5470,0,0,5473,0,0,5474,0,0,5476,0,0,0,0,0,0,0,0
+-,0,0,0,5477,0,0,0,0,0,0,0,5484,0,0,5485,5486,0,0,0,0,0,5488,0,0,0,0,0,0,0,5489,0
+-,0,0,0,0,5507,0,0,0,5510,0,5511,0,0,5512,0,0,0,5513,0,5515,0,0,5516,5517,0,5518,
+-0,0,5522,0,0,0,0,0,5534,5535,0,0,5536,0,5538,0,0,5543,0,5544,0,0,5545,0,5547,0,
+-5557,0,0,5558,0,5560,5567,0,0,0,0,5568,0,0,0,5571,5573,0,5574,0,5575,0,0,0,0,
+-5577,0,0,5598,0,0,0,0,0,0,0,0,0,5600,5609,0,0,0,0,5610,0,0,5612,0,5624,0,5625,0,
+-0,0,5629,0,5641,0,5642,5643,0,0,0,0,0,0,5651,0,0,0,5652,5653,0,5661,5662,5678,0,
+-5679,0,0,0,0,5685,5686,0,0,0,0,0,5690,5692,0,5703,0,0,0,0,0,5706,0,0,0,0,5707,0,
+-0,0,0,0,0,5708,0,0,5709,0,5710,0,0,0,5712,0,5733,0,5734,5735,0,0,5744,5751,0,0,0
+-,0,0,0,0,0,0,0,0,0,5752,0,5754,0,0,0,0,0,0,5757,5758,0,5760,5761,0,0,0,0,5763,
+-5764,5765,0,5766,0,5767,5768,0,5770,0,0,0,0,5776,5780,0,0,0,0,5782,0,0,0,0,5784,
+-0,0,5788,0,0,0,0,0,0,0,0,0,0,0,5797,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5799,0,0,5801,
+-0,0,0,5811,0,0,0,0,0,0,5816,0,0,5827,0,0,0,0,0,0,0,0,5830,5831,0,0,5832,0,0,5833
+-,0,5835,5844,5845,0,5846,0,0,0,0,0,5850,0,0,0,0,0,5852,0,5855,5857,0,0,5859,0,
+-5861,0,0,5863,0,5865,0,0,0,5873,5875,0,0,0,5877,0,5879,0,0,0,5888,0,0,5889,5891,
+-0,5894,0,0,0,0,0,0,5895,0,5897,0,0,0,0,0,0,5907,0,5911,0,0,5912,0,5913,5922,5924
+-,0,5927,5928,0,0,0,0,5929,5930,0,5933,0,0,0,0,5949,0,0,5951,0,0,0,0,0,0,0,0,5953
+-,0,0,5954,0,5959,5960,5961,0,5964,0,0,0,5976,5978,5987,5990,0,0,0,0,0,5991,0,
+-5992,0,0,0,5994,5995,0,0,5996,0,0,6001,6003,0,0,0,0,6007,0,0,0,0,0,6008,0,0,6009
+-,0,6010,0,0,0,6011,6015,0,6017,0,6019,0,6023,0,0,0,0,0,0,0,6025,0,0,0,0,0,0,0,0,
+-0,0,6026,0,6030,0,0,6032,0,0,0,6033,6038,6040,0,0,0,6041,6045,0,0,6046,0,0,6053,
+-0,0,6054,0,6055,0,0,0,0,0,0,6057,0,6063,0,0,0,6064,0,6066,6071,6072,0,0,0,0,0,0,
+-6075,6076,0,0,6077,0,0,0,0,0,0,0,0,0,6078,6079,0,0,0,0,0,0,0,0,6080,0,6083,0,0,0
+-,0,0,6084,0,0,6088,0,6089,0,0,6093,6105,0,0,6107,0,6110,0,0,0,6111,6125,6126,0,0
+-,0,6129,0,0,0,0,6130,0,0,0,6131,6134,0,0,0,0,0,0,6142,0,0,0,0,0,6144,0,0,6146,
+-6151,6153,0,6156,0,6163,0,6180,6181,0,0,0,0,0,6182,0,0,0,0,6184,6195,0,0,6206,0,
+-6208,0,0,6212,6213,6214,0,6215,0,0,0,6228,0,0,0,6234,0,0,0,0,0,0,6235,6240,0,
+-6242,6243,6244,0,6250,6255,0,0,0,0,0,6257,0,0,0,6258,6278,0,6284,0,0,0,6285,0,0,
+-0,0,0,0,0,0,6286,0,0,0,6320,0,0,6322,6332,0,0,0,0,0,0,0,0,6334,0,0,0,0,0,0,0,
+-6335,0,0,6337,0,6338,0,6339,6340,0,0,6356,6357,6369,0,0,0,6370,6371,6372,0,6373,
+-0,0,0,0,0,6376,0,0,0,0,0,6382,6383,6384,0,0,0,0,6386,0,6389,6397,6400,6411,0,
+-6414,0,0,0,0,0,0,0,6415,6416,0,0,0,0,0,0,6417,0,0,0,0,6418,0,0,0,0,0,0,0,6420,0,
+-6421,6423,6425,0,6429,6430,0,6433,6438,0,0,0,0,0,0,0,0,0,0,6439,6440,0,0,6441,0,
+-0,6444,0,0,0,0,6446,0,0,0,0,6447,6448,0,0,6450,0,0,0,6454,0,0,6455,0,6461,0,0,0,
+-0,0,0,6462,0,0,6463,0,6464,0,6465,6467,0,0,0,6468,0,6479,6480,0,0,0,0,0,0,0,6481
+-,0,0,6485,6487,0,0,0,0,0,0,6493,0,0,0,0,0,0,0,0,6494,6495,6496,0,0,0,0,0,6498,0,
+-0,0,6507,6508,0,0,0,0,0,0,0,0,0,0,6511,6512,0,0,0,0,6513,0,0,0,6514,0,0,0,0,0,
+-6516,0,0,6517,6518,0,0,0,6519,6520,6521,0,6523,0,0,0,0,6524,6528,0,6530,0,0,6532
+-,0,6578,0,0,0,6583,0,6584,0,0,0,6587,0,0,0,6590,0,6591,0,0,0,0,0,6592,0,0,0,0,
+-6593,6594,0,0,0,0,0,6599,6600,0,0,6601,6602,6604,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-6608,0,0,0,0,0,0,0,0,6610,6611,0,6615,0,6616,6618,6620,0,6637,0,0,0,0,6639,0,0,0
+-,0,6641,0,6642,0,0,0,6647,0,6660,6663,0,6664,0,6666,6669,0,6675,6676,6677,0,0,0,
+-0,0,0,0,0,0,6678,0,0,0,6679,0,6680,0,0,0,0,0,0,0,6693,0,0,0,0,0,0,0,0,0,6704,
+-6705,6706,0,0,6711,6713,0,0,0,0,0,6716,0,0,0,6717,0,6719,6724,0,0,0,0,0,0,0,0,
+-6725,6726,0,0,0,0,0,6728,6729,6735,0,6737,6742,0,0,6743,6750,0,6751,0,0,6752,
+-6753,0,0,0,0,0,0,6754,0,0,0,0,0,6756,0,0,0,0,0,0,6763,0,0,6764,6765,0,0,0,6770,0
+-,0,0,6776,6780,0,6781,0,0,0,6783,0,6784,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-6785,0,0,0,6792,0,0,0,6793,0,0,6802,0,0,0,0,0,6803,0,0,0,6804,0,0,0,6812,0,0,
+-6823,0,6824,6839,0,0,0,0,6852,0,0,6854,0,6856,6857,0,0,0,0,0,0,0,0,0,6867,0,6868
+-,6870,6872,0,0,0,6873,6874,0,0,0,0,0,6875,0,0,6877,0,0,0,0,0,0,0,6878,0,0,0,6879
+-,0,6880,0,0,0,0,0,0,0,0,0,0,6887,0,6888,6891,6893,0,6895,0,0,0,0,0,0,0,0,6899,0,
+-0,0,0,6901,0,0,0,0,6910,0,6911,0,0,6912,0,0,6913,6914,0,0,0,6915,0,0,0,6916,6919
+-,0,0,0,0,0,0,6924,0,6925,0,0,0,6926,6927,6928,0,6929,0,6930,0,0,6931,6935,0,6936
+-,0,0,0,0,6939,6940,6941,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6942,6948,6949,0,0,0,0,0,0
+-,0,6952,6954,6963,6965,6966,0,0,6967,6968,0,0,0,0,0,0,0,0,0,6969,0,0,6970,6979,0
+-,0,6980,0,0,6983,0,0,0,0,0,6984,0,0,0,0,0,0,0,6988,6990,6992,0,0,0,0,0,0,0,6995,
+-0,0,0,7012,0,0,0,0,0,0,0,0,0,7019,0,0,0,0,0,0,0,0,7021,0,0,7022,7023,7028,0,7030
+-,7033,0,0,0,0,0,0,7038,0,0,0,0,0,0,0,0,0,0,7039,0,0,0,0,0,7046,0,7047,0,0,0,0,0,
+-0,0,0,0,0,0,7048,7052,0,0,0,0,0,7054,0,7060,0,0,0,0,7061,0,7065,0,0,0,0,7067,
+-7069,0,7070,7071,7072,0,0,7078,0,7080,7081,0,7083,0,0,0,7084,7087,7088,0,0,7090,
+-0,7093,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7107,0,0,7108,0,0,0,0,0,0,0,0,7110,0,7114,0
+-,0,0,0,0,0,0,7115,0,7116,0,0,0,0,0,7117,0,0,7118,0,0,7124,0,7125,0,0,7126,0,0,0,
+-0,7128,0,0,0,0,0,7129,0,7130,0,7132,7133,0,0,7134,0,0,7139,0,7148,7150,0,0,0,0,
+-7152,0,0,0,7153,7156,7157,0,0,0,0,0,7158,0,0,0,0,0,0,0,0,0,0,7163,7165,7169,0,
+-7171,0,0,0,0,0,0,0,0,0,7172,0,7173,7181,0,0,0,0,0,7182,7185,0,0,0,0,7187,0,7201,
+-7204,0,0,0,0,0,7206,7207,0,0,0,0,7211,7216,0,7218,0,0,0,0,7226,7228,7230,7232,
+-7233,7235,7237,0,0,0,0,7238,7241,0,7242,0,0,7247,0,0,0,7266,0,0,0,0,0,0,0,7289,0
+-,0,7290,7291,0,0,7292,0,7297,0,0,0,0,0,0,0,0,0,0,7300,0,7301,0,0,0,0,0,0,0,0,0,0
+-,0,0,7302,0,0,0,0,7305,0,0,0,0,7307,0,7308,0,7310,0,7335,0,0,0,0,0,0,0,7337,0,
+-7343,7347,0,0,0,0,0,7348,0,7349,7350,7352,7354,0,0,0,0,7357,0,7358,7366,0,7367,
+-7368,0,0,7373,0,0,0,7374,0,0,0,0,0,0,0,7376,0,0,0,7377,0,0,0,0,0,7378,0,7379,
+-7380,0,0,0,0,0,7383,0,0,7386,0,0,0,0,7398,0,0,0,7399,7400,0,7401,0,0,0,0,0,0,0,
+-7402,0,0,0,0,0,7405,0,0,0,0,0,7406,0,0,0,0,0,0,0,0,7421,7427,7429,0,0,0,7435,0,0
+-,7436,0,0,0,7437,0,0,0,0,0,0,7438,7443,0,7446,0,7448,0,0,0,0,0,0,0,0,0,0,7456,0,
+-0,0,0,0,7457,0,0,7461,0,0,0,0,0,7462,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7463,7466,7472,
+-0,7476,0,0,7490,0,7491,0,0,7493,0,0,0,7498,7499,0,0,7508,0,0,0,0,0,7512,0,0,0,
+-7513,7514,7516,0,0,0,0,7518,0,0,7519,7521,7522,0,0,0,7526,0,0,7529,0,0,7531,0,
+-7536,0,7538,0,7539,0,0,7541,7542,7546,0,0,0,0,0,7547,0,7548,0,0,0,0,0,7550,0,0,
+-7552,7553,0,0,0,0,0,0,0,0,0,0,7554,7563,0,7573,0,0,0,0,0,0,7574,7576,0,7578,7581
+-,7583,0,0,0,7584,0,7587,0,0,0,0,0,7589,0,0,0,7594,0,0,7595,0,0,7600,7602,7610,0,
+-0,0,0,0,7612,0,7613,7614,0,0,7615,0,0,7616,0,7620,0,7621,7622,0,7623,0,0,0,0,
+-7626,0,0,0,0,7627,7629,7631,0,0,7633,0,0,0,0,0,7639,0,7640,7642,0,0,7643,0,0,0,0
+-,7644,0,0,0,0,0,0,0,7645,0,0,0,0,0,7661,7662,7663,7665,0,7666,0,7667,0,7684,7688
+-,7690,0,7691,0,0,0,0,0,0,7692,0,0,7700,0,7707,0,7708,0,7709,0,7721,0,0,0,7722,0,
+-7724,0,0,0,0,0,0,7729,7731,0,7732,0,7733,7735,0,0,0,0,0,0,0,7739,0,0,7741,7745,0
+-,7748,0,0,0,7751,0,0,0,7752,0,0,0,0,0,0,0,7753,0,0,7756,0,7757,0,7759,0,7760,0,0
+-,0,0,7761,7768,0,0,7769,0,0,7770,0,0,7771,0,0,7772,0,0,7773,0,0,0,0,0,7778,7783,
+-0,0,0,0,0,7784,7785,0,7790,0,0,0,0,7792,0,7798,0,0,0,0,0,7799,0,7810,0,0,7813,0,
+-7814,0,7816,0,7818,7824,7825,7826,0,7828,7830,0,0,0,7840,0,7842,0,7843,0,0,0,0,
+-7844,0,0,0,0,0,0,0,7846,0,0,0,0,0,7856,7857,7858,7862,0,7865,0,0,7866,0,0,7913,0
+-,0,0,0,7914,0,0,7915,7917,7918,7919,0,7920,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,7921,
+-7922,0,7924,0,0,7925,0,0,7927,0,7930,7935,0,0,7937,0,0,0,0,0,0,7939,0,7940,0,0,0
+-,0,0,7941,0,0,0,0,7945,0,0,0,0,7949,0,0,0,0,0,0,0,0,7950,0,7953,0,0,0,0,0,0,0,
+-7968,0,0,0,0,7969,7972,7992,0,7993,0,0,0,0,0,0,0,0,0,0,0,7994,0,0,0,0,8007,8008,
+-0,0,0,0,0,0,0,0,0,0,0,0,8010,0,0,0,8012,0,0,0,0,0,0,0,0,8018,0,8028,8029,0,0,
+-8030,0,0,8032,8033,0,0,8034,8036,0,0,0,0,0,0,0,0,0,0,8037,0,0,0,8043,8052,8059,
+-8060,0,0,8061,0,0,0,8062,0,8063,0,8064,0,8066,8068,0,0,0,8080,8081,0,8089,0,0,0,
+-0,0,8092,0,0,0,0,0,0,8093,8110,0,0,0,0,0,0,0,8111,0,0,0,0,0,8112,8115,0,8117,0,0
+-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8120,8121,8122,8128,8129,8130,8131,0,0,8139,0,0,
+-8144,0,0,0,0,8145,8146,8153,0,0,0,0,0,0,0,0,8154,0,8157,8160,8162,0,8164,8165,0,
+-0,0,0,8166,8167,0,0,8179,0,0,0,8185,0,0,0,8186,0,0,8187,0,0,0,8188,0,0,0,0,0,
+-8204,0,0,0,0,8210,0,0,0,0,0,8213,0,8214,0,0,8215,0,0,0,0,0,0,8218,0,0,0,0,0,0,0,
+-0,0,8219,0,8221,0,0,8222,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8225,0,0,0,8233,0,0,
+-8242,0,0,0,0,0,0,0,0,0,0,0,8247,0,8248,8252,0,8256,8257,0,0,8261,0,8264,8265,0,0
+-,0,0,8267,0,0,0,8269,0,0,0,0,0,0,0,0,0,8270,0,0,0,8278,0,8279,8283,0,0,8285,8286
+-,8289,8292,0,0,0,0,8293,8295,8299,8300,8301,0,0,0,0,0,0,8304,8307,0,0,0,0,0,0,0,
+-8321,0,0,0,8322,8323,8325,8326,8327,0,0,8332,8338,0,0,8340,0,0,0,0,0,8350,0,0,
+-8351,0,8354,8355,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8360,8372,0,0,0,0,0,0,0,0,8377,0,0,
+-0,0,8380,0,0,0,8383,0,8384,0,0,0,0,8386,8392,0,0,8394,0,0,0,0,0,0,0,8396,8397,0,
+-8398,0,8399,0,0,0,0,0,8400,0,8401,8410,8411,0,8412,8413,8422,0,0,0,0,8423,0,0,0,
+-0,8424,0,0,8425,0,0,0,0,0,0,0,8441,8442,0,0,0,0,0,0,8443,0,0,8444,0,8447,0,0,0,0
+-,8451,0,8458,0,8462,0,0,8468,0,8469,0,0,0,8470,0,8473,8479,8480,0,0,0,0,8481,
+-8483,0,0,0,0,0,0,0,0,0,8484,0,0,8490,0,0,0,0,0,0,8491,8493,8494,0,8528,0,0,0,0,0
+-,0,0,8530,0,0,0,0,0,0,0,0,8534,8538,8540,0,0,8541,0,0,8545,0,8557,0,0,8569,8570,
+-0,0,8571,8574,8575,8579,0,8583,0,0,0,0,8591,0,0,0,0,0,0,0,0,8606,0,8607,0,0,0,0,
+-0,0,0,0,0,8608,0,0,8609,0,0,0,8610,0,0,0,8611,0,0,8613,8617,8621,0,0,8622,0,8623
+-,0,8624,8625,0,0,0,0,0,0,0,0,0,8637,8638,8639,8650,0,0,0,0,8652,8654,8655,0,0,0,
+-0,0,0,0,0,0,0,8656,0,0,0,0,0,8657,0,0,0,0,0,0,0,0,0,8658,0,0,8659,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,8660,0,0,0,0,0,0,8661,8663,8664,0,0,0,0,8665,0,8669,0,
+-0,0,0,0,0,0,8671,8674,0,8684,0,8686,0,0,0,8689,0,0,0,8690,0,8706,0,0,0,0,0,0,0,0
+-,0,0,0,8710,0,8711,8713,8714,8724,8727,8728,8733,8736,0,8737,8739,0,0,0,0,8742,
+-8743,8745,8754,0,0,0,0,8756,0,0,0,0,0,0,8757,8760,0,0,0,0,0,8762,8763,8764,0,
+-8766,8769,8770,8773,0,8774,0,8779,0,0,0,0,8780,0,0,8781,0,0,8783,0,0,0,0,0,0,0,0
+-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,8784,0,0,0,0,0,0,0,0,8785,0,0,0,0,8786,0,0,0,0,8788
+-,8790,0,0,0,8803,0,8813,8814,0,0,0,0,0,8815,8816,0,0,0,0,8818,0,0,0,0,8822,8828,
+-8829,0,8831,0,0,0,0,8833,0,0,0,8834,0,0,0,8835,0,8836,0,0,0,8837,0,0,0,0,0,0,
+-8838,8839,0,0,0,0,0,0,0,0,0,0,0,8840,0,0,0,8841,0,8842,0,0,0,8846,0,0,0,0,0,0,0,
+-8847,0,8848,0,0,8864,0,0,8866,0,0,8870,8872,0,0,8873,8874,0,0,0,0,0,0,8875,0,
+-8876,0,0,0,0,8896,8900,0,0,0,0,8901,0,0,0,0,0,8904,0,8907,0,0,0,0,8911,8912,8913
+-,0,0,0,8914,0,8915,0,0,0,0,0,0,0,0,0,0,0,0,8916,0,0,0,8929,0,0,0,0,0,0,0,0,0,0,
+-8930,0,8932,0,8943,0,0,0,8945,8947,0,0,0,0,8949,0,8950,0,8954,8957,0,0,8970,0,0,
+-0,0,8971,0,8996,0,0,0,0,8997,9000,0,0,0,0,9001,9002,0,9004,9009,9024,0,0,0,0,0,0
+-,0,0,0,0,0,0,9027,9082,0,0,9083,9089,0,0,0,0,0,0,9090,0,0,0,9092,0,0,9093,0,9095
+-,0,0,9096,9097,9101,9102,0,0,0,0,0,0,0,0,9112,0,0,0,0,0,0,9114,0,0,9120,0,9121,
+-9122,0,0,0,9123,9124,0,0,9125,0,0,9126,0,9127,0,0,9129,9131,0,0,0,9132,0,0,9136,
+-0,9144,0,0,9148,0,0,0,0,0,0,9149,0,9152,9163,0,0,9165,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-9166,0,9169,0,0,0,0,0,0,0,9170,0,0,0,0,9172,0,9174,9175,9176,0,9177,0,0,0,0,0,0,
+-0,0,9186,0,9187,0,0,0,9188,9189,0,0,9190,0,0,0,0,9191,0,0,0,9193,0,0,0,0,9197,
+-9198,0,0,0,9208,9211,0,0,0,0,9216,9217,0,9220,0,0,0,0,9221,9222,9223,0,9224,9225
+-,0,0,9227,0,9228,9229,0,0,9230,0,9232,0,9233,0,0,0,0,0,9234,9235,0,0,9237,0,0,0,
+-0,0,0,0,0,9238,9240,0,0,9241,0,0,0,0,9244,0,0,0,0,9247,0,0,0,0,0,0,0,0,0,0,9248,
+-0,0,0,9249,0,0,0,0,0,9250,0,0,0,0,9251,0,0,9252,9255,0,0,0,9256,0,0,0,0,0,0,0,
+-9257,0,0,9258,0,0,0,0,0,0,9259,0,0,0,0,0,9262,9263,0,0,9265,9266,0,0,0,0,0,0,0,0
+-,9268,9271,0,0,0,0,0,0,0,0,0,9273,0,0,0,9276,9277,9279,0,0,0,0,0,0,0,9280,0,0,
+-9293,0,0,0,0,0,9297,9301,0,0,0,0,0,0,0,0,0,0,0,9308,9309,9313,9321,9322,0,9326,
+-9327,0,0,9477,0,9479,0,0,0,0,9482,0,0,0,9483,0,9484,0,0,0,0,0,0,0,0,0,9485,0,0,
+-9486,0,0,0,9489,0,0,0,0,9490,9491,0,0,0,0,9493,0,9495,9496,0,0,0,0,0,0,0,0,9500,
+-0,9502,0,0,0,0,0,9504,9507,0,9509,0,9511,0,0,9513,0,0,0,0,0,0,0,0,9515,0,0,0,0,0
+-,0,9516,9517,0,0,0,0,9532,0,0,9533,0,0,9538,0,9539,9540,0,0,0,0,9541,0,0,0,9542,
+-0,0,0,0,0,0,0,0,9544,9545,0,9546,0,0,0,0,0,0,9547,9548,0,0,0,9550,0,9557,0,9558,
+-0,9561,0,9563,9570,0,9572,9574,9575,0,0,0,9577,9592,0,0,9596,0,0,0,9598,0,9600,0
+-,9601,0,0,0,0,0,0,9608,0,9638,9639,0,0,0,0,0,0,0,9641,0,0,9643,9644,9645,9646,0,
+-0,0,9648,0,0,0,0,0,0,0,9650,9654,0,0,0,0,0,0,0,0,9655,0,0,0,0,0,9656,0,9657,0,0,
+-0,0,9658,0,0,9659,0,0,9664,0,0,9665,0,9667,9669,0,0,0,0,0,0,0,0,0,0,0,0,9671,0,
+-9673,9681,0,0,0,0,9682,9683,9684,0,0,0,0,9686,9698,0,0,9700,9701,9702,0,9703,
+-9717,0,0,0,0,9718,0,9726,0,0,0,0,9727,0,0,0,9728,0,9742,0,9744,0,0,0,9750,0,9754
+-,9755,0,0,0,0,0,9756,0,9757,9768,0,9769,0,0,0,9770,9771,0,9773,0,9774,0,9775,0,0
+-,0,9776,9777,9784,0,0,0,9786,0,9789,0,0,0,0,9793,9794,0,0,0,9808,0,0,0,0,0,9811,
+-0,0,0,0,0,0,0,0,0,0,0,0,9812,0,9820,0,9823,0,9828,0,0,0,0,9830,0,0,9833,9836,0,0
+-,0,9840,0,0,0,9841,0,0,9842,0,9845,0,0,0,9847,9848,0,0,9855,0,0,0,0,0,0,9856,
+-9863,9865,0,0,0,0,0,0,0,0,9866,9867,9868,9873,9875,0,0,0,0,0,0,9880,0,9886,0,0,0
+-,9887,0,0,9891,0,0,0,0,0,0,0,9906,9907,9908,0,0,0,9909,0,0,0,0,0,0,9910,0,0,0,0,
+-9913,0,0,0,0,9914,0,0,0,0,0,9922,0,0,0,0,9923,9925,0,0,0,0,0,0,9930,0,0,0,9931,0
+-,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9932,0,9939,0,0,9940,9962,9966,0,9969,9970,0,0,9974
+-,0,9979,9981,9982,0,0,0,9985,0,0,0,0,0,0,9987,0,0,0,0,0,0,0,9988,9993,0,0,9994,0
+-,0,0,9997,0,10004,0,0,0,0,0,10007,10019,10020,10022,0,0,0,10031,0,0,0,0,0,10032,
+-0,0,10034,0,10036,0,0,0,0,10038,0,10039,10040,10041,10042,0,0,0,0,0,10043,0,0,0,
+-0,0,10045,10054,0,0,0,0,10055,0,0,10057,10058,0,0,0,0,0,0,10059,0,0,0,0,0,0,0,
+-10060,0,0,0,0,0,0,0,10063,0,10066,0,0,0,10070,0,10072,0,0,10076,10077,0,0,10084,
+-0,10087,10090,10091,0,0,0,10094,10097,0,0,0,0,0,0,10098,0,0,0,0,0,0,10103,0,
+-10104,0,10108,0,0,0,0,0,0,0,0,10120,0,0,0,10122,0,0,10125,0,0,0,0,10127,10128,0,
+-0,10134,0,10135,10136,0,10137,0,0,10147,0,10149,10150,0,0,10156,0,10158,10159,
+-10160,10168,0,0,10171,0,10173,0,0,0,10176,0,0,0,0,10177,0,0,0,0,10178,0,0,0,0,
+-10194,0,10202,0,0,10203,10204,0,10205,10206,0,10207,0,0,0,0,10209,0,0,0,0,0,0,0,
+-10213,0,0,0,0,0,0,10217,0,10229,0,10230,10231,0,0,10232,0,0,10237,10238,10244,0,
+-0,0,0,0,10250,0,10252,0,0,0,0,0,0,10255,0,0,10257,0,0,0,0,0,0,10258,0,10259,0,0,
+-0,0,0,0,0,0,10260,0,0,0,0,0,0,0,10284,10288,10289,0,0,0,10290,0,10296,0,0,0,0,0,
+-10297,0,0,0,0,0,0,10298,0,0,0,0,10299,10303,0,0,0,0,0,10306,0,0,0,10307,0,10308,
+-0,0,0,0,10311,0,0,0,0,0,0,0,10315,10317,0,0,0,10318,10319,0,10321,0,10326,0,
+-10328,0,0,0,0,10329,0,0,10331,0,10332,0,0,0,0,0,0,10334,0,0,10335,10338,0,0,0,0,
+-0,10339,10349,0,0,0,0,0,0,10351,0,10353,0,0,0,0,0,0,10362,0,10368,0,10369,0,0,0,
+-10372,10373,0,0,0,0,0,10374,0,0,0,10375,0,10376,0,0,10386,10388,10390,0,0,0,0,0,
+-0,0,10391,0,0,10392,10394,0,0,10396,0,10397,0,10403,0,0,0,0,0,0,0,0,10404,0,
+-10405,10410,0,0,10411,0,10412,0,0,0,0,0,0,0,10421,10422,10423,0,0,0,0,0,0,0,0,0,
+-10425,0,0,10427,0,0,10430,0,0,0,0,0,10432,0,10433,10434,0,0,0,0,10436,10437,0,
+-10438,0,10439,0,10444,10446,0,0,0,0,0,10448,0,0,0,0,0,10449,0,0,0,0,0,0,0,10451,
+-0,10453,0,0,0,10454,10457,0,0,10459,0,10469,0,0,0,0,0,10472,10481,0,0,0,0,0,
+-10482,10483,0,10492,0,0,0,0,0,0,0,0,0,0,10499,0,0,0,10502,0,0,10510,0,10521,
+-10524,0,0,10525,10526,10528,0,0,0,0,0,0,0,0,10530,0,0,0,0,10533,0,10534,0,0,0,0,
+-0,0,0,0,0,0,10535,10536,0,0,10544,0,10553,10556,0,10557,10559,0,0,0,0,0,10562,
+-10563,10564,0,10565,0,0,0,10566,0,10567,0,0,0,0,10575,0,0,10576,0,10578,0,0,0,0,
+-0,0,0,0,0,0,10585,10586,10587,10589,0,10590,0,0,10594,0,0,0,0,0,10598,0,0,10601,
+-0,0,0,10602,0,10603,0,10604,0,10605,0,0,10607,0,10626,0,10627,0,0,0,0,0,10629,
+-10630,10631,0,0,0,10646,0,0,0,10647,0,10650,0,10651,0,0,0,10652,10653,10655,0,
+-10658,0,0,10659,0,10667,0,0,0,0,10669,0,0,0,0,0,0,0,0,0,10670,0,0,0,10671,0,0,0,
+-0,10672,10673,0,10674,0,0,0,10676,0,0,0,0,0,0,10678,0,10682,0,0,10692,0,10697,0,
+-0,0,0,10698,0,0,0,10700,0,0,0,0,0,10703,0,10704,0,0,0,0,0,0,0,10705,0,10715,
+-10718,10720,0,0,10722,0,0,0,0,0,0,0,0,10723,0,0,0,0,10726,0,0,0,0,0,10727,10730,
+-10743,0,0,0,0,0,0,10744,0,0,10745,0,0,0,0,0,0,10748,0,0,0,0,10750,0,0,10752,
+-10753,0,0,0,10756,0,0,0,0,0,0,10758,0,0,0,10759,0,10769,0,0,10772,0,0,0,0,0,0,
+-10773,0,0,0,10777,0,0,10779,0,0,0,0,0,0,0,0,10780,10784,0,0,0,10789,0,0,0,10791,
+-0,0,0,0,0,0,0,0,0,10795,0,0,10796,0,10808,0,10809,0,0,0,10810,0,0,0,10812,0,0,
+-10814,0,0,0,0,0,0,0,0,0,10815,0,0,0,0,10816,10817,0,0,0,0,10819,0,10820,0,0,0,0,
+-10821,10822,10823,0,10826,10849,0,0,0,0,10850,0,0,10852,0,10853,0,0,10856,0,0,
+-10857,10858,10859,10860,0,0,0,0,0,0,10863,0,10866,10867,10872,10890,0,0,10891,
+-10892,0,0,0,0,0,10893,0,0,0,10896,10899,0,0,10900,10902,0,0,0,0,0,10903,0,0,0,0,
+-0,0,0,0,0,0,0,0,10905,0,10906,0,0,0,0,10908,10911,0,10912,0,0,10916,0,0,0,0,0,
+-10917,0,10918,0,0,0,10923,0,0,0,0,0,10924,0,0,10928,10929,0,0,10930,0,0,0,10932,
+-0,0,0,0,10939,0,0,10945,0,0,0,10947,0,0,10948,0,0,0,0,0,0,0,0,0,0,0,0,10958,0,
+-10960,10962,0,0,10964,0,0,0,10966,0,0,0,0,0,0,0,0,0,0,10967,0,0,0,10968,0,0,0,
+-10973,0,0,0,0,0,10975,0,0,0,10976,10978,0,0,10982,10984,10987,0,0,10988,0,10989,
+-0,0,10991,0,0,0,0,10992,0,0,0,10993,0,10995,0,0,0,10996,10997,0,0,0,10998,0,
+-10999,0,11001,0,0,0,0,0,0,11010,11012,0,11013,11016,11017,0,0,11019,11020,11021,
+-0,0,0,0,0,0,0,0,0,0,0,0,11022,0,0,11023,11029,0,0,0,0,11031,0,0,0,11034,0,0,0,0,
+-11055,0,0,0,0,0,11056,11060,0,0,0,0,0,0,11061,0,0,11064,11065,0,11066,0,11069,0,
+-11085,0,0,0,0,0,11086,0,0,0,11088,0,0,0,11094,0,0,0,11095,11096,0,0,0,0,0,0,
+-11097,11098,0,0,0,0,0,0,11099,0,0,11102,11108,0,0,0,11109,0,11114,11119,0,11131,
+-0,0,0,11142,0,0,11143,0,11146,0,11147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11148,0,
+-11149,11152,11153,11154,0,11156,0,11157,0,0,0,11158,0,0,11159,11160,0,0,0,0,0,0,
+-0,0,0,0,0,0,11163,0,0,11164,11166,0,0,0,11172,11174,0,0,0,11176,0,0,0,0,0,11182,
+-11183,0,0,0,11184,11187,0,0,11188,11189,0,0,0,0,0,0,11194,0,0,0,0,0,0,0,11200,
+-11202,0,0,0,0,0,0,11203,0,11204,0,0,0,0,0,11205,0,0,0,11206,0,11207,0,0,11209,0,
+-11211,0,11214,0,0,11231,0,0,0,11293,11295,0,0,11296,11297,11302,0,0,0,11307,0,0,
+-0,0,11309,11310,0,11311,0,0,0,11313,0,11314,0,0,0,0,11334,0,11338,0,0,0,11339,0,
+-0,0,0,0,11340,0,11341,11342,0,11344,0,11345,0,0,0,11348,11349,0,0,11350,0,0,0,
+-11355,0,0,0,0,0,0,11356,0,11357,11370,0,0,11371,0,11374,11376,0,0,0,11377,0,0,
+-11378,11383,0,11386,11399,0,11400,11406,0,0,0,11408,0,0,11409,11412,0,0,0,0,
+-11417,0,0,0,11418,0,11421,0,11426,11429,0,0,0,0,0,11430,0,11437,0,11438,0,0,0,0,
+-0,11440,11453,0,0,0,0,0,0,11454,0,0,0,0,11455,0,0,11456,11460,11461,11463,0,
+-11469,0,11473,0,0,0,0,11474,0,0,0,11475,0,11476,11477,11480,0,0,0,0,11481,0,0,
+-11484,0,0,11487,0,0,0,0,0,0,0,0,0,0,11497,0,0,11502,0,11509,0,0,11510,11511,
+-11513,0,0,0,0,0,0,0,0,0,0,11515,0,0,0,0,11516,0,11520,11521,0,0,0,0,0,0,0,0,0,0,
+-0,11529,11530,11531,11534,0,0,11543,0,0,0,0,0,11547,0,11548,0,0,0,0,0,11552,
+-11556,0,11557,0,0,11559,0,11560,0,0,0,0,0,0,11561,0,0,11563,11564,0,11565,0,0,0,
+-0,11567,0,0,0,11569,0,11574,0,11575,0,0,0,11577,0,11578,0,0,0,11580,11581,0,0,0,
+-11582,11584,0,0,0,0,0,0,0,11587,0,11588,11591,0,11595,0,0,0,0,0,0,0,0,11596,0,
+-11597,0,0,0,0,11598,11601,0,0,0,11602,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,11603,
+-11604,0,11606,0,0,11608,0,0,0,0,11610,0,0,11611,0,0,0,0,11613,0,11622,0,0,0,
+-11623,0,0,0,0,11625,0,0,11626,11627,11628,11630,0,0,0,0,0,0,11639,0,0,11646,0,
+-11648,11649,0,11650,0,0,0,0,0,0,0,0,0,11651,0,0,11652,11653,11656,0,0,11677,
+-11679,0,0,0,0,11680,0,0,11681,0,11685,0,0,0,0,0,0,0,0,11688,0,0,0,11716,0,11719,
+-0,0,0,0,0,11721,0,0,11724,11743,0,0,0,0,0,0,0,0,11745,11748,11750,0,0,0,0,0,
+-11751,0,0,0,11752,11754,0,11755,0,0,0,0,0,0,0,11759,0,0,0,0,0,0,11760,0,0,0,
+-11761,0,0,0,0,0,0,11766,11767,0,11772,11773,0,11774,0,0,11775,0,11777,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,11778,11780,0,0,0,0,0,0,0,11783,0,11784,0,0,0,11785,
+-0,0,0,11786,0,0,0,0,11788,0,0,11789,11791,11792,0,0,0,0,11795,11834,11835,11836,
+-0,0,11837,0,0,0,11838,0,0,11846,11851,0,11852,0,11869,0,0,0,11871,0,0,0,11872,
+-11874,0,0,0,0,0,0,11875,0,11876,11877,0,0,0,0,0,0,0,0,0,0,11883,0,0,0,0,0,0,0,
+-11884,0,11885,0,11886,0,0,11887,0,11894,11895,11897,11909,11910,0,11912,11918,0,
+-0,11920,0,11922,11924,11927,11928,0,0,0,0,11929,0,11934,0,0,0,0,0,11941,11943,
+-11944,0,11945,0,0,0,0,11948,11949,0,0,0,0,11953,0,11954,0,11955,0,11956,0,0,0,0,
+-0,11957,0,0,11959,0,0,0,0,0,0,0,0,11961,0,0,0,0,0,11978,0,0,0,11979,11980,11986,
+-11987,0,11992,0,0,0,0,0,11993,0,0,0,11994,0,11999,12004,12005,12006,0,0,0,0,0,
+-12011,0,0,12012,12014,0,0,12015,0,0,12019,12028,0,0,12029,0,0,12032,12033,0,0,0,
+-0,12034,0,12041,12043,0,0,12044,0,0,0,0,0,0,0,12046,0,0,0,0,0,0,0,12054,12055,0,
+-12056,0,0,0,12060,12064,0,0,0,0,0,12065,12067,12068,0,0,0,0,0,0,0,0,12074,0,0,0,
+-12075,12076,0,0,0,12079,0,12081,12086,12087,0,0,12088,0,0,0,0,12089,0,12092,0,0,
+-0,0,12097,0,0,0,0,0,0,0,0,12098,0,0,0,0,0,0,0,0,0,0,0,0,0,12102,12103,12104,
+-12111,0,0,12114,12116,0,0,0,12118,0,0,0,12119,12120,12128,0,0,0,0,12130,0,0,0,0,
+-0,0,12131,0,0,0,12132,12134,0,0,0,0,12137,0,12139,0,12141,0,0,12142,0,0,0,12144,
+-0,0,0,0,0,12145,0,12148,0,12153,0,0,0,0,12154,12171,12173,0,0,0,12175,0,0,0,0,
+-12178,0,0,0,0,0,0,0,12183,0,0,0,0,0,0,0,0,12184,0,0,0,12186,0,0,0,0,0,12187,
+-12188,0,0,12189,0,12196,0,12197,0,0,12198,0,12201,0,0,0,0,12203,0,12209,0,0,0,0,
+-12210,12211,12212,12213,0,12217,12218,0,0,0,0,0,0,0,0,0,12222,0,0,0,0,0,0,0,
+-12223,0,0,12229,0,0,0,0,12233,0,0,0,0,12234,0,0,12236,12242,0,0,0,12243,0,0,0,
+-12244,12253,0,12254,12256,0,12257,0,0,12275,0,0,0,0,0,12277,0,0,0,0,0,12278,0,
+-12289,0,0,12290,0,12292,12293,0,0,12294,0,12295,0,0,12296,0,12297,0,12298,0,0,0,
+-0,12301,0,0,0,0,0,0,0,0,0,0,0,0,0,12309,0,12338,12340,0,0,0,0,12341,0,0,0,0,0,0,
+-0,0,12342,12343,0,12344,0,0,0,0,0,0,0,0,0,12345,0,0,0,0,0,0,0,0,12346,0,0,0,0,
+-12348,0,0,0,0,0,0,0,0,0,0,0,0,12350,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12351,0,12355,
+-12356,12357,0,0,12367,12370,12371,0,0,0,0,0,12372,12376,0,0,0,0,0,0,0,0,12379,0,
+-12382,0,12383,0,0,12384,0,0,0,0,12393,0,0,12394,0,0,0,0,12398,12403,0,0,12404,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,12410,0,0,0,12411,0,0,0,12412,0,0,0,0,12420,0,12421,0,0,
+-0,0,0,12423,0,12425,12429,0,0,0,12431,12432,0,0,0,0,0,0,0,0,0,0,0,0,12434,0,0,0,
+-0,0,12435,12436,0,0,0,0,0,0,0,0,12437,0,0,0,0,0,12438,0,0,0,0,0,0,0,0,12445,0,0,
+-0,12450,12451,0,0,0,0,0,0,0,0,12452,12475,0,0,12493,12494,0,0,0,12495,0,0,0,0,
+-12496,12502,12509,0,0,0,0,12510,0,12512,12513,0,0,0,0,12514,0,0,0,12515,0,12520,
+-0,0,0,12524,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12527,0,0,0,12528,0,0,0,12529,0,0,0,
+-0,0,12530,0,12535,0,0,12536,0,12538,0,0,0,0,0,0,0,0,0,0,0,0,12540,0,12548,0,0,0,
+-0,0,12550,0,0,0,12551,12552,0,0,0,12554,0,0,0,0,0,0,0,0,12555,0,0,12562,0,12565,
+-0,12566,0,0,0,0,0,0,0,0,0,0,0,0,12569,0,0,0,12571,12574,0,0,0,0,0,0,0,12577,0,0,
+-0,0,0,0,0,12578,12579,12603,0,12608,0,0,12611,0,12612,0,12615,0,12625,0,0,0,0,
+-12627,12646,0,12648,0,0,12657,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12670,0,0,12671,0,
+-12673,12677,0,0,0,0,0,0,0,0,0,0,0,12679,0,12681,0,12682,12693,0,12694,0,12697,0,
+-12701,0,0,0,12703,12704,0,0,0,0,12707,12737,0,0,12739,0,0,12740,0,0,12742,12743,
+-0,0,0,0,0,0,0,0,0,12745,0,12746,12747,0,12748,0,0,12759,12767,0,0,0,0,12773,0,
+-12774,12778,0,0,0,0,0,0,0,12779,0,0,0,0,0,12780,12793,0,12824,0,12825,0,12836,0,
+-0,0,0,12839,0,12842,0,0,0,0,0,0,0,0,0,0,0,0,12843,12845,0,12846,0,0,0,0,12847,0,
+-0,12850,12852,12853,0,0,0,12854,0,0,0,12855,0,12856,0,12858,0,0,12859,0,12862,0,
+-12863,0,0,12866,0,12869,12872,12873,0,0,0,0,0,0,0,0,0,12875,0,12877,0,0,12878,0,
+-0,0,0,0,0,0,0,0,12884,12885,12888,0,12889,0,0,0,0,12893,0,0,0,12895,12896,12898,
+-0,0,0,0,0,0,0,12902,0,12909,12910,0,12926,0,12928,0,0,0,12929,0,12930,0,0,0,0,
+-12931,0,12932,12933,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,12934,0,12942,0,0,0,0,12944,
+-0,0,0,0,0,0,0,0,12946,0,0,12948,0,0,12949,0,0,0,0,12950,0,0,0,0,12951,0,12952,0,
+-12953,0,0,0,12954,12958,12959,0,0,0,0,0,12960,12964,0,0,0,0,0,12966,0,0,0,0,0,0,
+-0,0,12970,0,12971,0,0,0,0,0,0,12972,0,0,12982,0,0,0,12984,12985,0,12986,12996,
+-12997,13001,13002,0,0,0,0,13004,0,0,13005,0,0,13007,13009,0,13017,0,0,0,13020,0,
+-13021,0,0,0,0,0,0,0,0,0,0,13022,0,0,0,0,0,0,0,0,13024,13027,0,0,0,0,0,13028,0,0,
+-13029,0,0,0,0,0,0,0,13032,0,13037,0,0,0,0,0,0,13040,0,0,13041,0,0,0,13043,13044,
+-13046,0,0,0,0,13047,0,0,0,0,0,0,0,13049,13054,0,13056,0,0,13060,13061,0,0,0,0,0,
+-13067,0,0,13068,0,13071,0,0,0,0,0,13077,13078,0,0,0,0,0,13079,13080,13081,0,
+-13082,0,0,0,13085,0,0,0,0,0,0,0,13086,0,13087,13088,0,0,0,0,0,13094,0,13099,0,
+-13100,0,0,0,13101,0,13125,13126,13128,13129,0,0,13130,0,13131,0,0,0,0,0,0,13134,
+-0,0,0,0,0,0,0,0,0,0,0,13150,0,13168,0,0,0,0,0,0,0,0,0,13169,0,0,13170,0,0,0,0,
+-13174,0,0,0,13176,0,0,0,0,0,13177,0,13178,13183,13187,0,0,0,13189,0,0,13190,0,0,
+-13191,0,0,13206,0,0,0,13207,0,0,0,0,0,0,0,0,0,0,13212,0,0,13219,13232,0,0,0,
+-13241,0,13249,13253,0,0,0,0,0,13255,13259,0,13260,13261,0,13262,0,13272,0,0,0,0,
+-13276,0,0,0,0,13277,13299,0,0,13301,13302,0,0,13303,0,0,13305,0,13310,0,0,0,
+-13311,0,0,0,0,13325,0,13328,0,0,0,13329,0,0,0,0,0,0,13330,0,0,13331,0,13335,0,0,
+-13342,0,0,0,0,0,13343,0,13354,0,13362,0,13366,13367,13369,0,0,13371,13372,0,
+-13373,13374,0,13376,0,13380,13381,13386,0,13387,13388,0,13389,13391,13395,0,0,0,
+-0,0,13401,13409,0,13410,0,0,0,0,13420,0,0,0,0,0,13422,0,0,0,0,13423,0,0,0,0,
+-13425,0,0,0,0,0,13427,0,0,0,13428,0,0,13430,13438,0,13439,0,13445,0,13448,13449,
+-0,0,0,0,0,0,13451,0,13457,0,0,0,0,13458,13459,0,13460,0,0,0,0,13464,13465,13466,
+-13470,0,13471,13472,13474,13475,0,13476,0,0,13478,13479,0,13481,0,0,0,0,13487,0,
+-13490,0,13493,0,0,13494,0,0,13495,0,0,0,0,0,0,0,0,0,0,0,0,0,0,13496,13497,0,
+-13500,0,0,13516,13522,0,0,13525,13528,0,0,0,13530,13535,0,13537,13539,0,13540,0,
+-13543,0,13544,0,0,0,0,0,0,13545,0,0,0,0,0,0,13547,0,0,0,13549,13555,0,0,0,13556,
+-13557,0,0,0,0,0,0,0,13558,0,13563,0,0,0,0,13564,0,0,0,0,0,0,0,0,13566,0,0,0,0,0,
+-0,13569,0,0,13571,0,0,0,0,13573,0,0,0,0,0,0,13578,0,0,0,0,0,0,0,0,0,0,13581,0,
+-13586,0,13595,0,13600,0,0,0,0,0,0,0,0,13601,13603,0,13604,13605,13606,13607,0,0,
+-13617,13618,0,0,0,0,0,0,0,13623,0,13625,13627,0,0,0,0,0,0,0,0,13629,0,0,0,13634,
+-0,0,0,13638,0,0,0,0,0,0,0,0,13654,0,0,0,0,0,0,0,0,0,0,13656,0,13659,0,0,13660,0,
+-0,13662,0,0,0,13663,0,13664,0,0,0,0,0,13668,0,13669,13671,0,0,13672,0,0,0,0,0,0,
+-13675,13685,0,13686,0,0,0,13687,0,0,0,13692,13694,13697,0,0,0,13702,0,0,0,0,0,
+-13705,0,0,0,0,13707,0,0,0,13714,0,0,0,0,0,0,0,0,0,13715,0,13716,13717,0,0,13719,
+-13724,13730,13731,0,0,0,0,0,0,0,0,13732,0,0,0,0,0,0,0,13734,0,13736,0,0,13737,
+-13738,13747,0,13751,0,0,13752,0,0,0,13753,0,13757,0,0,13762,13763,0,13764,13765,
+-0,13766,0,0,13767,0,0,0,13768,0,0,0,0,0,0,0,13769,0,0,13772,0,13775,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,13776,13778,13787,0,0,0,13797,0,13798,0,13801,0,13804,
+-13806,0,0,0,0,13816,13817,0,0,0,0,0,0,0,0,0,0,0,0,0,13834,0,13836,0,0,13838,0,0,
+-13839,0,13840,0,0,0,0,13842,0,0,0,0,0,0,13843,0,0,0,0,0,0,0,0,0,13845,0,0,0,0,0,
+-13858,0,0,13860,0,0,13861,0,0,13862,13863,0,13868,0,13869,13870,0,0,0,0,0,0,0,0,
+-0,0,13872,0,0,0,0,13873,13878,0,0,0,0,0,0,0,0,0,0,13886,0,13888,13889,13890,0,0,
+-13891,13894,0,13897,13899,13900,13904,0,0,13906,0,0,0,13909,0,0,0,13910,0,0,0,
+-13911,0,0,0,0,0,13912,13917,0,0,0,0,13918,0,13919,0,0,13920,0,0,0,13921,0,0,
+-13922,0,0,0,0,0,0,0,13924,0,13927,0,0,0,0,0,13932,0,13933,0,13934,0,0,13935,0,
+-13944,0,0,0,13954,0,0,13955,0,0,0,0,13956,0,13957,0,13967,13969,0,0,0,0,0,0,0,0,
+-0,0,0,0,13970,13990,0,13991,13994,0,13995,0,0,0,0,13996,0,0,13999,0,0,0,14018,0,
+-14019,0,14021,0,0,0,0,0,0,14041,0,0,0,0,0,0,0,0,14043,0,0,0,0,14046,0,0,0,14048,
+-14049,0,0,0,0,0,0,0,0,0,0,14051,0,0,14052,14056,0,14063,0,14064,14066,0,0,14067,
+-0,0,0,0,0,0,0,0,0,14068,0,0,0,14072,0,14074,14075,0,14076,14079,14085,14086,
+-14087,14093,0,0,0,0,14095,0,0,0,0,0,0,14096,14097,0,0,0,0,0,0,0,14098,0,14102,0,
+-0,0,0,0,14103,0,0,0,14104,0,0,14105,0,0,0,14107,14108,0,0,14109,0,0,0,0,0,0,0,0,
+-14117,0,0,0,0,14118,0,0,0,0,14119,0,0,14120,0,0,14121,0,14122,14127,0,14128,
+-14136,0,0,14138,0,14140,0,0,0,14141,14142,0,0,0,0,14146,0,0,14149,0,14151,0,0,0,
+-14152,0,0,14153,0,0,0,0,0,0,0,0,0,14154,0,14156,14157,0,0,14159,0,14161,0,0,0,0,
+-14162,0,0,0,0,0,0,14163,0,0,14173,0,0,0,0,0,0,14174,0,0,14176,0,0,14178,0,0,
+-14179,14181,0,0,14182,14185,14187,0,14190,0,0,14197,0,0,0,0,0,0,0,0,0,0,0,0,
+-14198,0,0,0,0,0,0,14199,14200,0,0,0,14204,0,0,14208,0,0,0,0,0,0,0,0,0,0,0,14231,
+-0,0,0,0,0,0,0,0,0,14234,0,0,14235,0,0,0,14240,14241,0,0,0,14246,0,0,0,14247,0,
+-14250,0,0,14251,0,0,14254,0,0,14256,0,0,0,14260,0,14261,0,0,0,0,14262,14267,
+-14269,0,0,14277,0,0,14278,0,14279,14282,0,0,0,14283,0,0,0,14284,14285,0,0,0,0,
+-14286,0,0,0,14288,0,0,0,14289,0,14290,0,14293,14301,14302,14304,14305,0,14307,0,
+-14308,14309,0,0,0,0,0,0,0,0,0,0,0,14311,14312,0,0,14317,0,0,0,0,0,0,0,14318,0,0,
+-0,0,14320,0,0,0,0,14321,14322,0,0,0,0,0,14326,14329,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-14330,14331,0,0,0,0,14332,0,0,0,14333,0,0,14337,14340,0,14341,0,0,14342,0,14345,
+-14346,0,0,14347,0,14362,0,0,0,0,0,14364,14365,14371,0,14373,0,0,14374,0,14379,0,
+-14400,0,0,0,0,0,14401,0,0,14405,0,14406,0,14408,14409,0,0,0,14417,0,0,14424,0,0,
+-0,0,0,0,0,0,0,14430,0,0,0,14431,0,0,14435,0,14440,0,0,0,0,0,0,14442,0,0,14443,0,
+-0,0,0,0,14446,0,0,0,0,0,0,0,14454,0,14457,0,14460,0,0,14466,0,0,0,0,0,14467,0,0,
+-0,0,0,0,14469,0,14477,0,0,0,0,0,0,14478,14482,0,0,0,14483,0,0,0,14485,14486,0,0,
+-0,14487,14488,14489,14492,14493,14494,14495,14496,14497,0,14499,0,14501,0,0,0,0,
+-0,0,0,0,0,0,14502,0,14507,14512,14513,14514,0,0,0,0,0,0,0,0,0,0,0,14515,14526,
+-14530,0,14537,0,14544,0,14547,0,0,14548,14550,14551,0,0,14552,0,0,0,14553,0,
+-14554,0,0,0,0,14556,14564,0,0,14565,14566,0,0,0,0,0,0,14568,0,0,14569,0,0,0,
+-14571,14576,0,0,14577,14578,14579,0,0,14580,0,0,0,0,14582,0,0,0,0,0,0,0,0,0,0,0,
+-0,14583,0,0,0,0,0,14587,0,14588,0,0,14600,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,14601,0,0,14604,14605,14611,0,14613,0,0,0,0,14615,0,0,0,0,0,0,14627,0,14628,0,
+-0,0,0,14631,0,14633,14634,0,0,0,0,14635,0,0,0,0,0,0,0,0,14636,0,0,14639,14642,0,
+-0,0,0,14644,0,0,0,0,14645,14646,0,14653,0,0,14654,0,14658,0,14661,0,0,0,14665,0,
+-0,0,14668,0,0,0,0,0,0,0,0,0,14669,0,0,14670,0,0,0,14680,0,0,14681,0,0,0,0,0,
+-14682,14683,0,0,0,0,14686,0,0,0,0,14687,14697,0,0,0,0,14699,14705,14711,0,0,0,0,
+-0,0,0,0,0,0,14712,0,0,0,14713,0,0,0,0,14719,0,14720,14721,14726,0,0,0,14728,
+-14729,0,0,0,0,14731,0,0,0,0,0,0,0,14733,14736,14737,0,0,14740,14742,0,0,0,14744,
+-14753,0,0,0,0,14755,14758,14760,0,0,0,0,0,14761,14762,14765,14771,0,14772,0,
+-14773,14774,0,0,14775,0,0,14776,0,0,0,0,14777,0,14779,0,0,14782,0,0,14785,14786,
+-14788,0,0,0,0,0,14795,0,0,0,0,0,0,14798,0,14803,14804,14806,0,0,0,14809,0,0,0,0,
+-0,0,14810,0,0,0,0,14811,0,14812,0,0,0,0,0,14815,0,0,0,0,0,0,0,0,14816,0,14818,0,
+-0,0,0,0,0,14819,0,14820,0,14823,0,0,0,14824,0,0,14826,14827,0,0,0,0,0,0,0,0,0,0,
+-0,0,14830,0,0,0,0,0,14833,0,14845,0,0,0,0,0,14846,0,0,14847,14871,0,14873,0,
+-14876,0,14877,14878,14880,0,0,0,0,0,14881,0,14882,14894,0,0,0,0,14895,0,14907,0,
+-14908,0,0,0,0,0,0,0,14911,0,0,0,0,14920,0,0,14931,0,14932,14934,14935,0,0,14936,
+-0,14945,0,0,0,0,0,0,0,14947,0,0,14948,14949,14951,0,0,14952,0,0,0,14964,14973,0,
+-0,14990,0,0,0,0,14995,0,0,14998,15001,0,0,15002,15020,0,0,0,0,0,0,15021,0,15022,
+-0,0,0,0,15023,0,0,15025,15029,15033,0,0,0,15034,0,0,0,15035,0,0,0,0,0,15043,
+-15044,0,0,0,15045,15046,15048,15050,0,15065,0,0,0,0,15066,0,0,15075,15082,15084,
+-0,0,15085,15086,0,0,0,0,0,0,0,0,15088,0,0,0,15089,0,0,0,0,15094,0,15096,0,15097,
+-0,15100,0,0,15102,0,0,0,0,0,0,0,0,15105,0,0,15106,0,15109,15113,0,0,0,15115,0,
+-15118,0,0,0,0,0,0,15119,0,0,15120,0,0,0,0,0,15123,15129,0,0,0,15130,0,15131,0,0,
+-15134,0,15135,0,0,0,15137,15138,0,0,0,0,0,0,15139,0,0,0,0,0,15140,0,0,15154,
+-15162,0,15169,15170,0,15175,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15177,0,15178,15179,0,
+-0,0,0,0,15183,0,0,0,0,0,0,0,0,0,0,0,0,15185,15187,0,15194,15195,15196,0,0,0,0,0,
+-0,0,15204,0,0,0,0,15206,0,0,0,0,0,15207,0,0,0,0,0,0,0,0,0,15213,0,15214,0,0,0,0,
+-0,0,0,15232,0,0,0,0,15234,0,15238,15240,0,15248,0,0,0,0,15250,15251,0,0,0,0,0,0,
+-0,15252,0,0,0,15255,15262,15266,0,0,0,15267,0,0,0,15277,15279,0,0,0,15280,15281,
+-15282,0,0,0,0,0,15285,0,0,0,0,15289,0,0,15291,0,0,0,0,0,0,0,15296,15297,0,0,
+-15304,0,0,0,0,15306,0,0,0,0,0,0,15307,15308,0,15309,0,0,15311,0,0,15312,15313,0,
+-0,0,0,0,0,0,0,0,0,0,0,15314,15317,0,0,0,15318,15319,0,0,0,0,15320,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,15321,0,0,0,0,0,15324,0,15325,15326,0,15330,0,0,0,0,15334,0,
+-15335,0,15341,0,0,15342,0,0,15343,15344,0,0,0,0,15345,0,0,0,0,15347,0,0,15348,
+-15349,15350,0,15356,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15357,0,15358,0,0,0,0,0,0,0,
+-15359,15360,15364,0,15380,0,0,0,0,0,15392,0,0,15393,0,15395,0,0,0,0,0,0,0,0,
+-15396,0,0,15397,15398,0,0,0,0,0,0,0,0,0,15399,0,15400,0,0,0,15402,0,15405,15410,
+-0,0,0,0,15411,0,0,0,15412,0,15416,0,0,0,0,0,0,0,15428,0,15435,0,0,15438,0,0,0,0,
+-15439,0,0,0,15440,0,0,0,15441,15449,15451,0,0,0,0,0,0,0,15452,0,0,15455,0,0,0,
+-15456,0,0,15458,0,15460,15461,0,0,0,0,0,15462,15464,0,15465,0,0,15466,0,0,15467,
+-0,0,0,0,0,15468,0,0,0,0,15481,0,0,15484,0,15485,15486,0,0,0,15487,0,0,0,0,0,
+-15488,0,15492,15498,0,0,0,15499,0,0,0,15500,0,15501,0,0,15512,0,15522,0,0,0,
+-15524,0,15525,15526,0,0,15527,0,0,15545,15546,0,15548,15552,0,15553,0,0,0,15554,
+-0,15555,0,15557,15565,15573,15577,15578,0,15582,0,15583,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,15586,0,0,0,0,0,0,0,0,0,0,0,0,0,0,15588,0,0,0,0,0,15589,0,0,0,0,0,0,0,15593,
+-15594,0,0,0,0,15595,0,0,0,0,0,0,15596,0,0,0,15597,0,0,0,0,15600,0,0,15601,0,0,0,
+-0,15602,15603,0,0,0,0,0,0,15604,0,15609,0,0,15612,0,0,15613,0,0,15615,15617,
+-15618,0,0,15620,0,15636,15637,0,0,15649,0,0,0,0,0,0,0,15650,0,0,15651,0,0,0,
+-15656,0,15658,0,0,0,15664,0,0,15665,0,0,15668,0,0,0,0,0,15669,0,0,15674,0,0,
+-15675,0,0,0,0,15676,0,0,0,0,0,0,0,0,0,0,0,15677,0,0,0,0,15678,0,0,0,0,0,15679,0,
+-0,15681,0,15686,0,0,0,0,15687,0,15688,0,0,15690,0,0,0,15697,0,15699,15700,0,0,0,
+-0,0,0,0,0,0,15701,0,15702,15703,0,15704,0,15705,0,15707,0,15709,0,15712,15716,0,
+-15717,0,15718,15720,0,0,0,0,0,15724,0,0,0,15725,0,15726,0,0,0,15740,0,15745,
+-15746,0,0,15747,0,15748,0,0,0,0,0,15749,0,0,0,15752,0,15753,0,0,0,0,0,0,15759,0,
+-0,0,15765,0,0,0,0,0,0,0,0,0,15767,0,0,0,15771,0,0,15784,0,0,0,0,15785,15790,
+-15791,0,0,15792,0,0,0,15807,0,15811,0,0,0,0,0,0,0,0,0,0,0,0,15818,0,0,0,15819,0,
+-0,0,0,15821,0,0,0,0,0,15822,15824,0,0,15827,0,0,15829,15831,0,15832,0,0,15833,0,
+-15835,15838,15839,15843,0,0,0,0,0,0,0,0,0,0,0,15844,0,0,0,0,15845,15851,15856,0,
+-0,0,0,0,0,0,15858,15860,0,15861,0,0,0,15864,0,0,0,0,15865,0,0,0,0,0,0,15866,0,
+-15872,0,0,15876,0,0,0,0,15877,15878,15883,15885,0,0,15888,0,0,0,0,0,15889,15890,
+-0,0,0,0,0,0,0,0,15892,0,0,0,0,0,0,0,15893,0,0,15894,0,0,0,15895,0,15896,15897,0,
+-15898,15901,15902,0,15911,15915,0,15916,0,15924,15935,0,15937,0,0,0,0,0,15950,0,
+-0,0,0,0,0,0,15958,0,0,0,15961,0,0,15966,0,15967,0,0,15977,0,0,15978,0,0,15981,
+-15982,15983,0,0,0,0,0,0,0,15986,0,0,0,15990,0,15991,15995,15998,0,15999,0,16000,
+-0,0,0,0,16008,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16009,16011,0,16013,0,0,0,0,
+-0,0,0,0,16014,0,0,16015,16023,16024,16025,0,0,16026,0,16030,0,16032,0,16033,0,0,
+-0,0,0,0,16035,16036,16037,0,0,0,0,0,16039,0,0,0,0,16041,0,0,0,0,0,16043,16044,0,
+-0,16047,0,0,0,16048,0,0,16049,16050,16052,0,0,0,0,0,16055,0,0,0,0,0,0,0,0,16056,
+-0,0,0,0,0,0,0,16058,16060,16061,0,0,16063,0,0,16064,0,0,0,16067,16068,0,0,16069,
+-16078,0,0,0,16079,0,0,0,16080,0,16081,0,0,0,16088,0,0,0,0,0,0,0,0,0,0,0,16089,
+-16093,0,16097,0,16103,0,16104,16105,0,0,16256,0,0,16259,0,0,0,0,0,0,0,16260,
+-16261,0,0,16262,0,0,16263,0,16268,0,0,0,0,0,0,0,16269,0,0,16270,16273,0,16274,0,
+-0,0,0,16275,16276,16277,16280,0,0,0,16281,16284,0,0,0,16286,0,16289,0,0,0,0,0,0,
+-0,0,0,16290,0,0,0,0,16291,0,0,0,0,0,0,0,16292,0,0,0,0,0,0,0,0,16293,16295,16297,
+-0,16302,0,16304,0,16305,0,16306,0,0,0,0,0,0,0,0,0,0,0,0,16307,16308,16312,0,0,0,
+-0,0,0,16313,16315,0,16318,0,0,0,16321,0,0,0,0,0,0,0,16326,16333,16336,0,0,0,0,
+-16337,16340,0,0,0,0,0,16345,0,0,16346,0,0,0,0,0,0,0,0,0,16347,0,0,16348,0,0,0,0,
+-16349,0,0,0,16350,0,16357,0,0,0,0,16359,16360,0,0,0,0,16362,16363,16364,16365,0,
+-0,16366,0,0,0,0,16367,16368,0,16369,16374,0,0,0,0,0,0,0,16376,0,0,0,0,16378,
+-16379,0,16380,0,0,0,16381,16383,0,0,0,0,0,16390,0,0,0,16399,0,16402,16404,16406,
+-16407,0,0,0,16409,16411,0,0,0,0,16412,0,16413,16415,16423,0,0,0,0,0,16424,0,0,0,
+-16428,16434,16435,16449,0,16450,16451,0,0,0,16453,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-16454,0,0,16456,16458,0,0,16459,0,0,16460,0,0,0,0,16462,0,16463,0,0,16466,0,0,0,
+-0,0,16479,0,0,16480,0,16481,16484,0,0,0,0,0,0,0,0,0,0,16485,0,0,0,0,0,0,16489,0,
+-0,0,0,0,16491,0,0,16498,0,0,16503,0,16505,0,0,0,0,0,0,0,0,16506,0,0,0,16508,
+-16509,0,0,0,0,0,0,0,0,16511,16513,0,0,0,16516,0,16517,0,16519,0,16529,0,0,16531,
+-0,0,0,0,0,0,16534,0,0,16541,16542,0,0,0,0,0,0,0,0,0,16543,16547,16548,0,0,0,
+-16551,0,16552,0,0,0,16553,0,0,16558,0,0,16562,16565,0,0,0,16570,0,0,0,16573,
+-16585,0,0,0,16586,16587,16595,0,16596,0,16598,0,0,0,16600,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,16601,0,0,0,0,16603,0,0,0,0,0,0,0,16604,16612,0,0,0,0,16613,0,16618,0,0,0,
+-16640,0,0,16641,0,0,0,0,0,0,16645,0,0,0,0,16646,0,0,0,0,0,0,16651,0,0,0,0,16653,
+-16654,0,0,0,16655,0,0,16656,16667,0,0,0,0,16671,0,16672,0,0,0,16673,0,0,0,0,0,
+-16676,0,16686,0,0,0,0,16689,0,16690,0,16692,0,16693,0,16694,0,16696,0,0,0,16705,
+-0,0,0,0,0,0,16707,0,0,0,16709,0,0,0,0,16711,0,16712,16713,0,0,0,16715,0,0,0,0,
+-16716,0,0,0,0,0,0,0,0,0,16718,16724,0,0,16726,16727,0,0,0,0,0,0,0,16728,0,16729,
+-0,0,16730,0,0,0,0,0,16731,0,0,0,16732,0,0,0,0,16734,16738,0,0,0,0,0,0,0,0,16743,
+-0,0,16745,0,0,0,0,0,16749,0,16752,0,0,0,0,16756,0,0,16758,0,16759,0,0,0,0,0,
+-16760,0,0,0,0,0,0,0,16762,0,16769,0,16770,0,16772,0,0,0,16777,16780,0,0,0,0,0,0,
+-16781,0,0,16782,0,16784,0,0,16785,16787,16792,0,0,16794,0,0,0,16798,0,0,16809,0,
+-0,16814,16816,16817,0,16819,0,0,0,0,0,0,0,0,0,0,16820,0,0,16836,16839,0,0,16841,
+-16851,16857,0,0,16858,16859,0,0,16860,0,0,0,0,0,0,0,0,16862,0,16863,0,0,0,0,0,0,
+-0,16864,0,0,0,0,0,0,0,16876,0,16881,16882,0,16885,16886,0,16887,0,0,0,16889,
+-16891,0,0,0,0,0,16894,16895,0,0,0,0,0,0,0,0,0,0,0,16897,0,16898,0,0,0,0,0,16913,
+-0,0,16924,16925,16926,0,0,16927,0,0,0,16937,16938,0,0,0,16940,16941,0,0,0,16942,
+-16945,0,16946,16949,16950,0,0,0,16952,16955,0,0,0,16965,0,16969,0,0,16975,0,0,
+-16976,0,0,0,0,16978,0,0,16981,0,16983,16989,0,0,0,0,16990,0,0,16991,0,0,0,16993,
+-0,16994,16996,17000,0,0,0,0,0,17002,17004,0,17006,0,0,17007,0,0,0,0,17008,17013,
+-17014,0,0,0,0,0,0,0,0,0,17021,0,17031,0,0,0,0,0,17033,17036,0,17038,0,0,17039,0,
+-17045,0,0,17046,17047,0,0,0,0,17048,0,17049,17050,0,17051,17053,0,17054,0,17055,
+-0,0,0,0,0,17063,0,0,17064,0,0,0,0,0,0,0,17065,0,0,17068,0,0,0,0,0,17072,0,0,0,0,
+-0,0,17073,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17074,0,17080,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,17081,17083,17084,0,0,0,17085,0,0,0,0,17092,0,0,0,0,0,0,0,
+-0,0,17093,0,17095,17102,0,0,0,0,0,0,17103,0,0,17105,0,17107,0,0,0,0,17114,0,0,0,
+-0,0,17115,17125,17127,0,0,17128,0,0,0,17129,17130,0,17131,0,0,0,0,0,17132,17135,
+-17145,0,0,0,0,0,0,0,0,17146,0,17147,0,17148,0,0,0,0,0,0,17149,17150,0,17151,
+-17153,0,17155,0,0,0,0,17163,17171,0,17174,0,0,0,0,17179,0,0,17182,17185,0,0,0,0,
+-0,17186,0,0,17188,0,0,0,0,0,0,0,17189,17191,0,17194,0,0,0,0,0,0,0,0,0,17195,
+-17196,17203,17204,0,0,17205,17217,0,0,0,0,0,17218,0,0,0,0,17219,0,17220,0,17221,
+-0,0,17230,0,0,0,0,0,17236,0,17238,17239,0,0,0,17241,17244,0,0,17245,0,17248,0,0,
+-17251,0,17252,0,0,17264,0,17266,0,0,0,17268,0,0,0,0,17271,17272,0,17273,0,17295,
+-0,17302,0,17305,0,0,0,17306,0,0,0,0,0,0,0,17308,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-17309,0,17310,17313,0,0,0,0,17314,17315,0,17317,0,0,0,0,17318,0,0,0,0,0,0,0,
+-17320,0,0,0,0,0,0,17334,0,17344,17348,0,0,0,17350,17351,0,0,17353,0,0,17354,0,0,
+-0,0,0,0,0,0,0,17355,0,0,0,0,0,0,17356,17357,0,0,17359,0,0,0,17371,0,17372,0,0,0,
+-17393,0,0,0,0,17394,0,0,0,0,0,17395,0,0,17399,0,0,0,17401,17417,0,17418,0,17419,
+-0,0,0,0,0,17422,17423,0,0,0,0,0,17424,0,0,0,0,0,17428,17429,17433,0,0,0,17437,0,
+-0,17441,0,0,17442,0,0,17453,0,0,0,0,0,0,0,0,17454,17456,17462,0,0,17466,0,0,
+-17468,0,0,17469,0,0,0,0,17470,0,17475,0,0,0,0,0,17479,0,0,0,17483,17484,0,17485,
+-0,17486,0,17491,17492,0,0,17493,0,17494,17495,0,0,0,17496,0,0,0,17497,0,0,0,
+-17502,0,0,0,0,0,17503,0,17505,0,17507,0,0,0,17512,17513,17514,0,0,17515,0,0,0,
+-17519,0,0,0,17522,0,0,17523,0,0,0,0,0,0,0,0,0,17527,0,0,0,17528,0,0,0,17534,0,0,
+-0,0,17536,0,0,0,17539,0,17540,17543,17549,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17556,
+-0,0,17558,0,17559,0,0,17560,0,0,0,17563,0,0,0,0,0,0,17564,0,0,17565,17566,0,
+-17567,0,0,0,0,0,0,17569,17570,0,17575,0,0,0,0,0,0,0,0,0,0,0,17581,0,0,0,17582,
+-17583,0,17586,0,0,17587,0,0,0,0,0,0,0,17588,0,0,0,0,17596,17597,0,0,17598,17600,
+-0,0,0,0,0,0,17601,0,0,0,17604,0,0,17605,0,0,17607,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,17612,0,0,17618,0,17621,17622,0,0,0,0,17623,0,0,17624,0,0,17630,0,0,
+-17631,17633,17634,0,0,0,0,0,0,0,17635,0,0,17636,0,0,17637,0,17638,0,17640,0,0,0,
+-0,0,0,0,0,0,0,17641,0,0,0,0,0,0,0,0,0,0,17643,0,0,0,0,17645,0,0,0,0,0,0,0,0,
+-17646,17662,0,0,0,0,0,0,0,0,0,17663,17664,0,17665,17666,0,0,0,17669,17671,17673,
+-0,17679,0,0,0,0,0,0,0,17684,0,0,0,17686,0,17714,0,0,17720,17722,17726,0,0,17728,
+-0,0,17729,0,0,0,17732,0,17733,0,17734,0,0,0,17735,0,0,0,0,17737,0,0,0,0,17739,0,
+-0,0,17741,17742,0,0,0,0,17743,17744,17745,0,0,0,17749,0,17750,17751,17752,17754,
+-17761,17762,0,17763,0,17766,0,17772,0,0,0,0,0,17775,0,0,0,0,0,0,0,17776,0,0,
+-17777,0,0,17778,17779,0,17782,17783,0,0,0,0,0,0,0,0,0,0,17784,0,0,0,0,0,0,0,
+-17821,0,0,0,17822,0,0,0,17823,17825,0,0,0,0,0,17826,17831,17832,17833,0,0,17845,
+-0,0,0,17846,0,0,0,17848,17850,17854,0,17855,0,0,17859,0,0,0,0,0,0,17860,17861,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,17870,17871,0,0,0,0,0,0,17872,0,0,0,17879,0,
+-0,0,17881,17883,0,17884,0,17885,0,0,17886,0,0,17887,17891,17953,0,0,0,0,17954,0,
+-0,17955,0,17968,0,0,17972,0,0,0,0,0,17974,0,0,0,0,17976,17978,0,0,17983,0,0,0,0,
+-18003,0,0,0,0,0,18007,0,0,0,0,0,18009,0,0,0,0,0,0,0,18010,0,0,0,0,0,0,18012,0,0,
+-18014,0,0,0,18015,0,0,0,18016,0,18017,0,0,0,18030,0,0,0,0,0,0,0,18031,0,0,18036,
+-18037,18038,0,0,18049,18056,0,18057,18058,0,18059,0,0,0,0,0,0,0,0,18062,0,0,0,0,
+-18064,0,0,0,0,0,0,0,0,18067,0,0,0,18068,0,0,18075,0,0,18078,18093,18094,0,0,0,0,
+-0,0,0,0,18097,0,0,0,0,0,18098,18100,0,0,0,18108,0,18111,0,0,18112,0,18113,0,0,
+-18115,18116,0,18118,0,0,0,0,18121,0,0,0,0,18123,0,0,0,0,0,0,0,0,0,18124,0,0,0,0,
+-18125,18126,0,18127,0,0,18128,18135,0,0,0,0,0,0,0,0,0,18150,0,0,0,0,0,18151,
+-18152,0,0,18156,18164,0,18166,18171,0,0,0,0,0,0,0,0,0,18172,18183,0,18184,0,0,0,
+-0,18185,0,18187,0,0,0,0,0,18188,0,0,0,0,0,0,0,0,18189,0,0,18190,0,0,18191,18192,
+-0,0,18194,18195,18196,0,0,0,18197,0,18203,0,18204,0,0,0,0,18205,0,0,0,18207,
+-18208,0,0,18214,0,0,0,18215,18216,0,0,0,18220,0,0,18222,0,0,0,0,0,18223,0,18225,
+-18231,0,18234,0,18235,0,0,0,0,18240,0,0,18241,18242,0,0,0,0,0,18243,18251,0,
+-18253,0,18254,0,0,0,18266,0,0,0,0,0,0,18269,18270,18271,18273,18281,0,0,0,0,0,0,
+-0,0,0,0,0,0,18282,0,18283,0,18284,0,0,0,0,0,0,18285,0,18287,18289,0,0,18290,0,0,
+-0,0,18308,0,0,0,18310,0,0,0,0,0,0,0,0,0,0,0,0,18311,0,18312,18313,0,18315,0,0,
+-18316,18320,0,18331,0,18332,0,18336,0,0,0,0,18337,0,18340,0,0,0,0,0,0,0,0,0,
+-18341,0,18344,18345,0,18346,0,0,0,0,0,18348,0,18351,0,0,18356,0,0,0,0,0,0,18357,
+-0,0,0,0,0,18367,0,0,0,18368,0,18369,0,18370,18371,0,0,0,18437,18444,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,18445,18450,0,0,0,0,18451,0,18452,0,0,0,18453,0,0,0,0,0,18455,0,
+-0,0,18456,0,18457,0,18460,0,0,18461,0,0,0,0,0,0,0,0,18466,0,0,18467,0,0,0,0,
+-18473,0,0,0,18476,0,18477,0,0,0,18478,18479,18480,0,0,0,18485,0,0,0,18486,0,0,0,
+-0,0,0,18488,18490,0,0,0,0,0,0,18491,0,0,0,0,0,18495,0,0,18496,0,0,0,0,0,0,18505,
+-0,18521,0,18522,18523,0,0,0,18525,18526,0,0,0,0,0,18527,0,0,0,0,18532,18533,0,
+-18534,0,0,0,0,0,0,18535,18537,0,18538,0,0,0,0,0,0,18540,18541,18542,18543,0,
+-18546,0,0,0,0,18553,18556,0,0,18558,0,0,18569,18571,0,0,0,18572,0,18574,0,0,0,0,
+-18586,0,0,0,0,0,18588,0,0,18589,0,0,0,0,0,0,18590,0,18592,0,0,0,0,18594,0,0,0,
+-18596,0,0,18597,18598,0,0,18601,0,0,0,0,18602,0,0,0,18603,18604,0,18605,0,0,0,0,
+-18608,0,0,18611,0,0,0,0,0,0,0,0,0,18612,0,18616,0,0,18617,18619,0,0,0,18628,0,0,
+-0,18629,0,0,18630,0,0,0,0,0,0,0,18631,0,18632,0,0,18635,18637,0,0,0,0,0,0,18641,
+-18643,18648,0,18652,0,0,18653,0,18655,18656,0,0,0,18657,0,0,18666,18674,0,0,0,0,
+-18677,18684,18685,0,0,18686,0,0,18690,0,0,0,0,0,0,0,18695,18696,0,0,0,0,0,0,0,0,
+-0,0,18697,0,0,18700,0,0,0,0,0,0,18702,0,18708,0,0,18709,0,18710,0,0,18711,0,
+-18714,0,0,18718,0,0,0,0,0,0,18719,0,0,18722,0,18726,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-18731,0,0,0,0,0,18739,18741,0,0,18742,0,18743,18744,18746,18748,0,18752,18753,0,
+-0,18754,18763,0,18765,0,0,0,18766,0,0,0,18769,0,0,0,0,0,18773,18778,18779,18781,
+-0,0,18784,18787,0,18788,0,18793,0,0,0,0,0,0,18795,0,0,18800,0,0,0,0,0,18801,
+-18804,0,0,0,0,0,0,0,18806,0,0,0,18811,18815,18816,0,0,0,0,18825,0,0,18827,18829,
+-0,0,18830,0,0,0,0,18831,0,0,18832,0,0,0,0,18833,0,18840,0,18841,0,18842,0,0,0,0,
+-18843,0,18844,0,0,0,0,0,0,18845,18846,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-18848,0,0,0,18853,18860,0,0,18862,18866,0,0,18867,18869,0,0,18874,18881,18891,0,
+-0,0,0,0,0,0,0,0,0,18892,0,0,0,0,0,0,0,0,18895,0,18896,0,0,0,18900,0,0,0,18901,0,
+-18902,18915,18916,0,0,0,0,0,0,0,0,18919,0,0,0,0,0,18920,0,0,0,18921,18929,0,0,0,
+-0,18930,0,0,0,0,0,0,18932,0,0,0,0,18934,18942,0,0,0,18951,18957,0,0,0,0,18958,0,
+-0,0,0,18959,18960,0,0,18961,0,0,18962,0,0,0,0,18963,18964,0,0,0,18965,0,18967,0,
+-0,0,0,0,0,0,0,0,18968,0,18969,0,18970,18973,18976,0,0,0,0,0,0,18977,0,0,0,18981,
+-0,0,0,18990,0,18998,0,0,0,0,0,18999,19003,0,0,19005,0,0,0,19006,0,0,0,0,0,0,
+-19008,19011,0,0,19018,0,0,19019,0,19024,0,19031,19032,0,19039,0,19041,19050,0,0,
+-0,19051,19055,19056,0,19059,19063,19064,0,0,19088,0,0,0,19093,19094,0,0,0,0,
+-19095,0,19096,0,0,0,19097,0,0,19098,0,19099,19100,0,0,19103,0,0,0,0,0,0,0,19111,
+-0,0,0,0,0,0,19112,0,0,0,19116,19117,0,19121,19122,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,19123,19124,0,0,0,0,0,0,0,19125,19126,0,19128,0,0,0,0,0,0,0,0,0,0,
+-19129,19130,19131,19132,0,0,19146,0,0,19147,19156,19158,0,0,0,0,0,0,0,0,19182,
+-19185,0,0,19187,0,0,0,19193,0,0,0,0,0,19194,0,19197,0,0,0,0,19198,0,0,0,0,0,0,0,
+-0,0,0,19202,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19203,0,19205,19210,
+-0,0,0,19213,0,19218,0,0,0,19223,19229,0,0,19230,0,0,19231,19232,19233,19239,0,0,
+-0,0,0,19240,0,19248,19249,0,0,0,0,19254,0,19256,19258,19259,0,0,19261,0,19266,0,
+-0,0,19272,0,19278,19281,19282,0,0,0,0,0,0,0,0,0,0,0,0,19283,0,0,19284,0,0,19285,
+-19287,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19288,19291,0,19292,0,0,0,0,19297,0,19298,0,0,
+-0,0,19302,19303,0,0,0,0,19304,19305,0,0,0,0,19314,0,0,19315,0,0,19321,0,0,0,0,0,
+-0,0,19322,0,19333,0,19334,19335,0,19336,19337,0,0,0,0,0,0,0,0,0,0,0,19346,0,0,
+-19353,0,19354,19362,0,19366,19367,0,0,19369,0,19375,0,19377,19380,19388,0,0,0,0,
+-0,19389,19390,0,0,0,0,19392,0,0,0,0,0,19402,0,0,0,0,0,0,0,0,19412,0,0,19413,
+-19422,0,19424,0,0,0,19425,0,0,0,19428,0,0,0,0,19431,0,0,0,0,0,19432,0,0,0,0,0,
+-19448,19459,0,0,19461,0,19462,19463,0,19467,19474,19482,0,0,0,0,19494,0,0,0,0,
+-19501,0,0,0,0,0,0,0,0,0,0,19502,19504,0,0,0,0,0,0,0,19505,0,0,0,0,19506,19507,0,
+-0,0,19508,0,0,19511,0,0,19514,0,19515,0,19516,0,19518,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,19530,0,19537,19538,0,19543,19546,0,19547,19551,0,0,0,0,0,0,19552,
+-19553,0,0,0,0,0,0,0,0,0,0,0,0,19555,0,0,19556,0,0,0,0,0,0,0,0,0,0,0,0,19560,
+-19561,0,0,19562,0,0,0,0,0,0,19565,19567,0,19568,0,0,0,19569,19570,0,19578,0,0,0,
+-0,19580,0,0,0,0,19581,19584,0,0,0,0,0,0,0,19585,19586,0,0,0,19587,19588,0,19589,
+-0,0,0,0,0,0,19592,19593,19599,0,19600,0,0,19604,0,0,19605,0,19606,19608,19610,0,
+-19613,19614,0,0,0,0,0,0,19616,19617,0,0,19618,0,0,19619,0,0,0,19620,19621,19631,
+-0,0,19632,19634,19636,0,19643,0,0,19644,19658,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,19659,0,0,0,0,0,0,0,0,0,0,0,19675,19677,0,0,0,0,19679,0,19683,0,19684,0,0,
+-0,0,0,0,19687,0,0,0,0,0,0,0,0,19688,19689,19692,0,0,0,0,0,0,0,19695,19697,0,0,0,
+-0,0,19698,19699,0,0,19700,0,19702,0,0,19703,0,0,0,0,0,0,19704,19708,0,19710,0,
+-19713,0,0,0,19715,0,0,0,0,19718,0,0,0,0,0,0,0,19720,0,19722,0,0,19725,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,19730,0,0,0,0,0,19731,0,19734,19735,19739,0,0,19740,0,19741,0,0,
+-0,19746,0,0,19747,0,19771,0,0,0,0,0,0,0,0,19772,19775,0,0,0,0,0,0,19778,0,0,0,0,
+-0,19779,0,0,19780,19790,0,19791,0,0,19792,0,0,0,19793,0,0,19796,19797,0,0,0,
+-19799,0,0,0,19801,0,0,0,0,19803,0,19804,0,19805,0,0,19807,0,0,0,19808,0,0,0,0,0,
+-0,19809,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,19816,0,19821,0,19822,19830,19831,0,0,
+-0,19833,0,0,0,0,0,0,0,0,0,0,19838,0,0,0,0,19839,0,0,19843,0,0,0,0,19845,0,0,0,0,
+-19847,0,0,19848,0,19849,0,0,0,0,0,0,0,19851,0,0,0,19854,0,0,0,0,0,0,0,0,0,19864,
+-0,19865,0,19866,0,0,0,0,0,0,0,19868,0,0,19870,0,0,19871,0,0,19872,19873,19875,0,
+-19880,19882,19884,0,0,19885,19886,19888,0,0,0,0,0,0,0,0,0,0,0,0,19890,19892,
+-19893,0,0,19894,0,0,0,19895,0,19896,19902,0,0,19903,0,0,19905,0,0,0,19906,0,
+-19908,0,19909,19911,0,0,0,19913,19920,0,19938,19939,19940,0,0,0,0,0,0,0,19942,0,
+-19943,0,19945,0,0,0,19951,19952,19954,19960,0,19965,0,19971,0,0,0,0,0,19975,0,
+-19976,0,19990,0,0,19991,0,19993,0,19995,0,0,0,19998,19999,20001,0,20003,20005,0,
+-20011,20012,0,0,0,0,0,0,20014,0,20020,0,0,0,0,20021,0,0,0,0,0,20023,20024,0,0,0,
+-0,0,20025,0,0,20027,0,0,20029,0,0,20032,0,0,0,0,20044,20045,0,20048,20049,0,0,
+-20050,0,20052,0,0,20054,20057,0,0,0,0,0,0,0,0,0,20059,0,0,20061,0,20062,0,20064,
+-0,0,20066,0,0,20067,0,0,0,0,20069,0,0,0,0,0,0,20070,20071,0,0,0,0,0,0,0,0,0,0,0,
+-20072,0,0,20073,20074,0,0,0,0,0,20075,0,20078,0,0,0,0,20080,0,20081,0,0,0,0,0,0,
+-20095,0,20098,0,0,0,0,0,0,0,20107,0,0,0,0,0,0,0,0,20112,0,0,0,20113,20114,0,0,0,
+-20115,20123,20124,0,0,0,20131,20133,20134,0,0,0,0,20136,0,0,20137,20138,20150,0,
+-20152,0,0,0,20153,0,0,20154,0,0,0,20158,0,20163,0,0,20164,0,0,0,0,0,0,0,20166,0,
+-20168,0,20170,0,20175,0,0,20178,0,0,0,0,20223,0,0,0,0,20224,0,20226,0,0,20230,0,
+-20231,0,0,0,0,20232,0,0,20233,20234,0,20244,0,20247,0,0,0,0,0,0,20249,0,0,0,
+-20250,0,0,0,0,20251,0,20253,0,20254,0,0,0,0,20256,0,0,20264,0,0,0,0,20266,0,0,0,
+-20278,0,0,20279,20282,0,0,0,0,0,20283,0,20284,0,20285,0,20287,20290,0,0,0,0,
+-20292,0,0,0,0,20293,20297,0,0,0,0,0,0,20299,0,20300,20303,0,0,0,0,0,0,20307,0,0,
+-20308,0,20309,0,20310,0,0,0,0,0,0,20312,0,0,0,20314,0,0,0,0,20315,20316,0,20322,
+-0,0,0,0,0,0,20339,0,0,0,20342,0,0,0,0,20352,0,0,0,0,0,0,0,0,0,0,20362,0,0,20365,
+-0,20375,20377,0,0,0,0,0,0,0,0,0,0,0,20378,20379,0,20380,0,0,20381,0,20382,0,
+-20383,0,20388,0,0,0,0,0,0,0,0,0,0,0,0,0,0,20390,20392,20393,0,0,20395,0,0,0,0,0,
+-20396,0,0,0,0,0,0,0,0,20398,20415,0,0,0,20417,0,0,20420,0,0,20426,20428,0,20431,
+-0,0,20432,0,20433,20434,20435,0,0,0,0,20440,0,0,0,0,0,20442,0,20443,0,20446,0,0,
+-0,0,20448,0,20451,0,0,0,0,0,0,0,0,0,20452,20453,0,0,20454,0,0,0,0,0,0,20457,0,
+-20458,0,0,0,20465,0,0,0,0,0,20469,0,0,0,20473,0,20476,0,0,0,0,0,0,0,0,20477,0,0,
+-20485,0,0,20486,0,0,20487,0,20496,0,20497,0,0,20498,0,0,0,0,0,0,0,0,0,0,20499,
+-20500,0,20501,0,0,0,0,0,20520,20527,0,20529,0,0,0,0,20539,0,0,20540,0,0,0,20543,
+-0,0,0,20546,0,0,0,0,0,20548,0,0,20563,0,0,20564,0,20566,0,0,0,0,0,20589,0,0,0,0,
+-20590,0,0,20593,20594,0,0,0,0,20595,0,20597,20598,0,0,0,20618,20620,0,0,0,0,
+-20621,0,0,0,0,20627,0,0,0,0,0,20628,0,0,0,20629,0,20630,0,0,20639,0,0,0,0,0,
+-20707,0,0,20709,0,0,0,20713,20714,0,0,0,0,0,20724,20725,0,0,0,0,20726,20728,
+-20729,0,20733,0,20734,0,20735,20736,0,20737,0,0,20744,0,20745,0,20748,0,0,20749,
+-0,0,0,0,0,0,0,0,20750,0,0,0,0,20754,0,0,0,20761,0,0,20763,0,0,0,0,0,0,0,20766,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,20767,0,0,0,0,20768,0,20769,20777,0,0,0,0,0,0,20785,0,
+-0,0,20786,20795,20801,0,20802,0,20807,0,0,20808,0,0,20810,0,0,20811,0,20812,0,0,
+-0,0,0,20813,0,0,20818,20820,20821,0,0,0,20822,0,20823,0,0,0,20826,0,0,0,0,0,0,0,
+-20829,20830,20831,0,20832,20836,0,0,20839,0,0,20840,20842,0,20843,0,20844,0,
+-20854,0,0,0,20855,0,0,0,0,20856,0,0,0,20869,0,0,20871,0,0,0,0,0,0,0,20873,0,0,0,
+-0,0,20876,0,0,0,0,0,20880,0,0,20882,0,0,0,0,20883,20884,0,0,20890,0,0,0,0,0,0,0,
+-0,0,20891,0,0,0,0,0,20905,0,20906,20910,0,0,20912,20915,0,0,0,0,0,20916,0,20917,
+-0,20919,20920,20922,0,20927,0,20928,20929,20930,0,0,20935,0,0,20939,0,0,20941,0,
+-0,0,20943,0,0,0,20946,20947,0,0,0,0,0,20950,0,20954,0,0,20955,20964,0,0,20967,0,
+-0,0,0,0,20973,20975,0,0,0,20984,0,20987,20988,0,0,0,0,0,20989,0,0,0,20995,0,
+-20998,0,20999,0,0,0,0,21000,21001,0,0,0,0,21008,0,21010,0,21016,0,0,0,21017,
+-21018,0,0,0,0,0,21021,21026,21027,21028,0,0,21029,0,0,0,0,0,21030,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,21031,21032,0,0,0,0,0,21037,0,0,21038,0,0,0,0,0,0,0,0,0,21039,0,
+-21041,0,21046,21047,0,0,0,21049,21053,0,0,21057,21064,21065,0,0,21066,21067,0,0,
+-0,21069,0,0,0,21071,21072,0,0,21073,0,21074,0,0,21078,0,0,0,0,21079,0,0,21080,
+-21081,0,0,21086,21087,0,21089,0,0,0,0,0,0,0,21091,0,21093,0,21094,0,0,0,0,0,0,0,
+-0,21095,0,0,0,0,0,21096,0,21098,0,0,0,0,0,0,0,21099,0,0,21100,21101,21102,0,0,0,
+-0,0,21103,0,21104,0,0,0,0,0,21105,21108,21109,0,0,21112,21113,0,0,0,0,0,0,21115,
+-21122,21123,0,0,0,0,0,21125,0,0,0,0,0,0,0,0,21129,21131,0,0,21134,0,0,0,21137,
+-21142,0,21143,0,0,21144,0,21145,21146,0,21152,21154,21155,21156,0,0,0,21160,0,0,
+-0,0,0,0,21161,0,21164,0,21166,0,0,0,0,21170,0,0,0,0,21171,0,0,21172,0,21174,0,
+-21175,0,0,0,0,0,21176,21179,21188,0,0,0,21189,0,0,21190,0,0,0,21192,0,0,21193,0,
+-0,0,21198,0,21212,0,0,21213,0,0,0,0,0,0,21215,21216,0,0,21223,21225,0,21226,0,0,
+-0,0,21227,21228,0,0,21229,0,0,0,0,21230,21236,0,0,0,0,0,0,0,0,0,0,0,0,0,21237,0,
+-0,21238,21239,0,0,0,0,21256,0,0,0,0,0,21257,0,0,0,0,0,0,0,21259,0,0,0,21263,0,
+-21272,0,21274,0,21282,0,0,0,0,0,0,0,0,21283,0,0,0,0,0,0,0,0,21294,0,0,21297,0,0,
+-0,0,21298,0,0,0,21299,0,21300,21302,0,21316,0,21318,21322,21323,0,21324,0,21326,
+-0,0,0,21327,21328,0,0,0,21352,0,0,21354,21361,0,0,0,0,0,0,0,0,0,0,0,0,0,21362,0,
+-0,0,21363,0,0,0,0,0,0,0,0,0,21366,0,0,21367,21372,21374,0,0,0,21375,21377,0,
+-21378,0,0,0,21380,0,0,0,0,0,0,0,0,0,0,21381,0,0,0,0,0,0,21382,0,21383,0,0,21384,
+-0,0,21385,0,0,0,0,21389,21390,0,0,0,0,0,0,0,0,0,0,0,0,0,21397,21398,0,0,0,0,0,0,
+-0,0,0,0,21399,0,21400,0,0,0,0,21402,0,0,0,21403,21404,0,21405,21406,0,0,0,21407,
+-0,0,0,0,0,0,0,0,0,0,0,0,21408,0,0,0,0,21409,0,21421,0,21422,0,0,0,21425,21428,0,
+-0,0,0,21429,0,0,0,0,0,21433,0,0,0,0,0,0,0,0,0,0,21434,0,21443,0,21444,21449,0,
+-21452,0,21453,21454,0,0,0,21457,0,0,21458,0,0,0,21460,21461,0,0,21464,0,0,0,
+-21473,21478,0,0,21479,0,0,21481,21483,0,0,0,0,0,0,0,0,21484,0,0,21485,21486,0,0,
+-21488,0,0,0,0,0,0,21523,0,0,21525,0,0,0,0,0,0,0,21526,0,0,0,0,0,0,21529,21530,0,
+-0,21531,0,0,21533,0,0,21539,21564,0,21567,0,0,0,0,0,0,0,0,21575,0,0,0,0,21577,0,
+-0,0,0,0,21591,0,0,21604,0,0,0,0,0,0,0,0,0,21605,0,21606,0,0,21617,21618,21619,
+-21620,0,0,0,0,0,0,0,0,0,0,0,0,0,21623,0,0,0,0,21631,0,21635,0,0,0,0,21639,21646,
+-21653,21662,0,0,21663,21664,0,21666,0,0,21667,0,21670,21672,21673,0,21674,21683,
+-0,0,0,0,0,21684,0,21694,0,0,0,0,21695,21700,0,21703,0,21704,0,0,21709,0,0,0,
+-21710,0,0,0,0,0,0,0,0,21711,0,0,0,21712,0,21717,0,21730,0,0,0,21731,21733,0,0,0,
+-0,21737,21741,21742,0,21747,0,0,0,21749,0,0,0,0,0,0,0,0,0,0,0,0,0,21750,0,0,0,0,
+-0,21752,0,0,0,0,21753,0,0,0,0,0,0,21755,21756,0,21757,0,0,0,0,0,0,21760,0,0,
+-21763,0,0,0,0,0,0,0,0,0,21764,0,0,21766,0,0,21767,0,0,0,0,0,0,0,0,0,21773,0,
+-21774,0,0,21775,0,0,0,0,21776,0,0,21777,0,0,0,0,0,0,0,0,0,21780,21787,21788,
+-21791,0,0,0,21797,0,0,0,0,0,21805,0,0,0,0,21806,0,21807,21809,0,21810,21811,0,
+-21817,21819,21820,0,21823,0,21824,0,0,21825,0,0,21826,21832,0,0,0,0,0,21833,
+-21848,21849,0,0,21867,21870,21871,21873,0,0,0,21874,0,0,0,0,0,0,0,0,0,21875,0,
+-21878,0,0,0,21879,0,21881,21886,0,0,0,0,21887,0,0,21888,21894,21895,21897,0,
+-21901,0,21904,0,0,21906,0,0,0,21909,21910,21911,0,0,21912,0,0,21913,21914,21915,
+-0,21919,0,0,0,0,0,0,0,21921,0,0,21922,21933,21939,0,0,0,0,0,0,0,0,0,0,0,21944,0,
+-0,0,0,0,21945,0,21947,0,0,0,0,0,0,0,0,0,0,21949,0,0,0,21950,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,21951,0,21952,0,0,0,0,0,0,0,0,0,21954,21957,0,0,0,0,21958,0,21959,0,0,0,0,
+-0,0,21962,21963,0,0,0,0,0,0,0,0,21964,21965,0,0,21969,21970,0,0,0,21974,0,0,
+-21980,21981,0,21982,0,0,0,0,0,21985,0,21988,0,21992,0,21999,0,0,0,0,0,0,22001,0,
+-22002,0,0,0,0,0,0,22003,0,0,0,0,0,22004,0,0,0,22008,0,22009,22015,0,0,22016,0,0,
+-0,22017,22019,0,0,0,0,0,0,0,0,0,22020,0,0,0,0,0,0,0,0,0,0,22021,22037,0,22039,0,
+-0,0,22040,0,0,0,22048,22049,0,0,22053,22055,22056,22059,0,0,22060,22061,0,0,
+-22064,0,0,0,0,22066,0,0,0,0,0,0,0,22073,0,0,0,22074,22075,0,0,0,0,0,0,0,22076,0,
+-0,0,0,22077,22084,22099,0,0,0,0,0,0,0,22104,0,0,22107,0,22108,0,22109,0,22110,0,
+-0,0,0,0,0,0,22111,22119,0,22120,22122,0,0,0,0,22125,0,0,0,22128,22129,0,0,0,0,0,
+-0,22141,0,0,0,22142,0,0,22144,22146,0,22148,22149,22151,22154,0,0,0,22162,0,0,0,
+-0,22164,22177,0,0,0,0,22179,0,22182,22183,0,0,22184,22188,0,0,0,0,0,0,0,0,22190,
+-0,22194,22201,0,0,22208,0,22209,0,22212,0,0,22215,0,22223,22231,0,0,22232,0,
+-22234,0,0,22235,22236,0,22237,0,22240,0,0,0,0,0,22241,0,0,0,22242,22246,22247,0,
+-0,0,22259,22268,0,22269,0,0,0,0,0,0,0,22270,0,0,0,0,22271,0,22272,0,22277,0,0,0,
+-0,0,22278,22280,22283,22286,0,0,22287,22289,0,0,22290,0,22293,0,0,0,0,0,0,0,0,0,
+-0,22295,0,22301,22302,0,0,0,22305,0,22308,0,0,0,0,0,0,0,0,0,0,22315,0,0,0,22317,
+-0,22334,0,0,0,22335,0,0,0,0,0,22336,0,22338,22344,0,22347,22349,0,22350,0,0,0,0,
+-0,0,0,22357,0,0,0,0,0,22358,0,0,0,0,0,0,0,0,0,0,22359,22360,0,0,0,0,0,0,0,0,
+-22361,22366,0,0,22369,0,22370,22373,0,0,0,0,0,22375,0,22377,0,0,0,0,0,22378,0,0,
+-0,0,22381,0,0,0,0,22382,0,22383,0,0,0,0,0,0,0,0,0,22391,0,0,22392,22395,22396,
+-22402,0,0,0,0,0,0,0,0,0,0,0,0,0,22405,0,0,22406,0,0,22408,0,0,22409,22410,0,0,0,
+-0,0,0,22424,0,0,0,0,22426,0,0,0,22427,0,22428,0,22432,0,22435,22442,22443,0,0,0,
+-0,22444,0,0,0,0,0,22446,0,22454,0,22455,0,0,0,22465,0,22470,0,22471,0,0,0,0,
+-22472,22473,0,22487,0,0,0,22488,0,0,0,0,22489,0,0,22499,0,0,0,0,0,0,22514,0,0,
+-22515,0,0,0,0,0,0,0,22516,0,0,0,22517,22520,0,0,0,22534,0,0,22535,0,0,22536,0,
+-22540,22553,0,22555,0,0,0,0,22561,0,0,22562,0,0,0,0,0,0,0,0,0,0,0,22566,0,0,0,0,
+-22567,22568,0,0,22575,0,22579,0,22582,22583,22585,0,0,0,0,0,22586,0,0,22587,0,0,
+-22590,0,0,0,0,0,22591,0,22592,0,0,0,0,0,22593,0,22602,0,0,22604,0,0,22609,0,0,
+-22618,0,0,0,0,0,0,22619,0,22624,22625,0,0,22638,0,0,0,0,0,22639,0,0,22640,0,0,0,
+-0,0,0,0,22644,0,22645,22647,0,0,0,0,22652,22653,0,0,0,22654,0,22655,0,0,0,22656,
+-0,0,0,0,0,0,0,0,0,0,22673,22675,22676,0,0,22678,22679,0,22691,0,0,0,0,0,0,0,
+-22693,0,0,22696,0,22699,22707,22708,0,0,0,0,0,0,0,0,22718,0,22719,0,0,0,0,22723,
+-0,0,0,22724,22725,0,0,0,0,0,0,0,0,0,0,0,0,0,0,22726,22728,0,0,0,0,0,0,0,0,22729,
+-0,0,22731,0,0,0,0,22732,22735,22736,0,0,0,0,22739,0,22749,0,0,22751,0,0,0,0,0,0,
+-0,0,0,0,0,22758,0,0,0,0,0,22760,0,0,0,0,0,22764,22765,22766,0,22768,0,0,0,0,0,
+-22769,22770,0,0,0,0,0,0,22771,0,0,22772,22775,0,22776,22777,22780,0,0,22782,
+-22784,0,22787,0,22789,22796,0,0,0,0,0,22798,0,0,0,0,0,0,22802,0,22803,22804,0,0,
+-0,0,0,0,0,0,0,0,22805,0,0,22810,22811,22814,22816,0,22825,22826,0,22831,22833,0,
+-0,0,0,0,0,0,0,0,22834,0,22836,22838,0,22839,0,0,0,0,0,22840,0,22847,0,0,0,0,0,
+-22856,22857,0,22858,22859,0,0,22862,0,0,22864,0,0,0,0,22865,0,0,0,0,0,0,0,0,0,0,
+-0,22866,0,22867,22868,0,0,0,0,22869,0,22871,0,22872,0,22873,22881,22882,22884,
+-22885,0,0,0,0,0,0,0,22886,22887,0,22894,0,22895,0,0,0,22900,0,22901,0,0,0,0,
+-22904,0,0,0,0,22905,22907,0,0,0,22915,22917,0,0,22918,0,0,0,22920,0,0,0,22929,
+-22930,0,0,0,22941,22942,0,0,0,22943,0,0,0,22944,0,0,0,0,0,0,0,22946,0,22947,0,0,
+-22954,0,22956,0,0,22962,0,0,0,0,0,0,0,22963,0,0,22964,0,0,0,0,0,0,0,22965,0,
+-22968,0,0,0,22969,0,0,0,0,0,22970,0,22971,0,0,0,0,0,22978,0,0,22979,0,22987,0,0,
+-22989,0,0,0,0,0,0,22990,0,23005,0,0,0,0,0,0,0,23006,23007,23008,0,0,23023,23024,
+-23029,0,0,0,0,23030,0,0,0,0,0,23032,0,0,0,0,0,23035,0,0,0,0,23038,0,0,0,23048,0,
+-23049,23052,23053,23060,23061,0,23063,0,0,0,0,23067,23068,0,0,0,23069,23073,0,0,
+-0,23127,0,23128,0,0,0,0,0,23129,0,23138,23141,0,23149,0,0,23150,0,0,0,23152,0,0,
+-0,0,0,0,0,0,23154,0,0,0,0,23157,23159,23160,0,0,0,0,0,0,0,0,0,0,0,0,23180,0,0,0,
+-0,23181,0,0,23188,0,23189,0,0,0,0,0,0,0,0,0,0,0,0,23195,0,0,23196,23199,0,0,0,0,
+-0,0,0,0,0,23202,0,23204,0,23207,0,23209,23210,0,0,0,0,0,0,23227,23229,0,0,23230,
+-23234,23238,0,0,0,23245,23246,23248,0,0,0,0,23249,23254,0,0,0,23265,0,0,0,0,0,0,
+-0,23268,0,23276,0,0,0,0,23277,0,23297,0,23298,0,0,0,0,23299,0,23302,0,0,23303,
+-23312,0,0,23314,0,23320,0,0,0,0,23324,0,23325,0,23328,0,23334,0,0,0,23337,0,0,0,
+-0,23343,23344,23346,0,23348,0,0,0,0,0,0,0,0,23353,0,0,0,0,23355,0,23356,23358,0,
+-0,0,23359,23360,0,23361,0,23367,0,23369,0,0,23373,0,23378,23379,0,23382,23383,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,23387,0,0,0,0,0,0,23388,23390,0,0,23393,23398,0,0,0,
+-23399,0,0,0,23400,0,0,0,0,23401,0,0,0,23415,0,0,0,0,0,0,0,0,23416,0,23422,0,
+-23443,23444,0,0,0,0,23448,0,23454,0,0,0,0,0,0,23456,0,0,23458,23464,0,0,0,0,0,0,
+-23465,0,0,0,23470,23471,0,0,23472,0,0,0,23473,23496,0,0,0,0,0,0,0,0,23497,0,
+-23499,0,0,23502,0,0,23503,0,0,23513,0,0,23515,0,0,0,23517,0,0,0,0,23518,23519,
+-23521,23524,0,23525,23528,23539,0,0,0,0,0,23541,0,0,23544,0,0,23556,0,0,23557,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,23559,0,23560,0,0,23561,0,0,23566,0,0,0,0,0,23568,23569,
+-23570,0,0,0,0,23571,0,23574,0,0,0,0,0,0,0,0,0,0,0,23575,0,23579,0,0,23581,0,0,0,
+-0,0,0,23587,0,0,0,0,0,0,0,23596,23598,0,0,0,0,23602,23606,0,0,23607,0,23608,0,0,
+-0,23614,23616,0,0,0,0,0,23618,0,0,23619,0,0,0,0,23621,23626,0,23627,0,0,0,0,0,0,
+-0,23629,0,23630,0,0,0,0,23634,0,23636,0,0,0,0,0,0,23638,0,0,0,0,23640,23667,0,
+-23669,0,0,0,23681,0,0,0,0,0,0,0,23682,0,23683,0,0,0,0,0,23684,0,0,0,23685,23689,
+-0,23693,23694,23700,0,23702,0,23709,0,0,0,0,0,0,0,23712,0,0,0,0,0,23714,0,0,
+-23715,0,0,0,0,23718,0,0,23720,0,0,0,0,23722,0,0,0,23726,23729,0,23741,23746,0,
+-23748,0,0,0,0,23749,0,0,0,0,0,23750,0,0,0,0,23751,0,23753,0,0,0,0,23757,23765,0,
+-0,0,23770,0,0,0,0,0,0,0,23771,0,23772,23781,0,0,23796,0,0,0,0,23798,0,23799,0,0,
+-0,23802,0,0,23806,0,23807,0,0,23808,0,23809,0,23819,0,0,0,23821,0,23827,0,0,0,
+-23829,0,0,0,0,0,0,0,23830,0,0,0,0,0,0,23832,23833,23834,23835,0,0,0,0,23837,
+-23838,0,0,0,0,0,23846,0,0,0,0,0,0,23847,0,0,0,0,0,23879,23881,0,0,23882,23883,
+-23895,0,23899,0,0,0,0,23901,0,0,0,0,0,0,23902,0,0,0,0,0,23903,23905,0,23906,0,
+-23907,23918,23919,23920,0,23922,0,23924,0,23927,0,23934,0,23937,23941,0,23942,
+-23946,0,0,0,0,0,23955,23956,23958,0,0,0,0,0,0,23959,0,23962,23965,0,23966,0,0,0,
+-0,23967,23968,0,0,23973,0,0,23974,0,0,0,0,23975,0,23976,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,23977,0,0,0,0,0,0,0,0,23980,0,0,23984,0,23985,0,0,23987,0,0,23988,23990,23991,
+-0,0,0,0,0,0,23992,0,0,0,0,0,0,0,0,23994,0,0,0,23998,0,0,0,0,0,0,0,0,0,23999,0,0,
+-24003,0,24004,0,24006,0,0,0,24007,0,0,24008,0,0,0,0,0,0,0,24009,0,0,24010,0,0,
+-24011,0,0,24013,24014,0,0,24015,24016,24027,0,24028,24029,0,24030,0,0,0,0,0,
+-24033,24034,0,24035,0,0,24036,0,0,24044,0,24048,24049,24063,24067,0,24068,24070,
+-0,0,24071,24078,24087,0,24090,0,0,0,24095,0,24098,24101,24104,24106,0,24107,0,0,
+-0,24108,0,0,0,0,24110,24111,0,24113,0,0,24115,24120,0,0,0,0,0,0,24124,0,24125,0,
+-24126,0,24127,0,0,0,0,0,24135,0,0,24136,0,24137,24142,0,0,0,24146,0,0,24147,
+-24149,24154,0,24163,0,0,0,24165,24166,24167,0,0,0,0,0,0,0,0,0,0,24169,24170,
+-24175,0,0,0,24178,0,0,24179,0,0,24181,0,24184,24197,0,24201,24204,0,0,0,0,0,0,
+-24206,24212,24220,0,0,0,24224,0,0,0,0,0,0,0,0,24226,0,24234,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,24235,0,24236,0,0,0,0,0,24239,24240,24241,0,0,24248,0,0,24249,0,
+-24251,0,0,0,0,0,0,24253,0,24268,0,0,0,24269,0,24271,24272,0,0,0,0,24273,0,0,
+-24274,0,0,24279,0,0,0,0,0,0,0,24280,0,24293,24294,0,0,0,0,0,0,24296,0,0,24323,0,
+-0,0,24329,24330,24331,24339,0,24351,0,0,24369,24370,0,0,0,24371,0,0,0,0,24372,
+-24373,24374,0,0,0,0,0,24378,0,0,0,0,24379,0,24381,0,24383,24389,0,24390,0,0,
+-24394,24395,24400,0,0,0,24401,24402,0,24406,0,0,0,24411,0,0,0,24415,0,24416,0,0,
+-0,0,0,24417,0,24419,0,24422,0,24423,24428,0,24435,0,0,0,24439,0,0,0,24440,24442,
+-24446,0,0,0,24447,24448,24449,24452,0,0,0,0,24453,24457,0,0,24458,24459,24460,0,
+-24465,0,0,0,0,0,0,0,24470,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24471,0,24473,
+-24474,24475,24476,0,24478,0,0,0,0,24480,0,0,0,0,0,0,0,0,0,0,24481,0,0,0,0,0,0,0,
+-0,0,0,24482,24485,0,0,0,0,24486,0,0,0,24488,0,0,0,24494,0,0,0,0,24497,0,0,24498,
+-0,0,0,24499,24506,0,0,0,24507,0,0,24511,0,0,24513,24514,0,0,0,0,0,24517,0,24518,
+-0,24520,0,24521,24524,24525,0,0,0,0,0,24527,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24528,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,24537,24539,0,24540,0,0,0,24548,0,0,0,0,0,24549,
+-24550,0,0,0,24553,24554,0,24555,0,24556,0,24558,0,0,0,0,0,24560,0,0,0,24561,0,0,
+-0,0,0,24562,0,0,0,0,0,0,0,0,0,0,0,0,0,24567,0,0,0,0,0,24569,0,0,0,24574,0,24575,
+-0,0,0,0,0,0,0,0,0,0,0,24577,24581,0,24584,0,0,0,0,0,24585,0,0,0,0,0,24586,0,0,
+-24587,0,24588,0,0,0,0,0,0,0,0,0,0,24590,24591,0,0,0,0,24592,0,0,0,0,0,0,0,24594,
+-0,0,0,0,0,0,0,24596,24597,0,0,0,0,24602,24603,0,0,0,0,24604,0,0,24605,0,24610,0,
+-0,24611,0,0,0,0,24612,24615,24616,24624,0,0,0,24627,0,24638,24639,0,0,0,0,24640,
+-0,0,0,24655,24656,24657,0,0,0,0,0,0,0,0,24662,0,24663,24664,0,0,0,0,0,24665,0,0,
+-0,0,24667,0,0,0,0,0,0,24668,24669,0,24670,24674,0,0,0,24675,0,24678,0,0,24679,0,
+-0,0,24681,0,24683,0,0,0,0,24684,0,24685,0,0,24686,0,0,24688,24689,0,0,0,0,24690,
+-24691,0,0,0,0,0,0,0,24697,0,24698,0,0,0,0,0,0,0,0,24709,0,0,0,0,0,24710,0,24712,
+-0,0,0,0,0,0,24713,24714,0,24715,0,24716,24718,0,24719,0,0,0,0,24720,0,0,24725,0,
+-0,24738,0,24749,24750,0,0,0,24752,0,0,0,24753,0,0,0,24758,0,0,0,0,0,24762,0,
+-24763,0,0,0,0,0,0,0,24764,0,0,0,0,0,24765,24767,24768,0,24772,0,0,0,0,24773,0,0,
+-0,0,24777,0,0,0,0,0,24785,0,24786,24788,0,0,0,24789,0,0,0,0,24794,24798,0,24799,
+-24800,0,0,0,24803,0,24804,24806,0,24807,0,0,0,24810,0,0,0,0,0,0,24827,24828,0,
+-24835,0,0,0,0,0,0,24836,0,0,0,0,0,24839,0,24843,24844,0,0,0,0,0,0,0,0,0,0,24847,
+-0,0,24848,0,0,0,0,0,0,24849,0,24850,24851,0,0,0,24852,0,24853,0,0,0,0,0,0,0,0,0,
+-24854,0,24855,0,0,24868,0,0,0,24883,0,0,0,24884,0,24895,24897,0,0,0,0,0,24899,0,
+-0,0,0,0,24900,0,24913,0,0,0,0,0,0,24914,0,0,24917,24930,24931,0,0,0,24932,0,0,
+-24939,0,0,24942,0,0,0,0,0,0,0,0,0,24945,24950,0,24951,0,0,24953,0,0,0,24954,0,
+-24959,0,0,0,24961,0,0,24962,0,24964,24968,24970,24972,0,0,0,0,0,24976,0,0,0,
+-24977,0,24982,0,0,24983,0,0,24984,0,0,0,24993,0,0,0,24994,0,0,25001,0,0,0,25003,
+-0,0,25018,0,0,25023,0,0,0,25034,0,0,25035,25036,0,25037,0,0,0,0,0,0,0,25039,0,0,
+-0,0,0,25040,0,0,0,0,0,0,0,25042,0,0,25043,25045,0,0,0,0,0,0,25049,0,0,25051,0,
+-25052,25053,0,0,25054,0,0,0,25055,0,0,0,0,25057,25059,0,0,25060,25064,0,25065,
+-25069,25070,0,0,0,0,25072,0,25073,0,25090,0,0,25092,25093,25101,0,0,0,0,0,0,
+-25105,25108,0,0,25113,0,0,25115,25116,0,0,0,0,0,0,25117,0,0,0,25120,25121,0,0,0,
+-0,0,0,0,25125,0,0,0,25126,0,25130,25134,0,25139,0,25143,0,0,0,25151,0,25161,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,25163,0,0,0,0,0,0,0,25174,0,25175,0,25207,0,0,
+-0,25209,0,0,0,0,25213,0,25219,0,25223,0,25225,0,0,0,25227,0,0,0,25228,0,0,0,
+-25229,0,0,0,0,0,0,0,25231,25233,0,0,0,0,25237,25239,0,0,0,25243,0,0,0,25252,0,
+-25257,25258,0,0,0,0,25260,25265,0,25268,0,0,25273,25324,0,25325,0,25326,0,0,0,0,
+-0,0,0,0,25327,0,0,0,0,0,25328,0,0,0,0,0,0,25332,0,0,0,25333,0,0,0,25336,25337,
+-25338,0,0,25343,0,25350,0,0,0,0,0,0,0,25352,0,25354,0,25375,0,25379,0,0,0,0,
+-25384,0,0,0,0,0,0,0,0,0,25386,0,25388,0,25390,0,0,25399,0,0,25401,0,0,0,25402,0,
+-0,0,25407,0,0,0,0,0,0,0,0,0,0,0,25413,25415,0,0,25417,0,0,0,0,0,0,0,25419,0,0,0,
+-25421,0,0,0,25424,0,0,0,0,25433,0,0,0,0,0,0,0,0,0,25435,0,0,0,0,0,0,25436,0,0,0,
+-25437,0,0,25440,0,0,0,0,0,0,25442,0,0,25443,0,25446,0,0,25449,0,0,0,25450,0,0,0,
+-0,25452,0,25453,25454,25455,0,0,0,25456,0,25457,0,0,0,25459,0,25461,0,25468,0,0,
+-0,0,0,0,0,0,25469,0,0,0,0,0,25471,0,0,0,0,0,25474,0,0,0,0,0,0,0,0,25475,0,0,0,0,
+-25477,0,0,0,0,25483,0,0,0,0,0,25484,0,0,0,0,0,0,0,0,0,0,0,0,25485,0,25497,0,0,
+-25498,0,25504,0,25510,0,25512,0,0,25513,25514,0,0,0,0,0,0,25517,25518,25519,0,
+-25520,0,0,0,0,0,0,0,25521,0,25522,25527,25534,0,25536,0,25537,0,0,25548,25550,0,
+-0,25551,0,25552,0,0,0,0,0,25554,0,25555,0,25556,25557,25568,0,0,0,25570,25571,0,
+-0,0,0,0,0,25574,0,0,0,0,25579,0,0,0,25581,0,0,0,25582,0,0,0,0,0,0,0,0,0,25588,0,
+-0,0,0,25589,0,0,0,0,25590,0,25591,25592,25593,0,25594,0,0,0,25596,0,25597,25615,
+-0,0,0,0,0,25618,0,0,0,0,25619,25623,0,0,25629,0,0,25631,0,0,0,25635,25636,0,0,
+-25649,0,0,0,0,25654,0,0,0,25661,25663,0,0,25671,0,0,25678,25698,0,25699,25702,
+-25703,0,0,0,0,0,0,0,0,25704,0,0,0,0,0,25706,0,0,25710,0,25711,0,25712,0,25715,
+-25716,25717,0,0,25718,25728,25732,0,0,0,25734,0,0,0,0,0,0,0,0,0,25737,0,0,25739,
+-0,0,0,25740,0,25741,25745,0,25746,0,25748,25772,25778,0,0,0,0,0,25780,0,0,0,0,
+-25781,0,25782,25784,25785,0,0,0,25789,0,0,0,0,0,0,25797,25801,0,0,0,25808,25809,
+-0,0,25811,25814,25815,0,0,25817,0,0,0,0,0,0,0,0,25820,0,0,0,0,25832,25833,0,0,0,
+-25846,0,0,0,25847,25848,0,0,0,0,0,0,0,0,0,25849,25850,0,0,25851,0,0,25852,0,
+-25862,0,0,0,25863,25865,0,0,0,0,0,0,0,25867,25868,0,25869,25874,0,25875,0,25876,
+-25877,0,0,0,0,25878,25902,0,0,0,0,0,0,0,25903,25904,25905,0,0,0,25908,25909,0,0,
+-0,0,25910,0,0,0,0,0,0,0,25912,0,25913,0,0,0,0,0,0,0,0,25914,0,0,25916,0,0,0,0,0,
+-25917,25927,0,0,0,0,25928,0,0,25930,0,0,0,25933,0,0,25938,25942,0,0,0,0,0,0,0,
+-25945,0,25950,0,25956,0,0,25961,25962,0,0,25963,0,25964,25965,25966,0,0,0,0,0,
+-25967,0,0,0,0,25968,0,0,0,25969,25971,0,0,0,0,0,25973,25975,0,0,0,0,0,0,0,25978,
+-0,25981,0,0,0,25982,0,0,0,25984,0,0,0,0,0,0,0,25993,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-26002,0,0,0,26005,0,0,0,26006,26007,0,0,26014,26015,26016,0,0,0,0,0,0,26017,
+-26018,26020,0,26022,26023,0,0,0,26024,26028,0,26029,26033,26034,26044,0,0,0,0,0,
+-26046,0,0,26047,0,0,26049,0,26050,0,26051,0,0,0,0,0,26053,0,0,0,0,26054,26059,0,
+-0,0,0,0,0,26060,0,26066,0,0,0,0,0,0,0,0,0,0,0,0,26067,0,26069,0,0,26071,0,0,0,
+-26073,0,26074,26077,0,0,0,0,26078,0,0,0,26079,0,26090,0,0,26094,0,0,0,0,0,0,0,0,
+-26095,0,0,0,0,0,0,0,0,0,0,0,26096,26101,0,26107,26122,0,26124,0,0,26125,0,0,0,0,
+-0,0,26136,26141,26155,0,0,0,0,0,0,0,0,0,26164,26166,0,0,0,26167,0,26170,26171,0,
+-0,26172,0,0,26174,0,0,0,0,0,0,0,0,0,0,0,0,0,26175,0,0,0,26176,26177,0,26321,
+-26322,0,26323,0,0,26324,0,0,0,0,0,0,0,26325,0,26331,0,0,0,0,0,0,26335,0,0,0,
+-26350,0,0,0,26379,0,0,26382,26383,26385,0,0,26392,26406,0,0,0,0,26411,0,0,0,0,0,
+-26412,0,0,26420,0,0,26423,0,26424,26426,26432,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-26435,0,26436,0,0,0,0,0,26441,0,26444,0,0,0,26446,0,0,0,0,26447,0,0,0,0,26449,0,
+-26450,26452,0,26453,26454,0,0,0,26455,0,0,0,26456,0,0,26458,0,0,26460,0,26463,0,
+-0,0,0,0,0,0,0,26464,26470,0,0,0,0,0,0,0,0,0,26473,0,0,26474,0,0,0,0,0,0,0,26475,
+-0,0,0,0,0,0,0,26477,0,26485,0,0,26486,0,26487,0,0,26488,26493,26494,0,0,26495,0,
+-26497,26504,26506,0,0,0,0,0,26507,0,0,0,0,0,26509,0,0,26510,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,26512,0,26513,26515,0,0,0,26518,0,0,0,26519,0,26524,26526,0,0,0,26527,0,
+-26532,0,26533,26537,26558,0,0,0,26559,0,0,0,26571,0,0,26573,0,26588,0,26593,0,0,
+-0,0,0,0,26603,0,26604,0,0,0,0,0,0,0,0,0,0,26606,0,0,0,0,0,0,0,26607,26609,26611,
+-26614,0,0,0,26616,26620,0,26621,0,0,0,0,0,26627,0,26629,0,0,26630,0,0,26632,
+-26643,0,0,0,26644,0,0,0,0,0,0,0,0,0,26646,26647,0,0,0,26650,0,0,26656,0,0,0,0,
+-26663,26670,26671,0,0,0,26685,26686,26687,0,26689,0,0,0,0,26744,0,26745,0,26747,
+-26748,0,26749,26750,26751,0,0,0,0,26752,26755,0,0,0,26756,26769,0,0,0,26774,0,0,
+-0,0,0,26775,0,26777,26778,0,26786,0,0,0,26787,0,0,0,0,0,0,0,0,0,0,0,0,0,26788,0,
+-0,26789,0,0,0,0,0,26791,0,26792,26793,0,0,0,26794,0,26797,26798,0,0,0,26800,0,0,
+-26803,0,26804,0,0,0,0,0,0,0,0,0,26805,0,0,26808,0,0,26809,0,0,0,0,0,0,0,26812,0,
+-26825,0,0,0,0,0,0,0,26826,0,0,26827,26829,26834,0,0,0,0,26835,0,0,26849,0,26851,
+-0,0,0,0,0,0,0,0,0,26852,0,26853,26857,0,26858,0,26859,0,0,0,0,0,0,0,26876,0,
+-26878,26882,26883,0,0,0,0,26890,26894,0,0,0,0,26895,26896,0,0,0,0,0,26900,0,0,0,
+-0,0,0,0,26911,26913,26914,26915,26916,26919,0,0,0,26921,26922,0,0,26925,0,0,0,
+-26928,0,0,26929,26930,0,0,0,26931,0,26932,0,0,0,0,0,26933,0,0,0,0,0,0,26937,0,0,
+-26943,0,0,26944,0,0,0,26946,0,0,0,0,0,0,0,26956,0,26958,0,0,26963,0,0,0,0,0,0,0,
+-26965,0,26969,26970,26972,0,0,0,0,0,26973,0,26974,0,26978,0,26980,0,0,0,0,0,0,
+-26982,0,26986,26987,0,26990,0,0,0,0,27003,27006,0,0,27007,27010,27012,27013,0,0,
+-0,0,0,0,0,0,27014,27015,27018,0,27019,0,0,0,0,0,27025,0,0,0,27026,0,0,0,0,27029,
+-27030,27031,27034,0,0,27036,27037,0,0,0,27038,27042,0,0,0,27044,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,27045,0,0,0,0,0,0,0,27046,0,0,0,0,0,0,0,27047,27049,0,27050,0,0,0,
+-27051,27052,0,27055,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,27056,27058,27059,0,
+-27061,0,27064,0,0,0,0,0,27069,0,0,27070,0,0,0,0,0,0,0,27072,0,0,0,0,0,0,0,0,
+-27076,0,0,0,0,0,27078,0,27079,0,0,0,27081,0,0,0,0,0,0,27082,0,27083,27086,0,0,0,
+-0,27087,0,0,0,0,0,27088,27090,0,27094,0,0,27095,0,27099,27102,0,0,0,27103,0,0,0,
+-0,27105,0,0,0,27106,0,0,0,0,0,0,27107,0,0,0,0,27108,27117,0,0,0,0,27118,0,0,
+-27124,0,27126,0,0,27130,27131,0,0,0,0,0,0,27147,0,0,0,0,27148,27149,0,0,0,0,
+-27150,27151,0,27152,0,27159,0,0,0,27164,0,0,0,0,0,0,0,27175,0,27189,0,0,27191,0,
+-27193,0,27195,0,27198,0,0,0,0,0,27200,0,0,0,0,27202,0,0,0,0,27203,0,0,27204,0,0,
+-27206,0,27207,0,0,0,0,27209,0,0,0,27213,0,0,27216,27219,27220,27222,27223,0,
+-27224,0,27225,27226,0,0,27233,0,0,0,0,27235,0,27237,0,27238,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,27239,0,27242,27243,0,27250,0,0,0,27251,0,27253,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,27254,27255,27258,0,0,0,27259,0,0,0,0,0,0,27267,0,27276,27278,
+-0,0,0,0,0,0,0,0,0,27296,27297,27301,0,0,0,0,0,0,27302,0,0,0,0,0,0,27312,27313,0,
+-0,0,0,0,27318,0,27320,0,27329,0,27330,27331,0,27332,0,0,0,0,27340,0,0,0,27348,0,
+-0,0,0,0,0,27350,0,27351,0,0,0,0,27355,0,0,27358,27359,27361,0,0,0,27365,0,27367,
+-0,27376,27378,0,0,27379,0,0,0,0,0,0,27396,0,27397,27404,0,0,0,0,0,27408,0,0,0,0,
+-27453,0,0,0,27456,0,0,0,27458,0,0,0,0,0,0,0,27459,0,0,0,27460,0,0,27461,0,27465,
+-27467,0,0,27469,0,27470,0,27471,0,27477,27482,0,0,0,0,0,0,27484,0,0,0,0,0,0,
+-27485,0,0,0,0,0,27493,0,27494,27502,0,0,0,0,0,0,0,0,0,0,0,0,27511,27532,0,0,0,
+-27533,27545,0,0,0,27546,0,0,0,0,0,0,0,0,0,0,27547,0,0,27549,27550,0,27551,0,0,0,
+-0,0,0,0,27555,0,0,27571,0,27573,27574,27575,27577,0,27578,0,0,27579,27585,0,0,0,
+-0,0,27586,0,0,27588,27589,0,0,0,0,27596,0,0,27600,0,0,0,0,0,0,0,0,0,0,0,27608,0,
+-0,0,0,0,0,0,0,0,0,0,27610,0,0,0,27618,0,0,27620,0,0,0,27631,0,0,27632,27634,0,
+-27636,27638,0,0,0,27643,0,27644,27649,0,0,0,0,0,0,0,0,0,0,0,0,0,27651,27660,0,
+-27661,0,0,0,0,0,0,0,27662,0,0,27664,0,27665,0,0,0,27669,0,27671,0,0,0,27673,
+-27674,0,0,0,27682,0,0,0,27711,0,27712,27713,27719,27720,0,0,27728,0,27729,0,0,0,
+-0,0,0,0,0,0,27731,0,0,27732,0,27733,0,27738,0,0,0,27742,0,0,0,27743,27744,0,0,0,
+-0,0,0,27745,27746,0,0,0,27747,27748,27751,27752,0,0,0,27768,27770,0,0,0,27774,
+-27775,0,27776,27777,0,0,27781,0,27784,0,27786,0,0,27791,0,27792,27793,27804,0,
+-27812,27813,0,0,0,0,0,0,0,0,27814,0,27825,0,27827,0,0,0,0,27828,27861,27862,0,0,
+-0,27864,0,0,0,27865,27884,0,27889,0,0,0,0,0,27890,0,27891,0,0,0,27892,0,0,0,0,0,
+-27897,27898,0,0,27899,0,0,0,27901,27905,0,0,27920,0,0,27921,0,27922,0,0,0,27931,
+-27934,0,0,0,0,0,0,0,0,0,0,27941,0,27942,0,27945,0,27947,27954,0,0,0,0,27960,
+-27963,0,0,0,0,0,0,0,0,27964,27965,0,0,0,27967,0,27969,27975,0,27976,27977,0,
+-27981,0,27983,28051,28052,0,0,0,0,0,28056,0,0,0,0,0,0,28058,28059,0,0,28061,0,0,
+-0,0,0,0,0,28063,0,0,0,0,0,0,28066,0,0,0,0,0,0,28069,28070,28072,0,28073,0,0,
+-28074,0,0,0,0,28075,0,0,0,0,0,0,0,28078,0,0,0,0,28085,0,0,0,0,28086,0,0,0,0,0,0,
+-28088,0,0,0,0,0,0,0,0,28090,0,28097,28114,28115,0,0,0,0,0,0,0,28116,0,0,0,0,0,
+-28118,0,28129,0,28131,0,0,28135,0,0,0,28140,28141,0,0,0,28146,0,0,0,0,28152,0,0,
+-0,0,28155,28157,28161,0,0,0,0,28166,0,28167,0,0,0,0,0,0,0,0,0,0,0,28172,0,0,0,0,
+-0,0,28173,0,0,28175,0,0,0,0,0,0,0,0,0,28178,28188,0,28190,0,0,0,0,0,28191,0,
+-28193,28206,0,0,28207,28209,0,28211,0,28213,0,0,0,28215,28216,28217,0,28222,0,
+-28223,28225,0,0,0,28226,0,28227,28229,28232,0,0,0,0,0,0,0,0,0,28235,0,28241,0,0,
+-28242,0,0,0,0,28243,0,0,0,28245,0,0,0,28248,28250,0,28251,28252,0,0,0,0,0,0,
+-28253,0,0,28254,28255,0,0,28256,0,0,28258,0,0,0,0,0,28259,0,0,28260,0,0,28261,0,
+-0,0,0,28262,28263,0,0,28264,0,0,0,28266,0,28268,28269,0,28270,28272,28274,0,
+-28277,28278,0,0,0,28279,0,28280,28281,28283,0,28292,0,28294,0,28297,0,0,0,0,
+-28299,0,0,0,0,0,28300,0,0,0,0,0,0,0,28301,0,0,0,0,0,0,0,0,0,0,0,0,0,28302,28303,
+-0,0,0,0,28304,0,0,28305,0,28312,0,28313,28314,0,0,0,0,0,0,28315,0,0,0,28320,
+-28321,0,0,28328,0,0,0,28329,28338,0,28339,0,0,28344,0,0,0,0,0,0,0,0,28347,0,0,0,
+-0,0,0,0,0,28348,0,0,0,0,0,28411,0,28412,28413,0,28416,0,0,0,28420,0,0,0,0,0,
+-28421,0,0,0,0,28423,0,0,0,28424,0,0,28428,0,0,0,0,0,28429,0,0,0,28431,28434,0,
+-28458,0,0,0,0,0,0,0,0,0,0,0,28464,0,0,0,0,28465,0,28467,0,0,0,0,0,0,28471,0,0,0,
+-0,28474,0,28480,0,28481,0,0,28485,0,0,0,0,28486,28488,0,0,28489,0,0,0,0,28492,0,
+-0,0,28495,0,28497,0,28499,0,0,0,0,28500,0,0,28502,28503,0,0,0,28508,0,0,0,28510,
+-0,0,28512,28513,28514,28521,0,28526,0,28527,28528,0,0,0,0,28529,0,0,28532,0,0,
+-28537,28538,0,0,0,28539,0,28548,0,28553,28554,0,0,0,0,0,0,0,0,0,0,0,0,28560,
+-28563,0,0,28564,0,0,0,0,28565,0,0,0,0,0,0,0,28566,28568,0,0,0,0,0,0,28569,0,0,0,
+-28570,0,28572,28573,0,0,0,0,28575,0,0,0,0,28576,28581,28588,0,0,28589,0,0,0,
+-28590,28595,0,28598,0,0,28601,0,0,28605,0,0,0,0,28614,28615,28619,0,0,0,0,0,0,
+-28620,0,28626,0,0,28628,0,28631,0,28632,0,0,0,0,0,0,28635,0,0,0,28637,28638,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,28639,0,28643,0,0,28652,0,0,0,28662,0,
+-28670,28671,0,0,0,0,0,0,0,0,0,28672,28673,28675,28676,0,0,0,0,0,0,0,28691,0,0,0,
+-28695,0,0,0,28696,0,28697,28698,0,28705,0,28707,28708,28710,0,0,0,0,0,0,0,28711,
+-28728,0,0,0,28736,0,0,0,28737,0,0,0,0,0,0,0,0,0,28738,0,28739,0,28741,0,0,28742,
+-0,0,0,0,0,0,0,0,0,0,0,28745,0,0,0,0,0,0,28749,28750,28752,28754,28756,0,28757,0,
+-0,0,0,28759,28760,0,0,0,0,0,0,28762,0,0,0,28764,0,0,0,0,0,0,28766,0,28767,28768,
+-0,0,0,0,28769,28770,0,0,0,0,0,0,0,0,0,0,0,0,0,28771,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+-0,28772,0,28773,0,28782,0,0,0,0,0,0,28784,0,28785,0,28786,0,0,0,28787,0,0,0,
+-28797,0,0,0,0,0,0,28799,0,0,28801,0,0,0,0,28802,0,28805,0,0,28806,0,0,28807,0,0,
+-0,0,0,0,0,28808,0,0,0,0,0,28810,28812,0,0,28816,28819,0,0,28821,0,28826,0,0,0,
+-28842,28852,0,0,28853,0,28854,28855,0,0,0,28857,0,0,0,28858,0,28867,28868,28869,
+-0,0,0,28874,28880,28882,28890,28892,0,0,0,0,0,0,0,28895,0,0,0,28898,28899,0,0,0,
+-28900,0,0,28904,0,28906,0,0,0,0,28907,0,0,0,0,0,0,28908,0,0,0,28910,0,28914,0,0,
+-0,0,0,0,0,28915,28916,28919,0,0,28920,0,28921,0,0,0,0,0,0,0,0,28924,0,0,0,0,
+-28926,28929,0,0,0,28930,0,28936,0,28939,0,0,0,0,28942,0,0,0,0,0,0,28956,0,0,0,
+-28966,0,0,0,0,28967,0,0,0,0,0,0,0,0,0,28968,0,28971,0,28975,28976,0,28982,28983,
+-0,0,28984,28989,28996,28997,28998,0,0,0,0,0,0,28999,0,0,0,0,0,29000,0,29001,0,0,
+-0,29009,0,0,29011,0,0,29021,0,0,0,0,29024,0,29025,0,0,0,0,0,29026,0,0,0,29036,0,
+-0,0,29037,0,0,0,0,29038,0,29045,0,29047,0,0,0,0,0,0,0,0,0,29051,0,0,0,29054,
+-29056,29062,0,29070,29082,0,0,0,29083,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29084,0,0,
+-0,0,29085,29088,0,0,0,0,0,0,0,29090,29097,0,0,0,29103,0,0,0,0,0,0,0,0,29105,0,0,
+-0,0,0,29107,0,29109,0,0,0,29115,0,0,29120,0,0,29138,29140,0,0,0,0,0,0,0,0,0,
+-29152,0,29160,29174,0,29176,0,0,29180,0,29181,0,0,0,0,0,0,0,0,29228,0,0,29229,0,
+-0,29230,0,0,0,0,0,0,0,0,0,0,29234,0,0,0,29241,0,29245,0,29248,0,29250,29256,
+-29280,0,29282,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29285,0,0,29286,29291,29292,0,0,0,0,
+-29294,0,29295,0,0,0,0,0,29296,29297,29298,29300,0,29302,0,0,29304,29307,0,29312,
+-0,0,0,29322,0,0,29323,0,0,29324,29326,29328,0,29335,0,0,0,0,0,0,0,29338,29339,0,
+-0,0,0,0,29341,29343,0,0,0,0,29344,0,0,0,0,0,29345,0,0,0,0,29346,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,29347,29348,29349,0,0,29354,0,0,29355,0,0,0,0,0,0,0,0,29357,0,0,
+-0,0,29364,0,29365,0,0,0,0,0,0,0,29366,0,0,29368,0,0,0,0,0,0,0,0,29378,0,29381,0,
+-0,0,0,0,0,0,0,29386,0,0,0,0,0,0,29389,0,0,0,29390,0,0,29391,29397,0,29398,29412,
+-29414,29418,29419,0,0,0,0,0,0,0,29420,0,0,0,0,0,0,0,29423,0,0,0,29435,0,0,0,
+-29437,0,0,29439,0,29441,0,0,0,0,29443,0,29446,29450,29452,0,0,0,0,0,29456,0,0,0,
+-0,0,29461,0,0,0,29464,0,0,0,0,0,0,0,0,29468,0,29473,0,0,0,29486,0,0,0,29490,0,0,
+-0,29491,29492,0,0,29497,0,0,0,29498,0,29499,0,29502,29505,0,29509,0,0,0,29510,0,
+-0,0,29512,0,0,0,29516,0,0,0,0,0,0,0,0,29518,0,29519,0,0,0,0,0,29520,29521,29529,
+-0,0,0,0,0,0,0,0,29530,0,0,29531,29538,0,29540,0,0,0,29542,0,29543,29544,29547,0,
+-0,29548,0,0,0,29549,0,0,0,29550,0,0,29552,0,0,0,0,29558,29561,0,29562,29564,0,0,
+-29565,0,0,29566,0,0,0,0,0,0,0,0,0,0,29578,29584,29586,29591,0,0,0,0,29593,29594,
+-0,0,29597,0,0,29613,0,29614,0,29615,0,0,0,0,29616,29617,0,0,29625,0,0,0,29632,0,
+-0,0,0,0,0,0,29633,0,0,0,0,0,29634,29635,29637,0,29638,0,29641,29643,0,0,0,0,0,0,
+-29644,0,29645,0,29649,0,0,0,29650,0,29653,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29656,
+-29659,0,0,29660,0,0,0,29661,0,0,0,0,0,29664,0,0,0,29671,29673,0,0,0,0,0,0,0,
+-29675,0,29677,29679,0,0,29684,0,0,0,0,0,29685,0,0,0,29687,0,0,0,29688,0,29689,
+-29690,29700,0,29701,0,0,0,29702,0,29706,0,0,0,0,0,0,0,29720,0,29721,0,29727,0,
+-29733,29734,0,29750,29761,0,29763,0,0,0,0,0,29764,0,0,29765,0,0,0,29771,0,0,0,0,
+-0,0,0,0,0,0,0,0,29772,0,0,0,29773,29774,29775,0,0,0,0,0,0,0,0,0,0,0,29822,0,0,0,
+-29824,0,29825,0,0,0,0,0,29827,0,0,0,0,0,0,0,0,29829,0,29832,29834,0,0,29835,0,0,
+-29837,29838,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,29843,0,0,0,0,29844,29845,0,0,0,
+-0,0,0,0,0,0,29849,0,0,29869,29872,29890,29905,0,0,0,0,0,29907,29921,0,29922,0,0,
+-29923,29926,29944,29946,0,0,0,0,0,0,0,29947,29948,0,0,0,29951,0,0,0,0,0,29953,0,
+-0,29956,0,29957,0,0,29962,0,0,0,0,29971,0,0,0,29972,0,0,0,0,0,29978,0,29979,
+-29992,30007,30008,30010,0,0,0,30013,0,0,0,0,30014,30016,0,0,0,0,0,0,0,0,0,0,0,
+-30017,0,0,0,0,0,30023,30031,0,0,30033,0,0,0,0,0,0,0,0,0,0,30034,0,30038,0,30039,
+-0,30040,0,0,0,0,0,0,30067,30068,0,0,0,30069,0,30072,0,0,0,30073,0,0,0,0,30075,0,
+-0,0,0,0,0,30079,0,0,30080,0,0,0,0,0,30082,0,0,0,0,0,0,0,0,0,0,0,30084,30090,0,0,
+-30091,0,0,0,0,30098,30118,0,30119,0,30121,30130,0,0,0,0,0,0,0,0,0,0,0,0,0,30131,
+-30132,30133,0,0,0,0,0,0,30135,0,0,0,0,0,0,0,0,0,0,0,30136,0,0,30137,30138,0,0,0,
+-30139,30146,0,0,0,0,0,30147,0,0,30148,30151,0,0,0,30168,0,30172,30173,0,0,0,0,0,
+-0,0,0,30180,30181,0,30192,0,0,0,0,0,0,0,30194,30196,0,0,30199,0,0,30202,0,0,0,0,
+-30203,0,0,0,0,0,0,0,0,0,0,30213,0,0,0,30216,0,0,30217,0,0,0,30218,0,0,0,0,30219,
+-0,30220,0,30222,30227,0,0,0,0,0,30231,0,0,30233,30235,0,0,0,0,30238,0,30240,
+-30243,30245,0,30250,30252,0,0,0,30269,0,0,30271,30272,0,0,0,30278,30280,0,0,
+-30282,0,30284,0,30294,0,0,0,0,30295,30296,0,0,0,0,0,30298,30299,30302,30304,
+-30306,0,0,0,0,0,0,30316,30317,0,0,0,30318,0,0,0,30319,0,30320,30322,30326,0,0,0,
+-0,0,30327,0,30332,30348,30349,0,0,30356,0,0,0,0,0,0,0,0,30357,0,30358,0,30359,
+-30360,0,0,30365,30366,30378,0,0,0,0,30379,0,0,30381,0,30385,0,30388,30397,0,0,0,
+-30401,0,0,0,0,30403,0,0,0,0,0,30404,0,0,30405,0,30406,30408,0,30409,0,30410,0,0,
+-0,30417,0,0,30418,30419,0,30420,0,30424,0,0,0,30427,30430,30432,0,0,0,0,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,0,30433,0,0,0,0,0,0,0,30436,0,30437,30438,0,30441,30442,0,0,
+-0,30445,0,0,0,0,30452,30456,30457,0,0,0,30458,0,30464,0,0,0,0,0,0,30467,0,30469,
+-0,0,0,0,0,30477,0,0,30484,0,0,0,0,0,30485,0,0,0,0,0,30486,30487,30497,30498,0,0,
+-0,0,0,0,0,0,0,0,30505,0,30508,0,0,0,30509,30510,0,30514,30516,0,0,0,0,0,0,0,0,0,
+-0,0,30523,0,30524,0,30525,0,0,0,0,30537,0,0,30538,0,0,0,0,0,30553,0,0,30555,
+-30556,30558,30559,30560,0,0,30561,0,30562,0,0,0,0,0,0,0,0,30563,30570,30571,0,
+-30586,30587,0,0,30590,0,0,30594,0,0,0,0,30611,30612,30623,30634,0,0,30636,30640,
+-30655,30656,0,30657,0,0,30658,30669,0,30670,0,30676,30678,0,0,0,0,0,0,0,30679,0,
+-0,0,0,0,0,0,0,0,0,0,30695,0,0,30698,0,0,0,0,30700,0,0,0,0,30701,0,30702,30703,0,
+-0,0,0,30707,0,0,0,30709,0,0,30710,30719,30729,0,0,0,0,0,0,0,0,0,30731,0,0,30733,
+-0,0,0,30734,0,0,0,0,0,30736,30737,0,0,0,30740,0,0,0,30743,0,30746,0,30747,30748,
+-0,0,30751,30752,30753,0,0,0,30754,0,0,30760,0,0,0,0,0,0,0,30763,0,30764,0,0,
+-30766,0,30769,30770,30771,30774,30777,0,0,30779,30780,30781,0,0,0,0,30790,0,0,0,
+-30792,0,0,0,0,30810,0,0,0,0,0,0,0,30812,30819,0,0,30823,30824,0,30825,0,30827,0,
+-0,0,0,0,0,30828,0,0,30830,0,0,0,30834,0,30835,0,30837,30838,0,30845,0,0,0,0,0,
+-30846,30847,0,0,30849,0,30851,0,0,0,0,0,30852,30858,0,0,30859,0,30865,0,0,30866,
+-0,0,30868,0,0,30869,0,0,0,30881,30883,0,0,0,0,0,30889,0,30891,0,0,0,0,30894,0,
+-30895,0,30897,0,30898,0,0,0,30904,30906,0,30909,0,0,0,0,0,0,30910,0,0,0,30915,
+-30933,30942,0,0,0,0,30943,0,0,30945,0,0,0,0,0,0,30946,0,0,30947,0,0,30955,30956,
+-0,0,30960,0,0,30961,30962,30966,0,0,30969,30974,0,0,0,30976,0,0,30977,0,30978,
+-30982,0,0,0,0,0,0,0,30994,30995,30998,0,31000,0,0,31001,0,0,31003,31005,0,0,
+-31006,31011,0,0,31014,0,31016,0,0,0,0,31018,0,0,31020,31023,31024,31025,0,0,0,0,
+-0,0,0,0,0,0,0,0,0,0,31027,31028,31029,0,0,0,0,0,0,31032,0,0,0,0,0,0,0,0,0,0,0,
+-31036,31037,31038,0,0,0,31041,31043,31045,0,31047,0,0,0,31048,0,31049,0,0,0,
+-31053,31054,31055,0,0,31063,0,0,0,0,0,31066,0,31068,31071,0,0,0,31072,31073,0,0,
+-0,0,31075,0,0,31076,0,0,0,31077,31079,0,31080,0,0,0,0,0,0,0,0,0,0,31087,0,31142,
+-0,31144,0,0,31145,31146,31147,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31149,0,31151,31152,0,
+-0,0,0,0,0,0,31162,31171,31174,31175,0,0,0,31176,0,0,0,0,0,0,0,31179,0,0,0,31186,
+-0,0,0,31192,31195,0,0,31196,0,0,0,0,0,0,0,0,31198,0,0,0,0,0,31199,0,0,0,31205,0,
+-0,0,0,31211,31215,0,0,0,0,31231,0,31232,0,0,0,0,0,0,0,0,0,0,31233,31236,31253,0,
+-31254,0,0,0,0,0,0,31255,0,0,31257,0,0,0,0,0,0,0,0,0,31258,31259,0,0,31260,0,
+-31261,0,0,0,0,0,31262,31263,0,0,31264,0,31266,0,31267,0,0,0,0,0,31281,0,31282,0,
+-31284,0,0,31285,31287,31288,0,0,31290,0,0,0,31292,31295,0,31299,0,31300,0,0,0,0,
+-0,31302,0,0,0,0,31303,0,0,0,0,0,0,31304,0,0,0,0,0,31305,31308,31309,31315,0,
+-31317,0,0,0,0,0,31323,0,31324,0,0,0,0,0,31325,31327,0,0,31331,0,0,0,0,0,31333,0,
+-0,0,0,0,31336,0,0,31337,0,0,0,0,0,0,31338,0,0,0,0,0,0,0,0,0,0,0,0,31339,0,0,0,0,
+-0,0,0,31342,0,0,0,0,31345,0,0,0,0,0,0,0,0,31347,0,0,0,0,0,0,31348,0,0,31350,
+-31351,0,31352,0,0,31354,0,0,0,0,31355,0,0,31356,0,0,0,0,0,0,0,0,0,0,31363,0,
+-31372,0,0,31373,0,0,0,0,0,0,0,0,0,31376,0,31388,0,31389,0,31392,0,31401,0,31405,
+-31407,31408,0,31409,0,0,0,0,0,0,31413,31415,0,0,0,31416,31418,0,0,0,0,0,0,31422,
+-31423,0,0,31424,0,31425,31432,0,0,0,0,0,0,0,0,0,31433,0,0,0,0,0,0,0,0,31434,0,0,
+-0,0,0,0,31435,0,0,0,0,31438,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,31442,0,31444,0,
+-31448,0,0,31451,0,0,0,0,31452,0,31461,31465,0,0,31466,0,0,31467,0,0,31468,0,0,0,
+-31469,31473,0,31476,0,0,0,0,31489,31490,0,0,0,0,0,0,0,31492,31493,31494,0,0,0,0,
+-31501,31504,31505,0,0,0,0,0,0,0,0,0,31509,0,0,0,0,31510,0,0,31511,0,0,31513,0,0,
+-0,0,0,0,0,0,0,31514,0,31522,31536,31539,31540,0,31541,0,0,0,0,0,0,31546,31553,
+-31559,0,0,0,31560,31561,31562,0,0,31564,31567,0,31569,0,0,0,31570,0,0,0,0,31571,
+-0,0,0,0,0,0,31572,31574,31580,31581,0,0,31582,31584,31585,31586,31595,0,31596,0,
+-0,0,0,31597,0,31599,0,31600,31601,0,0,31603,31604,0,0,31608,31610,0,0,0,31611,0,
+-31615,0,0,0,0,31616,0,0,0,0,0,0,31617,0,0,0,0,0,31618,0,0,0,0,0,0,31621,0,0,0,0,
+-0,0,0,0,0,31622,31625,0,0,0,0,31627,0,31641,0,0,31642,0,0,31643,0,0,0,0,0,0,0,0,
+-0,31644,0,31646,0,0,0,0,31648,0,0,0,31652,0,0,0,31657,0,0,31676,0,0,0,0,0,0,0,
+-31689,31691,31692,0,31694,0,0,0,31696,0,31702,0,31703,0};
+-
+-static const DictWord kStaticDictionaryWords[31705] = {
+-{0,0,0},{8,0,1002},{136,0,1015},{4,0,683},{4,10,325},{138,10,125},{7,11,572},{9,
+-11,592},{11,11,680},{11,11,842},{11,11,924},{12,11,356},{12,11,550},{13,11,317},
+-{13,11,370},{13,11,469},{13,11,471},{14,11,397},{18,11,69},{146,11,145},{134,0,
+-1265},{136,11,534},{134,0,1431},{11,0,138},{140,0,40},{4,0,155},{7,0,1689},{4,10
+-,718},{135,10,1216},{4,0,245},{5,0,151},{5,0,741},{6,0,1147},{7,0,498},{7,0,870}
+-,{7,0,1542},{12,0,213},{14,0,36},{14,0,391},{17,0,111},{18,0,6},{18,0,46},{18,0,
+-151},{19,0,36},{20,0,32},{20,0,56},{20,0,69},{20,0,102},{21,0,4},{22,0,8},{22,0,
+-10},{22,0,14},{150,0,31},{4,0,624},{135,0,1752},{5,10,124},{5,10,144},{6,10,548}
+-,{7,10,15},{7,10,153},{137,10,629},{6,0,503},{9,0,586},{13,0,468},{14,0,66},{16,
+-0,58},{7,10,1531},{8,10,416},{9,10,275},{10,10,100},{11,10,658},{11,10,979},{12,
+-10,86},{14,10,207},{15,10,20},{143,10,25},{5,0,603},{7,0,1212},{9,0,565},{14,0,
+-301},{5,10,915},{6,10,1783},{7,10,211},{7,10,1353},{9,10,83},{10,10,376},{10,10,
+-431},{11,10,543},{12,10,664},{13,10,280},{13,10,428},{14,10,128},{17,10,52},{145
+-,10,81},{4,0,492},{133,0,451},{135,0,835},{141,0,70},{132,0,539},{7,11,748},{139
+-,11,700},{7,11,1517},{11,11,597},{14,11,76},{14,11,335},{148,11,33},{6,0,113},{
+-135,0,436},{4,10,338},{133,10,400},{136,0,718},{133,11,127},{133,11,418},{6,0,
+-1505},{7,0,520},{6,11,198},{11,10,892},{140,11,83},{4,10,221},{5,10,659},{5,10,
+-989},{7,10,697},{7,10,1211},{138,10,284},{135,0,1070},{5,11,276},{6,11,55},{135,
+-11,1369},{134,0,1515},{6,11,1752},{136,11,726},{138,10,507},{15,0,78},{4,10,188}
+-,{135,10,805},{5,10,884},{139,10,991},{133,11,764},{134,10,1653},{6,11,309},{7,
+-11,331},{138,11,550},{135,11,1861},{132,11,348},{135,11,986},{135,11,1573},{12,0
+-,610},{13,0,431},{144,0,59},{9,11,799},{140,10,166},{134,0,1530},{132,0,750},{
+-132,0,307},{133,0,964},{6,11,194},{7,11,133},{10,11,493},{10,11,570},{139,11,664
+-},{5,11,24},{5,11,569},{6,11,3},{6,11,119},{6,11,143},{6,11,440},{7,11,295},{7,
+-11,599},{7,11,1686},{7,11,1854},{8,11,424},{9,11,43},{9,11,584},{9,11,760},{10,
+-11,148},{10,11,328},{11,11,159},{11,11,253},{11,11,506},{12,11,487},{12,11,531},
+-{144,11,33},{136,10,760},{5,11,14},{5,11,892},{6,11,283},{7,11,234},{136,11,537}
+-,{135,11,1251},{4,11,126},{8,11,635},{147,11,34},{4,11,316},{135,11,1561},{6,0,
+-999},{6,0,1310},{137,11,861},{4,11,64},{5,11,352},{5,11,720},{6,11,368},{139,11,
+-359},{4,0,75},{5,0,180},{6,0,500},{7,0,58},{7,0,710},{10,0,645},{136,10,770},{
+-133,0,649},{6,0,276},{7,0,282},{7,0,879},{7,0,924},{8,0,459},{9,0,599},{9,0,754}
+-,{11,0,574},{12,0,128},{12,0,494},{13,0,52},{13,0,301},{15,0,30},{143,0,132},{
+-132,0,200},{4,10,89},{5,10,489},{6,10,315},{7,10,553},{7,10,1745},{138,10,243},{
+-135,11,1050},{7,0,1621},{6,10,1658},{9,10,3},{10,10,154},{11,10,641},{13,10,85},
+-{13,10,201},{141,10,346},{6,11,175},{137,11,289},{5,11,432},{133,11,913},{6,0,
+-225},{137,0,211},{7,0,718},{8,0,687},{139,0,374},{4,10,166},{133,10,505},{9,0,
+-110},{134,10,1670},{8,0,58},{9,0,724},{11,0,809},{13,0,113},{145,0,72},{6,0,345}
+-,{7,0,1247},{144,11,82},{5,11,931},{134,11,1698},{8,0,767},{8,0,803},{9,0,301},{
+-137,0,903},{139,0,203},{134,0,1154},{7,0,1949},{136,0,674},{134,0,259},{135,0,
+-1275},{5,11,774},{6,11,1637},{6,11,1686},{134,11,1751},{134,0,1231},{7,10,445},{
+-8,10,307},{8,10,704},{10,10,41},{10,10,439},{11,10,237},{11,10,622},{140,10,201}
+-,{136,0,254},{6,11,260},{135,11,1484},{139,0,277},{135,10,1977},{4,10,189},{5,10
+-,713},{6,11,573},{136,10,57},{138,10,371},{132,10,552},{134,11,344},{133,0,248},
+-{9,0,800},{10,0,693},{11,0,482},{11,0,734},{11,0,789},{134,11,240},{4,0,116},{5,
+-0,95},{5,0,445},{7,0,1688},{8,0,29},{9,0,272},{11,0,509},{11,0,915},{4,11,292},{
+-4,11,736},{5,11,871},{6,11,171},{6,11,1689},{7,11,1324},{7,11,1944},{9,11,415},{
+-9,11,580},{14,11,230},{146,11,68},{7,0,490},{13,0,100},{143,0,75},{135,0,1641},{
+-133,0,543},{7,11,209},{8,11,661},{10,11,42},{11,11,58},{12,11,58},{12,11,118},{
+-141,11,32},{5,0,181},{8,0,41},{6,11,63},{135,11,920},{133,0,657},{133,11,793},{
+-138,0,709},{7,0,25},{8,0,202},{138,0,536},{5,11,665},{135,10,1788},{145,10,49},{
+-9,0,423},{140,0,89},{5,11,67},{6,11,62},{6,11,374},{135,11,1391},{8,0,113},{9,0,
+-877},{10,0,554},{11,0,83},{12,0,136},{19,0,109},{9,11,790},{140,11,47},{138,10,
+-661},{4,0,963},{10,0,927},{14,0,442},{135,10,1945},{133,0,976},{132,0,206},{4,11
+-,391},{135,11,1169},{134,0,2002},{6,0,696},{134,0,1008},{134,0,1170},{132,11,271
+-},{7,0,13},{8,0,226},{10,0,537},{11,0,570},{11,0,605},{11,0,799},{11,0,804},{12,
+-0,85},{12,0,516},{12,0,623},{13,0,112},{13,0,361},{14,0,77},{14,0,78},{17,0,28},
+-{19,0,110},{140,11,314},{132,0,769},{134,0,1544},{4,0,551},{137,0,678},{5,10,84}
+-,{134,10,163},{9,0,57},{9,0,459},{10,0,425},{11,0,119},{12,0,184},{12,0,371},{13
+-,0,358},{145,0,51},{5,0,188},{5,0,814},{8,0,10},{9,0,421},{9,0,729},{10,0,609},{
+-11,0,689},{4,11,253},{5,10,410},{5,11,544},{7,11,300},{137,11,340},{134,0,624},{
+-138,11,321},{135,0,1941},{18,0,130},{5,10,322},{8,10,186},{9,10,262},{10,10,187}
+-,{142,10,208},{5,11,53},{5,11,541},{6,11,94},{6,11,499},{7,11,230},{139,11,321},
+-{133,10,227},{4,0,378},{4,11,920},{5,11,25},{5,11,790},{6,11,457},{135,11,853},{
+-137,0,269},{132,0,528},{134,0,1146},{7,10,1395},{8,10,486},{9,10,236},{9,10,878}
+-,{10,10,218},{11,10,95},{19,10,17},{147,10,31},{7,10,2043},{8,10,672},{141,10,
+-448},{134,0,1105},{134,0,1616},{134,11,1765},{140,11,163},{5,10,412},{133,11,822
+-},{132,11,634},{6,0,656},{134,11,1730},{134,0,1940},{5,0,104},{6,0,173},{135,0,
+-1631},{136,10,562},{6,11,36},{7,11,658},{8,11,454},{147,11,86},{5,0,457},{134,10
+-,1771},{7,0,810},{8,0,138},{8,0,342},{9,0,84},{10,0,193},{11,0,883},{140,0,359},
+-{9,0,620},{135,10,1190},{137,10,132},{7,11,975},{137,11,789},{6,0,95},{6,0,1934}
+-,{136,0,967},{141,11,335},{6,0,406},{10,0,409},{10,0,447},{11,0,44},{140,0,100},
+-{4,10,317},{135,10,1279},{132,0,477},{134,0,1268},{6,0,1941},{8,0,944},{5,10,63}
+-,{133,10,509},{132,0,629},{132,11,104},{4,0,246},{133,0,375},{6,0,1636},{132,10,
+-288},{135,11,1614},{9,0,49},{10,0,774},{8,10,89},{8,10,620},{11,10,628},{12,10,
+-322},{143,10,124},{4,0,282},{7,0,1034},{11,0,398},{11,0,634},{12,0,1},{12,0,79},
+-{12,0,544},{14,0,237},{17,0,10},{146,0,20},{132,0,824},{7,11,45},{9,11,542},{9,
+-11,566},{138,11,728},{5,0,118},{5,0,499},{6,0,476},{6,0,665},{6,0,1176},{6,0,
+-1196},{7,0,600},{7,0,888},{135,0,1096},{7,0,296},{7,0,596},{8,0,560},{8,0,586},{
+-9,0,612},{11,0,304},{12,0,46},{13,0,89},{14,0,112},{145,0,122},{5,0,894},{6,0,
+-1772},{9,0,1009},{138,10,120},{5,11,533},{7,11,755},{138,11,780},{151,10,1},{6,0
+-,1474},{7,11,87},{142,11,288},{139,0,366},{137,10,461},{7,11,988},{7,11,1939},{9
+-,11,64},{9,11,502},{12,11,7},{12,11,34},{13,11,12},{13,11,234},{147,11,77},{7,0,
+-1599},{7,0,1723},{8,0,79},{8,0,106},{8,0,190},{8,0,302},{8,0,383},{8,0,713},{9,0
+-,119},{9,0,233},{9,0,419},{9,0,471},{10,0,181},{10,0,406},{11,0,57},{11,0,85},{
+-11,0,120},{11,0,177},{11,0,296},{11,0,382},{11,0,454},{11,0,758},{11,0,999},{12,
+-0,27},{12,0,98},{12,0,131},{12,0,245},{12,0,312},{12,0,446},{12,0,454},{13,0,25}
+-,{13,0,98},{13,0,426},{13,0,508},{14,0,70},{14,0,163},{14,0,272},{14,0,277},{14,
+-0,370},{15,0,95},{15,0,138},{15,0,167},{17,0,38},{148,0,96},{135,10,1346},{10,0,
+-200},{19,0,2},{151,0,22},{135,11,141},{134,10,85},{134,0,1759},{138,0,372},{145,
+-0,16},{8,0,943},{132,11,619},{139,11,88},{5,11,246},{8,11,189},{9,11,355},{9,11,
+-512},{10,11,124},{10,11,453},{11,11,143},{11,11,416},{11,11,859},{141,11,341},{5
+-,0,258},{134,0,719},{6,0,1798},{6,0,1839},{8,0,900},{10,0,874},{10,0,886},{12,0,
+-698},{12,0,732},{12,0,770},{16,0,106},{18,0,163},{18,0,170},{18,0,171},{152,0,20
+-},{9,0,707},{11,0,326},{11,0,339},{12,0,423},{12,0,502},{20,0,62},{9,11,707},{11
+-,11,326},{11,11,339},{12,11,423},{12,11,502},{148,11,62},{5,0,30},{7,0,495},{8,0
+-,134},{9,0,788},{140,0,438},{133,11,678},{5,10,279},{6,10,235},{7,10,468},{8,10,
+-446},{9,10,637},{10,10,717},{11,10,738},{140,10,514},{5,11,35},{6,11,287},{7,11,
+-862},{7,11,1886},{138,11,179},{7,0,1948},{7,0,2004},{132,11,517},{5,10,17},{6,10
+-,371},{137,10,528},{4,0,115},{5,0,669},{6,0,407},{8,0,311},{11,0,10},{141,0,5},{
+-137,0,381},{5,0,50},{6,0,439},{7,0,780},{135,0,1040},{136,11,667},{11,11,403},{
+-146,11,83},{5,0,1},{6,0,81},{138,0,520},{134,0,738},{5,0,482},{8,0,98},{9,0,172}
+-,{10,0,360},{10,0,700},{10,0,822},{11,0,302},{11,0,778},{12,0,50},{12,0,127},{12
+-,0,396},{13,0,62},{13,0,328},{14,0,122},{147,0,72},{9,11,157},{10,11,131},{140,
+-11,72},{135,11,714},{135,11,539},{5,0,2},{6,0,512},{7,0,797},{7,0,1494},{8,0,253
+-},{8,0,589},{9,0,77},{10,0,1},{10,0,129},{10,0,225},{11,0,118},{11,0,226},{11,0,
+-251},{11,0,430},{11,0,701},{11,0,974},{11,0,982},{12,0,64},{12,0,260},{12,0,488}
+-,{140,0,690},{5,11,394},{7,11,367},{7,11,487},{7,11,857},{7,11,1713},{8,11,246},
+-{9,11,537},{10,11,165},{12,11,219},{140,11,561},{136,0,557},{5,10,779},{5,10,807
+-},{6,10,1655},{134,10,1676},{4,10,196},{5,10,558},{133,10,949},{11,11,827},{12,
+-11,56},{14,11,34},{143,11,148},{137,0,347},{133,0,572},{134,0,832},{4,0,12},{7,0
+-,504},{7,0,522},{7,0,809},{8,0,797},{141,0,88},{4,10,752},{133,11,449},{7,11,86}
+-,{8,11,103},{145,11,69},{7,11,2028},{138,11,641},{5,0,528},{6,11,1},{142,11,2},{
+-134,0,861},{10,0,294},{4,10,227},{5,10,159},{5,10,409},{7,10,80},{10,10,479},{12
+-,10,418},{14,10,50},{14,10,249},{142,10,295},{7,10,1470},{8,10,66},{8,10,137},{8
+-,10,761},{9,10,638},{11,10,80},{11,10,212},{11,10,368},{11,10,418},{12,10,8},{13
+-,10,15},{16,10,61},{17,10,59},{19,10,28},{148,10,84},{20,0,109},{135,11,1148},{6
+-,11,277},{7,11,1274},{7,11,1386},{7,11,1392},{12,11,129},{146,11,87},{6,11,187},
+-{7,11,39},{7,11,1203},{8,11,380},{8,11,542},{14,11,117},{149,11,28},{134,0,1187}
+-,{5,0,266},{9,0,290},{9,0,364},{10,0,293},{11,0,606},{142,0,45},{6,11,297},{7,11
+-,793},{139,11,938},{4,0,50},{6,0,594},{9,0,121},{10,0,49},{10,0,412},{139,0,834}
+-,{136,0,748},{7,11,464},{8,11,438},{11,11,105},{11,11,363},{12,11,231},{14,11,
+-386},{15,11,102},{148,11,75},{132,0,466},{13,0,399},{14,0,337},{6,10,38},{7,10,
+-1220},{8,10,185},{8,10,256},{9,10,22},{9,10,331},{10,10,738},{11,10,205},{11,10,
+-540},{11,10,746},{13,10,465},{142,10,194},{9,0,378},{141,0,162},{137,0,519},{4,
+-10,159},{6,10,115},{7,10,252},{7,10,257},{7,10,1928},{8,10,69},{9,10,384},{10,10
+-,91},{10,10,615},{12,10,375},{14,10,235},{18,10,117},{147,10,123},{5,11,604},{5,
+-10,911},{136,10,278},{132,0,667},{8,0,351},{9,0,322},{4,10,151},{135,10,1567},{
+-134,0,902},{133,10,990},{12,0,180},{5,10,194},{7,10,1662},{137,10,90},{4,0,869},
+-{134,0,1996},{134,0,813},{133,10,425},{137,11,761},{132,0,260},{133,10,971},{5,
+-11,20},{6,11,298},{7,11,659},{7,11,1366},{137,11,219},{4,0,39},{5,0,36},{7,0,
+-1843},{8,0,407},{11,0,144},{140,0,523},{4,0,510},{10,0,587},{139,10,752},{7,0,29
+-},{7,0,66},{7,0,1980},{10,0,487},{138,0,809},{13,0,260},{14,0,82},{18,0,63},{137
+-,10,662},{5,10,72},{6,10,264},{7,10,21},{7,10,46},{7,10,2013},{8,10,215},{8,10,
+-513},{10,10,266},{139,10,22},{134,0,570},{6,0,565},{7,0,1667},{4,11,439},{10,10,
+-95},{11,10,603},{12,11,242},{13,10,443},{14,10,160},{143,10,4},{134,0,1464},{134
+-,10,431},{9,0,372},{15,0,2},{19,0,10},{19,0,18},{5,10,874},{6,10,1677},{143,10,0
+-},{132,0,787},{6,0,380},{12,0,399},{21,0,19},{7,10,939},{7,10,1172},{7,10,1671},
+-{9,10,540},{10,10,696},{11,10,265},{11,10,732},{11,10,928},{11,10,937},{141,10,
+-438},{137,0,200},{132,11,233},{132,0,516},{134,11,577},{132,0,844},{11,0,887},{
+-14,0,365},{142,0,375},{132,11,482},{8,0,821},{140,0,44},{7,0,1655},{136,0,305},{
+-5,10,682},{135,10,1887},{135,11,346},{132,10,696},{4,0,10},{7,0,917},{139,0,786}
+-,{5,11,795},{6,11,1741},{8,11,417},{137,11,782},{4,0,1016},{134,0,2031},{5,0,684
+-},{4,10,726},{133,10,630},{6,0,1021},{134,0,1480},{8,10,802},{136,10,838},{134,0
+-,27},{134,0,395},{135,11,622},{7,11,625},{135,11,1750},{4,11,203},{135,11,1936},
+-{6,10,118},{7,10,215},{7,10,1521},{140,10,11},{132,0,813},{136,0,511},{7,10,615}
+-,{138,10,251},{135,10,1044},{145,0,56},{133,10,225},{6,0,342},{6,0,496},{8,0,275
+-},{137,0,206},{4,0,909},{133,0,940},{132,0,891},{7,11,311},{9,11,308},{140,11,
+-255},{4,10,370},{5,10,756},{135,10,1326},{4,0,687},{134,0,1596},{134,0,1342},{6,
+-10,1662},{7,10,48},{8,10,771},{10,10,116},{13,10,104},{14,10,105},{14,10,184},{
+-15,10,168},{19,10,92},{148,10,68},{138,10,209},{4,11,400},{5,11,267},{135,11,232
+-},{151,11,12},{6,0,41},{141,0,160},{141,11,314},{134,0,1718},{136,0,778},{142,11
+-,261},{134,0,1610},{133,0,115},{132,0,294},{14,0,314},{132,10,120},{132,0,983},{
+-5,0,193},{140,0,178},{138,10,429},{5,10,820},{135,10,931},{6,0,994},{6,0,1051},{
+-6,0,1439},{7,0,174},{133,11,732},{4,11,100},{7,11,679},{8,11,313},{138,10,199},{
+-6,10,151},{6,10,1675},{7,10,383},{151,10,10},{6,0,1796},{8,0,848},{8,0,867},{8,0
+-,907},{10,0,855},{140,0,703},{140,0,221},{4,0,122},{5,0,796},{5,0,952},{6,0,1660
+-},{6,0,1671},{8,0,567},{9,0,687},{9,0,742},{10,0,686},{11,0,682},{11,0,909},{140
+-,0,281},{5,11,362},{5,11,443},{6,11,318},{7,11,1019},{139,11,623},{5,11,463},{
+-136,11,296},{11,0,583},{13,0,262},{6,10,1624},{12,10,422},{142,10,360},{5,0,179}
+-,{7,0,1095},{135,0,1213},{4,10,43},{4,11,454},{5,10,344},{133,10,357},{4,0,66},{
+-7,0,722},{135,0,904},{134,0,773},{7,0,352},{133,10,888},{5,11,48},{5,11,404},{6,
+-11,557},{7,11,458},{8,11,597},{10,11,455},{10,11,606},{11,11,49},{11,11,548},{12
+-,11,476},{13,11,18},{141,11,450},{134,11,418},{132,10,711},{5,11,442},{135,11,
+-1984},{141,0,35},{137,0,152},{134,0,1197},{135,11,1093},{137,11,203},{137,10,440
+-},{10,0,592},{10,0,753},{12,0,317},{12,0,355},{12,0,465},{12,0,469},{12,0,560},{
+-12,0,578},{141,0,243},{133,0,564},{134,0,797},{5,10,958},{133,10,987},{5,11,55},
+-{7,11,376},{140,11,161},{133,11,450},{134,0,556},{134,0,819},{11,10,276},{142,10
+-,293},{7,0,544},{138,0,61},{8,0,719},{4,10,65},{5,10,479},{5,10,1004},{7,10,1913
+-},{8,10,317},{9,10,302},{10,10,612},{141,10,22},{4,0,5},{5,0,498},{8,0,637},{9,0
+-,521},{4,11,213},{4,10,261},{7,11,223},{7,10,510},{136,11,80},{5,0,927},{7,0,101
+-},{4,10,291},{7,11,381},{7,11,806},{7,11,820},{8,11,354},{8,11,437},{8,11,787},{
+-9,10,515},{9,11,657},{10,11,58},{10,11,339},{10,11,749},{11,11,914},{12,10,152},
+-{12,11,162},{12,10,443},{13,11,75},{13,10,392},{14,11,106},{14,11,198},{14,11,
+-320},{14,10,357},{14,11,413},{146,11,43},{6,0,1153},{7,0,1441},{136,11,747},{4,0
+-,893},{5,0,780},{133,0,893},{138,11,654},{133,11,692},{133,0,238},{134,11,191},{
+-4,10,130},{135,10,843},{6,0,1296},{5,10,42},{5,10,879},{7,10,245},{7,10,324},{7,
+-10,1532},{11,10,463},{11,10,472},{13,10,363},{144,10,52},{134,0,1729},{6,0,1999}
+-,{136,0,969},{4,10,134},{133,10,372},{4,0,60},{7,0,941},{7,0,1800},{8,0,314},{9,
+-0,700},{139,0,487},{134,0,1144},{6,11,162},{7,11,1960},{136,11,831},{132,11,706}
+-,{135,0,1147},{138,11,426},{138,11,89},{7,0,1853},{138,0,437},{136,0,419},{135,
+-10,1634},{133,0,828},{5,0,806},{7,0,176},{7,0,178},{7,0,1240},{7,0,1976},{132,10
+-,644},{135,11,1877},{5,11,420},{135,11,1449},{4,0,51},{5,0,39},{6,0,4},{7,0,591}
+-,{7,0,849},{7,0,951},{7,0,1613},{7,0,1760},{7,0,1988},{9,0,434},{10,0,754},{11,0
+-,25},{139,0,37},{10,11,57},{138,11,277},{135,10,540},{132,11,204},{135,0,159},{
+-139,11,231},{133,0,902},{7,0,928},{7,11,366},{9,11,287},{12,11,199},{12,11,556},
+-{140,11,577},{6,10,623},{136,10,789},{4,10,908},{5,10,359},{5,10,508},{6,10,1723
+-},{7,10,343},{7,10,1996},{135,10,2026},{134,0,270},{4,10,341},{135,10,480},{5,11
+-,356},{135,11,224},{11,11,588},{11,11,864},{11,11,968},{143,11,160},{132,0,556},
+-{137,0,801},{132,0,416},{142,0,372},{5,0,152},{5,0,197},{7,0,340},{7,0,867},{10,
+-0,548},{10,0,581},{11,0,6},{12,0,3},{12,0,19},{14,0,110},{142,0,289},{139,0,369}
+-,{7,11,630},{9,11,567},{11,11,150},{11,11,444},{141,11,119},{134,11,539},{7,10,
+-1995},{8,10,299},{11,10,890},{140,10,674},{7,0,34},{7,0,190},{8,0,28},{8,0,141},
+-{8,0,444},{8,0,811},{9,0,468},{11,0,334},{12,0,24},{12,0,386},{140,0,576},{133,0
+-,757},{7,0,1553},{136,0,898},{133,0,721},{136,0,1012},{4,0,789},{5,0,647},{135,0
+-,1102},{132,0,898},{10,0,183},{4,10,238},{5,10,503},{6,10,179},{7,10,2003},{8,10
+-,381},{8,10,473},{9,10,149},{10,10,788},{15,10,45},{15,10,86},{20,10,110},{150,
+-10,57},{9,0,136},{19,0,107},{4,10,121},{5,10,156},{5,10,349},{10,10,605},{142,10
+-,342},{4,11,235},{135,11,255},{4,11,194},{5,11,584},{6,11,384},{7,11,583},{10,11
+-,761},{11,11,760},{139,11,851},{6,10,80},{6,10,1694},{7,10,173},{7,10,1974},{9,
+-10,547},{10,10,730},{14,10,18},{150,10,39},{4,10,923},{134,10,1711},{5,0,277},{
+-141,0,247},{132,0,435},{133,11,562},{134,0,1311},{5,11,191},{137,11,271},{132,10
+-,595},{7,11,1537},{14,11,96},{143,11,73},{5,0,437},{7,0,502},{7,0,519},{7,0,1122
+-},{7,0,1751},{14,0,211},{6,10,459},{7,10,1753},{7,10,1805},{8,10,658},{9,10,1},{
+-11,10,959},{141,10,446},{6,0,814},{4,11,470},{5,11,473},{6,11,153},{7,11,1503},{
+-7,11,1923},{10,11,701},{11,11,132},{11,11,168},{11,11,227},{11,11,320},{11,11,
+-436},{11,11,525},{11,11,855},{12,11,41},{12,11,286},{13,11,103},{13,11,284},{14,
+-11,255},{14,11,262},{15,11,117},{143,11,127},{5,0,265},{6,0,212},{135,0,28},{138
+-,0,750},{133,11,327},{6,11,552},{7,11,1754},{137,11,604},{134,0,2012},{132,0,702
+-},{5,11,80},{6,11,405},{7,11,403},{7,11,1502},{7,11,1626},{8,11,456},{9,11,487},
+-{9,11,853},{9,11,889},{10,11,309},{11,11,721},{11,11,994},{12,11,430},{141,11,
+-165},{5,0,808},{135,0,2045},{5,0,166},{8,0,739},{140,0,511},{134,10,490},{4,11,
+-453},{5,11,887},{6,11,535},{8,11,6},{136,11,543},{4,0,119},{5,0,170},{5,0,447},{
+-7,0,1708},{7,0,1889},{9,0,357},{9,0,719},{12,0,486},{140,0,596},{137,0,500},{7,
+-10,250},{136,10,507},{132,10,158},{6,0,809},{134,0,1500},{9,0,327},{11,0,350},{
+-11,0,831},{13,0,352},{4,10,140},{7,10,362},{8,10,209},{9,10,10},{9,10,503},{9,10
+-,614},{10,10,689},{11,10,327},{11,10,725},{12,10,252},{12,10,583},{13,10,192},{
+-14,10,269},{14,10,356},{148,10,50},{135,11,741},{4,0,450},{7,0,1158},{19,10,1},{
+-19,10,26},{150,10,9},{6,0,597},{135,0,1318},{134,0,1602},{6,10,228},{7,10,1341},
+-{9,10,408},{138,10,343},{7,0,1375},{7,0,1466},{138,0,331},{132,0,754},{132,10,
+-557},{5,11,101},{6,11,88},{6,11,543},{7,11,1677},{9,11,100},{10,11,677},{14,11,
+-169},{14,11,302},{14,11,313},{15,11,48},{143,11,84},{134,0,1368},{4,11,310},{9,
+-11,795},{10,11,733},{11,11,451},{12,11,249},{14,11,115},{14,11,286},{143,11,100}
+-,{132,10,548},{10,0,557},{7,10,197},{8,10,142},{8,10,325},{9,10,150},{9,10,596},
+-{10,10,353},{11,10,74},{11,10,315},{12,10,662},{12,10,681},{14,10,423},{143,10,
+-141},{133,11,587},{5,0,850},{136,0,799},{10,0,908},{12,0,701},{12,0,757},{142,0,
+-466},{4,0,62},{5,0,275},{18,0,19},{6,10,399},{6,10,579},{7,10,692},{7,10,846},{7
+-,10,1015},{7,10,1799},{8,10,403},{9,10,394},{10,10,133},{12,10,4},{12,10,297},{
+-12,10,452},{16,10,81},{18,10,25},{21,10,14},{22,10,12},{151,10,18},{12,0,459},{7
+-,10,1546},{11,10,299},{142,10,407},{132,10,177},{132,11,498},{7,11,217},{8,11,
+-140},{138,11,610},{5,10,411},{135,10,653},{134,0,1802},{7,10,439},{10,10,727},{
+-11,10,260},{139,10,684},{133,11,905},{11,11,580},{142,11,201},{134,0,1397},{5,10
+-,208},{7,10,753},{135,10,1528},{7,0,238},{7,0,2033},{8,0,120},{8,0,188},{8,0,659
+-},{9,0,598},{10,0,466},{12,0,342},{12,0,588},{13,0,503},{14,0,246},{143,0,92},{
+-135,11,1041},{4,11,456},{7,11,105},{7,11,358},{7,11,1637},{8,11,643},{139,11,483
+-},{6,0,1318},{134,0,1324},{4,0,201},{7,0,1744},{8,0,602},{11,0,247},{11,0,826},{
+-17,0,65},{133,10,242},{8,0,164},{146,0,62},{133,10,953},{139,10,802},{133,0,615}
+-,{7,11,1566},{8,11,269},{9,11,212},{9,11,718},{14,11,15},{14,11,132},{142,11,227
+-},{133,10,290},{132,10,380},{5,10,52},{7,10,277},{9,10,368},{139,10,791},{135,0,
+-1243},{133,11,539},{11,11,919},{141,11,409},{136,0,968},{133,11,470},{134,0,882}
+-,{132,0,907},{5,0,100},{10,0,329},{12,0,416},{149,0,29},{10,10,138},{139,10,476}
+-,{5,10,725},{5,10,727},{6,11,91},{7,11,435},{135,10,1811},{4,11,16},{5,11,316},{
+-5,11,842},{6,11,370},{6,11,1778},{8,11,166},{11,11,812},{12,11,206},{12,11,351},
+-{14,11,418},{16,11,15},{16,11,34},{18,11,3},{19,11,3},{19,11,7},{20,11,4},{149,
+-11,21},{132,0,176},{5,0,636},{5,0,998},{7,0,9},{7,0,1508},{8,0,26},{9,0,317},{9,
+-0,358},{10,0,210},{10,0,292},{10,0,533},{11,0,555},{12,0,526},{12,0,607},{13,0,
+-263},{13,0,459},{142,0,271},{6,0,256},{8,0,265},{4,10,38},{7,10,307},{7,10,999},
+-{7,10,1481},{7,10,1732},{7,10,1738},{9,10,414},{11,10,316},{12,10,52},{13,10,420
+-},{147,10,100},{135,10,1296},{4,11,611},{133,11,606},{4,0,643},{142,11,21},{133,
+-11,715},{133,10,723},{6,0,610},{135,11,597},{10,0,127},{141,0,27},{6,0,1995},{6,
+-0,2001},{8,0,119},{136,0,973},{4,11,149},{138,11,368},{12,0,522},{4,11,154},{5,
+-10,109},{6,10,1784},{7,11,1134},{7,10,1895},{8,11,105},{12,10,296},{140,10,302},
+-{4,11,31},{6,11,429},{7,11,962},{9,11,458},{139,11,691},{10,0,553},{11,0,876},{
+-13,0,193},{13,0,423},{14,0,166},{19,0,84},{4,11,312},{5,10,216},{7,10,1879},{9,
+-10,141},{9,10,270},{9,10,679},{10,10,159},{11,10,197},{12,10,538},{12,10,559},{
+-14,10,144},{14,10,167},{143,10,67},{134,0,1582},{7,0,1578},{135,11,1578},{137,10
+-,81},{132,11,236},{134,10,391},{134,0,795},{7,10,322},{136,10,249},{5,11,836},{5
+-,11,857},{6,11,1680},{7,11,59},{147,11,53},{135,0,432},{10,11,68},{139,11,494},{
+-4,11,81},{139,11,867},{7,0,126},{136,0,84},{142,11,280},{5,11,282},{8,11,650},{9
+-,11,295},{9,11,907},{138,11,443},{136,0,790},{5,10,632},{138,10,526},{6,0,64},{
+-12,0,377},{13,0,309},{14,0,141},{14,0,429},{14,11,141},{142,11,429},{134,0,1529}
+-,{6,0,321},{7,0,1857},{9,0,530},{19,0,99},{7,10,948},{7,10,1042},{8,10,235},{8,
+-10,461},{9,10,453},{10,10,354},{145,10,77},{7,0,1104},{11,0,269},{11,0,539},{11,
+-0,627},{11,0,706},{11,0,975},{12,0,248},{12,0,434},{12,0,600},{12,0,622},{13,0,
+-297},{13,0,485},{14,0,69},{14,0,409},{143,0,108},{4,10,362},{7,10,52},{7,10,303}
+-,{10,11,70},{12,11,26},{14,11,17},{14,11,178},{15,11,34},{149,11,12},{11,0,977},
+-{141,0,507},{9,0,34},{139,0,484},{5,10,196},{6,10,486},{7,10,212},{8,10,309},{
+-136,10,346},{6,0,1700},{7,0,26},{7,0,293},{7,0,382},{7,0,1026},{7,0,1087},{7,0,
+-2027},{8,0,24},{8,0,114},{8,0,252},{8,0,727},{8,0,729},{9,0,30},{9,0,199},{9,0,
+-231},{9,0,251},{9,0,334},{9,0,361},{9,0,712},{10,0,55},{10,0,60},{10,0,232},{10,
+-0,332},{10,0,384},{10,0,396},{10,0,504},{10,0,542},{10,0,652},{11,0,20},{11,0,48
+-},{11,0,207},{11,0,291},{11,0,298},{11,0,342},{11,0,365},{11,0,394},{11,0,620},{
+-11,0,705},{11,0,1017},{12,0,123},{12,0,340},{12,0,406},{12,0,643},{13,0,61},{13,
+-0,269},{13,0,311},{13,0,319},{13,0,486},{14,0,234},{15,0,62},{15,0,85},{16,0,71}
+-,{18,0,119},{20,0,105},{135,10,1912},{4,11,71},{5,11,376},{7,11,119},{138,11,665
+-},{10,0,918},{10,0,926},{4,10,686},{136,11,55},{138,10,625},{136,10,706},{132,11
+-,479},{4,10,30},{133,10,43},{6,0,379},{7,0,270},{8,0,176},{8,0,183},{9,0,432},{9
+-,0,661},{12,0,247},{12,0,617},{18,0,125},{7,11,607},{8,11,99},{152,11,4},{5,0,
+-792},{133,0,900},{4,11,612},{133,11,561},{4,11,41},{4,10,220},{5,11,74},{7,10,
+-1535},{7,11,1627},{11,11,871},{140,11,619},{135,0,1920},{7,11,94},{11,11,329},{
+-11,11,965},{12,11,241},{14,11,354},{15,11,22},{148,11,63},{9,11,209},{137,11,300
+-},{134,0,771},{135,0,1979},{4,0,901},{133,0,776},{142,0,254},{133,11,98},{9,11,
+-16},{141,11,386},{133,11,984},{4,11,182},{6,11,205},{135,11,220},{7,10,1725},{7,
+-10,1774},{138,10,393},{5,10,263},{134,10,414},{4,11,42},{9,11,205},{9,11,786},{
+-138,11,659},{14,0,140},{148,0,41},{8,0,440},{10,0,359},{6,10,178},{6,11,289},{6,
+-10,1750},{7,11,1670},{9,10,690},{10,10,155},{10,10,373},{11,10,698},{12,11,57},{
+-13,10,155},{20,10,93},{151,11,4},{4,0,37},{5,0,334},{7,0,1253},{151,11,25},{4,0,
+-508},{4,11,635},{5,10,97},{137,10,393},{139,11,533},{4,0,640},{133,0,513},{134,
+-10,1639},{132,11,371},{4,11,272},{7,11,836},{7,11,1651},{145,11,89},{5,11,825},{
+-6,11,444},{6,11,1640},{136,11,308},{4,10,191},{7,10,934},{8,10,647},{145,10,97},
+-{12,0,246},{15,0,162},{19,0,64},{20,0,8},{20,0,95},{22,0,24},{152,0,17},{4,0,533
+-},{5,10,165},{9,10,346},{138,10,655},{5,11,737},{139,10,885},{133,10,877},{8,10,
+-128},{139,10,179},{137,11,307},{140,0,752},{133,0,920},{135,0,1048},{5,0,153},{6
+-,0,580},{6,10,1663},{7,10,132},{7,10,1154},{7,10,1415},{7,10,1507},{12,10,493},{
+-15,10,105},{151,10,15},{5,10,459},{7,10,1073},{8,10,241},{136,10,334},{138,0,391
+-},{135,0,1952},{133,11,525},{8,11,641},{11,11,388},{140,11,580},{142,0,126},{134
+-,0,640},{132,0,483},{7,0,1616},{9,0,69},{6,10,324},{6,10,520},{7,10,338},{7,10,
+-1729},{8,10,228},{139,10,750},{5,11,493},{134,11,528},{135,0,734},{4,11,174},{
+-135,11,911},{138,0,480},{9,0,495},{146,0,104},{135,10,705},{9,0,472},{4,10,73},{
+-6,10,612},{7,10,927},{7,10,1330},{7,10,1822},{8,10,217},{9,10,765},{9,10,766},{
+-10,10,408},{11,10,51},{11,10,793},{12,10,266},{15,10,158},{20,10,89},{150,10,32}
+-,{7,11,548},{137,11,58},{4,11,32},{5,11,215},{6,11,269},{7,11,1782},{7,11,1892},
+-{10,11,16},{11,11,822},{11,11,954},{141,11,481},{132,0,874},{9,0,229},{5,10,389}
+-,{136,10,636},{7,11,1749},{136,11,477},{134,0,948},{5,11,308},{135,11,1088},{4,0
+-,748},{139,0,1009},{136,10,21},{6,0,555},{135,0,485},{5,11,126},{8,11,297},{9,11
+-,366},{9,11,445},{12,11,53},{12,11,374},{141,11,492},{7,11,1551},{139,11,361},{
+-136,0,193},{136,0,472},{8,0,653},{13,0,93},{147,0,14},{132,0,984},{132,11,175},{
+-5,0,172},{6,0,1971},{132,11,685},{149,11,8},{133,11,797},{13,0,83},{5,10,189},{7
+-,10,442},{7,10,443},{8,10,281},{12,10,174},{141,10,261},{134,0,1568},{133,11,565
+-},{139,0,384},{133,0,260},{7,0,758},{7,0,880},{7,0,1359},{9,0,164},{9,0,167},{10
+-,0,156},{10,0,588},{12,0,101},{14,0,48},{15,0,70},{6,10,2},{7,10,1262},{7,10,
+-1737},{8,10,22},{8,10,270},{8,10,612},{9,10,312},{9,10,436},{10,10,311},{10,10,
+-623},{11,10,72},{11,10,330},{11,10,455},{12,10,321},{12,10,504},{12,10,530},{12,
+-10,543},{13,10,17},{13,10,156},{13,10,334},{17,10,60},{148,10,64},{4,11,252},{7,
+-11,1068},{10,11,434},{11,11,228},{11,11,426},{13,11,231},{18,11,106},{148,11,87}
+-,{7,10,354},{10,10,410},{139,10,815},{6,0,367},{7,10,670},{7,10,1327},{8,10,411}
+-,{8,10,435},{9,10,653},{9,10,740},{10,10,385},{11,10,222},{11,10,324},{11,10,829
+-},{140,10,611},{7,0,1174},{6,10,166},{135,10,374},{146,0,121},{132,0,828},{5,11,
+-231},{138,11,509},{7,11,601},{9,11,277},{9,11,674},{10,11,178},{10,11,257},{10,
+-11,418},{11,11,531},{11,11,544},{11,11,585},{12,11,113},{12,11,475},{13,11,99},{
+-142,11,428},{134,0,1541},{135,11,1779},{5,0,343},{134,10,398},{135,10,50},{135,
+-11,1683},{4,0,440},{7,0,57},{8,0,167},{8,0,375},{9,0,82},{9,0,561},{9,0,744},{10
+-,0,620},{137,11,744},{134,0,926},{6,10,517},{7,10,1159},{10,10,621},{139,10,192}
+-,{137,0,827},{8,0,194},{136,0,756},{10,10,223},{139,10,645},{7,10,64},{136,10,
+-245},{4,11,399},{5,11,119},{5,11,494},{7,11,751},{137,11,556},{132,0,808},{135,0
+-,22},{7,10,1763},{140,10,310},{5,0,639},{7,0,1249},{11,0,896},{134,11,584},{134,
+-0,1614},{135,0,860},{135,11,1121},{5,10,129},{6,10,61},{135,10,947},{4,0,102},{7
+-,0,815},{7,0,1699},{139,0,964},{13,10,505},{141,10,506},{139,10,1000},{132,11,
+-679},{132,0,899},{132,0,569},{5,11,694},{137,11,714},{136,0,795},{6,0,2045},{139
+-,11,7},{6,0,52},{9,0,104},{9,0,559},{12,0,308},{147,0,87},{4,0,301},{132,0,604},
+-{133,10,637},{136,0,779},{5,11,143},{5,11,769},{6,11,1760},{7,11,682},{7,11,1992
+-},{136,11,736},{137,10,590},{147,0,32},{137,11,527},{5,10,280},{135,10,1226},{
+-134,0,494},{6,0,677},{6,0,682},{134,0,1044},{133,10,281},{135,10,1064},{7,0,508}
+-,{133,11,860},{6,11,422},{7,11,0},{7,11,1544},{9,11,577},{11,11,990},{12,11,141}
+-,{12,11,453},{13,11,47},{141,11,266},{134,0,1014},{5,11,515},{137,11,131},{134,0
+-,957},{132,11,646},{6,0,310},{7,0,1849},{8,0,72},{8,0,272},{8,0,431},{9,0,12},{9
+-,0,376},{10,0,563},{10,0,630},{10,0,796},{10,0,810},{11,0,367},{11,0,599},{11,0,
+-686},{140,0,672},{7,0,570},{4,11,396},{7,10,120},{7,11,728},{8,10,489},{9,11,117
+-},{9,10,319},{10,10,820},{11,10,1004},{12,10,379},{12,10,679},{13,10,117},{13,11
+-,202},{13,10,412},{14,10,25},{15,10,52},{15,10,161},{16,10,47},{20,11,51},{149,
+-10,2},{6,11,121},{6,11,124},{6,11,357},{7,11,1138},{7,11,1295},{8,11,162},{139,
+-11,655},{8,0,449},{4,10,937},{5,10,801},{136,11,449},{139,11,958},{6,0,181},{7,0
+-,537},{8,0,64},{9,0,127},{10,0,496},{12,0,510},{141,0,384},{138,11,253},{4,0,244
+-},{135,0,233},{133,11,237},{132,10,365},{6,0,1650},{10,0,702},{139,0,245},{5,10,
+-7},{139,10,774},{13,0,463},{20,0,49},{13,11,463},{148,11,49},{4,10,734},{5,10,
+-662},{134,10,430},{4,10,746},{135,10,1090},{5,10,360},{136,10,237},{137,0,338},{
+-143,11,10},{7,11,571},{138,11,366},{134,0,1279},{9,11,513},{10,11,22},{10,11,39}
+-,{12,11,122},{140,11,187},{133,0,896},{146,0,178},{134,0,695},{137,0,808},{134,
+-11,587},{7,11,107},{7,11,838},{8,11,550},{138,11,401},{7,0,1117},{136,0,539},{4,
+-10,277},{5,10,608},{6,10,493},{7,10,457},{140,10,384},{133,11,768},{12,0,257},{7
+-,10,27},{135,10,316},{140,0,1003},{4,0,207},{5,0,586},{5,0,676},{6,0,448},{8,0,
+-244},{11,0,1},{13,0,3},{16,0,54},{17,0,4},{18,0,13},{133,10,552},{4,10,401},{137
+-,10,264},{5,0,516},{7,0,1883},{135,11,1883},{12,0,960},{132,11,894},{5,0,4},{5,0
+-,810},{6,0,13},{6,0,538},{6,0,1690},{6,0,1726},{7,0,499},{7,0,1819},{8,0,148},{8
+-,0,696},{8,0,791},{12,0,125},{143,0,9},{135,0,1268},{11,0,30},{14,0,315},{9,10,
+-543},{10,10,524},{12,10,524},{16,10,18},{20,10,26},{148,10,65},{6,0,748},{4,10,
+-205},{5,10,623},{7,10,104},{136,10,519},{11,0,542},{139,0,852},{140,0,6},{132,0,
+-848},{7,0,1385},{11,0,582},{11,0,650},{11,0,901},{11,0,949},{12,0,232},{12,0,236
+-},{13,0,413},{13,0,501},{18,0,116},{7,10,579},{9,10,41},{9,10,244},{9,10,669},{
+-10,10,5},{11,10,861},{11,10,951},{139,10,980},{4,0,945},{6,0,1811},{6,0,1845},{6
+-,0,1853},{6,0,1858},{8,0,862},{12,0,782},{12,0,788},{18,0,160},{148,0,117},{132,
+-10,717},{4,0,925},{5,0,803},{8,0,698},{138,0,828},{134,0,1416},{132,0,610},{139,
+-0,992},{6,0,878},{134,0,1477},{135,0,1847},{138,11,531},{137,11,539},{134,11,272
+-},{133,0,383},{134,0,1404},{132,10,489},{4,11,9},{5,11,128},{7,11,368},{11,11,
+-480},{148,11,3},{136,0,986},{9,0,660},{138,0,347},{135,10,892},{136,11,682},{7,0
+-,572},{9,0,592},{11,0,680},{12,0,356},{140,0,550},{7,0,1411},{138,11,527},{4,11,
+-2},{7,11,545},{135,11,894},{137,10,473},{11,0,64},{7,11,481},{7,10,819},{9,10,26
+-},{9,10,392},{9,11,792},{10,10,152},{10,10,226},{12,10,276},{12,10,426},{12,10,
+-589},{13,10,460},{15,10,97},{19,10,48},{148,10,104},{135,10,51},{136,11,445},{
+-136,11,646},{135,0,606},{132,10,674},{6,0,1829},{134,0,1830},{132,10,770},{5,10,
+-79},{7,10,1027},{7,10,1477},{139,10,52},{5,11,530},{142,11,113},{134,10,1666},{7
+-,0,748},{139,0,700},{134,10,195},{133,10,789},{9,0,87},{10,0,365},{4,10,251},{4,
+-10,688},{7,10,513},{135,10,1284},{136,11,111},{133,0,127},{6,0,198},{140,0,83},{
+-133,11,556},{133,10,889},{4,10,160},{5,10,330},{7,10,1434},{136,10,174},{5,0,276
+-},{6,0,55},{7,0,1369},{138,0,864},{8,11,16},{140,11,568},{6,0,1752},{136,0,726},
+-{135,0,1066},{133,0,764},{6,11,186},{137,11,426},{11,0,683},{139,11,683},{6,0,
+-309},{7,0,331},{138,0,550},{133,10,374},{6,0,1212},{6,0,1852},{7,0,1062},{8,0,
+-874},{8,0,882},{138,0,936},{132,11,585},{134,0,1364},{7,0,986},{133,10,731},{6,0
+-,723},{6,0,1408},{138,0,381},{135,0,1573},{134,0,1025},{4,10,626},{5,10,642},{6,
+-10,425},{10,10,202},{139,10,141},{4,11,93},{5,11,252},{6,11,229},{7,11,291},{9,
+-11,550},{139,11,644},{137,11,749},{137,11,162},{132,11,381},{135,0,1559},{6,0,
+-194},{7,0,133},{10,0,493},{10,0,570},{139,0,664},{5,0,24},{5,0,569},{6,0,3},{6,0
+-,119},{6,0,143},{6,0,440},{7,0,295},{7,0,599},{7,0,1686},{7,0,1854},{8,0,424},{9
+-,0,43},{9,0,584},{9,0,760},{10,0,148},{10,0,328},{11,0,159},{11,0,253},{11,0,506
+-},{12,0,487},{140,0,531},{6,0,661},{134,0,1517},{136,10,835},{151,10,17},{5,0,14
+-},{5,0,892},{6,0,283},{7,0,234},{136,0,537},{139,0,541},{4,0,126},{8,0,635},{147
+-,0,34},{4,0,316},{4,0,495},{135,0,1561},{4,11,187},{5,11,184},{5,11,690},{7,11,
+-1869},{138,11,756},{139,11,783},{4,0,998},{137,0,861},{136,0,1009},{139,11,292},
+-{5,11,21},{6,11,77},{6,11,157},{7,11,974},{7,11,1301},{7,11,1339},{7,11,1490},{7
+-,11,1873},{137,11,628},{7,11,1283},{9,11,227},{9,11,499},{10,11,341},{11,11,325}
+-,{11,11,408},{14,11,180},{15,11,144},{18,11,47},{147,11,49},{4,0,64},{5,0,352},{
+-5,0,720},{6,0,368},{139,0,359},{5,10,384},{8,10,455},{140,10,48},{5,10,264},{134
+-,10,184},{7,0,1577},{10,0,304},{10,0,549},{12,0,365},{13,0,220},{13,0,240},{142,
+-0,33},{134,0,1107},{134,0,929},{135,0,1142},{6,0,175},{137,0,289},{5,0,432},{133
+-,0,913},{6,0,279},{7,0,219},{5,10,633},{135,10,1323},{7,0,785},{7,10,359},{8,10,
+-243},{140,10,175},{139,0,595},{132,10,105},{8,11,398},{9,11,681},{139,11,632},{
+-140,0,80},{5,0,931},{134,0,1698},{142,11,241},{134,11,20},{134,0,1323},{11,0,526
+-},{11,0,939},{141,0,290},{5,0,774},{6,0,780},{6,0,1637},{6,0,1686},{6,0,1751},{8
+-,0,559},{141,0,109},{141,0,127},{7,0,1167},{11,0,934},{13,0,391},{17,0,76},{135,
+-11,709},{135,0,963},{6,0,260},{135,0,1484},{134,0,573},{4,10,758},{139,11,941},{
+-135,10,1649},{145,11,36},{4,0,292},{137,0,580},{4,0,736},{5,0,871},{6,0,1689},{
+-135,0,1944},{7,11,945},{11,11,713},{139,11,744},{134,0,1164},{135,11,937},{6,0,
+-1922},{9,0,982},{15,0,173},{15,0,178},{15,0,200},{18,0,189},{18,0,207},{21,0,47}
+-,{135,11,1652},{7,0,1695},{139,10,128},{6,0,63},{135,0,920},{133,0,793},{143,11,
+-134},{133,10,918},{5,0,67},{6,0,62},{6,0,374},{135,0,1391},{9,0,790},{12,0,47},{
+-4,11,579},{5,11,226},{5,11,323},{135,11,960},{10,11,784},{141,11,191},{4,0,391},
+-{135,0,1169},{137,0,443},{13,11,232},{146,11,35},{132,10,340},{132,0,271},{137,
+-11,313},{5,11,973},{137,11,659},{134,0,1140},{6,11,135},{135,11,1176},{4,0,253},
+-{5,0,544},{7,0,300},{137,0,340},{7,0,897},{5,10,985},{7,10,509},{145,10,96},{138
+-,11,735},{135,10,1919},{138,0,890},{5,0,818},{134,0,1122},{5,0,53},{5,0,541},{6,
+-0,94},{6,0,499},{7,0,230},{139,0,321},{4,0,920},{5,0,25},{5,0,790},{6,0,457},{7,
+-0,853},{8,0,788},{142,11,31},{132,10,247},{135,11,314},{132,0,468},{7,0,243},{6,
+-10,337},{7,10,494},{8,10,27},{8,10,599},{138,10,153},{4,10,184},{5,10,390},{7,10
+-,618},{7,10,1456},{139,10,710},{134,0,870},{134,0,1238},{134,0,1765},{10,0,853},
+-{10,0,943},{14,0,437},{14,0,439},{14,0,443},{14,0,446},{14,0,452},{14,0,469},{14
+-,0,471},{14,0,473},{16,0,93},{16,0,102},{16,0,110},{148,0,121},{4,0,605},{7,0,
+-518},{7,0,1282},{7,0,1918},{10,0,180},{139,0,218},{133,0,822},{4,0,634},{11,0,
+-916},{142,0,419},{6,11,281},{7,11,6},{8,11,282},{8,11,480},{8,11,499},{9,11,198}
+-,{10,11,143},{10,11,169},{10,11,211},{10,11,417},{10,11,574},{11,11,147},{11,11,
+-395},{12,11,75},{12,11,407},{12,11,608},{13,11,500},{142,11,251},{134,0,898},{6,
+-0,36},{7,0,658},{8,0,454},{150,11,48},{133,11,674},{135,11,1776},{4,11,419},{10,
+-10,227},{11,10,497},{11,10,709},{140,10,415},{6,10,360},{7,10,1664},{136,10,478}
+-,{137,0,806},{12,11,508},{14,11,102},{14,11,226},{144,11,57},{135,11,1123},{4,11
+-,138},{7,11,1012},{7,11,1280},{137,11,76},{5,11,29},{140,11,638},{136,10,699},{
+-134,0,1326},{132,0,104},{135,11,735},{132,10,739},{134,0,1331},{7,0,260},{135,11
+-,260},{135,11,1063},{7,0,45},{9,0,542},{9,0,566},{10,0,728},{137,10,869},{4,10,
+-67},{5,10,422},{7,10,1037},{7,10,1289},{7,10,1555},{9,10,741},{145,10,108},{139,
+-0,263},{134,0,1516},{14,0,146},{15,0,42},{16,0,23},{17,0,86},{146,0,17},{138,0,
+-468},{136,0,1005},{4,11,17},{5,11,23},{7,11,995},{11,11,383},{11,11,437},{12,11,
+-460},{140,11,532},{7,0,87},{142,0,288},{138,10,96},{135,11,626},{144,10,26},{7,0
+-,988},{7,0,1939},{9,0,64},{9,0,502},{12,0,22},{12,0,34},{13,0,12},{13,0,234},{
+-147,0,77},{13,0,133},{8,10,203},{11,10,823},{11,10,846},{12,10,482},{13,10,277},
+-{13,10,302},{13,10,464},{14,10,205},{142,10,221},{4,10,449},{133,10,718},{135,0,
+-141},{6,0,1842},{136,0,872},{8,11,70},{12,11,171},{141,11,272},{4,10,355},{6,10,
+-311},{9,10,256},{138,10,404},{132,0,619},{137,0,261},{10,11,233},{10,10,758},{
+-139,11,76},{5,0,246},{8,0,189},{9,0,355},{9,0,512},{10,0,124},{10,0,453},{11,0,
+-143},{11,0,416},{11,0,859},{141,0,341},{134,11,442},{133,10,827},{5,10,64},{140,
+-10,581},{4,10,442},{7,10,1047},{7,10,1352},{135,10,1643},{134,11,1709},{5,0,678}
+-,{6,0,305},{7,0,775},{7,0,1065},{133,10,977},{11,11,69},{12,11,105},{12,11,117},
+-{13,11,213},{14,11,13},{14,11,62},{14,11,177},{14,11,421},{15,11,19},{146,11,141
+-},{137,11,309},{5,0,35},{7,0,862},{7,0,1886},{138,0,179},{136,0,285},{132,0,517}
+-,{7,11,976},{9,11,146},{10,11,206},{10,11,596},{13,11,218},{142,11,153},{132,10,
+-254},{6,0,214},{12,0,540},{4,10,275},{7,10,1219},{140,10,376},{8,0,667},{11,0,
+-403},{146,0,83},{12,0,74},{10,11,648},{11,11,671},{143,11,46},{135,0,125},{134,
+-10,1753},{133,0,761},{6,0,912},{4,11,518},{6,10,369},{6,10,502},{7,10,1036},{7,
+-11,1136},{8,10,348},{9,10,452},{10,10,26},{11,10,224},{11,10,387},{11,10,772},{
+-12,10,95},{12,10,629},{13,10,195},{13,10,207},{13,10,241},{14,10,260},{14,10,270
+-},{143,10,140},{10,0,131},{140,0,72},{132,10,269},{5,10,480},{7,10,532},{7,10,
+-1197},{7,10,1358},{8,10,291},{11,10,349},{142,10,396},{8,11,689},{137,11,863},{8
+-,0,333},{138,0,182},{4,11,18},{7,11,145},{7,11,444},{7,11,1278},{8,11,49},{8,11,
+-400},{9,11,71},{9,11,250},{10,11,459},{12,11,160},{144,11,24},{14,11,35},{142,11
+-,191},{135,11,1864},{135,0,1338},{148,10,15},{14,0,94},{15,0,65},{16,0,4},{16,0,
+-77},{16,0,80},{145,0,5},{12,11,82},{143,11,36},{133,11,1010},{133,0,449},{133,0,
+-646},{7,0,86},{8,0,103},{135,10,657},{7,0,2028},{138,0,641},{136,10,533},{134,0,
+-1},{139,11,970},{5,11,87},{7,11,313},{7,11,1103},{10,11,112},{10,11,582},{11,11,
+-389},{11,11,813},{12,11,385},{13,11,286},{14,11,124},{146,11,108},{6,0,869},{132
+-,11,267},{6,0,277},{7,0,1274},{7,0,1386},{146,0,87},{6,0,187},{7,0,39},{7,0,1203
+-},{8,0,380},{14,0,117},{149,0,28},{4,10,211},{4,10,332},{5,10,335},{6,10,238},{7
+-,10,269},{7,10,811},{7,10,1797},{8,10,836},{9,10,507},{141,10,242},{4,0,785},{5,
+-0,368},{6,0,297},{7,0,793},{139,0,938},{7,0,464},{8,0,558},{11,0,105},{12,0,231}
+-,{14,0,386},{15,0,102},{148,0,75},{133,10,1009},{8,0,877},{140,0,731},{139,11,
+-289},{10,11,249},{139,11,209},{132,11,561},{134,0,1608},{132,11,760},{134,0,1429
+-},{9,11,154},{140,11,485},{5,10,228},{6,10,203},{7,10,156},{8,10,347},{137,10,
+-265},{7,0,1010},{11,0,733},{11,0,759},{13,0,34},{14,0,427},{146,0,45},{7,10,1131
+-},{135,10,1468},{136,11,255},{7,0,1656},{9,0,369},{10,0,338},{10,0,490},{11,0,
+-154},{11,0,545},{11,0,775},{13,0,77},{141,0,274},{133,11,621},{134,0,1038},{4,11
+-,368},{135,11,641},{6,0,2010},{8,0,979},{8,0,985},{10,0,951},{138,0,1011},{134,0
+-,1005},{19,0,121},{5,10,291},{5,10,318},{7,10,765},{9,10,389},{140,10,548},{5,0,
+-20},{6,0,298},{7,0,659},{137,0,219},{7,0,1440},{11,0,854},{11,0,872},{11,0,921},
+-{12,0,551},{13,0,472},{142,0,367},{5,0,490},{6,0,615},{6,0,620},{135,0,683},{6,0
+-,1070},{134,0,1597},{139,0,522},{132,0,439},{136,0,669},{6,0,766},{6,0,1143},{6,
+-0,1245},{10,10,525},{139,10,82},{9,11,92},{147,11,91},{6,0,668},{134,0,1218},{6,
+-11,525},{9,11,876},{140,11,284},{132,0,233},{136,0,547},{132,10,422},{5,10,355},
+-{145,10,0},{6,11,300},{135,11,1515},{4,0,482},{137,10,905},{4,0,886},{7,0,346},{
+-133,11,594},{133,10,865},{5,10,914},{134,10,1625},{135,0,334},{5,0,795},{6,0,
+-1741},{133,10,234},{135,10,1383},{6,11,1641},{136,11,820},{135,0,371},{7,11,1313
+-},{138,11,660},{135,10,1312},{135,0,622},{7,0,625},{135,0,1750},{135,0,339},{4,0
+-,203},{135,0,1936},{15,0,29},{16,0,38},{15,11,29},{144,11,38},{5,0,338},{135,0,
+-1256},{135,10,1493},{10,0,130},{6,10,421},{7,10,61},{7,10,1540},{138,10,501},{6,
+-11,389},{7,11,149},{9,11,142},{138,11,94},{137,10,341},{11,0,678},{12,0,307},{
+-142,10,98},{6,11,8},{7,11,1881},{136,11,91},{135,0,2044},{6,0,770},{6,0,802},{6,
+-0,812},{7,0,311},{9,0,308},{12,0,255},{6,10,102},{7,10,72},{15,10,142},{147,10,
+-67},{151,10,30},{135,10,823},{135,0,1266},{135,11,1746},{135,10,1870},{4,0,400},
+-{5,0,267},{135,0,232},{7,11,24},{11,11,542},{139,11,852},{135,11,1739},{4,11,503
+-},{135,11,1661},{5,11,130},{7,11,1314},{9,11,610},{10,11,718},{11,11,601},{11,11
+-,819},{11,11,946},{140,11,536},{10,11,149},{11,11,280},{142,11,336},{7,0,739},{
+-11,0,690},{7,11,1946},{8,10,48},{8,10,88},{8,10,582},{8,10,681},{9,10,373},{9,10
+-,864},{11,10,157},{11,10,843},{148,10,27},{134,0,990},{4,10,88},{5,10,137},{5,10
+-,174},{5,10,777},{6,10,1664},{6,10,1725},{7,10,77},{7,10,426},{7,10,1317},{7,10,
+-1355},{8,10,126},{8,10,563},{9,10,523},{9,10,750},{10,10,310},{10,10,836},{11,10
+-,42},{11,10,318},{11,10,731},{12,10,68},{12,10,92},{12,10,507},{12,10,692},{13,
+-10,81},{13,10,238},{13,10,374},{14,10,436},{18,10,138},{19,10,78},{19,10,111},{
+-20,10,55},{20,10,77},{148,10,92},{141,10,418},{7,0,1831},{132,10,938},{6,0,776},
+-{134,0,915},{138,10,351},{5,11,348},{6,11,522},{6,10,1668},{7,10,1499},{8,10,117
+-},{9,10,314},{138,10,174},{135,10,707},{132,0,613},{133,10,403},{132,11,392},{5,
+-11,433},{9,11,633},{139,11,629},{133,0,763},{132,0,878},{132,0,977},{132,0,100},
+-{6,0,463},{4,10,44},{5,10,311},{7,10,639},{7,10,762},{7,10,1827},{9,10,8},{9,10,
+-462},{148,10,83},{134,11,234},{4,10,346},{7,10,115},{9,10,180},{9,10,456},{138,
+-10,363},{5,0,362},{5,0,443},{6,0,318},{7,0,1019},{139,0,623},{5,0,463},{8,0,296}
+-,{7,11,140},{7,11,1950},{8,11,680},{11,11,817},{147,11,88},{7,11,1222},{138,11,
+-386},{142,0,137},{132,0,454},{7,0,1914},{6,11,5},{7,10,1051},{9,10,545},{11,11,
+-249},{12,11,313},{16,11,66},{145,11,26},{135,0,1527},{145,0,58},{148,11,59},{5,0
+-,48},{5,0,404},{6,0,557},{7,0,458},{8,0,597},{10,0,455},{10,0,606},{11,0,49},{11
+-,0,548},{12,0,476},{13,0,18},{141,0,450},{5,11,963},{134,11,1773},{133,0,729},{
+-138,11,586},{5,0,442},{135,0,1984},{134,0,449},{144,0,40},{4,0,853},{7,11,180},{
+-8,11,509},{136,11,792},{6,10,185},{7,10,1899},{9,10,875},{139,10,673},{134,11,
+-524},{12,0,227},{4,10,327},{5,10,478},{7,10,1332},{136,10,753},{6,0,1491},{5,10,
+-1020},{133,10,1022},{4,10,103},{133,10,401},{132,11,931},{4,10,499},{135,10,1421
+-},{5,0,55},{7,0,376},{140,0,161},{133,0,450},{6,0,1174},{134,0,1562},{10,0,62},{
+-13,0,400},{135,11,1837},{140,0,207},{135,0,869},{4,11,773},{5,11,618},{137,11,
+-756},{132,10,96},{4,0,213},{7,0,223},{8,0,80},{135,10,968},{4,11,90},{5,11,337},
+-{5,11,545},{7,11,754},{9,11,186},{10,11,72},{10,11,782},{11,11,513},{11,11,577},
+-{11,11,610},{11,11,889},{11,11,961},{12,11,354},{12,11,362},{12,11,461},{12,11,
+-595},{13,11,79},{143,11,121},{7,0,381},{7,0,806},{7,0,820},{8,0,354},{8,0,437},{
+-8,0,787},{9,0,657},{10,0,58},{10,0,339},{10,0,749},{11,0,914},{12,0,162},{13,0,
+-75},{14,0,106},{14,0,198},{14,0,320},{14,0,413},{146,0,43},{136,0,747},{136,0,
+-954},{134,0,1073},{135,0,556},{7,11,151},{9,11,329},{139,11,254},{5,0,692},{134,
+-0,1395},{6,10,563},{137,10,224},{134,0,191},{132,0,804},{9,11,187},{10,11,36},{
+-17,11,44},{146,11,64},{7,11,165},{7,11,919},{136,11,517},{4,11,506},{5,11,295},{
+-7,11,1680},{15,11,14},{144,11,5},{4,0,706},{6,0,162},{7,0,1960},{136,0,831},{135
+-,11,1376},{7,11,987},{9,11,688},{10,11,522},{11,11,788},{140,11,566},{150,0,35},
+-{138,0,426},{135,0,1235},{135,11,1741},{7,11,389},{7,11,700},{7,11,940},{8,11,
+-514},{9,11,116},{9,11,535},{10,11,118},{11,11,107},{11,11,148},{11,11,922},{12,
+-11,254},{12,11,421},{142,11,238},{134,0,1234},{132,11,743},{4,10,910},{5,10,832}
+-,{135,11,1335},{141,0,96},{135,11,185},{146,0,149},{4,0,204},{137,0,902},{4,11,
+-784},{133,11,745},{136,0,833},{136,0,949},{7,0,366},{9,0,287},{12,0,199},{12,0,
+-556},{12,0,577},{5,11,81},{7,11,146},{7,11,1342},{7,11,1446},{8,11,53},{8,11,561
+-},{8,11,694},{8,11,754},{9,11,97},{9,11,115},{9,11,894},{10,11,462},{10,11,813},
+-{11,11,230},{11,11,657},{11,11,699},{11,11,748},{12,11,119},{12,11,200},{12,11,
+-283},{14,11,273},{145,11,15},{5,11,408},{137,11,747},{9,11,498},{140,11,181},{6,
+-0,2020},{136,0,992},{5,0,356},{135,0,224},{134,0,784},{7,0,630},{9,0,567},{11,0,
+-150},{11,0,444},{13,0,119},{8,10,528},{137,10,348},{134,0,539},{4,10,20},{133,10
+-,616},{142,0,27},{7,11,30},{8,11,86},{8,11,315},{8,11,700},{9,11,576},{9,11,858}
+-,{11,11,310},{11,11,888},{11,11,904},{12,11,361},{141,11,248},{138,11,839},{134,
+-0,755},{134,0,1063},{7,10,1091},{135,10,1765},{134,11,428},{7,11,524},{8,11,169}
+-,{8,11,234},{9,11,480},{138,11,646},{139,0,814},{7,11,1462},{139,11,659},{4,10,
+-26},{5,10,429},{6,10,245},{7,10,704},{7,10,1379},{135,10,1474},{7,11,1205},{138,
+-11,637},{139,11,803},{132,10,621},{136,0,987},{4,11,266},{8,11,4},{9,11,39},{10,
+-11,166},{11,11,918},{12,11,635},{20,11,10},{22,11,27},{150,11,43},{4,0,235},{135
+-,0,255},{4,0,194},{5,0,584},{6,0,384},{7,0,583},{10,0,761},{11,0,760},{139,0,851
+-},{133,10,542},{134,0,1086},{133,10,868},{8,0,1016},{136,0,1018},{7,0,1396},{7,
+-11,1396},{136,10,433},{135,10,1495},{138,10,215},{141,10,124},{7,11,157},{8,11,
+-279},{9,11,759},{16,11,31},{16,11,39},{16,11,75},{18,11,24},{20,11,42},{152,11,1
+-},{5,0,562},{134,11,604},{134,0,913},{5,0,191},{137,0,271},{4,0,470},{6,0,153},{
+-7,0,1503},{7,0,1923},{10,0,701},{11,0,132},{11,0,227},{11,0,320},{11,0,436},{11,
+-0,525},{11,0,855},{11,0,873},{12,0,41},{12,0,286},{13,0,103},{13,0,284},{14,0,
+-255},{14,0,262},{15,0,117},{143,0,127},{7,0,475},{12,0,45},{147,10,112},{132,11,
+-567},{137,11,859},{6,0,713},{6,0,969},{6,0,1290},{134,0,1551},{133,0,327},{6,0,
+-552},{6,0,1292},{7,0,1754},{137,0,604},{4,0,223},{6,0,359},{11,0,3},{13,0,108},{
+-14,0,89},{16,0,22},{5,11,762},{7,11,1880},{9,11,680},{139,11,798},{5,0,80},{6,0,
+-405},{7,0,403},{7,0,1502},{8,0,456},{9,0,487},{9,0,853},{9,0,889},{10,0,309},{11
+-,0,721},{11,0,994},{12,0,430},{141,0,165},{133,11,298},{132,10,647},{134,0,2016}
+-,{18,10,10},{146,11,10},{4,0,453},{5,0,887},{6,0,535},{8,0,6},{8,0,543},{136,0,
+-826},{136,0,975},{10,0,961},{138,0,962},{138,10,220},{6,0,1891},{6,0,1893},{9,0,
+-916},{9,0,965},{9,0,972},{12,0,801},{12,0,859},{12,0,883},{15,0,226},{149,0,51},
+-{132,10,109},{135,11,267},{7,11,92},{7,11,182},{8,11,453},{9,11,204},{11,11,950}
+-,{12,11,94},{12,11,644},{16,11,20},{16,11,70},{16,11,90},{147,11,55},{134,10,
+-1746},{6,11,71},{7,11,845},{7,11,1308},{8,11,160},{137,11,318},{5,0,101},{6,0,88
+-},{7,0,263},{7,0,628},{7,0,1677},{8,0,349},{9,0,100},{10,0,677},{14,0,169},{14,0
+-,302},{14,0,313},{15,0,48},{15,0,84},{7,11,237},{8,11,664},{9,11,42},{9,11,266},
+-{9,11,380},{9,11,645},{10,11,177},{138,11,276},{138,11,69},{4,0,310},{7,0,708},{
+-7,0,996},{9,0,795},{10,0,390},{10,0,733},{11,0,451},{12,0,249},{14,0,115},{14,0,
+-286},{143,0,100},{5,0,587},{4,10,40},{10,10,67},{11,10,117},{11,10,768},{139,10,
+-935},{6,0,1942},{7,0,512},{136,0,983},{7,10,992},{8,10,301},{9,10,722},{12,10,63
+-},{13,10,29},{14,10,161},{143,10,18},{136,11,76},{139,10,923},{134,0,645},{134,0
+-,851},{4,0,498},{132,11,293},{7,0,217},{8,0,140},{10,0,610},{14,11,352},{17,11,
+-53},{18,11,146},{18,11,152},{19,11,11},{150,11,54},{134,0,1448},{138,11,841},{
+-133,0,905},{4,11,605},{7,11,518},{7,11,1282},{7,11,1918},{10,11,180},{139,11,218
+-},{139,11,917},{135,10,825},{140,10,328},{4,0,456},{7,0,105},{7,0,358},{7,0,1637
+-},{8,0,643},{139,0,483},{134,0,792},{6,11,96},{135,11,1426},{137,11,691},{4,11,
+-651},{133,11,289},{7,11,688},{8,11,35},{9,11,511},{10,11,767},{147,11,118},{150,
+-0,56},{5,0,243},{5,0,535},{6,10,204},{10,10,320},{10,10,583},{13,10,502},{14,10,
+-72},{14,10,274},{14,10,312},{14,10,344},{15,10,159},{16,10,62},{16,10,69},{17,10
+-,30},{18,10,42},{18,10,53},{18,10,84},{18,10,140},{19,10,68},{19,10,85},{20,10,5
+-},{20,10,45},{20,10,101},{22,10,7},{150,10,20},{4,10,558},{6,10,390},{7,10,162},
+-{7,10,689},{9,10,360},{138,10,653},{146,11,23},{135,0,1748},{5,10,856},{6,10,
+-1672},{6,10,1757},{134,10,1781},{5,0,539},{5,0,754},{6,0,876},{132,11,704},{135,
+-11,1078},{5,10,92},{10,10,736},{140,10,102},{17,0,91},{5,10,590},{137,10,213},{
+-134,0,1565},{6,0,91},{135,0,435},{4,0,939},{140,0,792},{134,0,1399},{4,0,16},{5,
+-0,316},{5,0,842},{6,0,370},{6,0,1778},{8,0,166},{11,0,812},{12,0,206},{12,0,351}
+-,{14,0,418},{16,0,15},{16,0,34},{18,0,3},{19,0,3},{19,0,7},{20,0,4},{21,0,21},{4
+-,11,720},{133,11,306},{144,0,95},{133,11,431},{132,11,234},{135,0,551},{4,0,999}
+-,{6,0,1966},{134,0,2042},{7,0,619},{10,0,547},{11,0,122},{12,0,601},{15,0,7},{
+-148,0,20},{5,11,464},{6,11,236},{7,11,276},{7,11,696},{7,11,914},{7,11,1108},{7,
+-11,1448},{9,11,15},{9,11,564},{10,11,14},{12,11,565},{13,11,449},{14,11,53},{15,
+-11,13},{16,11,64},{145,11,41},{6,0,884},{6,0,1019},{134,0,1150},{6,11,1767},{12,
+-11,194},{145,11,107},{136,10,503},{133,11,840},{7,0,671},{134,10,466},{132,0,888
+-},{4,0,149},{138,0,368},{4,0,154},{7,0,1134},{136,0,105},{135,0,983},{9,11,642},
+-{11,11,236},{142,11,193},{4,0,31},{6,0,429},{7,0,962},{9,0,458},{139,0,691},{6,0
+-,643},{134,0,1102},{132,0,312},{4,11,68},{5,11,634},{6,11,386},{7,11,794},{8,11,
+-273},{9,11,563},{10,11,105},{10,11,171},{11,11,94},{139,11,354},{133,0,740},{135
+-,0,1642},{4,11,95},{7,11,416},{8,11,211},{139,11,830},{132,0,236},{138,10,241},{
+-7,11,731},{13,11,20},{143,11,11},{5,0,836},{5,0,857},{6,0,1680},{135,0,59},{10,0
+-,68},{11,0,494},{152,11,6},{4,0,81},{139,0,867},{135,0,795},{133,11,689},{4,0,
+-1001},{5,0,282},{6,0,1932},{6,0,1977},{6,0,1987},{6,0,1992},{8,0,650},{8,0,919},
+-{8,0,920},{8,0,923},{8,0,926},{8,0,927},{8,0,931},{8,0,939},{8,0,947},{8,0,956},
+-{8,0,997},{9,0,907},{10,0,950},{10,0,953},{10,0,954},{10,0,956},{10,0,958},{10,0
+-,959},{10,0,964},{10,0,970},{10,0,972},{10,0,973},{10,0,975},{10,0,976},{10,0,
+-980},{10,0,981},{10,0,984},{10,0,988},{10,0,990},{10,0,995},{10,0,999},{10,0,
+-1002},{10,0,1003},{10,0,1005},{10,0,1006},{10,0,1008},{10,0,1009},{10,0,1012},{
+-10,0,1014},{10,0,1015},{10,0,1019},{10,0,1020},{10,0,1022},{12,0,959},{12,0,961}
+-,{12,0,962},{12,0,963},{12,0,964},{12,0,965},{12,0,967},{12,0,968},{12,0,969},{
+-12,0,970},{12,0,971},{12,0,972},{12,0,973},{12,0,974},{12,0,975},{12,0,976},{12,
+-0,977},{12,0,979},{12,0,981},{12,0,982},{12,0,983},{12,0,984},{12,0,985},{12,0,
+-986},{12,0,987},{12,0,989},{12,0,990},{12,0,992},{12,0,993},{12,0,995},{12,0,998
+-},{12,0,999},{12,0,1000},{12,0,1001},{12,0,1002},{12,0,1004},{12,0,1005},{12,0,
+-1006},{12,0,1007},{12,0,1008},{12,0,1009},{12,0,1010},{12,0,1011},{12,0,1012},{
+-12,0,1014},{12,0,1015},{12,0,1016},{12,0,1017},{12,0,1018},{12,0,1019},{12,0,
+-1022},{12,0,1023},{14,0,475},{14,0,477},{14,0,478},{14,0,479},{14,0,480},{14,0,
+-482},{14,0,483},{14,0,484},{14,0,485},{14,0,486},{14,0,487},{14,0,488},{14,0,489
+-},{14,0,490},{14,0,491},{14,0,492},{14,0,493},{14,0,494},{14,0,495},{14,0,496},{
+-14,0,497},{14,0,498},{14,0,499},{14,0,500},{14,0,501},{14,0,502},{14,0,503},{14,
+-0,504},{14,0,506},{14,0,507},{14,0,508},{14,0,509},{14,0,510},{14,0,511},{16,0,
+-113},{16,0,114},{16,0,115},{16,0,117},{16,0,118},{16,0,119},{16,0,121},{16,0,122
+-},{16,0,123},{16,0,124},{16,0,125},{16,0,126},{16,0,127},{18,0,242},{18,0,243},{
+-18,0,244},{18,0,245},{18,0,248},{18,0,249},{18,0,250},{18,0,251},{18,0,252},{18,
+-0,253},{18,0,254},{18,0,255},{20,0,125},{20,0,126},{148,0,127},{7,11,1717},{7,11
+-,1769},{138,11,546},{7,11,1127},{7,11,1572},{10,11,297},{10,11,422},{11,11,764},
+-{11,11,810},{12,11,264},{13,11,102},{13,11,300},{13,11,484},{14,11,147},{14,11,
+-229},{17,11,71},{18,11,118},{147,11,120},{6,0,1148},{134,0,1586},{132,0,775},{
+-135,10,954},{133,11,864},{133,11,928},{138,11,189},{135,10,1958},{6,10,549},{8,
+-10,34},{8,10,283},{9,10,165},{138,10,475},{5,10,652},{5,10,701},{135,10,449},{
+-135,11,695},{4,10,655},{7,10,850},{17,10,75},{146,10,137},{140,11,682},{133,11,
+-523},{8,0,970},{136,10,670},{136,11,555},{7,11,76},{8,11,44},{9,11,884},{10,11,
+-580},{11,11,399},{11,11,894},{15,11,122},{18,11,144},{147,11,61},{6,10,159},{6,
+-10,364},{7,10,516},{7,10,1439},{137,10,518},{4,0,71},{5,0,376},{7,0,119},{138,0,
+-665},{141,10,151},{11,0,827},{14,0,34},{143,0,148},{133,11,518},{4,0,479},{135,
+-11,1787},{135,11,1852},{135,10,993},{7,0,607},{136,0,99},{134,0,1960},{132,0,793
+-},{4,0,41},{5,0,74},{7,0,1627},{11,0,871},{140,0,619},{7,0,94},{11,0,329},{11,0,
+-965},{12,0,241},{14,0,354},{15,0,22},{148,0,63},{7,10,501},{9,10,111},{10,10,141
+-},{11,10,332},{13,10,43},{13,10,429},{14,10,130},{14,10,415},{145,10,102},{9,0,
+-209},{137,0,300},{134,0,1497},{138,11,255},{4,11,934},{5,11,138},{136,11,610},{
+-133,0,98},{6,0,1316},{10,11,804},{138,11,832},{8,11,96},{9,11,36},{10,11,607},{
+-11,11,423},{11,11,442},{12,11,309},{14,11,199},{15,11,90},{145,11,110},{132,0,
+-463},{5,10,149},{136,10,233},{133,10,935},{4,11,652},{8,11,320},{9,11,13},{9,11,
+-398},{9,11,727},{10,11,75},{10,11,184},{10,11,230},{10,11,564},{10,11,569},{11,
+-11,973},{12,11,70},{12,11,189},{13,11,57},{13,11,257},{22,11,6},{150,11,16},{142
+-,0,291},{12,10,582},{146,10,131},{136,10,801},{133,0,984},{145,11,116},{4,11,692
+-},{133,11,321},{4,0,182},{6,0,205},{135,0,220},{4,0,42},{9,0,205},{9,0,786},{138
+-,0,659},{6,0,801},{11,11,130},{140,11,609},{132,0,635},{5,11,345},{135,11,1016},
+-{139,0,533},{132,0,371},{4,0,272},{135,0,836},{6,0,1282},{135,11,1100},{5,0,825}
+-,{134,0,1640},{135,11,1325},{133,11,673},{4,11,287},{133,11,1018},{135,0,357},{6
+-,0,467},{137,0,879},{7,0,317},{135,0,569},{6,0,924},{134,0,1588},{5,11,34},{5,10
+-,406},{10,11,724},{12,11,444},{13,11,354},{18,11,32},{23,11,24},{23,11,31},{152,
+-11,5},{6,0,1795},{6,0,1835},{6,0,1836},{6,0,1856},{8,0,844},{8,0,849},{8,0,854},
+-{8,0,870},{8,0,887},{10,0,852},{138,0,942},{6,10,69},{135,10,117},{137,0,307},{4
+-,0,944},{6,0,1799},{6,0,1825},{10,0,848},{10,0,875},{10,0,895},{10,0,899},{10,0,
+-902},{140,0,773},{11,0,43},{13,0,72},{141,0,142},{135,10,1830},{134,11,382},{4,
+-10,432},{135,10,824},{132,11,329},{7,0,1820},{139,11,124},{133,10,826},{133,0,
+-525},{132,11,906},{7,11,1940},{136,11,366},{138,11,10},{4,11,123},{4,11,649},{5,
+-11,605},{7,11,1509},{136,11,36},{6,0,110},{135,0,1681},{133,0,493},{133,11,767},
+-{4,0,174},{135,0,911},{138,11,786},{8,0,417},{137,0,782},{133,10,1000},{7,0,733}
+-,{137,0,583},{4,10,297},{6,10,529},{7,10,152},{7,10,713},{7,10,1845},{8,10,710},
+-{8,10,717},{12,10,639},{140,10,685},{4,0,32},{5,0,215},{6,0,269},{7,0,1782},{7,0
+-,1892},{10,0,16},{11,0,822},{11,0,954},{141,0,481},{4,11,273},{5,11,658},{133,11
+-,995},{136,0,477},{134,11,72},{135,11,1345},{5,0,308},{7,0,1088},{4,10,520},{135
+-,10,575},{133,11,589},{5,0,126},{8,0,297},{9,0,366},{140,0,374},{7,0,1551},{139,
+-0,361},{5,11,117},{6,11,514},{6,11,541},{7,11,1164},{7,11,1436},{8,11,220},{8,11
+-,648},{10,11,688},{139,11,560},{133,11,686},{4,0,946},{6,0,1807},{8,0,871},{10,0
+-,854},{10,0,870},{10,0,888},{10,0,897},{10,0,920},{12,0,722},{12,0,761},{12,0,
+-763},{12,0,764},{14,0,454},{14,0,465},{16,0,107},{18,0,167},{18,0,168},{146,0,
+-172},{132,0,175},{135,0,1307},{132,0,685},{135,11,1834},{133,0,797},{6,0,745},{6
+-,0,858},{134,0,963},{133,0,565},{5,10,397},{6,10,154},{7,11,196},{7,10,676},{8,
+-10,443},{8,10,609},{9,10,24},{9,10,325},{10,10,35},{10,11,765},{11,11,347},{11,
+-10,535},{11,11,552},{11,11,576},{11,10,672},{11,11,790},{11,10,1018},{12,11,263}
+-,{12,10,637},{13,11,246},{13,11,270},{13,11,395},{14,11,74},{14,11,176},{14,11,
+-190},{14,11,398},{14,11,412},{15,11,32},{15,11,63},{16,10,30},{16,11,88},{147,11
+-,105},{13,11,84},{141,11,122},{4,0,252},{7,0,1068},{10,0,434},{11,0,228},{11,0,
+-426},{13,0,231},{18,0,106},{148,0,87},{137,0,826},{4,11,589},{139,11,282},{5,11,
+-381},{135,11,1792},{132,0,791},{5,0,231},{10,0,509},{133,10,981},{7,0,601},{9,0,
+-277},{9,0,674},{10,0,178},{10,0,418},{10,0,571},{11,0,531},{12,0,113},{12,0,475}
+-,{13,0,99},{142,0,428},{4,10,56},{7,11,616},{7,10,1791},{8,10,607},{8,10,651},{
+-10,11,413},{11,10,465},{11,10,835},{12,10,337},{141,10,480},{7,0,1591},{144,0,43
+-},{9,10,158},{138,10,411},{135,0,1683},{8,0,289},{11,0,45},{12,0,278},{140,0,537
+-},{6,11,120},{7,11,1188},{7,11,1710},{8,11,286},{9,11,667},{11,11,592},{139,11,
+-730},{136,10,617},{135,0,1120},{135,11,1146},{139,10,563},{4,11,352},{4,10,369},
+-{135,11,687},{143,11,38},{4,0,399},{5,0,119},{5,0,494},{7,0,751},{9,0,556},{14,
+-11,179},{15,11,151},{150,11,11},{4,11,192},{5,11,49},{6,11,200},{6,11,293},{6,11
+-,1696},{135,11,488},{4,0,398},{133,0,660},{7,0,1030},{134,10,622},{135,11,595},{
+-141,0,168},{132,11,147},{7,0,973},{10,10,624},{142,10,279},{132,10,363},{132,0,
+-642},{133,11,934},{134,0,1615},{7,11,505},{135,11,523},{7,0,594},{7,0,851},{7,0,
+-1858},{9,0,411},{9,0,574},{9,0,666},{9,0,737},{10,0,346},{10,0,712},{11,0,246},{
+-11,0,432},{11,0,517},{11,0,647},{11,0,679},{11,0,727},{12,0,304},{12,0,305},{12,
+-0,323},{12,0,483},{12,0,572},{12,0,593},{12,0,602},{13,0,95},{13,0,101},{13,0,
+-171},{13,0,315},{13,0,378},{13,0,425},{13,0,475},{14,0,63},{14,0,380},{14,0,384}
+-,{15,0,133},{18,0,112},{148,0,72},{135,0,1093},{132,0,679},{8,0,913},{10,0,903},
+-{10,0,915},{12,0,648},{12,0,649},{14,0,455},{16,0,112},{138,11,438},{137,0,203},
+-{134,10,292},{134,0,1492},{7,0,1374},{8,0,540},{5,10,177},{6,10,616},{7,10,827},
+-{9,10,525},{138,10,656},{135,0,1486},{9,0,714},{138,10,31},{136,0,825},{134,0,
+-1511},{132,11,637},{134,0,952},{4,10,161},{133,10,631},{5,0,143},{5,0,769},{6,0,
+-1760},{7,0,682},{7,0,1992},{136,0,736},{132,0,700},{134,0,1540},{132,11,777},{9,
+-11,867},{138,11,837},{7,0,1557},{135,10,1684},{133,0,860},{6,0,422},{7,0,0},{7,0
+-,1544},{9,0,605},{11,0,990},{12,0,235},{12,0,453},{13,0,47},{13,0,266},{9,10,469
+-},{9,10,709},{12,10,512},{14,10,65},{145,10,12},{11,0,807},{10,10,229},{11,10,73
+-},{139,10,376},{6,11,170},{7,11,1080},{8,11,395},{8,11,487},{11,11,125},{141,11,
+-147},{5,0,515},{137,0,131},{7,0,1605},{11,0,962},{146,0,139},{132,0,646},{4,0,
+-396},{7,0,728},{9,0,117},{13,0,202},{148,0,51},{6,0,121},{6,0,124},{6,0,357},{7,
+-0,1138},{7,0,1295},{8,0,162},{8,0,508},{11,0,655},{4,11,535},{6,10,558},{7,10,
+-651},{8,11,618},{9,10,0},{10,10,34},{139,10,1008},{135,11,1245},{138,0,357},{150
+-,11,23},{133,0,237},{135,0,1784},{7,10,1832},{138,10,374},{132,0,713},{132,11,46
+-},{6,0,1536},{10,0,348},{5,11,811},{6,11,1679},{6,11,1714},{135,11,2032},{11,11,
+-182},{142,11,195},{6,0,523},{7,0,738},{7,10,771},{7,10,1731},{9,10,405},{138,10,
+-421},{7,11,1458},{9,11,407},{139,11,15},{6,11,34},{7,11,69},{7,11,640},{7,11,
+-1089},{8,11,708},{8,11,721},{9,11,363},{9,11,643},{10,11,628},{148,11,98},{133,0
+-,434},{135,0,1877},{7,0,571},{138,0,366},{5,10,881},{133,10,885},{9,0,513},{10,0
+-,25},{10,0,39},{12,0,122},{140,0,187},{132,0,580},{5,10,142},{134,10,546},{132,
+-11,462},{137,0,873},{5,10,466},{11,10,571},{12,10,198},{13,10,283},{14,10,186},{
+-15,10,21},{143,10,103},{7,0,171},{4,10,185},{5,10,257},{5,10,839},{5,10,936},{9,
+-10,399},{10,10,258},{10,10,395},{10,10,734},{11,10,1014},{12,10,23},{13,10,350},
+-{14,10,150},{147,10,6},{134,0,625},{7,0,107},{7,0,838},{8,0,550},{138,0,401},{5,
+-11,73},{6,11,23},{134,11,338},{4,0,943},{6,0,1850},{12,0,713},{142,0,434},{11,0,
+-588},{11,0,864},{11,0,936},{11,0,968},{12,0,73},{12,0,343},{12,0,394},{13,0,275}
+-,{14,0,257},{15,0,160},{7,10,404},{7,10,1377},{7,10,1430},{7,10,2017},{8,10,149}
+-,{8,10,239},{8,10,512},{8,10,793},{8,10,818},{9,10,474},{9,10,595},{10,10,122},{
+-10,10,565},{10,10,649},{10,10,783},{11,10,239},{11,10,295},{11,10,447},{11,10,
+-528},{11,10,639},{11,10,800},{12,10,25},{12,10,157},{12,10,316},{12,10,390},{12,
+-10,391},{12,10,395},{12,10,478},{12,10,503},{12,10,592},{12,10,680},{13,10,50},{
+-13,10,53},{13,10,132},{13,10,198},{13,10,322},{13,10,415},{13,10,511},{14,10,71}
+-,{14,10,395},{15,10,71},{15,10,136},{17,10,123},{18,10,93},{147,10,58},{133,0,
+-768},{11,0,103},{142,0,0},{136,10,712},{132,0,799},{132,0,894},{7,11,725},{8,11,
+-498},{139,11,268},{135,11,1798},{135,11,773},{141,11,360},{4,10,377},{152,10,13}
+-,{135,0,1673},{132,11,583},{134,0,1052},{133,11,220},{140,11,69},{132,11,544},{4
+-,10,180},{135,10,1906},{134,0,272},{4,0,441},{134,0,1421},{4,0,9},{5,0,128},{7,0
+-,368},{11,0,480},{148,0,3},{5,11,176},{6,11,437},{6,11,564},{11,11,181},{141,11,
+-183},{132,10,491},{7,0,1182},{141,11,67},{6,0,1346},{4,10,171},{138,10,234},{4,
+-10,586},{7,10,1186},{138,10,631},{136,0,682},{134,0,1004},{15,0,24},{143,11,24},
+-{134,0,968},{4,0,2},{6,0,742},{6,0,793},{7,0,545},{7,0,894},{9,10,931},{10,10,
+-334},{148,10,71},{136,11,600},{133,10,765},{9,0,769},{140,0,185},{4,11,790},{5,
+-11,273},{134,11,394},{7,0,474},{137,0,578},{4,11,135},{6,11,127},{7,11,1185},{7,
+-11,1511},{8,11,613},{11,11,5},{12,11,133},{12,11,495},{12,11,586},{14,11,385},{
+-15,11,118},{17,11,20},{146,11,98},{133,10,424},{5,0,530},{142,0,113},{6,11,230},
+-{7,11,961},{7,11,1085},{136,11,462},{7,11,1954},{137,11,636},{136,10,714},{149,
+-11,6},{135,10,685},{9,10,420},{10,10,269},{10,10,285},{10,10,576},{11,10,397},{
+-13,10,175},{145,10,90},{132,10,429},{5,0,556},{5,11,162},{136,11,68},{132,11,654
+-},{4,11,156},{7,11,998},{7,11,1045},{7,11,1860},{9,11,48},{9,11,692},{11,11,419}
+-,{139,11,602},{6,0,1317},{8,0,16},{9,0,825},{12,0,568},{7,11,1276},{8,11,474},{
+-137,11,652},{18,0,97},{7,10,18},{7,10,699},{7,10,1966},{8,10,752},{9,10,273},{9,
+-10,412},{9,10,703},{10,10,71},{10,10,427},{138,10,508},{10,0,703},{7,11,1454},{
+-138,11,703},{4,10,53},{5,10,186},{135,10,752},{134,0,892},{134,0,1571},{8,10,575
+-},{10,10,289},{139,10,319},{6,0,186},{137,0,426},{134,0,1101},{132,10,675},{132,
+-0,585},{6,0,1870},{137,0,937},{152,11,10},{9,11,197},{10,11,300},{12,11,473},{13
+-,11,90},{141,11,405},{4,0,93},{5,0,252},{6,0,229},{7,0,291},{9,0,550},{139,0,644
+-},{137,0,749},{9,0,162},{6,10,209},{8,10,468},{9,10,210},{11,10,36},{12,10,28},{
+-12,10,630},{13,10,21},{13,10,349},{14,10,7},{145,10,13},{132,0,381},{132,11,606}
+-,{4,10,342},{135,10,1179},{7,11,1587},{7,11,1707},{10,11,528},{139,11,504},{12,
+-11,39},{13,11,265},{141,11,439},{4,10,928},{133,10,910},{7,10,1838},{7,11,1978},
+-{136,11,676},{6,0,762},{6,0,796},{134,0,956},{4,10,318},{4,10,496},{7,10,856},{
+-139,10,654},{137,11,242},{4,11,361},{133,11,315},{132,11,461},{132,11,472},{132,
+-0,857},{5,0,21},{6,0,77},{6,0,157},{7,0,974},{7,0,1301},{7,0,1339},{7,0,1490},{7
+-,0,1873},{9,0,628},{7,10,915},{8,10,247},{147,10,0},{4,10,202},{5,10,382},{6,10,
+-454},{7,10,936},{7,10,1803},{8,10,758},{9,10,375},{9,10,895},{10,10,743},{10,10,
+-792},{11,10,978},{11,10,1012},{142,10,109},{7,11,617},{10,11,498},{11,11,501},{
+-12,11,16},{140,11,150},{7,10,1150},{7,10,1425},{7,10,1453},{10,11,747},{140,10,
+-513},{133,11,155},{11,0,919},{141,0,409},{138,10,791},{10,0,633},{139,11,729},{7
+-,11,163},{8,11,319},{9,11,402},{10,11,24},{10,11,681},{11,11,200},{11,11,567},{
+-12,11,253},{12,11,410},{142,11,219},{5,11,475},{7,11,1780},{9,11,230},{11,11,297
+-},{11,11,558},{14,11,322},{147,11,76},{7,0,332},{6,10,445},{137,10,909},{135,11,
+-1956},{136,11,274},{134,10,578},{135,0,1489},{135,11,1848},{5,11,944},{134,11,
+-1769},{132,11,144},{136,10,766},{4,0,832},{135,10,541},{8,0,398},{9,0,681},{139,
+-0,632},{136,0,645},{9,0,791},{10,0,93},{16,0,13},{17,0,23},{18,0,135},{19,0,12},
+-{20,0,1},{20,0,12},{148,0,14},{6,11,247},{137,11,555},{134,0,20},{132,0,800},{
+-135,0,1841},{139,10,983},{137,10,768},{132,10,584},{141,11,51},{6,0,1993},{4,11,
+-620},{138,11,280},{136,0,769},{11,0,290},{11,0,665},{7,11,1810},{11,11,866},{12,
+-11,103},{13,11,495},{17,11,67},{147,11,74},{134,0,1426},{139,0,60},{4,10,326},{
+-135,10,1770},{7,0,1874},{9,0,641},{132,10,226},{6,0,644},{5,10,426},{8,10,30},{9
+-,10,2},{11,10,549},{147,10,122},{5,11,428},{138,11,442},{135,11,1871},{135,0,
+-1757},{147,10,117},{135,0,937},{135,0,1652},{6,0,654},{134,0,1476},{133,11,99},{
+-135,0,527},{132,10,345},{4,10,385},{4,11,397},{7,10,265},{135,10,587},{4,0,579},
+-{5,0,226},{5,0,323},{135,0,960},{134,0,1486},{8,11,502},{144,11,9},{4,10,347},{5
+-,10,423},{5,10,996},{135,10,1329},{7,11,727},{146,11,73},{4,11,485},{7,11,353},{
+-7,10,1259},{7,11,1523},{9,10,125},{139,10,65},{6,0,325},{5,10,136},{6,11,366},{7
+-,11,1384},{7,11,1601},{136,10,644},{138,11,160},{6,0,1345},{137,11,282},{18,0,91
+-},{147,0,70},{136,0,404},{4,11,157},{133,11,471},{133,0,973},{6,0,135},{135,0,
+-1176},{8,11,116},{11,11,551},{142,11,159},{4,0,549},{4,10,433},{133,10,719},{136
+-,0,976},{5,11,160},{7,11,363},{7,11,589},{10,11,170},{141,11,55},{144,0,21},{144
+-,0,51},{135,0,314},{135,10,1363},{4,11,108},{7,11,405},{10,11,491},{139,11,498},
+-{146,0,4},{4,10,555},{8,10,536},{10,10,288},{139,10,1005},{135,11,1005},{6,0,281
+-},{7,0,6},{8,0,282},{8,0,480},{8,0,499},{9,0,198},{10,0,143},{10,0,169},{10,0,
+-211},{10,0,417},{10,0,574},{11,0,147},{11,0,395},{12,0,75},{12,0,407},{12,0,608}
+-,{13,0,500},{142,0,251},{6,0,1093},{6,0,1405},{9,10,370},{138,10,90},{4,11,926},
+-{133,11,983},{135,0,1776},{134,0,1528},{132,0,419},{132,11,538},{6,11,294},{7,11
+-,1267},{136,11,624},{135,11,1772},{138,11,301},{4,10,257},{135,10,2031},{4,0,138
+-},{7,0,1012},{7,0,1280},{9,0,76},{135,10,1768},{132,11,757},{5,0,29},{140,0,638}
+-,{7,11,655},{135,11,1844},{7,0,1418},{6,11,257},{135,11,1522},{8,11,469},{138,11
+-,47},{142,11,278},{6,10,83},{6,10,1733},{135,10,1389},{11,11,204},{11,11,243},{
+-140,11,293},{135,11,1875},{6,0,1710},{135,0,2038},{137,11,299},{4,0,17},{5,0,23}
+-,{7,0,995},{11,0,383},{11,0,437},{12,0,460},{140,0,532},{133,0,862},{137,10,696}
+-,{6,0,592},{138,0,946},{138,11,599},{7,10,1718},{9,10,95},{9,10,274},{10,10,279}
+-,{10,10,317},{10,10,420},{11,10,303},{11,10,808},{12,10,134},{12,10,367},{13,10,
+-149},{13,10,347},{14,10,349},{14,10,406},{18,10,22},{18,10,89},{18,10,122},{147,
+-10,47},{8,0,70},{12,0,171},{141,0,272},{133,10,26},{132,10,550},{137,0,812},{10,
+-0,233},{139,0,76},{134,0,988},{134,0,442},{136,10,822},{7,0,896},{4,10,902},{5,
+-10,809},{134,10,122},{5,11,150},{7,11,106},{8,11,603},{9,11,593},{9,11,634},{10,
+-11,44},{10,11,173},{11,11,462},{11,11,515},{13,11,216},{13,11,288},{142,11,400},
+-{136,0,483},{135,10,262},{6,0,1709},{133,10,620},{4,10,34},{5,10,574},{7,10,279}
+-,{7,10,1624},{136,10,601},{137,10,170},{147,0,119},{12,11,108},{141,11,291},{11,
+-0,69},{12,0,105},{12,0,117},{13,0,213},{14,0,13},{14,0,62},{14,0,177},{14,0,421}
+-,{15,0,19},{146,0,141},{137,0,309},{11,11,278},{142,11,73},{7,0,608},{7,0,976},{
+-9,0,146},{10,0,206},{10,0,596},{13,0,218},{142,0,153},{133,10,332},{6,10,261},{8
+-,10,182},{139,10,943},{4,11,493},{144,11,55},{134,10,1721},{132,0,768},{4,10,933
+-},{133,10,880},{7,11,555},{7,11,1316},{7,11,1412},{7,11,1839},{9,11,192},{9,11,
+-589},{11,11,241},{11,11,676},{11,11,811},{11,11,891},{12,11,140},{12,11,346},{12
+-,11,479},{13,11,30},{13,11,49},{13,11,381},{14,11,188},{15,11,150},{16,11,76},{
+-18,11,30},{148,11,52},{4,0,518},{135,0,1136},{6,11,568},{7,11,112},{7,11,1804},{
+-8,11,362},{8,11,410},{8,11,830},{9,11,514},{11,11,649},{142,11,157},{135,11,673}
+-,{8,0,689},{137,0,863},{4,0,18},{7,0,145},{7,0,444},{7,0,1278},{8,0,49},{8,0,400
+-},{9,0,71},{9,0,250},{10,0,459},{12,0,160},{16,0,24},{132,11,625},{140,0,1020},{
+-4,0,997},{6,0,1946},{6,0,1984},{134,0,1998},{6,11,16},{6,11,158},{7,11,43},{7,11
+-,129},{7,11,181},{8,11,276},{8,11,377},{10,11,523},{11,11,816},{12,11,455},{13,
+-11,303},{142,11,135},{133,10,812},{134,0,658},{4,11,1},{7,11,1143},{7,11,1463},{
+-8,11,61},{9,11,207},{9,11,390},{9,11,467},{139,11,836},{150,11,26},{140,0,106},{
+-6,0,1827},{10,0,931},{18,0,166},{20,0,114},{4,10,137},{7,10,1178},{7,11,1319},{
+-135,10,1520},{133,0,1010},{4,11,723},{5,11,895},{7,11,1031},{8,11,199},{8,11,340
+-},{9,11,153},{9,11,215},{10,11,21},{10,11,59},{10,11,80},{10,11,224},{11,11,229}
+-,{11,11,652},{12,11,192},{13,11,146},{142,11,91},{132,11,295},{6,11,619},{7,11,
+-898},{7,11,1092},{8,11,485},{18,11,28},{147,11,116},{137,11,51},{6,10,1661},{7,
+-10,1975},{7,10,2009},{135,10,2011},{5,11,309},{140,11,211},{5,0,87},{7,0,313},{7
+-,0,1103},{10,0,208},{10,0,582},{11,0,389},{11,0,813},{12,0,385},{13,0,286},{14,0
+-,124},{146,0,108},{5,11,125},{8,11,77},{138,11,15},{132,0,267},{133,0,703},{137,
+-11,155},{133,11,439},{11,11,164},{140,11,76},{9,0,496},{5,10,89},{7,10,1915},{9,
+-10,185},{9,10,235},{10,10,64},{10,10,270},{10,10,403},{10,10,469},{10,10,529},{
+-10,10,590},{11,10,140},{11,10,860},{13,10,1},{13,10,422},{14,10,341},{14,10,364}
+-,{17,10,93},{18,10,113},{19,10,97},{147,10,113},{133,10,695},{135,0,1121},{5,10,
+-6},{6,10,183},{7,10,680},{7,10,978},{7,10,1013},{7,10,1055},{12,10,230},{13,10,
+-172},{146,10,29},{4,11,8},{7,11,1152},{7,11,1153},{7,11,1715},{9,11,374},{10,11,
+-478},{139,11,648},{135,11,1099},{6,10,29},{139,10,63},{4,0,561},{10,0,249},{139,
+-0,209},{132,0,760},{7,11,799},{138,11,511},{136,11,87},{9,0,154},{140,0,485},{
+-136,0,255},{132,0,323},{140,0,419},{132,10,311},{134,10,1740},{4,0,368},{135,0,
+-641},{7,10,170},{8,10,90},{8,10,177},{8,10,415},{11,10,714},{142,10,281},{4,11,
+-69},{5,11,122},{9,11,656},{138,11,464},{5,11,849},{134,11,1633},{8,0,522},{142,0
+-,328},{11,10,91},{13,10,129},{15,10,101},{145,10,125},{7,0,562},{8,0,551},{4,10,
+-494},{6,10,74},{7,10,44},{11,11,499},{12,10,17},{15,10,5},{148,10,11},{4,10,276}
+-,{133,10,296},{9,0,92},{147,0,91},{4,10,7},{5,10,90},{5,10,158},{6,10,542},{7,10
+-,221},{7,10,1574},{9,10,490},{10,10,540},{11,10,443},{139,10,757},{6,0,525},{6,0
+-,1976},{8,0,806},{9,0,876},{140,0,284},{5,11,859},{7,10,588},{7,11,1160},{8,11,
+-107},{9,10,175},{9,11,291},{9,11,439},{10,10,530},{10,11,663},{11,11,609},{140,
+-11,197},{7,11,168},{13,11,196},{141,11,237},{139,0,958},{133,0,594},{135,10,580}
+-,{7,10,88},{136,10,627},{6,0,479},{6,0,562},{7,0,1060},{13,0,6},{5,10,872},{6,10
+-,57},{7,10,471},{9,10,447},{137,10,454},{136,11,413},{145,11,19},{4,11,117},{6,
+-11,372},{7,11,1905},{142,11,323},{4,11,722},{139,11,471},{17,0,61},{5,10,31},{
+-134,10,614},{8,10,330},{140,10,477},{7,10,1200},{138,10,460},{6,10,424},{135,10,
+-1866},{6,0,1641},{136,0,820},{6,0,1556},{134,0,1618},{9,11,5},{12,11,216},{12,11
+-,294},{12,11,298},{12,11,400},{12,11,518},{13,11,229},{143,11,139},{15,11,155},{
+-144,11,79},{4,0,302},{135,0,1766},{5,10,13},{134,10,142},{6,0,148},{7,0,1313},{7
+-,10,116},{8,10,322},{8,10,755},{9,10,548},{10,10,714},{11,10,884},{141,10,324},{
+-137,0,676},{9,11,88},{139,11,270},{5,11,12},{7,11,375},{137,11,438},{134,0,1674}
+-,{7,10,1472},{135,10,1554},{11,0,178},{7,10,1071},{7,10,1541},{7,10,1767},{7,10,
+-1806},{11,10,162},{11,10,242},{12,10,605},{15,10,26},{144,10,44},{6,0,389},{7,0,
+-149},{9,0,142},{138,0,94},{140,11,71},{145,10,115},{6,0,8},{7,0,1881},{8,0,91},{
+-11,11,966},{12,11,287},{13,11,342},{13,11,402},{15,11,110},{143,11,163},{4,11,
+-258},{136,11,639},{6,11,22},{7,11,903},{138,11,577},{133,11,681},{135,10,1111},{
+-135,11,1286},{9,0,112},{8,10,1},{138,10,326},{5,10,488},{6,10,527},{7,10,489},{7
+-,10,1636},{8,10,121},{8,10,144},{8,10,359},{9,10,193},{9,10,241},{9,10,336},{9,
+-10,882},{11,10,266},{11,10,372},{11,10,944},{12,10,401},{140,10,641},{4,11,664},
+-{133,11,804},{6,0,747},{134,0,1015},{135,0,1746},{9,10,31},{10,10,244},{10,10,
+-699},{12,10,149},{141,10,497},{133,10,377},{135,0,24},{6,0,1352},{5,11,32},{145,
+-10,101},{7,0,1530},{10,0,158},{13,0,13},{13,0,137},{13,0,258},{14,0,111},{14,0,
+-225},{14,0,253},{14,0,304},{14,0,339},{14,0,417},{146,0,33},{4,0,503},{135,0,
+-1661},{5,0,130},{6,0,845},{7,0,1314},{9,0,610},{10,0,718},{11,0,601},{11,0,819},
+-{11,0,946},{140,0,536},{10,0,149},{11,0,280},{142,0,336},{134,0,1401},{135,0,
+-1946},{8,0,663},{144,0,8},{134,0,1607},{135,10,2023},{4,11,289},{7,11,629},{7,11
+-,1698},{7,11,1711},{140,11,215},{6,11,450},{136,11,109},{10,0,882},{10,0,883},{
+-10,0,914},{138,0,928},{133,10,843},{136,11,705},{132,10,554},{133,10,536},{5,0,
+-417},{9,10,79},{11,10,625},{145,10,7},{7,11,1238},{142,11,37},{4,0,392},{135,0,
+-1597},{5,0,433},{9,0,633},{11,0,629},{132,10,424},{7,10,336},{136,10,785},{134,
+-11,355},{6,0,234},{7,0,769},{9,0,18},{138,0,358},{4,10,896},{134,10,1777},{138,
+-11,323},{7,0,140},{7,0,1950},{8,0,680},{11,0,817},{147,0,88},{7,0,1222},{138,0,
+-386},{139,11,908},{11,0,249},{12,0,313},{16,0,66},{145,0,26},{134,0,5},{7,10,750
+-},{9,10,223},{11,10,27},{11,10,466},{12,10,624},{14,10,265},{146,10,61},{134,11,
+-26},{134,0,1216},{5,0,963},{134,0,1773},{4,11,414},{5,11,467},{9,11,654},{10,11,
+-451},{12,11,59},{141,11,375},{135,11,17},{4,10,603},{133,10,661},{4,10,11},{6,10
+-,128},{7,10,231},{7,10,1533},{138,10,725},{135,11,955},{7,0,180},{8,0,509},{136,
+-0,792},{132,10,476},{132,0,1002},{133,11,538},{135,10,1807},{132,0,931},{7,0,943
+-},{11,0,614},{140,0,747},{135,0,1837},{9,10,20},{10,10,324},{10,10,807},{139,10,
+-488},{134,0,641},{6,11,280},{10,11,502},{11,11,344},{140,11,38},{5,11,45},{7,11,
+-1161},{11,11,448},{11,11,880},{13,11,139},{13,11,407},{15,11,16},{17,11,95},{18,
+-11,66},{18,11,88},{18,11,123},{149,11,7},{9,0,280},{138,0,134},{22,0,22},{23,0,5
+-},{151,0,29},{136,11,777},{4,0,90},{5,0,545},{7,0,754},{9,0,186},{10,0,72},{10,0
+-,782},{11,0,577},{11,0,610},{11,0,960},{12,0,354},{12,0,362},{12,0,595},{4,11,
+-410},{135,11,521},{135,11,1778},{5,10,112},{6,10,103},{134,10,150},{138,10,356},
+-{132,0,742},{7,0,151},{9,0,329},{139,0,254},{8,0,853},{8,0,881},{8,0,911},{8,0,
+-912},{10,0,872},{12,0,741},{12,0,742},{152,0,18},{4,11,573},{136,11,655},{6,0,
+-921},{134,0,934},{9,0,187},{10,0,36},{11,0,1016},{17,0,44},{146,0,64},{7,0,833},
+-{136,0,517},{4,0,506},{5,0,295},{135,0,1680},{4,10,708},{8,10,15},{9,10,50},{9,
+-10,386},{11,10,18},{11,10,529},{140,10,228},{7,0,251},{7,0,1701},{8,0,436},{4,10
+-,563},{7,10,592},{7,10,637},{7,10,770},{8,10,463},{9,10,60},{9,10,335},{9,10,904
+-},{10,10,73},{11,10,434},{12,10,585},{13,10,331},{18,10,110},{148,10,60},{132,10
+-,502},{136,0,584},{6,10,347},{138,10,161},{7,0,987},{9,0,688},{10,0,522},{11,0,
+-788},{12,0,137},{12,0,566},{14,0,9},{14,0,24},{14,0,64},{7,11,899},{142,11,325},
+-{4,0,214},{5,0,500},{5,10,102},{6,10,284},{7,10,1079},{7,10,1423},{7,10,1702},{8
+-,10,470},{9,10,554},{9,10,723},{139,10,333},{7,10,246},{135,10,840},{6,10,10},{8
+-,10,571},{9,10,739},{143,10,91},{133,10,626},{146,0,195},{134,0,1775},{7,0,389},
+-{7,0,700},{7,0,940},{8,0,514},{9,0,116},{9,0,535},{10,0,118},{11,0,107},{11,0,
+-148},{11,0,922},{12,0,254},{12,0,421},{142,0,238},{5,10,18},{6,10,526},{13,10,24
+-},{13,10,110},{19,10,5},{147,10,44},{132,0,743},{11,0,292},{4,10,309},{5,10,462}
+-,{7,10,970},{135,10,1097},{22,10,30},{150,10,33},{139,11,338},{135,11,1598},{7,0
+-,1283},{9,0,227},{11,0,325},{11,0,408},{14,0,180},{146,0,47},{4,0,953},{6,0,1805
+-},{6,0,1814},{6,0,1862},{140,0,774},{6,11,611},{135,11,1733},{135,11,1464},{5,0,
+-81},{7,0,146},{7,0,1342},{8,0,53},{8,0,561},{8,0,694},{8,0,754},{9,0,115},{9,0,
+-179},{9,0,894},{10,0,462},{10,0,813},{11,0,230},{11,0,657},{11,0,699},{11,0,748}
+-,{12,0,119},{12,0,200},{12,0,283},{142,0,273},{5,0,408},{6,0,789},{6,0,877},{6,0
+-,1253},{6,0,1413},{137,0,747},{134,10,1704},{135,11,663},{6,0,1910},{6,0,1915},{
+-6,0,1923},{9,0,913},{9,0,928},{9,0,950},{9,0,954},{9,0,978},{9,0,993},{12,0,812}
+-,{12,0,819},{12,0,831},{12,0,833},{12,0,838},{12,0,909},{12,0,928},{12,0,931},{
+-12,0,950},{15,0,186},{15,0,187},{15,0,195},{15,0,196},{15,0,209},{15,0,215},{15,
+-0,236},{15,0,241},{15,0,249},{15,0,253},{18,0,180},{18,0,221},{18,0,224},{18,0,
+-227},{18,0,229},{149,0,60},{7,0,1826},{135,0,1938},{11,0,490},{18,0,143},{5,10,
+-86},{7,10,743},{9,10,85},{10,10,281},{10,10,432},{12,10,251},{13,10,118},{142,10
+-,378},{5,10,524},{133,10,744},{141,11,442},{10,10,107},{140,10,436},{135,11,503}
+-,{134,0,1162},{132,10,927},{7,0,30},{8,0,86},{8,0,315},{8,0,700},{9,0,576},{9,0,
+-858},{10,0,414},{11,0,310},{11,0,888},{11,0,904},{12,0,361},{13,0,248},{13,0,371
+-},{14,0,142},{12,10,670},{146,10,94},{134,0,721},{4,11,113},{5,11,163},{5,11,735
+-},{7,11,1009},{7,10,1149},{9,11,9},{9,10,156},{9,11,771},{12,11,90},{13,11,138},
+-{13,11,410},{143,11,128},{138,0,839},{133,10,778},{137,0,617},{133,10,502},{8,10
+-,196},{10,10,283},{139,10,406},{6,0,428},{7,0,524},{8,0,169},{8,0,234},{9,0,480}
+-,{138,0,646},{133,10,855},{134,0,1648},{7,0,1205},{138,0,637},{7,0,1596},{4,11,
+-935},{133,11,823},{5,11,269},{7,11,434},{7,11,891},{8,11,339},{9,11,702},{11,11,
+-594},{11,11,718},{145,11,100},{7,11,878},{9,11,485},{141,11,264},{4,0,266},{8,0,
+-4},{9,0,39},{10,0,166},{11,0,918},{12,0,635},{20,0,10},{22,0,27},{22,0,43},{22,0
+-,52},{134,11,1713},{7,10,1400},{9,10,446},{138,10,45},{135,11,900},{132,0,862},{
+-134,0,1554},{135,11,1033},{19,0,16},{147,11,16},{135,11,1208},{7,0,157},{136,0,
+-279},{6,0,604},{136,0,391},{13,10,455},{15,10,99},{15,10,129},{144,10,68},{135,
+-10,172},{7,0,945},{11,0,713},{139,0,744},{4,0,973},{10,0,877},{10,0,937},{10,0,
+-938},{140,0,711},{139,0,1022},{132,10,568},{142,11,143},{4,0,567},{9,0,859},{132
+-,10,732},{7,0,1846},{136,0,628},{136,10,733},{133,0,762},{4,10,428},{135,10,1789
+-},{10,0,784},{13,0,191},{7,10,2015},{140,10,665},{133,0,298},{7,0,633},{7,0,905}
+-,{7,0,909},{7,0,1538},{9,0,767},{140,0,636},{138,10,806},{132,0,795},{139,0,301}
+-,{135,0,1970},{5,11,625},{135,11,1617},{135,11,275},{7,11,37},{8,11,425},{8,11,
+-693},{9,11,720},{10,11,380},{10,11,638},{11,11,273},{11,11,307},{11,11,473},{12,
+-11,61},{143,11,43},{135,11,198},{134,0,1236},{7,0,369},{12,0,644},{12,0,645},{
+-144,0,90},{19,0,15},{149,0,27},{6,0,71},{7,0,845},{8,0,160},{9,0,318},{6,10,1623
+-},{134,10,1681},{134,0,1447},{134,0,1255},{138,0,735},{8,0,76},{132,11,168},{6,
+-10,1748},{8,10,715},{9,10,802},{10,10,46},{10,10,819},{13,10,308},{14,10,351},{
+-14,10,363},{146,10,67},{135,11,91},{6,0,474},{4,10,63},{133,10,347},{133,10,749}
+-,{138,0,841},{133,10,366},{6,0,836},{132,11,225},{135,0,1622},{135,10,89},{140,0
+-,735},{134,0,1601},{138,11,145},{6,0,1390},{137,0,804},{142,0,394},{6,11,15},{7,
+-11,70},{10,11,240},{147,11,93},{6,0,96},{135,0,1426},{4,0,651},{133,0,289},{7,11
+-,956},{7,10,977},{7,11,1157},{7,11,1506},{7,11,1606},{7,11,1615},{7,11,1619},{7,
+-11,1736},{7,11,1775},{8,11,590},{9,11,324},{9,11,736},{9,11,774},{9,11,776},{9,
+-11,784},{10,11,567},{10,11,708},{11,11,518},{11,11,613},{11,11,695},{11,11,716},
+-{11,11,739},{11,11,770},{11,11,771},{11,11,848},{11,11,857},{11,11,931},{11,11,
+-947},{12,11,326},{12,11,387},{12,11,484},{12,11,528},{12,11,552},{12,11,613},{13
+-,11,189},{13,11,256},{13,11,340},{13,11,432},{13,11,436},{13,11,440},{13,11,454}
+-,{14,11,174},{14,11,220},{14,11,284},{14,11,390},{145,11,121},{7,0,688},{8,0,35}
+-,{9,0,511},{10,0,767},{147,0,118},{134,0,667},{4,0,513},{5,10,824},{133,10,941},
+-{7,10,440},{8,10,230},{139,10,106},{134,0,2034},{135,11,1399},{143,11,66},{135,
+-11,1529},{4,11,145},{6,11,176},{7,11,395},{9,11,562},{144,11,28},{132,11,501},{
+-132,0,704},{134,0,1524},{7,0,1078},{134,11,464},{6,11,509},{10,11,82},{20,11,91}
+-,{151,11,13},{4,0,720},{133,0,306},{133,0,431},{7,0,1196},{4,10,914},{5,10,800},
+-{133,10,852},{135,11,1189},{10,0,54},{141,10,115},{7,10,564},{142,10,168},{5,0,
+-464},{6,0,236},{7,0,696},{7,0,914},{7,0,1108},{7,0,1448},{9,0,15},{9,0,564},{10,
+-0,14},{12,0,565},{13,0,449},{14,0,53},{15,0,13},{16,0,64},{17,0,41},{4,10,918},{
+-133,10,876},{6,0,1418},{134,10,1764},{4,10,92},{133,10,274},{134,0,907},{4,11,
+-114},{8,10,501},{9,11,492},{13,11,462},{142,11,215},{4,11,77},{5,11,361},{6,11,
+-139},{6,11,401},{6,11,404},{7,11,413},{7,11,715},{7,11,1716},{11,11,279},{12,11,
+-179},{12,11,258},{13,11,244},{142,11,358},{6,0,1767},{12,0,194},{145,0,107},{134
+-,11,1717},{5,10,743},{142,11,329},{4,10,49},{7,10,280},{135,10,1633},{5,0,840},{
+-7,11,1061},{8,11,82},{11,11,250},{12,11,420},{141,11,184},{135,11,724},{134,0,
+-900},{136,10,47},{134,0,1436},{144,11,0},{6,0,675},{7,0,1008},{7,0,1560},{9,0,
+-642},{11,0,236},{14,0,193},{5,10,272},{5,10,908},{5,10,942},{8,10,197},{9,10,47}
+-,{11,10,538},{139,10,742},{4,0,68},{5,0,628},{5,0,634},{6,0,386},{7,0,794},{8,0,
+-273},{9,0,563},{10,0,105},{10,0,171},{11,0,94},{139,0,354},{135,10,1911},{137,10
+-,891},{4,0,95},{6,0,1297},{6,0,1604},{7,0,416},{139,0,830},{6,11,513},{135,11,
+-1052},{7,0,731},{13,0,20},{143,0,11},{137,11,899},{10,0,850},{140,0,697},{4,0,
+-662},{7,11,1417},{12,11,382},{17,11,48},{152,11,12},{133,0,736},{132,0,861},{4,
+-10,407},{132,10,560},{141,10,490},{6,11,545},{7,11,565},{7,11,1669},{10,11,114},
+-{11,11,642},{140,11,618},{6,0,871},{134,0,1000},{5,0,864},{10,0,648},{11,0,671},
+-{15,0,46},{133,11,5},{133,0,928},{11,0,90},{13,0,7},{4,10,475},{11,10,35},{13,10
+-,71},{13,10,177},{142,10,422},{136,0,332},{135,11,192},{134,0,1055},{136,11,763}
+-,{11,0,986},{140,0,682},{7,0,76},{8,0,44},{9,0,884},{10,0,580},{11,0,399},{11,0,
+-894},{143,0,122},{135,11,1237},{135,10,636},{11,0,300},{6,10,222},{7,10,1620},{8
+-,10,409},{137,10,693},{4,11,87},{5,11,250},{10,11,601},{13,11,298},{13,11,353},{
+-141,11,376},{5,0,518},{10,0,340},{11,0,175},{149,0,16},{140,0,771},{6,0,1108},{
+-137,0,831},{132,0,836},{135,0,1852},{4,0,957},{6,0,1804},{8,0,842},{8,0,843},{8,
+-0,851},{8,0,855},{140,0,767},{135,11,814},{4,11,57},{7,11,1195},{7,11,1438},{7,
+-11,1548},{7,11,1835},{7,11,1904},{9,11,757},{10,11,604},{139,11,519},{133,10,882
+-},{138,0,246},{4,0,934},{5,0,202},{8,0,610},{7,11,1897},{12,11,290},{13,11,80},{
+-13,11,437},{145,11,74},{8,0,96},{9,0,36},{10,0,607},{10,0,804},{10,0,832},{11,0,
+-423},{11,0,442},{12,0,309},{14,0,199},{15,0,90},{145,0,110},{132,10,426},{7,0,
+-654},{8,0,240},{6,10,58},{7,10,745},{7,10,1969},{8,10,675},{9,10,479},{9,10,731}
+-,{10,10,330},{10,10,593},{10,10,817},{11,10,32},{11,10,133},{11,10,221},{145,10,
+-68},{9,0,13},{9,0,398},{9,0,727},{10,0,75},{10,0,184},{10,0,230},{10,0,564},{10,
+-0,569},{11,0,973},{12,0,70},{12,0,189},{13,0,57},{141,0,257},{4,11,209},{135,11,
+-902},{7,0,391},{137,10,538},{134,0,403},{6,11,303},{7,11,335},{7,11,1437},{7,11,
+-1668},{8,11,553},{8,11,652},{8,11,656},{9,11,558},{11,11,743},{149,11,18},{132,
+-11,559},{11,0,75},{142,0,267},{6,0,815},{141,11,2},{141,0,366},{137,0,631},{133,
+-11,1017},{5,0,345},{135,0,1016},{133,11,709},{134,11,1745},{133,10,566},{7,0,952
+-},{6,10,48},{9,10,139},{10,10,399},{11,10,469},{12,10,634},{141,10,223},{133,0,
+-673},{9,0,850},{7,11,8},{136,11,206},{6,0,662},{149,0,35},{4,0,287},{133,0,1018}
+-,{6,10,114},{7,10,1224},{7,10,1556},{136,10,3},{8,10,576},{137,10,267},{4,0,884}
+-,{5,0,34},{10,0,724},{12,0,444},{13,0,354},{18,0,32},{23,0,24},{23,0,31},{152,0,
+-5},{133,10,933},{132,11,776},{138,0,151},{136,0,427},{134,0,382},{132,0,329},{9,
+-0,846},{10,0,827},{138,11,33},{9,0,279},{10,0,407},{14,0,84},{22,0,18},{135,11,
+-1297},{136,11,406},{132,0,906},{136,0,366},{134,0,843},{134,0,1443},{135,0,1372}
+-,{138,0,992},{4,0,123},{5,0,605},{7,0,1509},{136,0,36},{132,0,649},{8,11,175},{
+-10,11,168},{138,11,573},{133,0,767},{134,0,1018},{135,11,1305},{12,10,30},{13,10
+-,148},{14,10,87},{14,10,182},{16,10,42},{148,10,70},{134,11,607},{4,0,273},{5,0,
+-658},{133,0,995},{6,0,72},{139,11,174},{10,0,483},{12,0,368},{7,10,56},{7,10,
+-1989},{8,10,337},{8,10,738},{9,10,600},{13,10,447},{142,10,92},{5,11,784},{138,
+-10,666},{135,0,1345},{139,11,882},{134,0,1293},{133,0,589},{134,0,1988},{5,0,117
+-},{6,0,514},{6,0,541},{7,0,1164},{7,0,1436},{8,0,220},{8,0,648},{10,0,688},{139,
+-0,560},{136,0,379},{5,0,686},{7,10,866},{135,10,1163},{132,10,328},{9,11,14},{9,
+-11,441},{10,11,306},{139,11,9},{4,10,101},{135,10,1171},{5,10,833},{136,10,744},
+-{5,11,161},{7,11,839},{135,11,887},{7,0,196},{10,0,765},{11,0,347},{11,0,552},{
+-11,0,790},{12,0,263},{13,0,246},{13,0,270},{13,0,395},{14,0,176},{14,0,190},{14,
+-0,398},{14,0,412},{15,0,32},{15,0,63},{16,0,88},{147,0,105},{6,10,9},{6,10,397},
+-{7,10,53},{7,10,1742},{10,10,632},{11,10,828},{140,10,146},{5,0,381},{135,0,1792
+-},{134,0,1452},{135,11,429},{8,0,367},{10,0,760},{14,0,79},{20,0,17},{152,0,0},{
+-7,0,616},{138,0,413},{11,10,417},{12,10,223},{140,10,265},{7,11,1611},{13,11,14}
+-,{15,11,44},{19,11,13},{148,11,76},{135,0,1229},{6,0,120},{7,0,1188},{7,0,1710},
+-{8,0,286},{9,0,667},{11,0,592},{139,0,730},{135,11,1814},{135,0,1146},{4,10,186}
+-,{5,10,157},{8,10,168},{138,10,6},{4,0,352},{135,0,687},{4,0,192},{5,0,49},{6,0,
+-200},{6,0,293},{6,0,1696},{135,0,1151},{133,10,875},{5,10,773},{5,10,991},{6,10,
+-1635},{134,10,1788},{7,10,111},{136,10,581},{6,0,935},{134,0,1151},{134,0,1050},
+-{132,0,650},{132,0,147},{11,0,194},{12,0,62},{12,0,88},{11,11,194},{12,11,62},{
+-140,11,88},{6,0,339},{135,0,923},{134,10,1747},{7,11,643},{136,11,236},{133,0,
+-934},{7,10,1364},{7,10,1907},{141,10,158},{132,10,659},{4,10,404},{135,10,675},{
+-7,11,581},{9,11,644},{137,11,699},{13,0,211},{14,0,133},{14,0,204},{15,0,64},{15
+-,0,69},{15,0,114},{16,0,10},{19,0,23},{19,0,35},{19,0,39},{19,0,51},{19,0,71},{
+-19,0,75},{152,0,15},{133,10,391},{5,11,54},{135,11,1513},{7,0,222},{8,0,341},{5,
+-10,540},{134,10,1697},{134,10,78},{132,11,744},{136,0,293},{137,11,701},{7,11,
+-930},{10,11,402},{10,11,476},{13,11,452},{18,11,55},{147,11,104},{132,0,637},{
+-133,10,460},{8,11,50},{137,11,624},{132,11,572},{134,0,1159},{4,10,199},{139,10,
+-34},{134,0,847},{134,10,388},{6,11,43},{7,11,38},{8,11,248},{9,11,504},{138,11,
+-513},{9,0,683},{4,10,511},{6,10,608},{9,10,333},{10,10,602},{11,10,441},{11,10,
+-723},{11,10,976},{140,10,357},{9,0,867},{138,0,837},{6,0,944},{135,11,326},{135,
+-0,1809},{5,10,938},{7,11,783},{136,10,707},{133,11,766},{133,11,363},{6,0,170},{
+-7,0,1080},{8,0,395},{8,0,487},{141,0,147},{6,11,258},{140,11,409},{4,0,535},{8,0
+-,618},{5,11,249},{148,11,82},{6,0,1379},{149,11,15},{135,0,1625},{150,0,23},{5,
+-11,393},{6,11,378},{7,11,1981},{9,11,32},{9,11,591},{10,11,685},{10,11,741},{142
+-,11,382},{133,11,788},{7,11,1968},{10,11,19},{139,11,911},{7,11,1401},{135,11,
+-1476},{4,11,61},{5,11,58},{5,11,171},{5,11,635},{5,11,683},{5,11,700},{6,11,291}
+-,{6,11,566},{7,11,1650},{11,11,523},{12,11,273},{12,11,303},{15,11,39},{143,11,
+-111},{6,10,469},{7,10,1709},{138,10,515},{4,0,778},{134,11,589},{132,0,46},{5,0,
+-811},{6,0,1679},{6,0,1714},{135,0,2032},{7,0,1458},{9,0,407},{11,0,15},{12,0,651
+-},{149,0,37},{7,0,938},{132,10,500},{6,0,34},{7,0,69},{7,0,1089},{7,0,1281},{8,0
+-,708},{8,0,721},{9,0,363},{148,0,98},{10,11,231},{147,11,124},{7,11,726},{152,11
+-,9},{5,10,68},{134,10,383},{136,11,583},{4,11,917},{133,11,1005},{11,10,216},{
+-139,10,340},{135,11,1675},{8,0,441},{10,0,314},{143,0,3},{132,11,919},{4,10,337}
+-,{6,10,353},{7,10,1934},{8,10,488},{137,10,429},{7,0,889},{7,10,1795},{8,10,259}
+-,{9,10,135},{9,10,177},{9,10,860},{10,10,825},{11,10,115},{11,10,370},{11,10,405
+-},{11,10,604},{12,10,10},{12,10,667},{12,10,669},{13,10,76},{14,10,310},{15,10,
+-76},{15,10,147},{148,10,23},{4,10,15},{4,11,255},{5,10,22},{5,11,302},{6,11,132}
+-,{6,10,244},{7,10,40},{7,11,128},{7,10,200},{7,11,283},{7,10,906},{7,10,1199},{7
+-,11,1299},{9,10,616},{10,11,52},{10,11,514},{10,10,716},{11,10,635},{11,10,801},
+-{11,11,925},{12,10,458},{13,11,92},{142,11,309},{132,0,462},{137,11,173},{135,10
+-,1735},{8,0,525},{5,10,598},{7,10,791},{8,10,108},{137,10,123},{5,0,73},{6,0,23}
+-,{134,0,338},{132,0,676},{132,10,683},{7,0,725},{8,0,498},{139,0,268},{12,0,21},
+-{151,0,7},{135,0,773},{4,10,155},{135,10,1689},{4,0,164},{5,0,730},{5,10,151},{5
+-,10,741},{6,11,210},{7,10,498},{7,10,870},{7,10,1542},{12,10,213},{14,10,36},{14
+-,10,391},{17,10,111},{18,10,6},{18,10,46},{18,10,151},{19,10,36},{20,10,32},{20,
+-10,56},{20,10,69},{20,10,102},{21,10,4},{22,10,8},{22,10,10},{22,10,14},{150,10,
+-31},{4,10,624},{135,10,1752},{4,0,583},{9,0,936},{15,0,214},{18,0,199},{24,0,26}
+-,{134,11,588},{7,0,1462},{11,0,659},{4,11,284},{134,11,223},{133,0,220},{139,0,
+-803},{132,0,544},{4,10,492},{133,10,451},{16,0,98},{148,0,119},{4,11,218},{7,11,
+-526},{143,11,137},{135,10,835},{4,11,270},{5,11,192},{6,11,332},{7,11,1322},{13,
+-11,9},{13,10,70},{14,11,104},{142,11,311},{132,10,539},{140,11,661},{5,0,176},{6
+-,0,437},{6,0,564},{11,0,181},{141,0,183},{135,0,1192},{6,10,113},{135,10,436},{
+-136,10,718},{135,10,520},{135,0,1878},{140,11,196},{7,11,379},{8,11,481},{137,11
+-,377},{5,11,1003},{6,11,149},{137,11,746},{8,11,262},{9,11,627},{10,11,18},{11,
+-11,214},{11,11,404},{11,11,457},{11,11,780},{11,11,849},{11,11,913},{13,11,330},
+-{13,11,401},{142,11,200},{149,0,26},{136,11,304},{132,11,142},{135,0,944},{4,0,
+-790},{5,0,273},{134,0,394},{134,0,855},{4,0,135},{6,0,127},{7,0,1185},{7,0,1511}
+-,{8,0,613},{11,0,5},{12,0,336},{12,0,495},{12,0,586},{12,0,660},{12,0,668},{14,0
+-,385},{15,0,118},{17,0,20},{146,0,98},{6,0,230},{9,0,752},{18,0,109},{12,10,610}
+-,{13,10,431},{144,10,59},{7,0,1954},{135,11,925},{4,11,471},{5,11,51},{6,11,602}
+-,{8,11,484},{10,11,195},{140,11,159},{132,10,307},{136,11,688},{132,11,697},{7,
+-11,812},{7,11,1261},{7,11,1360},{9,11,632},{140,11,352},{5,0,162},{8,0,68},{133,
+-10,964},{4,0,654},{136,11,212},{4,0,156},{7,0,998},{7,0,1045},{7,0,1860},{9,0,48
+-},{9,0,692},{11,0,419},{139,0,602},{133,11,221},{4,11,373},{5,11,283},{6,11,480}
+-,{135,11,609},{142,11,216},{132,0,240},{6,11,192},{9,11,793},{145,11,55},{4,10,
+-75},{5,10,180},{6,10,500},{7,10,58},{7,10,710},{138,10,645},{4,11,132},{5,11,69}
+-,{5,10,649},{135,11,1242},{6,10,276},{7,10,282},{7,10,879},{7,10,924},{8,10,459}
+-,{9,10,599},{9,10,754},{11,10,574},{12,10,128},{12,10,494},{13,10,52},{13,10,301
+-},{15,10,30},{143,10,132},{132,10,200},{4,11,111},{135,11,302},{9,0,197},{10,0,
+-300},{12,0,473},{13,0,90},{141,0,405},{132,11,767},{6,11,42},{7,11,1416},{7,11,
+-1590},{7,11,2005},{8,11,131},{8,11,466},{9,11,672},{13,11,252},{148,11,103},{8,0
+-,958},{8,0,999},{10,0,963},{138,0,1001},{135,10,1621},{135,0,858},{4,0,606},{137
+-,11,444},{6,11,44},{136,11,368},{139,11,172},{4,11,570},{133,11,120},{139,11,624
+-},{7,0,1978},{8,0,676},{6,10,225},{137,10,211},{7,0,972},{11,0,102},{136,10,687}
+-,{6,11,227},{135,11,1589},{8,10,58},{9,10,724},{11,10,809},{13,10,113},{145,10,
+-72},{4,0,361},{133,0,315},{132,0,461},{6,10,345},{135,10,1247},{132,0,472},{8,10
+-,767},{8,10,803},{9,10,301},{137,10,903},{135,11,1333},{135,11,477},{7,10,1949},
+-{136,10,674},{6,0,905},{138,0,747},{133,0,155},{134,10,259},{7,0,163},{8,0,319},
+-{9,0,402},{10,0,24},{10,0,681},{11,0,200},{12,0,253},{12,0,410},{142,0,219},{5,0
+-,475},{7,0,1780},{9,0,230},{11,0,297},{11,0,558},{14,0,322},{19,0,76},{6,11,1667
+-},{7,11,2036},{138,11,600},{136,10,254},{6,0,848},{135,0,1956},{6,11,511},{140,
+-11,132},{5,11,568},{6,11,138},{135,11,1293},{6,0,631},{137,0,838},{149,0,36},{4,
+-11,565},{8,11,23},{136,11,827},{5,0,944},{134,0,1769},{4,0,144},{6,0,842},{6,0,
+-1400},{4,11,922},{133,11,1023},{133,10,248},{9,10,800},{10,10,693},{11,10,482},{
+-11,10,734},{139,10,789},{7,11,1002},{139,11,145},{4,10,116},{5,10,95},{5,10,445}
+-,{7,10,1688},{8,10,29},{9,10,272},{11,10,509},{139,10,915},{14,0,369},{146,0,72}
+-,{135,10,1641},{132,11,740},{133,10,543},{140,11,116},{6,0,247},{9,0,555},{5,10,
+-181},{136,10,41},{133,10,657},{136,0,996},{138,10,709},{7,0,189},{8,10,202},{138
+-,10,536},{136,11,402},{4,11,716},{141,11,31},{10,0,280},{138,0,797},{9,10,423},{
+-140,10,89},{8,10,113},{9,10,877},{10,10,554},{11,10,83},{12,10,136},{147,10,109}
+-,{133,10,976},{7,0,746},{132,10,206},{136,0,526},{139,0,345},{136,0,1017},{8,11,
+-152},{9,11,53},{9,11,268},{9,11,901},{10,11,518},{10,11,829},{11,11,188},{13,11,
+-74},{14,11,46},{15,11,17},{15,11,33},{17,11,40},{18,11,36},{19,11,20},{22,11,1},
+-{152,11,2},{133,11,736},{136,11,532},{5,0,428},{138,0,651},{135,11,681},{135,0,
+-1162},{7,0,327},{13,0,230},{17,0,113},{8,10,226},{10,10,537},{11,10,570},{11,10,
+-605},{11,10,799},{11,10,804},{12,10,85},{12,10,516},{12,10,623},{12,11,677},{13,
+-10,361},{14,10,77},{14,10,78},{147,10,110},{4,0,792},{7,0,1717},{10,0,546},{132,
+-10,769},{4,11,684},{136,11,384},{132,10,551},{134,0,1203},{9,10,57},{9,10,459},{
+-10,10,425},{11,10,119},{12,10,184},{12,10,371},{13,10,358},{145,10,51},{5,0,672}
+-,{5,10,814},{8,10,10},{9,10,421},{9,10,729},{10,10,609},{139,10,689},{138,0,189}
+-,{134,10,624},{7,11,110},{7,11,188},{8,11,290},{8,11,591},{9,11,382},{9,11,649},
+-{11,11,71},{11,11,155},{11,11,313},{12,11,5},{13,11,325},{142,11,287},{133,0,99}
+-,{6,0,1053},{135,0,298},{7,11,360},{7,11,425},{9,11,66},{9,11,278},{138,11,644},
+-{4,0,397},{136,0,555},{137,10,269},{132,10,528},{4,11,900},{133,11,861},{6,0,
+-1157},{5,11,254},{7,11,985},{136,11,73},{7,11,1959},{136,11,683},{12,0,398},{20,
+-0,39},{21,0,11},{150,0,41},{4,0,485},{7,0,353},{135,0,1523},{6,0,366},{7,0,1384}
+-,{135,0,1601},{138,0,787},{137,0,282},{5,10,104},{6,10,173},{135,10,1631},{139,
+-11,146},{4,0,157},{133,0,471},{134,0,941},{132,11,725},{7,0,1336},{8,10,138},{8,
+-10,342},{9,10,84},{10,10,193},{11,10,883},{140,10,359},{134,11,196},{136,0,116},
+-{133,11,831},{134,0,787},{134,10,95},{6,10,406},{10,10,409},{10,10,447},{11,10,
+-44},{140,10,100},{5,0,160},{7,0,363},{7,0,589},{10,0,170},{141,0,55},{134,0,1815
+-},{132,0,866},{6,0,889},{6,0,1067},{6,0,1183},{4,11,321},{134,11,569},{5,11,848}
+-,{134,11,66},{4,11,36},{6,10,1636},{7,11,1387},{10,11,205},{11,11,755},{141,11,
+-271},{132,0,689},{9,0,820},{4,10,282},{7,10,1034},{11,10,398},{11,10,634},{12,10
+-,1},{12,10,79},{12,10,544},{14,10,237},{17,10,10},{146,10,20},{4,0,108},{7,0,804
+-},{139,0,498},{132,11,887},{6,0,1119},{135,11,620},{6,11,165},{138,11,388},{5,0,
+-244},{5,10,499},{6,10,476},{7,10,600},{7,10,888},{135,10,1096},{140,0,609},{135,
+-0,1005},{4,0,412},{133,0,581},{4,11,719},{135,11,155},{7,10,296},{7,10,596},{8,
+-10,560},{8,10,586},{9,10,612},{11,10,304},{12,10,46},{13,10,89},{14,10,112},{145
+-,10,122},{4,0,895},{133,0,772},{142,11,307},{135,0,1898},{4,0,926},{133,0,983},{
+-4,11,353},{6,11,146},{6,11,1789},{7,11,288},{7,11,990},{7,11,1348},{9,11,665},{9
+-,11,898},{11,11,893},{142,11,212},{132,0,538},{133,11,532},{6,0,294},{7,0,1267},
+-{8,0,624},{141,0,496},{7,0,1325},{4,11,45},{135,11,1257},{138,0,301},{9,0,298},{
+-12,0,291},{13,0,276},{14,0,6},{17,0,18},{21,0,32},{7,10,1599},{7,10,1723},{8,10,
+-79},{8,10,106},{8,10,190},{8,10,302},{8,10,383},{8,10,713},{9,10,119},{9,10,233}
+-,{9,10,419},{9,10,471},{10,10,181},{10,10,406},{11,10,57},{11,10,85},{11,10,120}
+-,{11,10,177},{11,10,296},{11,10,382},{11,10,454},{11,10,758},{11,10,999},{12,10,
+-27},{12,10,131},{12,10,245},{12,10,312},{12,10,446},{12,10,454},{13,10,98},{13,
+-10,426},{13,10,508},{14,10,163},{14,10,272},{14,10,277},{14,10,370},{15,10,95},{
+-15,10,138},{15,10,167},{17,10,38},{148,10,96},{132,0,757},{134,0,1263},{4,0,820}
+-,{134,10,1759},{133,0,722},{136,11,816},{138,10,372},{145,10,16},{134,0,1039},{4
+-,0,991},{134,0,2028},{133,10,258},{7,0,1875},{139,0,124},{6,11,559},{6,11,1691},
+-{135,11,586},{5,0,324},{7,0,881},{8,10,134},{9,10,788},{140,10,438},{7,11,1823},
+-{139,11,693},{6,0,1348},{134,0,1545},{134,0,911},{132,0,954},{8,0,329},{8,0,414}
+-,{7,10,1948},{135,10,2004},{5,0,517},{6,10,439},{7,10,780},{135,10,1040},{132,0,
+-816},{5,10,1},{6,10,81},{138,10,520},{9,0,713},{10,0,222},{5,10,482},{8,10,98},{
+-10,10,700},{10,10,822},{11,10,302},{11,10,778},{12,10,50},{12,10,127},{12,10,396
+-},{13,10,62},{13,10,328},{14,10,122},{147,10,72},{137,0,33},{5,10,2},{7,10,1494}
+-,{136,10,589},{6,10,512},{7,10,797},{8,10,253},{9,10,77},{10,10,1},{10,11,108},{
+-10,10,129},{10,10,225},{11,11,116},{11,10,118},{11,10,226},{11,10,251},{11,10,
+-430},{11,10,701},{11,10,974},{11,10,982},{12,10,64},{12,10,260},{12,10,488},{140
+-,10,690},{134,11,456},{133,11,925},{5,0,150},{7,0,106},{7,0,774},{8,0,603},{9,0,
+-593},{9,0,634},{10,0,44},{10,0,173},{11,0,462},{11,0,515},{13,0,216},{13,0,288},
+-{142,0,400},{137,10,347},{5,0,748},{134,0,553},{12,0,108},{141,0,291},{7,0,420},
+-{4,10,12},{7,10,522},{7,10,809},{8,10,797},{141,10,88},{6,11,193},{7,11,240},{7,
+-11,1682},{10,11,51},{10,11,640},{11,11,410},{13,11,82},{14,11,247},{14,11,331},{
+-142,11,377},{133,10,528},{135,0,1777},{4,0,493},{144,0,55},{136,11,633},{139,0,
+-81},{6,0,980},{136,0,321},{148,10,109},{5,10,266},{9,10,290},{9,10,364},{10,10,
+-293},{11,10,606},{142,10,45},{6,0,568},{7,0,112},{7,0,1804},{8,0,362},{8,0,410},
+-{8,0,830},{9,0,514},{11,0,649},{142,0,157},{4,0,74},{6,0,510},{6,10,594},{9,10,
+-121},{10,10,49},{10,10,412},{139,10,834},{134,0,838},{136,10,748},{132,10,466},{
+-132,0,625},{135,11,1443},{4,11,237},{135,11,514},{9,10,378},{141,10,162},{6,0,16
+-},{6,0,158},{7,0,43},{7,0,129},{7,0,181},{8,0,276},{8,0,377},{10,0,523},{11,0,
+-816},{12,0,455},{13,0,303},{142,0,135},{135,0,281},{4,0,1},{7,0,1143},{7,0,1463}
+-,{8,0,61},{9,0,207},{9,0,390},{9,0,467},{139,0,836},{6,11,392},{7,11,65},{135,11
+-,2019},{132,10,667},{4,0,723},{5,0,895},{7,0,1031},{8,0,199},{8,0,340},{9,0,153}
+-,{9,0,215},{10,0,21},{10,0,59},{10,0,80},{10,0,224},{10,0,838},{11,0,229},{11,0,
+-652},{12,0,192},{13,0,146},{142,0,91},{132,0,295},{137,0,51},{9,11,222},{10,11,
+-43},{139,11,900},{5,0,309},{140,0,211},{5,0,125},{8,0,77},{138,0,15},{136,11,604
+-},{138,0,789},{5,0,173},{4,10,39},{7,10,1843},{8,10,407},{11,10,144},{140,10,523
+-},{138,11,265},{133,0,439},{132,10,510},{7,0,648},{7,0,874},{11,0,164},{12,0,76}
+-,{18,0,9},{7,10,1980},{10,10,487},{138,10,809},{12,0,111},{14,0,294},{19,0,45},{
+-13,10,260},{146,10,63},{133,11,549},{134,10,570},{4,0,8},{7,0,1152},{7,0,1153},{
+-7,0,1715},{9,0,374},{10,0,478},{139,0,648},{135,0,1099},{5,0,575},{6,0,354},{135
+-,0,701},{7,11,36},{8,11,201},{136,11,605},{4,10,787},{136,11,156},{6,0,518},{149
+-,11,13},{140,11,224},{134,0,702},{132,10,516},{5,11,724},{10,11,305},{11,11,151}
+-,{12,11,33},{12,11,121},{12,11,381},{17,11,3},{17,11,27},{17,11,78},{18,11,18},{
+-19,11,54},{149,11,5},{8,0,87},{4,11,523},{5,11,638},{11,10,887},{14,10,365},{142
+-,10,375},{138,0,438},{136,10,821},{135,11,1908},{6,11,242},{7,11,227},{7,11,1581
+-},{8,11,104},{9,11,113},{9,11,220},{9,11,427},{10,11,74},{10,11,239},{11,11,579}
+-,{11,11,1023},{13,11,4},{13,11,204},{13,11,316},{18,11,95},{148,11,86},{4,0,69},
+-{5,0,122},{5,0,849},{6,0,1633},{9,0,656},{138,0,464},{7,0,1802},{4,10,10},{139,
+-10,786},{135,11,861},{139,0,499},{7,0,476},{7,0,1592},{138,0,87},{133,10,684},{4
+-,0,840},{134,10,27},{142,0,283},{6,0,1620},{7,11,1328},{136,11,494},{5,0,859},{7
+-,0,1160},{8,0,107},{9,0,291},{9,0,439},{10,0,663},{11,0,609},{140,0,197},{7,11,
+-1306},{8,11,505},{9,11,482},{10,11,126},{11,11,225},{12,11,347},{12,11,449},{13,
+-11,19},{142,11,218},{5,11,268},{10,11,764},{12,11,120},{13,11,39},{145,11,127},{
+-145,10,56},{7,11,1672},{10,11,472},{11,11,189},{143,11,51},{6,10,342},{6,10,496}
+-,{8,10,275},{137,10,206},{133,0,600},{4,0,117},{6,0,372},{7,0,1905},{142,0,323},
+-{4,10,909},{5,10,940},{135,11,1471},{132,10,891},{4,0,722},{139,0,471},{4,11,384
+-},{135,11,1022},{132,10,687},{9,0,5},{12,0,216},{12,0,294},{12,0,298},{12,0,400}
+-,{12,0,518},{13,0,229},{143,0,139},{135,11,1703},{7,11,1602},{10,11,698},{12,11,
+-212},{141,11,307},{6,10,41},{141,10,160},{135,11,1077},{9,11,159},{11,11,28},{
+-140,11,603},{4,0,514},{7,0,1304},{138,0,477},{134,0,1774},{9,0,88},{139,0,270},{
+-5,0,12},{7,0,375},{9,0,438},{134,10,1718},{132,11,515},{136,10,778},{8,11,632},{
+-8,11,697},{137,11,854},{6,0,362},{6,0,997},{146,0,51},{7,0,816},{7,0,1241},{9,0,
+-283},{9,0,520},{10,0,213},{10,0,307},{10,0,463},{10,0,671},{10,0,746},{11,0,401}
+-,{11,0,794},{12,0,517},{18,0,107},{147,0,115},{133,10,115},{150,11,28},{4,11,136
+-},{133,11,551},{142,10,314},{132,0,258},{6,0,22},{7,0,903},{7,0,1963},{8,0,639},
+-{138,0,577},{5,0,681},{8,0,782},{13,0,130},{17,0,84},{5,10,193},{140,10,178},{9,
+-11,17},{138,11,291},{7,11,1287},{9,11,44},{10,11,552},{10,11,642},{11,11,839},{
+-12,11,274},{12,11,275},{12,11,372},{13,11,91},{142,11,125},{135,10,174},{4,0,664
+-},{5,0,804},{139,0,1013},{134,0,942},{6,0,1349},{6,0,1353},{6,0,1450},{7,11,1518
+-},{139,11,694},{11,0,356},{4,10,122},{5,10,796},{5,10,952},{6,10,1660},{6,10,
+-1671},{8,10,567},{9,10,687},{9,10,742},{10,10,686},{11,10,682},{140,10,281},{5,0
+-,32},{6,11,147},{7,11,886},{9,11,753},{138,11,268},{5,10,179},{7,10,1095},{135,
+-10,1213},{4,10,66},{7,10,722},{135,10,904},{135,10,352},{9,11,245},{138,11,137},
+-{4,0,289},{7,0,629},{7,0,1698},{7,0,1711},{12,0,215},{133,11,414},{6,0,1975},{
+-135,11,1762},{6,0,450},{136,0,109},{141,10,35},{134,11,599},{136,0,705},{133,0,
+-664},{134,11,1749},{11,11,402},{12,11,109},{12,11,431},{13,11,179},{13,11,206},{
+-14,11,175},{14,11,217},{16,11,3},{148,11,53},{135,0,1238},{134,11,1627},{132,11,
+-488},{13,0,318},{10,10,592},{10,10,753},{12,10,317},{12,10,355},{12,10,465},{12,
+-10,469},{12,10,560},{140,10,578},{133,10,564},{132,11,83},{140,11,676},{6,0,1872
+-},{6,0,1906},{6,0,1907},{9,0,934},{9,0,956},{9,0,960},{9,0,996},{12,0,794},{12,0
+-,876},{12,0,880},{12,0,918},{15,0,230},{18,0,234},{18,0,238},{21,0,38},{149,0,62
+-},{134,10,556},{134,11,278},{137,0,103},{7,10,544},{8,10,719},{138,10,61},{4,10,
+-5},{5,10,498},{8,10,637},{137,10,521},{7,0,777},{12,0,229},{12,0,239},{15,0,12},
+-{12,11,229},{12,11,239},{143,11,12},{6,0,26},{7,11,388},{7,11,644},{139,11,781},
+-{7,11,229},{8,11,59},{9,11,190},{9,11,257},{10,11,378},{140,11,191},{133,10,927}
+-,{135,10,1441},{4,10,893},{5,10,780},{133,10,893},{4,0,414},{5,0,467},{9,0,654},
+-{10,0,451},{12,0,59},{141,0,375},{142,0,173},{135,0,17},{7,0,1350},{133,10,238},
+-{135,0,955},{4,0,960},{10,0,887},{12,0,753},{18,0,161},{18,0,162},{152,0,19},{
+-136,11,344},{6,10,1729},{137,11,288},{132,11,660},{4,0,217},{5,0,710},{7,0,760},
+-{7,0,1926},{9,0,428},{9,0,708},{10,0,254},{10,0,296},{10,0,720},{11,0,109},{11,0
+-,255},{12,0,165},{12,0,315},{13,0,107},{13,0,203},{14,0,54},{14,0,99},{14,0,114}
+-,{14,0,388},{16,0,85},{17,0,9},{17,0,33},{20,0,25},{20,0,28},{20,0,29},{21,0,9},
+-{21,0,10},{21,0,34},{22,0,17},{4,10,60},{7,10,1800},{8,10,314},{9,10,700},{139,
+-10,487},{7,11,1035},{138,11,737},{7,11,690},{9,11,217},{9,11,587},{140,11,521},{
+-6,0,919},{7,11,706},{7,11,1058},{138,11,538},{7,10,1853},{138,10,437},{136,10,
+-419},{6,0,280},{10,0,502},{11,0,344},{140,0,38},{5,0,45},{7,0,1161},{11,0,448},{
+-11,0,880},{13,0,139},{13,0,407},{15,0,16},{17,0,95},{18,0,66},{18,0,88},{18,0,
+-123},{149,0,7},{11,11,92},{11,11,196},{11,11,409},{11,11,450},{11,11,666},{11,11
+-,777},{12,11,262},{13,11,385},{13,11,393},{15,11,115},{16,11,45},{145,11,82},{
+-136,0,777},{134,11,1744},{4,0,410},{7,0,521},{133,10,828},{134,0,673},{7,0,1110}
+-,{7,0,1778},{7,10,176},{135,10,178},{5,10,806},{7,11,268},{7,10,1976},{136,11,
+-569},{4,11,733},{9,11,194},{10,11,92},{11,11,198},{12,11,84},{12,11,87},{13,11,
+-128},{144,11,74},{5,0,341},{7,0,1129},{11,0,414},{4,10,51},{6,10,4},{7,10,591},{
+-7,10,849},{7,10,951},{7,10,1613},{7,10,1760},{7,10,1988},{9,10,434},{10,10,754},
+-{11,10,25},{139,10,37},{133,10,902},{135,10,928},{135,0,787},{132,0,436},{134,10
+-,270},{7,0,1587},{135,0,1707},{6,0,377},{7,0,1025},{9,0,613},{145,0,104},{7,11,
+-982},{7,11,1361},{10,11,32},{143,11,56},{139,0,96},{132,0,451},{132,10,416},{142
+-,10,372},{5,10,152},{5,10,197},{7,11,306},{7,10,340},{7,10,867},{10,10,548},{10,
+-10,581},{11,10,6},{12,10,3},{12,10,19},{14,10,110},{142,10,289},{134,0,680},{134
+-,11,609},{7,0,483},{7,10,190},{8,10,28},{8,10,141},{8,10,444},{8,10,811},{9,10,
+-468},{11,10,334},{12,10,24},{12,10,386},{140,10,576},{10,0,916},{133,10,757},{5,
+-10,721},{135,10,1553},{133,11,178},{134,0,937},{132,10,898},{133,0,739},{147,0,
+-82},{135,0,663},{146,0,128},{5,10,277},{141,10,247},{134,0,1087},{132,10,435},{6
+-,11,381},{7,11,645},{7,11,694},{136,11,546},{7,0,503},{135,0,1885},{6,0,1965},{8
+-,0,925},{138,0,955},{4,0,113},{5,0,163},{5,0,735},{7,0,1009},{9,0,9},{9,0,771},{
+-12,0,90},{13,0,138},{13,0,410},{143,0,128},{4,0,324},{138,0,104},{7,0,460},{5,10
+-,265},{134,10,212},{133,11,105},{7,11,261},{7,11,1107},{7,11,1115},{7,11,1354},{
+-7,11,1588},{7,11,1705},{7,11,1902},{9,11,465},{10,11,248},{10,11,349},{10,11,647
+-},{11,11,527},{11,11,660},{11,11,669},{12,11,529},{141,11,305},{5,11,438},{9,11,
+-694},{12,11,627},{141,11,210},{152,11,11},{4,0,935},{133,0,823},{132,10,702},{5,
+-0,269},{7,0,434},{7,0,891},{8,0,339},{9,0,702},{11,0,594},{11,0,718},{17,0,100},
+-{5,10,808},{135,10,2045},{7,0,1014},{9,0,485},{141,0,264},{134,0,1713},{7,0,1810
+-},{11,0,866},{12,0,103},{13,0,495},{140,11,233},{4,0,423},{10,0,949},{138,0,1013
+-},{135,0,900},{8,11,25},{138,11,826},{5,10,166},{8,10,739},{140,10,511},{134,0,
+-2018},{7,11,1270},{139,11,612},{4,10,119},{5,10,170},{5,10,447},{7,10,1708},{7,
+-10,1889},{9,10,357},{9,10,719},{12,10,486},{140,10,596},{12,0,574},{140,11,574},
+-{132,11,308},{6,0,964},{6,0,1206},{134,0,1302},{4,10,450},{135,10,1158},{135,11,
+-150},{136,11,649},{14,0,213},{148,0,38},{9,11,45},{9,11,311},{141,11,42},{134,11
+-,521},{7,10,1375},{7,10,1466},{138,10,331},{132,10,754},{5,11,339},{7,11,1442},{
+-14,11,3},{15,11,41},{147,11,66},{136,11,378},{134,0,1022},{5,10,850},{136,10,799
+-},{142,0,143},{135,0,2029},{134,11,1628},{8,0,523},{150,0,34},{5,0,625},{135,0,
+-1617},{7,0,275},{7,10,238},{7,10,2033},{8,10,120},{8,10,188},{8,10,659},{9,10,
+-598},{10,10,466},{12,10,342},{12,10,588},{13,10,503},{14,10,246},{143,10,92},{7,
+-0,37},{8,0,425},{8,0,693},{9,0,720},{10,0,380},{10,0,638},{11,0,273},{11,0,473},
+-{12,0,61},{143,0,43},{135,11,829},{135,0,1943},{132,0,765},{5,11,486},{135,11,
+-1349},{7,11,1635},{8,11,17},{10,11,217},{138,11,295},{4,10,201},{7,10,1744},{8,
+-10,602},{11,10,247},{11,10,826},{145,10,65},{138,11,558},{11,0,551},{142,0,159},
+-{8,10,164},{146,10,62},{139,11,176},{132,0,168},{136,0,1010},{134,0,1994},{135,0
+-,91},{138,0,532},{135,10,1243},{135,0,1884},{132,10,907},{5,10,100},{10,10,329},
+-{12,10,416},{149,10,29},{134,11,447},{132,10,176},{5,10,636},{5,10,998},{7,10,9}
+-,{7,10,1508},{8,10,26},{9,10,317},{9,10,358},{10,10,210},{10,10,292},{10,10,533}
+-,{11,10,555},{12,10,526},{12,10,607},{13,10,263},{13,10,459},{142,10,271},{4,11,
+-609},{135,11,756},{6,0,15},{7,0,70},{10,0,240},{147,0,93},{4,11,930},{133,11,947
+-},{134,0,1227},{134,0,1534},{133,11,939},{133,11,962},{5,11,651},{8,11,170},{9,
+-11,61},{9,11,63},{10,11,23},{10,11,37},{10,11,834},{11,11,4},{11,11,187},{11,11,
+-281},{11,11,503},{11,11,677},{12,11,96},{12,11,130},{12,11,244},{14,11,5},{14,11
+-,40},{14,11,162},{14,11,202},{146,11,133},{4,11,406},{5,11,579},{12,11,492},{150
+-,11,15},{139,0,392},{6,10,610},{10,10,127},{141,10,27},{7,0,655},{7,0,1844},{136
+-,10,119},{4,0,145},{6,0,176},{7,0,395},{137,0,562},{132,0,501},{140,11,145},{136
+-,0,1019},{134,0,509},{139,0,267},{6,11,17},{7,11,16},{7,11,1001},{7,11,1982},{9,
+-11,886},{10,11,489},{10,11,800},{11,11,782},{12,11,320},{13,11,467},{14,11,145},
+-{14,11,387},{143,11,119},{145,11,17},{6,0,1099},{133,11,458},{7,11,1983},{8,11,0
+-},{8,11,171},{9,11,120},{9,11,732},{10,11,473},{11,11,656},{11,11,998},{18,11,0}
+-,{18,11,2},{147,11,21},{12,11,427},{146,11,38},{10,0,948},{138,0,968},{7,10,126}
+-,{136,10,84},{136,10,790},{4,0,114},{9,0,492},{13,0,462},{142,0,215},{6,10,64},{
+-12,10,377},{141,10,309},{4,0,77},{5,0,361},{6,0,139},{6,0,401},{6,0,404},{7,0,
+-413},{7,0,715},{7,0,1716},{11,0,279},{12,0,179},{12,0,258},{13,0,244},{142,0,358
+-},{134,0,1717},{7,0,772},{7,0,1061},{7,0,1647},{8,0,82},{11,0,250},{11,0,607},{
+-12,0,311},{12,0,420},{13,0,184},{13,0,367},{7,10,1104},{11,10,269},{11,10,539},{
+-11,10,627},{11,10,706},{11,10,975},{12,10,248},{12,10,434},{12,10,600},{12,10,
+-622},{13,10,297},{13,10,485},{14,10,69},{14,10,409},{143,10,108},{135,0,724},{4,
+-11,512},{4,11,519},{133,11,342},{134,0,1133},{145,11,29},{11,10,977},{141,10,507
+-},{6,0,841},{6,0,1042},{6,0,1194},{10,0,993},{140,0,1021},{6,11,31},{7,11,491},{
+-7,11,530},{8,11,592},{9,10,34},{11,11,53},{11,10,484},{11,11,779},{12,11,167},{
+-12,11,411},{14,11,14},{14,11,136},{15,11,72},{16,11,17},{144,11,72},{4,0,1021},{
+-6,0,2037},{133,11,907},{7,0,373},{8,0,335},{8,0,596},{9,0,488},{6,10,1700},{7,10
+-,293},{7,10,382},{7,10,1026},{7,10,1087},{7,10,2027},{8,10,252},{8,10,727},{8,10
+-,729},{9,10,30},{9,10,199},{9,10,231},{9,10,251},{9,10,334},{9,10,361},{9,10,712
+-},{10,10,55},{10,10,60},{10,10,232},{10,10,332},{10,10,384},{10,10,396},{10,10,
+-504},{10,10,542},{10,10,652},{11,10,20},{11,10,48},{11,10,207},{11,10,291},{11,
+-10,298},{11,10,342},{11,10,365},{11,10,394},{11,10,620},{11,10,705},{11,10,1017}
+-,{12,10,123},{12,10,340},{12,10,406},{12,10,643},{13,10,61},{13,10,269},{13,10,
+-311},{13,10,319},{13,10,486},{14,10,234},{15,10,62},{15,10,85},{16,10,71},{18,10
+-,119},{148,10,105},{150,0,37},{4,11,208},{5,11,106},{6,11,531},{8,11,408},{9,11,
+-188},{138,11,572},{132,0,564},{6,0,513},{135,0,1052},{132,0,825},{9,0,899},{140,
+-11,441},{134,0,778},{133,11,379},{7,0,1417},{12,0,382},{17,0,48},{152,0,12},{132
+-,11,241},{7,0,1116},{6,10,379},{7,10,270},{8,10,176},{8,10,183},{9,10,432},{9,10
+-,661},{12,10,247},{12,10,617},{146,10,125},{5,10,792},{133,10,900},{6,0,545},{7,
+-0,565},{7,0,1669},{10,0,114},{11,0,642},{140,0,618},{133,0,5},{138,11,7},{132,11
+-,259},{135,0,192},{134,0,701},{136,0,763},{135,10,1979},{4,10,901},{133,10,776},
+-{10,0,755},{147,0,29},{133,0,759},{4,11,173},{5,11,312},{5,11,512},{135,11,1285}
+-,{7,11,1603},{7,11,1691},{9,11,464},{11,11,195},{12,11,279},{12,11,448},{14,11,
+-11},{147,11,102},{7,0,370},{7,0,1007},{7,0,1177},{135,0,1565},{135,0,1237},{4,0,
+-87},{5,0,250},{141,0,298},{4,11,452},{5,11,583},{5,11,817},{6,11,433},{7,11,593}
+-,{7,11,720},{7,11,1378},{8,11,161},{9,11,284},{10,11,313},{139,11,886},{4,11,547
+-},{135,11,1409},{136,11,722},{4,10,37},{5,10,334},{135,10,1253},{132,10,508},{12
+-,0,107},{146,0,31},{8,11,420},{139,11,193},{135,0,814},{135,11,409},{140,0,991},
+-{4,0,57},{7,0,1195},{7,0,1438},{7,0,1548},{7,0,1835},{7,0,1904},{9,0,757},{10,0,
+-604},{139,0,519},{132,0,540},{138,11,308},{132,10,533},{136,0,608},{144,11,65},{
+-4,0,1014},{134,0,2029},{4,0,209},{7,0,902},{5,11,1002},{136,11,745},{134,0,2030}
+-,{6,0,303},{7,0,335},{7,0,1437},{7,0,1668},{8,0,553},{8,0,652},{8,0,656},{9,0,
+-558},{11,0,743},{149,0,18},{5,11,575},{6,11,354},{135,11,701},{4,11,239},{6,11,
+-477},{7,11,1607},{11,11,68},{139,11,617},{132,0,559},{8,0,527},{18,0,60},{147,0,
+-24},{133,10,920},{138,0,511},{133,0,1017},{133,0,675},{138,10,391},{11,0,156},{
+-135,10,1952},{138,11,369},{132,11,367},{133,0,709},{6,0,698},{134,0,887},{142,10
+-,126},{134,0,1745},{132,10,483},{13,11,299},{142,11,75},{133,0,714},{7,0,8},{136
+-,0,206},{138,10,480},{4,11,694},{9,10,495},{146,10,104},{7,11,1248},{11,11,621},
+-{139,11,702},{140,11,687},{132,0,776},{139,10,1009},{135,0,1272},{134,0,1059},{8
+-,10,653},{13,10,93},{147,10,14},{135,11,213},{136,0,406},{133,10,172},{132,0,947
+-},{8,0,175},{10,0,168},{138,0,573},{132,0,870},{6,0,1567},{151,11,28},{134,11,
+-472},{5,10,260},{136,11,132},{4,11,751},{11,11,390},{140,11,32},{4,11,409},{133,
+-11,78},{12,0,554},{6,11,473},{145,11,105},{133,0,784},{8,0,908},{136,11,306},{
+-139,0,882},{6,0,358},{7,0,1393},{8,0,396},{10,0,263},{14,0,154},{16,0,48},{17,0,
+-8},{7,11,1759},{8,11,396},{10,11,263},{14,11,154},{16,11,48},{145,11,8},{13,11,
+-163},{13,11,180},{18,11,78},{148,11,35},{14,0,32},{18,0,85},{20,0,2},{152,0,16},
+-{7,0,228},{10,0,770},{8,10,167},{8,10,375},{9,10,82},{9,10,561},{138,10,620},{
+-132,0,845},{9,0,14},{9,0,441},{10,0,306},{139,0,9},{11,0,966},{12,0,287},{13,0,
+-342},{13,0,402},{15,0,110},{15,0,163},{8,10,194},{136,10,756},{134,0,1578},{4,0,
+-967},{6,0,1820},{6,0,1847},{140,0,716},{136,0,594},{7,0,1428},{7,0,1640},{7,0,
+-1867},{9,0,169},{9,0,182},{9,0,367},{9,0,478},{9,0,506},{9,0,551},{9,0,557},{9,0
+-,648},{9,0,697},{9,0,705},{9,0,725},{9,0,787},{9,0,794},{10,0,198},{10,0,214},{
+-10,0,267},{10,0,275},{10,0,456},{10,0,551},{10,0,561},{10,0,613},{10,0,627},{10,
+-0,668},{10,0,675},{10,0,691},{10,0,695},{10,0,707},{10,0,715},{11,0,183},{11,0,
+-201},{11,0,244},{11,0,262},{11,0,352},{11,0,439},{11,0,493},{11,0,572},{11,0,591
+-},{11,0,608},{11,0,611},{11,0,646},{11,0,674},{11,0,711},{11,0,751},{11,0,761},{
+-11,0,776},{11,0,785},{11,0,850},{11,0,853},{11,0,862},{11,0,865},{11,0,868},{11,
+-0,875},{11,0,898},{11,0,902},{11,0,903},{11,0,910},{11,0,932},{11,0,942},{11,0,
+-957},{11,0,967},{11,0,972},{12,0,148},{12,0,195},{12,0,220},{12,0,237},{12,0,318
+-},{12,0,339},{12,0,393},{12,0,445},{12,0,450},{12,0,474},{12,0,505},{12,0,509},{
+-12,0,533},{12,0,591},{12,0,594},{12,0,597},{12,0,621},{12,0,633},{12,0,642},{13,
+-0,59},{13,0,60},{13,0,145},{13,0,239},{13,0,250},{13,0,329},{13,0,344},{13,0,365
+-},{13,0,372},{13,0,387},{13,0,403},{13,0,414},{13,0,456},{13,0,470},{13,0,478},{
+-13,0,483},{13,0,489},{14,0,55},{14,0,57},{14,0,81},{14,0,90},{14,0,148},{14,0,
+-239},{14,0,266},{14,0,321},{14,0,326},{14,0,327},{14,0,330},{14,0,347},{14,0,355
+-},{14,0,401},{14,0,404},{14,0,411},{14,0,414},{14,0,416},{14,0,420},{15,0,61},{
+-15,0,74},{15,0,87},{15,0,88},{15,0,94},{15,0,96},{15,0,116},{15,0,149},{15,0,154
+-},{16,0,50},{16,0,63},{16,0,73},{17,0,2},{17,0,66},{17,0,92},{17,0,103},{17,0,
+-112},{17,0,120},{18,0,50},{18,0,54},{18,0,82},{18,0,86},{18,0,90},{18,0,111},{18
+-,0,115},{18,0,156},{19,0,40},{19,0,79},{20,0,78},{21,0,22},{135,11,883},{5,0,161
+-},{135,0,839},{4,0,782},{13,11,293},{142,11,56},{133,11,617},{139,11,50},{135,10
+-,22},{145,0,64},{5,10,639},{7,10,1249},{139,10,896},{138,0,998},{135,11,2042},{4
+-,11,546},{142,11,233},{6,0,1043},{134,0,1574},{134,0,1496},{4,10,102},{7,10,815}
+-,{7,10,1699},{139,10,964},{12,0,781},{142,0,461},{4,11,313},{133,11,577},{6,0,
+-639},{6,0,1114},{137,0,817},{8,11,184},{141,11,433},{7,0,1814},{135,11,935},{10,
+-0,997},{140,0,958},{4,0,812},{137,11,625},{132,10,899},{136,10,795},{5,11,886},{
+-6,11,46},{6,11,1790},{7,11,14},{7,11,732},{7,11,1654},{8,11,95},{8,11,327},{8,11
+-,616},{10,11,598},{10,11,769},{11,11,134},{11,11,747},{12,11,378},{142,11,97},{
+-136,0,139},{6,10,52},{9,10,104},{9,10,559},{12,10,308},{147,10,87},{133,11,1021}
+-,{132,10,604},{132,10,301},{136,10,779},{7,0,643},{136,0,236},{132,11,153},{134,
+-0,1172},{147,10,32},{133,11,798},{6,0,1338},{132,11,587},{6,11,598},{7,11,42},{8
+-,11,695},{10,11,212},{11,11,158},{14,11,196},{145,11,85},{135,10,508},{5,11,957}
+-,{5,11,1008},{135,11,249},{4,11,129},{135,11,465},{5,0,54},{7,11,470},{7,11,1057
+-},{7,11,1201},{9,11,755},{11,11,906},{140,11,527},{7,11,908},{146,11,7},{5,11,
+-148},{136,11,450},{144,11,1},{4,0,256},{135,0,1488},{9,0,351},{6,10,310},{7,10,
+-1849},{8,10,72},{8,10,272},{8,10,431},{9,10,12},{10,10,563},{10,10,630},{10,10,
+-796},{10,10,810},{11,10,367},{11,10,599},{11,10,686},{140,10,672},{6,0,1885},{6,
+-0,1898},{6,0,1899},{140,0,955},{4,0,714},{133,0,469},{6,0,1270},{134,0,1456},{
+-132,0,744},{6,0,313},{7,10,537},{8,10,64},{9,10,127},{10,10,496},{12,10,510},{
+-141,10,384},{4,11,217},{4,10,244},{5,11,710},{7,10,233},{7,11,1926},{9,11,428},{
+-9,11,708},{10,11,254},{10,11,296},{10,11,720},{11,11,109},{11,11,255},{12,11,165
+-},{12,11,315},{13,11,107},{13,11,203},{14,11,54},{14,11,99},{14,11,114},{14,11,
+-388},{16,11,85},{17,11,9},{17,11,33},{20,11,25},{20,11,28},{20,11,29},{21,11,9},
+-{21,11,10},{21,11,34},{150,11,17},{138,0,402},{7,0,969},{146,0,55},{8,0,50},{137
+-,0,624},{134,0,1355},{132,0,572},{134,10,1650},{10,10,702},{139,10,245},{10,0,
+-847},{142,0,445},{6,0,43},{7,0,38},{8,0,248},{138,0,513},{133,0,369},{137,10,338
+-},{133,0,766},{133,0,363},{133,10,896},{8,11,392},{11,11,54},{13,11,173},{13,11,
+-294},{148,11,7},{134,0,678},{7,11,1230},{136,11,531},{6,0,258},{140,0,409},{5,0,
+-249},{148,0,82},{7,10,1117},{136,10,539},{5,0,393},{6,0,378},{7,0,1981},{9,0,32}
+-,{9,0,591},{10,0,685},{10,0,741},{142,0,382},{133,0,788},{134,0,1281},{134,0,
+-1295},{7,0,1968},{141,0,509},{4,0,61},{5,0,58},{5,0,171},{5,0,683},{6,0,291},{6,
+-0,566},{7,0,1650},{11,0,523},{12,0,273},{12,0,303},{15,0,39},{143,0,111},{6,0,
+-706},{134,0,1283},{134,0,589},{135,11,1433},{133,11,435},{7,0,1059},{13,0,54},{5
+-,10,4},{5,10,810},{6,10,13},{6,10,538},{6,10,1690},{6,10,1726},{7,10,1819},{8,10
+-,148},{8,10,696},{8,10,791},{12,10,125},{143,10,9},{135,10,1268},{5,11,85},{6,11
+-,419},{7,11,134},{7,11,305},{7,11,361},{7,11,1337},{8,11,71},{140,11,519},{137,0
+-,824},{140,11,688},{5,11,691},{7,11,345},{7,10,1385},{9,11,94},{11,10,582},{11,
+-10,650},{11,10,901},{11,10,949},{12,11,169},{12,10,232},{12,10,236},{13,10,413},
+-{13,10,501},{146,10,116},{4,0,917},{133,0,1005},{7,0,1598},{5,11,183},{6,11,582}
+-,{9,11,344},{10,11,679},{140,11,435},{4,10,925},{5,10,803},{8,10,698},{138,10,
+-828},{132,0,919},{135,11,511},{139,10,992},{4,0,255},{5,0,302},{6,0,132},{7,0,
+-128},{7,0,283},{7,0,1299},{10,0,52},{10,0,514},{11,0,925},{13,0,92},{142,0,309},
+-{134,0,1369},{135,10,1847},{134,0,328},{7,11,1993},{136,11,684},{133,10,383},{
+-137,0,173},{134,11,583},{134,0,1411},{19,0,65},{5,11,704},{8,11,357},{10,11,745}
+-,{14,11,426},{17,11,94},{147,11,57},{9,10,660},{138,10,347},{4,11,179},{5,11,198
+-},{133,11,697},{7,11,347},{7,11,971},{8,11,181},{138,11,711},{141,0,442},{11,0,
+-842},{11,0,924},{13,0,317},{13,0,370},{13,0,469},{13,0,471},{14,0,397},{18,0,69}
+-,{18,0,145},{7,10,572},{9,10,592},{11,10,680},{12,10,356},{140,10,550},{14,11,19
+-},{14,11,28},{144,11,29},{136,0,534},{4,11,243},{5,11,203},{7,11,19},{7,11,71},{
+-7,11,113},{10,11,405},{11,11,357},{142,11,240},{6,0,210},{10,0,845},{138,0,862},
+-{7,11,1351},{9,11,581},{10,11,639},{11,11,453},{140,11,584},{7,11,1450},{139,11,
+-99},{10,0,892},{12,0,719},{144,0,105},{4,0,284},{6,0,223},{134,11,492},{5,11,134
+-},{6,11,408},{6,11,495},{135,11,1593},{136,0,529},{137,0,807},{4,0,218},{7,0,526
+-},{143,0,137},{6,0,1444},{142,11,4},{132,11,665},{4,0,270},{5,0,192},{6,0,332},{
+-7,0,1322},{4,11,248},{7,11,137},{137,11,349},{140,0,661},{7,0,1517},{11,0,597},{
+-14,0,76},{14,0,335},{20,0,33},{7,10,748},{139,10,700},{5,11,371},{135,11,563},{
+-146,11,57},{133,10,127},{133,0,418},{4,11,374},{7,11,547},{7,11,1700},{7,11,1833
+-},{139,11,858},{6,10,198},{140,10,83},{7,11,1812},{13,11,259},{13,11,356},{14,11
+-,242},{147,11,114},{7,0,379},{8,0,481},{9,0,377},{5,10,276},{6,10,55},{135,10,
+-1369},{138,11,286},{5,0,1003},{6,0,149},{6,10,1752},{136,10,726},{8,0,262},{9,0,
+-627},{10,0,18},{11,0,214},{11,0,404},{11,0,457},{11,0,780},{11,0,913},{13,0,401}
+-,{14,0,200},{6,11,1647},{7,11,1552},{7,11,2010},{9,11,494},{137,11,509},{135,0,
+-742},{136,0,304},{132,0,142},{133,10,764},{6,10,309},{7,10,331},{138,10,550},{
+-135,10,1062},{6,11,123},{7,11,214},{7,10,986},{9,11,728},{10,11,157},{11,11,346}
+-,{11,11,662},{143,11,106},{135,10,1573},{7,0,925},{137,0,799},{4,0,471},{5,0,51}
+-,{6,0,602},{8,0,484},{138,0,195},{136,0,688},{132,0,697},{6,0,1169},{6,0,1241},{
+-6,10,194},{7,10,133},{10,10,493},{10,10,570},{139,10,664},{140,0,751},{7,0,929},
+-{10,0,452},{11,0,878},{16,0,33},{5,10,24},{5,10,569},{6,10,3},{6,10,119},{6,10,
+-143},{6,10,440},{7,10,599},{7,10,1686},{7,10,1854},{8,10,424},{9,10,43},{9,10,
+-584},{9,10,760},{10,10,328},{11,10,159},{11,10,253},{12,10,487},{140,10,531},{4,
+-11,707},{13,11,106},{18,11,49},{147,11,41},{5,0,221},{5,11,588},{134,11,393},{
+-134,0,1437},{6,11,211},{7,11,1690},{11,11,486},{140,11,369},{5,10,14},{5,10,892}
+-,{6,10,283},{7,10,234},{136,10,537},{4,0,988},{136,0,955},{135,0,1251},{4,10,126
+-},{8,10,635},{147,10,34},{4,10,316},{135,10,1561},{137,10,861},{4,10,64},{5,10,
+-352},{5,10,720},{6,10,368},{139,10,359},{134,0,192},{4,0,132},{5,0,69},{135,0,
+-1242},{7,10,1577},{10,10,304},{10,10,549},{12,10,365},{13,10,220},{13,10,240},{
+-142,10,33},{4,0,111},{7,0,865},{134,11,219},{5,11,582},{6,11,1646},{7,11,99},{7,
+-11,1962},{7,11,1986},{8,11,515},{8,11,773},{9,11,23},{9,11,491},{12,11,620},{14,
+-11,52},{145,11,50},{132,0,767},{7,11,568},{148,11,21},{6,0,42},{7,0,1416},{7,0,
+-2005},{8,0,131},{8,0,466},{9,0,672},{13,0,252},{20,0,103},{133,11,851},{135,0,
+-1050},{6,10,175},{137,10,289},{5,10,432},{133,10,913},{6,0,44},{136,0,368},{135,
+-11,784},{132,0,570},{133,0,120},{139,10,595},{140,0,29},{6,0,227},{135,0,1589},{
+-4,11,98},{7,11,1365},{9,11,422},{9,11,670},{10,11,775},{11,11,210},{13,11,26},{
+-13,11,457},{141,11,476},{140,10,80},{5,10,931},{134,10,1698},{133,0,522},{134,0,
+-1120},{135,0,1529},{12,0,739},{14,0,448},{142,0,467},{11,10,526},{11,10,939},{
+-141,10,290},{5,10,774},{6,10,1637},{6,10,1686},{134,10,1751},{6,0,1667},{135,0,
+-2036},{7,10,1167},{11,10,934},{13,10,391},{145,10,76},{137,11,147},{6,10,260},{7
+-,10,1484},{11,11,821},{12,11,110},{12,11,153},{18,11,41},{150,11,19},{6,0,511},{
+-12,0,132},{134,10,573},{5,0,568},{6,0,138},{135,0,1293},{132,0,1020},{8,0,258},{
+-9,0,208},{137,0,359},{4,0,565},{8,0,23},{136,0,827},{134,0,344},{4,0,922},{5,0,
+-1023},{13,11,477},{14,11,120},{148,11,61},{134,0,240},{5,11,209},{6,11,30},{11,
+-11,56},{139,11,305},{6,0,171},{7,0,1002},{7,0,1324},{9,0,415},{14,0,230},{18,0,
+-68},{4,10,292},{4,10,736},{5,10,871},{6,10,1689},{7,10,1944},{137,10,580},{9,11,
+-635},{139,11,559},{4,11,150},{5,11,303},{134,11,327},{6,10,63},{135,10,920},{133
+-,10,793},{8,11,192},{10,11,78},{10,11,555},{11,11,308},{13,11,359},{147,11,95},{
+-135,11,786},{135,11,1712},{136,0,402},{6,0,754},{6,11,1638},{7,11,79},{7,11,496}
+-,{9,11,138},{10,11,336},{11,11,12},{12,11,412},{12,11,440},{142,11,305},{4,0,716
+-},{141,0,31},{133,0,982},{8,0,691},{8,0,731},{5,10,67},{6,10,62},{6,10,374},{135
+-,10,1391},{9,10,790},{140,10,47},{139,11,556},{151,11,1},{7,11,204},{7,11,415},{
+-8,11,42},{10,11,85},{11,11,33},{11,11,564},{12,11,571},{149,11,1},{8,0,888},{7,
+-11,610},{135,11,1501},{4,10,391},{135,10,1169},{5,0,847},{9,0,840},{138,0,803},{
+-137,0,823},{134,0,785},{8,0,152},{9,0,53},{9,0,268},{9,0,901},{10,0,518},{10,0,
+-829},{11,0,188},{13,0,74},{14,0,46},{15,0,17},{15,0,33},{17,0,40},{18,0,36},{19,
+-0,20},{22,0,1},{152,0,2},{4,11,3},{5,11,247},{5,11,644},{7,11,744},{7,11,1207},{
+-7,11,1225},{7,11,1909},{146,11,147},{136,0,532},{135,0,681},{132,10,271},{140,0,
+-314},{140,0,677},{4,0,684},{136,0,384},{5,11,285},{9,11,67},{13,11,473},{143,11,
+-82},{4,10,253},{5,10,544},{7,10,300},{137,10,340},{7,0,110},{7,0,447},{8,0,290},
+-{8,0,591},{9,0,382},{9,0,649},{11,0,71},{11,0,155},{11,0,313},{12,0,5},{13,0,325
+-},{142,0,287},{134,0,1818},{136,0,1007},{138,0,321},{7,0,360},{7,0,425},{9,0,66}
+-,{9,0,278},{138,0,644},{133,10,818},{5,0,385},{5,10,541},{6,10,94},{6,10,499},{7
+-,10,230},{139,10,321},{4,10,920},{5,10,25},{5,10,790},{6,10,457},{7,10,853},{136
+-,10,788},{4,0,900},{133,0,861},{5,0,254},{7,0,985},{136,0,73},{7,0,1959},{136,0,
+-683},{134,10,1765},{133,10,822},{132,10,634},{4,11,29},{6,11,532},{7,11,1628},{7
+-,11,1648},{9,11,303},{9,11,350},{10,11,433},{11,11,97},{11,11,557},{11,11,745},{
+-12,11,289},{12,11,335},{12,11,348},{12,11,606},{13,11,116},{13,11,233},{13,11,
+-466},{14,11,181},{14,11,209},{14,11,232},{14,11,236},{14,11,300},{16,11,41},{148
+-,11,97},{19,0,86},{6,10,36},{7,10,658},{136,10,454},{135,11,1692},{132,0,725},{5
+-,11,501},{7,11,1704},{9,11,553},{11,11,520},{12,11,557},{141,11,249},{134,0,196}
+-,{133,0,831},{136,0,723},{7,0,1897},{13,0,80},{13,0,437},{145,0,74},{4,0,992},{6
+-,0,627},{136,0,994},{135,11,1294},{132,10,104},{5,0,848},{6,0,66},{136,0,764},{4
+-,0,36},{7,0,1387},{10,0,205},{139,0,755},{6,0,1046},{134,0,1485},{134,0,950},{
+-132,0,887},{14,0,450},{148,0,111},{7,0,620},{7,0,831},{9,10,542},{9,10,566},{138
+-,10,728},{6,0,165},{138,0,388},{139,10,263},{4,0,719},{135,0,155},{138,10,468},{
+-6,11,453},{144,11,36},{134,11,129},{5,0,533},{7,0,755},{138,0,780},{134,0,1465},
+-{4,0,353},{6,0,146},{6,0,1789},{7,0,427},{7,0,990},{7,0,1348},{9,0,665},{9,0,898
+-},{11,0,893},{142,0,212},{7,10,87},{142,10,288},{4,0,45},{135,0,1257},{12,0,7},{
+-7,10,988},{7,10,1939},{9,10,64},{9,10,502},{12,10,34},{13,10,12},{13,10,234},{
+-147,10,77},{4,0,607},{5,11,60},{6,11,504},{7,11,614},{7,11,1155},{140,11,0},{135
+-,10,141},{8,11,198},{11,11,29},{140,11,534},{140,0,65},{136,0,816},{132,10,619},
+-{139,0,88},{5,10,246},{8,10,189},{9,10,355},{9,10,512},{10,10,124},{10,10,453},{
+-11,10,143},{11,10,416},{11,10,859},{141,10,341},{4,11,379},{135,11,1397},{4,0,
+-600},{137,0,621},{133,0,367},{134,0,561},{6,0,559},{134,0,1691},{6,0,585},{134,
+-11,585},{135,11,1228},{4,11,118},{5,10,678},{6,11,274},{6,11,361},{7,11,75},{141
+-,11,441},{135,11,1818},{137,11,841},{5,0,573},{6,0,287},{7,10,862},{7,10,1886},{
+-138,10,179},{132,10,517},{140,11,693},{5,11,314},{6,11,221},{7,11,419},{10,11,
+-650},{11,11,396},{12,11,156},{13,11,369},{14,11,333},{145,11,47},{140,10,540},{
+-136,10,667},{11,10,403},{146,10,83},{6,0,672},{133,10,761},{9,0,157},{10,10,131}
+-,{140,10,72},{7,0,714},{134,11,460},{134,0,456},{133,0,925},{5,11,682},{135,11,
+-1887},{136,11,510},{136,11,475},{133,11,1016},{9,0,19},{7,11,602},{8,11,179},{10
+-,11,781},{140,11,126},{6,11,329},{138,11,111},{6,0,822},{134,0,1473},{144,11,86}
+-,{11,0,113},{139,11,113},{5,11,821},{134,11,1687},{133,10,449},{7,0,463},{17,0,
+-69},{136,10,103},{7,10,2028},{138,10,641},{6,0,193},{7,0,240},{7,0,1682},{10,0,
+-51},{10,0,640},{11,0,410},{13,0,82},{14,0,247},{14,0,331},{142,0,377},{6,0,471},
+-{11,0,411},{142,0,2},{5,11,71},{7,11,1407},{9,11,388},{9,11,704},{10,11,261},{10
+-,11,619},{11,11,547},{11,11,619},{143,11,157},{136,0,633},{135,0,1148},{6,0,554}
+-,{7,0,1392},{12,0,129},{7,10,1274},{7,10,1386},{7,11,2008},{9,11,337},{10,11,517
+-},{146,10,87},{7,0,803},{8,0,542},{6,10,187},{7,10,1203},{8,10,380},{14,10,117},
+-{149,10,28},{6,10,297},{7,10,793},{139,10,938},{8,0,438},{11,0,363},{7,10,464},{
+-11,10,105},{12,10,231},{14,10,386},{15,10,102},{148,10,75},{5,11,16},{6,11,86},{
+-6,11,603},{7,11,292},{7,11,561},{8,11,257},{8,11,382},{9,11,721},{9,11,778},{11,
+-11,581},{140,11,466},{6,0,717},{4,11,486},{133,11,491},{132,0,875},{132,11,72},{
+-6,11,265},{135,11,847},{4,0,237},{135,0,514},{6,0,392},{7,0,65},{135,0,2019},{
+-140,11,261},{135,11,922},{137,11,404},{12,0,563},{14,0,101},{18,0,129},{7,10,
+-1010},{11,10,733},{11,10,759},{13,10,34},{146,10,45},{7,10,1656},{9,10,369},{10,
+-10,338},{10,10,490},{11,10,154},{11,10,545},{11,10,775},{13,10,77},{141,10,274},
+-{4,0,444},{10,0,146},{140,0,9},{139,11,163},{7,0,1260},{135,0,1790},{9,0,222},{
+-10,0,43},{139,0,900},{137,11,234},{138,0,971},{137,0,761},{134,0,699},{136,11,
+-434},{6,0,1116},{7,0,1366},{5,10,20},{6,11,197},{6,10,298},{7,10,659},{8,11,205}
+-,{137,10,219},{132,11,490},{11,11,820},{150,11,51},{7,10,1440},{11,10,854},{11,
+-10,872},{11,10,921},{12,10,551},{13,10,472},{142,10,367},{140,11,13},{132,0,829}
+-,{12,0,242},{132,10,439},{136,10,669},{6,0,593},{6,11,452},{7,11,312},{138,11,
+-219},{4,11,333},{9,11,176},{12,11,353},{141,11,187},{7,0,36},{8,0,201},{136,0,
+-605},{140,0,224},{132,10,233},{134,0,1430},{134,0,1806},{4,0,523},{133,0,638},{6
+-,0,1889},{9,0,958},{9,0,971},{9,0,976},{12,0,796},{12,0,799},{12,0,808},{12,0,
+-835},{12,0,836},{12,0,914},{12,0,946},{15,0,216},{15,0,232},{18,0,183},{18,0,187
+-},{18,0,194},{18,0,212},{18,0,232},{149,0,49},{132,10,482},{6,0,827},{134,0,1434
+-},{135,10,346},{134,0,2043},{6,0,242},{7,0,227},{7,0,1581},{8,0,104},{9,0,113},{
+-9,0,220},{9,0,427},{10,0,136},{10,0,239},{11,0,579},{11,0,1023},{13,0,4},{13,0,
+-204},{13,0,316},{148,0,86},{134,11,1685},{7,0,148},{8,0,284},{141,0,63},{142,0,
+-10},{135,11,584},{134,0,1249},{7,0,861},{135,10,334},{5,10,795},{6,10,1741},{137
+-,11,70},{132,0,807},{7,11,135},{8,11,7},{8,11,62},{9,11,243},{10,11,658},{10,11,
+-697},{11,11,456},{139,11,756},{9,11,395},{138,11,79},{137,11,108},{147,0,94},{
+-136,0,494},{135,11,631},{135,10,622},{7,0,1510},{135,10,1750},{4,10,203},{135,10
+-,1936},{7,11,406},{7,11,459},{8,11,606},{139,11,726},{7,0,1306},{8,0,505},{9,0,
+-482},{10,0,126},{11,0,225},{12,0,347},{12,0,449},{13,0,19},{14,0,218},{142,0,435
+-},{5,0,268},{10,0,764},{12,0,120},{13,0,39},{145,0,127},{142,11,68},{11,10,678},
+-{140,10,307},{12,11,268},{12,11,640},{142,11,119},{135,10,2044},{133,11,612},{4,
+-11,372},{7,11,482},{8,11,158},{9,11,602},{9,11,615},{10,11,245},{10,11,678},{10,
+-11,744},{11,11,248},{139,11,806},{7,10,311},{9,10,308},{140,10,255},{4,0,384},{
+-135,0,1022},{5,11,854},{135,11,1991},{135,10,1266},{4,10,400},{5,10,267},{135,10
+-,232},{135,0,1703},{9,0,159},{11,0,661},{140,0,603},{4,0,964},{14,0,438},{14,0,
+-444},{14,0,456},{22,0,60},{22,0,63},{9,11,106},{9,11,163},{9,11,296},{10,11,167}
+-,{10,11,172},{10,11,777},{139,11,16},{136,0,583},{132,0,515},{8,0,632},{8,0,697}
+-,{137,0,854},{5,11,195},{135,11,1685},{6,0,1123},{134,0,1365},{134,11,328},{7,11
+-,1997},{8,11,730},{139,11,1006},{4,0,136},{133,0,551},{134,0,1782},{7,0,1287},{9
+-,0,44},{10,0,552},{10,0,642},{11,0,839},{12,0,274},{12,0,275},{12,0,372},{13,0,
+-91},{142,0,125},{5,11,751},{11,11,797},{140,11,203},{133,0,732},{7,0,679},{8,0,
+-313},{4,10,100},{135,11,821},{10,0,361},{142,0,316},{134,0,595},{6,0,147},{7,0,
+-886},{9,0,753},{138,0,268},{5,10,362},{5,10,443},{6,10,318},{7,10,1019},{139,10,
+-623},{5,10,463},{136,10,296},{4,10,454},{5,11,950},{5,11,994},{134,11,351},{138,
+-0,137},{5,10,48},{5,10,404},{6,10,557},{7,10,458},{8,10,597},{10,10,455},{10,10,
+-606},{11,10,49},{11,10,548},{12,10,476},{13,10,18},{141,10,450},{133,0,414},{135
+-,0,1762},{5,11,421},{135,11,47},{5,10,442},{135,10,1984},{134,0,599},{134,0,1749
+-},{134,0,1627},{4,0,488},{132,11,350},{137,11,751},{132,0,83},{140,0,676},{133,
+-11,967},{7,0,1639},{5,10,55},{140,10,161},{4,11,473},{7,11,623},{8,11,808},{9,11
+-,871},{9,11,893},{11,11,38},{11,11,431},{12,11,112},{12,11,217},{12,11,243},{12,
+-11,562},{12,11,683},{13,11,141},{13,11,197},{13,11,227},{13,11,406},{13,11,487},
+-{14,11,156},{14,11,203},{14,11,224},{14,11,256},{18,11,58},{150,11,0},{133,10,
+-450},{7,11,736},{139,11,264},{134,0,278},{4,11,222},{7,11,286},{136,11,629},{135
+-,10,869},{140,0,97},{144,0,14},{134,0,1085},{4,10,213},{7,10,223},{136,10,80},{7
+-,0,388},{7,0,644},{139,0,781},{132,0,849},{7,0,229},{8,0,59},{9,0,190},{10,0,378
+-},{140,0,191},{7,10,381},{7,10,806},{7,10,820},{8,10,354},{8,10,437},{8,10,787},
+-{9,10,657},{10,10,58},{10,10,339},{10,10,749},{11,10,914},{12,10,162},{13,10,75}
+-,{14,10,106},{14,10,198},{14,10,320},{14,10,413},{146,10,43},{141,11,306},{136,
+-10,747},{134,0,1115},{16,0,94},{16,0,108},{136,11,146},{6,0,700},{6,0,817},{134,
+-0,1002},{133,10,692},{4,11,465},{135,11,1663},{134,10,191},{6,0,1414},{135,11,
+-913},{132,0,660},{7,0,1035},{138,0,737},{6,10,162},{7,10,1960},{136,10,831},{132
+-,10,706},{7,0,690},{9,0,217},{9,0,587},{140,0,521},{138,10,426},{135,10,1235},{6
+-,11,82},{7,11,138},{7,11,517},{9,11,673},{139,11,238},{138,0,272},{5,11,495},{7,
+-11,834},{9,11,733},{139,11,378},{134,0,1744},{132,0,1011},{7,11,828},{142,11,116
+-},{4,0,733},{9,0,194},{10,0,92},{11,0,198},{12,0,84},{13,0,128},{133,11,559},{10
+-,0,57},{10,0,277},{6,11,21},{6,11,1737},{7,11,1444},{136,11,224},{4,10,204},{137
+-,10,902},{136,10,833},{11,0,348},{12,0,99},{18,0,1},{18,0,11},{19,0,4},{7,10,366
+-},{9,10,287},{12,10,199},{12,10,556},{140,10,577},{6,0,1981},{136,0,936},{21,0,
+-33},{150,0,40},{5,11,519},{138,11,204},{5,10,356},{135,10,224},{134,0,775},{135,
+-0,306},{7,10,630},{9,10,567},{11,10,150},{11,10,444},{141,10,119},{5,0,979},{134
+-,10,539},{133,0,611},{4,11,402},{135,11,1679},{5,0,178},{7,11,2},{8,11,323},{136
+-,11,479},{5,11,59},{135,11,672},{4,0,1010},{6,0,1969},{138,11,237},{133,11,412},
+-{146,11,34},{7,11,1740},{146,11,48},{134,0,664},{139,10,814},{4,11,85},{135,11,
+-549},{133,11,94},{133,11,457},{132,0,390},{134,0,1510},{4,10,235},{135,10,255},{
+-4,10,194},{5,10,584},{6,11,11},{6,10,384},{7,11,187},{7,10,583},{10,10,761},{11,
+-10,760},{139,10,851},{4,11,522},{139,11,802},{135,0,493},{10,11,776},{13,11,345}
+-,{142,11,425},{146,0,37},{4,11,52},{135,11,661},{134,0,724},{134,0,829},{133,11,
+-520},{133,10,562},{4,11,281},{5,11,38},{7,11,194},{7,11,668},{7,11,1893},{137,11
+-,397},{5,10,191},{137,10,271},{7,0,1537},{14,0,96},{143,0,73},{5,0,473},{11,0,
+-168},{4,10,470},{6,10,153},{7,10,1503},{7,10,1923},{10,10,701},{11,10,132},{11,
+-10,227},{11,10,320},{11,10,436},{11,10,525},{11,10,855},{12,10,41},{12,10,286},{
+-13,10,103},{13,10,284},{14,10,255},{14,10,262},{15,10,117},{143,10,127},{133,0,
+-105},{5,0,438},{9,0,694},{12,0,627},{141,0,210},{133,10,327},{6,10,552},{7,10,
+-1754},{137,10,604},{134,0,1256},{152,0,11},{5,11,448},{11,11,98},{139,11,524},{7
+-,0,1626},{5,10,80},{6,10,405},{7,10,403},{7,10,1502},{8,10,456},{9,10,487},{9,10
+-,853},{9,10,889},{10,10,309},{11,10,721},{11,10,994},{12,10,430},{13,10,165},{14
+-,11,16},{146,11,44},{132,0,779},{8,0,25},{138,0,826},{4,10,453},{5,10,887},{6,10
+-,535},{8,10,6},{8,10,543},{136,10,826},{137,11,461},{140,11,632},{132,0,308},{
+-135,0,741},{132,0,671},{7,0,150},{8,0,649},{136,0,1020},{9,0,99},{6,11,336},{8,
+-11,552},{9,11,285},{10,11,99},{139,11,568},{134,0,521},{5,0,339},{14,0,3},{15,0,
+-41},{15,0,166},{147,0,66},{6,11,423},{7,11,665},{7,11,1210},{9,11,218},{141,11,
+-222},{6,0,543},{5,10,101},{5,11,256},{6,10,88},{7,10,1677},{9,10,100},{10,10,677
+-},{14,10,169},{14,10,302},{14,10,313},{15,10,48},{143,10,84},{4,10,310},{7,10,
+-708},{7,10,996},{9,10,795},{10,10,390},{10,10,733},{11,10,451},{12,10,249},{14,
+-10,115},{14,10,286},{143,10,100},{133,10,587},{13,11,417},{14,11,129},{143,11,15
+-},{134,0,1358},{136,11,554},{132,10,498},{7,10,217},{8,10,140},{138,10,610},{135
+-,11,989},{135,11,634},{6,0,155},{140,0,234},{135,11,462},{132,11,618},{134,0,
+-1628},{132,0,766},{4,11,339},{5,10,905},{135,11,259},{135,0,829},{4,11,759},{141
+-,11,169},{7,0,1445},{4,10,456},{7,10,358},{7,10,1637},{8,10,643},{139,10,483},{5
+-,0,486},{135,0,1349},{5,11,688},{135,11,712},{7,0,1635},{8,0,17},{10,0,217},{10,
+-0,295},{12,0,2},{140,11,2},{138,0,558},{150,10,56},{4,11,278},{5,11,465},{135,11
+-,1367},{136,11,482},{133,10,535},{6,0,1362},{6,0,1461},{10,11,274},{10,11,625},{
+-139,11,530},{5,0,599},{5,11,336},{6,11,341},{6,11,478},{6,11,1763},{136,11,386},
+-{7,10,1748},{137,11,151},{134,0,1376},{133,10,539},{135,11,73},{135,11,1971},{
+-139,11,283},{9,0,93},{139,0,474},{6,10,91},{135,10,435},{6,0,447},{5,11,396},{
+-134,11,501},{4,10,16},{5,10,316},{5,10,842},{6,10,370},{6,10,1778},{8,10,166},{
+-11,10,812},{12,10,206},{12,10,351},{14,10,418},{16,10,15},{16,10,34},{18,10,3},{
+-19,10,3},{19,10,7},{20,10,4},{149,10,21},{7,0,577},{7,0,1432},{9,0,475},{9,0,505
+-},{9,0,526},{9,0,609},{9,0,689},{9,0,726},{9,0,735},{9,0,738},{10,0,556},{10,0,
+-674},{10,0,684},{11,0,89},{11,0,202},{11,0,272},{11,0,380},{11,0,415},{11,0,505}
+-,{11,0,537},{11,0,550},{11,0,562},{11,0,640},{11,0,667},{11,0,688},{11,0,847},{
+-11,0,927},{11,0,930},{11,0,940},{12,0,144},{12,0,325},{12,0,329},{12,0,389},{12,
+-0,403},{12,0,451},{12,0,515},{12,0,604},{12,0,616},{12,0,626},{13,0,66},{13,0,
+-131},{13,0,167},{13,0,236},{13,0,368},{13,0,411},{13,0,434},{13,0,453},{13,0,461
+-},{13,0,474},{14,0,59},{14,0,60},{14,0,139},{14,0,152},{14,0,276},{14,0,353},{14
+-,0,402},{15,0,28},{15,0,81},{15,0,123},{15,0,152},{18,0,136},{148,0,88},{4,11,
+-929},{133,11,799},{136,11,46},{142,0,307},{4,0,609},{7,0,756},{9,0,544},{11,0,
+-413},{144,0,25},{10,0,687},{7,10,619},{10,10,547},{11,10,122},{140,10,601},{4,0,
+-930},{133,0,947},{133,0,939},{142,0,21},{4,11,892},{133,11,770},{133,0,962},{5,0
+-,651},{8,0,170},{9,0,61},{9,0,63},{10,0,23},{10,0,37},{10,0,834},{11,0,4},{11,0,
+-187},{11,0,281},{11,0,503},{11,0,677},{12,0,96},{12,0,130},{12,0,244},{14,0,5},{
+-14,0,40},{14,0,162},{14,0,202},{146,0,133},{4,0,406},{5,0,579},{12,0,492},{150,0
+-,15},{135,11,158},{135,0,597},{132,0,981},{132,10,888},{4,10,149},{138,10,368},{
+-132,0,545},{4,10,154},{7,10,1134},{136,10,105},{135,11,2001},{134,0,1558},{4,10,
+-31},{6,10,429},{7,10,962},{9,10,458},{139,10,691},{132,10,312},{135,10,1642},{6,
+-0,17},{6,0,1304},{7,0,16},{7,0,1001},{9,0,886},{10,0,489},{10,0,800},{11,0,782},
+-{12,0,320},{13,0,467},{14,0,145},{14,0,387},{143,0,119},{135,0,1982},{17,0,17},{
+-7,11,1461},{140,11,91},{4,10,236},{132,11,602},{138,0,907},{136,0,110},{7,0,272}
+-,{19,0,53},{5,10,836},{5,10,857},{134,10,1680},{5,0,458},{7,11,1218},{136,11,303
+-},{7,0,1983},{8,0,0},{8,0,171},{9,0,120},{9,0,732},{10,0,473},{11,0,656},{11,0,
+-998},{18,0,0},{18,0,2},{19,0,21},{10,10,68},{139,10,494},{137,11,662},{4,11,13},
+-{5,11,567},{7,11,1498},{9,11,124},{11,11,521},{140,11,405},{4,10,81},{139,10,867
+-},{135,11,1006},{7,11,800},{7,11,1783},{138,11,12},{9,0,295},{10,0,443},{5,10,
+-282},{8,10,650},{137,10,907},{132,11,735},{4,11,170},{4,10,775},{135,11,323},{6,
+-0,1844},{10,0,924},{11,11,844},{12,11,104},{140,11,625},{5,11,304},{7,11,1403},{
+-140,11,498},{134,0,1232},{4,0,519},{10,0,70},{12,0,26},{14,0,17},{14,0,178},{15,
+-0,34},{149,0,12},{132,0,993},{4,11,148},{133,11,742},{6,0,31},{7,0,491},{7,0,530
+-},{8,0,592},{11,0,53},{11,0,779},{12,0,167},{12,0,411},{14,0,14},{14,0,136},{15,
+-0,72},{16,0,17},{144,0,72},{133,0,907},{134,0,733},{133,11,111},{4,10,71},{5,10,
+-376},{7,10,119},{138,10,665},{136,0,55},{8,0,430},{136,11,430},{4,0,208},{5,0,
+-106},{6,0,531},{8,0,408},{9,0,188},{138,0,572},{12,0,56},{11,10,827},{14,10,34},
+-{143,10,148},{134,0,1693},{133,11,444},{132,10,479},{140,0,441},{9,0,449},{10,0,
+-192},{138,0,740},{134,0,928},{4,0,241},{7,10,607},{136,10,99},{8,11,123},{15,11,
+-6},{144,11,7},{6,11,285},{8,11,654},{11,11,749},{12,11,190},{12,11,327},{13,11,
+-120},{13,11,121},{13,11,327},{15,11,47},{146,11,40},{4,10,41},{5,10,74},{7,10,
+-1627},{11,10,871},{140,10,619},{7,0,1525},{11,10,329},{11,10,965},{12,10,241},{
+-14,10,354},{15,10,22},{148,10,63},{132,0,259},{135,11,183},{9,10,209},{137,10,
+-300},{5,11,937},{135,11,100},{133,10,98},{4,0,173},{5,0,312},{5,0,512},{135,0,
+-1285},{141,0,185},{7,0,1603},{7,0,1691},{9,0,464},{11,0,195},{12,0,279},{12,0,
+-448},{14,0,11},{147,0,102},{135,0,1113},{133,10,984},{4,0,452},{5,0,583},{135,0,
+-720},{4,0,547},{5,0,817},{6,0,433},{7,0,593},{7,0,1378},{8,0,161},{9,0,284},{10,
+-0,313},{139,0,886},{8,0,722},{4,10,182},{6,10,205},{135,10,220},{150,0,13},{4,10
+-,42},{9,10,205},{9,10,786},{138,10,659},{6,0,289},{7,0,1670},{12,0,57},{151,0,4}
+-,{132,10,635},{14,0,43},{146,0,21},{139,10,533},{135,0,1694},{8,0,420},{139,0,
+-193},{135,0,409},{132,10,371},{4,10,272},{135,10,836},{5,10,825},{134,10,1640},{
+-5,11,251},{5,11,956},{8,11,268},{9,11,214},{146,11,142},{138,0,308},{6,0,1863},{
+-141,11,37},{137,10,879},{7,10,317},{135,10,569},{132,11,294},{134,0,790},{5,0,
+-1002},{136,0,745},{5,11,346},{5,11,711},{136,11,390},{135,0,289},{5,0,504},{11,0
+-,68},{137,10,307},{4,0,239},{6,0,477},{7,0,1607},{139,0,617},{149,0,13},{133,0,
+-609},{133,11,624},{5,11,783},{7,11,1998},{135,11,2047},{133,10,525},{132,0,367},
+-{132,11,594},{6,0,528},{133,10,493},{4,10,174},{135,10,911},{8,10,417},{137,10,
+-782},{132,0,694},{7,0,548},{137,0,58},{4,10,32},{5,10,215},{6,10,269},{7,10,1782
+-},{7,10,1892},{10,10,16},{11,10,822},{11,10,954},{141,10,481},{140,0,687},{7,0,
+-1749},{136,10,477},{132,11,569},{133,10,308},{135,10,1088},{4,0,661},{138,0,1004
+-},{5,11,37},{6,11,39},{6,11,451},{7,11,218},{7,11,667},{7,11,1166},{7,11,1687},{
+-8,11,662},{144,11,2},{9,0,445},{12,0,53},{13,0,492},{5,10,126},{8,10,297},{9,10,
+-366},{140,10,374},{7,10,1551},{139,10,361},{148,0,74},{134,11,508},{135,0,213},{
+-132,10,175},{132,10,685},{6,0,760},{6,0,834},{134,0,1248},{7,11,453},{7,11,635},
+-{7,11,796},{8,11,331},{9,11,328},{9,11,330},{9,11,865},{10,11,119},{10,11,235},{
+-11,11,111},{11,11,129},{11,11,240},{12,11,31},{12,11,66},{12,11,222},{12,11,269}
+-,{12,11,599},{12,11,689},{13,11,186},{13,11,364},{142,11,345},{7,0,1672},{139,0,
+-189},{133,10,797},{133,10,565},{6,0,1548},{6,11,98},{7,11,585},{135,11,702},{9,0
+-,968},{15,0,192},{149,0,56},{4,10,252},{6,11,37},{7,11,299},{7,10,1068},{7,11,
+-1666},{8,11,195},{8,11,316},{9,11,178},{9,11,276},{9,11,339},{9,11,536},{10,11,
+-102},{10,11,362},{10,10,434},{10,11,785},{11,11,55},{11,11,149},{11,10,228},{11,
+-10,426},{11,11,773},{13,10,231},{13,11,416},{13,11,419},{14,11,38},{14,11,41},{
+-14,11,210},{18,10,106},{148,10,87},{4,0,751},{11,0,390},{140,0,32},{4,0,409},{
+-133,0,78},{11,11,458},{12,11,15},{140,11,432},{7,0,1602},{10,0,257},{10,0,698},{
+-11,0,544},{11,0,585},{12,0,212},{13,0,307},{5,10,231},{7,10,601},{9,10,277},{9,
+-10,674},{10,10,178},{10,10,418},{10,10,509},{11,10,531},{12,10,113},{12,10,475},
+-{13,10,99},{142,10,428},{6,0,473},{145,0,105},{6,0,1949},{15,0,156},{133,11,645}
+-,{7,10,1591},{144,10,43},{135,0,1779},{135,10,1683},{4,11,290},{135,11,1356},{
+-134,0,763},{6,11,70},{7,11,1292},{10,11,762},{139,11,288},{142,0,29},{140,11,428
+-},{7,0,883},{7,11,131},{7,11,422},{8,11,210},{140,11,573},{134,0,488},{4,10,399}
+-,{5,10,119},{5,10,494},{7,10,751},{137,10,556},{133,0,617},{132,11,936},{139,0,
+-50},{7,0,1518},{139,0,694},{137,0,785},{4,0,546},{135,0,2042},{7,11,716},{13,11,
+-97},{141,11,251},{132,11,653},{145,0,22},{134,0,1016},{4,0,313},{133,0,577},{136
+-,11,657},{8,0,184},{141,0,433},{135,0,935},{6,0,720},{9,0,114},{146,11,80},{12,0
+-,186},{12,0,292},{14,0,100},{18,0,70},{7,10,594},{7,10,851},{7,10,1858},{9,10,
+-411},{9,10,574},{9,10,666},{9,10,737},{10,10,346},{10,10,712},{11,10,246},{11,10
+-,432},{11,10,517},{11,10,647},{11,10,679},{11,10,727},{12,10,304},{12,10,305},{
+-12,10,323},{12,10,483},{12,10,572},{12,10,593},{12,10,602},{13,10,95},{13,10,101
+-},{13,10,171},{13,10,315},{13,10,378},{13,10,425},{13,10,475},{14,10,63},{14,10,
+-380},{14,10,384},{15,10,133},{18,10,112},{148,10,72},{135,10,1093},{135,11,1836}
+-,{132,10,679},{137,10,203},{11,0,402},{12,0,109},{12,0,431},{13,0,179},{13,0,206
+-},{14,0,217},{16,0,3},{148,0,53},{7,11,1368},{8,11,232},{8,11,361},{10,11,682},{
+-138,11,742},{137,10,714},{5,0,886},{6,0,46},{6,0,1790},{7,0,14},{7,0,732},{7,0,
+-1654},{8,0,95},{8,0,327},{8,0,616},{9,0,892},{10,0,598},{10,0,769},{11,0,134},{
+-11,0,747},{12,0,378},{14,0,97},{137,11,534},{4,0,969},{136,10,825},{137,11,27},{
+-6,0,727},{142,11,12},{133,0,1021},{134,0,1190},{134,11,1657},{5,10,143},{5,10,
+-769},{6,10,1760},{7,10,682},{7,10,1992},{136,10,736},{132,0,153},{135,11,127},{
+-133,0,798},{132,0,587},{6,0,598},{7,0,42},{8,0,695},{10,0,212},{11,0,158},{14,0,
+-196},{145,0,85},{133,10,860},{6,0,1929},{134,0,1933},{5,0,957},{5,0,1008},{9,0,
+-577},{12,0,141},{6,10,422},{7,10,0},{7,10,1544},{8,11,364},{11,10,990},{12,10,
+-453},{13,10,47},{141,10,266},{134,0,1319},{4,0,129},{135,0,465},{7,0,470},{7,0,
+-1057},{7,0,1201},{9,0,755},{11,0,906},{140,0,527},{7,0,908},{146,0,7},{5,0,148},
+-{136,0,450},{5,10,515},{137,10,131},{7,10,1605},{11,10,962},{146,10,139},{132,10
+-,646},{134,0,1166},{4,10,396},{7,10,728},{9,10,117},{13,10,202},{148,10,51},{6,
+-10,121},{6,10,124},{6,10,357},{7,10,1138},{7,10,1295},{8,10,162},{139,10,655},{
+-14,0,374},{142,11,374},{138,0,253},{139,0,1003},{5,11,909},{9,11,849},{138,11,
+-805},{133,10,237},{7,11,525},{7,11,1579},{8,11,497},{136,11,573},{137,0,46},{132
+-,0,879},{134,0,806},{135,0,1868},{6,0,1837},{134,0,1846},{6,0,730},{134,0,881},{
+-7,0,965},{7,0,1460},{7,0,1604},{7,11,193},{7,11,397},{7,11,1105},{8,11,124},{8,
+-11,619},{9,11,305},{10,11,264},{11,11,40},{12,11,349},{13,11,134},{13,11,295},{
+-14,11,155},{15,11,120},{146,11,105},{136,0,506},{143,0,10},{4,11,262},{7,11,342}
+-,{7,10,571},{7,10,1877},{10,10,366},{141,11,23},{133,11,641},{10,0,22},{9,10,513
+-},{10,10,39},{12,10,122},{140,10,187},{135,11,1431},{150,11,49},{4,11,99},{6,11,
+-250},{6,11,346},{8,11,127},{138,11,81},{6,0,2014},{8,0,928},{10,0,960},{10,0,979
+-},{140,0,996},{134,0,296},{132,11,915},{5,11,75},{9,11,517},{10,11,470},{12,11,
+-155},{141,11,224},{137,10,873},{4,0,854},{140,11,18},{134,0,587},{7,10,107},{7,
+-10,838},{8,10,550},{138,10,401},{11,0,636},{15,0,145},{17,0,34},{19,0,50},{23,0,
+-20},{11,10,588},{11,10,864},{11,10,968},{143,10,160},{135,11,216},{7,0,982},{10,
+-0,32},{143,0,56},{133,10,768},{133,11,954},{6,11,304},{7,11,1114},{8,11,418},{10
+-,11,345},{11,11,341},{11,11,675},{141,11,40},{9,11,410},{139,11,425},{136,0,941}
+-,{5,0,435},{132,10,894},{5,0,85},{6,0,419},{7,0,134},{7,0,305},{7,0,361},{7,0,
+-1337},{8,0,71},{140,0,519},{140,0,688},{135,0,740},{5,0,691},{7,0,345},{9,0,94},
+-{140,0,169},{5,0,183},{6,0,582},{10,0,679},{140,0,435},{134,11,14},{6,0,945},{
+-135,0,511},{134,11,1708},{5,11,113},{6,11,243},{7,11,1865},{11,11,161},{16,11,37
+-},{145,11,99},{132,11,274},{137,0,539},{7,0,1993},{8,0,684},{134,10,272},{6,0,
+-659},{134,0,982},{4,10,9},{5,10,128},{7,10,368},{11,10,480},{148,10,3},{134,0,
+-583},{132,0,803},{133,0,704},{4,0,179},{5,0,198},{133,0,697},{7,0,347},{7,0,971}
+-,{8,0,181},{10,0,711},{135,11,166},{136,10,682},{4,10,2},{7,10,545},{7,10,894},{
+-136,11,521},{135,0,481},{132,0,243},{5,0,203},{7,0,19},{7,0,71},{7,0,113},{10,0,
+-405},{11,0,357},{142,0,240},{5,11,725},{5,11,727},{135,11,1811},{6,0,826},{137,
+-11,304},{7,0,1450},{139,0,99},{133,11,654},{134,0,492},{5,0,134},{6,0,408},{6,0,
+-495},{7,0,1593},{6,11,273},{10,11,188},{13,11,377},{146,11,77},{9,10,769},{140,
+-10,185},{135,11,410},{142,0,4},{4,0,665},{134,11,1785},{4,0,248},{7,0,137},{137,
+-0,349},{5,10,530},{142,10,113},{7,0,1270},{139,0,612},{132,11,780},{5,0,371},{
+-135,0,563},{135,0,826},{6,0,1535},{23,0,21},{151,0,23},{4,0,374},{7,0,547},{7,0,
+-1700},{7,0,1833},{139,0,858},{133,10,556},{7,11,612},{8,11,545},{8,11,568},{8,11
+-,642},{9,11,717},{10,11,541},{10,11,763},{11,11,449},{12,11,489},{13,11,153},{13
+-,11,296},{14,11,138},{14,11,392},{15,11,50},{16,11,6},{16,11,12},{148,11,9},{9,0
+-,311},{141,0,42},{8,10,16},{140,10,568},{6,0,1968},{6,0,2027},{138,0,991},{6,0,
+-1647},{7,0,1552},{7,0,2010},{9,0,494},{137,0,509},{133,11,948},{6,10,186},{137,
+-10,426},{134,0,769},{134,0,642},{132,10,585},{6,0,123},{7,0,214},{9,0,728},{10,0
+-,157},{11,0,346},{11,0,662},{143,0,106},{142,11,381},{135,0,1435},{4,11,532},{5,
+-11,706},{135,11,662},{5,11,837},{134,11,1651},{4,10,93},{5,10,252},{6,10,229},{7
+-,10,291},{9,10,550},{139,10,644},{148,0,79},{137,10,749},{134,0,1425},{137,10,
+-162},{4,11,362},{7,11,52},{7,11,303},{140,11,166},{132,10,381},{4,11,330},{7,11,
+-933},{7,11,2012},{136,11,292},{135,11,767},{4,0,707},{5,0,588},{6,0,393},{13,0,
+-106},{18,0,49},{147,0,41},{6,0,211},{7,0,1690},{11,0,486},{140,0,369},{137,11,
+-883},{4,11,703},{135,11,207},{4,0,187},{5,0,184},{5,0,690},{7,0,1869},{10,0,756}
+-,{139,0,783},{132,11,571},{134,0,1382},{5,0,175},{6,10,77},{6,10,157},{7,10,974}
+-,{7,10,1301},{7,10,1339},{7,10,1490},{7,10,1873},{137,10,628},{134,0,1493},{5,11
+-,873},{133,11,960},{134,0,1007},{12,11,93},{12,11,501},{13,11,362},{14,11,151},{
+-15,11,40},{15,11,59},{16,11,46},{17,11,25},{18,11,14},{18,11,134},{19,11,25},{19
+-,11,69},{20,11,16},{20,11,19},{20,11,66},{21,11,23},{21,11,25},{150,11,42},{11,
+-10,919},{141,10,409},{134,0,219},{5,0,582},{6,0,1646},{7,0,99},{7,0,1962},{7,0,
+-1986},{8,0,515},{8,0,773},{9,0,23},{9,0,491},{12,0,620},{142,0,93},{133,0,851},{
+-5,11,33},{134,11,470},{135,11,1291},{134,0,1278},{135,11,1882},{135,10,1489},{
+-132,0,1000},{138,0,982},{8,0,762},{8,0,812},{137,0,910},{6,11,47},{7,11,90},{7,
+-11,664},{7,11,830},{7,11,1380},{7,11,2025},{8,11,448},{136,11,828},{4,0,98},{4,0
+-,940},{6,0,1819},{6,0,1834},{6,0,1841},{7,0,1365},{8,0,859},{8,0,897},{8,0,918},
+-{9,0,422},{9,0,670},{10,0,775},{10,0,894},{10,0,909},{10,0,910},{10,0,935},{11,0
+-,210},{12,0,750},{12,0,755},{13,0,26},{13,0,457},{13,0,476},{16,0,100},{16,0,109
+-},{18,0,173},{18,0,175},{8,10,398},{9,10,681},{139,10,632},{9,11,417},{137,11,
+-493},{136,10,645},{138,0,906},{134,0,1730},{134,10,20},{133,11,1019},{134,0,1185
+-},{10,0,40},{136,10,769},{9,0,147},{134,11,208},{140,0,650},{5,0,209},{6,0,30},{
+-11,0,56},{139,0,305},{132,0,553},{138,11,344},{6,11,68},{7,11,398},{7,11,448},{7
+-,11,1629},{7,11,1813},{8,11,387},{8,11,442},{9,11,710},{10,11,282},{138,11,722},
+-{5,0,597},{14,0,20},{142,11,20},{135,0,1614},{135,10,1757},{4,0,150},{5,0,303},{
+-6,0,327},{135,10,937},{16,0,49},{7,10,1652},{144,11,49},{8,0,192},{10,0,78},{141
+-,0,359},{135,0,786},{143,0,134},{6,0,1638},{7,0,79},{7,0,496},{9,0,138},{10,0,
+-336},{11,0,12},{12,0,412},{12,0,440},{142,0,305},{136,11,491},{4,10,579},{5,10,
+-226},{5,10,323},{135,10,960},{7,0,204},{7,0,415},{8,0,42},{10,0,85},{139,0,564},
+-{132,0,614},{4,11,403},{5,11,441},{7,11,450},{11,11,101},{12,11,193},{141,11,430
+-},{135,11,1927},{135,11,1330},{4,0,3},{5,0,247},{5,0,644},{7,0,744},{7,0,1207},{
+-7,0,1225},{7,0,1909},{146,0,147},{136,0,942},{4,0,1019},{134,0,2023},{5,11,679},
+-{133,10,973},{5,0,285},{9,0,67},{13,0,473},{143,0,82},{7,11,328},{137,11,326},{
+-151,0,8},{6,10,135},{135,10,1176},{135,11,1128},{134,0,1309},{135,11,1796},{135,
+-10,314},{4,11,574},{7,11,350},{7,11,1024},{8,11,338},{9,11,677},{10,11,808},{139
+-,11,508},{7,11,818},{17,11,14},{17,11,45},{18,11,75},{148,11,18},{146,10,4},{135
+-,11,1081},{4,0,29},{6,0,532},{7,0,1628},{7,0,1648},{9,0,350},{10,0,433},{11,0,97
+-},{11,0,557},{11,0,745},{12,0,289},{12,0,335},{12,0,348},{12,0,606},{13,0,116},{
+-13,0,233},{13,0,466},{14,0,181},{14,0,209},{14,0,232},{14,0,236},{14,0,300},{16,
+-0,41},{148,0,97},{7,0,318},{6,10,281},{8,10,282},{8,10,480},{8,10,499},{9,10,198
+-},{10,10,143},{10,10,169},{10,10,211},{10,10,417},{10,10,574},{11,10,147},{11,10
+-,395},{12,10,75},{12,10,407},{12,10,608},{13,10,500},{142,10,251},{135,11,1676},
+-{135,11,2037},{135,0,1692},{5,0,501},{7,0,1704},{9,0,553},{11,0,520},{12,0,557},
+-{141,0,249},{6,0,1527},{14,0,324},{15,0,55},{15,0,80},{14,11,324},{15,11,55},{
+-143,11,80},{135,10,1776},{8,0,988},{137,11,297},{132,10,419},{142,0,223},{139,11
+-,234},{7,0,1123},{12,0,508},{14,0,102},{14,0,226},{144,0,57},{4,10,138},{7,10,
+-1012},{7,10,1280},{137,10,76},{7,0,1764},{5,10,29},{140,10,638},{134,0,2015},{
+-134,0,1599},{138,11,56},{6,11,306},{7,11,1140},{7,11,1340},{8,11,133},{138,11,
+-449},{139,11,1011},{6,10,1710},{135,10,2038},{7,11,1763},{140,11,310},{6,0,129},
+-{4,10,17},{5,10,23},{7,10,995},{11,10,383},{11,10,437},{12,10,460},{140,10,532},
+-{5,11,329},{136,11,260},{133,10,862},{132,0,534},{6,0,811},{135,0,626},{132,11,
+-657},{4,0,25},{5,0,60},{6,0,504},{7,0,614},{7,0,1155},{12,0,0},{152,11,7},{7,0,
+-1248},{11,0,621},{139,0,702},{137,0,321},{8,10,70},{12,10,171},{141,10,272},{10,
+-10,233},{139,10,76},{4,0,379},{7,0,1397},{134,10,442},{5,11,66},{7,11,1896},{136
+-,11,288},{134,11,1643},{134,10,1709},{4,11,21},{5,11,91},{5,11,570},{5,11,648},{
+-5,11,750},{5,11,781},{6,11,54},{6,11,112},{6,11,402},{6,11,1732},{7,11,315},{7,
+-11,749},{7,11,1347},{7,11,1900},{9,11,78},{9,11,508},{10,11,611},{11,11,510},{11
+-,11,728},{13,11,36},{14,11,39},{16,11,83},{17,11,124},{148,11,30},{4,0,118},{6,0
+-,274},{6,0,361},{7,0,75},{141,0,441},{10,11,322},{10,11,719},{139,11,407},{147,
+-10,119},{12,11,549},{14,11,67},{147,11,60},{11,10,69},{12,10,105},{12,10,117},{
+-13,10,213},{14,10,13},{14,10,62},{14,10,177},{14,10,421},{15,10,19},{146,10,141}
+-,{9,0,841},{137,10,309},{7,10,608},{7,10,976},{8,11,125},{8,11,369},{8,11,524},{
+-9,10,146},{10,10,206},{10,11,486},{10,10,596},{11,11,13},{11,11,381},{11,11,736}
+-,{11,11,766},{11,11,845},{13,11,114},{13,10,218},{13,11,292},{14,11,47},{142,10,
+-153},{12,0,693},{135,11,759},{5,0,314},{6,0,221},{7,0,419},{10,0,650},{11,0,396}
+-,{12,0,156},{13,0,369},{14,0,333},{145,0,47},{6,11,1684},{6,11,1731},{7,11,356},
+-{7,11,1932},{8,11,54},{8,11,221},{9,11,225},{9,11,356},{10,11,77},{10,11,446},{
+-10,11,731},{12,11,404},{141,11,491},{132,11,375},{4,10,518},{135,10,1136},{4,0,
+-913},{4,11,411},{11,11,643},{140,11,115},{4,11,80},{133,11,44},{8,10,689},{137,
+-10,863},{138,0,880},{4,10,18},{7,10,145},{7,10,444},{7,10,1278},{8,10,49},{8,10,
+-400},{9,10,71},{9,10,250},{10,10,459},{12,10,160},{144,10,24},{136,0,475},{5,0,
+-1016},{5,11,299},{135,11,1083},{7,0,602},{8,0,179},{10,0,781},{140,0,126},{6,0,
+-329},{138,0,111},{135,0,1864},{4,11,219},{7,11,1761},{137,11,86},{6,0,1888},{6,0
+-,1892},{6,0,1901},{6,0,1904},{9,0,953},{9,0,985},{9,0,991},{9,0,1001},{12,0,818}
+-,{12,0,846},{12,0,847},{12,0,861},{12,0,862},{12,0,873},{12,0,875},{12,0,877},{
+-12,0,879},{12,0,881},{12,0,884},{12,0,903},{12,0,915},{12,0,926},{12,0,939},{15,
+-0,182},{15,0,219},{15,0,255},{18,0,191},{18,0,209},{18,0,211},{149,0,41},{5,11,
+-328},{135,11,918},{137,0,780},{12,0,82},{143,0,36},{133,10,1010},{5,0,821},{134,
+-0,1687},{133,11,514},{132,0,956},{134,0,1180},{10,0,112},{5,10,87},{7,10,313},{7
+-,10,1103},{10,10,582},{11,10,389},{11,10,813},{12,10,385},{13,10,286},{14,10,124
+-},{146,10,108},{5,0,71},{7,0,1407},{9,0,704},{10,0,261},{10,0,619},{11,0,547},{
+-11,0,619},{143,0,157},{4,0,531},{5,0,455},{5,11,301},{6,11,571},{14,11,49},{146,
+-11,102},{132,10,267},{6,0,385},{7,0,2008},{9,0,337},{138,0,517},{133,11,726},{
+-133,11,364},{4,11,76},{7,11,1550},{9,11,306},{9,11,430},{9,11,663},{10,11,683},{
+-11,11,427},{11,11,753},{12,11,334},{12,11,442},{14,11,258},{14,11,366},{143,11,
+-131},{6,0,1865},{6,0,1879},{6,0,1881},{6,0,1894},{6,0,1908},{9,0,915},{9,0,926},
+-{9,0,940},{9,0,943},{9,0,966},{9,0,980},{9,0,989},{9,0,1005},{9,0,1010},{12,0,
+-813},{12,0,817},{12,0,840},{12,0,843},{12,0,855},{12,0,864},{12,0,871},{12,0,872
+-},{12,0,899},{12,0,905},{12,0,924},{15,0,171},{15,0,181},{15,0,224},{15,0,235},{
+-15,0,251},{146,0,184},{137,11,52},{5,0,16},{6,0,86},{6,0,603},{7,0,292},{7,0,561
+-},{8,0,257},{8,0,382},{9,0,721},{9,0,778},{11,0,581},{140,0,466},{4,0,486},{5,0,
+-491},{135,10,1121},{4,0,72},{6,0,265},{135,0,1300},{135,11,1183},{10,10,249},{
+-139,10,209},{132,10,561},{137,11,519},{4,11,656},{4,10,760},{135,11,779},{9,10,
+-154},{140,10,485},{135,11,1793},{135,11,144},{136,10,255},{133,0,621},{4,10,368}
+-,{135,10,641},{135,11,1373},{7,11,554},{7,11,605},{141,11,10},{137,0,234},{5,0,
+-815},{6,0,1688},{134,0,1755},{5,11,838},{5,11,841},{134,11,1649},{7,0,1987},{7,0
+-,2040},{136,0,743},{133,11,1012},{6,0,197},{136,0,205},{6,0,314},{134,11,314},{
+-144,11,53},{6,11,251},{7,11,365},{7,11,1357},{7,11,1497},{8,11,154},{141,11,281}
+-,{133,11,340},{6,0,452},{7,0,312},{138,0,219},{138,0,589},{4,0,333},{9,0,176},{
+-12,0,353},{141,0,187},{9,10,92},{147,10,91},{134,0,1110},{11,0,47},{139,11,495},
+-{6,10,525},{8,10,806},{9,10,876},{140,10,284},{8,11,261},{9,11,144},{9,11,466},{
+-10,11,370},{12,11,470},{13,11,144},{142,11,348},{137,11,897},{8,0,863},{8,0,864}
+-,{8,0,868},{8,0,884},{10,0,866},{10,0,868},{10,0,873},{10,0,911},{10,0,912},{10,
+-0,944},{12,0,727},{6,11,248},{9,11,546},{10,11,535},{11,11,681},{141,11,135},{6,
+-0,300},{135,0,1515},{134,0,1237},{139,10,958},{133,10,594},{140,11,250},{134,0,
+-1685},{134,11,567},{7,0,135},{8,0,7},{8,0,62},{9,0,243},{10,0,658},{10,0,697},{
+-11,0,456},{139,0,756},{9,0,395},{138,0,79},{6,10,1641},{136,10,820},{4,10,302},{
+-135,10,1766},{134,11,174},{135,10,1313},{135,0,631},{134,10,1674},{134,11,395},{
+-138,0,835},{7,0,406},{7,0,459},{8,0,606},{139,0,726},{134,11,617},{134,0,979},{6
+-,10,389},{7,10,149},{9,10,142},{138,10,94},{5,11,878},{133,11,972},{6,10,8},{7,
+-10,1881},{8,10,91},{136,11,511},{133,0,612},{132,11,351},{4,0,372},{7,0,482},{8,
+-0,158},{9,0,602},{9,0,615},{10,0,245},{10,0,678},{10,0,744},{11,0,248},{139,0,
+-806},{5,0,854},{135,0,1991},{132,11,286},{135,11,344},{7,11,438},{7,11,627},{7,
+-11,1516},{8,11,40},{9,11,56},{9,11,294},{10,11,30},{10,11,259},{11,11,969},{146,
+-11,148},{135,0,1492},{5,11,259},{7,11,414},{7,11,854},{142,11,107},{135,10,1746}
+-,{6,0,833},{134,0,998},{135,10,24},{6,0,750},{135,0,1739},{4,10,503},{135,10,
+-1661},{5,10,130},{7,10,1314},{9,10,610},{10,10,718},{11,10,601},{11,10,819},{11,
+-10,946},{140,10,536},{10,10,149},{11,10,280},{142,10,336},{132,11,738},{135,10,
+-1946},{5,0,195},{135,0,1685},{7,0,1997},{8,0,730},{139,0,1006},{151,11,17},{133,
+-11,866},{14,0,463},{14,0,470},{150,0,61},{5,0,751},{8,0,266},{11,0,578},{4,10,
+-392},{135,10,1597},{5,10,433},{9,10,633},{139,10,629},{135,0,821},{6,0,715},{134
+-,0,1325},{133,11,116},{6,0,868},{132,11,457},{134,0,959},{6,10,234},{138,11,199}
+-,{7,0,1053},{7,10,1950},{8,10,680},{11,10,817},{147,10,88},{7,10,1222},{138,10,
+-386},{5,0,950},{5,0,994},{6,0,351},{134,0,1124},{134,0,1081},{7,0,1595},{6,10,5}
+-,{11,10,249},{12,10,313},{16,10,66},{145,10,26},{148,0,59},{5,11,527},{6,11,189}
+-,{135,11,859},{5,10,963},{6,10,1773},{11,11,104},{11,11,554},{15,11,60},{143,11,
+-125},{135,0,47},{137,0,684},{134,11,116},{134,0,1606},{134,0,777},{7,0,1020},{8,
+-10,509},{136,10,792},{135,0,1094},{132,0,350},{133,11,487},{4,11,86},{5,11,667},
+-{5,11,753},{6,11,316},{6,11,455},{135,11,946},{7,0,1812},{13,0,259},{13,0,356},{
+-14,0,242},{147,0,114},{132,10,931},{133,0,967},{4,0,473},{7,0,623},{8,0,808},{9,
+-0,871},{9,0,893},{11,0,38},{11,0,431},{12,0,112},{12,0,217},{12,0,243},{12,0,562
+-},{12,0,663},{12,0,683},{13,0,141},{13,0,197},{13,0,227},{13,0,406},{13,0,487},{
+-14,0,156},{14,0,203},{14,0,224},{14,0,256},{18,0,58},{150,0,0},{138,0,286},{7,10
+-,943},{139,10,614},{135,10,1837},{150,11,45},{132,0,798},{4,0,222},{7,0,286},{
+-136,0,629},{4,11,79},{7,11,1773},{10,11,450},{11,11,589},{13,11,332},{13,11,493}
+-,{14,11,183},{14,11,334},{14,11,362},{14,11,368},{14,11,376},{14,11,379},{19,11,
+-90},{19,11,103},{19,11,127},{148,11,90},{5,0,337},{11,0,513},{11,0,889},{11,0,
+-961},{12,0,461},{13,0,79},{15,0,121},{4,10,90},{5,10,545},{7,10,754},{9,10,186},
+-{10,10,72},{10,10,782},{11,10,577},{11,10,610},{12,10,354},{12,10,362},{140,10,
+-595},{141,0,306},{136,0,146},{7,0,1646},{9,10,329},{11,10,254},{141,11,124},{4,0
+-,465},{135,0,1663},{132,0,525},{133,11,663},{10,0,299},{18,0,74},{9,10,187},{11,
+-10,1016},{145,10,44},{7,0,165},{7,0,919},{4,10,506},{136,10,517},{5,10,295},{135
+-,10,1680},{133,11,846},{134,0,1064},{5,11,378},{7,11,1402},{7,11,1414},{8,11,465
+-},{9,11,286},{10,11,185},{10,11,562},{10,11,635},{11,11,31},{11,11,393},{12,11,
+-456},{13,11,312},{18,11,65},{18,11,96},{147,11,89},{132,0,596},{7,10,987},{9,10,
+-688},{10,10,522},{11,10,788},{140,10,566},{6,0,82},{7,0,138},{7,0,517},{7,0,1741
+-},{11,0,238},{4,11,648},{134,10,1775},{7,0,1233},{7,10,700},{7,10,940},{8,10,514
+-},{9,10,116},{9,10,535},{10,10,118},{11,10,107},{11,10,148},{11,10,922},{12,10,
+-254},{12,10,421},{142,10,238},{4,0,962},{6,0,1824},{8,0,894},{12,0,708},{12,0,
+-725},{14,0,451},{20,0,94},{22,0,59},{150,0,62},{5,11,945},{6,11,1656},{6,11,1787
+-},{7,11,167},{8,11,824},{9,11,391},{10,11,375},{139,11,185},{5,0,495},{7,0,834},
+-{9,0,733},{139,0,378},{4,10,743},{135,11,1273},{6,0,1204},{7,11,1645},{8,11,352}
+-,{137,11,249},{139,10,292},{133,0,559},{132,11,152},{9,0,499},{10,0,341},{15,0,
+-144},{19,0,49},{7,10,1283},{9,10,227},{11,10,325},{11,10,408},{14,10,180},{146,
+-10,47},{6,0,21},{6,0,1737},{7,0,1444},{136,0,224},{133,11,1006},{7,0,1446},{9,0,
+-97},{17,0,15},{5,10,81},{7,10,146},{7,10,1342},{8,10,53},{8,10,561},{8,10,694},{
+-8,10,754},{9,10,115},{9,10,894},{10,10,462},{10,10,813},{11,10,230},{11,10,657},
+-{11,10,699},{11,10,748},{12,10,119},{12,10,200},{12,10,283},{142,10,273},{5,10,
+-408},{137,10,747},{135,11,431},{135,11,832},{6,0,729},{134,0,953},{4,0,727},{8,0
+-,565},{5,11,351},{7,11,264},{136,11,565},{134,0,1948},{5,0,519},{5,11,40},{7,11,
+-598},{7,11,1638},{8,11,78},{9,11,166},{9,11,640},{9,11,685},{9,11,773},{11,11,
+-215},{13,11,65},{14,11,172},{14,11,317},{145,11,6},{8,11,60},{9,11,343},{139,11,
+-769},{137,11,455},{134,0,1193},{140,0,790},{7,11,1951},{8,11,765},{8,11,772},{
+-140,11,671},{7,11,108},{8,11,219},{8,11,388},{9,11,639},{9,11,775},{11,11,275},{
+-140,11,464},{132,11,468},{7,10,30},{8,10,86},{8,10,315},{8,10,700},{9,10,576},{9
+-,10,858},{11,10,310},{11,10,888},{11,10,904},{12,10,361},{141,10,248},{5,11,15},
+-{6,11,56},{7,11,1758},{8,11,500},{9,11,730},{11,11,331},{13,11,150},{142,11,282}
+-,{4,0,402},{7,0,2},{8,0,323},{136,0,479},{138,10,839},{11,0,580},{142,0,201},{5,
+-0,59},{135,0,672},{137,10,617},{146,0,34},{134,11,1886},{4,0,961},{136,0,896},{6
+-,0,1285},{5,11,205},{6,11,438},{137,11,711},{134,10,428},{7,10,524},{8,10,169},{
+-8,10,234},{9,10,480},{138,10,646},{148,0,46},{141,0,479},{133,11,534},{6,0,2019}
+-,{134,10,1648},{4,0,85},{7,0,549},{7,10,1205},{138,10,637},{4,0,663},{5,0,94},{7
+-,11,235},{7,11,1475},{15,11,68},{146,11,120},{6,11,443},{9,11,237},{9,11,571},{9
+-,11,695},{10,11,139},{11,11,715},{12,11,417},{141,11,421},{132,0,783},{4,0,682},
+-{8,0,65},{9,10,39},{10,10,166},{11,10,918},{12,10,635},{20,10,10},{22,10,27},{22
+-,10,43},{150,10,52},{6,0,11},{135,0,187},{132,0,522},{4,0,52},{135,0,661},{4,0,
+-383},{133,0,520},{135,11,546},{11,0,343},{142,0,127},{4,11,578},{7,10,157},{7,11
+-,624},{7,11,916},{8,10,279},{10,11,256},{11,11,87},{139,11,703},{134,10,604},{4,
+-0,281},{5,0,38},{7,0,194},{7,0,668},{7,0,1893},{137,0,397},{7,10,945},{11,10,713
+-},{139,10,744},{139,10,1022},{9,0,635},{139,0,559},{5,11,923},{7,11,490},{12,11,
+-553},{13,11,100},{14,11,118},{143,11,75},{132,0,975},{132,10,567},{137,10,859},{
+-7,10,1846},{7,11,1846},{8,10,628},{136,11,628},{148,0,116},{138,11,750},{14,0,51
+-},{14,11,51},{15,11,7},{148,11,20},{132,0,858},{134,0,1075},{4,11,924},{133,10,
+-762},{136,0,535},{133,0,448},{10,10,784},{141,10,191},{133,10,298},{7,0,610},{
+-135,0,1501},{7,10,633},{7,10,905},{7,10,909},{7,10,1538},{9,10,767},{140,10,636}
+-,{4,11,265},{7,11,807},{135,11,950},{5,11,93},{12,11,267},{144,11,26},{136,0,191
+-},{139,10,301},{135,10,1970},{135,0,267},{4,0,319},{5,0,699},{138,0,673},{6,0,
+-336},{7,0,92},{7,0,182},{8,0,453},{8,0,552},{9,0,204},{9,0,285},{10,0,99},{11,0,
+-568},{11,0,950},{12,0,94},{16,0,20},{16,0,70},{19,0,55},{12,10,644},{144,10,90},
+-{6,0,551},{7,0,1308},{7,10,845},{7,11,994},{8,10,160},{137,10,318},{19,11,1},{19
+-,11,26},{150,11,9},{7,0,1406},{9,0,218},{141,0,222},{5,0,256},{138,0,69},{5,11,
+-233},{5,11,320},{6,11,140},{7,11,330},{136,11,295},{6,0,1980},{136,0,952},{4,0,
+-833},{137,11,678},{133,11,978},{4,11,905},{6,11,1701},{137,11,843},{138,10,735},
+-{136,10,76},{17,0,39},{148,0,36},{18,0,81},{146,11,81},{14,0,352},{17,0,53},{18,
+-0,146},{18,0,152},{19,0,11},{150,0,54},{135,0,634},{138,10,841},{132,0,618},{4,0
+-,339},{7,0,259},{17,0,73},{4,11,275},{140,11,376},{132,11,509},{7,11,273},{139,
+-11,377},{4,0,759},{13,0,169},{137,10,804},{6,10,96},{135,10,1426},{4,10,651},{
+-133,10,289},{7,0,1075},{8,10,35},{9,10,511},{10,10,767},{147,10,118},{6,0,649},{
+-6,0,670},{136,0,482},{5,0,336},{6,0,341},{6,0,478},{6,0,1763},{136,0,386},{5,11,
+-802},{7,11,2021},{8,11,805},{14,11,94},{15,11,65},{16,11,4},{16,11,77},{16,11,80
+-},{145,11,5},{6,0,1035},{5,11,167},{5,11,899},{6,11,410},{137,11,777},{134,11,
+-1705},{5,0,924},{133,0,969},{132,10,704},{135,0,73},{135,11,10},{135,10,1078},{5
+-,11,11},{6,11,117},{6,11,485},{7,11,1133},{9,11,582},{9,11,594},{11,11,21},{11,
+-11,818},{12,11,535},{141,11,86},{135,0,1971},{4,11,264},{7,11,1067},{8,11,204},{
+-8,11,385},{139,11,953},{6,0,1458},{135,0,1344},{5,0,396},{134,0,501},{4,10,720},
+-{133,10,306},{4,0,929},{5,0,799},{8,0,46},{8,0,740},{133,10,431},{7,11,646},{7,
+-11,1730},{11,11,446},{141,11,178},{7,0,276},{5,10,464},{6,10,236},{7,10,696},{7,
+-10,914},{7,10,1108},{7,10,1448},{9,10,15},{9,10,564},{10,10,14},{12,10,565},{13,
+-10,449},{14,10,53},{15,10,13},{16,10,64},{145,10,41},{4,0,892},{133,0,770},{6,10
+-,1767},{12,10,194},{145,10,107},{135,0,158},{5,10,840},{138,11,608},{134,0,1432}
+-,{138,11,250},{8,11,794},{9,11,400},{10,11,298},{142,11,228},{151,0,25},{7,11,
+-1131},{135,11,1468},{135,0,2001},{9,10,642},{11,10,236},{142,10,193},{4,10,68},{
+-5,10,634},{6,10,386},{7,10,794},{8,10,273},{9,10,563},{10,10,105},{10,10,171},{
+-11,10,94},{139,10,354},{136,11,724},{132,0,478},{11,11,512},{13,11,205},{19,11,
+-30},{22,11,36},{151,11,19},{7,0,1461},{140,0,91},{6,11,190},{7,11,768},{135,11,
+-1170},{4,0,602},{8,0,211},{4,10,95},{7,10,416},{139,10,830},{7,10,731},{13,10,20
+-},{143,10,11},{6,0,1068},{135,0,1872},{4,0,13},{5,0,567},{7,0,1498},{9,0,124},{
+-11,0,521},{12,0,405},{135,11,1023},{135,0,1006},{132,0,735},{138,0,812},{4,0,170
+-},{135,0,323},{6,11,137},{9,11,75},{9,11,253},{10,11,194},{138,11,444},{5,0,304}
+-,{7,0,1403},{5,10,864},{10,10,648},{11,10,671},{143,10,46},{135,11,1180},{133,10
+-,928},{4,0,148},{133,0,742},{11,10,986},{140,10,682},{133,0,523},{135,11,1743},{
+-7,0,730},{18,0,144},{19,0,61},{8,10,44},{9,10,884},{10,10,580},{11,10,399},{11,
+-10,894},{143,10,122},{5,11,760},{7,11,542},{8,11,135},{136,11,496},{136,0,981},{
+-133,0,111},{10,0,132},{11,0,191},{11,0,358},{139,0,460},{7,11,319},{7,11,355},{7
+-,11,763},{10,11,389},{145,11,43},{134,0,890},{134,0,1420},{136,11,557},{133,10,
+-518},{133,0,444},{135,0,1787},{135,10,1852},{8,0,123},{15,0,6},{144,0,7},{6,0,
+-2041},{10,11,38},{139,11,784},{136,0,932},{5,0,937},{135,0,100},{6,0,995},{4,11,
+-58},{5,11,286},{6,11,319},{7,11,402},{7,11,1254},{7,11,1903},{8,11,356},{140,11,
+-408},{4,11,389},{9,11,181},{9,11,255},{10,11,8},{10,11,29},{10,11,816},{11,11,
+-311},{11,11,561},{12,11,67},{141,11,181},{138,0,255},{5,0,138},{4,10,934},{136,
+-10,610},{4,0,965},{10,0,863},{138,0,898},{10,10,804},{138,10,832},{12,0,631},{8,
+-10,96},{9,10,36},{10,10,607},{11,10,423},{11,10,442},{12,10,309},{14,10,199},{15
+-,10,90},{145,10,110},{134,0,1394},{4,0,652},{8,0,320},{22,0,6},{22,0,16},{9,10,
+-13},{9,10,398},{9,10,727},{10,10,75},{10,10,184},{10,10,230},{10,10,564},{10,10,
+-569},{11,10,973},{12,10,70},{12,10,189},{13,10,57},{141,10,257},{6,0,897},{134,0
+-,1333},{4,0,692},{133,0,321},{133,11,373},{135,0,922},{5,0,619},{133,0,698},{137
+-,10,631},{5,10,345},{135,10,1016},{9,0,957},{9,0,1018},{12,0,828},{12,0,844},{12
+-,0,897},{12,0,901},{12,0,943},{15,0,180},{18,0,197},{18,0,200},{18,0,213},{18,0,
+-214},{146,0,226},{5,0,917},{134,0,1659},{135,0,1100},{134,0,1173},{134,0,1930},{
+-5,0,251},{5,0,956},{8,0,268},{9,0,214},{146,0,142},{133,10,673},{137,10,850},{4,
+-10,287},{133,10,1018},{132,11,672},{5,0,346},{5,0,711},{8,0,390},{11,11,752},{
+-139,11,885},{5,10,34},{10,10,724},{12,10,444},{13,10,354},{18,10,32},{23,10,24},
+-{23,10,31},{152,10,5},{4,11,710},{134,11,606},{134,0,744},{134,10,382},{133,11,
+-145},{4,10,329},{7,11,884},{140,11,124},{4,11,467},{5,11,405},{134,11,544},{9,10
+-,846},{138,10,827},{133,0,624},{9,11,372},{15,11,2},{19,11,10},{147,11,18},{4,11
+-,387},{135,11,1288},{5,0,783},{7,0,1998},{135,0,2047},{132,10,906},{136,10,366},
+-{135,11,550},{4,10,123},{4,10,649},{5,10,605},{7,10,1509},{136,10,36},{134,0,
+-1125},{132,0,594},{133,10,767},{135,11,1227},{136,11,467},{4,11,576},{135,11,
+-1263},{4,0,268},{7,0,1534},{135,11,1534},{4,10,273},{5,10,658},{5,11,919},{5,10,
+-995},{134,11,1673},{133,0,563},{134,10,72},{135,10,1345},{4,11,82},{5,11,333},{5
+-,11,904},{6,11,207},{7,11,325},{7,11,1726},{8,11,101},{10,11,778},{139,11,220},{
+-5,0,37},{6,0,39},{6,0,451},{7,0,218},{7,0,667},{7,0,1166},{7,0,1687},{8,0,662},{
+-16,0,2},{133,10,589},{134,0,1332},{133,11,903},{134,0,508},{5,10,117},{6,10,514}
+-,{6,10,541},{7,10,1164},{7,10,1436},{8,10,220},{8,10,648},{10,10,688},{11,10,560
+-},{140,11,147},{6,11,555},{135,11,485},{133,10,686},{7,0,453},{7,0,635},{7,0,796
+-},{8,0,331},{9,0,330},{9,0,865},{10,0,119},{10,0,235},{11,0,111},{11,0,129},{11,
+-0,240},{12,0,31},{12,0,66},{12,0,222},{12,0,269},{12,0,599},{12,0,684},{12,0,689
+-},{12,0,691},{142,0,345},{135,0,1834},{4,11,705},{7,11,615},{138,11,251},{136,11
+-,345},{137,0,527},{6,0,98},{7,0,702},{135,0,991},{11,0,576},{14,0,74},{7,10,196}
+-,{10,10,765},{11,10,347},{11,10,552},{11,10,790},{12,10,263},{13,10,246},{13,10,
+-270},{13,10,395},{14,10,176},{14,10,190},{14,10,398},{14,10,412},{15,10,32},{15,
+-10,63},{16,10,88},{147,10,105},{134,11,90},{13,0,84},{141,0,122},{6,0,37},{7,0,
+-299},{7,0,1666},{8,0,195},{8,0,316},{9,0,178},{9,0,276},{9,0,339},{9,0,536},{10,
+-0,102},{10,0,362},{10,0,785},{11,0,55},{11,0,149},{11,0,773},{13,0,416},{13,0,
+-419},{14,0,38},{14,0,41},{142,0,210},{5,10,381},{135,10,1792},{7,11,813},{12,11,
+-497},{141,11,56},{7,10,616},{138,10,413},{133,0,645},{6,11,125},{135,11,1277},{
+-132,0,290},{6,0,70},{7,0,1292},{10,0,762},{139,0,288},{6,10,120},{7,10,1188},{7,
+-10,1710},{8,10,286},{9,10,667},{11,10,592},{139,10,730},{135,11,1784},{7,0,1315}
+-,{135,11,1315},{134,0,1955},{135,10,1146},{7,0,131},{7,0,422},{8,0,210},{140,0,
+-573},{4,10,352},{135,10,687},{139,0,797},{143,0,38},{14,0,179},{15,0,151},{150,0
+-,11},{7,0,488},{4,10,192},{5,10,49},{6,10,200},{6,10,293},{134,10,1696},{132,0,
+-936},{135,11,703},{6,11,160},{7,11,1106},{9,11,770},{10,11,618},{11,11,112},{140
+-,11,413},{5,0,453},{134,0,441},{135,0,595},{132,10,650},{132,10,147},{6,0,991},{
+-6,0,1182},{12,11,271},{145,11,109},{133,10,934},{140,11,221},{132,0,653},{7,0,
+-505},{135,0,523},{134,0,903},{135,11,479},{7,11,304},{9,11,646},{9,11,862},{10,
+-11,262},{11,11,696},{12,11,208},{15,11,79},{147,11,108},{146,0,80},{135,11,981},
+-{142,0,432},{132,0,314},{137,11,152},{7,0,1368},{8,0,232},{8,0,361},{10,0,682},{
+-138,0,742},{135,11,1586},{9,0,534},{4,11,434},{11,11,663},{12,11,210},{13,11,166
+-},{13,11,310},{14,11,373},{147,11,43},{7,11,1091},{135,11,1765},{6,11,550},{135,
+-11,652},{137,0,27},{142,0,12},{4,10,637},{5,11,553},{7,11,766},{138,11,824},{7,
+-11,737},{8,11,298},{136,11,452},{7,0,736},{139,0,264},{134,0,1657},{133,11,292},
+-{138,11,135},{6,0,844},{134,0,1117},{135,0,127},{9,10,867},{138,10,837},{6,0,
+-1184},{134,0,1208},{134,0,1294},{136,0,364},{6,0,1415},{7,0,1334},{11,0,125},{6,
+-10,170},{7,11,393},{8,10,395},{8,10,487},{10,11,603},{11,11,206},{141,10,147},{
+-137,11,748},{4,11,912},{137,11,232},{4,10,535},{136,10,618},{137,0,792},{7,11,
+-1973},{136,11,716},{135,11,98},{5,0,909},{9,0,849},{138,0,805},{4,0,630},{132,0,
+-699},{5,11,733},{14,11,103},{150,10,23},{12,11,158},{18,11,8},{19,11,62},{20,11,
+-6},{22,11,4},{23,11,2},{151,11,9},{132,0,968},{132,10,778},{132,10,46},{5,10,811
+-},{6,10,1679},{6,10,1714},{135,10,2032},{6,0,1446},{7,10,1458},{9,10,407},{139,
+-10,15},{7,0,206},{7,0,397},{7,0,621},{7,0,640},{8,0,124},{8,0,619},{9,0,305},{9,
+-0,643},{10,0,264},{10,0,628},{11,0,40},{12,0,349},{13,0,134},{13,0,295},{14,0,
+-155},{15,0,120},{18,0,105},{6,10,34},{7,10,1089},{8,10,708},{8,10,721},{9,10,363
+-},{148,10,98},{4,0,262},{5,0,641},{135,0,342},{137,11,72},{4,0,99},{6,0,250},{6,
+-0,346},{8,0,127},{138,0,81},{132,0,915},{5,0,75},{9,0,517},{10,0,470},{12,0,155}
+-,{141,0,224},{132,10,462},{11,11,600},{11,11,670},{141,11,245},{142,0,83},{5,10,
+-73},{6,10,23},{134,10,338},{6,0,1031},{139,11,923},{7,11,164},{7,11,1571},{9,11,
+-107},{140,11,225},{134,0,1470},{133,0,954},{6,0,304},{8,0,418},{10,0,345},{11,0,
+-341},{139,0,675},{9,0,410},{139,0,425},{4,11,27},{5,11,484},{5,11,510},{6,11,434
+-},{7,11,1000},{7,11,1098},{8,11,2},{136,11,200},{134,0,734},{140,11,257},{7,10,
+-725},{8,10,498},{139,10,268},{134,0,1822},{135,0,1798},{135,10,773},{132,11,460}
+-,{4,11,932},{133,11,891},{134,0,14},{132,10,583},{7,10,1462},{8,11,625},{139,10,
+-659},{5,0,113},{6,0,243},{6,0,1708},{7,0,1865},{11,0,161},{16,0,37},{17,0,99},{
+-133,10,220},{134,11,76},{5,11,461},{135,11,1925},{140,0,69},{8,11,92},{137,11,
+-221},{139,10,803},{132,10,544},{4,0,274},{134,0,922},{132,0,541},{5,0,627},{6,10
+-,437},{6,10,564},{11,10,181},{141,10,183},{135,10,1192},{7,0,166},{132,11,763},{
+-133,11,253},{134,0,849},{9,11,73},{10,11,110},{14,11,185},{145,11,119},{5,11,212
+-},{12,11,35},{141,11,382},{133,0,717},{137,0,304},{136,0,600},{133,0,654},{6,0,
+-273},{10,0,188},{13,0,377},{146,0,77},{4,10,790},{5,10,273},{134,10,394},{132,0,
+-543},{135,0,410},{11,0,98},{11,0,524},{141,0,87},{132,0,941},{135,11,1175},{4,0,
+-250},{7,0,1612},{11,0,186},{12,0,133},{6,10,127},{7,10,1511},{8,10,613},{12,10,
+-495},{12,10,586},{12,10,660},{12,10,668},{14,10,385},{15,10,118},{17,10,20},{146
+-,10,98},{6,0,1785},{133,11,816},{134,0,1339},{7,0,961},{7,0,1085},{7,0,1727},{8,
+-0,462},{6,10,230},{135,11,1727},{9,0,636},{135,10,1954},{132,0,780},{5,11,869},{
+-5,11,968},{6,11,1626},{8,11,734},{136,11,784},{4,11,542},{6,11,1716},{6,11,1727}
+-,{7,11,1082},{7,11,1545},{8,11,56},{8,11,118},{8,11,412},{8,11,564},{9,11,888},{
+-9,11,908},{10,11,50},{10,11,423},{11,11,685},{11,11,697},{11,11,933},{12,11,299}
+-,{13,11,126},{13,11,136},{13,11,170},{141,11,190},{134,11,226},{4,11,232},{9,11,
+-202},{10,11,474},{140,11,433},{137,11,500},{5,0,529},{136,10,68},{132,10,654},{4
+-,10,156},{7,10,998},{7,10,1045},{7,10,1860},{9,10,48},{9,10,692},{11,10,419},{
+-139,10,602},{7,0,1276},{8,0,474},{9,0,652},{6,11,108},{7,11,1003},{7,11,1181},{
+-136,11,343},{7,11,1264},{7,11,1678},{11,11,945},{12,11,341},{12,11,471},{140,11,
+-569},{134,11,1712},{5,0,948},{12,0,468},{19,0,96},{148,0,24},{4,11,133},{7,11,
+-711},{7,11,1298},{7,11,1585},{135,11,1929},{6,0,753},{140,0,657},{139,0,941},{6,
+-11,99},{7,11,1808},{145,11,57},{6,11,574},{7,11,428},{7,11,1250},{10,11,669},{11
+-,11,485},{11,11,840},{12,11,300},{142,11,250},{4,0,532},{5,0,706},{135,0,662},{5
+-,0,837},{6,0,1651},{139,0,985},{7,0,1861},{9,10,197},{10,10,300},{12,10,473},{13
+-,10,90},{141,10,405},{137,11,252},{6,11,323},{135,11,1564},{4,0,330},{4,0,863},{
+-7,0,933},{7,0,2012},{8,0,292},{7,11,461},{8,11,775},{138,11,435},{132,10,606},{4
+-,11,655},{7,11,850},{17,11,75},{146,11,137},{135,0,767},{7,10,1978},{136,10,676}
+-,{132,0,641},{135,11,1559},{134,0,1233},{137,0,242},{17,0,114},{4,10,361},{133,
+-10,315},{137,0,883},{132,10,461},{138,0,274},{134,0,2008},{134,0,1794},{4,0,703}
+-,{135,0,207},{12,0,285},{132,10,472},{132,0,571},{5,0,873},{5,0,960},{8,0,823},{
+-9,0,881},{136,11,577},{7,0,617},{10,0,498},{11,0,501},{12,0,16},{140,0,150},{138
+-,10,747},{132,0,431},{133,10,155},{11,0,283},{11,0,567},{7,10,163},{8,10,319},{9
+-,10,402},{10,10,24},{10,10,681},{11,10,200},{12,10,253},{12,10,410},{142,10,219}
+-,{4,11,413},{5,11,677},{8,11,432},{140,11,280},{9,0,401},{5,10,475},{7,10,1780},
+-{11,10,297},{11,10,558},{14,10,322},{147,10,76},{6,0,781},{9,0,134},{10,0,2},{10
+-,0,27},{10,0,333},{11,0,722},{143,0,1},{5,0,33},{6,0,470},{139,0,424},{135,0,
+-2006},{12,0,783},{135,10,1956},{136,0,274},{135,0,1882},{132,0,794},{135,0,1848}
+-,{5,10,944},{134,10,1769},{6,0,47},{7,0,90},{7,0,664},{7,0,830},{7,0,1380},{7,0,
+-2025},{8,0,448},{136,0,828},{132,10,144},{134,0,1199},{4,11,395},{139,11,762},{
+-135,11,1504},{9,0,417},{137,0,493},{9,11,174},{10,11,164},{11,11,440},{11,11,841
+-},{143,11,98},{134,11,426},{139,11,1002},{134,0,295},{134,0,816},{6,10,247},{137
+-,10,555},{133,0,1019},{4,0,620},{5,11,476},{10,10,280},{138,10,797},{139,0,464},
+-{5,11,76},{6,11,458},{6,11,497},{7,11,764},{7,11,868},{9,11,658},{10,11,594},{11
+-,11,173},{11,11,566},{12,11,20},{12,11,338},{141,11,200},{134,0,208},{4,11,526},
+-{7,11,1029},{135,11,1054},{132,11,636},{6,11,233},{7,11,660},{7,11,1124},{17,11,
+-31},{19,11,22},{151,11,14},{10,0,442},{133,10,428},{10,0,930},{140,0,778},{6,0,
+-68},{7,0,448},{7,0,1629},{7,0,1769},{7,0,1813},{8,0,442},{8,0,516},{9,0,710},{10
+-,0,282},{10,0,722},{7,10,1717},{138,10,546},{134,0,1128},{11,0,844},{12,0,104},{
+-140,0,625},{4,11,432},{135,11,824},{138,10,189},{133,0,787},{133,10,99},{4,11,
+-279},{7,11,301},{137,11,362},{8,0,491},{4,10,397},{136,10,555},{4,11,178},{133,
+-11,399},{134,0,711},{144,0,9},{4,0,403},{5,0,441},{7,0,450},{10,0,840},{11,0,101
+-},{12,0,193},{141,0,430},{135,11,1246},{12,10,398},{20,10,39},{21,10,11},{150,10
+-,41},{4,10,485},{7,10,353},{135,10,1523},{6,10,366},{7,10,1384},{7,10,1601},{135
+-,11,1912},{7,0,396},{10,0,160},{135,11,396},{137,10,282},{134,11,1692},{4,10,157
+-},{5,10,471},{6,11,202},{10,11,448},{11,11,208},{12,11,360},{17,11,117},{17,11,
+-118},{18,11,27},{148,11,67},{133,0,679},{137,0,326},{136,10,116},{7,11,872},{10,
+-11,516},{139,11,167},{132,11,224},{5,11,546},{7,11,35},{8,11,11},{8,11,12},{9,11
+-,315},{9,11,533},{10,11,802},{11,11,166},{12,11,525},{142,11,243},{7,0,1128},{
+-135,11,1920},{5,11,241},{8,11,242},{9,11,451},{10,11,667},{11,11,598},{140,11,
+-429},{6,0,737},{5,10,160},{7,10,363},{7,10,589},{10,10,170},{141,10,55},{135,0,
+-1796},{142,11,254},{4,0,574},{7,0,350},{7,0,1024},{8,0,338},{9,0,677},{138,0,808
+-},{134,0,1096},{137,11,516},{7,0,405},{10,0,491},{4,10,108},{4,11,366},{139,10,
+-498},{11,11,337},{142,11,303},{134,11,1736},{7,0,1081},{140,11,364},{7,10,1005},
+-{140,10,609},{7,0,1676},{4,10,895},{133,10,772},{135,0,2037},{6,0,1207},{11,11,
+-916},{142,11,419},{14,11,140},{148,11,41},{6,11,331},{136,11,623},{9,0,944},{9,0
+-,969},{9,0,1022},{12,0,913},{12,0,936},{15,0,177},{15,0,193},{4,10,926},{133,10,
+-983},{5,0,354},{135,11,506},{8,0,598},{9,0,664},{138,0,441},{4,11,640},{133,11,
+-513},{137,0,297},{132,10,538},{6,10,294},{7,10,1267},{136,10,624},{7,0,1772},{7,
+-11,1888},{8,11,289},{11,11,45},{12,11,278},{140,11,537},{135,10,1325},{138,0,751
+-},{141,0,37},{134,0,1828},{132,10,757},{132,11,394},{6,0,257},{135,0,1522},{4,0,
+-582},{9,0,191},{135,11,1931},{7,11,574},{7,11,1719},{137,11,145},{132,11,658},{
+-10,0,790},{132,11,369},{9,11,781},{10,11,144},{11,11,385},{13,11,161},{13,11,228
+-},{13,11,268},{148,11,107},{8,0,469},{10,0,47},{136,11,374},{6,0,306},{7,0,1140}
+-,{7,0,1340},{8,0,133},{138,0,449},{139,0,1011},{7,10,1875},{139,10,124},{4,11,
+-344},{6,11,498},{139,11,323},{137,0,299},{132,0,837},{133,11,906},{5,0,329},{8,0
+-,260},{138,0,10},{134,0,1320},{4,0,657},{146,0,158},{135,0,1191},{152,0,7},{6,0,
+-1939},{8,0,974},{138,0,996},{135,0,1665},{11,11,126},{139,11,287},{143,0,8},{14,
+-11,149},{14,11,399},{143,11,57},{5,0,66},{7,0,1896},{136,0,288},{7,0,175},{10,0,
+-494},{5,10,150},{8,10,603},{9,10,593},{9,10,634},{10,10,173},{11,10,462},{11,10,
+-515},{13,10,216},{13,10,288},{142,10,400},{134,0,1643},{136,11,21},{4,0,21},{5,0
+-,91},{5,0,648},{5,0,750},{5,0,781},{6,0,54},{6,0,112},{6,0,402},{6,0,1732},{7,0,
+-315},{7,0,749},{7,0,1427},{7,0,1900},{9,0,78},{9,0,508},{10,0,611},{10,0,811},{
+-11,0,510},{11,0,728},{13,0,36},{14,0,39},{16,0,83},{17,0,124},{148,0,30},{4,0,
+-668},{136,0,570},{10,0,322},{10,0,719},{139,0,407},{135,11,1381},{136,11,193},{
+-12,10,108},{141,10,291},{132,11,616},{136,11,692},{8,0,125},{8,0,369},{8,0,524},
+-{10,0,486},{11,0,13},{11,0,381},{11,0,736},{11,0,766},{11,0,845},{13,0,114},{13,
+-0,292},{142,0,47},{134,0,1247},{6,0,1684},{6,0,1731},{7,0,356},{8,0,54},{8,0,221
+-},{9,0,225},{9,0,356},{10,0,77},{10,0,446},{10,0,731},{12,0,404},{141,0,491},{
+-135,10,1777},{4,11,305},{4,10,493},{144,10,55},{4,0,951},{6,0,1809},{6,0,1849},{
+-8,0,846},{8,0,866},{8,0,899},{10,0,896},{12,0,694},{142,0,468},{5,11,214},{7,11,
+-603},{8,11,611},{9,11,686},{10,11,88},{11,11,459},{11,11,496},{12,11,463},{12,11
+-,590},{13,11,0},{142,11,214},{132,0,411},{4,0,80},{133,0,44},{140,11,74},{143,0,
+-31},{7,0,669},{6,10,568},{7,10,1804},{8,10,362},{8,10,410},{8,10,830},{9,10,514}
+-,{11,10,649},{142,10,157},{7,0,673},{134,11,1703},{132,10,625},{134,0,1303},{5,0
+-,299},{135,0,1083},{138,0,704},{6,0,275},{7,0,408},{6,10,158},{7,10,129},{7,10,
+-181},{8,10,276},{8,10,377},{10,10,523},{11,10,816},{12,10,455},{13,10,303},{142,
+-10,135},{4,0,219},{7,0,367},{7,0,1713},{7,0,1761},{9,0,86},{9,0,537},{10,0,165},
+-{12,0,219},{140,0,561},{8,0,216},{4,10,1},{4,11,737},{6,11,317},{7,10,1143},{7,
+-10,1463},{9,10,207},{9,10,390},{9,10,467},{10,11,98},{11,11,294},{11,10,836},{12
+-,11,60},{12,11,437},{13,11,64},{13,11,380},{142,11,430},{6,11,1758},{8,11,520},{
+-9,11,345},{9,11,403},{142,11,350},{5,11,47},{10,11,242},{138,11,579},{5,11,139},
+-{7,11,1168},{138,11,539},{135,0,1319},{4,10,295},{4,10,723},{5,10,895},{7,10,
+-1031},{8,10,199},{8,10,340},{9,10,153},{9,10,215},{10,10,21},{10,10,59},{10,10,
+-80},{10,10,224},{10,10,838},{11,10,229},{11,10,652},{12,10,192},{13,10,146},{142
+-,10,91},{140,0,428},{137,10,51},{133,0,514},{5,10,309},{140,10,211},{6,0,1010},{
+-5,10,125},{8,10,77},{138,10,15},{4,0,55},{5,0,301},{6,0,571},{142,0,49},{146,0,
+-102},{136,11,370},{4,11,107},{7,11,613},{8,11,358},{8,11,439},{8,11,504},{9,11,
+-501},{10,11,383},{139,11,477},{132,11,229},{133,0,364},{133,10,439},{4,11,903},{
+-135,11,1816},{11,0,379},{140,10,76},{4,0,76},{4,0,971},{7,0,1550},{9,0,306},{9,0
+-,430},{9,0,663},{10,0,683},{10,0,921},{11,0,427},{11,0,753},{12,0,334},{12,0,442
+-},{14,0,258},{14,0,366},{143,0,131},{137,0,52},{4,11,47},{6,11,373},{7,11,452},{
+-7,11,543},{7,11,1714},{7,11,1856},{9,11,6},{11,11,257},{139,11,391},{4,10,8},{7,
+-10,1152},{7,10,1153},{7,10,1715},{9,10,374},{10,10,478},{139,10,648},{4,11,785},
+-{133,11,368},{135,10,1099},{135,11,860},{5,11,980},{134,11,1754},{134,0,1258},{6
+-,0,1058},{6,0,1359},{7,11,536},{7,11,1331},{136,11,143},{4,0,656},{135,0,779},{
+-136,10,87},{5,11,19},{6,11,533},{146,11,126},{7,0,144},{138,10,438},{5,11,395},{
+-5,11,951},{134,11,1776},{135,0,1373},{7,0,554},{7,0,605},{141,0,10},{4,10,69},{5
+-,10,122},{9,10,656},{138,10,464},{5,10,849},{134,10,1633},{5,0,838},{5,0,841},{
+-134,0,1649},{133,0,1012},{139,10,499},{7,10,476},{7,10,1592},{138,10,87},{6,0,
+-251},{7,0,365},{7,0,1357},{7,0,1497},{8,0,154},{141,0,281},{132,11,441},{132,11,
+-695},{7,11,497},{9,11,387},{147,11,81},{133,0,340},{14,10,283},{142,11,283},{134
+-,0,810},{135,11,1894},{139,0,495},{5,11,284},{6,11,49},{6,11,350},{7,11,1},{7,11
+-,377},{7,11,1693},{8,11,18},{8,11,678},{9,11,161},{9,11,585},{9,11,671},{9,11,
+-839},{11,11,912},{141,11,427},{5,10,859},{7,10,1160},{8,10,107},{9,10,291},{9,10
+-,439},{10,10,663},{11,10,609},{140,10,197},{8,0,261},{9,0,144},{9,0,466},{10,0,
+-370},{12,0,470},{13,0,144},{142,0,348},{137,0,897},{6,0,248},{9,0,546},{10,0,535
+-},{11,0,681},{141,0,135},{4,0,358},{135,0,1496},{134,0,567},{136,0,445},{4,10,
+-117},{6,10,372},{7,10,1905},{142,10,323},{4,10,722},{139,10,471},{6,0,697},{134,
+-0,996},{7,11,2007},{9,11,101},{9,11,450},{10,11,66},{10,11,842},{11,11,536},{140
+-,11,587},{132,0,577},{134,0,1336},{9,10,5},{12,10,216},{12,10,294},{12,10,298},{
+-12,10,400},{12,10,518},{13,10,229},{143,10,139},{6,0,174},{138,0,917},{134,10,
+-1774},{5,10,12},{7,10,375},{9,10,88},{9,10,438},{11,11,62},{139,10,270},{134,11,
+-1766},{6,11,0},{7,11,84},{7,10,816},{7,10,1241},{9,10,283},{9,10,520},{10,10,213
+-},{10,10,307},{10,10,463},{10,10,671},{10,10,746},{11,10,401},{11,10,794},{11,11
+-,895},{12,10,517},{17,11,11},{18,10,107},{147,10,115},{5,0,878},{133,0,972},{6,
+-11,1665},{7,11,256},{7,11,1388},{138,11,499},{4,10,258},{136,10,639},{4,11,22},{
+-5,11,10},{6,10,22},{7,11,848},{7,10,903},{7,10,1963},{8,11,97},{138,10,577},{5,
+-10,681},{136,10,782},{133,11,481},{132,0,351},{4,10,664},{5,10,804},{139,10,1013
+-},{6,11,134},{7,11,437},{7,11,959},{9,11,37},{14,11,285},{14,11,371},{144,11,60}
+-,{7,11,486},{8,11,155},{11,11,93},{140,11,164},{132,0,286},{7,0,438},{7,0,627},{
+-7,0,1516},{8,0,40},{9,0,56},{9,0,294},{10,0,30},{11,0,969},{11,0,995},{146,0,148
+-},{5,11,591},{135,11,337},{134,0,1950},{133,10,32},{138,11,500},{5,11,380},{5,11
+-,650},{136,11,310},{4,11,364},{7,11,1156},{7,11,1187},{137,11,409},{4,0,738},{
+-134,11,482},{4,11,781},{6,11,487},{7,11,926},{8,11,263},{139,11,500},{135,11,418
+-},{6,0,2047},{10,0,969},{4,10,289},{7,10,629},{7,10,1698},{7,10,1711},{140,10,
+-215},{6,10,450},{136,10,109},{134,0,818},{136,10,705},{133,0,866},{4,11,94},{135
+-,11,1265},{132,11,417},{134,0,1467},{135,10,1238},{4,0,972},{6,0,1851},{134,0,
+-1857},{134,0,355},{133,0,116},{132,0,457},{135,11,1411},{4,11,408},{4,11,741},{
+-135,11,500},{134,10,26},{142,11,137},{5,0,527},{6,0,189},{7,0,859},{136,0,267},{
+-11,0,104},{11,0,554},{15,0,60},{143,0,125},{134,0,1613},{4,10,414},{5,10,467},{9
+-,10,654},{10,10,451},{12,10,59},{141,10,375},{135,10,17},{134,0,116},{135,11,541
+-},{135,10,955},{6,11,73},{135,11,177},{133,11,576},{134,0,886},{133,0,487},{4,0,
+-86},{5,0,667},{5,0,753},{6,0,316},{6,0,455},{135,0,946},{142,11,231},{150,0,45},
+-{134,0,863},{134,0,1953},{6,10,280},{10,10,502},{11,10,344},{140,10,38},{4,0,79}
+-,{7,0,1773},{10,0,450},{11,0,589},{13,0,332},{13,0,493},{14,0,183},{14,0,334},{
+-14,0,362},{14,0,368},{14,0,376},{14,0,379},{19,0,90},{19,0,103},{19,0,127},{148,
+-0,90},{5,10,45},{7,10,1161},{11,10,448},{11,10,880},{13,10,139},{13,10,407},{15,
+-10,16},{17,10,95},{18,10,66},{18,10,88},{18,10,123},{149,10,7},{136,10,777},{4,
+-10,410},{135,10,521},{135,10,1778},{135,11,538},{142,0,381},{133,11,413},{134,0,
+-1142},{6,0,1189},{136,11,495},{5,0,663},{6,0,1962},{134,0,2003},{7,11,54},{8,11,
+-312},{10,11,191},{10,11,614},{140,11,567},{132,10,436},{133,0,846},{10,0,528},{
+-11,0,504},{7,10,1587},{135,10,1707},{5,0,378},{8,0,465},{9,0,286},{10,0,185},{10
+-,0,562},{10,0,635},{11,0,31},{11,0,393},{13,0,312},{18,0,65},{18,0,96},{147,0,89
+-},{7,0,899},{14,0,325},{6,11,468},{7,11,567},{7,11,1478},{8,11,530},{142,11,290}
+-,{7,0,1880},{9,0,680},{139,0,798},{134,0,1770},{132,0,648},{150,11,35},{5,0,945}
+-,{6,0,1656},{6,0,1787},{7,0,167},{8,0,824},{9,0,391},{10,0,375},{139,0,185},{6,
+-11,484},{135,11,822},{134,0,2046},{7,0,1645},{8,0,352},{137,0,249},{132,0,152},{
+-6,0,611},{135,0,1733},{6,11,1724},{135,11,2022},{133,0,1006},{141,11,96},{5,0,
+-420},{135,0,1449},{146,11,149},{135,0,832},{135,10,663},{133,0,351},{5,0,40},{7,
+-0,598},{7,0,1638},{8,0,78},{9,0,166},{9,0,640},{9,0,685},{9,0,773},{11,0,215},{
+-13,0,65},{14,0,172},{14,0,317},{145,0,6},{8,0,60},{9,0,343},{139,0,769},{134,0,
+-1354},{132,0,724},{137,0,745},{132,11,474},{7,0,1951},{8,0,765},{8,0,772},{140,0
+-,671},{7,0,108},{8,0,219},{8,0,388},{9,0,775},{11,0,275},{140,0,464},{137,0,639}
+-,{135,10,503},{133,11,366},{5,0,15},{6,0,56},{7,0,1758},{8,0,500},{9,0,730},{11,
+-0,331},{13,0,150},{14,0,282},{5,11,305},{9,11,560},{141,11,208},{4,10,113},{5,10
+-,163},{5,10,735},{7,10,1009},{9,10,9},{9,10,771},{12,10,90},{13,10,138},{13,10,
+-410},{143,10,128},{4,10,324},{138,10,104},{135,11,466},{142,11,27},{134,0,1886},
+-{5,0,205},{6,0,438},{9,0,711},{4,11,480},{6,11,167},{6,11,302},{6,11,1642},{7,11
+-,130},{7,11,656},{7,11,837},{7,11,1547},{7,11,1657},{8,11,429},{9,11,228},{10,11
+-,643},{13,11,289},{13,11,343},{147,11,101},{134,0,865},{6,0,2025},{136,0,965},{7
+-,11,278},{10,11,739},{11,11,708},{141,11,348},{133,0,534},{135,11,1922},{137,0,
+-691},{4,10,935},{133,10,823},{6,0,443},{9,0,237},{9,0,571},{9,0,695},{10,0,139},
+-{11,0,715},{12,0,417},{141,0,421},{5,10,269},{7,10,434},{7,10,891},{8,10,339},{9
+-,10,702},{11,10,594},{11,10,718},{145,10,100},{6,0,1555},{7,0,878},{9,10,485},{
+-141,10,264},{134,10,1713},{7,10,1810},{11,10,866},{12,10,103},{141,10,495},{135,
+-10,900},{6,0,1410},{9,11,316},{139,11,256},{4,0,995},{135,0,1033},{132,0,578},{
+-10,0,881},{12,0,740},{12,0,743},{140,0,759},{132,0,822},{133,0,923},{142,10,143}
+-,{135,11,1696},{6,11,363},{7,11,1955},{136,11,725},{132,0,924},{133,0,665},{135,
+-10,2029},{135,0,1901},{4,0,265},{6,0,1092},{6,0,1417},{7,0,807},{135,0,950},{5,0
+-,93},{12,0,267},{141,0,498},{135,0,1451},{5,11,813},{135,11,2046},{5,10,625},{
+-135,10,1617},{135,0,747},{6,0,788},{137,0,828},{7,0,184},{11,0,307},{11,0,400},{
+-15,0,130},{5,11,712},{7,11,1855},{8,10,425},{8,10,693},{9,10,720},{10,10,380},{
+-10,10,638},{11,11,17},{11,10,473},{12,10,61},{13,11,321},{144,11,67},{135,0,198}
+-,{6,11,320},{7,11,781},{7,11,1921},{9,11,55},{10,11,186},{10,11,273},{10,11,664}
+-,{10,11,801},{11,11,996},{11,11,997},{13,11,157},{142,11,170},{136,11,271},{135,
+-0,994},{7,11,103},{7,11,863},{11,11,184},{14,11,299},{145,11,62},{11,10,551},{
+-142,10,159},{5,0,233},{5,0,320},{6,0,140},{8,0,295},{8,0,615},{136,11,615},{133,
+-0,978},{4,0,905},{6,0,1701},{137,0,843},{132,10,168},{4,0,974},{8,0,850},{12,0,
+-709},{12,0,768},{140,0,786},{135,10,91},{152,0,6},{138,10,532},{135,10,1884},{
+-132,0,509},{6,0,1307},{135,0,273},{5,11,77},{7,11,1455},{10,11,843},{19,11,73},{
+-150,11,5},{132,11,458},{135,11,1420},{6,11,109},{138,11,382},{6,0,201},{6,11,330
+-},{7,10,70},{7,11,1084},{10,10,240},{11,11,142},{147,10,93},{7,0,1041},{140,11,
+-328},{133,11,354},{134,0,1040},{133,0,693},{134,0,774},{139,0,234},{132,0,336},{
+-7,0,1399},{139,10,392},{20,0,22},{148,11,22},{5,0,802},{7,0,2021},{136,0,805},{5
+-,0,167},{5,0,899},{6,0,410},{137,0,777},{137,0,789},{134,0,1705},{7,10,655},{135
+-,10,1844},{4,10,145},{6,10,176},{7,10,395},{137,10,562},{132,10,501},{135,0,10},
+-{5,0,11},{6,0,117},{6,0,485},{7,0,1133},{9,0,582},{9,0,594},{10,0,82},{11,0,21},
+-{11,0,818},{12,0,535},{13,0,86},{20,0,91},{23,0,13},{134,10,509},{4,0,264},{7,0,
+-1067},{8,0,204},{8,0,385},{139,0,953},{139,11,737},{138,0,56},{134,0,1917},{133,
+-0,470},{10,11,657},{14,11,297},{142,11,361},{135,11,412},{7,0,1198},{7,11,1198},
+-{8,11,556},{14,11,123},{14,11,192},{143,11,27},{7,11,1985},{14,11,146},{15,11,42
+-},{16,11,23},{17,11,86},{146,11,17},{11,0,1015},{136,11,122},{4,10,114},{9,10,
+-492},{13,10,462},{142,10,215},{4,10,77},{5,10,361},{6,10,139},{6,10,401},{6,10,
+-404},{7,10,413},{7,10,715},{7,10,1716},{11,10,279},{12,10,179},{12,10,258},{13,
+-10,244},{142,10,358},{134,10,1717},{7,10,1061},{8,10,82},{11,10,250},{12,10,420}
+-,{141,10,184},{133,0,715},{135,10,724},{9,0,919},{9,0,922},{9,0,927},{9,0,933},{
+-9,0,962},{9,0,1000},{9,0,1002},{9,0,1021},{12,0,890},{12,0,907},{12,0,930},{15,0
+-,207},{15,0,228},{15,0,238},{149,0,61},{8,0,794},{9,0,400},{10,0,298},{142,0,228
+-},{5,11,430},{5,11,932},{6,11,131},{7,11,417},{9,11,522},{11,11,314},{141,11,390
+-},{132,0,867},{8,0,724},{132,11,507},{137,11,261},{4,11,343},{133,11,511},{6,0,
+-190},{7,0,768},{135,0,1170},{6,10,513},{135,10,1052},{7,11,455},{138,11,591},{
+-134,0,1066},{137,10,899},{14,0,67},{147,0,60},{4,0,948},{18,0,174},{146,0,176},{
+-135,0,1023},{7,10,1417},{12,10,382},{17,10,48},{152,10,12},{134,11,575},{132,0,
+-764},{6,10,545},{7,10,565},{7,10,1669},{10,10,114},{11,10,642},{140,10,618},{6,0
+-,137},{9,0,75},{9,0,253},{10,0,194},{138,0,444},{4,0,756},{133,10,5},{8,0,1008},
+-{135,10,192},{132,0,842},{11,0,643},{12,0,115},{136,10,763},{139,0,67},{133,10,
+-759},{4,0,821},{5,0,760},{7,0,542},{8,0,135},{8,0,496},{135,11,580},{7,10,370},{
+-7,10,1007},{7,10,1177},{135,10,1565},{135,10,1237},{140,0,736},{7,0,319},{7,0,
+-355},{7,0,763},{10,0,389},{145,0,43},{8,11,333},{138,11,182},{4,10,87},{5,10,250
+-},{141,10,298},{138,0,786},{134,0,2044},{8,11,330},{140,11,477},{135,11,1338},{
+-132,11,125},{134,0,1030},{134,0,1083},{132,11,721},{135,10,814},{7,11,776},{8,11
+-,145},{147,11,56},{134,0,1226},{4,10,57},{7,10,1195},{7,10,1438},{7,10,1548},{7,
+-10,1835},{7,10,1904},{9,10,757},{10,10,604},{139,10,519},{7,11,792},{8,11,147},{
+-10,11,821},{139,11,1021},{137,11,797},{4,0,58},{5,0,286},{6,0,319},{7,0,402},{7,
+-0,1254},{7,0,1903},{8,0,356},{140,0,408},{4,0,389},{4,0,815},{9,0,181},{9,0,255}
+-,{10,0,8},{10,0,29},{10,0,816},{11,0,311},{11,0,561},{12,0,67},{141,0,181},{7,11
+-,1472},{135,11,1554},{7,11,1071},{7,11,1541},{7,11,1767},{7,11,1806},{7,11,1999}
+-,{9,11,248},{10,11,400},{11,11,162},{11,11,178},{11,11,242},{12,11,605},{15,11,
+-26},{144,11,44},{5,11,168},{5,11,930},{8,11,74},{9,11,623},{12,11,500},{12,11,
+-579},{13,11,41},{143,11,93},{6,11,220},{7,11,1101},{141,11,105},{5,0,474},{7,0,
+-507},{4,10,209},{7,11,507},{135,10,902},{132,0,427},{6,0,413},{7,10,335},{7,10,
+-1437},{7,10,1668},{8,10,553},{8,10,652},{8,10,656},{9,10,558},{11,10,743},{149,
+-10,18},{132,0,730},{6,11,19},{7,11,1413},{139,11,428},{133,0,373},{132,10,559},{
+-7,11,96},{8,11,401},{137,11,896},{7,0,799},{7,0,1972},{5,10,1017},{138,10,511},{
+-135,0,1793},{7,11,1961},{7,11,1965},{8,11,702},{136,11,750},{8,11,150},{8,11,737
+-},{140,11,366},{132,0,322},{133,10,709},{8,11,800},{9,11,148},{9,11,872},{9,11,
+-890},{11,11,309},{11,11,1001},{13,11,267},{141,11,323},{134,10,1745},{7,0,290},{
+-136,10,206},{7,0,1651},{145,0,89},{139,0,2},{132,0,672},{6,0,1860},{8,0,905},{10
+-,0,844},{10,0,846},{10,0,858},{12,0,699},{12,0,746},{140,0,772},{135,11,424},{
+-133,11,547},{133,0,737},{5,11,490},{6,11,615},{6,11,620},{135,11,683},{6,0,746},
+-{134,0,1612},{132,10,776},{9,11,385},{149,11,17},{133,0,145},{135,10,1272},{7,0,
+-884},{140,0,124},{4,0,387},{135,0,1288},{5,11,133},{136,10,406},{136,11,187},{6,
+-0,679},{8,11,8},{138,11,0},{135,0,550},{135,11,798},{136,11,685},{7,11,1086},{
+-145,11,46},{8,10,175},{10,10,168},{138,10,573},{135,0,1305},{4,0,576},{135,0,
+-1263},{6,0,686},{134,0,1563},{134,0,607},{5,0,919},{134,0,1673},{148,0,37},{8,11
+-,774},{10,11,670},{140,11,51},{133,10,784},{139,10,882},{4,0,82},{5,0,333},{5,0,
+-904},{6,0,207},{7,0,325},{7,0,1726},{8,0,101},{10,0,778},{139,0,220},{135,11,371
+-},{132,0,958},{133,0,903},{4,11,127},{5,11,350},{6,11,356},{8,11,426},{9,11,572}
+-,{10,11,247},{139,11,312},{140,0,147},{6,11,59},{7,11,885},{9,11,603},{141,11,
+-397},{10,0,367},{9,10,14},{9,10,441},{139,10,9},{11,10,966},{12,10,287},{13,10,
+-342},{13,10,402},{15,10,110},{143,10,163},{134,0,690},{132,0,705},{9,0,651},{11,
+-0,971},{13,0,273},{7,10,1428},{7,10,1640},{7,10,1867},{9,10,169},{9,10,182},{9,
+-10,367},{9,10,478},{9,10,506},{9,10,551},{9,10,557},{9,10,648},{9,10,697},{9,10,
+-705},{9,10,725},{9,10,787},{9,10,794},{10,10,198},{10,10,214},{10,10,267},{10,10
+-,275},{10,10,456},{10,10,551},{10,10,561},{10,10,613},{10,10,627},{10,10,668},{
+-10,10,675},{10,10,691},{10,10,695},{10,10,707},{10,10,715},{11,10,183},{11,10,
+-201},{11,10,262},{11,10,352},{11,10,439},{11,10,493},{11,10,572},{11,10,591},{11
+-,10,608},{11,10,611},{11,10,646},{11,10,674},{11,10,711},{11,10,751},{11,10,761}
+-,{11,10,776},{11,10,785},{11,10,850},{11,10,853},{11,10,862},{11,10,865},{11,10,
+-868},{11,10,875},{11,10,898},{11,10,902},{11,10,903},{11,10,910},{11,10,932},{11
+-,10,942},{11,10,957},{11,10,967},{11,10,972},{12,10,148},{12,10,195},{12,10,220}
+-,{12,10,237},{12,10,318},{12,10,339},{12,10,393},{12,10,445},{12,10,450},{12,10,
+-474},{12,10,505},{12,10,509},{12,10,533},{12,10,591},{12,10,594},{12,10,597},{12
+-,10,621},{12,10,633},{12,10,642},{13,10,59},{13,10,60},{13,10,145},{13,10,239},{
+-13,10,250},{13,10,329},{13,10,344},{13,10,365},{13,10,372},{13,10,387},{13,10,
+-403},{13,10,414},{13,10,456},{13,10,470},{13,10,478},{13,10,483},{13,10,489},{14
+-,10,55},{14,10,57},{14,10,81},{14,10,90},{14,10,148},{14,10,239},{14,10,266},{14
+-,10,321},{14,10,326},{14,10,327},{14,10,330},{14,10,347},{14,10,355},{14,10,401}
+-,{14,10,404},{14,10,411},{14,10,414},{14,10,416},{14,10,420},{15,10,61},{15,10,
+-74},{15,10,87},{15,10,88},{15,10,94},{15,10,96},{15,10,116},{15,10,149},{15,10,
+-154},{16,10,50},{16,10,63},{16,10,73},{17,10,2},{17,10,66},{17,10,92},{17,10,103
+-},{17,10,112},{17,10,120},{18,10,50},{18,10,54},{18,10,82},{18,10,86},{18,10,90}
+-,{18,10,111},{18,10,115},{18,10,156},{19,10,40},{19,10,79},{20,10,78},{149,10,22
+-},{7,0,887},{5,10,161},{135,10,839},{142,11,98},{134,0,90},{138,11,356},{135,11,
+-441},{6,11,111},{7,11,4},{8,11,163},{8,11,776},{138,11,566},{134,0,908},{134,0,
+-1261},{7,0,813},{12,0,497},{141,0,56},{134,0,1235},{135,0,429},{135,11,1994},{
+-138,0,904},{6,0,125},{7,0,1277},{137,0,772},{151,0,12},{4,0,841},{5,0,386},{133,
+-11,386},{5,11,297},{135,11,1038},{6,0,860},{6,0,1069},{135,11,309},{136,0,946},{
+-135,10,1814},{141,11,418},{136,11,363},{10,0,768},{139,0,787},{22,11,30},{150,11
+-,33},{6,0,160},{7,0,1106},{9,0,770},{11,0,112},{140,0,413},{11,11,216},{139,11,
+-340},{136,10,139},{135,11,1390},{135,11,808},{132,11,280},{12,0,271},{17,0,109},
+-{7,10,643},{136,10,236},{140,11,54},{4,11,421},{133,11,548},{11,0,719},{12,0,36}
+-,{141,0,337},{7,0,581},{9,0,644},{137,0,699},{11,11,511},{13,11,394},{14,11,298}
+-,{14,11,318},{146,11,103},{7,0,304},{9,0,646},{9,0,862},{11,0,696},{12,0,208},{
+-15,0,79},{147,0,108},{4,0,631},{7,0,1126},{135,0,1536},{135,11,1527},{8,0,880},{
+-10,0,869},{138,0,913},{7,0,1513},{5,10,54},{6,11,254},{9,11,109},{138,11,103},{
+-135,0,981},{133,11,729},{132,10,744},{132,0,434},{134,0,550},{7,0,930},{10,0,476
+-},{13,0,452},{19,0,104},{6,11,1630},{10,10,402},{146,10,55},{5,0,553},{138,0,824
+-},{136,0,452},{8,0,151},{137,10,624},{132,10,572},{132,0,772},{133,11,671},{133,
+-0,292},{138,0,135},{132,11,889},{140,11,207},{9,0,504},{6,10,43},{7,10,38},{8,10
+-,248},{138,10,513},{6,0,1089},{135,11,1910},{4,11,627},{133,11,775},{135,0,783},
+-{133,10,766},{133,10,363},{7,0,387},{135,11,387},{7,0,393},{10,0,603},{11,0,206}
+-,{7,11,202},{11,11,362},{11,11,948},{140,11,388},{6,11,507},{7,11,451},{8,11,389
+-},{12,11,490},{13,11,16},{13,11,215},{13,11,351},{18,11,132},{147,11,125},{4,0,
+-912},{9,0,232},{135,11,841},{6,10,258},{140,10,409},{5,10,249},{148,10,82},{136,
+-11,566},{6,0,977},{135,11,1214},{7,0,1973},{136,0,716},{135,0,98},{133,0,733},{5
+-,11,912},{134,11,1695},{5,10,393},{6,10,378},{7,10,1981},{9,10,32},{9,10,591},{
+-10,10,685},{10,10,741},{142,10,382},{133,10,788},{10,0,19},{11,0,911},{7,10,1968
+-},{141,10,509},{5,0,668},{5,11,236},{6,11,572},{8,11,492},{11,11,618},{144,11,56
+-},{135,11,1789},{4,0,360},{5,0,635},{5,0,700},{5,10,58},{5,10,171},{5,10,683},{6
+-,10,291},{6,10,566},{7,10,1650},{11,10,523},{12,10,273},{12,10,303},{15,10,39},{
+-143,10,111},{133,0,901},{134,10,589},{5,11,190},{136,11,318},{140,0,656},{7,0,
+-726},{152,0,9},{4,10,917},{133,10,1005},{135,10,1598},{134,11,491},{4,10,919},{
+-133,11,434},{137,0,72},{6,0,1269},{6,0,1566},{134,0,1621},{9,0,463},{10,0,595},{
+-4,10,255},{5,10,302},{6,10,132},{7,10,128},{7,10,283},{7,10,1299},{10,10,52},{10
+-,10,514},{11,10,925},{13,10,92},{142,10,309},{135,0,1454},{134,0,1287},{11,0,600
+-},{13,0,245},{137,10,173},{136,0,989},{7,0,164},{7,0,1571},{9,0,107},{140,0,225}
+-,{6,0,1061},{141,10,442},{4,0,27},{5,0,484},{5,0,510},{6,0,434},{7,0,1000},{7,0,
+-1098},{136,0,2},{7,11,85},{7,11,247},{8,11,585},{10,11,163},{138,11,316},{11,11,
+-103},{142,11,0},{134,0,1127},{4,0,460},{134,0,852},{134,10,210},{4,0,932},{133,0
+-,891},{6,0,588},{147,11,83},{8,0,625},{4,10,284},{134,10,223},{134,0,76},{8,0,92
+-},{137,0,221},{4,11,124},{10,11,457},{11,11,121},{11,11,169},{11,11,422},{11,11,
+-870},{12,11,214},{13,11,389},{14,11,187},{143,11,77},{9,11,618},{138,11,482},{4,
+-10,218},{7,10,526},{143,10,137},{13,0,9},{14,0,104},{14,0,311},{4,10,270},{5,10,
+-192},{6,10,332},{135,10,1322},{140,10,661},{135,11,1193},{6,11,107},{7,11,638},{
+-7,11,1632},{137,11,396},{132,0,763},{4,0,622},{5,11,370},{134,11,1756},{133,0,
+-253},{135,0,546},{9,0,73},{10,0,110},{14,0,185},{17,0,119},{133,11,204},{7,0,624
+-},{7,0,916},{10,0,256},{139,0,87},{7,10,379},{8,10,481},{137,10,377},{5,0,212},{
+-12,0,35},{13,0,382},{5,11,970},{134,11,1706},{9,0,746},{5,10,1003},{134,10,149},
+-{10,0,150},{11,0,849},{13,0,330},{8,10,262},{9,10,627},{11,10,214},{11,10,404},{
+-11,10,457},{11,10,780},{11,10,913},{13,10,401},{142,10,200},{134,0,1466},{135,11
+-,3},{6,0,1299},{4,11,35},{5,11,121},{5,11,483},{5,11,685},{6,11,489},{7,11,1204}
+-,{136,11,394},{135,10,742},{4,10,142},{136,10,304},{4,11,921},{133,11,1007},{134
+-,0,1518},{6,0,1229},{135,0,1175},{133,0,816},{12,0,159},{4,10,471},{4,11,712},{5
+-,10,51},{6,10,602},{7,10,925},{8,10,484},{138,10,195},{134,11,1629},{5,0,869},{5
+-,0,968},{6,0,1626},{8,0,734},{136,0,784},{4,0,542},{6,0,1716},{6,0,1727},{7,0,
+-1082},{7,0,1545},{8,0,56},{8,0,118},{8,0,412},{8,0,564},{9,0,888},{9,0,908},{10,
+-0,50},{10,0,423},{11,0,685},{11,0,697},{11,0,933},{12,0,299},{13,0,126},{13,0,
+-136},{13,0,170},{13,0,190},{136,10,688},{132,10,697},{4,0,232},{9,0,202},{10,0,
+-474},{140,0,433},{136,0,212},{6,0,108},{7,0,1003},{7,0,1181},{8,0,111},{136,0,
+-343},{5,10,221},{135,11,1255},{133,11,485},{134,0,1712},{142,0,216},{5,0,643},{6
+-,0,516},{4,11,285},{5,11,317},{6,11,301},{7,11,7},{8,11,153},{10,11,766},{11,11,
+-468},{12,11,467},{141,11,143},{4,0,133},{7,0,711},{7,0,1298},{135,0,1585},{134,0
+-,650},{135,11,512},{6,0,99},{7,0,1808},{145,0,57},{6,0,246},{6,0,574},{7,0,428},
+-{9,0,793},{10,0,669},{11,0,485},{11,0,840},{12,0,300},{14,0,250},{145,0,55},{4,
+-10,132},{5,10,69},{135,10,1242},{136,0,1023},{7,0,302},{132,10,111},{135,0,1871}
+-,{132,0,728},{9,0,252},{132,10,767},{6,0,461},{7,0,1590},{7,10,1416},{7,10,2005}
+-,{8,10,131},{8,10,466},{9,10,672},{13,10,252},{148,10,103},{6,0,323},{135,0,1564
+-},{7,0,461},{136,0,775},{6,10,44},{136,10,368},{139,0,172},{132,0,464},{4,10,570
+-},{133,10,120},{137,11,269},{6,10,227},{135,10,1589},{6,11,1719},{6,11,1735},{7,
+-11,2016},{7,11,2020},{8,11,837},{137,11,852},{7,0,727},{146,0,73},{132,0,1023},{
+-135,11,852},{135,10,1529},{136,0,577},{138,11,568},{134,0,1037},{8,11,67},{138,
+-11,419},{4,0,413},{5,0,677},{8,0,432},{140,0,280},{10,0,600},{6,10,1667},{7,11,
+-967},{7,10,2036},{141,11,11},{6,10,511},{140,10,132},{6,0,799},{5,10,568},{6,10,
+-138},{135,10,1293},{8,0,159},{4,10,565},{136,10,827},{7,0,646},{7,0,1730},{11,0,
+-446},{141,0,178},{4,10,922},{133,10,1023},{135,11,11},{132,0,395},{11,0,145},{
+-135,10,1002},{9,0,174},{10,0,164},{11,0,440},{11,0,514},{11,0,841},{15,0,98},{
+-149,0,20},{134,0,426},{10,0,608},{139,0,1002},{7,11,320},{8,11,51},{12,11,481},{
+-12,11,570},{148,11,106},{9,0,977},{9,0,983},{132,11,445},{138,0,250},{139,0,100}
+-,{6,0,1982},{136,10,402},{133,11,239},{4,10,716},{141,10,31},{5,0,476},{7,11,83}
+-,{7,11,1990},{8,11,130},{139,11,720},{8,10,691},{136,10,731},{5,11,123},{6,11,
+-530},{7,11,348},{135,11,1419},{5,0,76},{6,0,458},{6,0,497},{7,0,868},{9,0,658},{
+-10,0,594},{11,0,173},{11,0,566},{12,0,20},{12,0,338},{141,0,200},{9,11,139},{10,
+-11,399},{11,11,469},{12,11,634},{141,11,223},{9,10,840},{138,10,803},{133,10,847
+-},{11,11,223},{140,11,168},{132,11,210},{8,0,447},{9,10,53},{9,10,268},{9,10,901
+-},{10,10,518},{10,10,829},{11,10,188},{13,10,74},{14,10,46},{15,10,17},{15,10,33
+-},{17,10,40},{18,10,36},{19,10,20},{22,10,1},{152,10,2},{4,0,526},{7,0,1029},{
+-135,0,1054},{19,11,59},{150,11,2},{4,0,636},{6,0,1875},{6,0,1920},{9,0,999},{12,
+-0,807},{12,0,825},{15,0,179},{15,0,190},{18,0,182},{136,10,532},{6,0,1699},{7,0,
+-660},{7,0,1124},{17,0,31},{19,0,22},{151,0,14},{135,10,681},{132,11,430},{140,10
+-,677},{4,10,684},{136,10,384},{132,11,756},{133,11,213},{7,0,188},{7,10,110},{8,
+-10,290},{8,10,591},{9,10,382},{9,10,649},{11,10,71},{11,10,155},{11,10,313},{12,
+-10,5},{13,10,325},{142,10,287},{7,10,360},{7,10,425},{9,10,66},{9,10,278},{138,
+-10,644},{142,11,164},{4,0,279},{7,0,301},{137,0,362},{134,11,586},{135,0,1743},{
+-4,0,178},{133,0,399},{4,10,900},{133,10,861},{5,10,254},{7,10,985},{136,10,73},{
+-133,11,108},{7,10,1959},{136,10,683},{133,11,219},{4,11,193},{5,11,916},{7,11,
+-364},{10,11,398},{10,11,726},{11,11,317},{11,11,626},{12,11,142},{12,11,288},{12
+-,11,678},{13,11,313},{15,11,113},{18,11,114},{21,11,30},{150,11,53},{6,11,241},{
+-7,11,907},{8,11,832},{9,11,342},{10,11,729},{11,11,284},{11,11,445},{11,11,651},
+-{11,11,863},{13,11,398},{146,11,99},{132,0,872},{134,0,831},{134,0,1692},{6,0,
+-202},{6,0,1006},{9,0,832},{10,0,636},{11,0,208},{12,0,360},{17,0,118},{18,0,27},
+-{20,0,67},{137,11,734},{132,10,725},{7,11,993},{138,11,666},{134,0,1954},{134,10
+-,196},{7,0,872},{10,0,516},{139,0,167},{133,10,831},{4,11,562},{9,11,254},{139,
+-11,879},{137,0,313},{4,0,224},{132,11,786},{11,0,24},{12,0,170},{136,10,723},{5,
+-0,546},{7,0,35},{8,0,11},{8,0,12},{9,0,315},{9,0,533},{10,0,802},{11,0,166},{12,
+-0,525},{142,0,243},{7,0,1937},{13,10,80},{13,10,437},{145,10,74},{5,0,241},{8,0,
+-242},{9,0,451},{10,0,667},{11,0,598},{140,0,429},{150,0,46},{6,0,1273},{137,0,
+-830},{5,10,848},{6,10,66},{136,10,764},{6,0,825},{134,0,993},{4,0,1006},{10,0,
+-327},{13,0,271},{4,10,36},{7,10,1387},{139,10,755},{134,0,1023},{135,0,1580},{4,
+-0,366},{137,0,516},{132,10,887},{6,0,1736},{135,0,1891},{6,11,216},{7,11,901},{7
+-,11,1343},{136,11,493},{6,10,165},{138,10,388},{7,11,341},{139,11,219},{4,10,719
+-},{135,10,155},{134,0,1935},{132,0,826},{6,0,331},{6,0,1605},{8,0,623},{11,0,139
+-},{139,0,171},{135,11,1734},{10,11,115},{11,11,420},{12,11,154},{13,11,404},{14,
+-11,346},{15,11,54},{143,11,112},{7,0,288},{4,10,353},{6,10,146},{6,10,1789},{7,
+-10,990},{7,10,1348},{9,10,665},{9,10,898},{11,10,893},{142,10,212},{6,0,916},{
+-134,0,1592},{7,0,1888},{4,10,45},{135,10,1257},{5,11,1011},{136,11,701},{139,11,
+-596},{4,11,54},{5,11,666},{7,11,1039},{7,11,1130},{9,11,195},{138,11,302},{134,0
+-,1471},{134,0,1570},{132,0,394},{140,10,65},{136,10,816},{135,0,1931},{7,0,574},
+-{135,0,1719},{134,11,467},{132,0,658},{9,0,781},{10,0,144},{11,0,385},{13,0,161}
+-,{13,0,228},{13,0,268},{20,0,107},{134,11,1669},{136,0,374},{135,0,735},{4,0,344
+-},{6,0,498},{139,0,323},{7,0,586},{7,0,1063},{6,10,559},{134,10,1691},{137,0,155
+-},{133,0,906},{7,11,122},{9,11,259},{10,11,84},{11,11,470},{12,11,541},{141,11,
+-379},{134,0,1139},{10,0,108},{139,0,116},{134,10,456},{133,10,925},{5,11,82},{5,
+-11,131},{7,11,1755},{8,11,31},{9,11,168},{9,11,764},{139,11,869},{134,11,605},{5
+-,11,278},{137,11,68},{4,11,163},{5,11,201},{5,11,307},{5,11,310},{6,11,335},{7,
+-11,284},{136,11,165},{135,11,1660},{6,11,33},{135,11,1244},{4,0,616},{136,11,483
+-},{8,0,857},{8,0,902},{8,0,910},{10,0,879},{12,0,726},{4,11,199},{139,11,34},{
+-136,0,692},{6,10,193},{7,10,240},{7,10,1682},{10,10,51},{10,10,640},{11,10,410},
+-{13,10,82},{14,10,247},{14,10,331},{142,10,377},{6,0,823},{134,0,983},{139,10,
+-411},{132,0,305},{136,10,633},{138,11,203},{134,0,681},{6,11,326},{7,11,677},{
+-137,11,425},{5,0,214},{7,0,603},{8,0,611},{9,0,686},{10,0,88},{11,0,459},{11,0,
+-496},{12,0,463},{12,0,590},{141,0,0},{136,0,1004},{142,0,23},{134,0,1703},{147,
+-11,8},{145,11,56},{135,0,1443},{4,10,237},{135,10,514},{6,0,714},{145,0,19},{5,
+-11,358},{7,11,473},{7,11,1184},{10,11,662},{13,11,212},{13,11,304},{13,11,333},{
+-145,11,98},{4,0,737},{10,0,98},{11,0,294},{12,0,60},{12,0,437},{13,0,64},{13,0,
+-380},{142,0,430},{6,10,392},{7,10,65},{135,10,2019},{6,0,1758},{8,0,520},{9,0,
+-345},{9,0,403},{142,0,350},{5,0,47},{10,0,242},{138,0,579},{5,0,139},{7,0,1168},
+-{138,0,539},{134,0,1459},{13,0,388},{141,11,388},{134,0,253},{7,10,1260},{135,10
+-,1790},{10,0,252},{9,10,222},{139,10,900},{140,0,745},{133,11,946},{4,0,107},{7,
+-0,613},{8,0,439},{8,0,504},{9,0,501},{10,0,383},{139,0,477},{135,11,1485},{132,0
+-,871},{7,11,411},{7,11,590},{8,11,631},{9,11,323},{10,11,355},{11,11,491},{12,11
+-,143},{12,11,402},{13,11,73},{14,11,408},{15,11,107},{146,11,71},{132,0,229},{
+-132,0,903},{140,0,71},{133,0,549},{4,0,47},{6,0,373},{7,0,452},{7,0,543},{7,0,
+-1828},{7,0,1856},{9,0,6},{11,0,257},{139,0,391},{7,11,1467},{8,11,328},{10,11,
+-544},{11,11,955},{13,11,320},{145,11,83},{5,0,980},{134,0,1754},{136,0,865},{5,0
+-,705},{137,0,606},{7,0,161},{8,10,201},{136,10,605},{143,11,35},{5,11,835},{6,11
+-,483},{140,10,224},{7,0,536},{7,0,1331},{136,0,143},{134,0,1388},{5,0,724},{10,0
+-,305},{11,0,151},{12,0,33},{12,0,121},{12,0,381},{17,0,3},{17,0,27},{17,0,78},{
+-18,0,18},{19,0,54},{149,0,5},{4,10,523},{133,10,638},{5,0,19},{134,0,533},{5,0,
+-395},{5,0,951},{134,0,1776},{135,0,1908},{132,0,846},{10,0,74},{11,0,663},{12,0,
+-210},{13,0,166},{13,0,310},{14,0,373},{18,0,95},{19,0,43},{6,10,242},{7,10,227},
+-{7,10,1581},{8,10,104},{9,10,113},{9,10,220},{9,10,427},{10,10,239},{11,10,579},
+-{11,10,1023},{13,10,4},{13,10,204},{13,10,316},{148,10,86},{9,11,716},{11,11,108
+-},{13,11,123},{14,11,252},{19,11,38},{21,11,3},{151,11,11},{8,0,372},{9,0,122},{
+-138,0,175},{132,11,677},{7,11,1374},{136,11,540},{135,10,861},{132,0,695},{7,0,
+-497},{9,0,387},{147,0,81},{136,0,937},{134,0,718},{7,0,1328},{136,10,494},{132,
+-11,331},{6,0,1581},{133,11,747},{5,0,284},{6,0,49},{6,0,350},{7,0,1},{7,0,377},{
+-7,0,1693},{8,0,18},{8,0,678},{9,0,161},{9,0,585},{9,0,671},{9,0,839},{11,0,912},
+-{141,0,427},{7,10,1306},{8,10,505},{9,10,482},{10,10,126},{11,10,225},{12,10,347
+-},{12,10,449},{13,10,19},{14,10,218},{142,10,435},{10,10,764},{12,10,120},{13,10
+-,39},{145,10,127},{4,0,597},{133,10,268},{134,0,1094},{4,0,1008},{134,0,1973},{
+-132,0,811},{139,0,908},{135,0,1471},{133,11,326},{4,10,384},{135,10,1022},{7,0,
+-1935},{8,0,324},{12,0,42},{4,11,691},{7,11,1935},{8,11,324},{9,11,35},{10,11,680
+-},{11,11,364},{12,11,42},{13,11,357},{146,11,16},{135,0,2014},{7,0,2007},{9,0,
+-101},{9,0,450},{10,0,66},{10,0,842},{11,0,536},{12,0,587},{6,11,32},{7,11,385},{
+-7,11,757},{7,11,1916},{8,11,37},{8,11,94},{8,11,711},{9,11,541},{10,11,162},{10,
+-11,795},{11,11,989},{11,11,1010},{12,11,14},{142,11,308},{139,0,586},{135,10,
+-1703},{7,0,1077},{11,0,28},{9,10,159},{140,10,603},{6,0,1221},{136,10,583},{6,11
+-,152},{6,11,349},{6,11,1682},{7,11,1252},{8,11,112},{9,11,435},{9,11,668},{10,11
+-,290},{10,11,319},{10,11,815},{11,11,180},{11,11,837},{12,11,240},{13,11,152},{
+-13,11,219},{142,11,158},{139,0,62},{132,10,515},{8,10,632},{8,10,697},{137,10,
+-854},{134,0,1766},{132,11,581},{6,11,126},{7,11,573},{8,11,397},{142,11,44},{150
+-,0,28},{11,0,670},{22,0,25},{4,10,136},{133,10,551},{6,0,1665},{7,0,256},{7,0,
+-1388},{138,0,499},{4,0,22},{5,0,10},{7,0,1576},{136,0,97},{134,10,1782},{5,0,481
+-},{7,10,1287},{9,10,44},{10,10,552},{10,10,642},{11,10,839},{12,10,274},{12,10,
+-275},{12,10,372},{13,10,91},{142,10,125},{133,11,926},{7,11,1232},{137,11,531},{
+-6,0,134},{7,0,437},{7,0,1824},{9,0,37},{14,0,285},{142,0,371},{7,0,486},{8,0,155
+-},{11,0,93},{140,0,164},{6,0,1391},{134,0,1442},{133,11,670},{133,0,591},{6,10,
+-147},{7,10,886},{7,11,1957},{9,10,753},{138,10,268},{5,0,380},{5,0,650},{7,0,
+-1173},{136,0,310},{4,0,364},{7,0,1156},{7,0,1187},{137,0,409},{135,11,1621},{134
+-,0,482},{133,11,506},{4,0,781},{6,0,487},{7,0,926},{8,0,263},{139,0,500},{138,10
+-,137},{135,11,242},{139,11,96},{133,10,414},{135,10,1762},{134,0,804},{5,11,834}
+-,{7,11,1202},{8,11,14},{9,11,481},{137,11,880},{134,10,599},{4,0,94},{135,0,1265
+-},{4,0,415},{132,0,417},{5,0,348},{6,0,522},{6,10,1749},{7,11,1526},{138,11,465}
+-,{134,10,1627},{132,0,1012},{132,10,488},{4,11,357},{6,11,172},{7,11,143},{137,
+-11,413},{4,10,83},{4,11,590},{146,11,76},{140,10,676},{7,11,287},{8,11,355},{9,
+-11,293},{137,11,743},{134,10,278},{6,0,1803},{18,0,165},{24,0,21},{5,11,169},{7,
+-11,333},{136,11,45},{12,10,97},{140,11,97},{4,0,408},{4,0,741},{135,0,500},{132,
+-11,198},{7,10,388},{7,10,644},{139,10,781},{4,11,24},{5,11,140},{5,11,185},{7,11
+-,1500},{11,11,565},{139,11,838},{6,0,1321},{9,0,257},{7,10,229},{8,10,59},{9,10,
+-190},{10,10,378},{140,10,191},{4,11,334},{133,11,593},{135,11,1885},{134,0,1138}
+-,{4,0,249},{6,0,73},{135,0,177},{133,0,576},{142,0,231},{137,0,288},{132,10,660}
+-,{7,10,1035},{138,10,737},{135,0,1487},{6,0,989},{9,0,433},{7,10,690},{9,10,587}
+-,{140,10,521},{7,0,1264},{7,0,1678},{11,0,945},{12,0,341},{12,0,471},{140,0,569}
+-,{132,11,709},{133,11,897},{5,11,224},{13,11,174},{146,11,52},{135,11,1840},{134
+-,10,1744},{12,0,87},{16,0,74},{4,10,733},{9,10,194},{10,10,92},{11,10,198},{12,
+-10,84},{141,10,128},{140,0,779},{135,0,538},{4,11,608},{133,11,497},{133,0,413},
+-{7,11,1375},{7,11,1466},{138,11,331},{136,0,495},{6,11,540},{136,11,136},{7,0,54
+-},{8,0,312},{10,0,191},{10,0,614},{140,0,567},{6,0,468},{7,0,567},{7,0,1478},{8,
+-0,530},{14,0,290},{133,11,999},{4,11,299},{7,10,306},{135,11,1004},{142,11,296},
+-{134,0,1484},{133,10,979},{6,0,609},{9,0,815},{12,11,137},{14,11,9},{14,11,24},{
+-142,11,64},{133,11,456},{6,0,484},{135,0,822},{133,10,178},{136,11,180},{132,11,
+-755},{137,0,900},{135,0,1335},{6,0,1724},{135,0,2022},{135,11,1139},{5,0,640},{
+-132,10,390},{6,0,1831},{138,11,633},{135,11,566},{4,11,890},{5,11,805},{5,11,819
+-},{5,11,961},{6,11,396},{6,11,1631},{6,11,1678},{7,11,1967},{7,11,2041},{9,11,
+-630},{11,11,8},{11,11,1019},{12,11,176},{13,11,225},{14,11,292},{149,11,24},{132
+-,0,474},{134,0,1103},{135,0,1504},{134,0,1576},{6,0,961},{6,0,1034},{140,0,655},
+-{11,11,514},{149,11,20},{5,0,305},{135,11,1815},{7,11,1505},{10,11,190},{10,11,
+-634},{11,11,792},{12,11,358},{140,11,447},{5,11,0},{6,11,536},{7,11,604},{13,11,
+-445},{145,11,126},{7,0,1236},{133,10,105},{4,0,480},{6,0,217},{6,0,302},{6,0,
+-1642},{7,0,130},{7,0,837},{7,0,1321},{7,0,1547},{7,0,1657},{8,0,429},{9,0,228},{
+-13,0,289},{13,0,343},{19,0,101},{6,11,232},{6,11,412},{7,11,1074},{8,11,9},{8,11
+-,157},{8,11,786},{9,11,196},{9,11,352},{9,11,457},{10,11,337},{11,11,232},{11,11
+-,877},{12,11,480},{140,11,546},{5,10,438},{7,11,958},{9,10,694},{12,10,627},{13,
+-11,38},{141,10,210},{4,11,382},{136,11,579},{7,0,278},{10,0,739},{11,0,708},{141
+-,0,348},{4,11,212},{135,11,1206},{135,11,1898},{6,0,708},{6,0,1344},{152,10,11},
+-{137,11,768},{134,0,1840},{140,0,233},{8,10,25},{138,10,826},{6,0,2017},{133,11,
+-655},{6,0,1488},{139,11,290},{132,10,308},{134,0,1590},{134,0,1800},{134,0,1259}
+-,{16,0,28},{6,11,231},{7,11,95},{136,11,423},{133,11,300},{135,10,150},{136,10,
+-649},{7,11,1874},{137,11,641},{6,11,237},{7,11,611},{8,11,100},{9,11,416},{11,11
+-,335},{12,11,173},{146,11,101},{137,0,45},{134,10,521},{17,0,36},{14,11,26},{146
+-,11,150},{7,0,1442},{14,0,22},{5,10,339},{15,10,41},{15,10,166},{147,10,66},{8,0
+-,378},{6,11,581},{135,11,1119},{134,0,1507},{147,11,117},{139,0,39},{134,0,1054}
+-,{6,0,363},{7,0,1955},{136,0,725},{134,0,2036},{133,11,199},{6,0,1871},{9,0,935}
+-,{9,0,961},{9,0,1004},{9,0,1016},{12,0,805},{12,0,852},{12,0,853},{12,0,869},{12
+-,0,882},{12,0,896},{12,0,906},{12,0,917},{12,0,940},{15,0,170},{15,0,176},{15,0,
+-188},{15,0,201},{15,0,205},{15,0,212},{15,0,234},{15,0,244},{18,0,181},{18,0,193
+-},{18,0,196},{18,0,201},{18,0,202},{18,0,210},{18,0,217},{18,0,235},{18,0,236},{
+-18,0,237},{21,0,54},{21,0,55},{21,0,58},{21,0,59},{152,0,22},{134,10,1628},{137,
+-0,805},{5,0,813},{135,0,2046},{142,11,42},{5,0,712},{6,0,1240},{11,0,17},{13,0,
+-321},{144,0,67},{132,0,617},{135,10,829},{6,0,320},{7,0,781},{7,0,1921},{9,0,55}
+-,{10,0,186},{10,0,273},{10,0,664},{10,0,801},{11,0,996},{11,0,997},{13,0,157},{
+-142,0,170},{136,0,271},{5,10,486},{135,10,1349},{18,11,91},{147,11,70},{10,0,445
+-},{7,10,1635},{8,10,17},{138,10,295},{136,11,404},{7,0,103},{7,0,863},{11,0,184}
+-,{145,0,62},{138,10,558},{137,0,659},{6,11,312},{6,11,1715},{10,11,584},{11,11,
+-546},{11,11,692},{12,11,259},{12,11,295},{13,11,46},{141,11,154},{134,0,676},{
+-132,11,588},{4,11,231},{5,11,61},{6,11,104},{7,11,729},{7,11,964},{7,11,1658},{
+-140,11,414},{6,11,263},{138,11,757},{11,0,337},{142,0,303},{135,11,1363},{132,11
+-,320},{140,0,506},{134,10,447},{5,0,77},{7,0,1455},{10,0,843},{147,0,73},{7,10,
+-577},{7,10,1432},{9,10,475},{9,10,505},{9,10,526},{9,10,609},{9,10,689},{9,10,
+-726},{9,10,735},{9,10,738},{10,10,556},{10,10,674},{10,10,684},{11,10,89},{11,10
+-,202},{11,10,272},{11,10,380},{11,10,415},{11,10,505},{11,10,537},{11,10,550},{
+-11,10,562},{11,10,640},{11,10,667},{11,10,688},{11,10,847},{11,10,927},{11,10,
+-930},{11,10,940},{12,10,144},{12,10,325},{12,10,329},{12,10,389},{12,10,403},{12
+-,10,451},{12,10,515},{12,10,604},{12,10,616},{12,10,626},{13,10,66},{13,10,131},
+-{13,10,167},{13,10,236},{13,10,368},{13,10,411},{13,10,434},{13,10,453},{13,10,
+-461},{13,10,474},{14,10,59},{14,10,60},{14,10,139},{14,10,152},{14,10,276},{14,
+-10,353},{14,10,402},{15,10,28},{15,10,81},{15,10,123},{15,10,152},{18,10,136},{
+-148,10,88},{132,0,458},{135,0,1420},{6,0,109},{10,0,382},{4,11,405},{4,10,609},{
+-7,10,756},{7,11,817},{9,10,544},{11,10,413},{14,11,58},{14,10,307},{16,10,25},{
+-17,11,37},{146,11,124},{6,0,330},{7,0,1084},{11,0,142},{133,11,974},{4,10,930},{
+-133,10,947},{5,10,939},{142,11,394},{16,0,91},{145,0,87},{5,11,235},{5,10,962},{
+-7,11,1239},{11,11,131},{140,11,370},{11,0,492},{5,10,651},{8,10,170},{9,10,61},{
+-9,10,63},{10,10,23},{10,10,37},{10,10,834},{11,10,4},{11,10,281},{11,10,503},{11
+-,10,677},{12,10,96},{12,10,130},{12,10,244},{14,10,5},{14,10,40},{14,10,162},{14
+-,10,202},{146,10,133},{4,10,406},{5,10,579},{12,10,492},{150,10,15},{9,11,137},{
+-138,11,221},{134,0,1239},{11,0,211},{140,0,145},{7,11,390},{138,11,140},{135,11,
+-1418},{135,11,1144},{134,0,1049},{7,0,321},{6,10,17},{7,10,1001},{7,10,1982},{9,
+-10,886},{10,10,489},{10,10,800},{11,10,782},{12,10,320},{13,10,467},{14,10,145},
+-{14,10,387},{143,10,119},{145,10,17},{5,11,407},{11,11,489},{19,11,37},{20,11,73
+-},{150,11,38},{133,10,458},{135,0,1985},{7,10,1983},{8,10,0},{8,10,171},{9,10,
+-120},{9,10,732},{10,10,473},{11,10,656},{11,10,998},{18,10,0},{18,10,2},{147,10,
+-21},{5,11,325},{7,11,1483},{8,11,5},{8,11,227},{9,11,105},{10,11,585},{140,11,
+-614},{136,0,122},{132,0,234},{135,11,1196},{6,0,976},{6,0,1098},{134,0,1441},{7,
+-0,253},{136,0,549},{6,11,621},{13,11,504},{144,11,19},{132,10,519},{5,0,430},{5,
+-0,932},{6,0,131},{7,0,417},{9,0,522},{11,0,314},{141,0,390},{14,0,149},{14,0,399
+-},{143,0,57},{5,10,907},{6,10,31},{6,11,218},{7,10,491},{7,10,530},{8,10,592},{
+-11,10,53},{11,10,779},{12,10,167},{12,10,411},{14,10,14},{14,10,136},{15,10,72},
+-{16,10,17},{144,10,72},{140,11,330},{7,11,454},{7,11,782},{136,11,768},{132,0,
+-507},{10,11,676},{140,11,462},{6,0,630},{9,0,811},{4,10,208},{5,10,106},{6,10,
+-531},{8,10,408},{9,10,188},{138,10,572},{4,0,343},{5,0,511},{134,10,1693},{134,
+-11,164},{132,0,448},{7,0,455},{138,0,591},{135,0,1381},{12,10,441},{150,11,50},{
+-9,10,449},{10,10,192},{138,10,740},{6,0,575},{132,10,241},{134,0,1175},{134,0,
+-653},{134,0,1761},{134,0,1198},{132,10,259},{6,11,343},{7,11,195},{9,11,226},{10
+-,11,197},{10,11,575},{11,11,502},{139,11,899},{7,0,1127},{7,0,1572},{10,0,297},{
+-10,0,422},{11,0,764},{11,0,810},{12,0,264},{13,0,102},{13,0,300},{13,0,484},{14,
+-0,147},{14,0,229},{17,0,71},{18,0,118},{147,0,120},{135,11,666},{132,0,678},{4,
+-10,173},{5,10,312},{5,10,512},{135,10,1285},{7,10,1603},{7,10,1691},{9,10,464},{
+-11,10,195},{12,10,279},{12,10,448},{14,10,11},{147,10,102},{16,0,99},{146,0,164}
+-,{7,11,1125},{9,11,143},{11,11,61},{14,11,405},{150,11,21},{137,11,260},{4,10,
+-452},{5,10,583},{5,10,817},{6,10,433},{7,10,593},{7,10,720},{7,10,1378},{8,10,
+-161},{9,10,284},{10,10,313},{139,10,886},{132,10,547},{136,10,722},{14,0,35},{
+-142,0,191},{141,0,45},{138,0,121},{132,0,125},{134,0,1622},{133,11,959},{8,10,
+-420},{139,10,193},{132,0,721},{135,10,409},{136,0,145},{7,0,792},{8,0,147},{10,0
+-,821},{11,0,970},{11,0,1021},{136,11,173},{134,11,266},{132,0,715},{7,0,1999},{
+-138,10,308},{133,0,531},{5,0,168},{5,0,930},{8,0,74},{9,0,623},{12,0,500},{140,0
+-,579},{144,0,65},{138,11,246},{6,0,220},{7,0,1101},{13,0,105},{142,11,314},{5,10
+-,1002},{136,10,745},{134,0,960},{20,0,0},{148,11,0},{4,0,1005},{4,10,239},{6,10,
+-477},{7,10,1607},{11,10,68},{139,10,617},{6,0,19},{7,0,1413},{139,0,428},{149,10
+-,13},{7,0,96},{8,0,401},{8,0,703},{9,0,896},{136,11,300},{134,0,1595},{145,0,116
+-},{136,0,1021},{7,0,1961},{7,0,1965},{7,0,2030},{8,0,150},{8,0,702},{8,0,737},{8
+-,0,750},{140,0,366},{11,11,75},{142,11,267},{132,10,367},{8,0,800},{9,0,148},{9,
+-0,872},{9,0,890},{11,0,309},{11,0,1001},{13,0,267},{13,0,323},{5,11,427},{5,11,
+-734},{7,11,478},{136,11,52},{7,11,239},{11,11,217},{142,11,165},{132,11,323},{
+-140,11,419},{13,0,299},{142,0,75},{6,11,87},{6,11,1734},{7,11,20},{7,11,1056},{8
+-,11,732},{9,11,406},{9,11,911},{138,11,694},{134,0,1383},{132,10,694},{133,11,
+-613},{137,0,779},{4,0,598},{140,10,687},{6,0,970},{135,0,424},{133,0,547},{7,11,
+-32},{7,11,984},{8,11,85},{8,11,709},{9,11,579},{9,11,847},{9,11,856},{10,11,799}
+-,{11,11,258},{11,11,1007},{12,11,331},{12,11,615},{13,11,188},{13,11,435},{14,11
+-,8},{15,11,165},{16,11,27},{148,11,40},{6,0,1222},{134,0,1385},{132,0,876},{138,
+-11,151},{135,10,213},{4,11,167},{135,11,82},{133,0,133},{6,11,24},{7,11,74},{7,
+-11,678},{137,11,258},{5,11,62},{6,11,534},{7,11,684},{7,11,1043},{7,11,1072},{8,
+-11,280},{8,11,541},{8,11,686},{10,11,519},{11,11,252},{140,11,282},{136,0,187},{
+-8,0,8},{10,0,0},{10,0,818},{139,0,988},{132,11,359},{11,0,429},{15,0,51},{135,10
+-,1672},{136,0,685},{5,11,211},{7,11,88},{136,11,627},{134,0,472},{136,0,132},{6,
+-11,145},{141,11,336},{4,10,751},{11,10,390},{140,10,32},{6,0,938},{6,0,1060},{4,
+-11,263},{4,10,409},{133,10,78},{137,0,874},{8,0,774},{10,0,670},{12,0,51},{4,11,
+-916},{6,10,473},{7,10,1602},{10,10,698},{12,10,212},{13,10,307},{145,10,105},{
+-146,0,92},{143,10,156},{132,0,830},{137,0,701},{4,11,599},{6,11,1634},{7,11,5},{
+-7,11,55},{7,11,67},{7,11,97},{7,11,691},{7,11,979},{7,11,1697},{8,11,207},{8,11,
+-214},{8,11,231},{8,11,294},{8,11,336},{8,11,428},{8,11,451},{8,11,460},{8,11,471
+-},{8,11,622},{8,11,626},{8,11,679},{8,11,759},{8,11,829},{9,11,11},{9,11,246},{9
+-,11,484},{9,11,573},{9,11,706},{9,11,762},{9,11,798},{9,11,855},{9,11,870},{9,11
+-,912},{10,11,303},{10,11,335},{10,11,424},{10,11,461},{10,11,543},{10,11,759},{
+-10,11,814},{11,11,59},{11,11,199},{11,11,235},{11,11,475},{11,11,590},{11,11,929
+-},{11,11,963},{12,11,114},{12,11,182},{12,11,226},{12,11,332},{12,11,439},{12,11
+-,575},{12,11,598},{13,11,8},{13,11,125},{13,11,194},{13,11,287},{14,11,197},{14,
+-11,383},{15,11,53},{17,11,63},{19,11,46},{19,11,98},{19,11,106},{148,11,85},{4,0
+-,127},{5,0,350},{6,0,356},{8,0,426},{9,0,572},{10,0,247},{139,0,312},{134,0,1215
+-},{6,0,59},{9,0,603},{13,0,397},{7,11,1853},{138,11,437},{134,0,1762},{147,11,
+-126},{135,10,883},{13,0,293},{142,0,56},{133,10,617},{139,10,50},{5,11,187},{7,
+-10,1518},{139,10,694},{135,0,441},{6,0,111},{7,0,4},{8,0,163},{8,0,776},{138,0,
+-566},{132,0,806},{4,11,215},{9,11,38},{10,11,3},{11,11,23},{11,11,127},{139,11,
+-796},{14,0,233},{4,10,546},{135,10,2042},{135,0,1994},{134,0,1739},{135,11,1530}
+-,{136,0,393},{5,0,297},{7,0,1038},{14,0,359},{19,0,52},{148,0,47},{135,0,309},{4
+-,10,313},{133,10,577},{8,10,184},{141,10,433},{135,10,935},{12,10,186},{12,10,
+-292},{14,10,100},{146,10,70},{136,0,363},{14,0,175},{11,10,402},{12,10,109},{12,
+-10,431},{13,10,179},{13,10,206},{14,10,217},{16,10,3},{148,10,53},{5,10,886},{6,
+-10,46},{6,10,1790},{7,10,14},{7,10,732},{7,10,1654},{8,10,95},{8,10,327},{8,10,
+-616},{9,10,892},{10,10,598},{10,10,769},{11,10,134},{11,10,747},{12,10,378},{142
+-,10,97},{136,0,666},{135,0,1675},{6,0,655},{134,0,1600},{135,0,808},{133,10,1021
+-},{4,11,28},{5,11,440},{7,11,248},{11,11,833},{140,11,344},{134,11,1654},{132,0,
+-280},{140,0,54},{4,0,421},{133,0,548},{132,10,153},{6,11,339},{135,11,923},{133,
+-11,853},{133,10,798},{132,10,587},{6,11,249},{7,11,1234},{139,11,573},{6,10,598}
+-,{7,10,42},{8,10,695},{10,10,212},{11,10,158},{14,10,196},{145,10,85},{7,0,249},
+-{5,10,957},{133,10,1008},{4,10,129},{135,10,465},{6,0,254},{7,0,842},{7,0,1659},
+-{9,0,109},{10,0,103},{7,10,908},{7,10,1201},{9,10,755},{11,10,906},{12,10,527},{
+-146,10,7},{5,0,262},{136,10,450},{144,0,1},{10,11,201},{142,11,319},{7,11,49},{7
+-,11,392},{8,11,20},{8,11,172},{8,11,690},{9,11,383},{9,11,845},{10,11,48},{11,11
+-,293},{11,11,832},{11,11,920},{141,11,221},{5,11,858},{133,11,992},{134,0,805},{
+-139,10,1003},{6,0,1630},{134,11,307},{7,11,1512},{135,11,1794},{6,11,268},{137,
+-11,62},{135,10,1868},{133,0,671},{4,0,989},{8,0,972},{136,0,998},{132,11,423},{
+-132,0,889},{135,0,1382},{135,0,1910},{7,10,965},{7,10,1460},{135,10,1604},{4,0,
+-627},{5,0,775},{138,11,106},{134,11,348},{7,0,202},{11,0,362},{11,0,948},{140,0,
+-388},{138,11,771},{6,11,613},{136,11,223},{6,0,560},{7,0,451},{8,0,389},{12,0,
+-490},{13,0,16},{13,0,215},{13,0,351},{18,0,132},{147,0,125},{135,0,841},{136,0,
+-566},{136,0,938},{132,11,670},{5,0,912},{6,0,1695},{140,11,55},{9,11,40},{139,11
+-,136},{7,0,1361},{7,10,982},{10,10,32},{143,10,56},{11,11,259},{140,11,270},{5,0
+-,236},{6,0,572},{8,0,492},{11,0,618},{144,0,56},{8,11,572},{9,11,310},{9,11,682}
+-,{137,11,698},{134,0,1854},{5,0,190},{136,0,318},{133,10,435},{135,0,1376},{4,11
+-,296},{6,11,352},{7,11,401},{7,11,1410},{7,11,1594},{7,11,1674},{8,11,63},{8,11,
+-660},{137,11,74},{7,0,349},{5,10,85},{6,10,419},{7,10,305},{7,10,361},{7,10,1337
+-},{8,10,71},{140,10,519},{4,11,139},{4,11,388},{140,11,188},{6,0,1972},{6,0,2013
+-},{8,0,951},{10,0,947},{10,0,974},{10,0,1018},{142,0,476},{140,10,688},{135,10,
+-740},{5,10,691},{7,10,345},{9,10,94},{140,10,169},{9,0,344},{5,10,183},{6,10,582
+-},{10,10,679},{140,10,435},{135,10,511},{132,0,850},{8,11,441},{10,11,314},{143,
+-11,3},{7,10,1993},{136,10,684},{4,11,747},{6,11,290},{6,10,583},{7,11,649},{7,11
+-,1479},{135,11,1583},{133,11,232},{133,10,704},{134,0,910},{4,10,179},{5,10,198}
+-,{133,10,697},{7,10,347},{7,10,971},{8,10,181},{138,10,711},{136,11,525},{14,0,
+-19},{14,0,28},{144,0,29},{7,0,85},{7,0,247},{8,0,585},{138,0,163},{4,0,487},{7,
+-11,472},{7,11,1801},{10,11,748},{141,11,458},{4,10,243},{5,10,203},{7,10,19},{7,
+-10,71},{7,10,113},{10,10,405},{11,10,357},{142,10,240},{7,10,1450},{139,10,99},{
+-132,11,425},{138,0,145},{147,0,83},{6,10,492},{137,11,247},{4,0,1013},{134,0,
+-2033},{5,10,134},{6,10,408},{6,10,495},{135,10,1593},{135,0,1922},{134,11,1768},
+-{4,0,124},{10,0,457},{11,0,121},{11,0,169},{11,0,870},{11,0,874},{12,0,214},{14,
+-0,187},{143,0,77},{5,0,557},{135,0,1457},{139,0,66},{5,11,943},{6,11,1779},{142,
+-10,4},{4,10,248},{4,10,665},{7,10,137},{137,10,349},{7,0,1193},{5,11,245},{6,11,
+-576},{7,11,582},{136,11,225},{144,0,82},{7,10,1270},{139,10,612},{5,0,454},{10,0
+-,352},{138,11,352},{18,0,57},{5,10,371},{135,10,563},{135,0,1333},{6,0,107},{7,0
+-,638},{7,0,1632},{9,0,396},{134,11,610},{5,0,370},{134,0,1756},{4,10,374},{7,10,
+-547},{7,10,1700},{7,10,1833},{139,10,858},{133,0,204},{6,0,1305},{9,10,311},{141
+-,10,42},{5,0,970},{134,0,1706},{6,10,1647},{7,10,1552},{7,10,2010},{9,10,494},{
+-137,10,509},{13,11,455},{15,11,99},{15,11,129},{144,11,68},{135,0,3},{4,0,35},{5
+-,0,121},{5,0,483},{5,0,685},{6,0,489},{6,0,782},{6,0,1032},{7,0,1204},{136,0,394
+-},{4,0,921},{133,0,1007},{8,11,360},{138,11,63},{135,0,1696},{134,0,1519},{132,
+-11,443},{135,11,944},{6,10,123},{7,10,214},{9,10,728},{10,10,157},{11,10,346},{
+-11,10,662},{143,10,106},{137,0,981},{135,10,1435},{134,0,1072},{132,0,712},{134,
+-0,1629},{134,0,728},{4,11,298},{137,11,483},{6,0,1177},{6,0,1271},{5,11,164},{7,
+-11,121},{142,11,189},{7,0,1608},{4,10,707},{5,10,588},{6,10,393},{13,10,106},{18
+-,10,49},{147,10,41},{23,0,16},{151,11,16},{6,10,211},{7,10,1690},{11,10,486},{
+-140,10,369},{133,0,485},{19,11,15},{149,11,27},{4,11,172},{9,11,611},{10,11,436}
+-,{12,11,673},{141,11,255},{5,11,844},{10,11,484},{11,11,754},{12,11,457},{14,11,
+-171},{14,11,389},{146,11,153},{4,0,285},{5,0,27},{5,0,317},{6,0,301},{7,0,7},{8,
+-0,153},{10,0,766},{11,0,468},{12,0,467},{141,0,143},{134,0,1462},{9,11,263},{10,
+-11,147},{138,11,492},{133,11,537},{6,0,1945},{6,0,1986},{6,0,1991},{134,0,2038},
+-{134,10,219},{137,11,842},{14,0,52},{17,0,50},{5,10,582},{6,10,1646},{7,10,99},{
+-7,10,1962},{7,10,1986},{8,10,515},{8,10,773},{9,10,23},{9,10,491},{12,10,620},{
+-142,10,93},{138,11,97},{20,0,21},{20,0,44},{133,10,851},{136,0,819},{139,0,917},
+-{5,11,230},{5,11,392},{6,11,420},{8,10,762},{8,10,812},{9,11,568},{9,10,910},{
+-140,11,612},{135,0,784},{15,0,135},{143,11,135},{10,0,454},{140,0,324},{4,11,0},
+-{5,11,41},{7,11,1459},{7,11,1469},{7,11,1618},{7,11,1859},{9,11,549},{139,11,905
+-},{4,10,98},{7,10,1365},{9,10,422},{9,10,670},{10,10,775},{11,10,210},{13,10,26}
+-,{13,10,457},{141,10,476},{6,0,1719},{6,0,1735},{7,0,2016},{7,0,2020},{8,0,837},
+-{137,0,852},{133,11,696},{135,0,852},{132,0,952},{134,10,1730},{132,11,771},{138
+-,0,568},{137,0,448},{139,0,146},{8,0,67},{138,0,419},{133,11,921},{137,10,147},{
+-134,0,1826},{10,0,657},{14,0,297},{142,0,361},{6,0,666},{6,0,767},{134,0,1542},{
+-139,0,729},{6,11,180},{7,11,1137},{8,11,751},{139,11,805},{4,11,183},{7,11,271},
+-{11,11,824},{11,11,952},{13,11,278},{13,11,339},{13,11,482},{14,11,424},{148,11,
+-99},{4,0,669},{5,11,477},{5,11,596},{6,11,505},{7,11,1221},{11,11,907},{12,11,
+-209},{141,11,214},{135,11,1215},{5,0,402},{6,10,30},{11,10,56},{139,10,305},{7,
+-11,564},{142,11,168},{139,0,152},{7,0,912},{135,10,1614},{4,10,150},{5,10,303},{
+-134,10,327},{7,0,320},{8,0,51},{9,0,868},{10,0,833},{12,0,481},{12,0,570},{148,0
+-,106},{132,0,445},{7,11,274},{11,11,263},{11,11,479},{11,11,507},{140,11,277},{
+-10,0,555},{11,0,308},{19,0,95},{6,11,1645},{8,10,192},{10,10,78},{141,10,359},{
+-135,10,786},{6,11,92},{6,11,188},{7,11,1269},{7,11,1524},{7,11,1876},{10,11,228}
+-,{139,11,1020},{4,11,459},{133,11,966},{11,0,386},{6,10,1638},{7,10,79},{7,10,
+-496},{9,10,138},{10,10,336},{12,10,412},{12,10,440},{142,10,305},{133,0,239},{7,
+-0,83},{7,0,1990},{8,0,130},{139,0,720},{138,11,709},{4,0,143},{5,0,550},{133,0,
+-752},{5,0,123},{6,0,530},{7,0,348},{135,0,1419},{135,0,2024},{6,11,18},{7,11,179
+-},{7,11,721},{7,11,932},{8,11,548},{8,11,757},{9,11,54},{9,11,65},{9,11,532},{9,
+-11,844},{10,11,113},{10,11,117},{10,11,236},{10,11,315},{10,11,430},{10,11,798},
+-{11,11,153},{11,11,351},{11,11,375},{12,11,78},{12,11,151},{12,11,392},{14,11,
+-248},{143,11,23},{7,10,204},{7,10,415},{8,10,42},{10,10,85},{139,10,564},{134,0,
+-958},{133,11,965},{132,0,210},{135,11,1429},{138,11,480},{134,11,182},{139,11,
+-345},{10,11,65},{10,11,488},{138,11,497},{4,10,3},{5,10,247},{5,10,644},{7,10,
+-744},{7,10,1207},{7,10,1225},{7,10,1909},{146,10,147},{132,0,430},{5,10,285},{9,
+-10,67},{13,10,473},{143,10,82},{144,11,16},{7,11,1162},{9,11,588},{10,11,260},{
+-151,10,8},{133,0,213},{138,0,7},{135,0,801},{134,11,1786},{135,11,308},{6,0,936}
+-,{134,0,1289},{133,0,108},{132,0,885},{133,0,219},{139,0,587},{4,0,193},{5,0,916
+-},{6,0,1041},{7,0,364},{10,0,398},{10,0,726},{11,0,317},{11,0,626},{12,0,142},{
+-12,0,288},{12,0,678},{13,0,313},{15,0,113},{146,0,114},{135,0,1165},{6,0,241},{9
+-,0,342},{10,0,729},{11,0,284},{11,0,445},{11,0,651},{11,0,863},{13,0,398},{146,0
+-,99},{7,0,907},{136,0,832},{9,0,303},{4,10,29},{6,10,532},{7,10,1628},{7,10,1648
+-},{9,10,350},{10,10,433},{11,10,97},{11,10,557},{11,10,745},{12,10,289},{12,10,
+-335},{12,10,348},{12,10,606},{13,10,116},{13,10,233},{13,10,466},{14,10,181},{14
+-,10,209},{14,10,232},{14,10,236},{14,10,300},{16,10,41},{148,10,97},{7,11,423},{
+-7,10,1692},{136,11,588},{6,0,931},{134,0,1454},{5,10,501},{7,10,1704},{9,10,553}
+-,{11,10,520},{12,10,557},{141,10,249},{136,11,287},{4,0,562},{9,0,254},{139,0,
+-879},{132,0,786},{14,11,32},{18,11,85},{20,11,2},{152,11,16},{135,0,1294},{7,11,
+-723},{135,11,1135},{6,0,216},{7,0,901},{7,0,1343},{8,0,493},{134,11,403},{7,11,
+-719},{8,11,809},{136,11,834},{5,11,210},{6,11,213},{7,11,60},{10,11,364},{139,11
+-,135},{7,0,341},{11,0,219},{5,11,607},{8,11,326},{136,11,490},{4,11,701},{5,11,
+-472},{5,11,639},{7,11,1249},{9,11,758},{139,11,896},{135,11,380},{135,11,1947},{
+-139,0,130},{135,0,1734},{10,0,115},{11,0,420},{12,0,154},{13,0,404},{14,0,346},{
+-143,0,54},{134,10,129},{4,11,386},{7,11,41},{8,11,405},{9,11,497},{11,11,110},{
+-11,11,360},{15,11,37},{144,11,84},{141,11,282},{5,11,46},{7,11,1452},{7,11,1480}
+-,{8,11,634},{140,11,472},{4,11,524},{136,11,810},{10,11,238},{141,11,33},{133,0,
+-604},{5,0,1011},{136,0,701},{8,0,856},{8,0,858},{8,0,879},{12,0,702},{142,0,447}
+-,{4,0,54},{5,0,666},{7,0,1039},{7,0,1130},{9,0,195},{138,0,302},{4,10,25},{5,10,
+-60},{6,10,504},{7,10,614},{7,10,1155},{140,10,0},{7,10,1248},{11,10,621},{139,10
+-,702},{133,11,997},{137,10,321},{134,0,1669},{134,0,1791},{4,10,379},{135,10,
+-1397},{138,11,372},{5,11,782},{5,11,829},{134,11,1738},{135,0,1228},{4,10,118},{
+-6,10,274},{6,10,361},{7,10,75},{141,10,441},{132,0,623},{9,11,279},{10,11,407},{
+-14,11,84},{150,11,18},{137,10,841},{135,0,798},{140,10,693},{5,10,314},{6,10,221
+-},{7,10,419},{10,10,650},{11,10,396},{12,10,156},{13,10,369},{14,10,333},{145,10
+-,47},{135,11,1372},{7,0,122},{9,0,259},{10,0,84},{11,0,470},{12,0,541},{141,0,
+-379},{134,0,837},{8,0,1013},{4,11,78},{5,11,96},{5,11,182},{7,11,1724},{7,11,
+-1825},{10,11,394},{10,11,471},{11,11,532},{14,11,340},{145,11,88},{134,0,577},{
+-135,11,1964},{132,10,913},{134,0,460},{8,0,891},{10,0,901},{10,0,919},{10,0,932}
+-,{12,0,715},{12,0,728},{12,0,777},{14,0,457},{144,0,103},{5,0,82},{5,0,131},{7,0
+-,1755},{8,0,31},{9,0,168},{9,0,764},{139,0,869},{136,10,475},{6,0,605},{5,10,
+-1016},{9,11,601},{9,11,619},{10,11,505},{10,11,732},{11,11,355},{140,11,139},{7,
+-10,602},{8,10,179},{10,10,781},{140,10,126},{134,0,1246},{6,10,329},{138,10,111}
+-,{6,11,215},{7,11,1028},{7,11,1473},{7,11,1721},{9,11,424},{138,11,779},{5,0,278
+-},{137,0,68},{6,0,932},{6,0,1084},{144,0,86},{4,0,163},{5,0,201},{5,0,307},{5,0,
+-310},{6,0,335},{7,0,284},{7,0,1660},{136,0,165},{136,0,781},{134,0,707},{6,0,33}
+-,{135,0,1244},{5,10,821},{6,11,67},{6,10,1687},{7,11,258},{7,11,1630},{9,11,354}
+-,{9,11,675},{10,11,830},{14,11,80},{145,11,80},{6,11,141},{7,11,225},{9,11,59},{
+-9,11,607},{10,11,312},{11,11,687},{12,11,555},{13,11,373},{13,11,494},{148,11,58
+-},{134,0,1113},{9,0,388},{5,10,71},{7,10,1407},{9,10,704},{10,10,261},{10,10,619
+-},{11,10,547},{11,10,619},{143,10,157},{7,0,1953},{136,0,720},{138,0,203},{7,10,
+-2008},{9,10,337},{138,10,517},{6,0,326},{7,0,677},{137,0,425},{139,11,81},{7,0,
+-1316},{7,0,1412},{7,0,1839},{9,0,589},{11,0,241},{11,0,676},{11,0,811},{11,0,891
+-},{12,0,140},{12,0,346},{12,0,479},{13,0,140},{13,0,381},{14,0,188},{18,0,30},{
+-148,0,108},{5,0,416},{6,10,86},{6,10,603},{7,10,292},{7,10,561},{8,10,257},{8,10
+-,382},{9,10,721},{9,10,778},{11,10,581},{140,10,466},{4,10,486},{133,10,491},{
+-134,0,1300},{132,10,72},{7,0,847},{6,10,265},{7,11,430},{139,11,46},{5,11,602},{
+-6,11,106},{7,11,1786},{7,11,1821},{7,11,2018},{9,11,418},{137,11,763},{5,0,358},
+-{7,0,535},{7,0,1184},{10,0,662},{13,0,212},{13,0,304},{13,0,333},{145,0,98},{5,
+-11,65},{6,11,416},{7,11,1720},{7,11,1924},{8,11,677},{10,11,109},{11,11,14},{11,
+-11,70},{11,11,569},{11,11,735},{15,11,153},{148,11,80},{6,0,1823},{8,0,839},{8,0
+-,852},{8,0,903},{10,0,940},{12,0,707},{140,0,775},{135,11,1229},{6,0,1522},{140,
+-0,654},{136,11,595},{139,0,163},{141,0,314},{132,0,978},{4,0,601},{6,0,2035},{
+-137,10,234},{5,10,815},{6,10,1688},{134,10,1755},{133,0,946},{136,0,434},{6,10,
+-197},{136,10,205},{7,0,411},{7,0,590},{8,0,631},{9,0,323},{10,0,355},{11,0,491},
+-{12,0,143},{12,0,402},{13,0,73},{14,0,408},{15,0,107},{146,0,71},{7,0,1467},{8,0
+-,328},{10,0,544},{11,0,955},{12,0,13},{13,0,320},{145,0,83},{142,0,410},{11,0,
+-511},{13,0,394},{14,0,298},{14,0,318},{146,0,103},{6,10,452},{7,10,312},{138,10,
+-219},{138,10,589},{4,10,333},{9,10,176},{12,10,353},{141,10,187},{135,11,329},{
+-132,11,469},{5,0,835},{134,0,483},{134,11,1743},{5,11,929},{6,11,340},{8,11,376}
+-,{136,11,807},{134,10,1685},{132,0,677},{5,11,218},{7,11,1610},{138,11,83},{5,11
+-,571},{135,11,1842},{132,11,455},{137,0,70},{135,0,1405},{7,10,135},{8,10,7},{8,
+-10,62},{9,10,243},{10,10,658},{10,10,697},{11,10,456},{139,10,756},{9,10,395},{
+-138,10,79},{137,0,108},{6,11,161},{7,11,372},{137,11,597},{132,11,349},{132,0,
+-777},{132,0,331},{135,10,631},{133,0,747},{6,11,432},{6,11,608},{139,11,322},{
+-138,10,835},{5,11,468},{7,11,1809},{10,11,325},{11,11,856},{12,11,345},{143,11,
+-104},{133,11,223},{7,10,406},{7,10,459},{8,10,606},{139,10,726},{132,11,566},{
+-142,0,68},{4,11,59},{135,11,1394},{6,11,436},{139,11,481},{4,11,48},{5,11,271},{
+-135,11,953},{139,11,170},{5,11,610},{136,11,457},{133,11,755},{135,11,1217},{133
+-,10,612},{132,11,197},{132,0,505},{4,10,372},{7,10,482},{8,10,158},{9,10,602},{9
+-,10,615},{10,10,245},{10,10,678},{10,10,744},{11,10,248},{139,10,806},{133,0,326
+-},{5,10,854},{135,10,1991},{4,0,691},{146,0,16},{6,0,628},{9,0,35},{10,0,680},{
+-10,0,793},{11,0,364},{13,0,357},{143,0,164},{138,0,654},{6,0,32},{7,0,385},{7,0,
+-757},{7,0,1916},{8,0,37},{8,0,94},{8,0,711},{9,0,541},{10,0,162},{10,0,795},{11,
+-0,989},{11,0,1010},{12,0,14},{142,0,308},{133,11,217},{6,0,152},{6,0,349},{6,0,
+-1682},{7,0,1252},{8,0,112},{9,0,435},{9,0,668},{10,0,290},{10,0,319},{10,0,815},
+-{11,0,180},{11,0,837},{12,0,240},{13,0,152},{13,0,219},{142,0,158},{4,0,581},{
+-134,0,726},{5,10,195},{135,10,1685},{6,0,126},{7,0,573},{8,0,397},{142,0,44},{
+-138,0,89},{7,10,1997},{8,10,730},{139,10,1006},{134,0,1531},{134,0,1167},{5,0,
+-926},{12,0,203},{133,10,751},{4,11,165},{7,11,1398},{135,11,1829},{7,0,1232},{
+-137,0,531},{135,10,821},{134,0,943},{133,0,670},{4,0,880},{139,0,231},{134,0,
+-1617},{135,0,1957},{5,11,9},{7,11,297},{7,11,966},{140,11,306},{6,0,975},{134,0,
+-985},{5,10,950},{5,10,994},{134,10,351},{12,11,21},{151,11,7},{5,11,146},{6,11,
+-411},{138,11,721},{7,0,242},{135,0,1942},{6,11,177},{135,11,467},{5,0,421},{7,10
+-,47},{137,10,684},{5,0,834},{7,0,1202},{8,0,14},{9,0,481},{137,0,880},{138,0,465
+-},{6,0,688},{9,0,834},{132,10,350},{132,0,855},{4,0,357},{6,0,172},{7,0,143},{
+-137,0,413},{133,11,200},{132,0,590},{7,10,1812},{13,10,259},{13,10,356},{14,10,
+-242},{147,10,114},{133,10,967},{11,0,114},{4,10,473},{7,10,623},{8,10,808},{9,10
+-,871},{9,10,893},{11,10,431},{12,10,112},{12,10,217},{12,10,243},{12,10,562},{12
+-,10,663},{12,10,683},{13,10,141},{13,10,197},{13,10,227},{13,10,406},{13,10,487}
+-,{14,10,156},{14,10,203},{14,10,224},{14,10,256},{18,10,58},{150,10,0},{138,10,
+-286},{4,10,222},{7,10,286},{136,10,629},{5,0,169},{7,0,333},{136,0,45},{134,11,
+-481},{132,0,198},{4,0,24},{5,0,140},{5,0,185},{7,0,1500},{11,0,565},{11,0,838},{
+-4,11,84},{7,11,1482},{10,11,76},{138,11,142},{133,0,585},{141,10,306},{133,11,
+-1015},{4,11,315},{5,11,507},{135,11,1370},{136,10,146},{6,0,691},{134,0,1503},{4
+-,0,334},{133,0,593},{4,10,465},{135,10,1663},{142,11,173},{135,0,913},{12,0,116}
+-,{134,11,1722},{134,0,1360},{132,0,802},{8,11,222},{8,11,476},{9,11,238},{11,11,
+-516},{11,11,575},{15,11,109},{146,11,100},{6,0,308},{9,0,673},{7,10,138},{7,10,
+-517},{139,10,238},{132,0,709},{6,0,1876},{6,0,1895},{9,0,994},{9,0,1006},{12,0,
+-829},{12,0,888},{12,0,891},{146,0,185},{148,10,94},{4,0,228},{133,0,897},{7,0,
+-1840},{5,10,495},{7,10,834},{9,10,733},{139,10,378},{133,10,559},{6,10,21},{6,10
+-,1737},{7,10,1444},{136,10,224},{4,0,608},{133,0,497},{6,11,40},{135,11,1781},{
+-134,0,1573},{135,0,2039},{6,0,540},{136,0,136},{4,0,897},{5,0,786},{133,10,519},
+-{6,0,1878},{6,0,1884},{9,0,938},{9,0,948},{9,0,955},{9,0,973},{9,0,1012},{12,0,
+-895},{12,0,927},{143,0,254},{134,0,1469},{133,0,999},{4,0,299},{135,0,1004},{4,0
+-,745},{133,0,578},{136,11,574},{133,0,456},{134,0,1457},{7,0,1679},{132,10,402},
+-{7,0,693},{8,0,180},{12,0,163},{8,10,323},{136,10,479},{11,10,580},{142,10,201},
+-{5,10,59},{135,10,672},{132,11,354},{146,10,34},{4,0,755},{135,11,1558},{7,0,
+-1740},{146,0,48},{4,10,85},{135,10,549},{139,0,338},{133,10,94},{134,0,1091},{
+-135,11,469},{12,0,695},{12,0,704},{20,0,113},{5,11,830},{14,11,338},{148,11,81},
+-{135,0,1464},{6,10,11},{135,10,187},{135,0,975},{13,0,335},{132,10,522},{134,0,
+-1979},{5,11,496},{135,11,203},{4,10,52},{135,10,661},{7,0,1566},{8,0,269},{9,0,
+-212},{9,0,718},{14,0,15},{14,0,132},{142,0,227},{4,0,890},{5,0,805},{5,0,819},{5
+-,0,961},{6,0,396},{6,0,1631},{6,0,1678},{7,0,1967},{7,0,2041},{9,0,630},{11,0,8}
+-,{11,0,1019},{12,0,176},{13,0,225},{14,0,292},{21,0,24},{4,10,383},{133,10,520},
+-{134,11,547},{135,11,1748},{5,11,88},{137,11,239},{146,11,128},{7,11,650},{135,
+-11,1310},{4,10,281},{5,10,38},{7,10,194},{7,10,668},{7,10,1893},{137,10,397},{
+-135,0,1815},{9,10,635},{139,10,559},{7,0,1505},{10,0,190},{10,0,634},{11,0,792},
+-{12,0,358},{140,0,447},{5,0,0},{6,0,536},{7,0,604},{13,0,445},{145,0,126},{7,11,
+-1076},{9,11,80},{11,11,78},{11,11,421},{11,11,534},{140,11,545},{8,0,966},{10,0,
+-1023},{14,11,369},{146,11,72},{135,11,1641},{6,0,232},{6,0,412},{7,0,1074},{8,0,
+-9},{8,0,157},{8,0,786},{9,0,196},{9,0,352},{9,0,457},{10,0,337},{11,0,232},{11,0
+-,877},{12,0,480},{140,0,546},{135,0,958},{4,0,382},{136,0,579},{4,0,212},{135,0,
+-1206},{4,11,497},{5,11,657},{135,11,1584},{132,0,681},{8,0,971},{138,0,965},{5,
+-10,448},{136,10,535},{14,0,16},{146,0,44},{11,0,584},{11,0,616},{14,0,275},{11,
+-11,584},{11,11,616},{142,11,275},{136,11,13},{7,10,610},{135,10,1501},{7,11,642}
+-,{8,11,250},{11,11,123},{11,11,137},{13,11,48},{142,11,95},{133,0,655},{17,0,67}
+-,{147,0,74},{134,0,751},{134,0,1967},{6,0,231},{136,0,423},{5,0,300},{138,0,1016
+-},{4,10,319},{5,10,699},{138,10,673},{6,0,237},{7,0,611},{8,0,100},{9,0,416},{11
+-,0,335},{12,0,173},{18,0,101},{6,10,336},{8,10,552},{9,10,285},{10,10,99},{139,
+-10,568},{134,0,1370},{7,10,1406},{9,10,218},{141,10,222},{133,10,256},{135,0,
+-1208},{14,11,213},{148,11,38},{6,0,1219},{135,11,1642},{13,0,417},{14,0,129},{
+-143,0,15},{10,11,545},{140,11,301},{17,10,39},{148,10,36},{133,0,199},{4,11,904}
+-,{133,11,794},{12,0,427},{146,0,38},{134,0,949},{8,0,665},{135,10,634},{132,10,
+-618},{135,10,259},{132,10,339},{133,11,761},{141,10,169},{132,10,759},{5,0,688},
+-{7,0,539},{135,0,712},{7,11,386},{138,11,713},{134,0,1186},{6,11,7},{6,11,35},{7
+-,11,147},{7,11,1069},{7,11,1568},{7,11,1575},{7,11,1917},{8,11,43},{8,11,208},{9
+-,11,128},{9,11,866},{10,11,20},{11,11,981},{147,11,33},{7,11,893},{8,10,482},{
+-141,11,424},{6,0,312},{6,0,1715},{10,0,584},{11,0,546},{11,0,692},{12,0,259},{12
+-,0,295},{13,0,46},{141,0,154},{5,10,336},{6,10,341},{6,10,478},{6,10,1763},{136,
+-10,386},{137,0,151},{132,0,588},{152,0,4},{6,11,322},{9,11,552},{11,11,274},{13,
+-11,209},{13,11,499},{14,11,85},{15,11,126},{145,11,70},{135,10,73},{4,0,231},{5,
+-0,61},{6,0,104},{7,0,729},{7,0,964},{7,0,1658},{140,0,414},{6,0,263},{138,0,757}
+-,{135,10,1971},{4,0,612},{133,0,561},{132,0,320},{135,10,1344},{8,11,83},{8,11,
+-817},{9,11,28},{9,11,29},{9,11,885},{10,11,387},{11,11,633},{11,11,740},{13,11,
+-235},{13,11,254},{15,11,143},{143,11,146},{5,10,396},{134,10,501},{140,11,49},{
+-132,0,225},{4,10,929},{5,10,799},{8,10,46},{136,10,740},{4,0,405},{7,0,817},{14,
+-0,58},{17,0,37},{146,0,124},{133,0,974},{4,11,412},{133,11,581},{4,10,892},{133,
+-10,770},{4,0,996},{134,0,2026},{4,0,527},{5,0,235},{7,0,1239},{11,0,131},{140,0,
+-370},{9,0,16},{13,0,386},{135,11,421},{7,0,956},{7,0,1157},{7,0,1506},{7,0,1606}
+-,{7,0,1615},{7,0,1619},{7,0,1736},{7,0,1775},{8,0,590},{9,0,324},{9,0,736},{9,0,
+-774},{9,0,776},{9,0,784},{10,0,567},{10,0,708},{11,0,518},{11,0,613},{11,0,695},
+-{11,0,716},{11,0,739},{11,0,770},{11,0,771},{11,0,848},{11,0,857},{11,0,931},{11
+-,0,947},{12,0,326},{12,0,387},{12,0,484},{12,0,528},{12,0,552},{12,0,613},{13,0,
+-189},{13,0,256},{13,0,340},{13,0,432},{13,0,436},{13,0,440},{13,0,454},{14,0,174
+-},{14,0,220},{14,0,284},{14,0,390},{145,0,121},{135,10,158},{9,0,137},{138,0,221
+-},{4,11,110},{10,11,415},{10,11,597},{142,11,206},{141,11,496},{135,11,205},{151
+-,10,25},{135,11,778},{7,11,1656},{7,10,2001},{9,11,369},{10,11,338},{10,11,490},
+-{11,11,154},{11,11,545},{11,11,775},{13,11,77},{141,11,274},{4,11,444},{10,11,
+-146},{140,11,9},{7,0,390},{138,0,140},{135,0,1144},{134,0,464},{7,10,1461},{140,
+-10,91},{132,10,602},{4,11,283},{135,11,1194},{5,0,407},{11,0,204},{11,0,243},{11
+-,0,489},{12,0,293},{19,0,37},{20,0,73},{150,0,38},{7,0,1218},{136,0,303},{5,0,
+-325},{8,0,5},{8,0,227},{9,0,105},{10,0,585},{12,0,614},{4,10,13},{5,10,567},{7,
+-10,1498},{9,10,124},{11,10,521},{140,10,405},{135,10,1006},{7,0,800},{10,0,12},{
+-134,11,1720},{135,0,1783},{132,10,735},{138,10,812},{4,10,170},{135,10,323},{6,0
+-,621},{13,0,504},{144,0,89},{5,10,304},{135,10,1403},{137,11,216},{6,0,920},{6,0
+-,1104},{9,11,183},{139,11,286},{4,0,376},{133,10,742},{134,0,218},{8,0,641},{11,
+-0,388},{140,0,580},{7,0,454},{7,0,782},{8,0,768},{140,0,686},{137,11,33},{133,10
+-,111},{144,0,0},{10,0,676},{140,0,462},{6,0,164},{136,11,735},{133,10,444},{150,
+-0,50},{7,11,1862},{12,11,491},{12,11,520},{13,11,383},{14,11,244},{146,11,12},{5
+-,11,132},{9,11,486},{9,11,715},{10,11,458},{11,11,373},{11,11,668},{11,11,795},{
+-11,11,897},{12,11,272},{12,11,424},{12,11,539},{12,11,558},{14,11,245},{14,11,
+-263},{14,11,264},{14,11,393},{142,11,403},{8,10,123},{15,10,6},{144,10,7},{6,0,
+-285},{8,0,654},{11,0,749},{12,0,190},{12,0,327},{13,0,120},{13,0,121},{13,0,327}
+-,{15,0,47},{146,0,40},{5,11,8},{6,11,89},{6,11,400},{7,11,1569},{7,11,1623},{7,
+-11,1850},{8,11,218},{8,11,422},{9,11,570},{138,11,626},{6,11,387},{7,11,882},{
+-141,11,111},{6,0,343},{7,0,195},{9,0,226},{10,0,197},{10,0,575},{11,0,502},{11,0
+-,899},{6,11,224},{7,11,877},{137,11,647},{5,10,937},{135,10,100},{135,11,790},{
+-150,0,29},{147,0,8},{134,0,1812},{149,0,8},{135,11,394},{7,0,1125},{9,0,143},{11
+-,0,61},{14,0,405},{150,0,21},{10,11,755},{147,11,29},{9,11,378},{141,11,162},{
+-135,10,922},{5,10,619},{133,10,698},{134,0,1327},{6,0,1598},{137,0,575},{9,11,
+-569},{12,11,12},{12,11,81},{12,11,319},{13,11,69},{14,11,259},{16,11,87},{17,11,
+-1},{17,11,21},{17,11,24},{18,11,15},{18,11,56},{18,11,59},{18,11,127},{18,11,154
+-},{19,11,19},{148,11,31},{6,0,895},{135,11,1231},{5,0,959},{7,11,124},{136,11,38
+-},{5,11,261},{7,11,78},{7,11,199},{8,11,815},{9,11,126},{138,11,342},{5,10,917},
+-{134,10,1659},{7,0,1759},{5,11,595},{135,11,1863},{136,0,173},{134,0,266},{142,0
+-,261},{132,11,628},{5,10,251},{5,10,956},{8,10,268},{9,10,214},{146,10,142},{7,
+-11,266},{136,11,804},{135,11,208},{6,11,79},{7,11,1021},{135,11,1519},{11,11,704
+-},{141,11,396},{5,10,346},{5,10,711},{136,10,390},{136,11,741},{134,11,376},{134
+-,0,1427},{6,0,1033},{6,0,1217},{136,0,300},{133,10,624},{6,11,100},{7,11,244},{7
+-,11,632},{7,11,1609},{8,11,178},{8,11,638},{141,11,58},{6,0,584},{5,10,783},{7,
+-10,1998},{135,10,2047},{5,0,427},{5,0,734},{7,0,478},{136,0,52},{7,0,239},{11,0,
+-217},{142,0,165},{134,0,1129},{6,0,168},{6,0,1734},{7,0,20},{7,0,1056},{8,0,732}
+-,{9,0,406},{9,0,911},{138,0,694},{132,10,594},{133,11,791},{7,11,686},{8,11,33},
+-{8,11,238},{10,11,616},{11,11,467},{11,11,881},{13,11,217},{13,11,253},{142,11,
+-268},{137,11,476},{134,0,418},{133,0,613},{132,0,632},{132,11,447},{7,0,32},{7,0
+-,984},{8,0,85},{8,0,709},{9,0,579},{9,0,847},{9,0,856},{10,0,799},{11,0,258},{11
+-,0,1007},{12,0,331},{12,0,615},{13,0,188},{13,0,435},{14,0,8},{15,0,165},{16,0,
+-27},{20,0,40},{144,11,35},{4,11,128},{5,11,415},{6,11,462},{7,11,294},{7,11,578}
+-,{10,11,710},{139,11,86},{5,0,694},{136,0,909},{7,0,1109},{11,0,7},{5,10,37},{6,
+-10,39},{6,10,451},{7,10,218},{7,10,1166},{7,10,1687},{8,10,662},{144,10,2},{136,
+-11,587},{6,11,427},{7,11,1018},{138,11,692},{4,11,195},{6,10,508},{135,11,802},{
+-4,0,167},{135,0,82},{5,0,62},{6,0,24},{6,0,534},{7,0,74},{7,0,678},{7,0,684},{7,
+-0,1043},{7,0,1072},{8,0,280},{8,0,541},{8,0,686},{9,0,258},{10,0,519},{11,0,252}
+-,{140,0,282},{138,0,33},{4,0,359},{133,11,738},{7,0,980},{9,0,328},{13,0,186},{
+-13,0,364},{7,10,635},{7,10,796},{8,10,331},{9,10,330},{9,10,865},{10,10,119},{10
+-,10,235},{11,10,111},{11,10,129},{11,10,240},{12,10,31},{12,10,66},{12,10,222},{
+-12,10,269},{12,10,599},{12,10,684},{12,10,689},{12,10,691},{142,10,345},{137,10,
+-527},{6,0,596},{7,0,585},{135,10,702},{134,11,1683},{133,0,211},{6,0,145},{141,0
+-,336},{134,0,1130},{7,0,873},{6,10,37},{7,10,1666},{8,10,195},{8,10,316},{9,10,
+-178},{9,10,276},{9,10,339},{9,10,536},{10,10,102},{10,10,362},{10,10,785},{11,10
+-,55},{11,10,149},{11,10,773},{13,10,416},{13,10,419},{14,10,38},{14,10,41},{142,
+-10,210},{8,0,840},{136,0,841},{132,0,263},{5,11,3},{8,11,578},{9,11,118},{10,11,
+-705},{12,11,383},{141,11,279},{132,0,916},{133,11,229},{133,10,645},{15,0,155},{
+-16,0,79},{8,11,102},{10,11,578},{10,11,672},{12,11,496},{13,11,408},{14,11,121},
+-{145,11,106},{4,0,599},{5,0,592},{6,0,1634},{7,0,5},{7,0,55},{7,0,67},{7,0,97},{
+-7,0,691},{7,0,979},{7,0,1600},{7,0,1697},{8,0,207},{8,0,214},{8,0,231},{8,0,294}
+-,{8,0,336},{8,0,428},{8,0,471},{8,0,622},{8,0,626},{8,0,679},{8,0,759},{8,0,829}
+-,{9,0,11},{9,0,246},{9,0,484},{9,0,573},{9,0,706},{9,0,762},{9,0,798},{9,0,855},
+-{9,0,870},{9,0,912},{10,0,303},{10,0,335},{10,0,424},{10,0,461},{10,0,543},{10,0
+-,759},{10,0,814},{11,0,59},{11,0,199},{11,0,235},{11,0,590},{11,0,631},{11,0,929
+-},{11,0,963},{11,0,987},{12,0,114},{12,0,182},{12,0,226},{12,0,332},{12,0,439},{
+-12,0,575},{12,0,598},{12,0,675},{13,0,8},{13,0,125},{13,0,194},{13,0,287},{14,0,
+-197},{14,0,383},{15,0,53},{17,0,63},{19,0,46},{19,0,98},{19,0,106},{148,0,85},{7
+-,0,1356},{132,10,290},{6,10,70},{7,10,1292},{10,10,762},{139,10,288},{150,11,55}
+-,{4,0,593},{8,11,115},{8,11,350},{9,11,489},{10,11,128},{11,11,306},{12,11,373},
+-{14,11,30},{17,11,79},{147,11,80},{135,11,1235},{134,0,1392},{4,11,230},{133,11,
+-702},{147,0,126},{7,10,131},{7,10,422},{8,10,210},{140,10,573},{134,0,1179},{139
+-,11,435},{139,10,797},{134,11,1728},{4,0,162},{18,11,26},{19,11,42},{20,11,43},{
+-21,11,0},{23,11,27},{152,11,14},{132,10,936},{6,0,765},{5,10,453},{134,10,441},{
+-133,0,187},{135,0,1286},{6,0,635},{6,0,904},{6,0,1210},{134,0,1489},{4,0,215},{8
+-,0,890},{9,0,38},{10,0,923},{11,0,23},{11,0,127},{139,0,796},{6,0,1165},{134,0,
+-1306},{7,0,716},{13,0,97},{141,0,251},{132,10,653},{136,0,657},{146,10,80},{5,11
+-,622},{7,11,1032},{11,11,26},{11,11,213},{11,11,707},{12,11,380},{13,11,226},{
+-141,11,355},{6,0,299},{5,11,70},{6,11,334},{9,11,171},{11,11,637},{12,11,202},{
+-14,11,222},{145,11,42},{142,0,134},{4,11,23},{5,11,313},{5,11,1014},{6,11,50},{6
+-,11,51},{7,11,142},{7,11,384},{9,11,783},{139,11,741},{4,11,141},{7,11,559},{8,
+-11,640},{9,11,460},{12,11,183},{141,11,488},{136,11,614},{7,10,1368},{8,10,232},
+-{8,10,361},{10,10,682},{138,10,742},{137,10,534},{6,0,1082},{140,0,658},{137,10,
+-27},{135,0,2002},{142,10,12},{4,0,28},{5,0,440},{7,0,248},{11,0,833},{140,0,344}
+-,{7,10,736},{139,10,264},{134,10,1657},{134,0,1654},{138,0,531},{5,11,222},{9,11
+-,140},{138,11,534},{6,0,634},{6,0,798},{134,0,840},{138,11,503},{135,10,127},{
+-133,0,853},{5,11,154},{7,11,1491},{10,11,379},{138,11,485},{6,0,249},{7,0,1234},
+-{139,0,573},{133,11,716},{7,11,1570},{140,11,542},{136,10,364},{138,0,527},{4,11
+-,91},{5,11,388},{5,11,845},{6,11,206},{6,11,252},{6,11,365},{7,11,136},{7,11,531
+-},{8,11,264},{136,11,621},{134,0,1419},{135,11,1441},{7,0,49},{7,0,392},{8,0,20}
+-,{8,0,172},{8,0,690},{9,0,383},{9,0,845},{10,0,48},{11,0,293},{11,0,832},{11,0,
+-920},{11,0,984},{141,0,221},{5,0,858},{133,0,992},{5,0,728},{137,10,792},{5,10,
+-909},{9,10,849},{138,10,805},{7,0,525},{7,0,1579},{8,0,497},{136,0,573},{6,0,268
+-},{137,0,62},{135,11,576},{134,0,1201},{5,11,771},{5,11,863},{5,11,898},{6,11,
+-1632},{6,11,1644},{134,11,1780},{133,11,331},{7,0,193},{7,0,1105},{10,0,495},{7,
+-10,397},{8,10,124},{8,10,619},{9,10,305},{11,10,40},{12,10,349},{13,10,134},{13,
+-10,295},{14,10,155},{15,10,120},{146,10,105},{138,0,106},{6,0,859},{5,11,107},{7
+-,11,201},{136,11,518},{6,11,446},{135,11,1817},{13,0,23},{4,10,262},{135,10,342}
+-,{133,10,641},{137,11,851},{6,0,925},{137,0,813},{132,11,504},{6,0,613},{136,0,
+-223},{4,10,99},{6,10,250},{6,10,346},{8,10,127},{138,10,81},{136,0,953},{132,10,
+-915},{139,11,892},{5,10,75},{9,10,517},{10,10,470},{12,10,155},{141,10,224},{4,0
+-,666},{7,0,1017},{7,11,996},{138,11,390},{5,11,883},{133,11,975},{14,10,83},{142
+-,11,83},{4,0,670},{5,11,922},{134,11,1707},{135,0,216},{9,0,40},{11,0,136},{135,
+-11,787},{5,10,954},{5,11,993},{7,11,515},{137,11,91},{139,0,259},{7,0,1114},{9,0
+-,310},{9,0,682},{10,0,440},{13,0,40},{6,10,304},{8,10,418},{11,10,341},{139,10,
+-675},{14,0,296},{9,10,410},{139,10,425},{10,11,377},{12,11,363},{13,11,68},{13,
+-11,94},{14,11,108},{142,11,306},{7,0,1401},{135,0,1476},{4,0,296},{6,0,475},{7,0
+-,401},{7,0,1410},{7,0,1594},{7,0,1674},{8,0,63},{8,0,660},{137,0,74},{4,0,139},{
+-4,0,388},{140,0,188},{132,0,797},{132,11,766},{5,11,103},{7,11,921},{8,11,580},{
+-8,11,593},{8,11,630},{138,11,28},{4,11,911},{5,11,867},{133,11,1013},{134,10,14}
+-,{134,0,1572},{134,10,1708},{21,0,39},{5,10,113},{6,10,243},{7,10,1865},{11,10,
+-161},{16,10,37},{145,10,99},{7,11,1563},{141,11,182},{5,11,135},{6,11,519},{7,11
+-,1722},{10,11,271},{11,11,261},{145,11,54},{132,10,274},{134,0,1594},{4,11,300},
+-{5,11,436},{135,11,484},{4,0,747},{6,0,290},{7,0,649},{7,0,1479},{135,0,1583},{
+-133,11,535},{147,11,82},{133,0,232},{137,0,887},{135,10,166},{136,0,521},{4,0,14
+-},{7,0,472},{7,0,1801},{10,0,748},{141,0,458},{134,0,741},{134,0,992},{16,0,111}
+-,{137,10,304},{4,0,425},{5,11,387},{7,11,557},{12,11,547},{142,11,86},{135,11,
+-1747},{5,10,654},{135,11,1489},{7,0,789},{4,11,6},{5,11,708},{136,11,75},{6,10,
+-273},{10,10,188},{13,10,377},{146,10,77},{6,0,1593},{4,11,303},{7,11,619},{10,11
+-,547},{10,11,687},{11,11,122},{140,11,601},{134,0,1768},{135,10,410},{138,11,772
+-},{11,0,233},{139,10,524},{5,0,943},{134,0,1779},{134,10,1785},{136,11,529},{132
+-,0,955},{5,0,245},{6,0,576},{7,0,582},{136,0,225},{132,10,780},{142,0,241},{134,
+-0,1943},{4,11,106},{7,11,310},{7,11,1785},{10,11,690},{139,11,717},{134,0,1284},
+-{5,11,890},{133,11,988},{6,11,626},{142,11,431},{10,11,706},{145,11,32},{137,11,
+-332},{132,11,698},{135,0,709},{5,10,948},{138,11,17},{136,0,554},{134,0,1564},{
+-139,10,941},{132,0,443},{134,0,909},{134,11,84},{142,0,280},{4,10,532},{5,10,706
+-},{135,10,662},{132,0,729},{5,10,837},{6,10,1651},{139,10,985},{135,10,1861},{4,
+-0,348},{152,11,3},{5,11,986},{6,11,130},{7,11,1582},{8,11,458},{10,11,101},{10,
+-11,318},{138,11,823},{134,0,758},{4,0,298},{137,0,848},{4,10,330},{7,10,933},{7,
+-10,2012},{136,10,292},{7,11,1644},{137,11,129},{6,0,1422},{9,0,829},{135,10,767}
+-,{5,0,164},{7,0,121},{142,0,189},{7,0,812},{7,0,1261},{7,0,1360},{9,0,632},{140,
+-0,352},{135,11,1788},{139,0,556},{135,11,997},{145,10,114},{4,0,172},{9,0,611},{
+-10,0,436},{12,0,673},{13,0,255},{137,10,883},{11,0,530},{138,10,274},{133,0,844}
+-,{134,0,984},{13,0,232},{18,0,35},{4,10,703},{135,10,207},{132,10,571},{9,0,263}
+-,{10,0,147},{138,0,492},{7,11,1756},{137,11,98},{5,10,873},{5,10,960},{8,10,823}
+-,{137,10,881},{133,0,537},{132,0,859},{7,11,1046},{139,11,160},{137,0,842},{139,
+-10,283},{5,10,33},{6,10,470},{139,10,424},{6,11,45},{7,11,433},{8,11,129},{9,11,
+-21},{10,11,392},{11,11,79},{12,11,499},{13,11,199},{141,11,451},{135,0,1291},{
+-135,10,1882},{7,11,558},{136,11,353},{134,0,1482},{5,0,230},{5,0,392},{6,0,420},
+-{9,0,568},{140,0,612},{6,0,262},{7,10,90},{7,10,664},{7,10,830},{7,10,1380},{7,
+-10,2025},{8,11,81},{8,10,448},{8,10,828},{9,11,189},{9,11,201},{11,11,478},{11,
+-11,712},{141,11,338},{142,0,31},{5,11,353},{151,11,26},{132,0,753},{4,0,0},{5,0,
+-41},{7,0,1459},{7,0,1469},{7,0,1859},{9,0,549},{139,0,905},{9,10,417},{137,10,
+-493},{135,11,1113},{133,0,696},{141,11,448},{134,10,295},{132,0,834},{4,0,771},{
+-5,10,1019},{6,11,25},{7,11,855},{7,11,1258},{144,11,32},{134,0,1076},{133,0,921}
+-,{133,0,674},{4,11,4},{7,11,1118},{7,11,1320},{7,11,1706},{8,11,277},{9,11,622},
+-{10,11,9},{11,11,724},{12,11,350},{12,11,397},{13,11,28},{13,11,159},{15,11,89},
+-{18,11,5},{19,11,9},{20,11,34},{150,11,47},{134,10,208},{6,0,444},{136,0,308},{6
+-,0,180},{7,0,1137},{8,0,751},{139,0,805},{4,0,183},{7,0,271},{11,0,824},{11,0,
+-952},{13,0,278},{13,0,339},{13,0,482},{14,0,424},{148,0,99},{7,11,317},{135,11,
+-569},{4,0,19},{5,0,477},{5,0,596},{6,0,505},{7,0,1221},{11,0,907},{12,0,209},{
+-141,0,214},{135,0,1215},{6,0,271},{7,0,398},{8,0,387},{10,0,344},{7,10,448},{7,
+-10,1629},{7,10,1813},{8,10,442},{9,10,710},{10,10,282},{138,10,722},{11,10,844},
+-{12,10,104},{140,10,625},{134,11,255},{133,10,787},{134,0,1645},{11,11,956},{151
+-,11,3},{6,0,92},{6,0,188},{7,0,209},{7,0,1269},{7,0,1524},{7,0,1876},{8,0,661},{
+-10,0,42},{10,0,228},{11,0,58},{11,0,1020},{12,0,58},{12,0,118},{141,0,32},{4,0,
+-459},{133,0,966},{4,11,536},{7,11,1141},{10,11,723},{139,11,371},{140,0,330},{
+-134,0,1557},{7,11,285},{135,11,876},{136,10,491},{135,11,560},{6,0,18},{7,0,179}
+-,{7,0,932},{8,0,548},{8,0,757},{9,0,54},{9,0,65},{9,0,532},{9,0,844},{10,0,113},
+-{10,0,117},{10,0,315},{10,0,560},{10,0,622},{10,0,798},{11,0,153},{11,0,351},{11
+-,0,375},{12,0,78},{12,0,151},{12,0,392},{12,0,666},{14,0,248},{143,0,23},{6,0,
+-1742},{132,11,690},{4,10,403},{5,10,441},{7,10,450},{10,10,840},{11,10,101},{12,
+-10,193},{141,10,430},{133,0,965},{134,0,182},{10,0,65},{10,0,488},{138,0,497},{
+-135,11,1346},{6,0,973},{6,0,1158},{10,11,200},{19,11,2},{151,11,22},{4,11,190},{
+-133,11,554},{133,10,679},{7,0,328},{137,10,326},{133,11,1001},{9,0,588},{138,0,
+-260},{133,11,446},{135,10,1128},{135,10,1796},{147,11,119},{134,0,1786},{6,0,
+-1328},{6,0,1985},{8,0,962},{138,0,1017},{135,0,308},{11,0,508},{4,10,574},{7,10,
+-350},{7,10,1024},{8,10,338},{9,10,677},{138,10,808},{138,11,752},{135,10,1081},{
+-137,11,96},{7,10,1676},{135,10,2037},{136,0,588},{132,11,304},{133,0,614},{140,0
+-,793},{136,0,287},{137,10,297},{141,10,37},{6,11,53},{6,11,199},{7,11,1408},{8,
+-11,32},{8,11,93},{9,11,437},{10,11,397},{10,11,629},{11,11,593},{11,11,763},{13,
+-11,326},{145,11,35},{134,11,105},{9,11,320},{10,11,506},{138,11,794},{5,11,114},
+-{5,11,255},{141,11,285},{140,0,290},{7,11,2035},{8,11,19},{9,11,89},{138,11,831}
+-,{134,0,1136},{7,0,719},{8,0,796},{8,0,809},{8,0,834},{6,10,306},{7,10,1140},{7,
+-10,1340},{8,10,133},{138,10,449},{139,10,1011},{5,0,210},{6,0,213},{7,0,60},{10,
+-0,364},{139,0,135},{5,0,607},{8,0,326},{136,0,490},{138,11,176},{132,0,701},{5,0
+-,472},{7,0,380},{137,0,758},{135,0,1947},{6,0,1079},{138,0,278},{138,11,391},{5,
+-10,329},{8,10,260},{139,11,156},{4,0,386},{7,0,41},{8,0,405},{8,0,728},{9,0,497}
+-,{11,0,110},{11,0,360},{15,0,37},{144,0,84},{5,0,46},{7,0,1452},{7,0,1480},{8,0,
+-634},{140,0,472},{136,0,961},{4,0,524},{136,0,810},{10,0,238},{141,0,33},{132,10
+-,657},{152,10,7},{133,0,532},{5,0,997},{135,10,1665},{7,11,594},{7,11,851},{7,11
+-,1858},{9,11,411},{9,11,574},{9,11,666},{9,11,737},{10,11,346},{10,11,712},{11,
+-11,246},{11,11,432},{11,11,517},{11,11,647},{11,11,679},{11,11,727},{12,11,304},
+-{12,11,305},{12,11,323},{12,11,483},{12,11,572},{12,11,593},{12,11,602},{13,11,
+-95},{13,11,101},{13,11,171},{13,11,315},{13,11,378},{13,11,425},{13,11,475},{14,
+-11,63},{14,11,380},{14,11,384},{15,11,133},{18,11,112},{148,11,72},{5,11,955},{
+-136,11,814},{134,0,1301},{5,10,66},{7,10,1896},{136,10,288},{133,11,56},{134,10,
+-1643},{6,0,1298},{148,11,100},{5,0,782},{5,0,829},{6,0,671},{6,0,1156},{6,0,1738
+-},{137,11,621},{4,0,306},{5,0,570},{7,0,1347},{5,10,91},{5,10,648},{5,10,750},{5
+-,10,781},{6,10,54},{6,10,112},{6,10,402},{6,10,1732},{7,10,315},{7,10,749},{7,10
+-,1900},{9,10,78},{9,10,508},{10,10,611},{10,10,811},{11,10,510},{11,10,728},{13,
+-10,36},{14,10,39},{16,10,83},{17,10,124},{148,10,30},{8,10,570},{9,11,477},{141,
+-11,78},{4,11,639},{10,11,4},{10,10,322},{10,10,719},{11,10,407},{11,11,638},{12,
+-11,177},{148,11,57},{7,0,1823},{139,0,693},{7,0,759},{5,11,758},{8,10,125},{8,10
+-,369},{8,10,524},{10,10,486},{11,10,13},{11,10,381},{11,10,736},{11,10,766},{11,
+-10,845},{13,10,114},{13,10,292},{142,10,47},{7,0,1932},{6,10,1684},{6,10,1731},{
+-7,10,356},{8,10,54},{8,10,221},{9,10,225},{9,10,356},{10,10,77},{10,10,446},{10,
+-10,731},{12,10,404},{141,10,491},{135,11,552},{135,11,1112},{4,0,78},{5,0,96},{5
+-,0,182},{6,0,1257},{7,0,1724},{7,0,1825},{10,0,394},{10,0,471},{11,0,532},{14,0,
+-340},{145,0,88},{139,11,328},{135,0,1964},{132,10,411},{4,10,80},{5,10,44},{137,
+-11,133},{5,11,110},{6,11,169},{6,11,1702},{7,11,400},{8,11,538},{9,11,184},{9,11
+-,524},{140,11,218},{4,0,521},{5,10,299},{7,10,1083},{140,11,554},{6,11,133},{9,
+-11,353},{12,11,628},{146,11,79},{6,0,215},{7,0,584},{7,0,1028},{7,0,1473},{7,0,
+-1721},{9,0,424},{138,0,779},{7,0,857},{7,0,1209},{7,10,1713},{9,10,537},{10,10,
+-165},{12,10,219},{140,10,561},{4,10,219},{6,11,93},{7,11,1422},{7,10,1761},{7,11
+-,1851},{8,11,673},{9,10,86},{9,11,529},{140,11,43},{137,11,371},{136,0,671},{5,0
+-,328},{135,0,918},{132,0,529},{9,11,25},{10,11,467},{138,11,559},{4,11,335},{135
+-,11,942},{134,0,716},{134,0,1509},{6,0,67},{7,0,258},{7,0,1630},{9,0,354},{9,0,
+-675},{10,0,830},{14,0,80},{17,0,80},{140,10,428},{134,0,1112},{6,0,141},{7,0,225
+-},{9,0,59},{9,0,607},{10,0,312},{11,0,687},{12,0,555},{13,0,373},{13,0,494},{148
+-,0,58},{133,10,514},{8,11,39},{10,11,773},{11,11,84},{12,11,205},{142,11,1},{8,0
+-,783},{5,11,601},{133,11,870},{136,11,594},{4,10,55},{5,10,301},{6,10,571},{14,
+-10,49},{146,10,102},{132,11,181},{134,11,1652},{133,10,364},{4,11,97},{5,11,147}
+-,{6,11,286},{7,11,1362},{141,11,176},{4,10,76},{7,10,1550},{9,10,306},{9,10,430}
+-,{9,10,663},{10,10,683},{11,10,427},{11,10,753},{12,10,334},{12,10,442},{14,10,
+-258},{14,10,366},{143,10,131},{137,10,52},{6,0,955},{134,0,1498},{6,11,375},{7,
+-11,169},{7,11,254},{136,11,780},{7,0,430},{11,0,46},{14,0,343},{142,11,343},{135
+-,0,1183},{5,0,602},{7,0,2018},{9,0,418},{9,0,803},{135,11,1447},{8,0,677},{135,
+-11,1044},{139,11,285},{4,10,656},{135,10,779},{135,10,144},{5,11,629},{135,11,
+-1549},{135,10,1373},{138,11,209},{7,10,554},{7,10,605},{141,10,10},{5,10,838},{5
+-,10,841},{134,10,1649},{133,10,1012},{6,0,1357},{134,0,1380},{144,0,53},{6,0,590
+-},{7,10,365},{7,10,1357},{7,10,1497},{8,10,154},{141,10,281},{133,10,340},{132,
+-11,420},{135,0,329},{147,11,32},{4,0,469},{10,11,429},{139,10,495},{8,10,261},{9
+-,10,144},{9,10,466},{10,10,370},{12,10,470},{13,10,144},{142,10,348},{142,0,460}
+-,{4,11,325},{9,10,897},{138,11,125},{6,0,1743},{6,10,248},{9,10,546},{10,10,535}
+-,{11,10,681},{141,10,135},{4,0,990},{5,0,929},{6,0,340},{8,0,376},{8,0,807},{8,0
+-,963},{8,0,980},{138,0,1007},{134,0,1603},{140,0,250},{4,11,714},{133,11,469},{
+-134,10,567},{136,10,445},{5,0,218},{7,0,1610},{8,0,646},{10,0,83},{11,11,138},{
+-140,11,40},{7,0,1512},{135,0,1794},{135,11,1216},{11,0,0},{16,0,78},{132,11,718}
+-,{133,0,571},{132,0,455},{134,0,1012},{5,11,124},{5,11,144},{6,11,548},{7,11,15}
+-,{7,11,153},{137,11,629},{142,11,10},{6,11,75},{7,11,1531},{8,11,416},{9,11,240}
+-,{9,11,275},{10,11,100},{11,11,658},{11,11,979},{12,11,86},{13,11,468},{14,11,66
+-},{14,11,207},{15,11,20},{15,11,25},{144,11,58},{132,10,577},{5,11,141},{5,11,
+-915},{6,11,1783},{7,11,211},{7,11,698},{7,11,1353},{9,11,83},{9,11,281},{10,11,
+-376},{10,11,431},{11,11,543},{12,11,664},{13,11,280},{13,11,428},{14,11,61},{14,
+-11,128},{17,11,52},{145,11,81},{6,0,161},{7,0,372},{137,0,597},{132,0,349},{10,
+-11,702},{139,11,245},{134,0,524},{134,10,174},{6,0,432},{9,0,751},{139,0,322},{
+-147,11,94},{4,11,338},{133,11,400},{5,0,468},{10,0,325},{11,0,856},{12,0,345},{
+-143,0,104},{133,0,223},{132,0,566},{4,11,221},{5,11,659},{5,11,989},{7,11,697},{
+-7,11,1211},{138,11,284},{135,11,1070},{4,0,59},{135,0,1394},{6,0,436},{11,0,481}
+-,{5,10,878},{133,10,972},{4,0,48},{5,0,271},{135,0,953},{5,0,610},{136,0,457},{4
+-,0,773},{5,0,618},{137,0,756},{133,0,755},{135,0,1217},{138,11,507},{132,10,351}
+-,{132,0,197},{143,11,78},{4,11,188},{7,11,805},{11,11,276},{142,11,293},{5,11,
+-884},{139,11,991},{132,10,286},{10,0,259},{10,0,428},{7,10,438},{7,10,627},{7,10
+-,1516},{8,10,40},{9,10,56},{9,10,294},{11,10,969},{11,10,995},{146,10,148},{4,0,
+-356},{5,0,217},{5,0,492},{5,0,656},{8,0,544},{136,11,544},{5,0,259},{6,0,1230},{
+-7,0,414},{7,0,854},{142,0,107},{132,0,1007},{15,0,14},{144,0,5},{6,0,1580},{132,
+-10,738},{132,11,596},{132,0,673},{133,10,866},{6,0,1843},{135,11,1847},{4,0,165}
+-,{7,0,1398},{135,0,1829},{135,11,1634},{147,11,65},{6,0,885},{6,0,1009},{137,0,
+-809},{133,10,116},{132,10,457},{136,11,770},{9,0,498},{12,0,181},{10,11,361},{
+-142,11,316},{134,11,595},{5,0,9},{7,0,297},{7,0,966},{140,0,306},{4,11,89},{5,11
+-,489},{6,11,315},{7,11,553},{7,11,1745},{138,11,243},{134,0,1487},{132,0,437},{5
+-,0,146},{6,0,411},{138,0,721},{5,10,527},{6,10,189},{135,10,859},{11,10,104},{11
+-,10,554},{15,10,60},{143,10,125},{6,11,1658},{9,11,3},{10,11,154},{11,11,641},{
+-13,11,85},{13,11,201},{141,11,346},{6,0,177},{135,0,467},{134,0,1377},{134,10,
+-116},{136,11,645},{4,11,166},{5,11,505},{6,11,1670},{137,11,110},{133,10,487},{4
+-,10,86},{5,10,667},{5,10,753},{6,10,316},{6,10,455},{135,10,946},{133,0,200},{
+-132,0,959},{6,0,1928},{134,0,1957},{139,11,203},{150,10,45},{4,10,79},{7,10,1773
+-},{10,10,450},{11,10,589},{13,10,332},{13,10,493},{14,10,183},{14,10,334},{14,10
+-,362},{14,10,368},{14,10,376},{14,10,379},{19,10,90},{19,10,103},{19,10,127},{
+-148,10,90},{6,0,1435},{135,11,1275},{134,0,481},{7,11,445},{8,11,307},{8,11,704}
+-,{10,11,41},{10,11,439},{11,11,237},{11,11,622},{140,11,201},{135,11,869},{4,0,
+-84},{7,0,1482},{10,0,76},{138,0,142},{11,11,277},{144,11,14},{135,11,1977},{4,11
+-,189},{5,11,713},{136,11,57},{133,0,1015},{138,11,371},{4,0,315},{5,0,507},{135,
+-0,1370},{4,11,552},{142,10,381},{9,0,759},{16,0,31},{16,0,39},{16,0,75},{18,0,24
+-},{20,0,42},{152,0,1},{134,0,712},{134,0,1722},{133,10,663},{133,10,846},{8,0,
+-222},{8,0,476},{9,0,238},{11,0,516},{11,0,575},{15,0,109},{146,0,100},{7,0,1402}
+-,{7,0,1414},{12,0,456},{5,10,378},{8,10,465},{9,10,286},{10,10,185},{10,10,562},
+-{10,10,635},{11,10,31},{11,10,393},{13,10,312},{18,10,65},{18,10,96},{147,10,89}
+-,{4,0,986},{6,0,1958},{6,0,2032},{8,0,934},{138,0,985},{7,10,1880},{9,10,680},{
+-139,10,798},{134,10,1770},{145,11,49},{132,11,614},{132,10,648},{5,10,945},{6,10
+-,1656},{6,10,1787},{7,10,167},{8,10,824},{9,10,391},{10,10,375},{139,10,185},{
+-138,11,661},{7,0,1273},{135,11,1945},{7,0,706},{7,0,1058},{138,0,538},{7,10,1645
+-},{8,10,352},{137,10,249},{132,10,152},{11,0,92},{11,0,196},{11,0,409},{11,0,450
+-},{11,0,666},{11,0,777},{12,0,262},{13,0,385},{13,0,393},{15,0,115},{16,0,45},{
+-145,0,82},{133,10,1006},{6,0,40},{135,0,1781},{9,11,614},{139,11,327},{5,10,420}
+-,{135,10,1449},{135,0,431},{10,0,97},{135,10,832},{6,0,423},{7,0,665},{135,0,
+-1210},{7,0,237},{8,0,664},{9,0,42},{9,0,266},{9,0,380},{9,0,645},{10,0,177},{138
+-,0,276},{7,0,264},{133,10,351},{8,0,213},{5,10,40},{7,10,598},{7,10,1638},{9,10,
+-166},{9,10,640},{9,10,685},{9,10,773},{11,10,215},{13,10,65},{14,10,172},{14,10,
+-317},{145,10,6},{5,11,84},{134,11,163},{8,10,60},{9,10,343},{139,10,769},{137,0,
+-455},{133,11,410},{8,0,906},{12,0,700},{12,0,706},{140,0,729},{21,11,33},{150,11
+-,40},{7,10,1951},{8,10,765},{8,10,772},{140,10,671},{7,10,108},{8,10,219},{8,10,
+-388},{9,10,639},{9,10,775},{11,10,275},{140,10,464},{5,11,322},{7,11,1941},{8,11
+-,186},{9,11,262},{10,11,187},{14,11,208},{146,11,130},{139,0,624},{8,0,574},{5,
+-11,227},{140,11,29},{7,11,1546},{11,11,299},{142,11,407},{5,10,15},{6,10,56},{7,
+-10,1758},{8,10,500},{9,10,730},{11,10,331},{13,10,150},{142,10,282},{7,11,1395},
+-{8,11,486},{9,11,236},{9,11,878},{10,11,218},{11,11,95},{19,11,17},{147,11,31},{
+-135,11,2043},{4,0,354},{146,11,4},{140,11,80},{135,0,1558},{134,10,1886},{5,10,
+-205},{6,10,438},{137,10,711},{133,11,522},{133,10,534},{7,0,235},{7,0,1475},{15,
+-0,68},{146,0,120},{137,10,691},{4,0,942},{6,0,1813},{8,0,917},{10,0,884},{12,0,
+-696},{12,0,717},{12,0,723},{12,0,738},{12,0,749},{12,0,780},{16,0,97},{146,0,169
+-},{6,10,443},{8,11,562},{9,10,237},{9,10,571},{9,10,695},{10,10,139},{11,10,715}
+-,{12,10,417},{141,10,421},{135,0,957},{133,0,830},{134,11,1771},{146,0,23},{5,0,
+-496},{6,0,694},{7,0,203},{7,11,1190},{137,11,620},{137,11,132},{6,0,547},{134,0,
+-1549},{8,11,258},{9,11,208},{137,11,359},{4,0,864},{5,0,88},{137,0,239},{135,11,
+-493},{4,11,317},{135,11,1279},{132,11,477},{4,10,578},{5,11,63},{133,11,509},{7,
+-0,650},{135,0,1310},{7,0,1076},{9,0,80},{11,0,78},{11,0,421},{11,0,534},{140,0,
+-545},{132,11,288},{12,0,553},{14,0,118},{133,10,923},{7,0,274},{11,0,479},{139,0
+-,507},{8,11,89},{8,11,620},{9,11,49},{10,11,774},{11,11,628},{12,11,322},{143,11
+-,124},{4,0,497},{135,0,1584},{7,0,261},{7,0,1115},{7,0,1354},{7,0,1404},{7,0,
+-1588},{7,0,1705},{7,0,1902},{9,0,465},{10,0,248},{10,0,349},{10,0,647},{11,0,527
+-},{11,0,660},{11,0,669},{12,0,529},{13,0,305},{132,10,924},{133,10,665},{136,0,
+-13},{6,0,791},{138,11,120},{7,0,642},{8,0,250},{11,0,123},{11,0,137},{13,0,48},{
+-142,0,95},{4,10,265},{7,10,807},{135,10,950},{5,10,93},{140,10,267},{135,0,1429}
+-,{4,0,949},{10,0,885},{10,0,891},{10,0,900},{10,0,939},{12,0,760},{142,0,449},{
+-139,11,366},{132,0,818},{134,11,85},{135,10,994},{7,0,330},{5,10,233},{5,10,320}
+-,{6,10,140},{136,10,295},{4,0,1004},{8,0,982},{136,0,993},{133,10,978},{4,10,905
+-},{6,10,1701},{137,10,843},{10,0,545},{140,0,301},{6,0,947},{134,0,1062},{134,0,
+-1188},{4,0,904},{5,0,794},{152,10,6},{134,0,1372},{135,11,608},{5,11,279},{6,11,
+-235},{7,11,468},{8,11,446},{9,11,637},{10,11,717},{11,11,738},{140,11,514},{132,
+-10,509},{5,11,17},{6,11,371},{137,11,528},{132,0,693},{4,11,115},{5,11,669},{6,
+-11,407},{8,11,311},{11,11,10},{141,11,5},{11,0,377},{7,10,273},{137,11,381},{135
+-,0,695},{7,0,386},{138,0,713},{135,10,1041},{134,0,1291},{6,0,7},{6,0,35},{7,0,
+-147},{7,0,1069},{7,0,1568},{7,0,1575},{7,0,1917},{8,0,43},{8,0,208},{9,0,128},{9
+-,0,866},{10,0,20},{11,0,981},{147,0,33},{7,0,893},{141,0,424},{139,10,234},{150,
+-11,56},{5,11,779},{5,11,807},{6,11,1655},{134,11,1676},{5,10,802},{7,10,2021},{
+-136,10,805},{4,11,196},{5,10,167},{5,11,558},{5,10,899},{5,11,949},{6,10,410},{
+-137,10,777},{137,10,789},{134,10,1705},{8,0,904},{140,0,787},{6,0,322},{9,0,552}
+-,{11,0,274},{13,0,209},{13,0,499},{14,0,85},{15,0,126},{145,0,70},{135,10,10},{5
+-,10,11},{6,10,117},{6,10,485},{7,10,1133},{9,10,582},{9,10,594},{11,10,21},{11,
+-10,818},{12,10,535},{141,10,86},{4,10,264},{7,10,1067},{8,10,204},{8,10,385},{
+-139,10,953},{132,11,752},{138,10,56},{133,10,470},{6,0,1808},{8,0,83},{8,0,742},
+-{8,0,817},{9,0,28},{9,0,29},{9,0,885},{10,0,387},{11,0,633},{11,0,740},{13,0,235
+-},{13,0,254},{15,0,143},{143,0,146},{140,0,49},{134,0,1832},{4,11,227},{5,11,159
+-},{5,11,409},{7,11,80},{10,11,294},{10,11,479},{12,11,418},{14,11,50},{14,11,249
+-},{142,11,295},{7,11,1470},{8,11,66},{8,11,137},{8,11,761},{9,11,638},{11,11,80}
+-,{11,11,212},{11,11,368},{11,11,418},{12,11,8},{13,11,15},{16,11,61},{17,11,59},
+-{19,11,28},{148,11,84},{139,10,1015},{138,11,468},{135,0,421},{6,0,415},{7,0,
+-1049},{137,0,442},{6,11,38},{7,11,1220},{8,11,185},{8,11,256},{9,11,22},{9,11,
+-331},{10,11,738},{11,11,205},{11,11,540},{11,11,746},{13,11,399},{13,11,465},{14
+-,11,88},{142,11,194},{139,0,289},{133,10,715},{4,0,110},{10,0,415},{10,0,597},{
+-142,0,206},{4,11,159},{6,11,115},{7,11,252},{7,11,257},{7,11,1928},{8,11,69},{9,
+-11,384},{10,11,91},{10,11,615},{12,11,375},{14,11,235},{18,11,117},{147,11,123},
+-{5,11,911},{136,11,278},{7,0,205},{7,0,2000},{8,10,794},{9,10,400},{10,10,298},{
+-142,10,228},{135,11,1774},{4,11,151},{7,11,1567},{8,11,351},{137,11,322},{136,10
+-,724},{133,11,990},{7,0,1539},{11,0,512},{13,0,205},{19,0,30},{22,0,36},{23,0,19
+-},{135,11,1539},{5,11,194},{7,11,1662},{9,11,90},{140,11,180},{6,10,190},{7,10,
+-768},{135,10,1170},{134,0,1340},{4,0,283},{135,0,1194},{133,11,425},{133,11,971}
+-,{12,0,549},{14,10,67},{147,10,60},{135,10,1023},{134,0,1720},{138,11,587},{5,11
+-,72},{6,11,264},{7,11,21},{7,11,46},{7,11,2013},{8,11,215},{8,11,513},{10,11,266
+-},{139,11,22},{5,0,319},{135,0,534},{6,10,137},{9,10,75},{9,10,253},{10,10,194},
+-{138,10,444},{7,0,1180},{20,0,112},{6,11,239},{7,11,118},{10,11,95},{11,11,603},
+-{13,11,443},{14,11,160},{143,11,4},{134,11,431},{5,11,874},{6,11,1677},{11,10,
+-643},{12,10,115},{143,11,0},{134,0,967},{6,11,65},{7,11,939},{7,11,1172},{7,11,
+-1671},{9,11,540},{10,11,696},{11,11,265},{11,11,732},{11,11,928},{11,11,937},{12
+-,11,399},{13,11,438},{149,11,19},{137,11,200},{135,0,1940},{5,10,760},{7,10,542}
+-,{8,10,135},{136,10,496},{140,11,44},{7,11,1655},{136,11,305},{7,10,319},{7,10,
+-355},{7,10,763},{10,10,389},{145,10,43},{136,0,735},{138,10,786},{137,11,19},{
+-132,11,696},{5,0,132},{9,0,486},{9,0,715},{10,0,458},{11,0,373},{11,0,668},{11,0
+-,795},{11,0,897},{12,0,272},{12,0,424},{12,0,539},{12,0,558},{14,0,245},{14,0,
+-263},{14,0,264},{14,0,393},{142,0,403},{10,0,38},{139,0,784},{132,0,838},{4,11,
+-302},{135,11,1766},{133,0,379},{5,0,8},{6,0,89},{6,0,400},{7,0,1569},{7,0,1623},
+-{7,0,1850},{8,0,218},{8,0,422},{9,0,570},{10,0,626},{4,11,726},{133,11,630},{4,0
+-,1017},{138,0,660},{6,0,387},{7,0,882},{141,0,111},{6,0,224},{7,0,877},{137,0,
+-647},{4,10,58},{5,10,286},{6,10,319},{7,10,402},{7,10,1254},{7,10,1903},{8,10,
+-356},{140,10,408},{135,0,790},{9,0,510},{10,0,53},{4,10,389},{9,10,181},{10,10,
+-29},{10,10,816},{11,10,311},{11,10,561},{12,10,67},{141,10,181},{142,0,458},{6,
+-11,118},{7,11,215},{7,11,1521},{140,11,11},{134,0,954},{135,0,394},{134,0,1367},
+-{5,11,225},{133,10,373},{132,0,882},{7,0,1409},{135,10,1972},{135,10,1793},{4,11
+-,370},{5,11,756},{135,11,1326},{150,11,13},{7,11,354},{10,11,410},{139,11,815},{
+-6,11,1662},{7,11,48},{8,11,771},{10,11,116},{13,11,104},{14,11,105},{14,11,184},
+-{15,11,168},{19,11,92},{148,11,68},{7,0,124},{136,0,38},{5,0,261},{7,0,78},{7,0,
+-199},{8,0,815},{9,0,126},{10,0,342},{140,0,647},{4,0,628},{140,0,724},{7,0,266},
+-{8,0,804},{7,10,1651},{145,10,89},{135,0,208},{134,0,1178},{6,0,79},{135,0,1519}
+-,{132,10,672},{133,10,737},{136,0,741},{132,11,120},{4,0,710},{6,0,376},{134,0,
+-606},{134,0,1347},{134,0,1494},{6,0,850},{6,0,1553},{137,0,821},{5,10,145},{134,
+-11,593},{7,0,1311},{140,0,135},{4,0,467},{5,0,405},{134,0,544},{5,11,820},{135,
+-11,931},{6,0,100},{7,0,244},{7,0,632},{7,0,1609},{8,0,178},{8,0,638},{141,0,58},
+-{4,10,387},{135,10,1288},{6,11,151},{6,11,1675},{7,11,383},{151,11,10},{132,0,
+-481},{135,10,550},{134,0,1378},{6,11,1624},{11,11,11},{12,11,422},{13,11,262},{
+-142,11,360},{133,0,791},{4,11,43},{5,11,344},{133,11,357},{7,0,1227},{140,0,978}
+-,{7,0,686},{8,0,33},{8,0,238},{10,0,616},{11,0,467},{11,0,881},{13,0,217},{13,0,
+-253},{142,0,268},{137,0,857},{8,0,467},{8,0,1006},{7,11,148},{8,11,284},{141,11,
+-63},{4,10,576},{135,10,1263},{133,11,888},{5,10,919},{134,10,1673},{20,10,37},{
+-148,11,37},{132,0,447},{132,11,711},{4,0,128},{5,0,415},{6,0,462},{7,0,294},{7,0
+-,578},{10,0,710},{139,0,86},{4,10,82},{5,10,333},{5,10,904},{6,10,207},{7,10,325
+-},{7,10,1726},{8,10,101},{10,10,778},{139,10,220},{136,0,587},{137,11,440},{133,
+-10,903},{6,0,427},{7,0,1018},{138,0,692},{4,0,195},{135,0,802},{140,10,147},{134
+-,0,1546},{134,0,684},{132,10,705},{136,0,345},{11,11,678},{140,11,307},{133,0,
+-365},{134,0,1683},{4,11,65},{5,11,479},{5,11,1004},{7,11,1913},{8,11,317},{9,11,
+-302},{10,11,612},{141,11,22},{138,0,472},{4,11,261},{135,11,510},{134,10,90},{
+-142,0,433},{151,0,28},{4,11,291},{7,11,101},{9,11,515},{12,11,152},{12,11,443},{
+-13,11,392},{142,11,357},{140,0,997},{5,0,3},{8,0,578},{9,0,118},{10,0,705},{141,
+-0,279},{135,11,1266},{7,10,813},{12,10,497},{141,10,56},{133,0,229},{6,10,125},{
+-135,10,1277},{8,0,102},{10,0,578},{10,0,672},{12,0,496},{13,0,408},{14,0,121},{
+-17,0,106},{151,10,12},{6,0,866},{134,0,1080},{136,0,1022},{4,11,130},{135,11,843
+-},{5,11,42},{5,11,879},{7,11,245},{7,11,324},{7,11,1532},{11,11,463},{11,11,472}
+-,{13,11,363},{144,11,52},{150,0,55},{8,0,115},{8,0,350},{9,0,489},{10,0,128},{11
+-,0,306},{12,0,373},{14,0,30},{17,0,79},{19,0,80},{4,11,134},{133,11,372},{134,0,
+-657},{134,0,933},{135,11,1147},{4,0,230},{133,0,702},{134,0,1728},{4,0,484},{18,
+-0,26},{19,0,42},{20,0,43},{21,0,0},{23,0,27},{152,0,14},{7,0,185},{135,0,703},{6
+-,0,417},{10,0,618},{7,10,1106},{9,10,770},{11,10,112},{140,10,413},{134,0,803},{
+-132,11,644},{134,0,1262},{7,11,540},{12,10,271},{145,10,109},{135,11,123},{132,0
+-,633},{134,11,623},{4,11,908},{5,11,359},{5,11,508},{6,11,1723},{7,11,343},{7,11
+-,1996},{135,11,2026},{135,0,479},{10,0,262},{7,10,304},{9,10,646},{9,10,862},{11
+-,10,696},{12,10,208},{15,10,79},{147,10,108},{4,11,341},{135,11,480},{134,0,830}
+-,{5,0,70},{5,0,622},{6,0,334},{7,0,1032},{9,0,171},{11,0,26},{11,0,213},{11,0,
+-637},{11,0,707},{12,0,202},{12,0,380},{13,0,226},{13,0,355},{14,0,222},{145,0,42
+-},{135,10,981},{143,0,217},{137,11,114},{4,0,23},{4,0,141},{5,0,313},{5,0,1014},
+-{6,0,50},{6,0,51},{7,0,142},{7,0,384},{7,0,559},{8,0,640},{9,0,460},{9,0,783},{
+-11,0,741},{12,0,183},{141,0,488},{141,0,360},{7,0,1586},{7,11,1995},{8,11,299},{
+-11,11,890},{140,11,674},{132,10,434},{7,0,652},{134,10,550},{7,0,766},{5,10,553}
+-,{138,10,824},{7,0,737},{8,0,298},{136,10,452},{4,11,238},{5,11,503},{6,11,179},
+-{7,11,2003},{8,11,381},{8,11,473},{9,11,149},{10,11,183},{15,11,45},{143,11,86},
+-{133,10,292},{5,0,222},{9,0,655},{138,0,534},{138,10,135},{4,11,121},{5,11,156},
+-{5,11,349},{9,11,136},{10,11,605},{14,11,342},{147,11,107},{137,0,906},{6,0,1013
+-},{134,0,1250},{6,0,1956},{6,0,2009},{8,0,991},{144,0,120},{135,11,1192},{138,0,
+-503},{5,0,154},{7,0,1491},{10,0,379},{138,0,485},{6,0,1867},{6,0,1914},{6,0,1925
+-},{9,0,917},{9,0,925},{9,0,932},{9,0,951},{9,0,1007},{9,0,1013},{12,0,806},{12,0
+-,810},{12,0,814},{12,0,816},{12,0,824},{12,0,832},{12,0,837},{12,0,863},{12,0,
+-868},{12,0,870},{12,0,889},{12,0,892},{12,0,900},{12,0,902},{12,0,908},{12,0,933
+-},{12,0,942},{12,0,949},{12,0,954},{15,0,175},{15,0,203},{15,0,213},{15,0,218},{
+-15,0,225},{15,0,231},{15,0,239},{15,0,248},{15,0,252},{18,0,190},{18,0,204},{18,
+-0,215},{18,0,216},{18,0,222},{18,0,225},{18,0,230},{18,0,239},{18,0,241},{21,0,
+-42},{21,0,43},{21,0,44},{21,0,45},{21,0,46},{21,0,53},{24,0,27},{152,0,31},{133,
+-0,716},{135,0,844},{4,0,91},{5,0,388},{5,0,845},{6,0,206},{6,0,252},{6,0,365},{7
+-,0,136},{7,0,531},{136,0,621},{7,10,393},{10,10,603},{139,10,206},{6,11,80},{6,
+-11,1694},{7,11,173},{7,11,1974},{9,11,547},{10,11,730},{14,11,18},{150,11,39},{
+-137,0,748},{4,11,923},{134,11,1711},{4,10,912},{137,10,232},{7,10,98},{7,10,1973
+-},{136,10,716},{14,0,103},{133,10,733},{132,11,595},{12,0,158},{18,0,8},{19,0,62
+-},{20,0,6},{22,0,4},{23,0,2},{23,0,9},{5,11,240},{6,11,459},{7,11,12},{7,11,114}
+-,{7,11,502},{7,11,1751},{7,11,1753},{7,11,1805},{8,11,658},{9,11,1},{11,11,959},
+-{13,11,446},{142,11,211},{135,0,576},{5,0,771},{5,0,863},{5,0,898},{6,0,648},{6,
+-0,1632},{6,0,1644},{134,0,1780},{133,0,331},{7,11,633},{7,11,905},{7,11,909},{7,
+-11,1538},{9,11,767},{140,11,636},{140,0,632},{5,0,107},{7,0,201},{136,0,518},{6,
+-0,446},{7,0,1817},{134,11,490},{9,0,851},{141,0,510},{7,11,250},{8,11,506},{136,
+-11,507},{4,0,504},{137,10,72},{132,11,158},{4,11,140},{7,11,362},{8,11,209},{9,
+-11,10},{9,11,160},{9,11,503},{10,11,689},{11,11,350},{11,11,553},{11,11,725},{12
+-,11,252},{12,11,583},{13,11,192},{13,11,352},{14,11,269},{14,11,356},{148,11,50}
+-,{6,11,597},{135,11,1318},{135,10,1454},{5,0,883},{5,0,975},{8,0,392},{148,0,7},
+-{6,11,228},{7,11,1341},{9,11,408},{138,11,343},{11,11,348},{11,10,600},{12,11,99
+-},{13,10,245},{18,11,1},{18,11,11},{147,11,4},{134,11,296},{5,0,922},{134,0,1707
+-},{132,11,557},{4,11,548},{7,10,164},{7,10,1571},{9,10,107},{140,10,225},{7,11,
+-197},{8,11,142},{8,11,325},{9,11,150},{9,11,596},{10,11,350},{10,11,353},{11,11,
+-74},{11,11,315},{14,11,423},{143,11,141},{5,0,993},{7,0,515},{137,0,91},{4,0,131
+-},{8,0,200},{5,10,484},{5,10,510},{6,10,434},{7,10,1000},{7,10,1098},{136,10,2},
+-{152,0,10},{4,11,62},{5,11,83},{6,11,399},{6,11,579},{7,11,692},{7,11,846},{7,11
+-,1015},{7,11,1799},{8,11,403},{9,11,394},{10,11,133},{12,11,4},{12,11,297},{12,
+-11,452},{16,11,81},{18,11,19},{18,11,25},{21,11,14},{22,11,12},{151,11,18},{140,
+-11,459},{132,11,177},{7,0,1433},{9,0,365},{137,11,365},{132,10,460},{5,0,103},{6
+-,0,2004},{7,0,921},{8,0,580},{8,0,593},{8,0,630},{10,0,28},{5,11,411},{135,11,
+-653},{4,10,932},{133,10,891},{4,0,911},{5,0,867},{5,0,1013},{7,0,2034},{8,0,798}
+-,{136,0,813},{7,11,439},{10,11,727},{11,11,260},{139,11,684},{136,10,625},{5,11,
+-208},{7,11,753},{135,11,1528},{5,0,461},{7,0,1925},{12,0,39},{13,0,265},{13,0,
+-439},{134,10,76},{6,0,853},{8,10,92},{137,10,221},{5,0,135},{6,0,519},{7,0,1722}
+-,{10,0,271},{11,0,261},{145,0,54},{139,11,814},{14,0,338},{148,0,81},{4,0,300},{
+-133,0,436},{5,0,419},{5,0,687},{7,0,864},{9,0,470},{135,11,864},{9,0,836},{133,
+-11,242},{134,0,1937},{4,10,763},{133,11,953},{132,10,622},{132,0,393},{133,10,
+-253},{8,0,357},{10,0,745},{14,0,426},{17,0,94},{19,0,57},{135,10,546},{5,11,615}
+-,{146,11,37},{9,10,73},{10,10,110},{14,10,185},{145,10,119},{11,0,703},{7,10,624
+-},{7,10,916},{10,10,256},{139,10,87},{133,11,290},{5,10,212},{12,10,35},{141,10,
+-382},{132,11,380},{5,11,52},{7,11,277},{9,11,368},{139,11,791},{133,0,387},{10,
+-11,138},{139,11,476},{4,0,6},{5,0,708},{136,0,75},{7,0,1351},{9,0,581},{10,0,639
+-},{11,0,453},{140,0,584},{132,0,303},{138,0,772},{135,10,1175},{4,0,749},{5,10,
+-816},{6,11,256},{7,11,307},{7,11,999},{7,11,1481},{7,11,1732},{7,11,1738},{8,11,
+-265},{9,11,414},{11,11,316},{12,11,52},{13,11,420},{147,11,100},{135,11,1296},{6
+-,0,1065},{5,10,869},{5,10,968},{6,10,1626},{8,10,734},{136,10,784},{4,10,542},{6
+-,10,1716},{6,10,1727},{7,10,1082},{7,10,1545},{8,10,56},{8,10,118},{8,10,412},{8
+-,10,564},{9,10,888},{9,10,908},{10,10,50},{10,10,423},{11,10,685},{11,10,697},{
+-11,10,933},{12,10,299},{13,10,126},{13,10,136},{13,10,170},{141,10,190},{134,0,
+-226},{4,0,106},{7,0,310},{11,0,717},{133,11,723},{5,0,890},{5,0,988},{4,10,232},
+-{9,10,202},{10,10,474},{140,10,433},{6,0,626},{142,0,431},{10,0,706},{150,0,44},
+-{13,0,51},{6,10,108},{7,10,1003},{7,10,1181},{8,10,111},{136,10,343},{132,0,698}
+-,{5,11,109},{6,11,1784},{7,11,1895},{12,11,296},{140,11,302},{134,0,828},{134,10
+-,1712},{138,0,17},{7,0,1929},{4,10,133},{5,11,216},{7,10,711},{7,10,1298},{7,10,
+-1585},{7,11,1879},{9,11,141},{9,11,270},{9,11,679},{10,11,159},{10,11,553},{11,
+-11,197},{11,11,438},{12,11,538},{12,11,559},{13,11,193},{13,11,423},{14,11,144},
+-{14,11,166},{14,11,167},{15,11,67},{147,11,84},{141,11,127},{7,11,1872},{137,11,
+-81},{6,10,99},{7,10,1808},{145,10,57},{134,11,391},{5,0,689},{6,0,84},{7,0,1250}
+-,{6,10,574},{7,10,428},{10,10,669},{11,10,485},{11,10,840},{12,10,300},{142,10,
+-250},{7,11,322},{136,11,249},{7,11,432},{135,11,1649},{135,10,1871},{137,10,252}
+-,{6,11,155},{140,11,234},{7,0,871},{19,0,27},{147,11,27},{140,0,498},{5,0,986},{
+-6,0,130},{138,0,823},{6,0,1793},{7,0,1582},{8,0,458},{10,0,101},{10,0,318},{10,0
+-,945},{12,0,734},{16,0,104},{18,0,177},{6,10,323},{135,10,1564},{5,11,632},{138,
+-11,526},{10,0,435},{7,10,461},{136,10,775},{6,11,144},{7,11,948},{7,11,1042},{7,
+-11,1857},{8,11,235},{8,11,461},{9,11,453},{9,11,530},{10,11,354},{17,11,77},{19,
+-11,99},{148,11,79},{138,0,966},{7,0,1644},{137,0,129},{135,0,997},{136,0,502},{5
+-,11,196},{6,11,486},{7,11,212},{8,11,309},{136,11,346},{7,10,727},{146,10,73},{
+-132,0,823},{132,11,686},{135,0,1927},{4,0,762},{7,0,1756},{137,0,98},{136,10,577
+-},{24,0,8},{4,11,30},{5,11,43},{152,11,8},{7,0,1046},{139,0,160},{7,0,492},{4,10
+-,413},{5,10,677},{7,11,492},{8,10,432},{140,10,280},{6,0,45},{7,0,433},{8,0,129}
+-,{9,0,21},{10,0,392},{11,0,79},{12,0,499},{13,0,199},{141,0,451},{7,0,558},{136,
+-0,353},{4,11,220},{7,11,1535},{9,11,93},{139,11,474},{7,10,646},{7,10,1730},{11,
+-10,446},{141,10,178},{133,0,785},{134,0,1145},{8,0,81},{9,0,189},{9,0,201},{11,0
+-,478},{11,0,712},{141,0,338},{5,0,353},{151,0,26},{11,0,762},{132,10,395},{134,0
+-,2024},{4,0,611},{133,0,606},{9,10,174},{10,10,164},{11,10,440},{11,10,841},{143
+-,10,98},{134,10,426},{10,10,608},{139,10,1002},{138,10,250},{6,0,25},{7,0,855},{
+-7,0,1258},{144,0,32},{7,11,1725},{138,11,393},{5,11,263},{134,11,414},{6,0,2011}
+-,{133,10,476},{4,0,4},{7,0,1118},{7,0,1320},{7,0,1706},{8,0,277},{9,0,622},{10,0
+-,9},{11,0,724},{12,0,350},{12,0,397},{13,0,28},{13,0,159},{15,0,89},{18,0,5},{19
+-,0,9},{20,0,34},{22,0,47},{6,11,178},{6,11,1750},{8,11,251},{9,11,690},{10,11,
+-155},{10,11,196},{10,11,373},{11,11,698},{13,11,155},{148,11,93},{5,11,97},{137,
+-11,393},{7,0,764},{11,0,461},{12,0,172},{5,10,76},{6,10,458},{6,10,497},{7,10,
+-868},{9,10,658},{10,10,594},{11,10,566},{12,10,338},{141,10,200},{134,0,1449},{
+-138,11,40},{134,11,1639},{134,0,1445},{6,0,1168},{4,10,526},{7,10,1029},{135,10,
+-1054},{4,11,191},{7,11,934},{8,11,647},{145,11,97},{132,10,636},{6,0,233},{7,10,
+-660},{7,10,1124},{17,10,31},{19,10,22},{151,10,14},{6,10,1699},{136,11,110},{12,
+-11,246},{15,11,162},{19,11,64},{20,11,8},{20,11,95},{22,11,24},{152,11,17},{5,11
+-,165},{9,11,346},{138,11,655},{5,11,319},{135,11,534},{134,0,255},{9,0,216},{8,
+-11,128},{139,11,179},{9,0,183},{139,0,286},{11,0,956},{151,0,3},{4,0,536},{7,0,
+-1141},{10,0,723},{139,0,371},{4,10,279},{7,10,301},{137,10,362},{7,0,285},{5,11,
+-57},{6,11,101},{6,11,1663},{7,11,132},{7,11,1048},{7,11,1154},{7,11,1415},{7,11,
+-1507},{12,11,493},{15,11,105},{151,11,15},{5,11,459},{7,11,1073},{7,10,1743},{8,
+-11,241},{136,11,334},{4,10,178},{133,10,399},{135,0,560},{132,0,690},{135,0,1246
+-},{18,0,157},{147,0,63},{10,0,599},{11,0,33},{12,0,571},{149,0,1},{6,11,324},{6,
+-11,520},{7,11,338},{7,11,1616},{7,11,1729},{8,11,228},{9,11,69},{139,11,750},{7,
+-0,1862},{12,0,491},{12,0,520},{13,0,383},{142,0,244},{135,11,734},{134,10,1692},
+-{10,0,448},{11,0,630},{17,0,117},{6,10,202},{7,11,705},{12,10,360},{17,10,118},{
+-18,10,27},{148,10,67},{4,11,73},{6,11,612},{7,11,927},{7,11,1822},{8,11,217},{9,
+-11,472},{9,11,765},{9,11,766},{10,11,408},{11,11,51},{11,11,793},{12,11,266},{15
+-,11,158},{20,11,89},{150,11,32},{4,0,190},{133,0,554},{133,0,1001},{5,11,389},{8
+-,11,636},{137,11,229},{5,0,446},{7,10,872},{10,10,516},{139,10,167},{137,10,313}
+-,{132,10,224},{134,0,1313},{5,10,546},{7,10,35},{8,10,11},{8,10,12},{9,10,315},{
+-9,10,533},{10,10,802},{11,10,166},{12,10,525},{142,10,243},{6,0,636},{137,0,837}
+-,{5,10,241},{8,10,242},{9,10,451},{10,10,667},{11,10,598},{140,10,429},{22,10,46
+-},{150,11,46},{136,11,472},{11,0,278},{142,0,73},{141,11,185},{132,0,868},{134,0
+-,972},{4,10,366},{137,10,516},{138,0,1010},{5,11,189},{6,10,1736},{7,11,442},{7,
+-11,443},{8,11,281},{12,11,174},{13,11,83},{141,11,261},{139,11,384},{6,11,2},{7,
+-11,191},{7,11,446},{7,11,758},{7,11,1262},{7,11,1737},{8,11,22},{8,11,270},{8,11
+-,612},{9,11,4},{9,11,167},{9,11,312},{9,11,436},{10,11,156},{10,11,216},{10,11,
+-311},{10,11,623},{11,11,72},{11,11,330},{11,11,455},{12,11,101},{12,11,321},{12,
+-11,504},{12,11,530},{12,11,543},{13,11,17},{13,11,156},{13,11,334},{14,11,48},{
+-15,11,70},{17,11,60},{148,11,64},{6,10,331},{136,10,623},{135,0,1231},{132,0,304
+-},{6,11,60},{7,11,670},{7,11,1327},{8,11,411},{8,11,435},{9,11,653},{9,11,740},{
+-10,11,385},{11,11,222},{11,11,324},{11,11,829},{140,11,611},{7,0,506},{6,11,166}
+-,{7,11,374},{135,11,1174},{14,11,43},{146,11,21},{135,11,1694},{135,10,1888},{5,
+-11,206},{134,11,398},{135,11,50},{150,0,26},{6,0,53},{6,0,199},{7,0,1408},{8,0,
+-32},{8,0,93},{10,0,397},{10,0,629},{11,0,593},{11,0,763},{13,0,326},{145,0,35},{
+-134,0,105},{132,10,394},{4,0,843},{138,0,794},{11,0,704},{141,0,396},{5,0,114},{
+-5,0,255},{141,0,285},{6,0,619},{7,0,898},{7,0,1092},{8,0,485},{18,0,28},{19,0,
+-116},{135,10,1931},{9,0,145},{7,10,574},{135,10,1719},{7,0,2035},{8,0,19},{9,0,
+-89},{138,0,831},{132,10,658},{6,11,517},{7,11,1159},{10,11,621},{139,11,192},{7,
+-0,1933},{7,11,1933},{9,10,781},{10,10,144},{11,10,385},{13,10,161},{13,10,228},{
+-13,10,268},{148,10,107},{136,10,374},{10,11,223},{139,11,645},{135,0,1728},{7,11
+-,64},{7,11,289},{136,11,245},{4,10,344},{6,10,498},{139,10,323},{136,0,746},{135
+-,10,1063},{137,10,155},{4,0,987},{6,0,1964},{6,0,1974},{6,0,1990},{136,0,995},{
+-133,11,609},{133,10,906},{134,0,1550},{134,0,874},{5,11,129},{6,11,61},{135,11,
+-947},{4,0,1018},{6,0,1938},{6,0,2021},{134,0,2039},{132,0,814},{11,0,126},{139,0
+-,287},{134,0,1264},{5,0,955},{136,0,814},{141,11,506},{132,11,314},{6,0,981},{
+-139,11,1000},{5,0,56},{8,0,892},{8,0,915},{140,0,776},{148,0,100},{10,0,4},{10,0
+-,13},{11,0,638},{148,0,57},{148,11,74},{5,0,738},{132,10,616},{133,11,637},{136,
+-10,692},{133,0,758},{132,10,305},{137,11,590},{5,11,280},{135,11,1226},{134,11,
+-494},{135,0,1112},{133,11,281},{13,0,44},{14,0,214},{5,10,214},{7,10,603},{8,10,
+-611},{9,10,686},{10,10,88},{11,10,459},{11,10,496},{12,10,463},{140,10,590},{139
+-,0,328},{135,11,1064},{137,0,133},{7,0,168},{13,0,196},{141,0,237},{134,10,1703}
+-,{134,0,1152},{135,0,1245},{5,0,110},{6,0,169},{6,0,1702},{7,0,400},{8,0,538},{9
+-,0,184},{9,0,524},{140,0,218},{6,0,1816},{10,0,871},{12,0,769},{140,0,785},{132,
+-11,630},{7,11,33},{7,11,120},{8,11,489},{9,11,319},{10,11,820},{11,11,1004},{12,
+-11,379},{13,11,117},{13,11,412},{14,11,25},{15,11,52},{15,11,161},{16,11,47},{
+-149,11,2},{6,0,133},{8,0,413},{9,0,353},{139,0,993},{145,10,19},{4,11,937},{133,
+-11,801},{134,0,978},{6,0,93},{6,0,1508},{7,0,1422},{7,0,1851},{8,0,673},{9,0,529
+-},{140,0,43},{6,0,317},{10,0,512},{4,10,737},{11,10,294},{12,10,60},{12,10,437},
+-{13,10,64},{13,10,380},{142,10,430},{9,0,371},{7,11,1591},{144,11,43},{6,10,1758
+-},{8,10,520},{9,10,345},{9,10,403},{142,10,350},{5,0,526},{10,10,242},{138,10,
+-579},{9,0,25},{10,0,467},{138,0,559},{5,10,139},{7,10,1168},{138,10,539},{4,0,
+-335},{135,0,942},{140,0,754},{132,11,365},{11,0,182},{142,0,195},{142,11,29},{5,
+-11,7},{139,11,774},{4,11,746},{135,11,1090},{8,0,39},{10,0,773},{11,0,84},{12,0,
+-205},{142,0,1},{5,0,601},{5,0,870},{5,11,360},{136,11,237},{132,0,181},{136,0,
+-370},{134,0,1652},{8,0,358},{4,10,107},{7,10,613},{8,10,439},{8,10,504},{9,10,
+-501},{10,10,383},{139,10,477},{132,10,229},{137,11,785},{4,0,97},{5,0,147},{6,0,
+-286},{7,0,1362},{141,0,176},{6,0,537},{7,0,788},{7,0,1816},{132,10,903},{140,10,
+-71},{6,0,743},{134,0,1223},{6,0,375},{7,0,169},{7,0,254},{8,0,780},{135,11,1493}
+-,{7,0,1714},{4,10,47},{6,10,373},{7,10,452},{7,10,543},{7,10,1856},{9,10,6},{11,
+-10,257},{139,10,391},{6,0,896},{136,0,1003},{135,0,1447},{137,11,341},{5,10,980}
+-,{134,10,1754},{145,11,22},{4,11,277},{5,11,608},{6,11,493},{7,11,457},{140,11,
+-384},{7,10,536},{7,10,1331},{136,10,143},{140,0,744},{7,11,27},{135,11,316},{18,
+-0,126},{5,10,19},{134,10,533},{4,0,788},{11,0,41},{5,11,552},{5,11,586},{5,11,
+-676},{6,11,448},{8,11,244},{11,11,1},{11,11,41},{13,11,3},{16,11,54},{17,11,4},{
+-146,11,13},{4,0,985},{6,0,1801},{4,11,401},{137,11,264},{5,10,395},{5,10,951},{
+-134,10,1776},{5,0,629},{135,0,1549},{11,10,663},{12,10,210},{13,10,166},{13,10,
+-310},{14,10,373},{147,10,43},{9,11,543},{10,11,524},{11,11,30},{12,11,524},{14,
+-11,315},{16,11,18},{20,11,26},{148,11,65},{4,11,205},{5,11,623},{7,11,104},{136,
+-11,519},{5,0,293},{134,0,601},{7,11,579},{9,11,41},{9,11,244},{9,11,669},{10,11,
+-5},{11,11,861},{11,11,951},{139,11,980},{132,11,717},{132,10,695},{7,10,497},{9,
+-10,387},{147,10,81},{132,0,420},{142,0,37},{6,0,1134},{6,0,1900},{12,0,830},{12,
+-0,878},{12,0,894},{15,0,221},{143,0,245},{132,11,489},{7,0,1570},{140,0,542},{8,
+-0,933},{136,0,957},{6,0,1371},{7,0,31},{8,0,373},{5,10,284},{6,10,49},{6,10,350}
+-,{7,10,377},{7,10,1693},{8,10,678},{9,10,161},{9,10,585},{9,10,671},{9,10,839},{
+-11,10,912},{141,10,427},{135,11,892},{4,0,325},{138,0,125},{139,11,47},{132,10,
+-597},{138,0,323},{6,0,1547},{7,11,1605},{9,11,473},{11,11,962},{146,11,139},{139
+-,10,908},{7,11,819},{9,11,26},{9,11,392},{10,11,152},{10,11,226},{11,11,19},{12,
+-11,276},{12,11,426},{12,11,589},{13,11,460},{15,11,97},{19,11,48},{148,11,104},{
+-135,11,51},{4,0,718},{135,0,1216},{6,0,1896},{6,0,1905},{6,0,1912},{9,0,947},{9,
+-0,974},{12,0,809},{12,0,850},{12,0,858},{12,0,874},{12,0,887},{12,0,904},{12,0,
+-929},{12,0,948},{12,0,952},{15,0,198},{15,0,206},{15,0,220},{15,0,227},{15,0,247
+-},{18,0,188},{21,0,48},{21,0,50},{24,0,25},{24,0,29},{7,11,761},{7,11,1051},{137
+-,11,545},{5,0,124},{5,0,144},{6,0,548},{7,0,15},{7,0,153},{137,0,629},{135,11,
+-606},{135,10,2014},{7,10,2007},{9,11,46},{9,10,101},{9,10,450},{10,10,66},{10,10
+-,842},{11,10,536},{140,10,587},{6,0,75},{7,0,1531},{8,0,416},{9,0,240},{9,0,275}
+-,{10,0,100},{11,0,658},{11,0,979},{12,0,86},{14,0,207},{15,0,20},{143,0,25},{5,0
+-,141},{5,0,915},{6,0,1783},{7,0,211},{7,0,698},{7,0,1353},{9,0,83},{9,0,281},{10
+-,0,376},{10,0,431},{11,0,543},{12,0,664},{13,0,280},{13,0,428},{14,0,61},{14,0,
+-128},{17,0,52},{145,0,81},{132,11,674},{135,0,533},{149,0,6},{132,11,770},{133,0
+-,538},{5,11,79},{7,11,1027},{7,11,1477},{139,11,52},{139,10,62},{4,0,338},{133,0
+-,400},{5,11,789},{134,11,195},{4,11,251},{4,11,688},{7,11,513},{7,11,1284},{9,11
+-,87},{138,11,365},{134,10,1766},{6,0,0},{7,0,84},{11,0,895},{145,0,11},{139,0,
+-892},{4,0,221},{5,0,659},{7,0,697},{7,0,1211},{138,0,284},{133,0,989},{133,11,
+-889},{4,11,160},{5,11,330},{7,11,1434},{136,11,174},{6,10,1665},{7,10,256},{7,10
+-,1388},{10,10,499},{139,10,670},{7,0,848},{4,10,22},{5,10,10},{136,10,97},{138,0
+-,507},{133,10,481},{4,0,188},{135,0,805},{5,0,884},{6,0,732},{139,0,991},{135,11
+-,968},{11,11,636},{15,11,145},{17,11,34},{19,11,50},{151,11,20},{7,0,959},{16,0,
+-60},{6,10,134},{7,10,437},{9,10,37},{14,10,285},{142,10,371},{7,10,486},{8,10,
+-155},{11,10,93},{140,10,164},{134,0,1653},{7,0,337},{133,10,591},{6,0,1989},{8,0
+-,922},{8,0,978},{133,11,374},{132,0,638},{138,0,500},{133,11,731},{5,10,380},{5,
+-10,650},{136,10,310},{138,11,381},{4,10,364},{7,10,1156},{7,10,1187},{137,10,409
+-},{137,11,224},{140,0,166},{134,10,482},{4,11,626},{5,11,642},{6,11,425},{10,11,
+-202},{139,11,141},{4,10,781},{6,10,487},{7,10,926},{8,10,263},{139,10,500},{135,
+-0,418},{4,10,94},{135,10,1265},{136,0,760},{132,10,417},{136,11,835},{5,10,348},
+-{134,10,522},{6,0,1277},{134,0,1538},{139,11,541},{135,11,1597},{5,11,384},{8,11
+-,455},{140,11,48},{136,0,770},{5,11,264},{134,11,184},{4,0,89},{5,0,489},{6,0,
+-315},{7,0,553},{7,0,1745},{138,0,243},{4,10,408},{4,10,741},{135,10,500},{134,0,
+-1396},{133,0,560},{6,0,1658},{9,0,3},{10,0,154},{11,0,641},{13,0,85},{13,0,201},
+-{141,0,346},{135,11,1595},{5,11,633},{6,11,28},{7,11,219},{135,11,1323},{9,11,
+-769},{140,11,185},{135,11,785},{7,11,359},{8,11,243},{140,11,175},{138,0,586},{7
+-,0,1271},{134,10,73},{132,11,105},{4,0,166},{5,0,505},{134,0,1670},{133,10,576},
+-{4,11,324},{138,11,104},{142,10,231},{6,0,637},{7,10,1264},{7,10,1678},{11,10,
+-945},{12,10,341},{12,10,471},{12,10,569},{23,11,21},{151,11,23},{8,11,559},{141,
+-11,109},{134,0,1947},{7,0,445},{8,0,307},{8,0,704},{10,0,41},{10,0,439},{11,0,
+-237},{11,0,622},{140,0,201},{135,11,963},{135,0,1977},{4,0,189},{5,0,713},{136,0
+-,57},{138,0,371},{135,10,538},{132,0,552},{6,0,883},{133,10,413},{6,0,923},{132,
+-11,758},{138,11,215},{136,10,495},{7,10,54},{8,10,312},{10,10,191},{10,10,614},{
+-140,10,567},{7,11,351},{139,11,128},{7,0,875},{6,10,468},{7,10,1478},{8,10,530},
+-{142,10,290},{135,0,1788},{17,0,49},{133,11,918},{12,11,398},{20,11,39},{21,11,
+-11},{150,11,41},{10,0,661},{6,10,484},{135,10,822},{135,0,1945},{134,0,794},{137
+-,10,900},{135,10,1335},{6,10,1724},{135,10,2022},{132,11,340},{134,0,1135},{4,0,
+-784},{133,0,745},{5,0,84},{134,0,163},{133,0,410},{4,0,976},{5,11,985},{7,11,509
+-},{7,11,529},{145,11,96},{132,10,474},{134,0,703},{135,11,1919},{5,0,322},{8,0,
+-186},{9,0,262},{10,0,187},{142,0,208},{135,10,1504},{133,0,227},{9,0,560},{13,0,
+-208},{133,10,305},{132,11,247},{7,0,1395},{8,0,486},{9,0,236},{9,0,878},{10,0,
+-218},{11,0,95},{19,0,17},{147,0,31},{7,0,2043},{8,0,672},{141,0,448},{4,11,184},
+-{5,11,390},{6,11,337},{7,11,23},{7,11,494},{7,11,618},{7,11,1456},{8,11,27},{8,
+-11,599},{10,11,153},{139,11,710},{135,0,466},{135,10,1236},{6,0,167},{7,0,186},{
+-7,0,656},{10,0,643},{4,10,480},{6,10,302},{6,10,1642},{7,10,837},{7,10,1547},{7,
+-10,1657},{8,10,429},{9,10,228},{13,10,289},{13,10,343},{147,10,101},{134,0,1428}
+-,{134,0,1440},{5,0,412},{7,10,278},{10,10,739},{11,10,708},{141,10,348},{134,0,
+-1118},{136,0,562},{148,11,46},{9,0,316},{139,0,256},{134,0,1771},{135,0,1190},{
+-137,0,132},{10,11,227},{11,11,497},{11,11,709},{140,11,415},{143,0,66},{6,11,360
+-},{7,11,1664},{136,11,478},{144,10,28},{4,0,317},{135,0,1279},{5,0,63},{133,0,
+-509},{136,11,699},{145,10,36},{134,0,1475},{11,11,343},{142,11,127},{132,11,739}
+-,{132,0,288},{135,11,1757},{8,0,89},{8,0,620},{9,0,608},{11,0,628},{12,0,322},{
+-143,0,124},{134,0,1225},{7,0,1189},{4,11,67},{5,11,422},{6,10,363},{7,11,1037},{
+-7,11,1289},{7,11,1555},{7,10,1955},{8,10,725},{9,11,741},{145,11,108},{134,0,
+-1468},{6,0,689},{134,0,1451},{138,0,120},{151,0,1},{137,10,805},{142,0,329},{5,
+-10,813},{135,10,2046},{135,0,226},{138,11,96},{7,0,1855},{5,10,712},{11,10,17},{
+-13,10,321},{144,10,67},{9,0,461},{6,10,320},{7,10,781},{7,10,1921},{9,10,55},{10
+-,10,186},{10,10,273},{10,10,664},{10,10,801},{11,10,996},{11,10,997},{13,10,157}
+-,{142,10,170},{8,11,203},{8,10,271},{11,11,823},{11,11,846},{12,11,482},{13,11,
+-133},{13,11,277},{13,11,302},{13,11,464},{14,11,205},{142,11,221},{135,0,1346},{
+-4,11,449},{133,11,718},{134,0,85},{14,0,299},{7,10,103},{7,10,863},{11,10,184},{
+-145,10,62},{4,11,355},{6,11,311},{9,11,256},{138,11,404},{137,10,659},{138,11,
+-758},{133,11,827},{5,11,64},{140,11,581},{134,0,1171},{4,11,442},{7,11,1047},{7,
+-11,1352},{135,11,1643},{132,0,980},{5,11,977},{6,11,288},{7,11,528},{135,11,1065
+-},{5,0,279},{6,0,235},{7,0,468},{8,0,446},{9,0,637},{10,0,717},{11,0,738},{140,0
+-,514},{132,0,293},{11,10,337},{142,10,303},{136,11,285},{5,0,17},{6,0,371},{9,0,
+-528},{12,0,364},{132,11,254},{5,10,77},{7,10,1455},{10,10,843},{147,10,73},{150,
+-0,5},{132,10,458},{6,11,12},{7,11,1219},{145,11,73},{135,10,1420},{6,10,109},{
+-138,10,382},{135,11,125},{6,10,330},{7,10,1084},{139,10,142},{6,11,369},{6,11,
+-502},{7,11,1036},{8,11,348},{9,11,452},{10,11,26},{11,11,224},{11,11,387},{11,11
+-,772},{12,11,95},{12,11,629},{13,11,195},{13,11,207},{13,11,241},{14,11,260},{14
+-,11,270},{143,11,140},{132,11,269},{5,11,480},{7,11,532},{7,11,1197},{7,11,1358}
+-,{8,11,291},{11,11,349},{142,11,396},{150,0,48},{10,0,601},{13,0,353},{141,0,376
+-},{5,0,779},{5,0,807},{6,0,1655},{134,0,1676},{142,11,223},{4,0,196},{5,0,558},{
+-133,0,949},{148,11,15},{135,11,1764},{134,0,1322},{132,0,752},{139,0,737},{135,
+-11,657},{136,11,533},{135,0,412},{4,0,227},{5,0,159},{5,0,409},{7,0,80},{8,0,556
+-},{10,0,479},{12,0,418},{14,0,50},{14,0,123},{14,0,192},{14,0,249},{14,0,295},{
+-143,0,27},{7,0,1470},{8,0,66},{8,0,137},{8,0,761},{9,0,638},{11,0,80},{11,0,212}
+-,{11,0,368},{11,0,418},{12,0,8},{13,0,15},{16,0,61},{17,0,59},{19,0,28},{148,0,
+-84},{135,10,1985},{4,11,211},{4,11,332},{5,11,335},{6,11,238},{7,11,269},{7,11,
+-811},{7,11,1797},{8,10,122},{8,11,836},{9,11,507},{141,11,242},{6,0,683},{134,0,
+-1252},{4,0,873},{132,10,234},{134,0,835},{6,0,38},{7,0,1220},{8,0,185},{8,0,256}
+-,{9,0,22},{9,0,331},{10,0,738},{11,0,205},{11,0,540},{11,0,746},{13,0,465},{14,0
+-,88},{142,0,194},{138,0,986},{5,11,1009},{12,11,582},{146,11,131},{4,0,159},{6,0
+-,115},{7,0,252},{7,0,257},{7,0,1928},{8,0,69},{9,0,384},{10,0,91},{10,0,615},{12
+-,0,375},{14,0,235},{18,0,117},{147,0,123},{133,0,911},{136,0,278},{5,10,430},{5,
+-10,932},{6,10,131},{7,10,417},{9,10,522},{11,10,314},{141,10,390},{14,10,149},{
+-14,10,399},{143,10,57},{4,0,151},{7,0,1567},{136,0,749},{5,11,228},{6,11,203},{7
+-,11,156},{8,11,347},{137,11,265},{132,10,507},{10,0,989},{140,0,956},{133,0,990}
+-,{5,0,194},{6,0,927},{7,0,1662},{9,0,90},{140,0,564},{4,10,343},{133,10,511},{
+-133,0,425},{7,10,455},{138,10,591},{4,0,774},{7,11,476},{7,11,1592},{138,11,87},
+-{5,0,971},{135,10,1381},{5,11,318},{147,11,121},{5,11,291},{7,11,765},{9,11,389}
+-,{140,11,548},{134,10,575},{4,0,827},{12,0,646},{12,0,705},{12,0,712},{140,0,714
+-},{139,0,752},{137,0,662},{5,0,72},{6,0,264},{7,0,21},{7,0,46},{7,0,2013},{8,0,
+-215},{8,0,513},{10,0,266},{139,0,22},{139,11,522},{6,0,239},{7,0,118},{10,0,95},
+-{11,0,603},{13,0,443},{14,0,160},{143,0,4},{6,0,431},{134,0,669},{7,10,1127},{7,
+-10,1572},{10,10,297},{10,10,422},{11,10,764},{11,10,810},{12,10,264},{13,10,102}
+-,{13,10,300},{13,10,484},{14,10,147},{14,10,229},{17,10,71},{18,10,118},{147,10,
+-120},{5,0,874},{6,0,1677},{15,0,0},{10,11,525},{139,11,82},{6,0,65},{7,0,939},{7
+-,0,1172},{7,0,1671},{9,0,540},{10,0,696},{11,0,265},{11,0,732},{11,0,928},{11,0,
+-937},{141,0,438},{134,0,1350},{136,11,547},{132,11,422},{5,11,355},{145,11,0},{
+-137,11,905},{5,0,682},{135,0,1887},{132,0,809},{4,0,696},{133,11,865},{6,0,1074}
+-,{6,0,1472},{14,10,35},{142,10,191},{5,11,914},{134,11,1625},{133,11,234},{135,
+-11,1383},{137,11,780},{132,10,125},{4,0,726},{133,0,630},{8,0,802},{136,0,838},{
+-132,10,721},{6,0,1337},{7,0,776},{19,0,56},{136,10,145},{132,0,970},{7,10,792},{
+-8,10,147},{10,10,821},{139,10,1021},{139,10,970},{8,0,940},{137,0,797},{135,11,
+-1312},{9,0,248},{10,0,400},{7,11,816},{7,11,1241},{7,10,1999},{9,11,283},{9,11,
+-520},{10,11,213},{10,11,307},{10,11,463},{10,11,671},{10,11,746},{11,11,401},{11
+-,11,794},{12,11,517},{18,11,107},{147,11,115},{6,0,1951},{134,0,2040},{135,11,
+-339},{13,0,41},{15,0,93},{5,10,168},{5,10,930},{8,10,74},{9,10,623},{12,10,500},
+-{140,10,579},{6,0,118},{7,0,215},{7,0,1521},{140,0,11},{6,10,220},{7,10,1101},{
+-141,10,105},{6,11,421},{7,11,61},{7,11,1540},{10,11,11},{138,11,501},{7,0,615},{
+-138,0,251},{140,11,631},{135,0,1044},{6,10,19},{7,10,1413},{139,10,428},{133,0,
+-225},{7,10,96},{8,10,401},{8,10,703},{137,10,896},{145,10,116},{6,11,102},{7,11,
+-72},{15,11,142},{147,11,67},{7,10,1961},{7,10,1965},{8,10,702},{136,10,750},{7,
+-10,2030},{8,10,150},{8,10,737},{12,10,366},{151,11,30},{4,0,370},{5,0,756},{7,0,
+-1326},{135,11,823},{8,10,800},{9,10,148},{9,10,872},{9,10,890},{11,10,309},{11,
+-10,1001},{13,10,267},{141,10,323},{6,0,1662},{7,0,48},{8,0,771},{10,0,116},{13,0
+-,104},{14,0,105},{14,0,184},{15,0,168},{19,0,92},{148,0,68},{10,0,209},{135,11,
+-1870},{7,11,68},{8,11,48},{8,11,88},{8,11,582},{8,11,681},{9,11,373},{9,11,864},
+-{11,11,157},{11,11,336},{11,11,843},{148,11,27},{134,0,930},{4,11,88},{5,11,137}
+-,{5,11,174},{5,11,777},{6,11,1664},{6,11,1725},{7,11,77},{7,11,426},{7,11,1317},
+-{7,11,1355},{8,11,126},{8,11,563},{9,11,523},{9,11,750},{10,11,310},{10,11,836},
+-{11,11,42},{11,11,318},{11,11,731},{12,11,68},{12,11,92},{12,11,507},{12,11,692}
+-,{13,11,81},{13,11,238},{13,11,374},{18,11,138},{19,11,78},{19,11,111},{20,11,55
+-},{20,11,77},{148,11,92},{4,11,938},{135,11,1831},{5,10,547},{7,10,424},{8,11,
+-617},{138,11,351},{6,0,1286},{6,11,1668},{7,11,1499},{8,11,117},{9,11,314},{138,
+-11,174},{6,0,759},{6,0,894},{7,11,707},{139,11,563},{4,0,120},{135,0,1894},{9,0,
+-385},{149,0,17},{138,0,429},{133,11,403},{5,0,820},{135,0,931},{10,0,199},{133,
+-10,133},{6,0,151},{6,0,1675},{7,0,383},{151,0,10},{6,0,761},{136,10,187},{8,0,
+-365},{10,10,0},{10,10,818},{139,10,988},{4,11,44},{5,11,311},{6,11,156},{7,11,
+-639},{7,11,762},{7,11,1827},{9,11,8},{9,11,462},{148,11,83},{4,11,346},{7,11,115
+-},{9,11,180},{9,11,456},{138,11,363},{136,10,685},{7,0,1086},{145,0,46},{6,0,
+-1624},{11,0,11},{12,0,422},{13,0,444},{142,0,360},{6,0,1020},{6,0,1260},{134,0,
+-1589},{4,0,43},{5,0,344},{5,0,357},{14,0,472},{150,0,58},{6,0,1864},{6,0,1866},{
+-6,0,1868},{6,0,1869},{6,0,1874},{6,0,1877},{6,0,1903},{6,0,1911},{9,0,920},{9,0,
+-921},{9,0,924},{9,0,946},{9,0,959},{9,0,963},{9,0,970},{9,0,997},{9,0,1008},{9,0
+-,1017},{12,0,795},{12,0,797},{12,0,798},{12,0,800},{12,0,803},{12,0,811},{12,0,
+-820},{12,0,821},{12,0,839},{12,0,841},{12,0,848},{12,0,911},{12,0,921},{12,0,922
+-},{12,0,925},{12,0,937},{12,0,944},{12,0,945},{12,0,953},{15,0,184},{15,0,191},{
+-15,0,199},{15,0,237},{15,0,240},{15,0,243},{15,0,246},{18,0,203},{21,0,40},{21,0
+-,52},{21,0,57},{24,0,23},{24,0,28},{152,0,30},{134,0,725},{145,11,58},{133,0,888
+-},{137,10,874},{4,0,711},{8,10,774},{10,10,670},{140,10,51},{144,11,40},{6,11,
+-185},{7,11,1899},{139,11,673},{137,10,701},{137,0,440},{4,11,327},{5,11,478},{7,
+-11,1332},{8,11,753},{140,11,227},{4,10,127},{5,10,350},{6,10,356},{8,10,426},{9,
+-10,572},{10,10,247},{139,10,312},{5,11,1020},{133,11,1022},{4,11,103},{133,11,
+-401},{6,0,1913},{6,0,1926},{6,0,1959},{9,0,914},{9,0,939},{9,0,952},{9,0,979},{9
+-,0,990},{9,0,998},{9,0,1003},{9,0,1023},{12,0,827},{12,0,834},{12,0,845},{12,0,
+-912},{12,0,935},{12,0,951},{15,0,172},{15,0,174},{18,0,198},{149,0,63},{5,0,958}
+-,{5,0,987},{4,11,499},{135,11,1421},{7,0,885},{6,10,59},{6,10,1762},{9,10,603},{
+-141,10,397},{10,11,62},{141,11,164},{4,0,847},{135,0,326},{11,0,276},{142,0,293}
+-,{4,0,65},{5,0,479},{5,0,1004},{7,0,1913},{8,0,317},{9,0,302},{10,0,612},{13,0,
+-22},{132,11,96},{4,0,261},{135,0,510},{135,0,1514},{6,10,111},{7,10,4},{8,10,163
+-},{8,10,776},{138,10,566},{4,0,291},{9,0,515},{12,0,152},{12,0,443},{13,0,392},{
+-142,0,357},{7,11,399},{135,11,1492},{4,0,589},{139,0,282},{6,11,563},{135,10,
+-1994},{5,10,297},{135,10,1038},{4,0,130},{7,0,843},{135,0,1562},{5,0,42},{5,0,
+-879},{7,0,245},{7,0,324},{7,0,1532},{11,0,463},{11,0,472},{13,0,363},{144,0,52},
+-{4,0,134},{133,0,372},{133,0,680},{136,10,363},{6,0,1997},{8,0,935},{136,0,977},
+-{4,0,810},{135,0,1634},{135,10,1675},{7,0,1390},{4,11,910},{133,11,832},{7,10,
+-808},{8,11,266},{139,11,578},{132,0,644},{4,0,982},{138,0,867},{132,10,280},{135
+-,0,540},{140,10,54},{135,0,123},{134,0,1978},{4,10,421},{133,10,548},{6,0,623},{
+-136,0,789},{4,0,908},{5,0,359},{5,0,508},{6,0,1723},{7,0,343},{7,0,1996},{135,0,
+-2026},{134,0,1220},{4,0,341},{135,0,480},{6,10,254},{9,10,109},{138,10,103},{134
+-,0,888},{8,11,528},{137,11,348},{7,0,1995},{8,0,299},{11,0,890},{12,0,674},{4,11
+-,20},{133,11,616},{135,11,1094},{134,10,1630},{4,0,238},{5,0,503},{6,0,179},{7,0
+-,2003},{8,0,381},{8,0,473},{9,0,149},{10,0,788},{15,0,45},{15,0,86},{20,0,110},{
+-150,0,57},{133,10,671},{4,11,26},{5,11,429},{6,11,245},{7,11,704},{7,11,1379},{
+-135,11,1474},{4,0,121},{5,0,156},{5,0,349},{9,0,431},{10,0,605},{142,0,342},{7,
+-11,943},{139,11,614},{132,10,889},{132,11,621},{7,10,1382},{7,11,1382},{135,10,
+-1910},{132,10,627},{133,10,775},{133,11,542},{133,11,868},{136,11,433},{6,0,1373
+-},{7,0,1011},{11,10,362},{11,10,948},{140,10,388},{6,0,80},{7,0,173},{9,0,547},{
+-10,0,730},{14,0,18},{22,0,39},{135,11,1495},{6,0,1694},{135,0,1974},{140,0,196},
+-{4,0,923},{6,0,507},{6,0,1711},{7,10,451},{8,10,389},{12,10,490},{13,10,16},{13,
+-10,215},{13,10,351},{18,10,132},{147,10,125},{6,0,646},{134,0,1047},{135,10,841}
+-,{136,10,566},{6,0,1611},{135,0,1214},{139,0,926},{132,11,525},{132,0,595},{5,0,
+-240},{6,0,459},{7,0,12},{7,0,114},{7,0,949},{7,0,1753},{7,0,1805},{8,0,658},{9,0
+-,1},{11,0,959},{141,0,446},{5,10,912},{134,10,1695},{132,0,446},{7,11,62},{12,11
+-,45},{147,11,112},{5,10,236},{6,10,572},{8,10,492},{11,10,618},{144,10,56},{5,10
+-,190},{136,10,318},{135,10,1376},{4,11,223},{6,11,359},{11,11,3},{13,11,108},{14
+-,11,89},{144,11,22},{132,11,647},{134,0,490},{134,0,491},{134,0,1584},{135,11,
+-685},{138,11,220},{7,0,250},{136,0,507},{132,0,158},{4,0,140},{7,0,362},{8,0,209
+-},{9,0,10},{9,0,160},{9,0,503},{9,0,614},{10,0,689},{11,0,327},{11,0,553},{11,0,
+-725},{11,0,767},{12,0,252},{12,0,583},{13,0,192},{14,0,269},{14,0,356},{148,0,50
+-},{19,0,1},{19,0,26},{150,0,9},{132,11,109},{6,0,228},{7,0,1341},{9,0,408},{138,
+-0,343},{4,0,373},{5,0,283},{6,0,480},{7,0,609},{10,0,860},{138,0,878},{6,0,779},
+-{134,0,1209},{4,0,557},{7,11,263},{7,11,628},{136,11,349},{132,0,548},{7,0,197},
+-{8,0,142},{8,0,325},{9,0,150},{9,0,596},{10,0,350},{10,0,353},{11,0,74},{11,0,
+-315},{12,0,662},{12,0,681},{14,0,423},{143,0,141},{4,11,40},{10,11,67},{11,11,
+-117},{11,11,768},{139,11,935},{7,11,992},{8,11,301},{9,11,722},{12,11,63},{13,11
+-,29},{14,11,161},{143,11,18},{6,0,1490},{138,11,532},{5,0,580},{7,0,378},{7,0,
+-674},{7,0,1424},{15,0,83},{16,0,11},{15,11,83},{144,11,11},{6,0,1057},{6,0,1335}
+-,{10,0,316},{7,10,85},{7,10,247},{8,10,585},{138,10,163},{4,0,169},{5,0,83},{6,0
+-,399},{6,0,579},{6,0,1513},{7,0,692},{7,0,846},{7,0,1015},{7,0,1799},{8,0,403},{
+-9,0,394},{10,0,133},{12,0,4},{12,0,297},{12,0,452},{16,0,81},{18,0,25},{21,0,14}
+-,{22,0,12},{151,0,18},{134,0,1106},{7,0,1546},{11,0,299},{142,0,407},{134,0,1192
+-},{132,0,177},{5,0,411},{135,0,653},{7,0,439},{10,0,727},{11,0,260},{139,0,684},
+-{138,10,145},{147,10,83},{5,0,208},{7,0,753},{135,0,1528},{137,11,617},{135,10,
+-1922},{135,11,825},{11,0,422},{13,0,389},{4,10,124},{10,10,457},{11,10,121},{11,
+-10,169},{11,10,870},{12,10,214},{14,10,187},{143,10,77},{11,0,615},{15,0,58},{11
+-,11,615},{143,11,58},{9,0,618},{138,0,482},{6,0,1952},{6,0,1970},{142,0,505},{7,
+-10,1193},{135,11,1838},{133,0,242},{135,10,1333},{6,10,107},{7,10,638},{7,10,
+-1632},{137,10,396},{133,0,953},{5,10,370},{134,10,1756},{5,11,28},{6,11,204},{10
+-,11,320},{10,11,583},{13,11,502},{14,11,72},{14,11,274},{14,11,312},{14,11,344},
+-{15,11,159},{16,11,62},{16,11,69},{17,11,30},{18,11,42},{18,11,53},{18,11,84},{
+-18,11,140},{19,11,68},{19,11,85},{20,11,5},{20,11,45},{20,11,101},{22,11,7},{150
+-,11,20},{4,11,558},{6,11,390},{7,11,162},{7,11,689},{9,11,360},{138,11,653},{11,
+-0,802},{141,0,67},{133,10,204},{133,0,290},{5,10,970},{134,10,1706},{132,0,380},
+-{5,0,52},{7,0,277},{9,0,368},{139,0,791},{5,11,856},{6,11,1672},{6,11,1757},{6,
+-11,1781},{7,11,1150},{7,11,1425},{7,11,1453},{140,11,513},{5,11,92},{7,10,3},{10
+-,11,736},{140,11,102},{4,0,112},{5,0,653},{5,10,483},{5,10,685},{6,10,489},{7,10
+-,1204},{136,10,394},{132,10,921},{6,0,1028},{133,10,1007},{5,11,590},{9,11,213},
+-{145,11,91},{135,10,1696},{10,0,138},{139,0,476},{5,0,725},{5,0,727},{135,0,1811
+-},{4,0,979},{6,0,1821},{6,0,1838},{8,0,876},{8,0,883},{8,0,889},{8,0,893},{8,0,
+-895},{10,0,934},{12,0,720},{14,0,459},{148,0,123},{135,11,551},{4,0,38},{6,0,435
+-},{7,0,307},{7,0,999},{7,0,1481},{7,0,1732},{7,0,1738},{8,0,371},{9,0,414},{11,0
+-,316},{12,0,52},{13,0,420},{147,0,100},{135,0,1296},{132,10,712},{134,10,1629},{
+-133,0,723},{134,0,651},{136,11,191},{9,11,791},{10,11,93},{11,11,301},{16,11,13}
+-,{17,11,23},{18,11,135},{19,11,12},{20,11,1},{20,11,12},{148,11,14},{136,11,503}
+-,{6,11,466},{135,11,671},{6,0,1200},{134,0,1330},{135,0,1255},{134,0,986},{5,0,
+-109},{6,0,1784},{7,0,1895},{12,0,296},{140,0,302},{135,11,983},{133,10,485},{134
+-,0,660},{134,0,800},{5,0,216},{5,0,294},{6,0,591},{7,0,1879},{9,0,141},{9,0,270}
+-,{9,0,679},{10,0,159},{11,0,197},{11,0,438},{12,0,538},{12,0,559},{14,0,144},{14
+-,0,167},{15,0,67},{4,10,285},{5,10,317},{6,10,301},{7,10,7},{8,10,153},{10,10,
+-766},{11,10,468},{12,10,467},{141,10,143},{136,0,945},{134,0,1090},{137,0,81},{
+-12,11,468},{19,11,96},{148,11,24},{134,0,391},{138,11,241},{7,0,322},{136,0,249}
+-,{134,0,1412},{135,11,795},{5,0,632},{138,0,526},{136,10,819},{6,0,144},{7,0,948
+-},{7,0,1042},{8,0,235},{8,0,461},{9,0,453},{9,0,796},{10,0,354},{17,0,77},{135,
+-11,954},{139,10,917},{6,0,940},{134,0,1228},{4,0,362},{7,0,52},{135,0,303},{6,11
+-,549},{8,11,34},{8,11,283},{9,11,165},{138,11,475},{7,11,370},{7,11,1007},{7,11,
+-1177},{135,11,1565},{5,11,652},{5,11,701},{135,11,449},{5,0,196},{6,0,486},{7,0,
+-212},{8,0,309},{136,0,346},{6,10,1719},{6,10,1735},{7,10,2016},{7,10,2020},{8,10
+-,837},{137,10,852},{6,11,159},{6,11,364},{7,11,516},{7,11,1439},{137,11,518},{
+-135,0,1912},{135,0,1290},{132,0,686},{141,11,151},{138,0,625},{136,0,706},{138,
+-10,568},{139,0,412},{4,0,30},{133,0,43},{8,10,67},{138,10,419},{7,0,967},{141,0,
+-11},{12,0,758},{14,0,441},{142,0,462},{10,10,657},{14,10,297},{142,10,361},{139,
+-10,729},{4,0,220},{135,0,1535},{7,11,501},{9,11,111},{10,11,141},{11,11,332},{13
+-,11,43},{13,11,429},{14,11,130},{14,11,415},{145,11,102},{4,0,950},{6,0,1859},{7
+-,0,11},{8,0,873},{12,0,710},{12,0,718},{12,0,748},{12,0,765},{148,0,124},{5,11,
+-149},{5,11,935},{136,11,233},{142,11,291},{134,0,1579},{7,0,890},{8,10,51},{9,10
+-,868},{10,10,833},{12,10,481},{12,10,570},{148,10,106},{141,0,2},{132,10,445},{
+-136,11,801},{135,0,1774},{7,0,1725},{138,0,393},{5,0,263},{134,0,414},{132,11,
+-322},{133,10,239},{7,0,456},{7,10,1990},{8,10,130},{139,10,720},{137,0,818},{5,
+-10,123},{6,10,530},{7,10,348},{135,10,1419},{135,10,2024},{6,0,178},{6,0,1750},{
+-8,0,251},{9,0,690},{10,0,155},{10,0,196},{10,0,373},{11,0,698},{13,0,155},{148,0
+-,93},{5,0,97},{137,0,393},{134,0,674},{11,0,223},{140,0,168},{132,10,210},{139,
+-11,464},{6,0,1639},{146,0,159},{139,11,2},{7,0,934},{8,0,647},{17,0,97},{19,0,59
+-},{150,0,2},{132,0,191},{5,0,165},{9,0,346},{10,0,655},{11,0,885},{4,10,430},{
+-135,11,357},{133,0,877},{5,10,213},{133,11,406},{8,0,128},{139,0,179},{6,11,69},
+-{135,11,117},{135,0,1297},{11,11,43},{13,11,72},{141,11,142},{135,11,1830},{142,
+-0,164},{5,0,57},{6,0,101},{6,0,586},{6,0,1663},{7,0,132},{7,0,1154},{7,0,1415},{
+-7,0,1507},{12,0,493},{15,0,105},{151,0,15},{5,0,459},{7,0,1073},{8,0,241},{136,0
+-,334},{133,11,826},{133,10,108},{5,10,219},{10,11,132},{11,11,191},{11,11,358},{
+-139,11,460},{6,0,324},{6,0,520},{7,0,338},{7,0,1729},{8,0,228},{139,0,750},{21,0
+-,30},{22,0,53},{4,10,193},{5,10,916},{7,10,364},{10,10,398},{10,10,726},{11,10,
+-317},{11,10,626},{12,10,142},{12,10,288},{12,10,678},{13,10,313},{15,10,113},{
+-146,10,114},{6,11,110},{135,11,1681},{135,0,910},{6,10,241},{7,10,907},{8,10,832
+-},{9,10,342},{10,10,729},{11,10,284},{11,10,445},{11,10,651},{11,10,863},{13,10,
+-398},{146,10,99},{7,0,705},{9,0,734},{5,11,1000},{7,11,733},{137,11,583},{4,0,73
+-},{6,0,612},{7,0,927},{7,0,1822},{8,0,217},{9,0,765},{9,0,766},{10,0,408},{11,0,
+-51},{11,0,793},{12,0,266},{15,0,158},{20,0,89},{150,0,32},{7,0,1330},{4,11,297},
+-{6,11,529},{7,11,152},{7,11,713},{7,11,1845},{8,11,710},{8,11,717},{140,11,639},
+-{5,0,389},{136,0,636},{134,0,1409},{4,10,562},{9,10,254},{139,10,879},{134,0,893
+-},{132,10,786},{4,11,520},{135,11,575},{136,0,21},{140,0,721},{136,0,959},{7,11,
+-1428},{7,11,1640},{9,11,169},{9,11,182},{9,11,367},{9,11,478},{9,11,506},{9,11,
+-551},{9,11,648},{9,11,651},{9,11,697},{9,11,705},{9,11,725},{9,11,787},{9,11,794
+-},{10,11,198},{10,11,214},{10,11,267},{10,11,275},{10,11,456},{10,11,551},{10,11
+-,561},{10,11,613},{10,11,627},{10,11,668},{10,11,675},{10,11,691},{10,11,695},{
+-10,11,707},{10,11,715},{11,11,183},{11,11,201},{11,11,244},{11,11,262},{11,11,
+-352},{11,11,439},{11,11,493},{11,11,572},{11,11,591},{11,11,608},{11,11,611},{11
+-,11,646},{11,11,674},{11,11,711},{11,11,751},{11,11,761},{11,11,776},{11,11,785}
+-,{11,11,850},{11,11,853},{11,11,862},{11,11,865},{11,11,868},{11,11,898},{11,11,
+-902},{11,11,903},{11,11,910},{11,11,932},{11,11,942},{11,11,957},{11,11,967},{11
+-,11,972},{12,11,148},{12,11,195},{12,11,220},{12,11,237},{12,11,318},{12,11,339}
+-,{12,11,393},{12,11,445},{12,11,450},{12,11,474},{12,11,509},{12,11,533},{12,11,
+-591},{12,11,594},{12,11,597},{12,11,621},{12,11,633},{12,11,642},{13,11,59},{13,
+-11,60},{13,11,145},{13,11,239},{13,11,250},{13,11,273},{13,11,329},{13,11,344},{
+-13,11,365},{13,11,372},{13,11,387},{13,11,403},{13,11,414},{13,11,456},{13,11,
+-478},{13,11,483},{13,11,489},{14,11,55},{14,11,57},{14,11,81},{14,11,90},{14,11,
+-148},{14,11,239},{14,11,266},{14,11,321},{14,11,326},{14,11,327},{14,11,330},{14
+-,11,347},{14,11,355},{14,11,401},{14,11,411},{14,11,414},{14,11,416},{14,11,420}
+-,{15,11,61},{15,11,74},{15,11,87},{15,11,88},{15,11,94},{15,11,96},{15,11,116},{
+-15,11,149},{15,11,154},{16,11,50},{16,11,63},{16,11,73},{17,11,2},{17,11,66},{17
+-,11,92},{17,11,103},{17,11,112},{18,11,50},{18,11,54},{18,11,82},{18,11,86},{18,
+-11,90},{18,11,111},{18,11,115},{18,11,156},{19,11,40},{19,11,79},{20,11,78},{149
+-,11,22},{137,11,170},{134,0,1433},{135,11,1307},{139,11,411},{5,0,189},{7,0,442}
+-,{7,0,443},{8,0,281},{12,0,174},{141,0,261},{6,10,216},{7,10,901},{7,10,1343},{
+-136,10,493},{5,11,397},{6,11,154},{7,10,341},{7,11,676},{8,11,443},{8,11,609},{9
+-,11,24},{9,11,325},{10,11,35},{11,10,219},{11,11,535},{11,11,672},{11,11,1018},{
+-12,11,637},{144,11,30},{6,0,2},{7,0,191},{7,0,446},{7,0,1262},{7,0,1737},{8,0,22
+-},{8,0,270},{8,0,612},{9,0,4},{9,0,312},{9,0,436},{9,0,626},{10,0,216},{10,0,311
+-},{10,0,521},{10,0,623},{11,0,72},{11,0,330},{11,0,455},{12,0,321},{12,0,504},{
+-12,0,530},{12,0,543},{13,0,17},{13,0,156},{13,0,334},{14,0,131},{17,0,60},{148,0
+-,64},{7,0,354},{10,0,410},{139,0,815},{139,10,130},{7,10,1734},{137,11,631},{12,
+-0,425},{15,0,112},{10,10,115},{11,10,420},{13,10,404},{14,10,346},{143,10,54},{6
+-,0,60},{6,0,166},{7,0,374},{7,0,670},{7,0,1327},{8,0,411},{8,0,435},{9,0,653},{9
+-,0,740},{10,0,385},{11,0,222},{11,0,324},{11,0,829},{140,0,611},{7,0,1611},{13,0
+-,14},{15,0,44},{19,0,13},{148,0,76},{133,11,981},{4,11,56},{7,11,1791},{8,11,607
+-},{8,11,651},{11,11,465},{11,11,835},{12,11,337},{141,11,480},{6,0,1478},{5,10,
+-1011},{136,10,701},{139,0,596},{5,0,206},{134,0,398},{4,10,54},{5,10,666},{7,10,
+-1039},{7,10,1130},{9,10,195},{138,10,302},{7,0,50},{9,11,158},{138,11,411},{135,
+-11,1120},{6,0,517},{7,0,1159},{10,0,621},{11,0,192},{134,10,1669},{4,0,592},{6,0
+-,600},{135,0,1653},{10,0,223},{139,0,645},{136,11,139},{7,0,64},{136,0,245},{142
+-,0,278},{6,11,622},{135,11,1030},{136,0,604},{134,0,1502},{138,0,265},{141,11,
+-168},{7,0,1763},{140,0,310},{7,10,798},{139,11,719},{7,11,160},{10,11,624},{142,
+-11,279},{132,11,363},{7,10,122},{9,10,259},{10,10,84},{11,10,470},{12,10,541},{
+-141,10,379},{5,0,129},{6,0,61},{135,0,947},{134,0,1356},{135,11,1191},{13,0,505}
+-,{141,0,506},{11,0,1000},{5,10,82},{5,10,131},{7,10,1755},{8,10,31},{9,10,168},{
+-9,10,764},{139,10,869},{134,0,966},{134,10,605},{134,11,292},{5,11,177},{6,11,
+-616},{7,11,827},{9,11,525},{138,11,656},{135,11,1486},{138,11,31},{5,10,278},{
+-137,10,68},{4,10,163},{5,10,201},{5,10,307},{5,10,310},{6,10,335},{7,10,284},{
+-136,10,165},{6,0,839},{135,10,1660},{136,10,781},{6,10,33},{135,10,1244},{133,0,
+-637},{4,11,161},{133,11,631},{137,0,590},{7,10,1953},{136,10,720},{5,0,280},{7,0
+-,1226},{138,10,203},{134,0,1386},{5,0,281},{6,0,1026},{6,10,326},{7,10,677},{137
+-,10,425},{7,11,1557},{135,11,1684},{135,0,1064},{9,11,469},{9,11,709},{12,11,512
+-},{14,11,65},{145,11,12},{134,0,917},{10,11,229},{11,11,73},{11,11,376},{139,11,
+-433},{7,0,555},{9,0,192},{13,0,30},{13,0,49},{15,0,150},{16,0,76},{20,0,52},{7,
+-10,1316},{7,10,1412},{7,10,1839},{9,10,589},{11,10,241},{11,10,676},{11,10,811},
+-{11,10,891},{12,10,140},{12,10,346},{12,10,479},{13,10,381},{14,10,188},{146,10,
+-30},{149,0,15},{6,0,1882},{6,0,1883},{6,0,1897},{9,0,945},{9,0,1014},{9,0,1020},
+-{12,0,823},{12,0,842},{12,0,866},{12,0,934},{15,0,242},{146,0,208},{6,0,965},{
+-134,0,1499},{7,0,33},{7,0,120},{8,0,489},{9,0,319},{10,0,820},{11,0,1004},{12,0,
+-379},{12,0,679},{13,0,117},{13,0,412},{14,0,25},{15,0,52},{15,0,161},{16,0,47},{
+-149,0,2},{6,11,558},{7,11,651},{8,11,421},{9,11,0},{138,11,34},{4,0,937},{5,0,
+-801},{7,0,473},{5,10,358},{7,10,1184},{10,10,662},{13,10,212},{13,10,304},{13,10
+-,333},{145,10,98},{132,0,877},{6,0,693},{134,0,824},{132,0,365},{7,11,1832},{138
+-,11,374},{5,0,7},{139,0,774},{4,0,734},{5,0,662},{134,0,430},{4,0,746},{135,0,
+-1090},{5,0,360},{8,0,237},{10,0,231},{147,0,124},{138,11,348},{6,11,6},{7,11,81}
+-,{7,11,771},{7,11,1731},{9,11,405},{138,11,421},{6,0,740},{137,0,822},{133,10,
+-946},{7,0,1485},{136,0,929},{7,10,411},{8,10,631},{9,10,323},{10,10,355},{11,10,
+-491},{12,10,143},{12,10,402},{13,10,73},{14,10,408},{15,10,107},{146,10,71},{135
+-,10,590},{5,11,881},{133,11,885},{150,11,25},{4,0,852},{5,11,142},{134,11,546},{
+-7,10,1467},{8,10,328},{10,10,544},{11,10,955},{13,10,320},{145,10,83},{9,0,17},{
+-10,0,291},{11,10,511},{13,10,394},{14,10,298},{14,10,318},{146,10,103},{5,11,466
+-},{11,11,571},{12,11,198},{13,11,283},{14,11,186},{15,11,21},{143,11,103},{134,0
+-,1001},{4,11,185},{5,11,257},{5,11,839},{5,11,936},{7,11,171},{9,11,399},{10,11,
+-258},{10,11,395},{10,11,734},{11,11,1014},{12,11,23},{13,11,350},{14,11,150},{
+-147,11,6},{143,0,35},{132,0,831},{5,10,835},{134,10,483},{4,0,277},{5,0,608},{6,
+-0,493},{7,0,457},{12,0,384},{7,11,404},{7,11,1377},{7,11,1430},{7,11,2017},{8,11
+-,149},{8,11,239},{8,11,512},{8,11,793},{8,11,818},{9,11,474},{9,11,595},{10,11,
+-122},{10,11,565},{10,11,649},{10,11,783},{11,11,239},{11,11,295},{11,11,447},{11
+-,11,528},{11,11,639},{11,11,800},{11,11,936},{12,11,25},{12,11,73},{12,11,77},{
+-12,11,157},{12,11,316},{12,11,390},{12,11,391},{12,11,394},{12,11,395},{12,11,
+-478},{12,11,503},{12,11,592},{12,11,680},{13,11,50},{13,11,53},{13,11,132},{13,
+-11,198},{13,11,275},{13,11,322},{13,11,415},{14,11,71},{14,11,257},{14,11,395},{
+-15,11,71},{15,11,136},{17,11,123},{18,11,93},{147,11,58},{134,0,1351},{7,0,27},{
+-135,0,316},{136,11,712},{136,0,984},{133,0,552},{137,0,264},{132,0,401},{6,0,710
+-},{6,0,1111},{134,0,1343},{134,0,1211},{9,0,543},{10,0,524},{11,0,108},{11,0,653
+-},{12,0,524},{13,0,123},{14,0,252},{16,0,18},{19,0,38},{20,0,26},{20,0,65},{21,0
+-,3},{151,0,11},{4,0,205},{5,0,623},{7,0,104},{8,0,519},{137,0,716},{132,10,677},
+-{4,11,377},{152,11,13},{135,11,1673},{7,0,579},{9,0,41},{9,0,244},{9,0,669},{10,
+-0,5},{11,0,861},{11,0,951},{139,0,980},{132,0,717},{136,0,1011},{132,0,805},{4,
+-11,180},{135,11,1906},{132,10,777},{132,10,331},{132,0,489},{6,0,1024},{4,11,491
+-},{133,10,747},{135,11,1182},{4,11,171},{138,11,234},{4,11,586},{7,11,1186},{138
+-,11,631},{135,0,892},{135,11,336},{9,11,931},{10,11,334},{148,11,71},{137,0,473}
+-,{6,0,864},{12,0,659},{139,11,926},{7,0,819},{9,0,26},{9,0,392},{10,0,152},{10,0
+-,226},{11,0,19},{12,0,276},{12,0,426},{12,0,589},{13,0,460},{15,0,97},{19,0,48},
+-{148,0,104},{135,0,51},{133,10,326},{4,10,691},{146,10,16},{9,0,130},{11,0,765},
+-{10,10,680},{10,10,793},{141,10,357},{133,11,765},{8,0,229},{6,10,32},{7,10,385}
+-,{7,10,757},{7,10,1916},{8,10,94},{8,10,711},{9,10,541},{10,10,162},{10,10,795},
+-{11,10,989},{11,10,1010},{12,10,14},{142,10,308},{7,11,474},{137,11,578},{132,0,
+-674},{132,0,770},{5,0,79},{7,0,1027},{7,0,1477},{139,0,52},{133,11,424},{134,0,
+-1666},{6,0,409},{6,10,349},{6,10,1682},{7,10,1252},{8,10,112},{8,11,714},{9,10,
+-435},{9,10,668},{10,10,290},{10,10,319},{10,10,815},{11,10,180},{11,10,837},{12,
+-10,240},{13,10,152},{13,10,219},{142,10,158},{5,0,789},{134,0,195},{4,0,251},{4,
+-0,688},{7,0,513},{135,0,1284},{132,10,581},{9,11,420},{10,11,269},{10,11,285},{
+-10,11,576},{11,11,397},{13,11,175},{145,11,90},{6,10,126},{7,10,573},{8,10,397},
+-{142,10,44},{132,11,429},{133,0,889},{4,0,160},{5,0,330},{7,0,1434},{136,0,174},
+-{7,11,18},{7,11,699},{7,11,1966},{8,11,752},{9,11,273},{9,11,412},{9,11,703},{10
+-,11,71},{10,11,427},{10,11,508},{146,11,97},{6,0,872},{134,0,899},{133,10,926},{
+-134,0,1126},{134,0,918},{4,11,53},{5,11,186},{135,11,752},{7,0,268},{136,0,569},
+-{134,0,1224},{6,0,1361},{7,10,1232},{137,10,531},{8,11,575},{10,11,289},{139,11,
+-319},{133,10,670},{132,11,675},{133,0,374},{135,10,1957},{133,0,731},{11,0,190},
+-{15,0,49},{11,11,190},{143,11,49},{4,0,626},{5,0,506},{5,0,642},{6,0,425},{10,0,
+-202},{139,0,141},{137,0,444},{7,10,242},{135,10,1942},{6,11,209},{8,11,468},{9,
+-11,210},{11,11,36},{12,11,28},{12,11,630},{13,11,21},{13,11,349},{14,11,7},{145,
+-11,13},{4,11,342},{135,11,1179},{5,10,834},{7,10,1202},{8,10,14},{9,10,481},{137
+-,10,880},{4,11,928},{133,11,910},{4,11,318},{4,11,496},{7,11,856},{139,11,654},{
+-136,0,835},{7,0,1526},{138,10,465},{151,0,17},{135,0,477},{4,10,357},{6,10,172},
+-{7,10,143},{137,10,413},{6,0,1374},{138,0,994},{18,0,76},{132,10,590},{7,0,287},
+-{8,0,355},{9,0,293},{137,0,743},{134,0,1389},{7,11,915},{8,11,247},{147,11,0},{4
+-,11,202},{5,11,382},{6,11,454},{7,11,936},{7,11,1803},{8,11,758},{9,11,375},{9,
+-11,895},{10,11,743},{10,11,792},{11,11,978},{11,11,1012},{142,11,109},{5,0,384},
+-{8,0,455},{140,0,48},{132,11,390},{5,10,169},{7,10,333},{136,10,45},{5,0,264},{
+-134,0,184},{138,11,791},{133,11,717},{132,10,198},{6,11,445},{7,11,332},{137,11,
+-909},{136,0,1001},{4,10,24},{5,10,140},{5,10,185},{7,10,1500},{11,10,565},{139,
+-10,838},{134,11,578},{5,0,633},{6,0,28},{135,0,1323},{132,0,851},{136,11,267},{7
+-,0,359},{8,0,243},{140,0,175},{4,10,334},{133,10,593},{141,11,87},{136,11,766},{
+-10,0,287},{12,0,138},{10,11,287},{140,11,138},{4,0,105},{132,0,740},{140,10,116}
+-,{134,0,857},{135,11,1841},{6,0,1402},{137,0,819},{132,11,584},{132,10,709},{133
+-,10,897},{5,0,224},{13,0,174},{146,0,52},{135,10,1840},{4,10,608},{133,10,497},{
+-139,11,60},{4,0,758},{135,0,1649},{4,11,226},{4,11,326},{135,11,1770},{5,11,426}
+-,{8,11,30},{9,11,2},{11,11,549},{147,11,122},{135,10,2039},{6,10,540},{136,10,
+-136},{4,0,573},{8,0,655},{4,10,897},{133,10,786},{7,0,351},{139,0,128},{133,10,
+-999},{4,10,299},{135,10,1004},{133,0,918},{132,11,345},{4,11,385},{7,11,265},{
+-135,11,587},{133,10,456},{136,10,180},{6,0,687},{134,0,1537},{4,11,347},{5,11,
+-423},{5,11,996},{135,11,1329},{132,10,755},{7,11,1259},{9,11,125},{11,11,65},{
+-140,11,285},{5,11,136},{6,11,136},{136,11,644},{134,0,1525},{4,0,1009},{135,0,
+-1139},{139,10,338},{132,0,340},{135,10,1464},{8,0,847},{10,0,861},{10,0,876},{10
+-,0,889},{10,0,922},{10,0,929},{10,0,933},{12,0,784},{140,0,791},{139,0,176},{9,
+-11,134},{10,11,2},{10,11,27},{10,11,333},{11,11,722},{143,11,1},{4,11,433},{133,
+-11,719},{5,0,985},{7,0,509},{7,0,529},{145,0,96},{132,0,615},{4,10,890},{5,10,
+-805},{5,10,819},{5,10,961},{6,10,396},{6,10,1631},{6,10,1678},{7,10,1967},{7,10,
+-2041},{9,10,630},{11,10,8},{11,10,1019},{12,10,176},{13,10,225},{14,10,292},{149
+-,10,24},{135,0,1919},{134,0,1131},{144,11,21},{144,11,51},{135,10,1815},{4,0,247
+-},{7,10,1505},{10,10,190},{10,10,634},{11,10,792},{12,10,358},{140,10,447},{5,10
+-,0},{6,10,536},{7,10,604},{13,10,445},{145,10,126},{4,0,184},{5,0,390},{6,0,337}
+-,{7,0,23},{7,0,494},{7,0,618},{7,0,1456},{8,0,27},{8,0,599},{10,0,153},{139,0,
+-710},{6,10,232},{6,10,412},{7,10,1074},{8,10,9},{8,10,157},{8,10,786},{9,10,196}
+-,{9,10,352},{9,10,457},{10,10,337},{11,10,232},{11,10,877},{12,10,480},{140,10,
+-546},{13,0,38},{135,10,958},{4,10,382},{136,10,579},{4,10,212},{135,10,1206},{4,
+-11,555},{8,11,536},{138,11,288},{11,11,139},{139,11,171},{9,11,370},{138,11,90},
+-{132,0,1015},{134,0,1088},{5,10,655},{135,11,977},{134,0,1585},{17,10,67},{147,
+-10,74},{10,0,227},{11,0,497},{11,0,709},{140,0,415},{6,0,360},{7,0,1664},{136,0,
+-478},{7,0,95},{6,10,231},{136,10,423},{140,11,65},{4,11,257},{135,11,2031},{135,
+-11,1768},{133,10,300},{139,11,211},{136,0,699},{6,10,237},{7,10,611},{8,10,100},
+-{9,10,416},{11,10,335},{12,10,173},{146,10,101},{14,0,26},{146,0,150},{6,0,581},
+-{135,0,1119},{135,10,1208},{132,0,739},{6,11,83},{6,11,1733},{135,11,1389},{137,
+-0,869},{4,0,67},{5,0,422},{7,0,1037},{7,0,1289},{7,0,1555},{9,0,741},{145,0,108}
+-,{133,10,199},{12,10,427},{146,10,38},{136,0,464},{142,0,42},{10,0,96},{8,11,501
+-},{137,11,696},{134,11,592},{4,0,512},{4,0,966},{5,0,342},{6,0,1855},{8,0,869},{
+-8,0,875},{8,0,901},{144,0,26},{8,0,203},{11,0,823},{11,0,846},{12,0,482},{13,0,
+-277},{13,0,302},{13,0,464},{14,0,205},{142,0,221},{4,0,449},{133,0,718},{7,11,
+-1718},{9,11,95},{9,11,274},{10,11,279},{10,11,317},{10,11,420},{11,11,303},{11,
+-11,808},{12,11,134},{12,11,367},{13,11,149},{13,11,347},{14,11,349},{14,11,406},
+-{18,11,22},{18,11,89},{18,11,122},{147,11,47},{133,11,26},{4,0,355},{6,0,311},{9
+-,0,256},{138,0,404},{132,11,550},{10,0,758},{6,10,312},{6,10,1715},{10,10,584},{
+-11,10,546},{11,10,692},{12,10,259},{12,10,295},{13,10,46},{141,10,154},{136,11,
+-822},{5,0,827},{4,11,902},{5,11,809},{6,11,122},{135,11,896},{5,0,64},{140,0,581
+-},{4,0,442},{6,0,739},{7,0,1047},{7,0,1352},{7,0,1643},{7,11,1911},{9,11,449},{
+-10,11,192},{138,11,740},{135,11,262},{132,10,588},{133,11,620},{5,0,977},{6,0,
+-288},{7,0,528},{4,11,34},{5,11,574},{7,11,279},{7,11,1624},{136,11,601},{6,0,
+-1375},{4,10,231},{5,10,61},{6,10,104},{7,10,729},{7,10,964},{7,10,1658},{140,10,
+-414},{6,10,263},{138,10,757},{132,10,320},{4,0,254},{7,0,1309},{5,11,332},{135,
+-11,1309},{6,11,261},{8,11,182},{139,11,943},{132,10,225},{6,0,12},{135,0,1219},{
+-4,0,275},{12,0,376},{6,11,1721},{141,11,490},{4,11,933},{133,11,880},{6,0,951},{
+-6,0,1109},{6,0,1181},{7,0,154},{4,10,405},{7,10,817},{14,10,58},{17,10,37},{146,
+-10,124},{6,0,1520},{133,10,974},{134,0,1753},{6,0,369},{6,0,502},{7,0,1036},{8,0
+-,348},{9,0,452},{10,0,26},{11,0,224},{11,0,387},{11,0,772},{12,0,95},{12,0,629},
+-{13,0,195},{13,0,207},{13,0,241},{14,0,260},{14,0,270},{143,0,140},{132,0,269},{
+-5,0,480},{7,0,532},{7,0,1197},{7,0,1358},{8,0,291},{11,0,349},{142,0,396},{5,10,
+-235},{7,10,1239},{11,10,131},{140,10,370},{7,10,956},{7,10,1157},{7,10,1506},{7,
+-10,1606},{7,10,1615},{7,10,1619},{7,10,1736},{7,10,1775},{8,10,590},{9,10,324},{
+-9,10,736},{9,10,774},{9,10,776},{9,10,784},{10,10,567},{10,10,708},{11,10,518},{
+-11,10,613},{11,10,695},{11,10,716},{11,10,739},{11,10,770},{11,10,771},{11,10,
+-848},{11,10,857},{11,10,931},{11,10,947},{12,10,326},{12,10,387},{12,10,484},{12
+-,10,528},{12,10,552},{12,10,613},{13,10,189},{13,10,256},{13,10,340},{13,10,432}
+-,{13,10,436},{13,10,440},{13,10,454},{14,10,174},{14,10,220},{14,10,284},{14,10,
+-390},{145,10,121},{8,11,598},{9,11,664},{138,11,441},{9,10,137},{138,10,221},{
+-133,11,812},{148,0,15},{134,0,1341},{6,0,1017},{4,11,137},{7,11,1178},{135,11,
+-1520},{7,10,390},{138,10,140},{7,11,1260},{135,11,1790},{137,11,191},{135,10,
+-1144},{6,0,1810},{7,0,657},{8,0,886},{10,0,857},{14,0,440},{144,0,96},{8,0,533},
+-{6,11,1661},{7,11,1975},{7,11,2009},{135,11,2011},{6,0,1453},{134,10,464},{132,
+-11,715},{5,10,407},{11,10,204},{11,10,243},{11,10,489},{12,10,293},{19,10,37},{
+-20,10,73},{150,10,38},{133,11,703},{4,0,211},{7,0,1483},{5,10,325},{8,10,5},{8,
+-10,227},{9,10,105},{10,10,585},{140,10,614},{4,0,332},{5,0,335},{6,0,238},{7,0,
+-269},{7,0,811},{7,0,1797},{8,0,836},{9,0,507},{141,0,242},{5,11,89},{7,11,1915},
+-{9,11,185},{9,11,235},{9,11,496},{10,11,64},{10,11,270},{10,11,403},{10,11,469},
+-{10,11,529},{10,11,590},{11,11,140},{11,11,860},{13,11,1},{13,11,422},{14,11,341
+-},{14,11,364},{17,11,93},{18,11,113},{19,11,97},{147,11,113},{133,11,695},{16,0,
+-19},{5,11,6},{6,11,183},{6,10,621},{7,11,680},{7,11,978},{7,11,1013},{7,11,1055}
+-,{12,11,230},{13,11,172},{13,10,504},{146,11,29},{136,0,156},{133,0,1009},{6,11,
+-29},{139,11,63},{134,0,820},{134,10,218},{7,10,454},{7,10,782},{8,10,768},{140,
+-10,686},{5,0,228},{6,0,203},{7,0,156},{8,0,347},{9,0,265},{18,0,39},{20,0,54},{
+-21,0,31},{22,0,3},{23,0,0},{15,11,8},{18,11,39},{20,11,54},{21,11,31},{22,11,3},
+-{151,11,0},{7,0,1131},{135,0,1468},{144,10,0},{134,0,1276},{10,10,676},{140,10,
+-462},{132,11,311},{134,11,1740},{7,11,170},{8,11,90},{8,11,177},{8,11,415},{11,
+-11,714},{142,11,281},{134,10,164},{6,0,1792},{138,0,849},{150,10,50},{5,0,291},{
+-5,0,318},{7,0,765},{9,0,389},{12,0,548},{8,11,522},{142,11,328},{11,11,91},{13,
+-11,129},{15,11,101},{145,11,125},{4,11,494},{6,11,74},{7,11,44},{7,11,407},{8,11
+-,551},{12,11,17},{15,11,5},{148,11,11},{4,11,276},{133,11,296},{6,10,343},{7,10,
+-195},{7,11,1777},{9,10,226},{10,10,197},{10,10,575},{11,10,502},{139,10,899},{10
+-,0,525},{139,0,82},{14,0,453},{4,11,7},{5,11,90},{5,11,158},{6,11,542},{7,11,221
+-},{7,11,1574},{9,11,490},{10,11,540},{11,11,443},{139,11,757},{135,0,666},{22,10
+-,29},{150,11,29},{4,0,422},{147,10,8},{5,0,355},{145,0,0},{6,0,1873},{9,0,918},{
+-7,11,588},{9,11,175},{138,11,530},{143,11,31},{11,0,165},{7,10,1125},{9,10,143},
+-{14,10,405},{150,10,21},{9,0,260},{137,0,905},{5,11,872},{6,11,57},{6,11,479},{6
+-,11,562},{7,11,471},{7,11,1060},{9,11,447},{9,11,454},{141,11,6},{138,11,704},{
+-133,0,865},{5,0,914},{134,0,1625},{133,0,234},{7,0,1383},{5,11,31},{6,11,614},{
+-145,11,61},{7,11,1200},{138,11,460},{6,11,424},{135,11,1866},{136,0,306},{5,10,
+-959},{12,11,30},{13,11,148},{14,11,87},{14,11,182},{16,11,42},{18,11,92},{148,11
+-,70},{6,0,1919},{6,0,1921},{9,0,923},{9,0,930},{9,0,941},{9,0,949},{9,0,987},{9,
+-0,988},{9,0,992},{12,0,802},{12,0,815},{12,0,856},{12,0,885},{12,0,893},{12,0,
+-898},{12,0,919},{12,0,920},{12,0,941},{12,0,947},{15,0,183},{15,0,185},{15,0,189
+-},{15,0,197},{15,0,202},{15,0,233},{18,0,218},{18,0,219},{18,0,233},{143,11,156}
+-,{135,10,1759},{136,10,173},{13,0,163},{13,0,180},{18,0,78},{20,0,35},{5,11,13},
+-{134,11,142},{134,10,266},{6,11,97},{7,11,116},{8,11,322},{8,11,755},{9,11,548},
+-{10,11,714},{11,11,884},{141,11,324},{135,0,1312},{9,0,814},{137,11,676},{133,0,
+-707},{135,0,1493},{6,0,421},{7,0,61},{7,0,1540},{10,0,11},{138,0,501},{12,0,733}
+-,{12,0,766},{7,11,866},{135,11,1163},{137,0,341},{142,0,98},{145,11,115},{135,11
+-,1111},{136,10,300},{136,0,1014},{8,11,1},{9,11,112},{138,11,326},{132,11,730},{
+-5,11,488},{6,11,527},{7,11,489},{7,11,1636},{8,11,121},{8,11,144},{8,11,359},{9,
+-11,193},{9,11,241},{9,11,336},{9,11,882},{11,11,266},{11,11,372},{11,11,944},{12
+-,11,401},{140,11,641},{6,0,971},{134,0,1121},{6,0,102},{7,0,72},{15,0,142},{147,
+-0,67},{151,0,30},{135,0,823},{134,0,1045},{5,10,427},{5,10,734},{7,10,478},{136,
+-10,52},{7,0,1930},{11,10,217},{142,10,165},{6,0,1512},{135,0,1870},{9,11,31},{10
+-,11,244},{10,11,699},{12,11,149},{141,11,497},{133,11,377},{145,11,101},{10,11,
+-158},{13,11,13},{13,11,137},{13,11,258},{14,11,111},{14,11,225},{14,11,253},{14,
+-11,304},{14,11,339},{14,11,417},{146,11,33},{6,0,87},{6,10,1734},{7,10,20},{7,10
+-,1056},{8,10,732},{9,10,406},{9,10,911},{138,10,694},{134,0,1243},{137,0,245},{7
+-,0,68},{8,0,48},{8,0,88},{8,0,582},{8,0,681},{9,0,373},{9,0,864},{11,0,157},{11,
+-0,336},{11,0,843},{148,0,27},{8,11,663},{144,11,8},{133,10,613},{4,0,88},{5,0,
+-137},{5,0,174},{5,0,777},{6,0,1664},{6,0,1725},{7,0,77},{7,0,426},{7,0,1317},{7,
+-0,1355},{8,0,126},{8,0,563},{9,0,523},{9,0,750},{10,0,310},{10,0,836},{11,0,42},
+-{11,0,318},{11,0,731},{12,0,68},{12,0,92},{12,0,507},{12,0,692},{13,0,81},{13,0,
+-238},{13,0,374},{14,0,436},{18,0,138},{19,0,78},{19,0,111},{20,0,55},{20,0,77},{
+-148,0,92},{141,0,418},{4,0,938},{137,0,625},{138,0,351},{5,11,843},{7,10,32},{7,
+-10,984},{8,10,85},{8,10,709},{9,10,579},{9,10,847},{9,10,856},{10,10,799},{11,10
+-,258},{11,10,1007},{12,10,331},{12,10,615},{13,10,188},{13,10,435},{14,10,8},{15
+-,10,165},{16,10,27},{148,10,40},{6,0,1668},{7,0,1499},{8,0,117},{9,0,314},{138,0
+-,174},{135,0,707},{132,11,554},{133,11,536},{5,0,403},{5,11,207},{9,11,79},{11,
+-11,625},{145,11,7},{132,11,424},{136,11,785},{4,10,167},{135,10,82},{9,0,7},{23,
+-0,6},{9,11,7},{151,11,6},{6,0,282},{5,10,62},{6,10,534},{7,10,74},{7,10,678},{7,
+-10,684},{7,10,1043},{7,10,1072},{8,10,280},{8,10,541},{8,10,686},{9,10,258},{10,
+-10,519},{11,10,252},{140,10,282},{138,10,33},{132,10,359},{4,0,44},{5,0,311},{6,
+-0,156},{7,0,639},{7,0,762},{7,0,1827},{9,0,8},{9,0,462},{148,0,83},{7,11,769},{9
+-,11,18},{138,11,358},{4,0,346},{7,0,115},{9,0,180},{9,0,456},{10,0,363},{4,11,
+-896},{134,11,1777},{133,10,211},{7,0,761},{7,0,1051},{137,0,545},{6,10,145},{141
+-,10,336},{7,11,750},{9,11,223},{11,11,27},{11,11,466},{12,11,624},{14,11,265},{
+-146,11,61},{6,0,752},{6,0,768},{6,0,1195},{6,0,1254},{6,0,1619},{137,0,835},{6,0
+-,1936},{8,0,930},{136,0,960},{132,10,263},{132,11,249},{12,0,653},{132,10,916},{
+-4,11,603},{133,11,661},{8,0,344},{4,11,11},{6,11,128},{7,11,231},{7,11,1533},{
+-138,11,725},{134,0,1483},{134,0,875},{6,0,185},{7,0,1899},{9,0,875},{139,0,673},
+-{15,10,155},{144,10,79},{7,0,93},{7,0,210},{7,0,1223},{8,0,451},{8,0,460},{11,0,
+-353},{11,0,475},{4,10,599},{6,10,1634},{7,10,67},{7,10,691},{7,10,979},{7,10,
+-1697},{8,10,207},{8,10,214},{8,10,231},{8,10,294},{8,10,336},{8,10,428},{8,10,
+-471},{8,10,622},{8,10,626},{8,10,679},{8,10,759},{8,10,829},{9,10,11},{9,10,246}
+-,{9,10,484},{9,10,573},{9,10,706},{9,10,762},{9,10,798},{9,10,855},{9,10,870},{9
+-,10,912},{10,10,303},{10,10,335},{10,10,424},{10,10,461},{10,10,543},{10,10,759}
+-,{10,10,814},{11,10,59},{11,10,235},{11,10,590},{11,10,929},{11,10,963},{11,10,
+-987},{12,10,114},{12,10,182},{12,10,226},{12,10,332},{12,10,439},{12,10,575},{12
+-,10,598},{12,10,675},{13,10,8},{13,10,125},{13,10,194},{13,10,287},{14,10,197},{
+-14,10,383},{15,10,53},{17,10,63},{19,10,46},{19,10,98},{19,10,106},{148,10,85},{
+-132,11,476},{4,0,327},{5,0,478},{7,0,1332},{136,0,753},{5,0,1020},{133,0,1022},{
+-135,11,1807},{4,0,103},{133,0,401},{4,0,499},{135,0,1421},{10,0,207},{13,0,164},
+-{147,10,126},{9,11,20},{10,11,324},{139,11,488},{132,0,96},{9,11,280},{138,11,
+-134},{135,0,968},{133,10,187},{135,10,1286},{5,11,112},{6,11,103},{134,11,150},{
+-8,0,914},{10,0,3},{4,10,215},{9,10,38},{11,10,23},{11,10,127},{139,10,796},{135,
+-0,399},{6,0,563},{137,0,224},{6,0,704},{134,0,1214},{4,11,708},{8,11,15},{9,11,
+-50},{9,11,386},{11,11,18},{11,11,529},{140,11,228},{4,11,563},{7,11,109},{7,11,
+-592},{7,11,637},{7,11,770},{7,11,1701},{8,11,436},{8,11,463},{9,11,60},{9,11,335
+-},{9,11,904},{10,11,73},{11,11,434},{12,11,585},{13,11,331},{18,11,110},{148,11,
+-60},{134,0,1559},{132,11,502},{6,11,347},{138,11,161},{4,11,33},{5,11,102},{5,11
+-,500},{6,11,284},{7,11,1079},{7,11,1423},{7,11,1702},{8,11,470},{9,11,554},{9,11
+-,723},{139,11,333},{7,11,246},{135,11,840},{6,11,10},{8,11,571},{9,11,739},{143,
+-11,91},{8,0,861},{10,0,905},{12,0,730},{12,0,789},{133,11,626},{134,0,946},{5,0,
+-746},{12,0,333},{14,0,332},{12,11,333},{142,11,332},{5,11,18},{6,11,526},{13,11,
+-24},{13,11,110},{19,11,5},{147,11,44},{4,0,910},{5,0,832},{135,10,2002},{10,11,
+-768},{139,11,787},{4,11,309},{5,11,462},{7,11,970},{135,11,1097},{4,10,28},{5,10
+-,440},{7,10,248},{11,10,833},{140,10,344},{134,10,1654},{6,0,632},{6,0,652},{6,0
+-,1272},{6,0,1384},{134,0,1560},{134,11,1704},{6,0,1393},{133,10,853},{6,10,249},
+-{7,10,1234},{139,10,573},{5,11,86},{7,11,743},{9,11,85},{10,11,281},{10,11,432},
+-{11,11,490},{12,11,251},{13,11,118},{14,11,378},{146,11,143},{5,11,524},{133,11,
+-744},{134,0,1514},{10,0,201},{142,0,319},{7,0,717},{10,0,510},{7,10,392},{8,10,
+-20},{8,10,172},{8,10,690},{9,10,383},{9,10,845},{11,10,293},{11,10,832},{11,10,
+-920},{11,10,984},{141,10,221},{134,0,1381},{5,10,858},{133,10,992},{8,0,528},{
+-137,0,348},{10,11,107},{140,11,436},{4,0,20},{133,0,616},{134,0,1251},{132,11,
+-927},{10,11,123},{12,11,670},{13,11,371},{14,11,142},{146,11,94},{134,0,1163},{7
+-,11,1149},{137,11,156},{134,0,307},{133,11,778},{7,0,1091},{135,0,1765},{5,11,
+-502},{6,10,268},{137,10,62},{8,11,196},{10,11,283},{139,11,406},{4,0,26},{5,0,
+-429},{6,0,245},{7,0,704},{7,0,1379},{135,0,1474},{133,11,855},{132,0,881},{4,0,
+-621},{135,11,1596},{7,11,1400},{9,11,446},{138,11,45},{6,0,736},{138,10,106},{
+-133,0,542},{134,0,348},{133,0,868},{136,0,433},{135,0,1495},{138,0,771},{6,10,
+-613},{136,10,223},{138,0,215},{141,0,124},{136,11,391},{135,11,172},{132,10,670}
+-,{140,0,55},{9,10,40},{139,10,136},{7,0,62},{147,0,112},{132,0,856},{132,11,568}
+-,{12,0,270},{139,10,259},{8,0,572},{137,0,698},{4,11,732},{9,10,310},{137,10,682
+-},{142,10,296},{134,0,939},{136,11,733},{135,11,1435},{7,10,1401},{135,10,1476},
+-{6,0,352},{4,10,296},{7,10,401},{7,10,1410},{7,10,1594},{7,10,1674},{8,10,63},{8
+-,10,660},{137,10,74},{4,11,428},{133,11,668},{4,10,139},{4,10,388},{140,10,188},
+-{7,11,2015},{140,11,665},{132,0,647},{146,0,10},{138,0,220},{142,0,464},{132,0,
+-109},{134,0,1746},{6,0,515},{4,10,747},{6,11,1623},{6,11,1681},{7,10,649},{7,10,
+-1479},{135,10,1583},{133,10,232},{135,0,566},{137,10,887},{4,0,40},{10,0,67},{11
+-,0,117},{11,0,768},{139,0,935},{132,0,801},{7,0,992},{8,0,301},{9,0,722},{12,0,
+-63},{13,0,29},{14,0,161},{143,0,18},{139,0,923},{6,11,1748},{8,11,715},{9,11,802
+-},{10,11,46},{10,11,819},{13,11,308},{14,11,351},{14,11,363},{146,11,67},{137,11
+-,745},{7,0,1145},{4,10,14},{7,10,1801},{10,10,748},{141,10,458},{4,11,63},{5,11,
+-347},{134,11,474},{135,0,568},{4,10,425},{7,11,577},{7,11,1432},{9,11,475},{9,11
+-,505},{9,11,526},{9,11,609},{9,11,689},{9,11,726},{9,11,735},{9,11,738},{10,11,
+-556},{10,11,674},{10,11,684},{11,11,89},{11,11,202},{11,11,272},{11,11,380},{11,
+-11,415},{11,11,505},{11,11,537},{11,11,550},{11,11,562},{11,11,640},{11,11,667},
+-{11,11,688},{11,11,847},{11,11,927},{11,11,930},{11,11,940},{12,11,144},{12,11,
+-325},{12,11,329},{12,11,389},{12,11,403},{12,11,451},{12,11,515},{12,11,604},{12
+-,11,616},{12,11,626},{13,11,66},{13,11,131},{13,11,167},{13,11,236},{13,11,368},
+-{13,11,411},{13,11,434},{13,11,453},{13,11,461},{13,11,474},{14,11,59},{14,11,60
+-},{14,11,139},{14,11,152},{14,11,276},{14,11,353},{14,11,402},{15,11,28},{15,11,
+-81},{15,11,123},{15,11,152},{18,11,136},{148,11,88},{137,0,247},{135,11,1622},{9
+-,11,544},{11,11,413},{144,11,25},{4,0,645},{7,0,825},{6,10,1768},{135,11,89},{
+-140,0,328},{5,10,943},{134,10,1779},{134,0,1363},{5,10,245},{6,10,576},{7,10,582
+-},{136,10,225},{134,0,1280},{5,11,824},{133,11,941},{7,11,440},{8,11,230},{139,
+-11,106},{5,0,28},{6,0,204},{10,0,320},{10,0,583},{13,0,502},{14,0,72},{14,0,274}
+-,{14,0,312},{14,0,344},{15,0,159},{16,0,62},{16,0,69},{17,0,30},{18,0,42},{18,0,
+-53},{18,0,84},{18,0,140},{19,0,68},{19,0,85},{20,0,5},{20,0,45},{20,0,101},{22,0
+-,7},{150,0,20},{4,0,558},{6,0,390},{7,0,162},{7,0,689},{9,0,360},{138,0,653},{
+-134,0,764},{6,0,862},{137,0,833},{5,0,856},{6,0,1672},{6,0,1757},{134,0,1781},{5
+-,0,92},{10,0,736},{140,0,102},{6,0,1927},{6,0,1944},{8,0,924},{8,0,948},{10,0,
+-967},{138,0,978},{134,0,1479},{5,0,590},{8,0,360},{9,0,213},{138,0,63},{134,0,
+-1521},{6,0,709},{134,0,891},{132,10,443},{13,0,477},{14,0,120},{148,0,61},{4,11,
+-914},{5,11,800},{133,11,852},{10,11,54},{141,11,115},{4,11,918},{133,11,876},{
+-139,11,152},{4,11,92},{133,11,274},{135,11,1901},{9,11,800},{10,11,693},{11,11,
+-482},{11,11,734},{139,11,789},{9,0,483},{132,10,298},{6,0,1213},{141,11,498},{
+-135,11,1451},{133,11,743},{4,0,1022},{10,0,1000},{12,0,957},{12,0,980},{12,0,
+-1013},{14,0,481},{144,0,116},{8,0,503},{17,0,29},{4,11,49},{7,11,280},{135,11,
+-1633},{135,0,1712},{134,0,466},{136,11,47},{5,10,164},{7,10,121},{142,10,189},{7
+-,10,812},{7,10,1261},{7,10,1360},{9,10,632},{140,10,352},{139,10,556},{132,0,731
+-},{5,11,272},{5,11,908},{5,11,942},{7,11,1008},{7,11,1560},{8,11,197},{9,11,47},
+-{11,11,538},{139,11,742},{4,10,172},{9,10,611},{10,10,436},{12,10,673},{141,10,
+-255},{133,10,844},{10,0,484},{11,0,754},{12,0,457},{14,0,171},{14,0,389},{146,0,
+-153},{9,10,263},{10,10,147},{138,10,492},{137,11,891},{138,0,241},{133,10,537},{
+-6,0,2005},{136,0,964},{137,10,842},{151,11,8},{4,11,407},{132,11,560},{135,11,
+-1884},{6,0,1100},{134,0,1242},{135,0,954},{5,10,230},{5,10,392},{6,10,420},{9,10
+-,568},{140,10,612},{4,11,475},{11,11,35},{11,11,90},{13,11,7},{13,11,71},{13,11,
+-177},{142,11,422},{136,11,332},{135,0,1958},{6,0,549},{8,0,34},{8,0,283},{9,0,
+-165},{138,0,475},{10,0,952},{12,0,966},{140,0,994},{5,0,652},{5,0,701},{135,0,
+-449},{4,0,655},{7,0,850},{17,0,75},{146,0,137},{4,0,146},{7,0,1618},{8,0,670},{5
+-,10,41},{7,10,1459},{7,10,1469},{7,10,1859},{9,10,549},{139,10,905},{133,10,696}
+-,{6,0,159},{6,0,364},{7,0,516},{137,0,518},{135,0,1439},{6,11,222},{7,11,636},{7
+-,11,1620},{8,11,409},{9,11,693},{139,11,77},{13,0,151},{141,11,45},{6,0,1027},{4
+-,11,336},{132,10,771},{139,11,392},{10,11,121},{11,11,175},{149,11,16},{8,0,950}
+-,{138,0,983},{133,10,921},{135,0,993},{6,10,180},{7,10,1137},{8,10,751},{139,10,
+-805},{7,0,501},{9,0,111},{10,0,141},{11,0,332},{13,0,43},{13,0,429},{14,0,130},{
+-14,0,415},{145,0,102},{4,10,183},{5,11,882},{7,10,271},{11,10,824},{11,10,952},{
+-13,10,278},{13,10,339},{13,10,482},{14,10,424},{148,10,99},{4,10,19},{5,10,477},
+-{5,10,596},{6,10,505},{7,10,1221},{11,10,907},{12,10,209},{141,10,214},{135,10,
+-1215},{133,0,452},{132,11,426},{5,0,149},{136,0,233},{133,0,935},{6,11,58},{7,11
+-,654},{7,11,745},{7,11,1969},{8,11,240},{8,11,675},{9,11,479},{9,11,731},{10,11,
+-330},{10,11,593},{10,11,817},{11,11,32},{11,11,133},{11,11,221},{145,11,68},{12,
+-0,582},{18,0,131},{7,11,102},{137,11,538},{136,0,801},{134,10,1645},{132,0,70},{
+-6,10,92},{6,10,188},{7,10,1269},{7,10,1524},{7,10,1876},{10,10,228},{139,10,1020
+-},{4,10,459},{133,10,966},{138,0,369},{16,0,36},{140,10,330},{141,11,366},{7,0,
+-721},{10,0,236},{12,0,204},{6,10,18},{7,10,932},{8,10,757},{9,10,54},{9,10,65},{
+-9,10,844},{10,10,113},{10,10,315},{10,10,798},{11,10,153},{12,10,151},{12,10,392
+-},{12,10,666},{142,10,248},{7,0,241},{10,0,430},{8,10,548},{9,10,532},{10,10,117
+-},{11,10,351},{11,10,375},{143,10,23},{134,10,1742},{133,10,965},{133,11,566},{6
+-,11,48},{135,11,63},{134,10,182},{10,10,65},{10,10,488},{138,10,497},{6,11,114},
+-{7,11,1224},{7,11,1556},{136,11,3},{134,0,1817},{8,11,576},{137,11,267},{6,0,
+-1078},{144,0,16},{9,10,588},{138,10,260},{138,0,1021},{5,0,406},{134,0,2022},{
+-133,11,933},{6,0,69},{135,0,117},{7,0,1830},{136,11,427},{4,0,432},{135,0,824},{
+-134,10,1786},{133,0,826},{139,11,67},{133,11,759},{135,10,308},{137,0,816},{133,
+-0,1000},{4,0,297},{6,0,529},{7,0,152},{7,0,713},{7,0,1845},{8,0,710},{8,0,717},{
+-12,0,639},{140,0,685},{7,0,423},{136,10,588},{136,10,287},{136,0,510},{134,0,
+-1048},{6,0,618},{7,11,56},{7,11,1989},{8,11,337},{8,11,738},{9,11,600},{10,11,
+-483},{12,11,37},{13,11,447},{142,11,92},{4,0,520},{135,0,575},{8,0,990},{138,0,
+-977},{135,11,774},{9,11,347},{11,11,24},{140,11,170},{136,11,379},{140,10,290},{
+-132,11,328},{4,0,321},{134,0,569},{4,11,101},{135,11,1171},{7,0,723},{7,0,1135},
+-{5,11,833},{136,11,744},{7,10,719},{8,10,809},{136,10,834},{8,0,921},{136,10,796
+-},{5,10,210},{6,10,213},{7,10,60},{10,10,364},{139,10,135},{5,0,397},{6,0,154},{
+-7,0,676},{8,0,443},{8,0,609},{9,0,24},{9,0,325},{10,0,35},{11,0,535},{11,0,672},
+-{11,0,1018},{12,0,637},{16,0,30},{5,10,607},{8,10,326},{136,10,490},{4,10,701},{
+-5,10,472},{6,11,9},{6,11,397},{7,11,53},{7,11,1742},{9,10,758},{10,11,632},{11,
+-11,828},{140,11,146},{135,10,380},{135,10,1947},{148,11,109},{10,10,278},{138,11
+-,278},{134,0,856},{7,0,139},{4,10,386},{8,10,405},{8,10,728},{9,10,497},{11,10,
+-110},{11,10,360},{15,10,37},{144,10,84},{141,0,282},{133,0,981},{5,0,288},{7,10,
+-1452},{7,10,1480},{8,10,634},{140,10,472},{7,0,1890},{8,11,367},{10,11,760},{14,
+-11,79},{20,11,17},{152,11,0},{4,10,524},{136,10,810},{4,0,56},{7,0,1791},{8,0,
+-607},{8,0,651},{11,0,465},{11,0,835},{12,0,337},{141,0,480},{10,10,238},{141,10,
+-33},{11,11,417},{12,11,223},{140,11,265},{9,0,158},{10,0,411},{140,0,261},{133,
+-10,532},{133,10,997},{12,11,186},{12,11,292},{14,11,100},{146,11,70},{6,0,1403},
+-{136,0,617},{134,0,1205},{139,0,563},{4,0,242},{134,0,333},{4,11,186},{5,11,157}
+-,{8,11,168},{138,11,6},{132,0,369},{133,11,875},{5,10,782},{5,10,829},{134,10,
+-1738},{134,0,622},{135,11,1272},{6,0,1407},{7,11,111},{136,11,581},{7,10,1823},{
+-139,10,693},{7,0,160},{10,0,624},{142,0,279},{132,0,363},{10,11,589},{12,11,111}
+-,{13,11,260},{14,11,82},{18,11,63},{147,11,45},{7,11,1364},{7,11,1907},{141,11,
+-158},{4,11,404},{4,11,659},{135,11,675},{13,11,211},{14,11,133},{14,11,204},{15,
+-11,64},{15,11,69},{15,11,114},{16,11,10},{19,11,23},{19,11,35},{19,11,39},{19,11
+-,51},{19,11,71},{19,11,75},{152,11,15},{4,10,78},{5,10,96},{5,10,182},{7,10,1724
+-},{7,10,1825},{10,10,394},{10,10,471},{11,10,532},{14,10,340},{145,10,88},{135,
+-10,1964},{133,11,391},{11,11,887},{14,11,365},{142,11,375},{5,11,540},{6,11,1697
+-},{7,11,222},{136,11,341},{134,11,78},{9,0,601},{9,0,619},{10,0,505},{10,0,732},
+-{11,0,355},{140,0,139},{134,0,292},{139,0,174},{5,0,177},{6,0,616},{7,0,827},{9,
+-0,525},{138,0,656},{10,0,31},{6,10,215},{7,10,1028},{7,10,1473},{7,10,1721},{9,
+-10,424},{138,10,779},{135,10,584},{136,11,293},{134,0,685},{135,11,1868},{133,11
+-,460},{7,0,647},{6,10,67},{7,10,1630},{9,10,354},{9,10,675},{10,10,830},{14,10,
+-80},{145,10,80},{4,0,161},{133,0,631},{6,10,141},{7,10,225},{9,10,59},{9,10,607}
+-,{10,10,312},{11,10,687},{12,10,555},{13,10,373},{13,10,494},{148,10,58},{7,11,
+-965},{7,11,1460},{135,11,1604},{136,10,783},{134,11,388},{6,0,722},{6,0,1267},{4
+-,11,511},{9,11,333},{9,11,379},{10,11,602},{11,11,441},{11,11,723},{11,11,976},{
+-140,11,357},{134,0,1797},{135,0,1684},{9,0,469},{9,0,709},{12,0,512},{14,0,65},{
+-17,0,12},{5,11,938},{136,11,707},{7,0,1230},{136,0,531},{10,0,229},{11,0,73},{11
+-,0,376},{139,0,433},{12,0,268},{12,0,640},{142,0,119},{7,10,430},{139,10,46},{6,
+-0,558},{7,0,651},{8,0,421},{9,0,0},{10,0,34},{139,0,1008},{6,0,106},{7,0,1786},{
+-7,0,1821},{9,0,102},{9,0,763},{5,10,602},{7,10,2018},{137,10,418},{5,0,65},{6,0,
+-416},{7,0,1720},{7,0,1924},{10,0,109},{11,0,14},{11,0,70},{11,0,569},{11,0,735},
+-{15,0,153},{20,0,80},{136,10,677},{135,11,1625},{137,11,772},{136,0,595},{6,11,
+-469},{7,11,1709},{138,11,515},{7,0,1832},{138,0,374},{9,0,106},{9,0,163},{9,0,
+-296},{10,0,167},{10,0,172},{10,0,777},{139,0,16},{6,0,6},{7,0,81},{7,0,771},{7,0
+-,1731},{9,0,405},{138,0,421},{4,11,500},{135,11,938},{5,11,68},{134,11,383},{5,0
+-,881},{133,0,885},{6,0,854},{6,0,1132},{6,0,1495},{6,0,1526},{6,0,1533},{134,0,
+-1577},{4,11,337},{6,11,353},{7,11,1934},{8,11,488},{137,11,429},{7,11,236},{7,11
+-,1795},{8,11,259},{9,11,135},{9,11,177},{10,11,825},{11,11,115},{11,11,370},{11,
+-11,405},{11,11,604},{12,11,10},{12,11,667},{12,11,669},{13,11,76},{14,11,310},{
+-15,11,76},{15,11,147},{148,11,23},{5,0,142},{134,0,546},{4,11,15},{5,11,22},{6,
+-11,244},{7,11,40},{7,11,200},{7,11,906},{7,11,1199},{9,11,616},{10,11,716},{11,
+-11,635},{11,11,801},{140,11,458},{5,0,466},{11,0,571},{12,0,198},{13,0,283},{14,
+-0,186},{15,0,21},{15,0,103},{135,10,329},{4,0,185},{5,0,257},{5,0,839},{5,0,936}
+-,{9,0,399},{10,0,258},{10,0,395},{10,0,734},{11,0,1014},{12,0,23},{13,0,350},{14
+-,0,150},{19,0,6},{135,11,1735},{12,11,36},{141,11,337},{5,11,598},{7,11,791},{8,
+-11,108},{137,11,123},{132,10,469},{7,0,404},{7,0,1377},{7,0,1430},{7,0,2017},{8,
+-0,149},{8,0,239},{8,0,512},{8,0,793},{8,0,818},{9,0,474},{9,0,595},{10,0,122},{
+-10,0,565},{10,0,649},{10,0,783},{11,0,239},{11,0,295},{11,0,447},{11,0,528},{11,
+-0,639},{11,0,800},{12,0,25},{12,0,77},{12,0,157},{12,0,256},{12,0,316},{12,0,390
+-},{12,0,391},{12,0,395},{12,0,478},{12,0,503},{12,0,592},{12,0,680},{13,0,50},{
+-13,0,53},{13,0,132},{13,0,198},{13,0,322},{13,0,415},{13,0,511},{14,0,71},{14,0,
+-395},{15,0,71},{15,0,136},{17,0,123},{18,0,93},{147,0,58},{136,0,712},{134,10,
+-1743},{5,10,929},{6,10,340},{8,10,376},{136,10,807},{6,0,1848},{8,0,860},{10,0,
+-856},{10,0,859},{10,0,925},{10,0,941},{140,0,762},{6,0,629},{6,0,906},{9,0,810},
+-{140,0,652},{5,10,218},{7,10,1610},{138,10,83},{7,10,1512},{135,10,1794},{4,0,
+-377},{24,0,13},{4,11,155},{7,11,1689},{11,10,0},{144,10,78},{4,11,164},{5,11,151
+-},{5,11,730},{5,11,741},{7,11,498},{7,11,870},{7,11,1542},{12,11,213},{14,11,36}
+-,{14,11,391},{17,11,111},{18,11,6},{18,11,46},{18,11,151},{19,11,36},{20,11,32},
+-{20,11,56},{20,11,69},{20,11,102},{21,11,4},{22,11,8},{22,11,10},{22,11,14},{150
+-,11,31},{7,0,1842},{133,10,571},{4,10,455},{4,11,624},{135,11,1752},{134,0,1501}
+-,{4,11,492},{5,11,451},{6,10,161},{7,10,372},{137,10,597},{132,10,349},{4,0,180}
+-,{135,0,1906},{135,11,835},{141,11,70},{132,0,491},{137,10,751},{6,10,432},{139,
+-10,322},{4,0,171},{138,0,234},{6,11,113},{135,11,436},{4,0,586},{7,0,1186},{138,
+-0,631},{5,10,468},{10,10,325},{11,10,856},{12,10,345},{143,10,104},{5,10,223},{
+-10,11,592},{10,11,753},{12,11,317},{12,11,355},{12,11,465},{12,11,469},{12,11,
+-560},{12,11,578},{141,11,243},{132,10,566},{135,11,520},{4,10,59},{135,10,1394},
+-{6,10,436},{139,10,481},{9,0,931},{10,0,334},{20,0,71},{4,10,48},{5,10,271},{7,
+-10,953},{135,11,1878},{11,0,170},{5,10,610},{136,10,457},{133,10,755},{6,0,1587}
+-,{135,10,1217},{4,10,197},{149,11,26},{133,11,585},{137,11,521},{133,0,765},{133
+-,10,217},{139,11,586},{133,0,424},{9,11,752},{12,11,610},{13,11,431},{16,11,59},
+-{146,11,109},{136,0,714},{7,0,685},{132,11,307},{9,0,420},{10,0,269},{10,0,285},
+-{10,0,576},{11,0,397},{13,0,175},{145,0,90},{132,0,429},{133,11,964},{9,11,463},
+-{138,11,595},{7,0,18},{7,0,699},{7,0,1966},{8,0,752},{9,0,273},{9,0,412},{9,0,
+-703},{10,0,71},{10,0,427},{138,0,508},{4,10,165},{7,10,1398},{135,10,1829},{4,0,
+-53},{5,0,186},{7,0,752},{7,0,828},{142,0,116},{8,0,575},{10,0,289},{139,0,319},{
+-132,0,675},{134,0,1424},{4,11,75},{5,11,180},{6,11,500},{7,11,58},{7,11,710},{
+-138,11,645},{133,11,649},{6,11,276},{7,11,282},{7,11,879},{7,11,924},{8,11,459},
+-{9,11,599},{9,11,754},{11,11,574},{12,11,128},{12,11,494},{13,11,52},{13,11,301}
+-,{15,11,30},{143,11,132},{6,0,647},{134,0,1095},{5,10,9},{7,10,297},{7,10,966},{
+-140,10,306},{132,11,200},{134,0,1334},{5,10,146},{6,10,411},{138,10,721},{6,0,
+-209},{6,0,1141},{6,0,1288},{8,0,468},{9,0,210},{11,0,36},{12,0,28},{12,0,630},{
+-13,0,21},{13,0,349},{14,0,7},{145,0,13},{6,10,177},{135,10,467},{4,0,342},{135,0
+-,1179},{10,11,454},{140,11,324},{4,0,928},{133,0,910},{7,0,1838},{6,11,225},{137
+-,11,211},{16,0,101},{20,0,115},{20,0,118},{148,0,122},{4,0,496},{135,0,856},{4,0
+-,318},{11,0,654},{7,11,718},{139,11,102},{8,11,58},{9,11,724},{11,11,809},{13,11
+-,113},{145,11,72},{5,10,200},{6,11,345},{135,11,1247},{8,11,767},{8,11,803},{9,
+-11,301},{137,11,903},{7,0,915},{8,0,247},{19,0,0},{7,11,1949},{136,11,674},{4,0,
+-202},{5,0,382},{6,0,454},{7,0,936},{7,0,1803},{8,0,758},{9,0,375},{9,0,895},{10,
+-0,743},{10,0,792},{11,0,978},{11,0,1012},{142,0,109},{7,0,1150},{7,0,1425},{7,0,
+-1453},{140,0,513},{134,11,259},{138,0,791},{11,0,821},{12,0,110},{12,0,153},{18,
+-0,41},{150,0,19},{134,10,481},{132,0,796},{6,0,445},{9,0,909},{136,11,254},{10,0
+-,776},{13,0,345},{142,0,425},{4,10,84},{7,10,1482},{10,10,76},{138,10,142},{135,
+-11,742},{6,0,578},{133,10,1015},{6,0,1387},{4,10,315},{5,10,507},{135,10,1370},{
+-4,0,438},{133,0,555},{136,0,766},{133,11,248},{134,10,1722},{4,11,116},{5,11,95}
+-,{5,11,445},{7,11,1688},{8,11,29},{9,11,272},{11,11,509},{139,11,915},{135,0,541
+-},{133,11,543},{8,10,222},{8,10,476},{9,10,238},{11,10,516},{11,10,575},{15,10,
+-109},{146,10,100},{6,0,880},{134,0,1191},{5,11,181},{136,11,41},{134,0,1506},{
+-132,11,681},{7,11,25},{8,11,202},{138,11,536},{139,0,983},{137,0,768},{132,0,584
+-},{9,11,423},{140,11,89},{8,11,113},{9,11,877},{10,11,554},{11,11,83},{12,11,136
+-},{147,11,109},{7,10,706},{7,10,1058},{138,10,538},{133,11,976},{4,11,206},{135,
+-11,746},{136,11,526},{140,0,737},{11,10,92},{11,10,196},{11,10,409},{11,10,450},
+-{11,10,666},{11,10,777},{12,10,262},{13,10,385},{13,10,393},{15,10,115},{16,10,
+-45},{145,10,82},{4,0,226},{4,0,326},{7,0,1770},{4,11,319},{5,11,699},{138,11,673
+-},{6,10,40},{135,10,1781},{5,0,426},{8,0,30},{9,0,2},{11,0,549},{147,0,122},{6,0
+-,1161},{134,0,1329},{138,10,97},{6,10,423},{7,10,665},{135,10,1210},{7,11,13},{8
+-,11,226},{10,11,537},{11,11,570},{11,11,605},{11,11,799},{11,11,804},{12,11,85},
+-{12,11,516},{12,11,623},{13,11,112},{13,11,361},{14,11,77},{14,11,78},{17,11,28}
+-,{147,11,110},{132,11,769},{132,11,551},{132,11,728},{147,0,117},{9,11,57},{9,11
+-,459},{10,11,425},{11,11,119},{12,11,184},{12,11,371},{13,11,358},{145,11,51},{5
+-,11,188},{5,11,814},{8,11,10},{9,11,421},{9,11,729},{10,11,609},{139,11,689},{
+-134,11,624},{135,11,298},{135,0,462},{4,0,345},{139,10,624},{136,10,574},{4,0,
+-385},{7,0,265},{135,0,587},{6,0,808},{132,11,528},{133,0,398},{132,10,354},{4,0,
+-347},{5,0,423},{5,0,996},{135,0,1329},{135,10,1558},{7,0,1259},{9,0,125},{139,0,
+-65},{5,0,136},{6,0,136},{136,0,644},{5,11,104},{6,11,173},{135,11,1631},{135,0,
+-469},{133,10,830},{4,0,278},{5,0,465},{135,0,1367},{7,11,810},{8,11,138},{8,11,
+-342},{9,11,84},{10,11,193},{11,11,883},{140,11,359},{5,10,496},{135,10,203},{4,0
+-,433},{133,0,719},{6,11,95},{134,10,547},{5,10,88},{137,10,239},{6,11,406},{10,
+-11,409},{10,11,447},{11,11,44},{140,11,100},{134,0,1423},{7,10,650},{135,10,1310
+-},{134,0,749},{135,11,1243},{135,0,1363},{6,0,381},{7,0,645},{7,0,694},{8,0,546}
+-,{7,10,1076},{9,10,80},{11,10,78},{11,10,421},{11,10,534},{140,10,545},{134,11,
+-1636},{135,11,1344},{12,0,277},{7,10,274},{11,10,479},{139,10,507},{6,0,705},{6,
+-0,783},{6,0,1275},{6,0,1481},{4,11,282},{7,11,1034},{11,11,398},{11,11,634},{12,
+-11,1},{12,11,79},{12,11,544},{14,11,237},{17,11,10},{146,11,20},{134,0,453},{4,0
+-,555},{8,0,536},{10,0,288},{11,0,1005},{4,10,497},{135,10,1584},{5,11,118},{5,11
+-,499},{6,11,476},{7,11,600},{7,11,888},{135,11,1096},{138,0,987},{7,0,1107},{7,
+-10,261},{7,10,1115},{7,10,1354},{7,10,1588},{7,10,1705},{7,10,1902},{9,10,465},{
+-10,10,248},{10,10,349},{10,10,647},{11,10,527},{11,10,660},{11,10,669},{12,10,
+-529},{141,10,305},{7,11,296},{7,11,596},{8,11,560},{8,11,586},{9,11,612},{11,11,
+-100},{11,11,304},{12,11,46},{13,11,89},{14,11,112},{145,11,122},{9,0,370},{138,0
+-,90},{136,10,13},{132,0,860},{7,10,642},{8,10,250},{11,10,123},{11,10,137},{13,
+-10,48},{142,10,95},{135,10,1429},{137,11,321},{132,0,257},{135,0,2031},{7,0,1768
+-},{7,11,1599},{7,11,1723},{8,11,79},{8,11,106},{8,11,190},{8,11,302},{8,11,383},
+-{9,11,119},{9,11,233},{9,11,298},{9,11,419},{9,11,471},{10,11,181},{10,11,406},{
+-11,11,57},{11,11,85},{11,11,120},{11,11,177},{11,11,296},{11,11,382},{11,11,454}
+-,{11,11,758},{11,11,999},{12,11,27},{12,11,98},{12,11,131},{12,11,245},{12,11,
+-312},{12,11,446},{12,11,454},{13,11,25},{13,11,98},{13,11,426},{13,11,508},{14,
+-11,6},{14,11,163},{14,11,272},{14,11,277},{14,11,370},{15,11,95},{15,11,138},{15
+-,11,167},{17,11,18},{17,11,38},{20,11,96},{149,11,32},{5,11,722},{134,11,1759},{
+-145,11,16},{6,0,1071},{134,0,1561},{10,10,545},{140,10,301},{6,0,83},{6,0,1733},
+-{135,0,1389},{4,0,835},{135,0,1818},{133,11,258},{4,10,904},{133,10,794},{134,0,
+-2006},{5,11,30},{7,11,495},{8,11,134},{9,11,788},{140,11,438},{135,11,2004},{137
+-,0,696},{5,11,50},{6,11,439},{7,11,780},{135,11,1040},{7,11,772},{7,11,1104},{7,
+-11,1647},{11,11,269},{11,11,539},{11,11,607},{11,11,627},{11,11,706},{11,11,975}
+-,{12,11,248},{12,11,311},{12,11,434},{12,11,600},{12,11,622},{13,11,297},{13,11,
+-367},{13,11,485},{14,11,69},{14,11,409},{143,11,108},{5,11,1},{6,11,81},{138,11,
+-520},{7,0,1718},{9,0,95},{9,0,274},{10,0,279},{10,0,317},{10,0,420},{11,0,303},{
+-11,0,808},{12,0,134},{12,0,367},{13,0,149},{13,0,347},{14,0,349},{14,0,406},{18,
+-0,22},{18,0,89},{18,0,122},{147,0,47},{5,11,482},{8,11,98},{9,11,172},{10,11,222
+-},{10,11,700},{10,11,822},{11,11,302},{11,11,778},{12,11,50},{12,11,127},{12,11,
+-396},{13,11,62},{13,11,328},{14,11,122},{147,11,72},{7,10,386},{138,10,713},{6,
+-10,7},{6,10,35},{7,10,147},{7,10,1069},{7,10,1568},{7,10,1575},{7,10,1917},{8,10
+-,43},{8,10,208},{9,10,128},{9,10,866},{10,10,20},{11,10,981},{147,10,33},{133,0,
+-26},{132,0,550},{5,11,2},{7,11,1494},{136,11,589},{6,11,512},{7,11,797},{8,11,
+-253},{9,11,77},{10,11,1},{10,11,129},{10,11,225},{11,11,118},{11,11,226},{11,11,
+-251},{11,11,430},{11,11,701},{11,11,974},{11,11,982},{12,11,64},{12,11,260},{12,
+-11,488},{140,11,690},{7,10,893},{141,10,424},{134,0,901},{136,0,822},{4,0,902},{
+-5,0,809},{134,0,122},{6,0,807},{134,0,1366},{7,0,262},{5,11,748},{134,11,553},{
+-133,0,620},{4,0,34},{5,0,574},{7,0,279},{7,0,1624},{136,0,601},{9,0,170},{6,10,
+-322},{9,10,552},{11,10,274},{13,10,209},{13,10,499},{14,10,85},{15,10,126},{145,
+-10,70},{132,0,537},{4,11,12},{7,11,420},{7,11,522},{7,11,809},{8,11,797},{141,11
+-,88},{133,0,332},{8,10,83},{8,10,742},{8,10,817},{9,10,28},{9,10,29},{9,10,885},
+-{10,10,387},{11,10,633},{11,10,740},{13,10,235},{13,10,254},{15,10,143},{143,10,
+-146},{6,0,1909},{9,0,964},{12,0,822},{12,0,854},{12,0,865},{12,0,910},{12,0,938}
+-,{15,0,169},{15,0,208},{15,0,211},{18,0,205},{18,0,206},{18,0,220},{18,0,223},{
+-152,0,24},{140,10,49},{5,11,528},{135,11,1580},{6,0,261},{8,0,182},{139,0,943},{
+-134,0,1721},{4,0,933},{133,0,880},{136,11,321},{5,11,266},{9,11,290},{9,11,364},
+-{10,11,293},{11,11,606},{142,11,45},{6,0,1609},{4,11,50},{6,11,510},{6,11,594},{
+-9,11,121},{10,11,49},{10,11,412},{139,11,834},{7,0,895},{136,11,748},{132,11,466
+-},{4,10,110},{10,10,415},{10,10,597},{142,10,206},{133,0,812},{135,11,281},{6,0,
+-1890},{6,0,1902},{6,0,1916},{9,0,929},{9,0,942},{9,0,975},{9,0,984},{9,0,986},{9
+-,0,1011},{9,0,1019},{12,0,804},{12,0,851},{12,0,867},{12,0,916},{12,0,923},{15,0
+-,194},{15,0,204},{15,0,210},{15,0,222},{15,0,223},{15,0,229},{15,0,250},{18,0,
+-179},{18,0,186},{18,0,192},{7,10,205},{135,10,2000},{132,11,667},{135,0,778},{4,
+-0,137},{7,0,1178},{135,0,1520},{134,0,1314},{4,11,242},{134,11,333},{6,0,1661},{
+-7,0,1975},{7,0,2009},{135,0,2011},{134,0,1591},{4,10,283},{135,10,1194},{11,0,
+-820},{150,0,51},{4,11,39},{5,11,36},{7,11,1843},{8,11,407},{11,11,144},{140,11,
+-523},{134,10,1720},{4,11,510},{7,11,29},{7,11,66},{7,11,1980},{10,11,487},{10,11
+-,809},{146,11,9},{5,0,89},{7,0,1915},{9,0,185},{9,0,235},{10,0,64},{10,0,270},{
+-10,0,403},{10,0,469},{10,0,529},{10,0,590},{11,0,140},{11,0,860},{13,0,1},{13,0,
+-422},{14,0,341},{14,0,364},{17,0,93},{18,0,113},{19,0,97},{147,0,113},{133,0,695
+-},{6,0,987},{134,0,1160},{5,0,6},{6,0,183},{7,0,680},{7,0,978},{7,0,1013},{7,0,
+-1055},{12,0,230},{13,0,172},{146,0,29},{134,11,570},{132,11,787},{134,11,518},{6
+-,0,29},{139,0,63},{132,11,516},{136,11,821},{132,0,311},{134,0,1740},{7,0,170},{
+-8,0,90},{8,0,177},{8,0,415},{11,0,714},{14,0,281},{136,10,735},{134,0,1961},{135
+-,11,1405},{4,11,10},{7,11,917},{139,11,786},{5,10,132},{9,10,486},{9,10,715},{10
+-,10,458},{11,10,373},{11,10,668},{11,10,795},{11,10,897},{12,10,272},{12,10,424}
+-,{12,10,539},{12,10,558},{14,10,245},{14,10,263},{14,10,264},{14,10,393},{142,10
+-,403},{11,0,91},{13,0,129},{15,0,101},{145,0,125},{135,0,1132},{4,0,494},{6,0,74
+-},{7,0,44},{7,0,407},{12,0,17},{15,0,5},{148,0,11},{133,10,379},{5,0,270},{5,11,
+-684},{6,10,89},{6,10,400},{7,10,1569},{7,10,1623},{7,10,1850},{8,10,218},{8,10,
+-422},{9,10,570},{138,10,626},{4,0,276},{133,0,296},{6,0,1523},{134,11,27},{6,10,
+-387},{7,10,882},{141,10,111},{6,10,224},{7,10,877},{137,10,647},{135,10,790},{4,
+-0,7},{5,0,90},{5,0,158},{6,0,542},{7,0,221},{7,0,1574},{9,0,490},{10,0,540},{11,
+-0,443},{139,0,757},{7,0,588},{9,0,175},{138,0,530},{135,10,394},{142,11,23},{134
+-,0,786},{135,0,580},{7,0,88},{136,0,627},{5,0,872},{6,0,57},{7,0,471},{9,0,447},
+-{137,0,454},{6,11,342},{6,11,496},{8,11,275},{137,11,206},{4,11,909},{133,11,940
+-},{6,0,735},{132,11,891},{8,0,845},{8,0,916},{135,10,1409},{5,0,31},{134,0,614},
+-{11,0,458},{12,0,15},{140,0,432},{8,0,330},{140,0,477},{4,0,530},{5,0,521},{7,0,
+-1200},{10,0,460},{132,11,687},{6,0,424},{135,0,1866},{9,0,569},{12,0,12},{12,0,
+-81},{12,0,319},{13,0,69},{14,0,259},{16,0,87},{17,0,1},{17,0,21},{17,0,24},{18,0
+-,15},{18,0,56},{18,0,59},{18,0,127},{18,0,154},{19,0,19},{148,0,31},{7,0,1302},{
+-136,10,38},{134,11,253},{5,10,261},{7,10,78},{7,10,199},{8,10,815},{9,10,126},{
+-138,10,342},{5,0,595},{135,0,1863},{6,11,41},{141,11,160},{5,0,13},{134,0,142},{
+-6,0,97},{7,0,116},{8,0,322},{8,0,755},{9,0,548},{10,0,714},{11,0,884},{13,0,324}
+-,{7,11,1304},{138,11,477},{132,10,628},{134,11,1718},{7,10,266},{136,10,804},{
+-135,10,208},{7,0,1021},{6,10,79},{135,10,1519},{7,0,1472},{135,0,1554},{6,11,362
+-},{146,11,51},{7,0,1071},{7,0,1541},{7,0,1767},{7,0,1806},{11,0,162},{11,0,242},
+-{11,0,452},{12,0,605},{15,0,26},{144,0,44},{136,10,741},{133,11,115},{145,0,115}
+-,{134,10,376},{6,0,1406},{134,0,1543},{5,11,193},{12,11,178},{13,11,130},{145,11
+-,84},{135,0,1111},{8,0,1},{9,0,650},{10,0,326},{5,11,705},{137,11,606},{5,0,488}
+-,{6,0,527},{7,0,489},{7,0,1636},{8,0,121},{8,0,144},{8,0,359},{9,0,193},{9,0,241
+-},{9,0,336},{9,0,882},{11,0,266},{11,0,372},{11,0,944},{12,0,401},{140,0,641},{
+-135,11,174},{6,0,267},{7,10,244},{7,10,632},{7,10,1609},{8,10,178},{8,10,638},{
+-141,10,58},{134,0,1983},{134,0,1155},{134,0,1575},{134,0,1438},{9,0,31},{10,0,
+-244},{10,0,699},{12,0,149},{141,0,497},{133,0,377},{4,11,122},{5,11,796},{5,11,
+-952},{6,11,1660},{6,11,1671},{8,11,567},{9,11,687},{9,11,742},{10,11,686},{11,11
+-,356},{11,11,682},{140,11,281},{145,0,101},{11,11,0},{144,11,78},{5,11,179},{5,
+-10,791},{7,11,1095},{135,11,1213},{8,11,372},{9,11,122},{138,11,175},{7,10,686},
+-{8,10,33},{8,10,238},{10,10,616},{11,10,467},{11,10,881},{13,10,217},{13,10,253}
+-,{142,10,268},{9,0,476},{4,11,66},{7,11,722},{135,11,904},{7,11,352},{137,11,684
+-},{135,0,2023},{135,0,1836},{132,10,447},{5,0,843},{144,0,35},{137,11,779},{141,
+-11,35},{4,10,128},{5,10,415},{6,10,462},{7,10,294},{7,10,578},{10,10,710},{139,
+-10,86},{132,0,554},{133,0,536},{136,10,587},{5,0,207},{9,0,79},{11,0,625},{145,0
+-,7},{7,0,1371},{6,10,427},{138,10,692},{4,0,424},{4,10,195},{135,10,802},{8,0,
+-785},{133,11,564},{135,0,336},{4,0,896},{6,0,1777},{134,11,556},{137,11,103},{
+-134,10,1683},{7,11,544},{8,11,719},{138,11,61},{138,10,472},{4,11,5},{5,11,498},
+-{136,11,637},{7,0,750},{9,0,223},{11,0,27},{11,0,466},{12,0,624},{14,0,265},{146
+-,0,61},{12,0,238},{18,0,155},{12,11,238},{146,11,155},{151,10,28},{133,11,927},{
+-12,0,383},{5,10,3},{8,10,578},{9,10,118},{10,10,705},{141,10,279},{4,11,893},{5,
+-11,780},{133,11,893},{4,0,603},{133,0,661},{4,0,11},{6,0,128},{7,0,231},{7,0,
+-1533},{10,0,725},{5,10,229},{5,11,238},{135,11,1350},{8,10,102},{10,10,578},{10,
+-10,672},{12,10,496},{13,10,408},{14,10,121},{145,10,106},{132,0,476},{134,0,1552
+-},{134,11,1729},{8,10,115},{8,10,350},{9,10,489},{10,10,128},{11,10,306},{12,10,
+-373},{14,10,30},{17,10,79},{19,10,80},{150,10,55},{135,0,1807},{4,0,680},{4,11,
+-60},{7,11,760},{7,11,1800},{8,11,314},{9,11,700},{139,11,487},{4,10,230},{5,10,
+-702},{148,11,94},{132,11,228},{139,0,435},{9,0,20},{10,0,324},{10,0,807},{139,0,
+-488},{6,10,1728},{136,11,419},{4,10,484},{18,10,26},{19,10,42},{20,10,43},{21,10
+-,0},{23,10,27},{152,10,14},{135,0,1431},{133,11,828},{5,0,112},{6,0,103},{6,0,
+-150},{7,0,1303},{9,0,292},{10,0,481},{20,0,13},{7,11,176},{7,11,178},{7,11,1110}
+-,{10,11,481},{148,11,13},{138,0,356},{4,11,51},{5,11,39},{6,11,4},{7,11,591},{7,
+-11,849},{7,11,951},{7,11,1129},{7,11,1613},{7,11,1760},{7,11,1988},{9,11,434},{
+-10,11,754},{11,11,25},{11,11,37},{139,11,414},{6,0,1963},{134,0,2000},{132,10,
+-633},{6,0,1244},{133,11,902},{135,11,928},{140,0,18},{138,0,204},{135,11,1173},{
+-134,0,867},{4,0,708},{8,0,15},{9,0,50},{9,0,386},{11,0,18},{11,0,529},{140,0,228
+-},{134,11,270},{4,0,563},{7,0,109},{7,0,592},{7,0,637},{7,0,770},{8,0,463},{9,0,
+-60},{9,0,335},{9,0,904},{10,0,73},{11,0,434},{12,0,585},{13,0,331},{18,0,110},{
+-148,0,60},{132,0,502},{14,11,359},{19,11,52},{148,11,47},{6,11,377},{7,11,1025},
+-{9,11,613},{145,11,104},{6,0,347},{10,0,161},{5,10,70},{5,10,622},{6,10,334},{7,
+-10,1032},{9,10,171},{11,10,26},{11,10,213},{11,10,637},{11,10,707},{12,10,202},{
+-12,10,380},{13,10,226},{13,10,355},{14,10,222},{145,10,42},{132,11,416},{4,0,33}
+-,{5,0,102},{6,0,284},{7,0,1079},{7,0,1423},{7,0,1702},{8,0,470},{9,0,554},{9,0,
+-723},{11,0,333},{142,11,372},{5,11,152},{5,11,197},{7,11,340},{7,11,867},{10,11,
+-548},{10,11,581},{11,11,6},{12,11,3},{12,11,19},{14,11,110},{142,11,289},{7,0,
+-246},{135,0,840},{6,0,10},{8,0,571},{9,0,739},{143,0,91},{6,0,465},{7,0,1465},{4
+-,10,23},{4,10,141},{5,10,313},{5,10,1014},{6,10,50},{7,10,142},{7,10,559},{8,10,
+-640},{9,10,460},{9,10,783},{11,10,741},{12,10,183},{141,10,488},{133,0,626},{136
+-,0,614},{138,0,237},{7,11,34},{7,11,190},{8,11,28},{8,11,141},{8,11,444},{8,11,
+-811},{9,11,468},{11,11,334},{12,11,24},{12,11,386},{140,11,576},{133,11,757},{5,
+-0,18},{6,0,526},{13,0,24},{13,0,110},{19,0,5},{147,0,44},{6,0,506},{134,11,506},
+-{135,11,1553},{4,0,309},{5,0,462},{7,0,970},{7,0,1097},{22,0,30},{22,0,33},{7,11
+-,1385},{11,11,582},{11,11,650},{11,11,901},{11,11,949},{12,11,232},{12,11,236},{
+-13,11,413},{13,11,501},{146,11,116},{9,0,140},{5,10,222},{138,10,534},{6,0,1056}
+-,{137,10,906},{134,0,1704},{138,10,503},{134,0,1036},{5,10,154},{7,10,1491},{10,
+-10,379},{138,10,485},{4,11,383},{133,10,716},{134,0,1315},{5,0,86},{7,0,743},{9,
+-0,85},{10,0,281},{10,0,432},{11,0,825},{12,0,251},{13,0,118},{142,0,378},{8,0,
+-264},{4,10,91},{5,10,388},{5,10,845},{6,10,206},{6,10,252},{6,10,365},{7,10,136}
+-,{7,10,531},{136,10,621},{5,0,524},{133,0,744},{5,11,277},{141,11,247},{132,11,
+-435},{10,0,107},{140,0,436},{132,0,927},{10,0,123},{12,0,670},{146,0,94},{7,0,
+-1149},{9,0,156},{138,0,957},{5,11,265},{6,11,212},{135,11,28},{133,0,778},{133,0
+-,502},{8,0,196},{10,0,283},{139,0,406},{135,10,576},{136,11,535},{134,0,1312},{5
+-,10,771},{5,10,863},{5,10,898},{6,10,1632},{6,10,1644},{134,10,1780},{5,0,855},{
+-5,10,331},{135,11,1487},{132,11,702},{5,11,808},{135,11,2045},{7,0,1400},{9,0,
+-446},{138,0,45},{140,10,632},{132,0,1003},{5,11,166},{8,11,739},{140,11,511},{5,
+-10,107},{7,10,201},{136,10,518},{6,10,446},{135,10,1817},{134,0,1532},{134,0,
+-1097},{4,11,119},{5,11,170},{5,11,447},{7,11,1708},{7,11,1889},{9,11,357},{9,11,
+-719},{12,11,486},{140,11,596},{9,10,851},{141,10,510},{7,0,612},{8,0,545},{8,0,
+-568},{8,0,642},{9,0,717},{10,0,541},{10,0,763},{11,0,449},{12,0,489},{13,0,153},
+-{13,0,296},{14,0,138},{14,0,392},{15,0,50},{16,0,6},{16,0,12},{20,0,9},{132,10,
+-504},{4,11,450},{135,11,1158},{11,0,54},{13,0,173},{13,0,294},{5,10,883},{5,10,
+-975},{8,10,392},{148,10,7},{13,0,455},{15,0,99},{15,0,129},{144,0,68},{135,0,172
+-},{132,11,754},{5,10,922},{134,10,1707},{134,0,1029},{17,11,39},{148,11,36},{4,0
+-,568},{5,10,993},{7,10,515},{137,10,91},{132,0,732},{10,0,617},{138,11,617},{134
+-,0,974},{7,0,989},{10,0,377},{12,0,363},{13,0,68},{13,0,94},{14,0,108},{142,0,
+-306},{136,0,733},{132,0,428},{7,0,1789},{135,11,1062},{7,0,2015},{140,0,665},{
+-135,10,1433},{5,0,287},{7,10,921},{8,10,580},{8,10,593},{8,10,630},{138,10,28},{
+-138,0,806},{4,10,911},{5,10,867},{5,10,1013},{7,10,2034},{8,10,798},{136,10,813}
+-,{134,0,1539},{8,11,523},{150,11,34},{135,11,740},{7,11,238},{7,11,2033},{8,11,
+-120},{8,11,188},{8,11,659},{9,11,598},{10,11,466},{12,11,342},{12,11,588},{13,11
+-,503},{14,11,246},{143,11,92},{7,0,1563},{141,0,182},{5,10,135},{6,10,519},{7,10
+-,1722},{10,10,271},{11,10,261},{145,10,54},{14,10,338},{148,10,81},{7,0,484},{4,
+-10,300},{133,10,436},{145,11,114},{6,0,1623},{134,0,1681},{133,11,640},{4,11,201
+-},{7,11,1744},{8,11,602},{11,11,247},{11,11,826},{145,11,65},{8,11,164},{146,11,
+-62},{6,0,1833},{6,0,1861},{136,0,878},{134,0,1569},{8,10,357},{10,10,745},{14,10
+-,426},{17,10,94},{147,10,57},{12,0,93},{12,0,501},{13,0,362},{14,0,151},{15,0,40
+-},{15,0,59},{16,0,46},{17,0,25},{18,0,14},{18,0,134},{19,0,25},{19,0,69},{20,0,
+-16},{20,0,19},{20,0,66},{21,0,23},{21,0,25},{150,0,42},{6,0,1748},{8,0,715},{9,0
+-,802},{10,0,46},{10,0,819},{13,0,308},{14,0,351},{14,0,363},{146,0,67},{132,0,
+-994},{4,0,63},{133,0,347},{132,0,591},{133,0,749},{7,11,1577},{10,11,304},{10,11
+-,549},{11,11,424},{12,11,365},{13,11,220},{13,11,240},{142,11,33},{133,0,366},{7
+-,0,557},{12,0,547},{14,0,86},{133,10,387},{135,0,1747},{132,11,907},{5,11,100},{
+-10,11,329},{12,11,416},{149,11,29},{4,10,6},{5,10,708},{136,10,75},{7,10,1351},{
+-9,10,581},{10,10,639},{11,10,453},{140,10,584},{7,0,89},{132,10,303},{138,10,772
+-},{132,11,176},{5,11,636},{5,11,998},{8,11,26},{137,11,358},{7,11,9},{7,11,1508}
+-,{9,11,317},{10,11,210},{10,11,292},{10,11,533},{11,11,555},{12,11,526},{12,11,
+-607},{13,11,263},{13,11,459},{142,11,271},{134,0,1463},{6,0,772},{6,0,1137},{139
+-,11,595},{7,0,977},{139,11,66},{138,0,893},{20,0,48},{148,11,48},{5,0,824},{133,
+-0,941},{134,11,295},{7,0,1543},{7,0,1785},{10,0,690},{4,10,106},{139,10,717},{7,
+-0,440},{8,0,230},{139,0,106},{5,10,890},{133,10,988},{6,10,626},{142,10,431},{10
+-,11,127},{141,11,27},{17,0,32},{10,10,706},{150,10,44},{132,0,216},{137,0,332},{
+-4,10,698},{136,11,119},{139,11,267},{138,10,17},{11,11,526},{11,11,939},{141,11,
+-290},{7,11,1167},{11,11,934},{13,11,391},{145,11,76},{139,11,39},{134,10,84},{4,
+-0,914},{5,0,800},{133,0,852},{10,0,416},{141,0,115},{7,0,564},{142,0,168},{4,0,
+-918},{133,0,876},{134,0,1764},{152,0,3},{4,0,92},{5,0,274},{7,11,126},{136,11,84
+-},{140,10,498},{136,11,790},{8,0,501},{5,10,986},{6,10,130},{7,10,1582},{8,10,
+-458},{10,10,101},{10,10,318},{138,10,823},{6,11,64},{12,11,377},{141,11,309},{5,
+-0,743},{138,0,851},{4,0,49},{7,0,280},{135,0,1633},{134,0,879},{136,0,47},{7,10,
+-1644},{137,10,129},{132,0,865},{134,0,1202},{9,11,34},{139,11,484},{135,10,997},
+-{5,0,272},{5,0,908},{5,0,942},{8,0,197},{9,0,47},{11,0,538},{139,0,742},{6,11,
+-1700},{7,11,26},{7,11,293},{7,11,382},{7,11,1026},{7,11,1087},{7,11,2027},{8,11,
+-24},{8,11,114},{8,11,252},{8,11,727},{8,11,729},{9,11,30},{9,11,199},{9,11,231},
+-{9,11,251},{9,11,334},{9,11,361},{9,11,488},{9,11,712},{10,11,55},{10,11,60},{10
+-,11,232},{10,11,332},{10,11,384},{10,11,396},{10,11,504},{10,11,542},{10,11,652}
+-,{11,11,20},{11,11,48},{11,11,207},{11,11,291},{11,11,298},{11,11,342},{11,11,
+-365},{11,11,394},{11,11,620},{11,11,705},{11,11,1017},{12,11,123},{12,11,340},{
+-12,11,406},{12,11,643},{13,11,61},{13,11,269},{13,11,311},{13,11,319},{13,11,486
+-},{14,11,234},{15,11,62},{15,11,85},{16,11,71},{18,11,119},{148,11,105},{6,0,
+-1455},{150,11,37},{135,10,1927},{135,0,1911},{137,0,891},{7,10,1756},{137,10,98}
+-,{7,10,1046},{139,10,160},{132,0,761},{6,11,379},{7,11,270},{7,11,1116},{8,11,
+-176},{8,11,183},{9,11,432},{9,11,661},{12,11,247},{12,11,617},{146,11,125},{6,10
+-,45},{7,10,433},{8,10,129},{9,10,21},{10,10,392},{11,10,79},{12,10,499},{13,10,
+-199},{141,10,451},{4,0,407},{5,11,792},{133,11,900},{132,0,560},{135,0,183},{13,
+-0,490},{7,10,558},{136,10,353},{4,0,475},{6,0,731},{11,0,35},{13,0,71},{13,0,177
+-},{14,0,422},{133,10,785},{8,10,81},{9,10,189},{9,10,201},{11,10,478},{11,10,712
+-},{141,10,338},{4,0,418},{4,0,819},{133,10,353},{151,10,26},{4,11,901},{133,11,
+-776},{132,0,575},{7,0,818},{16,0,92},{17,0,14},{17,0,45},{18,0,75},{148,0,18},{6
+-,0,222},{7,0,636},{7,0,1620},{8,0,409},{9,0,693},{139,0,77},{6,10,25},{7,10,855}
+-,{7,10,1258},{144,10,32},{6,0,1880},{6,0,1887},{6,0,1918},{6,0,1924},{9,0,967},{
+-9,0,995},{9,0,1015},{12,0,826},{12,0,849},{12,0,857},{12,0,860},{12,0,886},{12,0
+-,932},{18,0,228},{18,0,231},{146,0,240},{134,0,633},{134,0,1308},{4,11,37},{5,11
+-,334},{135,11,1253},{10,0,86},{4,10,4},{7,10,1118},{7,10,1320},{7,10,1706},{8,10
+-,277},{9,10,622},{11,10,724},{12,10,350},{12,10,397},{13,10,28},{13,10,159},{15,
+-10,89},{18,10,5},{19,10,9},{20,10,34},{150,10,47},{132,11,508},{137,11,448},{12,
+-11,107},{146,11,31},{132,0,817},{134,0,663},{133,0,882},{134,0,914},{132,11,540}
+-,{132,11,533},{136,11,608},{8,0,885},{138,0,865},{132,0,426},{6,0,58},{7,0,745},
+-{7,0,1969},{8,0,399},{8,0,675},{9,0,479},{9,0,731},{10,0,330},{10,0,593},{10,0,
+-817},{11,0,32},{11,0,133},{11,0,221},{145,0,68},{134,10,255},{7,0,102},{137,0,
+-538},{137,10,216},{7,11,253},{136,11,549},{135,11,912},{9,10,183},{139,10,286},{
+-11,10,956},{151,10,3},{8,11,527},{18,11,60},{147,11,24},{4,10,536},{7,10,1141},{
+-10,10,723},{139,10,371},{133,11,920},{7,0,876},{135,10,285},{135,10,560},{132,10
+-,690},{142,11,126},{11,10,33},{12,10,571},{149,10,1},{133,0,566},{9,0,139},{10,0
+-,399},{11,0,469},{12,0,634},{13,0,223},{132,11,483},{6,0,48},{135,0,63},{18,0,12
+-},{7,10,1862},{12,10,491},{12,10,520},{13,10,383},{142,10,244},{135,11,1665},{
+-132,11,448},{9,11,495},{146,11,104},{6,0,114},{7,0,1224},{7,0,1556},{136,0,3},{4
+-,10,190},{133,10,554},{8,0,576},{9,0,267},{133,10,1001},{133,10,446},{133,0,933}
+-,{139,11,1009},{8,11,653},{13,11,93},{147,11,14},{6,0,692},{6,0,821},{134,0,1077
+-},{5,11,172},{135,11,801},{138,0,752},{4,0,375},{134,0,638},{134,0,1011},{140,11
+-,540},{9,0,96},{133,11,260},{139,11,587},{135,10,1231},{12,0,30},{13,0,148},{14,
+-0,87},{14,0,182},{16,0,42},{20,0,70},{132,10,304},{6,0,1398},{7,0,56},{7,0,1989}
+-,{8,0,337},{8,0,738},{9,0,600},{12,0,37},{13,0,447},{142,0,92},{138,0,666},{5,0,
+-394},{7,0,487},{136,0,246},{9,0,437},{6,10,53},{6,10,199},{7,10,1408},{8,10,32},
+-{8,10,93},{10,10,397},{10,10,629},{11,10,593},{11,10,763},{13,10,326},{145,10,35
+-},{134,10,105},{9,0,320},{10,0,506},{138,10,794},{7,11,57},{8,11,167},{8,11,375}
+-,{9,11,82},{9,11,561},{10,11,620},{10,11,770},{11,10,704},{141,10,396},{6,0,1003
+-},{5,10,114},{5,10,255},{141,10,285},{7,0,866},{135,0,1163},{133,11,531},{132,0,
+-328},{7,10,2035},{8,10,19},{9,10,89},{138,10,831},{8,11,194},{136,11,756},{136,0
+-,1000},{5,11,453},{134,11,441},{4,0,101},{5,0,833},{7,0,1171},{136,0,744},{133,0
+-,726},{136,10,746},{138,0,176},{6,0,9},{6,0,397},{7,0,53},{7,0,1742},{10,0,632},
+-{11,0,828},{140,0,146},{135,11,22},{145,11,64},{132,0,839},{11,0,417},{12,0,223}
+-,{140,0,265},{4,11,102},{7,11,815},{7,11,1699},{139,11,964},{5,10,955},{136,10,
+-814},{6,0,1931},{6,0,2007},{18,0,246},{146,0,247},{8,0,198},{11,0,29},{140,0,534
+-},{135,0,1771},{6,0,846},{7,11,1010},{11,11,733},{11,11,759},{12,11,563},{13,11,
+-34},{14,11,101},{18,11,45},{146,11,129},{4,0,186},{5,0,157},{8,0,168},{138,0,6},
+-{132,11,899},{133,10,56},{148,10,100},{133,0,875},{5,0,773},{5,0,991},{6,0,1635}
+-,{134,0,1788},{6,0,1274},{9,0,477},{141,0,78},{4,0,639},{7,0,111},{8,0,581},{12,
+-0,177},{6,11,52},{9,11,104},{9,11,559},{10,10,4},{10,10,13},{11,10,638},{12,11,
+-308},{19,11,87},{148,10,57},{132,11,604},{4,11,301},{133,10,738},{133,10,758},{
+-134,0,1747},{7,11,1440},{11,11,854},{11,11,872},{11,11,921},{12,11,551},{13,11,
+-472},{142,11,367},{7,0,1364},{7,0,1907},{141,0,158},{134,0,873},{4,0,404},{4,0,
+-659},{7,0,552},{135,0,675},{135,10,1112},{139,10,328},{7,11,508},{137,10,133},{
+-133,0,391},{5,10,110},{6,10,169},{6,10,1702},{7,10,400},{8,10,538},{9,10,184},{9
+-,10,524},{140,10,218},{6,11,310},{7,11,1849},{8,11,72},{8,11,272},{8,11,431},{9,
+-11,12},{9,11,351},{10,11,563},{10,11,630},{10,11,810},{11,11,367},{11,11,599},{
+-11,11,686},{140,11,672},{5,0,540},{6,0,1697},{136,0,668},{132,0,883},{134,0,78},
+-{12,0,628},{18,0,79},{6,10,133},{9,10,353},{139,10,993},{6,11,181},{7,11,537},{8
+-,11,64},{9,11,127},{10,11,496},{12,11,510},{141,11,384},{6,10,93},{7,10,1422},{7
+-,10,1851},{8,10,673},{9,10,529},{140,10,43},{137,10,371},{134,0,1460},{134,0,962
+-},{4,11,244},{135,11,233},{9,10,25},{10,10,467},{138,10,559},{4,10,335},{135,10,
+-942},{133,0,460},{135,11,334},{134,11,1650},{4,0,199},{139,0,34},{5,10,601},{8,
+-10,39},{10,10,773},{11,10,84},{12,10,205},{142,10,1},{133,10,870},{134,0,388},{
+-14,0,474},{148,0,120},{133,11,369},{139,0,271},{4,0,511},{9,0,333},{9,0,379},{10
+-,0,602},{11,0,441},{11,0,723},{11,0,976},{12,0,357},{132,10,181},{134,0,608},{
+-134,10,1652},{22,0,49},{137,11,338},{140,0,988},{134,0,617},{5,0,938},{136,0,707
+-},{132,10,97},{5,10,147},{6,10,286},{7,10,1362},{141,10,176},{6,0,756},{134,0,
+-1149},{133,11,896},{6,10,375},{7,10,169},{7,10,254},{136,10,780},{134,0,1583},{
+-135,10,1447},{139,0,285},{7,11,1117},{8,11,393},{136,11,539},{135,0,344},{6,0,
+-469},{7,0,1709},{138,0,515},{5,10,629},{135,10,1549},{5,11,4},{5,11,810},{6,11,
+-13},{6,11,538},{6,11,1690},{6,11,1726},{7,11,499},{7,11,1819},{8,11,148},{8,11,
+-696},{8,11,791},{12,11,125},{13,11,54},{143,11,9},{135,11,1268},{137,0,404},{132
+-,0,500},{5,0,68},{134,0,383},{11,0,216},{139,0,340},{4,11,925},{5,11,803},{8,11,
+-698},{138,11,828},{4,0,337},{6,0,353},{7,0,1934},{8,0,488},{137,0,429},{7,0,236}
+-,{7,0,1795},{8,0,259},{9,0,135},{9,0,177},{9,0,860},{10,0,825},{11,0,115},{11,0,
+-370},{11,0,405},{11,0,604},{12,0,10},{12,0,667},{12,0,669},{13,0,76},{14,0,310},
+-{15,0,76},{15,0,147},{148,0,23},{4,0,15},{4,0,490},{5,0,22},{6,0,244},{7,0,40},{
+-7,0,200},{7,0,906},{7,0,1199},{9,0,616},{10,0,716},{11,0,635},{11,0,801},{140,0,
+-458},{12,0,756},{132,10,420},{134,0,1504},{6,0,757},{133,11,383},{6,0,1266},{135
+-,0,1735},{5,0,598},{7,0,791},{8,0,108},{9,0,123},{7,10,1570},{140,10,542},{142,
+-11,410},{9,11,660},{138,11,347}
+-};
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_STATIC_DICT_LUT_H_ */
+diff --git a/modules/brotli/enc/utf8_util.c b/modules/brotli/enc/utf8_util.c
+deleted file mode 100644
+--- a/modules/brotli/enc/utf8_util.c
++++ /dev/null
+@@ -1,85 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Heuristics for deciding about the UTF8-ness of strings. */
+-
+-#include "./utf8_util.h"
+-
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static size_t BrotliParseAsUTF8(
+-    int* symbol, const uint8_t* input, size_t size) {
+-  /* ASCII */
+-  if ((input[0] & 0x80) == 0) {
+-    *symbol = input[0];
+-    if (*symbol > 0) {
+-      return 1;
+-    }
+-  }
+-  /* 2-byte UTF8 */
+-  if (size > 1u &&
+-      (input[0] & 0xE0) == 0xC0 &&
+-      (input[1] & 0xC0) == 0x80) {
+-    *symbol = (((input[0] & 0x1F) << 6) |
+-               (input[1] & 0x3F));
+-    if (*symbol > 0x7F) {
+-      return 2;
+-    }
+-  }
+-  /* 3-byte UFT8 */
+-  if (size > 2u &&
+-      (input[0] & 0xF0) == 0xE0 &&
+-      (input[1] & 0xC0) == 0x80 &&
+-      (input[2] & 0xC0) == 0x80) {
+-    *symbol = (((input[0] & 0x0F) << 12) |
+-               ((input[1] & 0x3F) << 6) |
+-               (input[2] & 0x3F));
+-    if (*symbol > 0x7FF) {
+-      return 3;
+-    }
+-  }
+-  /* 4-byte UFT8 */
+-  if (size > 3u &&
+-      (input[0] & 0xF8) == 0xF0 &&
+-      (input[1] & 0xC0) == 0x80 &&
+-      (input[2] & 0xC0) == 0x80 &&
+-      (input[3] & 0xC0) == 0x80) {
+-    *symbol = (((input[0] & 0x07) << 18) |
+-               ((input[1] & 0x3F) << 12) |
+-               ((input[2] & 0x3F) << 6) |
+-               (input[3] & 0x3F));
+-    if (*symbol > 0xFFFF && *symbol <= 0x10FFFF) {
+-      return 4;
+-    }
+-  }
+-  /* Not UTF8, emit a special symbol above the UTF8-code space */
+-  *symbol = 0x110000 | input[0];
+-  return 1;
+-}
+-
+-/* Returns 1 if at least min_fraction of the data is UTF8-encoded.*/
+-BROTLI_BOOL BrotliIsMostlyUTF8(
+-    const uint8_t* data, const size_t pos, const size_t mask,
+-    const size_t length, const double min_fraction) {
+-  size_t size_utf8 = 0;
+-  size_t i = 0;
+-  while (i < length) {
+-    int symbol;
+-    size_t bytes_read =
+-        BrotliParseAsUTF8(&symbol, &data[(pos + i) & mask], length - i);
+-    i += bytes_read;
+-    if (symbol < 0x110000) size_utf8 += bytes_read;
+-  }
+-  return TO_BROTLI_BOOL((double)size_utf8 > min_fraction * (double)length);
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+diff --git a/modules/brotli/enc/utf8_util.h b/modules/brotli/enc/utf8_util.h
+deleted file mode 100644
+--- a/modules/brotli/enc/utf8_util.h
++++ /dev/null
+@@ -1,32 +0,0 @@
+-/* Copyright 2013 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Heuristics for deciding about the UTF8-ness of strings. */
+-
+-#ifndef BROTLI_ENC_UTF8_UTIL_H_
+-#define BROTLI_ENC_UTF8_UTIL_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-static const double kMinUTF8Ratio = 0.75;
+-
+-/* Returns 1 if at least min_fraction of the bytes between pos and
+-   pos + length in the (data, mask) ring-buffer is UTF8-encoded, otherwise
+-   returns 0. */
+-BROTLI_INTERNAL BROTLI_BOOL BrotliIsMostlyUTF8(
+-    const uint8_t* data, const size_t pos, const size_t mask,
+-    const size_t length, const double min_fraction);
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_UTF8_UTIL_H_ */
+diff --git a/modules/brotli/enc/write_bits.h b/modules/brotli/enc/write_bits.h
+deleted file mode 100644
+--- a/modules/brotli/enc/write_bits.h
++++ /dev/null
+@@ -1,87 +0,0 @@
+-/* Copyright 2010 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Write bits into a byte array. */
+-
+-#ifndef BROTLI_ENC_WRITE_BITS_H_
+-#define BROTLI_ENC_WRITE_BITS_H_
+-
+-#include "../common/platform.h"
+-#include <brotli/types.h>
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-extern "C" {
+-#endif
+-
+-/* This function writes bits into bytes in increasing addresses, and within
+-   a byte least-significant-bit first.
+-
+-   The function can write up to 56 bits in one go with WriteBits
+-   Example: let's assume that 3 bits (Rs below) have been written already:
+-
+-   BYTE-0     BYTE+1       BYTE+2
+-
+-   0000 0RRR    0000 0000    0000 0000
+-
+-   Now, we could write 5 or less bits in MSB by just shifting by 3
+-   and OR'ing to BYTE-0.
+-
+-   For n bits, we take the last 5 bits, OR that with high bits in BYTE-0,
+-   and locate the rest in BYTE+1, BYTE+2, etc. */
+-static BROTLI_INLINE void BrotliWriteBits(size_t n_bits,
+-                                          uint64_t bits,
+-                                          size_t* BROTLI_RESTRICT pos,
+-                                          uint8_t* BROTLI_RESTRICT array) {
+-  BROTLI_LOG(("WriteBits  %2d  0x%08x%08x  %10d\n", (int)n_bits,
+-      (uint32_t)(bits >> 32), (uint32_t)(bits & 0xFFFFFFFF),
+-      (int)*pos));
+-  BROTLI_DCHECK((bits >> n_bits) == 0);
+-  BROTLI_DCHECK(n_bits <= 56);
+-#if defined(BROTLI_LITTLE_ENDIAN)
+-  /* This branch of the code can write up to 56 bits at a time,
+-     7 bits are lost by being perhaps already in *p and at least
+-     1 bit is needed to initialize the bit-stream ahead (i.e. if 7
+-     bits are in *p and we write 57 bits, then the next write will
+-     access a byte that was never initialized). */
+-  {
+-    uint8_t* p = &array[*pos >> 3];
+-    uint64_t v = (uint64_t)(*p);  /* Zero-extend 8 to 64 bits. */
+-    v |= bits << (*pos & 7);
+-    BROTLI_UNALIGNED_STORE64LE(p, v);  /* Set some bits. */
+-    *pos += n_bits;
+-  }
+-#else
+-  /* implicit & 0xFF is assumed for uint8_t arithmetics */
+-  {
+-    uint8_t* array_pos = &array[*pos >> 3];
+-    const size_t bits_reserved_in_first_byte = (*pos & 7);
+-    size_t bits_left_to_write;
+-    bits <<= bits_reserved_in_first_byte;
+-    *array_pos++ |= (uint8_t)bits;
+-    for (bits_left_to_write = n_bits + bits_reserved_in_first_byte;
+-         bits_left_to_write >= 9;
+-         bits_left_to_write -= 8) {
+-      bits >>= 8;
+-      *array_pos++ = (uint8_t)bits;
+-    }
+-    *array_pos = 0;
+-    *pos += n_bits;
+-  }
+-#endif
+-}
+-
+-static BROTLI_INLINE void BrotliWriteBitsPrepareStorage(
+-    size_t pos, uint8_t* array) {
+-  BROTLI_LOG(("WriteBitsPrepareStorage            %10d\n", (int)pos));
+-  BROTLI_DCHECK((pos & 7) == 0);
+-  array[pos >> 3] = 0;
+-}
+-
+-#if defined(__cplusplus) || defined(c_plusplus)
+-}  /* extern "C" */
+-#endif
+-
+-#endif  /* BROTLI_ENC_WRITE_BITS_H_ */
+diff --git a/modules/brotli/moz.build b/modules/brotli/moz.build
+--- a/modules/brotli/moz.build
++++ b/modules/brotli/moz.build
+@@ -27,41 +27,8 @@ UNIFIED_SOURCES += [
+ ]
+ 
+ # We allow warnings for third-party code that can be updated from upstream.
+ AllowCompilerWarnings()
+ 
+ CFLAGS += ['-DBROTLI_BUILD_PORTABLE']
+ 
+ Library('brotli')
+-
+-HostProgram('brotli')
+-
+-HOST_SOURCES += UNIFIED_SOURCES
+-
+-HOST_SOURCES += [
+-    'enc/backward_references.c',
+-    'enc/backward_references_hq.c',
+-    'enc/bit_cost.c',
+-    'enc/block_splitter.c',
+-    'enc/brotli_bit_stream.c',
+-    'enc/cluster.c',
+-    'enc/command.c',
+-    'enc/compress_fragment.c',
+-    'enc/compress_fragment_two_pass.c',
+-    'enc/dictionary_hash.c',
+-    'enc/encode.c',
+-    'enc/encoder_dict.c',
+-    'enc/entropy_encode.c',
+-    'enc/fast_log.c',
+-    'enc/histogram.c',
+-    'enc/literal_cost.c',
+-    'enc/memory.c',
+-    'enc/metablock.c',
+-    'enc/static_dict.c',
+-    'enc/utf8_util.c',
+-    'tools/brotli.c',
+-]
+-
+-if CONFIG['HOST_CC_TYPE'] not in ('msvc', 'clang-cl'):
+-    HOST_OS_LIBS += [
+-        'm' # for log2() function used by Brotli encoder
+-    ]
+diff --git a/modules/brotli/tools/brotli.c b/modules/brotli/tools/brotli.c
+deleted file mode 100644
+--- a/modules/brotli/tools/brotli.c
++++ /dev/null
+@@ -1,1116 +0,0 @@
+-/* Copyright 2014 Google Inc. All Rights Reserved.
+-
+-   Distributed under MIT license.
+-   See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
+-*/
+-
+-/* Command line interface for Brotli library. */
+-
+-/* Mute strerror/strcpy warnings. */
+-#if !defined(_CRT_SECURE_NO_WARNINGS)
+-#define _CRT_SECURE_NO_WARNINGS
+-#endif
+-
+-#include <errno.h>
+-#include <fcntl.h>
+-#include <stdio.h>
+-#include <stdlib.h>
+-#include <string.h>
+-#include <sys/stat.h>
+-#include <sys/types.h>
+-#include <time.h>
+-
+-#include "../common/constants.h"
+-#include "../common/version.h"
+-#include <brotli/decode.h>
+-#include <brotli/encode.h>
+-
+-#if !defined(_WIN32)
+-#include <unistd.h>
+-#include <utime.h>
+-#define MAKE_BINARY(FILENO) (FILENO)
+-#else
+-#include <io.h>
+-#include <share.h>
+-#include <sys/utime.h>
+-
+-#define MAKE_BINARY(FILENO) (_setmode((FILENO), _O_BINARY), (FILENO))
+-
+-#if !defined(__MINGW32__)
+-#define STDIN_FILENO _fileno(stdin)
+-#define STDOUT_FILENO _fileno(stdout)
+-#define S_IRUSR S_IREAD
+-#define S_IWUSR S_IWRITE
+-#endif
+-
+-#define fdopen _fdopen
+-#define isatty _isatty
+-#define unlink _unlink
+-#define utimbuf _utimbuf
+-#define utime _utime
+-
+-#define fopen ms_fopen
+-#define open ms_open
+-
+-#define chmod(F, P) (0)
+-#define chown(F, O, G) (0)
+-
+-#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+-#define fseek _fseeki64
+-#define ftell _ftelli64
+-#endif
+-
+-static FILE* ms_fopen(const char* filename, const char* mode) {
+-  FILE* result = 0;
+-  fopen_s(&result, filename, mode);
+-  return result;
+-}
+-
+-static int ms_open(const char* filename, int oflag, int pmode) {
+-  int result = -1;
+-  _sopen_s(&result, filename, oflag | O_BINARY, _SH_DENYNO, pmode);
+-  return result;
+-}
+-#endif  /* WIN32 */
+-
+-typedef enum {
+-  COMMAND_COMPRESS,
+-  COMMAND_DECOMPRESS,
+-  COMMAND_HELP,
+-  COMMAND_INVALID,
+-  COMMAND_TEST_INTEGRITY,
+-  COMMAND_NOOP,
+-  COMMAND_VERSION
+-} Command;
+-
+-#define DEFAULT_LGWIN 24
+-#define DEFAULT_SUFFIX ".br"
+-#define MAX_OPTIONS 20
+-
+-typedef struct {
+-  /* Parameters */
+-  int quality;
+-  int lgwin;
+-  int verbosity;
+-  BROTLI_BOOL force_overwrite;
+-  BROTLI_BOOL junk_source;
+-  BROTLI_BOOL copy_stat;
+-  BROTLI_BOOL write_to_stdout;
+-  BROTLI_BOOL test_integrity;
+-  BROTLI_BOOL decompress;
+-  BROTLI_BOOL large_window;
+-  const char* output_path;
+-  const char* suffix;
+-  int not_input_indices[MAX_OPTIONS];
+-  size_t longest_path_len;
+-  size_t input_count;
+-
+-  /* Inner state */
+-  int argc;
+-  char** argv;
+-  char* modified_path;  /* Storage for path with appended / cut suffix */
+-  int iterator;
+-  int ignore;
+-  BROTLI_BOOL iterator_error;
+-  uint8_t* buffer;
+-  uint8_t* input;
+-  uint8_t* output;
+-  const char* current_input_path;
+-  const char* current_output_path;
+-  int64_t input_file_length;  /* -1, if impossible to calculate */
+-  FILE* fin;
+-  FILE* fout;
+-
+-  /* I/O buffers */
+-  size_t available_in;
+-  const uint8_t* next_in;
+-  size_t available_out;
+-  uint8_t* next_out;
+-
+-  /* Reporting */
+-  /* size_t would be large enough,
+-     until 4GiB+ files are compressed / decompressed on 32-bit CPUs. */
+-  size_t total_in;
+-  size_t total_out;
+-} Context;
+-
+-/* Parse up to 5 decimal digits. */
+-static BROTLI_BOOL ParseInt(const char* s, int low, int high, int* result) {
+-  int value = 0;
+-  int i;
+-  for (i = 0; i < 5; ++i) {
+-    char c = s[i];
+-    if (c == 0) break;
+-    if (s[i] < '0' || s[i] > '9') return BROTLI_FALSE;
+-    value = (10 * value) + (c - '0');
+-  }
+-  if (i == 0) return BROTLI_FALSE;
+-  if (i > 1 && s[0] == '0') return BROTLI_FALSE;
+-  if (s[i] != 0) return BROTLI_FALSE;
+-  if (value < low || value > high) return BROTLI_FALSE;
+-  *result = value;
+-  return BROTLI_TRUE;
+-}
+-
+-/* Returns "base file name" or its tail, if it contains '/' or '\'. */
+-static const char* FileName(const char* path) {
+-  const char* separator_position = strrchr(path, '/');
+-  if (separator_position) path = separator_position + 1;
+-  separator_position = strrchr(path, '\\');
+-  if (separator_position) path = separator_position + 1;
+-  return path;
+-}
+-
+-/* Detect if the program name is a special alias that infers a command type. */
+-static Command ParseAlias(const char* name) {
+-  /* TODO: cast name to lower case? */
+-  const char* unbrotli = "unbrotli";
+-  size_t unbrotli_len = strlen(unbrotli);
+-  name = FileName(name);
+-  /* Partial comparison. On Windows there could be ".exe" suffix. */
+-  if (strncmp(name, unbrotli, unbrotli_len) == 0) {
+-    char terminator = name[unbrotli_len];
+-    if (terminator == 0 || terminator == '.') return COMMAND_DECOMPRESS;
+-  }
+-  return COMMAND_COMPRESS;
+-}
+-
+-static Command ParseParams(Context* params) {
+-  int argc = params->argc;
+-  char** argv = params->argv;
+-  int i;
+-  int next_option_index = 0;
+-  size_t input_count = 0;
+-  size_t longest_path_len = 1;
+-  BROTLI_BOOL command_set = BROTLI_FALSE;
+-  BROTLI_BOOL quality_set = BROTLI_FALSE;
+-  BROTLI_BOOL output_set = BROTLI_FALSE;
+-  BROTLI_BOOL keep_set = BROTLI_FALSE;
+-  BROTLI_BOOL lgwin_set = BROTLI_FALSE;
+-  BROTLI_BOOL suffix_set = BROTLI_FALSE;
+-  BROTLI_BOOL after_dash_dash = BROTLI_FALSE;
+-  Command command = ParseAlias(argv[0]);
+-
+-  for (i = 1; i < argc; ++i) {
+-    const char* arg = argv[i];
+-    /* C99 5.1.2.2.1: "members argv[0] through argv[argc-1] inclusive shall
+-       contain pointers to strings"; NULL and 0-length are not forbidden. */
+-    size_t arg_len = arg ? strlen(arg) : 0;
+-
+-    if (arg_len == 0) {
+-      params->not_input_indices[next_option_index++] = i;
+-      continue;
+-    }
+-
+-    /* Too many options. The expected longest option list is:
+-       "-q 0 -w 10 -o f -D d -S b -d -f -k -n -v --", i.e. 16 items in total.
+-       This check is an additional guard that is never triggered, but provides
+-       a guard for future changes. */
+-    if (next_option_index > (MAX_OPTIONS - 2)) {
+-      fprintf(stderr, "too many options passed\n");
+-      return COMMAND_INVALID;
+-    }
+-
+-    /* Input file entry. */
+-    if (after_dash_dash || arg[0] != '-' || arg_len == 1) {
+-      input_count++;
+-      if (longest_path_len < arg_len) longest_path_len = arg_len;
+-      continue;
+-    }
+-
+-    /* Not a file entry. */
+-    params->not_input_indices[next_option_index++] = i;
+-
+-    /* '--' entry stop parsing arguments. */
+-    if (arg_len == 2 && arg[1] == '-') {
+-      after_dash_dash = BROTLI_TRUE;
+-      continue;
+-    }
+-
+-    /* Simple / coalesced options. */
+-    if (arg[1] != '-') {
+-      size_t j;
+-      for (j = 1; j < arg_len; ++j) {
+-        char c = arg[j];
+-        if (c >= '0' && c <= '9') {
+-          if (quality_set) {
+-            fprintf(stderr, "quality already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          quality_set = BROTLI_TRUE;
+-          params->quality = c - '0';
+-          continue;
+-        } else if (c == 'c') {
+-          if (output_set) {
+-            fprintf(stderr, "write to standard output already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          output_set = BROTLI_TRUE;
+-          params->write_to_stdout = BROTLI_TRUE;
+-          continue;
+-        } else if (c == 'd') {
+-          if (command_set) {
+-            fprintf(stderr, "command already set when parsing -d\n");
+-            return COMMAND_INVALID;
+-          }
+-          command_set = BROTLI_TRUE;
+-          command = COMMAND_DECOMPRESS;
+-          continue;
+-        } else if (c == 'f') {
+-          if (params->force_overwrite) {
+-            fprintf(stderr, "force output overwrite already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          params->force_overwrite = BROTLI_TRUE;
+-          continue;
+-        } else if (c == 'h') {
+-          /* Don't parse further. */
+-          return COMMAND_HELP;
+-        } else if (c == 'j' || c == 'k') {
+-          if (keep_set) {
+-            fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          keep_set = BROTLI_TRUE;
+-          params->junk_source = TO_BROTLI_BOOL(c == 'j');
+-          continue;
+-        } else if (c == 'n') {
+-          if (!params->copy_stat) {
+-            fprintf(stderr, "argument --no-copy-stat / -n already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          params->copy_stat = BROTLI_FALSE;
+-          continue;
+-        } else if (c == 't') {
+-          if (command_set) {
+-            fprintf(stderr, "command already set when parsing -t\n");
+-            return COMMAND_INVALID;
+-          }
+-          command_set = BROTLI_TRUE;
+-          command = COMMAND_TEST_INTEGRITY;
+-          continue;
+-        } else if (c == 'v') {
+-          if (params->verbosity > 0) {
+-            fprintf(stderr, "argument --verbose / -v already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          params->verbosity = 1;
+-          continue;
+-        } else if (c == 'V') {
+-          /* Don't parse further. */
+-          return COMMAND_VERSION;
+-        } else if (c == 'Z') {
+-          if (quality_set) {
+-            fprintf(stderr, "quality already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          quality_set = BROTLI_TRUE;
+-          params->quality = 11;
+-          continue;
+-        }
+-        /* o/q/w/D/S with parameter is expected */
+-        if (c != 'o' && c != 'q' && c != 'w' && c != 'D' && c != 'S') {
+-          fprintf(stderr, "invalid argument -%c\n", c);
+-          return COMMAND_INVALID;
+-        }
+-        if (j + 1 != arg_len) {
+-          fprintf(stderr, "expected parameter for argument -%c\n", c);
+-          return COMMAND_INVALID;
+-        }
+-        i++;
+-        if (i == argc || !argv[i] || argv[i][0] == 0) {
+-          fprintf(stderr, "expected parameter for argument -%c\n", c);
+-          return COMMAND_INVALID;
+-        }
+-        params->not_input_indices[next_option_index++] = i;
+-        if (c == 'o') {
+-          if (output_set) {
+-            fprintf(stderr, "write to standard output already set (-o)\n");
+-            return COMMAND_INVALID;
+-          }
+-          params->output_path = argv[i];
+-        } else if (c == 'q') {
+-          if (quality_set) {
+-            fprintf(stderr, "quality already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          quality_set = ParseInt(argv[i], BROTLI_MIN_QUALITY,
+-                                 BROTLI_MAX_QUALITY, &params->quality);
+-          if (!quality_set) {
+-            fprintf(stderr, "error parsing quality value [%s]\n", argv[i]);
+-            return COMMAND_INVALID;
+-          }
+-        } else if (c == 'w') {
+-          if (lgwin_set) {
+-            fprintf(stderr, "lgwin parameter already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          lgwin_set = ParseInt(argv[i], 0,
+-                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+-          if (!lgwin_set) {
+-            fprintf(stderr, "error parsing lgwin value [%s]\n", argv[i]);
+-            return COMMAND_INVALID;
+-          }
+-          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+-            fprintf(stderr,
+-                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+-                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+-            return COMMAND_INVALID;
+-          }
+-        } else if (c == 'S') {
+-          if (suffix_set) {
+-            fprintf(stderr, "suffix already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          suffix_set = BROTLI_TRUE;
+-          params->suffix = argv[i];
+-        }
+-      }
+-    } else {  /* Double-dash. */
+-      arg = &arg[2];
+-      if (strcmp("best", arg) == 0) {
+-        if (quality_set) {
+-          fprintf(stderr, "quality already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        quality_set = BROTLI_TRUE;
+-        params->quality = 11;
+-      } else if (strcmp("decompress", arg) == 0) {
+-        if (command_set) {
+-          fprintf(stderr, "command already set when parsing --decompress\n");
+-          return COMMAND_INVALID;
+-        }
+-        command_set = BROTLI_TRUE;
+-        command = COMMAND_DECOMPRESS;
+-      } else if (strcmp("force", arg) == 0) {
+-        if (params->force_overwrite) {
+-          fprintf(stderr, "force output overwrite already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        params->force_overwrite = BROTLI_TRUE;
+-      } else if (strcmp("help", arg) == 0) {
+-        /* Don't parse further. */
+-        return COMMAND_HELP;
+-      } else if (strcmp("keep", arg) == 0) {
+-        if (keep_set) {
+-          fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        keep_set = BROTLI_TRUE;
+-        params->junk_source = BROTLI_FALSE;
+-      } else if (strcmp("no-copy-stat", arg) == 0) {
+-        if (!params->copy_stat) {
+-          fprintf(stderr, "argument --no-copy-stat / -n already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        params->copy_stat = BROTLI_FALSE;
+-      } else if (strcmp("rm", arg) == 0) {
+-        if (keep_set) {
+-          fprintf(stderr, "argument --rm / -j or --keep / -k already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        keep_set = BROTLI_TRUE;
+-        params->junk_source = BROTLI_TRUE;
+-      } else if (strcmp("stdout", arg) == 0) {
+-        if (output_set) {
+-          fprintf(stderr, "write to standard output already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        output_set = BROTLI_TRUE;
+-        params->write_to_stdout = BROTLI_TRUE;
+-      } else if (strcmp("test", arg) == 0) {
+-        if (command_set) {
+-          fprintf(stderr, "command already set when parsing --test\n");
+-          return COMMAND_INVALID;
+-        }
+-        command_set = BROTLI_TRUE;
+-        command = COMMAND_TEST_INTEGRITY;
+-      } else if (strcmp("verbose", arg) == 0) {
+-        if (params->verbosity > 0) {
+-          fprintf(stderr, "argument --verbose / -v already set\n");
+-          return COMMAND_INVALID;
+-        }
+-        params->verbosity = 1;
+-      } else if (strcmp("version", arg) == 0) {
+-        /* Don't parse further. */
+-        return COMMAND_VERSION;
+-      } else {
+-        /* key=value */
+-        const char* value = strrchr(arg, '=');
+-        size_t key_len;
+-        if (!value || value[1] == 0) {
+-          fprintf(stderr, "must pass the parameter as --%s=value\n", arg);
+-          return COMMAND_INVALID;
+-        }
+-        key_len = (size_t)(value - arg);
+-        value++;
+-        if (strncmp("lgwin", arg, key_len) == 0) {
+-          if (lgwin_set) {
+-            fprintf(stderr, "lgwin parameter already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          lgwin_set = ParseInt(value, 0,
+-                               BROTLI_MAX_WINDOW_BITS, &params->lgwin);
+-          if (!lgwin_set) {
+-            fprintf(stderr, "error parsing lgwin value [%s]\n", value);
+-            return COMMAND_INVALID;
+-          }
+-          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+-            fprintf(stderr,
+-                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+-                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+-            return COMMAND_INVALID;
+-          }
+-        } else if (strncmp("large_window", arg, key_len) == 0) {
+-          /* This option is intentionally not mentioned in help. */
+-          if (lgwin_set) {
+-            fprintf(stderr, "lgwin parameter already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          lgwin_set = ParseInt(value, 0,
+-                               BROTLI_LARGE_MAX_WINDOW_BITS, &params->lgwin);
+-          if (!lgwin_set) {
+-            fprintf(stderr, "error parsing lgwin value [%s]\n", value);
+-            return COMMAND_INVALID;
+-          }
+-          if (params->lgwin != 0 && params->lgwin < BROTLI_MIN_WINDOW_BITS) {
+-            fprintf(stderr,
+-                    "lgwin parameter (%d) smaller than the minimum (%d)\n",
+-                    params->lgwin, BROTLI_MIN_WINDOW_BITS);
+-            return COMMAND_INVALID;
+-          }
+-        } else if (strncmp("output", arg, key_len) == 0) {
+-          if (output_set) {
+-            fprintf(stderr,
+-                    "write to standard output already set (--output)\n");
+-            return COMMAND_INVALID;
+-          }
+-          params->output_path = value;
+-        } else if (strncmp("quality", arg, key_len) == 0) {
+-          if (quality_set) {
+-            fprintf(stderr, "quality already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          quality_set = ParseInt(value, BROTLI_MIN_QUALITY,
+-                                 BROTLI_MAX_QUALITY, &params->quality);
+-          if (!quality_set) {
+-            fprintf(stderr, "error parsing quality value [%s]\n", value);
+-            return COMMAND_INVALID;
+-          }
+-        } else if (strncmp("suffix", arg, key_len) == 0) {
+-          if (suffix_set) {
+-            fprintf(stderr, "suffix already set\n");
+-            return COMMAND_INVALID;
+-          }
+-          suffix_set = BROTLI_TRUE;
+-          params->suffix = value;
+-        } else {
+-          fprintf(stderr, "invalid parameter: [%s]\n", arg);
+-          return COMMAND_INVALID;
+-        }
+-      }
+-    }
+-  }
+-
+-  params->input_count = input_count;
+-  params->longest_path_len = longest_path_len;
+-  params->decompress = (command == COMMAND_DECOMPRESS);
+-  params->test_integrity = (command == COMMAND_TEST_INTEGRITY);
+-
+-  if (input_count > 1 && output_set) return COMMAND_INVALID;
+-  if (params->test_integrity) {
+-    if (params->output_path) return COMMAND_INVALID;
+-    if (params->write_to_stdout) return COMMAND_INVALID;
+-  }
+-  if (strchr(params->suffix, '/') || strchr(params->suffix, '\\')) {
+-    return COMMAND_INVALID;
+-  }
+-
+-  return command;
+-}
+-
+-static void PrintVersion(void) {
+-  int major = BROTLI_VERSION >> 24;
+-  int minor = (BROTLI_VERSION >> 12) & 0xFFF;
+-  int patch = BROTLI_VERSION & 0xFFF;
+-  fprintf(stdout, "brotli %d.%d.%d\n", major, minor, patch);
+-}
+-
+-static void PrintHelp(const char* name, BROTLI_BOOL error) {
+-  FILE* media = error ? stderr : stdout;
+-  /* String is cut to pieces with length less than 509, to conform C90 spec. */
+-  fprintf(media,
+-"Usage: %s [OPTION]... [FILE]...\n",
+-          name);
+-  fprintf(media,
+-"Options:\n"
+-"  -#                          compression level (0-9)\n"
+-"  -c, --stdout                write on standard output\n"
+-"  -d, --decompress            decompress\n"
+-"  -f, --force                 force output file overwrite\n"
+-"  -h, --help                  display this help and exit\n");
+-  fprintf(media,
+-"  -j, --rm                    remove source file(s)\n"
+-"  -k, --keep                  keep source file(s) (default)\n"
+-"  -n, --no-copy-stat          do not copy source file(s) attributes\n"
+-"  -o FILE, --output=FILE      output file (only if 1 input file)\n");
+-  fprintf(media,
+-"  -q NUM, --quality=NUM       compression level (%d-%d)\n",
+-          BROTLI_MIN_QUALITY, BROTLI_MAX_QUALITY);
+-  fprintf(media,
+-"  -t, --test                  test compressed file integrity\n"
+-"  -v, --verbose               verbose mode\n");
+-  fprintf(media,
+-"  -w NUM, --lgwin=NUM         set LZ77 window size (0, %d-%d)\n"
+-"                              window size = 2**NUM - 16\n"
+-"                              0 lets compressor choose the optimal value\n",
+-          BROTLI_MIN_WINDOW_BITS, BROTLI_MAX_WINDOW_BITS);
+-  fprintf(media,
+-"  --large_window=NUM          use incompatible large-window brotli\n"
+-"                              bitstream with window size (0, %d-%d)\n"
+-"                              WARNING: this format is not compatible\n"
+-"                              with brotli RFC 7932 and may not be\n"
+-"                              decodable with regular brotli decoders\n",
+-          BROTLI_MIN_WINDOW_BITS, BROTLI_LARGE_MAX_WINDOW_BITS);
+-  fprintf(media,
+-"  -S SUF, --suffix=SUF        output file suffix (default:'%s')\n",
+-          DEFAULT_SUFFIX);
+-  fprintf(media,
+-"  -V, --version               display version and exit\n"
+-"  -Z, --best                  use best compression level (11) (default)\n"
+-"Simple options could be coalesced, i.e. '-9kf' is equivalent to '-9 -k -f'.\n"
+-"With no FILE, or when FILE is -, read standard input.\n"
+-"All arguments after '--' are treated as files.\n");
+-}
+-
+-static const char* PrintablePath(const char* path) {
+-  return path ? path : "con";
+-}
+-
+-static BROTLI_BOOL OpenInputFile(const char* input_path, FILE** f) {
+-  *f = NULL;
+-  if (!input_path) {
+-    *f = fdopen(MAKE_BINARY(STDIN_FILENO), "rb");
+-    return BROTLI_TRUE;
+-  }
+-  *f = fopen(input_path, "rb");
+-  if (!*f) {
+-    fprintf(stderr, "failed to open input file [%s]: %s\n",
+-            PrintablePath(input_path), strerror(errno));
+-    return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL OpenOutputFile(const char* output_path, FILE** f,
+-                                  BROTLI_BOOL force) {
+-  int fd;
+-  *f = NULL;
+-  if (!output_path) {
+-    *f = fdopen(MAKE_BINARY(STDOUT_FILENO), "wb");
+-    return BROTLI_TRUE;
+-  }
+-  fd = open(output_path, O_CREAT | (force ? 0 : O_EXCL) | O_WRONLY | O_TRUNC,
+-            S_IRUSR | S_IWUSR);
+-  if (fd < 0) {
+-    fprintf(stderr, "failed to open output file [%s]: %s\n",
+-            PrintablePath(output_path), strerror(errno));
+-    return BROTLI_FALSE;
+-  }
+-  *f = fdopen(fd, "wb");
+-  if (!*f) {
+-    fprintf(stderr, "failed to open output file [%s]: %s\n",
+-            PrintablePath(output_path), strerror(errno));
+-    return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-static int64_t FileSize(const char* path) {
+-  FILE* f = fopen(path, "rb");
+-  int64_t retval;
+-  if (f == NULL) {
+-    return -1;
+-  }
+-  if (fseek(f, 0L, SEEK_END) != 0) {
+-    fclose(f);
+-    return -1;
+-  }
+-  retval = ftell(f);
+-  if (fclose(f) != 0) {
+-    return -1;
+-  }
+-  return retval;
+-}
+-
+-/* Copy file times and permissions.
+-   TODO: this is a "best effort" implementation; honest cross-platform
+-   fully featured implementation is way too hacky; add more hacks by request. */
+-static void CopyStat(const char* input_path, const char* output_path) {
+-  struct stat statbuf;
+-  struct utimbuf times;
+-  int res;
+-  if (input_path == 0 || output_path == 0) {
+-    return;
+-  }
+-  if (stat(input_path, &statbuf) != 0) {
+-    return;
+-  }
+-  times.actime = statbuf.st_atime;
+-  times.modtime = statbuf.st_mtime;
+-  utime(output_path, &times);
+-  res = chmod(output_path, statbuf.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO));
+-  if (res != 0) {
+-    fprintf(stderr, "setting access bits failed for [%s]: %s\n",
+-            PrintablePath(output_path), strerror(errno));
+-  }
+-  res = chown(output_path, (uid_t)-1, statbuf.st_gid);
+-  if (res != 0) {
+-    fprintf(stderr, "setting group failed for [%s]: %s\n",
+-            PrintablePath(output_path), strerror(errno));
+-  }
+-  res = chown(output_path, statbuf.st_uid, (gid_t)-1);
+-  if (res != 0) {
+-    fprintf(stderr, "setting user failed for [%s]: %s\n",
+-            PrintablePath(output_path), strerror(errno));
+-  }
+-}
+-
+-static BROTLI_BOOL NextFile(Context* context) {
+-  const char* arg;
+-  size_t arg_len;
+-
+-  /* Iterator points to last used arg; increment to search for the next one. */
+-  context->iterator++;
+-
+-  context->input_file_length = -1;
+-
+-  /* No input path; read from console. */
+-  if (context->input_count == 0) {
+-    if (context->iterator > 1) return BROTLI_FALSE;
+-    context->current_input_path = NULL;
+-    /* Either write to the specified path, or to console. */
+-    context->current_output_path = context->output_path;
+-    return BROTLI_TRUE;
+-  }
+-
+-  /* Skip option arguments. */
+-  while (context->iterator == context->not_input_indices[context->ignore]) {
+-    context->iterator++;
+-    context->ignore++;
+-  }
+-
+-  /* All args are scanned already. */
+-  if (context->iterator >= context->argc) return BROTLI_FALSE;
+-
+-  /* Iterator now points to the input file name. */
+-  arg = context->argv[context->iterator];
+-  arg_len = strlen(arg);
+-  /* Read from console. */
+-  if (arg_len == 1 && arg[0] == '-') {
+-    context->current_input_path = NULL;
+-    context->current_output_path = context->output_path;
+-    return BROTLI_TRUE;
+-  }
+-
+-  context->current_input_path = arg;
+-  context->input_file_length = FileSize(arg);
+-  context->current_output_path = context->output_path;
+-
+-  if (context->output_path) return BROTLI_TRUE;
+-  if (context->write_to_stdout) return BROTLI_TRUE;
+-
+-  strcpy(context->modified_path, arg);
+-  context->current_output_path = context->modified_path;
+-  /* If output is not specified, input path suffix should match. */
+-  if (context->decompress) {
+-    size_t suffix_len = strlen(context->suffix);
+-    char* name = (char*)FileName(context->modified_path);
+-    char* name_suffix;
+-    size_t name_len = strlen(name);
+-    if (name_len < suffix_len + 1) {
+-      fprintf(stderr, "empty output file name for [%s] input file\n",
+-              PrintablePath(arg));
+-      context->iterator_error = BROTLI_TRUE;
+-      return BROTLI_FALSE;
+-    }
+-    name_suffix = name + name_len - suffix_len;
+-    if (strcmp(context->suffix, name_suffix) != 0) {
+-      fprintf(stderr, "input file [%s] suffix mismatch\n",
+-              PrintablePath(arg));
+-      context->iterator_error = BROTLI_TRUE;
+-      return BROTLI_FALSE;
+-    }
+-    name_suffix[0] = 0;
+-    return BROTLI_TRUE;
+-  } else {
+-    strcpy(context->modified_path + arg_len, context->suffix);
+-    return BROTLI_TRUE;
+-  }
+-}
+-
+-static BROTLI_BOOL OpenFiles(Context* context) {
+-  BROTLI_BOOL is_ok = OpenInputFile(context->current_input_path, &context->fin);
+-  if (!context->test_integrity && is_ok) {
+-    is_ok = OpenOutputFile(
+-        context->current_output_path, &context->fout, context->force_overwrite);
+-  }
+-  return is_ok;
+-}
+-
+-static BROTLI_BOOL CloseFiles(Context* context, BROTLI_BOOL success) {
+-  BROTLI_BOOL is_ok = BROTLI_TRUE;
+-  if (!context->test_integrity && context->fout) {
+-    if (!success && context->current_output_path) {
+-      unlink(context->current_output_path);
+-    }
+-    if (fclose(context->fout) != 0) {
+-      if (success) {
+-        fprintf(stderr, "fclose failed [%s]: %s\n",
+-                PrintablePath(context->current_output_path), strerror(errno));
+-      }
+-      is_ok = BROTLI_FALSE;
+-    }
+-
+-    /* TOCTOU violation, but otherwise it is impossible to set file times. */
+-    if (success && is_ok && context->copy_stat) {
+-      CopyStat(context->current_input_path, context->current_output_path);
+-    }
+-  }
+-
+-  if (context->fin) {
+-    if (fclose(context->fin) != 0) {
+-      if (is_ok) {
+-        fprintf(stderr, "fclose failed [%s]: %s\n",
+-                PrintablePath(context->current_input_path), strerror(errno));
+-      }
+-      is_ok = BROTLI_FALSE;
+-    }
+-  }
+-  if (success && context->junk_source && context->current_input_path) {
+-    unlink(context->current_input_path);
+-  }
+-
+-  context->fin = NULL;
+-  context->fout = NULL;
+-
+-  return is_ok;
+-}
+-
+-static const size_t kFileBufferSize = 1 << 19;
+-
+-static void InitializeBuffers(Context* context) {
+-  context->available_in = 0;
+-  context->next_in = NULL;
+-  context->available_out = kFileBufferSize;
+-  context->next_out = context->output;
+-  context->total_in = 0;
+-  context->total_out = 0;
+-}
+-
+-/* This method might give the false-negative result.
+-   However, after an empty / incomplete read it should tell the truth. */
+-static BROTLI_BOOL HasMoreInput(Context* context) {
+-  return feof(context->fin) ? BROTLI_FALSE : BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL ProvideInput(Context* context) {
+-  context->available_in =
+-      fread(context->input, 1, kFileBufferSize, context->fin);
+-  context->total_in += context->available_in;
+-  context->next_in = context->input;
+-  if (ferror(context->fin)) {
+-    fprintf(stderr, "failed to read input [%s]: %s\n",
+-            PrintablePath(context->current_input_path), strerror(errno));
+-    return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-/* Internal: should be used only in Provide-/Flush-Output. */
+-static BROTLI_BOOL WriteOutput(Context* context) {
+-  size_t out_size = (size_t)(context->next_out - context->output);
+-  context->total_out += out_size;
+-  if (out_size == 0) return BROTLI_TRUE;
+-  if (context->test_integrity) return BROTLI_TRUE;
+-
+-  fwrite(context->output, 1, out_size, context->fout);
+-  if (ferror(context->fout)) {
+-    fprintf(stderr, "failed to write output [%s]: %s\n",
+-            PrintablePath(context->current_output_path), strerror(errno));
+-    return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL ProvideOutput(Context* context) {
+-  if (!WriteOutput(context)) return BROTLI_FALSE;
+-  context->available_out = kFileBufferSize;
+-  context->next_out = context->output;
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL FlushOutput(Context* context) {
+-  if (!WriteOutput(context)) return BROTLI_FALSE;
+-  context->available_out = 0;
+-  return BROTLI_TRUE;
+-}
+-
+-static void PrintBytes(size_t value) {
+-  if (value < 1024) {
+-    fprintf(stderr, "%d B", (int)value);
+-  } else if (value < 1048576) {
+-    fprintf(stderr, "%0.3f KiB", (double)value / 1024.0);
+-  } else if (value < 1073741824) {
+-    fprintf(stderr, "%0.3f MiB", (double)value / 1048576.0);
+-  } else {
+-    fprintf(stderr, "%0.3f GiB", (double)value / 1073741824.0);
+-  }
+-}
+-
+-static void PrintFileProcessingProgress(Context* context) {
+-  fprintf(stderr, "[%s]: ", PrintablePath(context->current_input_path));
+-  PrintBytes(context->total_in);
+-  fprintf(stderr, " -> ");
+-  PrintBytes(context->total_out);
+-}
+-
+-static BROTLI_BOOL DecompressFile(Context* context, BrotliDecoderState* s) {
+-  BrotliDecoderResult result = BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT;
+-  InitializeBuffers(context);
+-  for (;;) {
+-    if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT) {
+-      if (!HasMoreInput(context)) {
+-        fprintf(stderr, "corrupt input [%s]\n",
+-                PrintablePath(context->current_input_path));
+-        return BROTLI_FALSE;
+-      }
+-      if (!ProvideInput(context)) return BROTLI_FALSE;
+-    } else if (result == BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
+-      if (!ProvideOutput(context)) return BROTLI_FALSE;
+-    } else if (result == BROTLI_DECODER_RESULT_SUCCESS) {
+-      if (!FlushOutput(context)) return BROTLI_FALSE;
+-      int has_more_input =
+-          (context->available_in != 0) || (fgetc(context->fin) != EOF);
+-      if (has_more_input) {
+-        fprintf(stderr, "corrupt input [%s]\n",
+-                PrintablePath(context->current_input_path));
+-        return BROTLI_FALSE;
+-      }
+-      if (context->verbosity > 0) {
+-        fprintf(stderr, "Decompressed ");
+-        PrintFileProcessingProgress(context);
+-        fprintf(stderr, "\n");
+-      }
+-      return BROTLI_TRUE;
+-    } else {
+-      fprintf(stderr, "corrupt input [%s]\n",
+-              PrintablePath(context->current_input_path));
+-      return BROTLI_FALSE;
+-    }
+-
+-    result = BrotliDecoderDecompressStream(s, &context->available_in,
+-        &context->next_in, &context->available_out, &context->next_out, 0);
+-  }
+-}
+-
+-static BROTLI_BOOL DecompressFiles(Context* context) {
+-  while (NextFile(context)) {
+-    BROTLI_BOOL is_ok = BROTLI_TRUE;
+-    BrotliDecoderState* s = BrotliDecoderCreateInstance(NULL, NULL, NULL);
+-    if (!s) {
+-      fprintf(stderr, "out of memory\n");
+-      return BROTLI_FALSE;
+-    }
+-    /* This allows decoding "large-window" streams. Though it creates
+-       fragmentation (new builds decode streams that old builds don't),
+-       it is better from used experience perspective. */
+-    BrotliDecoderSetParameter(s, BROTLI_DECODER_PARAM_LARGE_WINDOW, 1u);
+-    is_ok = OpenFiles(context);
+-    if (is_ok && !context->current_input_path &&
+-        !context->force_overwrite && isatty(STDIN_FILENO)) {
+-      fprintf(stderr, "Use -h help. Use -f to force input from a terminal.\n");
+-      is_ok = BROTLI_FALSE;
+-    }
+-    if (is_ok) is_ok = DecompressFile(context, s);
+-    BrotliDecoderDestroyInstance(s);
+-    if (!CloseFiles(context, is_ok)) is_ok = BROTLI_FALSE;
+-    if (!is_ok) return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-static BROTLI_BOOL CompressFile(Context* context, BrotliEncoderState* s) {
+-  BROTLI_BOOL is_eof = BROTLI_FALSE;
+-  InitializeBuffers(context);
+-  for (;;) {
+-    if (context->available_in == 0 && !is_eof) {
+-      if (!ProvideInput(context)) return BROTLI_FALSE;
+-      is_eof = !HasMoreInput(context);
+-    }
+-
+-    if (!BrotliEncoderCompressStream(s,
+-        is_eof ? BROTLI_OPERATION_FINISH : BROTLI_OPERATION_PROCESS,
+-        &context->available_in, &context->next_in,
+-        &context->available_out, &context->next_out, NULL)) {
+-      /* Should detect OOM? */
+-      fprintf(stderr, "failed to compress data [%s]\n",
+-              PrintablePath(context->current_input_path));
+-      return BROTLI_FALSE;
+-    }
+-
+-    if (context->available_out == 0) {
+-      if (!ProvideOutput(context)) return BROTLI_FALSE;
+-    }
+-
+-    if (BrotliEncoderIsFinished(s)) {
+-      if (!FlushOutput(context)) return BROTLI_FALSE;
+-      if (context->verbosity > 0) {
+-        fprintf(stderr, "Compressed ");
+-        PrintFileProcessingProgress(context);
+-        fprintf(stderr, "\n");
+-      }
+-      return BROTLI_TRUE;
+-    }
+-  }
+-}
+-
+-static BROTLI_BOOL CompressFiles(Context* context) {
+-  while (NextFile(context)) {
+-    BROTLI_BOOL is_ok = BROTLI_TRUE;
+-    BrotliEncoderState* s = BrotliEncoderCreateInstance(NULL, NULL, NULL);
+-    if (!s) {
+-      fprintf(stderr, "out of memory\n");
+-      return BROTLI_FALSE;
+-    }
+-    BrotliEncoderSetParameter(s,
+-        BROTLI_PARAM_QUALITY, (uint32_t)context->quality);
+-    if (context->lgwin > 0) {
+-      /* Specified by user. */
+-      /* Do not enable "large-window" extension, if not required. */
+-      if (context->lgwin > BROTLI_MAX_WINDOW_BITS) {
+-        BrotliEncoderSetParameter(s, BROTLI_PARAM_LARGE_WINDOW, 1u);
+-      }
+-      BrotliEncoderSetParameter(s,
+-          BROTLI_PARAM_LGWIN, (uint32_t)context->lgwin);
+-    } else {
+-      /* 0, or not specified by user; could be chosen by compressor. */
+-      uint32_t lgwin = DEFAULT_LGWIN;
+-      /* Use file size to limit lgwin. */
+-      if (context->input_file_length >= 0) {
+-        lgwin = BROTLI_MIN_WINDOW_BITS;
+-        while (BROTLI_MAX_BACKWARD_LIMIT(lgwin) <
+-               (uint64_t)context->input_file_length) {
+-          lgwin++;
+-          if (lgwin == BROTLI_MAX_WINDOW_BITS) break;
+-        }
+-      }
+-      BrotliEncoderSetParameter(s, BROTLI_PARAM_LGWIN, lgwin);
+-    }
+-    if (context->input_file_length > 0) {
+-      uint32_t size_hint = context->input_file_length < (1 << 30) ?
+-          (uint32_t)context->input_file_length : (1u << 30);
+-      BrotliEncoderSetParameter(s, BROTLI_PARAM_SIZE_HINT, size_hint);
+-    }
+-    is_ok = OpenFiles(context);
+-    if (is_ok && !context->current_output_path &&
+-        !context->force_overwrite && isatty(STDOUT_FILENO)) {
+-      fprintf(stderr, "Use -h help. Use -f to force output to a terminal.\n");
+-      is_ok = BROTLI_FALSE;
+-    }
+-    if (is_ok) is_ok = CompressFile(context, s);
+-    BrotliEncoderDestroyInstance(s);
+-    if (!CloseFiles(context, is_ok)) is_ok = BROTLI_FALSE;
+-    if (!is_ok) return BROTLI_FALSE;
+-  }
+-  return BROTLI_TRUE;
+-}
+-
+-int main(int argc, char** argv) {
+-  Command command;
+-  Context context;
+-  BROTLI_BOOL is_ok = BROTLI_TRUE;
+-  int i;
+-
+-  context.quality = 11;
+-  context.lgwin = -1;
+-  context.verbosity = 0;
+-  context.force_overwrite = BROTLI_FALSE;
+-  context.junk_source = BROTLI_FALSE;
+-  context.copy_stat = BROTLI_TRUE;
+-  context.test_integrity = BROTLI_FALSE;
+-  context.write_to_stdout = BROTLI_FALSE;
+-  context.decompress = BROTLI_FALSE;
+-  context.large_window = BROTLI_FALSE;
+-  context.output_path = NULL;
+-  context.suffix = DEFAULT_SUFFIX;
+-  for (i = 0; i < MAX_OPTIONS; ++i) context.not_input_indices[i] = 0;
+-  context.longest_path_len = 1;
+-  context.input_count = 0;
+-
+-  context.argc = argc;
+-  context.argv = argv;
+-  context.modified_path = NULL;
+-  context.iterator = 0;
+-  context.ignore = 0;
+-  context.iterator_error = BROTLI_FALSE;
+-  context.buffer = NULL;
+-  context.current_input_path = NULL;
+-  context.current_output_path = NULL;
+-  context.fin = NULL;
+-  context.fout = NULL;
+-
+-  command = ParseParams(&context);
+-
+-  if (command == COMMAND_COMPRESS || command == COMMAND_DECOMPRESS ||
+-      command == COMMAND_TEST_INTEGRITY) {
+-    if (is_ok) {
+-      size_t modified_path_len =
+-          context.longest_path_len + strlen(context.suffix) + 1;
+-      context.modified_path = (char*)malloc(modified_path_len);
+-      context.buffer = (uint8_t*)malloc(kFileBufferSize * 2);
+-      if (!context.modified_path || !context.buffer) {
+-        fprintf(stderr, "out of memory\n");
+-        is_ok = BROTLI_FALSE;
+-      } else {
+-        context.input = context.buffer;
+-        context.output = context.buffer + kFileBufferSize;
+-      }
+-    }
+-  }
+-
+-  if (!is_ok) command = COMMAND_NOOP;
+-
+-  switch (command) {
+-    case COMMAND_NOOP:
+-      break;
+-
+-    case COMMAND_VERSION:
+-      PrintVersion();
+-      break;
+-
+-    case COMMAND_COMPRESS:
+-      is_ok = CompressFiles(&context);
+-      break;
+-
+-    case COMMAND_DECOMPRESS:
+-    case COMMAND_TEST_INTEGRITY:
+-      is_ok = DecompressFiles(&context);
+-      break;
+-
+-    case COMMAND_HELP:
+-    case COMMAND_INVALID:
+-    default:
+-      is_ok = (command == COMMAND_HELP);
+-      PrintHelp(FileName(argv[0]), is_ok);
+-      break;
+-  }
+-
+-  if (context.iterator_error) is_ok = BROTLI_FALSE;
+-
+-  free(context.modified_path);
+-  free(context.buffer);
+-
+-  if (!is_ok) exit(1);
+-  return 0;
+-}
+diff --git a/modules/brotli/tools/brotli.md b/modules/brotli/tools/brotli.md
+deleted file mode 100644
+--- a/modules/brotli/tools/brotli.md
++++ /dev/null
+@@ -1,107 +0,0 @@
+-brotli(1) -- brotli, unbrotli - compress or decompress files
+-================================================================
+-
+-SYNOPSIS
+---------
+-
+-`brotli` [*OPTION|FILE*]...
+-
+-`unbrotli` is equivalent to `brotli --decompress`
+-
+-DESCRIPTION
+------------
+-`brotli` is a generic-purpose lossless compression algorithm that compresses
+-data using a combination of a modern variant of the **LZ77** algorithm, Huffman
+-coding and 2-nd order context modeling, with a compression ratio comparable to
+-the best currently available general-purpose compression methods. It is similar
+-in speed with deflate but offers more dense compression.
+-
+-`brotli` command line syntax similar to `gzip (1)` and `zstd (1)`.
+-Unlike `gzip (1)`, source files are preserved by default. It is possible to
+-remove them after processing by using the `--rm` _option_.
+-
+-Arguments that look like "`--name`" or "`--name=value`" are _options_. Every
+-_option_ has a short form "`-x`" or "`-x value`". Multiple short form _options_
+-could be coalesced:
+-
+-* "`--decompress --stdout --suffix=.b`" works the same as
+-* "`-d -s -S .b`" and
+-* "`-dsS .b`"
+-
+-`brotli` has 3 operation modes:
+-
+-* default mode is compression;
+-* `--decompress` option activates decompression mode;
+-* `--test` option switches to integrity test mode; this option is equivalent to
+-  "`--decompress --stdout`" except that the decompressed data is discarded
+-  instead of being written to standard output.
+-
+-Every non-option argument is a _file_ entry. If no _files_ are given or _file_
+-is "`-`", `brotli` reads from standard input. All arguments after "`--`" are
+-_file_ entries.
+-
+-Unless `--stdout` or `--output` is specified, _files_ are written to a new file
+-whose name is derived from the source _file_ name:
+-
+-* when compressing, a suffix is appended to the source filename to
+-  get the target filename
+-* when decompressing, a suffix is removed from the source filename to
+-  get the target filename
+-
+-Default suffix is `.br`, but it could be specified with `--suffix` option.
+-
+-Conflicting or duplicate _options_ are not allowed.
+-
+-OPTIONS
+--------
+-
+-* `-#`:
+-    compression level (0-9); bigger values cause denser, but slower compression
+-* `-c`, `--stdout`:
+-    write on standard output
+-* `-d`, `--decompress`:
+-    decompress mode
+-* `-f`, `--force`:
+-    force output file overwrite
+-* `-h`, `--help`:
+-    display this help and exit
+-* `-j`, `--rm`:
+-    remove source file(s); `gzip (1)`-like behaviour
+-* `-k`, `--keep`:
+-    keep source file(s); `zstd (1)`-like behaviour
+-* `-n`, `--no-copy-stat`:
+-    do not copy source file(s) attributes
+-* `-o FILE`, `--output=FILE`
+-    output file; valid only if there is a single input entry
+-* `-q NUM`, `--quality=NUM`:
+-    compression level (0-11); bigger values cause denser, but slower compression
+-* `-t`, `--test`:
+-    test file integrity mode
+-* `-v`, `--verbose`:
+-    increase output verbosity
+-* `-w NUM`, `--lgwin=NUM`:
+-    set LZ77 window size (0, 10-24) (default: 22); window size is
+-    `(2**NUM - 16)`; 0 lets compressor decide over the optimal value; bigger
+-    windows size improve density; decoder might require up to window size
+-    memory to operate
+-* `-S SUF`, `--suffix=SUF`:
+-    output file suffix (default: `.br`)
+-* `-V`, `--version`:
+-    display version and exit
+-* `-Z`, `--best`:
+-    use best compression level (default); same as "`-q 11`"
+-
+-SEE ALSO
+---------
+-
+-`brotli` file format is defined in
+-[RFC 7932](https://www.ietf.org/rfc/rfc7932.txt).
+-
+-`brotli` is open-sourced under the
+-[MIT License](https://opensource.org/licenses/MIT).
+-
+-Mailing list: https://groups.google.com/forum/#!forum/brotli
+-
+-BUGS
+-----
+-Report bugs at: https://github.com/google/brotli/issues
+diff --git a/modules/brotli/update.sh b/modules/brotli/update.sh
+--- a/modules/brotli/update.sh
++++ b/modules/brotli/update.sh
+@@ -6,17 +6,17 @@
+ MY_TEMP_DIR=`mktemp -d -t brotli_update.XXXXXX` || exit 1
+ 
+ git clone https://github.com/google/brotli ${MY_TEMP_DIR}/brotli
+ git -C ${MY_TEMP_DIR}/brotli checkout v1.0.9
+ 
+ COMMIT=$(git -C ${MY_TEMP_DIR}/brotli rev-parse HEAD)
+ perl -p -i -e "s/\[commit [0-9a-f]{40}\]/[commit ${COMMIT}]/" README.mozilla;
+ 
+-DIRS="common dec enc include tools"
++DIRS="common dec include"
+ 
+ for d in $DIRS; do
+ 	rm -rf $d
+ 	mv ${MY_TEMP_DIR}/brotli/c/$d $d
+ done
+ rm -rf ${MY_TEMP_DIR}
+ 
+ hg addremove $DIRS

mozilla-release/patches/series

@@ -6759,3 +6759,6 @@ mozilla-central_731979.patch
 mozilla-central_732156.patch
 mozilla-central_732157.patch
 mozilla-central_732158.patch
+mozilla-central_584331.patch
+mozilla-central_584332.patch
+mozilla-central_584333.patch