././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6151257 hpack-4.0.0/0000755000076500000240000000000000000000000013343 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598782759.0 hpack-4.0.0/CHANGELOG.rst0000644000076500000240000001221000000000000015360 0ustar00kriechistaff00000000000000Release History =============== 4.0.0 (2020-08-30) ------------------ API Changes (Backward-Incompatible) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - Support for Python 2.7 has been removed. - Support for Python 3.4 has been removed. - Support for Python 3.5 has been removed. - Support for PyPy (Python 2.7 compatible) has been removed. - Support for Python 3.8 has been added. **Bugfixes** - Performance improvement of static header search. Use dict search instead of linear search. - Fix debug output of headers during encoding. 3.0.0 (2017-03-29) ------------------ **API Changes (Backward Incompatible)** - Removed nghttp2 support. This support had rotted and was essentially non-functional, so it has now been removed until someone has time to re-add the support in a functional form. - Attempts by the encoder to exceed the maximum allowed header table size via dynamic table size updates (or the absence thereof) are now forbidden. **API Changes (Backward Compatible)** - Added a new ``InvalidTableSizeError`` thrown when the encoder does not respect the maximum table size set by the user. - Added a ``Decoder.max_allowed_table_size`` field that sets the maximum allowed size of the decoder header table. See the documentation for an indication of how this should be used. **Bugfixes** - Up to 25% performance improvement decoding HPACK-packed integers, depending on the platform. - HPACK now tolerates receiving multiple header table size changes in sequence, rather than only one. - HPACK now forbids header table size changes anywhere but first in a header block, as required by RFC 7541 ยง 4.2. - Other miscellaneous performance improvements. 2.3.0 (2016-08-04) ------------------ **Security Fixes** - CVE-2016-6581: HPACK Bomb. This release now enforces a maximum value of the decompressed size of the header list. This is to avoid the so-called "HPACK Bomb" vulnerability, which is caused when a malicious peer sends a compressed HPACK body that decompresses to a gigantic header list size. This also adds a ``OversizedHeaderListError``, which is thrown by the ``decode`` method if the maximum header list size is being violated. This places the HPACK decoder into a broken state: it must not be used after this exception is thrown. This also adds a ``max_header_list_size`` to the ``Decoder`` object. This controls the maximum allowable decompressed size of the header list. By default this is set to 64kB. 2.2.0 (2016-04-20) ------------------ **API Changes (Backward Compatible)** - Added ``HeaderTuple`` and ``NeverIndexedHeaderTuple`` classes that signal whether a given header field may ever be indexed in HTTP/2 header compression. - Changed ``Decoder.decode()`` to return the newly added ``HeaderTuple`` class and subclass. These objects behave like two-tuples, so this change does not break working code. **Bugfixes** - Improve Huffman decoding speed by 4x using an approach borrowed from nghttp2. - Improve HPACK decoding speed by 10% by caching header table sizes. 2.1.1 (2016-03-16) ------------------ **Bugfixes** - When passing a dictionary or dictionary subclass to ``Encoder.encode``, HPACK now ensures that HTTP/2 special headers (headers whose names begin with ``:`` characters) appear first in the header block. 2.1.0 (2016-02-02) ------------------ **API Changes (Backward Compatible)** - Added new ``InvalidTableIndex`` exception, a subclass of ``HPACKDecodingError``. - Instead of throwing ``IndexError`` when encountering invalid encoded integers HPACK now throws ``HPACKDecodingError``. - Instead of throwing ``UnicodeDecodeError`` when encountering headers that are not UTF-8 encoded, HPACK now throws ``HPACKDecodingError``. - Instead of throwing ``IndexError`` when encountering invalid table offsets, HPACK now throws ``InvalidTableIndex``. - Added ``raw`` flag to ``decode``, allowing ``decode`` to return bytes instead of attempting to decode the headers as UTF-8. **Bugfixes** - ``memoryview`` objects are now used when decoding HPACK, improving the performance by avoiding unnecessary data copies. 2.0.1 (2015-11-09) ------------------ - Fixed a bug where the Python HPACK implementation would only emit header table size changes for the total change between one header block and another, rather than for the entire sequence of changes. 2.0.0 (2015-10-12) ------------------ - Remove unused ``HPACKEncodingError``. - Add the shortcut ability to import the public API (``Encoder``, ``Decoder``, ``HPACKError``, ``HPACKDecodingError``) directly, rather than from ``hpack.hpack``. 1.1.0 (2015-07-07) ------------------ - Add support for emitting 'never indexed' header fields, by using an optional third element in the header tuple. With thanks to @jimcarreer! 1.0.1 (2015-04-19) ------------------ - Header fields that have names matching header table entries are now added to the header table. This improves compression efficiency at the cost of slightly more table operations. With thanks to `Tatsuhiro Tsujikawa`_. .. _Tatsuhiro Tsujikawa: https://github.com/tatsuhiro-t 1.0.0 (2015-04-13) ------------------ - Initial fork of the code from `hyper`_. .. _hyper: https://hyper.readthedocs.org/ ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/CONTRIBUTORS.rst0000644000076500000240000000255400000000000016040 0ustar00kriechistaff00000000000000Hyper is written and maintained by Cory Benfield and various contributors: Development Lead ```````````````` - Cory Benfield Contributors (hpack) ```````````````````` In chronological order: - Sriram Ganesan (@elricL) - Implemented the Huffman encoding/decoding logic. - Tatsuhiro Tsujikawa (@tatsuhiro-t) - Improved compression efficiency. - Jim Carreer (@jimcarreer) - Support for 'never indexed' header fields. - Refactor of header table code. - Add support for returning bytestring headers instead of UTF-8 decoded ones. - Eugene Obukhov (@irvind) - Improved decoding efficiency. - Ian Foote (@Ian-Foote) - 25% performance improvement to integer decode. - Davey Shafik (@dshafik) - More testing. - Seth Michael Larson (@SethMichaelLarson) - Code cleanups. - Bulat Khasanov (@KhasanovBI) - Performance improvement of static header search. Use dict search instead of linear search. Contributors (hyper) ```````````````````` In chronological order: - Alek Storm (@alekstorm) - Implemented Python 2.7 support. - Implemented HTTP/2 draft 10 support. - Implemented server push. - Tetsuya Morimoto (@t2y) - Fixed a bug where large or incomplete frames were not handled correctly. - Added hyper command-line tool. - General code cleanups. - Jerome De Cuyper (@jdecuyper) - Updated documentation and tests. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/LICENSE0000644000076500000240000000207000000000000014347 0ustar00kriechistaff00000000000000The MIT License (MIT) Copyright (c) 2014 Cory Benfield Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597495005.0 hpack-4.0.0/MANIFEST.in0000644000076500000240000000045600000000000015106 0ustar00kriechistaff00000000000000graft src graft docs graft test prune bench prune docs/build prune utils exclude tasks.py exclude test/test_fixtures/*/*.json exclude test/test_hpack_integration.py include README.rst LICENSE CHANGELOG.rst CONTRIBUTORS.rst tox.ini Makefile global-exclude *.pyc *.pyo *.swo *.swp *.map *.yml *.DS_Store ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597495627.0 hpack-4.0.0/Makefile0000644000076500000240000000036100000000000015003 0ustar00kriechistaff00000000000000.PHONY: publish sample_output publish: rm -rf dist/ tox -e packaging twine upload -s dist/* sample_output: rm -rf hpack-test-case/ git clone https://github.com/http2jp/hpack-test-case.git tox -e create_test_output -- hpack-test-case ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6153994 hpack-4.0.0/PKG-INFO0000644000076500000240000000553000000000000014443 0ustar00kriechistaff00000000000000Metadata-Version: 2.1 Name: hpack Version: 4.0.0 Summary: Pure-Python HPACK header compression Home-page: https://github.com/python-hyper/hpack Author: Cory Benfield Author-email: cory@lukasa.co.uk License: MIT License Description: ======================================== hpack: HTTP/2 Header Encoding for Python ======================================== .. image:: https://github.com/python-hyper/hpack/workflows/CI/badge.svg :target: https://github.com/python-hyper/hpack/actions :alt: Build Status .. image:: https://codecov.io/gh/python-hyper/hpack/branch/master/graph/badge.svg :target: https://codecov.io/gh/python-hyper/hpack :alt: Code Coverage .. image:: https://readthedocs.org/projects/hpack/badge/?version=latest :target: https://hpack.readthedocs.io/en/latest/ :alt: Documentation Status .. image:: https://img.shields.io/badge/chat-join_now-brightgreen.svg :target: https://gitter.im/python-hyper/community :alt: Chat community .. image:: https://raw.github.com/Lukasa/hyper/development/docs/source/images/hyper.png This module contains a pure-Python HTTP/2 header encoding (HPACK) logic for use in Python programs that implement HTTP/2. Contributing ============ ``hpack`` welcomes contributions from anyone! Unlike many other projects we are happy to accept cosmetic contributions and small contributions, in addition to large feature requests and changes. Before you contribute (either by opening an issue or filing a pull request), please `read the contribution guidelines`_. .. _read the contribution guidelines: http://hyper.readthedocs.org/en/development/contributing.html License ======= ``hpack`` is made available under the MIT License. For more details, see the ``LICENSE`` file in the repository. Authors ======= ``hpack`` is maintained by Cory Benfield, with contributions from others. For more details about the contributors, please see ``CONTRIBUTORS.rst``. Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Requires-Python: >=3.6.1 Description-Content-Type: text/x-rst ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/README.rst0000644000076500000240000000324200000000000015033 0ustar00kriechistaff00000000000000======================================== hpack: HTTP/2 Header Encoding for Python ======================================== .. image:: https://github.com/python-hyper/hpack/workflows/CI/badge.svg :target: https://github.com/python-hyper/hpack/actions :alt: Build Status .. image:: https://codecov.io/gh/python-hyper/hpack/branch/master/graph/badge.svg :target: https://codecov.io/gh/python-hyper/hpack :alt: Code Coverage .. image:: https://readthedocs.org/projects/hpack/badge/?version=latest :target: https://hpack.readthedocs.io/en/latest/ :alt: Documentation Status .. image:: https://img.shields.io/badge/chat-join_now-brightgreen.svg :target: https://gitter.im/python-hyper/community :alt: Chat community .. image:: https://raw.github.com/Lukasa/hyper/development/docs/source/images/hyper.png This module contains a pure-Python HTTP/2 header encoding (HPACK) logic for use in Python programs that implement HTTP/2. Contributing ============ ``hpack`` welcomes contributions from anyone! Unlike many other projects we are happy to accept cosmetic contributions and small contributions, in addition to large feature requests and changes. Before you contribute (either by opening an issue or filing a pull request), please `read the contribution guidelines`_. .. _read the contribution guidelines: http://hyper.readthedocs.org/en/development/contributing.html License ======= ``hpack`` is made available under the MIT License. For more details, see the ``LICENSE`` file in the repository. Authors ======= ``hpack`` is maintained by Cory Benfield, with contributions from others. For more details about the contributors, please see ``CONTRIBUTORS.rst``. ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6006558 hpack-4.0.0/docs/0000755000076500000240000000000000000000000014273 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/docs/Makefile0000644000076500000240000000117600000000000015740 0ustar00kriechistaff00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = source BUILDDIR = build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/docs/make.bat0000644000076500000240000000143700000000000015705 0ustar00kriechistaff00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=source set BUILDDIR=build if "%1" == "" goto help %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6029456 hpack-4.0.0/docs/source/0000755000076500000240000000000000000000000015573 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1598783094.603857 hpack-4.0.0/docs/source/_static/0000755000076500000240000000000000000000000017221 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/docs/source/_static/.keep0000644000076500000240000000000000000000000020134 0ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/docs/source/api.rst0000644000076500000240000000102000000000000017067 0ustar00kriechistaff00000000000000hpack API ========= This document provides the HPACK API. .. autoclass:: hpack.Encoder :members: header_table_size, encode .. autoclass:: hpack.Decoder :members: header_table_size, decode .. autoclass:: hpack.HeaderTuple :members: indexable .. autoclass:: hpack.NeverIndexedHeaderTuple :members: indexable .. autoclass:: hpack.HPACKError .. autoclass:: hpack.HPACKDecodingError .. autoclass:: hpack.InvalidTableIndex .. autoclass:: hpack.OversizedHeaderListError .. autoclass:: hpack.InvalidTableSizeError ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/docs/source/conf.py0000644000076500000240000000454000000000000017075 0ustar00kriechistaff00000000000000# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # import os import sys import re sys.path.insert(0, os.path.abspath('../..')) PROJECT_ROOT = os.path.dirname(__file__) # Get the version version_regex = r'__version__ = ["\']([^"\']*)["\']' with open(os.path.join(PROJECT_ROOT, '../../', 'src/hpack/__init__.py')) as file_: text = file_.read() match = re.search(version_regex, text) version = match.group(1) # -- Project information ----------------------------------------------------- project = 'hpack' copyright = '2020, Cory Benfield' author = 'Cory Benfield' release = version # -- General configuration --------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.viewcode', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = [] # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { 'python': ('https://docs.python.org/', None), } master_doc = 'index' # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = 'default' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/docs/source/index.rst0000644000076500000240000000203400000000000017433 0ustar00kriechistaff00000000000000hpack: HTTP/2 Header Compression for Python =========================================== hpack provides a simple Python interface to the `HPACK`_ compression algorithm, used to compress HTTP headers in HTTP/2. Used by some of the most popular HTTP/2 implementations in Python, HPACK offers a great Python interface as well as optional upgrade to optimised C-based compression routines from `nghttp2`_. Using hpack is easy: .. code-block:: python from hpack import Encoder, Decoder e = Encoder() encoded_bytes = e.encode(headers) d = Decoder() decoded_headers = d.decode(encoded_bytes) hpack will transparently use nghttp2 on CPython if it's available, gaining even better compression efficiency and speed, but it also makes available a pure-Python implementation that conforms strictly to `RFC 7541`_. Contents -------- .. toctree:: :maxdepth: 2 installation api security/index .. _HPACK: https://tools.ietf.org/html/rfc7541 .. _nghttp2: https://nghttp2.org/ .. _RFC 7541: https://tools.ietf.org/html/rfc7541 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/docs/source/installation.rst0000644000076500000240000000132600000000000021030 0ustar00kriechistaff00000000000000Installing hpack ================ hpack is trivial to install from the Python Package Index. Simply run: .. code-block:: console $ pip install hpack Alternatively, feel free to download one of the release tarballs from `our GitHub page`_, extract it to your favourite directory, and then run .. code-block:: console $ python setup.py install hpack has no external dependencies. Using nghttp2 ------------- If you want to use nghttp2 with hpack, all you need to do is install it along with its Python bindings. Consult `nghttp2's documentation`_ for instructions on how to install it. .. _our GitHub page: https://github.com/python-hyper/hpack .. _nghttp2's documentation: https://nghttp2.org/documentation/ ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6048858 hpack-4.0.0/docs/source/security/0000755000076500000240000000000000000000000017442 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/docs/source/security/CVE-2016-6581.rst0000644000076500000240000000541100000000000021601 0ustar00kriechistaff00000000000000:orphan: HPACK Bomb ========== Hyper Project security advisory, August 4th 2016. Vulnerability ------------- A HTTP/2 implementation built using the priority library could be targetted for a denial of service attack based on HPACK, specifically a so-called "HPACK Bomb" attack. This attack occurs when an attacker inserts a header field that is exactly the size of the HPACK dynamic header table into the dynamic header table. The attacker can then send a header block that is simply repeated requests to expand that field in the dynamic table. This can lead to a gigantic compression ratio of 4,096 or better, meaning that 16kB of data can decompress to 64MB of data on the target machine. It only takes a few such header blocks before the attacker has forced the target to allocate gigabytes of memory, which will take the process down. This requires relatively few resources on the part of the attacker. While we are not aware of any attacker actively exploiting this vulnerability, it has been public disclosed in `this report`_, and so users should assume that they are likely to be targetted by such an attack. Info ---- This issue has been given the name CVE-2016-6581. Affected Versions ----------------- This issue affects all versions of the HPACK library prior to 2.3.0. It also affects versions of the Hyper client library earlier than 0.6.0, which bundled a copy of the HPACK library. The Solution ------------ In version 2.3.0, the HPACK library limits the maximum decompressed size of the header block. It does so by essentially adding support for the HTTP/2 setting ``SETTINGS_MAX_HEADER_LIST_SIZE``. This value defaults to 64kB, but is user-configurable. If it is necessary to backport a patch, the patch can be found in `this GitHub pull request`_. Recommendations --------------- We suggest you take the following actions immediately, in order of preference: 1. Update HPACK to 2.3.0 immediately. 2. Backport the patch made available on GitHub. 3. Substantially decrease the maximum size of the compressed header block your application will accept, or alternatively ensure that each decompressed header block is freed before your application processes the next one. If you have a copy of the Hyper client library, we recommend taking the following actions, in order of preference: 1. Update hyper to any version later than 0.6.0 2. Backport the patch made available on GitHub. Timeline -------- This class of vulnerability was publicly reported in `this report`_ on the 3rd of August. We requested a CVE ID from Mitre the same day. HPACK 2.3.0 was released on the 4th of August, at the same time as the publication of this advisory. .. _this report: http://www.imperva.com/docs/Imperva_HII_HTTP2.pdf .. _this GitHub pull request: https://github.com/python-hyper/hpack/pull/56 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/docs/source/security/index.rst0000644000076500000240000000173100000000000021305 0ustar00kriechistaff00000000000000Vulnerability Notifications =========================== This section of the page contains all known vulnerabilities in the HPACK library. These vulnerabilities have all been reported to us via our `vulnerability disclosure policy`_. Known Vulnerabilities --------------------- +----+---------------------------+----------------+---------------+--------------+---------------+ | \# | Vulnerability | Date Announced | First Version | Last Version | CVE | +====+===========================+================+===============+==============+===============+ | 1 | :doc:`HPACK Bomb | 2016-08-04 | 1.0.0 | 2.2.0 | CVE-2016-6581 | | | ` | | | | | +----+---------------------------+----------------+---------------+--------------+---------------+ .. _vulnerability disclosure policy: http://python-hyper.org/en/latest/security.html#vulnerability-disclosure ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6167424 hpack-4.0.0/setup.cfg0000644000076500000240000000051200000000000015162 0ustar00kriechistaff00000000000000[tool:pytest] testpaths = test [coverage:run] branch = True source = hpack [coverage:report] fail_under = 100 show_missing = True exclude_lines = pragma: no cover [coverage:paths] source = src .tox/*/site-packages [flake8] max-complexity = 10 exclude = hpack/huffman_constants.py [egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/setup.py0000755000076500000240000000342200000000000015061 0ustar00kriechistaff00000000000000#!/usr/bin/env python # -*- coding: utf-8 -*- import codecs import os import re import sys from setuptools import setup, find_packages PROJECT_ROOT = os.path.dirname(__file__) with open(os.path.join(PROJECT_ROOT, 'README.rst')) as file_: long_description = file_.read() # Get the version version_regex = r'__version__ = ["\']([^"\']*)["\']' with open(os.path.join(PROJECT_ROOT, 'src/hpack/__init__.py')) as file_: text = file_.read() match = re.search(version_regex, text) if match: version = match.group(1) else: raise RuntimeError("No version number found!") # Stealing this from Kenneth Reitz if sys.argv[-1] == 'publish': os.system('python setup.py sdist upload') sys.exit() setup( name='hpack', version=version, description='Pure-Python HPACK header compression', long_description=long_description, long_description_content_type='text/x-rst', author='Cory Benfield', author_email='cory@lukasa.co.uk', url='https://github.com/python-hyper/hpack', packages=find_packages(where="src"), package_data={'': ['LICENSE', 'README.rst', 'CHANGELOG.rst']}, package_dir={'': 'src'}, python_requires='>=3.6.1', include_package_data=True, license='MIT License', classifiers=[ 'Development Status :: 5 - Production/Stable', 'Intended Audience :: Developers', 'License :: OSI Approved :: MIT License', 'Programming Language :: Python', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', 'Programming Language :: Python :: 3.8', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', ], ) ././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1598783094.595596 hpack-4.0.0/src/0000755000076500000240000000000000000000000014132 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6093032 hpack-4.0.0/src/hpack/0000755000076500000240000000000000000000000015220 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598782725.0 hpack-4.0.0/src/hpack/__init__.py0000644000076500000240000000107000000000000017327 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack ~~~~~ HTTP/2 header encoding for Python. """ from .hpack import Encoder, Decoder from .struct import HeaderTuple, NeverIndexedHeaderTuple from .exceptions import ( HPACKError, HPACKDecodingError, InvalidTableIndex, OversizedHeaderListError, InvalidTableSizeError ) __all__ = [ 'Encoder', 'Decoder', 'HeaderTuple', 'NeverIndexedHeaderTuple', 'HPACKError', 'HPACKDecodingError', 'InvalidTableIndex', 'OversizedHeaderListError', 'InvalidTableSizeError', ] __version__ = '4.0.0' ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/exceptions.py0000644000076500000240000000171600000000000017760 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hyper/http20/exceptions ~~~~~~~~~~~~~~~~~~~~~~~ This defines exceptions used in the HTTP/2 portion of hyper. """ class HPACKError(Exception): """ The base class for all ``hpack`` exceptions. """ pass class HPACKDecodingError(HPACKError): """ An error has been encountered while performing HPACK decoding. """ pass class InvalidTableIndex(HPACKDecodingError): """ An invalid table index was received. """ pass class OversizedHeaderListError(HPACKDecodingError): """ A header list that was larger than we allow has been received. This may be a DoS attack. .. versionadded:: 2.3.0 """ pass class InvalidTableSizeError(HPACKDecodingError): """ An attempt was made to change the decoder table size to a value larger than allowed, or the list was shrunk and the remote peer didn't shrink their table size. .. versionadded:: 3.0.0 """ pass ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/hpack.py0000644000076500000240000005423300000000000016667 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack/hpack ~~~~~~~~~~~ Implements the HPACK header compression algorithm as detailed by the IETF. """ import logging from .table import HeaderTable, table_entry_size from .exceptions import ( HPACKDecodingError, OversizedHeaderListError, InvalidTableSizeError ) from .huffman import HuffmanEncoder from .huffman_constants import ( REQUEST_CODES, REQUEST_CODES_LENGTH ) from .huffman_table import decode_huffman from .struct import HeaderTuple, NeverIndexedHeaderTuple log = logging.getLogger(__name__) INDEX_NONE = b'\x00' INDEX_NEVER = b'\x10' INDEX_INCREMENTAL = b'\x40' # Precompute 2^i for 1-8 for use in prefix calcs. # Zero index is not used but there to save a subtraction # as prefix numbers are not zero indexed. _PREFIX_BIT_MAX_NUMBERS = [(2 ** i) - 1 for i in range(9)] try: # pragma: no cover basestring = basestring except NameError: # pragma: no cover basestring = (str, bytes) # We default the maximum header list we're willing to accept to 64kB. That's a # lot of headers, but if applications want to raise it they can do. DEFAULT_MAX_HEADER_LIST_SIZE = 2 ** 16 def _unicode_if_needed(header, raw): """ Provides a header as a unicode string if raw is False, otherwise returns it as a bytestring. """ name = bytes(header[0]) value = bytes(header[1]) if not raw: name = name.decode('utf-8') value = value.decode('utf-8') return header.__class__(name, value) def encode_integer(integer, prefix_bits): """ This encodes an integer according to the wacky integer encoding rules defined in the HPACK spec. """ log.debug("Encoding %d with %d bits", integer, prefix_bits) if integer < 0: raise ValueError( "Can only encode positive integers, got %s" % integer ) if prefix_bits < 1 or prefix_bits > 8: raise ValueError( "Prefix bits must be between 1 and 8, got %s" % prefix_bits ) max_number = _PREFIX_BIT_MAX_NUMBERS[prefix_bits] if integer < max_number: return bytearray([integer]) # Seriously? else: elements = [max_number] integer -= max_number while integer >= 128: elements.append((integer & 127) + 128) integer >>= 7 elements.append(integer) return bytearray(elements) def decode_integer(data, prefix_bits): """ This decodes an integer according to the wacky integer encoding rules defined in the HPACK spec. Returns a tuple of the decoded integer and the number of bytes that were consumed from ``data`` in order to get that integer. """ if prefix_bits < 1 or prefix_bits > 8: raise ValueError( "Prefix bits must be between 1 and 8, got %s" % prefix_bits ) max_number = _PREFIX_BIT_MAX_NUMBERS[prefix_bits] index = 1 shift = 0 mask = (0xFF >> (8 - prefix_bits)) try: number = data[0] & mask if number == max_number: while True: next_byte = data[index] index += 1 if next_byte >= 128: number += (next_byte - 128) << shift else: number += next_byte << shift break shift += 7 except IndexError: raise HPACKDecodingError( "Unable to decode HPACK integer representation from %r" % data ) log.debug("Decoded %d, consumed %d bytes", number, index) return number, index def _dict_to_iterable(header_dict): """ This converts a dictionary to an iterable of two-tuples. This is a HPACK-specific function because it pulls "special-headers" out first and then emits them. """ assert isinstance(header_dict, dict) keys = sorted( header_dict.keys(), key=lambda k: not _to_bytes(k).startswith(b':') ) for key in keys: yield key, header_dict[key] def _to_bytes(string): """ Convert string to bytes. """ if not isinstance(string, basestring): # pragma: no cover string = str(string) return string if isinstance(string, bytes) else string.encode('utf-8') class Encoder: """ An HPACK encoder object. This object takes HTTP headers and emits encoded HTTP/2 header blocks. """ def __init__(self): self.header_table = HeaderTable() self.huffman_coder = HuffmanEncoder( REQUEST_CODES, REQUEST_CODES_LENGTH ) self.table_size_changes = [] @property def header_table_size(self): """ Controls the size of the HPACK header table. """ return self.header_table.maxsize @header_table_size.setter def header_table_size(self, value): self.header_table.maxsize = value if self.header_table.resized: self.table_size_changes.append(value) def encode(self, headers, huffman=True): """ Takes a set of headers and encodes them into a HPACK-encoded header block. :param headers: The headers to encode. Must be either an iterable of tuples, an iterable of :class:`HeaderTuple `, or a ``dict``. If an iterable of tuples, the tuples may be either two-tuples or three-tuples. If they are two-tuples, the tuples must be of the format ``(name, value)``. If they are three-tuples, they must be of the format ``(name, value, sensitive)``, where ``sensitive`` is a boolean value indicating whether the header should be added to header tables anywhere. If not present, ``sensitive`` defaults to ``False``. If an iterable of :class:`HeaderTuple `, the tuples must always be two-tuples. Instead of using ``sensitive`` as a third tuple entry, use :class:`NeverIndexedHeaderTuple ` to request that the field never be indexed. .. warning:: HTTP/2 requires that all special headers (headers whose names begin with ``:`` characters) appear at the *start* of the header block. While this method will ensure that happens for ``dict`` subclasses, callers using any other iterable of tuples **must** ensure they place their special headers at the start of the iterable. For efficiency reasons users should prefer to use iterables of two-tuples: fixing the ordering of dictionary headers is an expensive operation that should be avoided if possible. :param huffman: (optional) Whether to Huffman-encode any header sent as a literal value. Except for use when debugging, it is recommended that this be left enabled. :returns: A bytestring containing the HPACK-encoded header block. """ # Transforming the headers into a header block is a procedure that can # be modeled as a chain or pipe. First, the headers are encoded. This # encoding can be done a number of ways. If the header name-value pair # are already in the header table we can represent them using the # indexed representation: the same is true if they are in the static # table. Otherwise, a literal representation will be used. header_block = [] # Turn the headers into a list of tuples if possible. This is the # natural way to interact with them in HPACK. Because dictionaries are # un-ordered, we need to make sure we grab the "special" headers first. if isinstance(headers, dict): headers = _dict_to_iterable(headers) # Before we begin, if the header table size has been changed we need # to signal all changes since last emission appropriately. if self.header_table.resized: header_block.append(self._encode_table_size_change()) self.header_table.resized = False # Add each header to the header block for header in headers: sensitive = False if isinstance(header, HeaderTuple): sensitive = not header.indexable elif len(header) > 2: sensitive = header[2] header = (_to_bytes(header[0]), _to_bytes(header[1])) header_block.append(self.add(header, sensitive, huffman)) header_block = b''.join(header_block) log.debug("Encoded header block to %s", header_block) return header_block def add(self, to_add, sensitive, huffman=False): """ This function takes a header key-value tuple and serializes it. """ log.debug( "Adding %s to the header table, sensitive:%s, huffman:%s", to_add, sensitive, huffman ) name, value = to_add # Set our indexing mode indexbit = INDEX_INCREMENTAL if not sensitive else INDEX_NEVER # Search for a matching header in the header table. match = self.header_table.search(name, value) if match is None: # Not in the header table. Encode using the literal syntax, # and add it to the header table. encoded = self._encode_literal(name, value, indexbit, huffman) if not sensitive: self.header_table.add(name, value) return encoded # The header is in the table, break out the values. If we matched # perfectly, we can use the indexed representation: otherwise we # can use the indexed literal. index, name, perfect = match if perfect: # Indexed representation. encoded = self._encode_indexed(index) else: # Indexed literal. We are going to add header to the # header table unconditionally. It is a future todo to # filter out headers which are known to be ineffective for # indexing since they just take space in the table and # pushed out other valuable headers. encoded = self._encode_indexed_literal( index, value, indexbit, huffman ) if not sensitive: self.header_table.add(name, value) return encoded def _encode_indexed(self, index): """ Encodes a header using the indexed representation. """ field = encode_integer(index, 7) field[0] |= 0x80 # we set the top bit return bytes(field) def _encode_literal(self, name, value, indexbit, huffman=False): """ Encodes a header with a literal name and literal value. If ``indexing`` is True, the header will be added to the header table: otherwise it will not. """ if huffman: name = self.huffman_coder.encode(name) value = self.huffman_coder.encode(value) name_len = encode_integer(len(name), 7) value_len = encode_integer(len(value), 7) if huffman: name_len[0] |= 0x80 value_len[0] |= 0x80 return b''.join( [indexbit, bytes(name_len), name, bytes(value_len), value] ) def _encode_indexed_literal(self, index, value, indexbit, huffman=False): """ Encodes a header with an indexed name and a literal value and performs incremental indexing. """ if indexbit != INDEX_INCREMENTAL: prefix = encode_integer(index, 4) else: prefix = encode_integer(index, 6) prefix[0] |= ord(indexbit) if huffman: value = self.huffman_coder.encode(value) value_len = encode_integer(len(value), 7) if huffman: value_len[0] |= 0x80 return b''.join([bytes(prefix), bytes(value_len), value]) def _encode_table_size_change(self): """ Produces the encoded form of all header table size change context updates. """ block = b'' for size_bytes in self.table_size_changes: size_bytes = encode_integer(size_bytes, 5) size_bytes[0] |= 0x20 block += bytes(size_bytes) self.table_size_changes = [] return block class Decoder: """ An HPACK decoder object. .. versionchanged:: 2.3.0 Added ``max_header_list_size`` argument. :param max_header_list_size: The maximum decompressed size we will allow for any single header block. This is a protection against DoS attacks that attempt to force the application to expand a relatively small amount of data into a really large header list, allowing enormous amounts of memory to be allocated. If this amount of data is exceeded, a `OversizedHeaderListError ` exception will be raised. At this point the connection should be shut down, as the HPACK state will no longer be usable. Defaults to 64kB. :type max_header_list_size: ``int`` """ def __init__(self, max_header_list_size=DEFAULT_MAX_HEADER_LIST_SIZE): self.header_table = HeaderTable() #: The maximum decompressed size we will allow for any single header #: block. This is a protection against DoS attacks that attempt to #: force the application to expand a relatively small amount of data #: into a really large header list, allowing enormous amounts of memory #: to be allocated. #: #: If this amount of data is exceeded, a `OversizedHeaderListError #: ` exception will be raised. At this #: point the connection should be shut down, as the HPACK state will no #: longer be usable. #: #: Defaults to 64kB. #: #: .. versionadded:: 2.3.0 self.max_header_list_size = max_header_list_size #: Maximum allowed header table size. #: #: A HTTP/2 implementation should set this to the most recent value of #: SETTINGS_HEADER_TABLE_SIZE that it sent *and has received an ACK #: for*. Once this setting is set, the actual header table size will be #: checked at the end of each decoding run and whenever it is changed, #: to confirm that it fits in this size. self.max_allowed_table_size = self.header_table.maxsize @property def header_table_size(self): """ Controls the size of the HPACK header table. """ return self.header_table.maxsize @header_table_size.setter def header_table_size(self, value): self.header_table.maxsize = value def decode(self, data, raw=False): """ Takes an HPACK-encoded header block and decodes it into a header set. :param data: A bytestring representing a complete HPACK-encoded header block. :param raw: (optional) Whether to return the headers as tuples of raw byte strings or to decode them as UTF-8 before returning them. The default value is False, which returns tuples of Unicode strings :returns: A list of two-tuples of ``(name, value)`` representing the HPACK-encoded headers, in the order they were decoded. :raises HPACKDecodingError: If an error is encountered while decoding the header block. """ log.debug("Decoding %s", data) data_mem = memoryview(data) headers = [] data_len = len(data) inflated_size = 0 current_index = 0 while current_index < data_len: # Work out what kind of header we're decoding. # If the high bit is 1, it's an indexed field. current = data[current_index] indexed = True if current & 0x80 else False # Otherwise, if the second-highest bit is 1 it's a field that does # alter the header table. literal_index = True if current & 0x40 else False # Otherwise, if the third-highest bit is 1 it's an encoding context # update. encoding_update = True if current & 0x20 else False if indexed: header, consumed = self._decode_indexed( data_mem[current_index:] ) elif literal_index: # It's a literal header that does affect the header table. header, consumed = self._decode_literal_index( data_mem[current_index:] ) elif encoding_update: # It's an update to the encoding context. These are forbidden # in a header block after any actual header. if headers: raise HPACKDecodingError( "Table size update not at the start of the block" ) consumed = self._update_encoding_context( data_mem[current_index:] ) header = None else: # It's a literal header that does not affect the header table. header, consumed = self._decode_literal_no_index( data_mem[current_index:] ) if header: headers.append(header) inflated_size += table_entry_size(*header) if inflated_size > self.max_header_list_size: raise OversizedHeaderListError( "A header list larger than %d has been received" % self.max_header_list_size ) current_index += consumed # Confirm that the table size is lower than the maximum. We do this # here to ensure that we catch when the max has been *shrunk* and the # remote peer hasn't actually done that. self._assert_valid_table_size() try: return [_unicode_if_needed(h, raw) for h in headers] except UnicodeDecodeError: raise HPACKDecodingError("Unable to decode headers as UTF-8.") def _assert_valid_table_size(self): """ Check that the table size set by the encoder is lower than the maximum we expect to have. """ if self.header_table_size > self.max_allowed_table_size: raise InvalidTableSizeError( "Encoder did not shrink table size to within the max" ) def _update_encoding_context(self, data): """ Handles a byte that updates the encoding context. """ # We've been asked to resize the header table. new_size, consumed = decode_integer(data, 5) if new_size > self.max_allowed_table_size: raise InvalidTableSizeError( "Encoder exceeded max allowable table size" ) self.header_table_size = new_size return consumed def _decode_indexed(self, data): """ Decodes a header represented using the indexed representation. """ index, consumed = decode_integer(data, 7) header = HeaderTuple(*self.header_table.get_by_index(index)) log.debug("Decoded %s, consumed %d", header, consumed) return header, consumed def _decode_literal_no_index(self, data): return self._decode_literal(data, False) def _decode_literal_index(self, data): return self._decode_literal(data, True) def _decode_literal(self, data, should_index): """ Decodes a header represented with a literal. """ total_consumed = 0 # When should_index is true, if the low six bits of the first byte are # nonzero, the header name is indexed. # When should_index is false, if the low four bits of the first byte # are nonzero the header name is indexed. if should_index: indexed_name = data[0] & 0x3F name_len = 6 not_indexable = False else: high_byte = data[0] indexed_name = high_byte & 0x0F name_len = 4 not_indexable = high_byte & 0x10 if indexed_name: # Indexed header name. index, consumed = decode_integer(data, name_len) name = self.header_table.get_by_index(index)[0] total_consumed = consumed length = 0 else: # Literal header name. The first byte was consumed, so we need to # move forward. data = data[1:] length, consumed = decode_integer(data, 7) name = data[consumed:consumed + length] if len(name) != length: raise HPACKDecodingError("Truncated header block") if data[0] & 0x80: name = decode_huffman(name) total_consumed = consumed + length + 1 # Since we moved forward 1. data = data[consumed + length:] # The header value is definitely length-based. length, consumed = decode_integer(data, 7) value = data[consumed:consumed + length] if len(value) != length: raise HPACKDecodingError("Truncated header block") if data[0] & 0x80: value = decode_huffman(value) # Updated the total consumed length. total_consumed += length + consumed # If we have been told never to index the header field, encode that in # the tuple we use. if not_indexable: header = NeverIndexedHeaderTuple(name, value) else: header = HeaderTuple(name, value) # If we've been asked to index this, add it to the header table. if should_index: self.header_table.add(name, value) log.debug( "Decoded %s, total consumed %d bytes, indexed %s", header, total_consumed, should_index ) return header, total_consumed ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/huffman.py0000644000076500000240000000461300000000000017222 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack/huffman_decoder ~~~~~~~~~~~~~~~~~~~~~ An implementation of a bitwise prefix tree specially built for decoding Huffman-coded content where we already know the Huffman table. """ class HuffmanEncoder: """ Encodes a string according to the Huffman encoding table defined in the HPACK specification. """ def __init__(self, huffman_code_list, huffman_code_list_lengths): self.huffman_code_list = huffman_code_list self.huffman_code_list_lengths = huffman_code_list_lengths def encode(self, bytes_to_encode): """ Given a string of bytes, encodes them according to the HPACK Huffman specification. """ # If handed the empty string, just immediately return. if not bytes_to_encode: return b'' final_num = 0 final_int_len = 0 # Turn each byte into its huffman code. These codes aren't necessarily # octet aligned, so keep track of how far through an octet we are. To # handle this cleanly, just use a single giant integer. for byte in bytes_to_encode: bin_int_len = self.huffman_code_list_lengths[byte] bin_int = self.huffman_code_list[byte] & ( 2 ** (bin_int_len + 1) - 1 ) final_num <<= bin_int_len final_num |= bin_int final_int_len += bin_int_len # Pad out to an octet with ones. bits_to_be_padded = (8 - (final_int_len % 8)) % 8 final_num <<= bits_to_be_padded final_num |= (1 << bits_to_be_padded) - 1 # Convert the number to hex and strip off the leading '0x' and the # trailing 'L', if present. final_num = hex(final_num)[2:].rstrip('L') # If this is odd, prepend a zero. final_num = '0' + final_num if len(final_num) % 2 != 0 else final_num # This number should have twice as many digits as bytes. If not, we're # missing some leading zeroes. Work out how many bytes we want and how # many digits we have, then add the missing zero digits to the front. total_bytes = (final_int_len + bits_to_be_padded) // 8 expected_digits = total_bytes * 2 if len(final_num) != expected_digits: missing_digits = expected_digits - len(final_num) final_num = ('0' * missing_digits) + final_num return bytes.fromhex(final_num) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/huffman_constants.py0000644000076500000240000001104300000000000021311 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack/huffman_constants ~~~~~~~~~~~~~~~~~~~~~~~ Defines the constant Huffman table. This takes up an upsetting amount of space, but c'est la vie. """ # flake8: noqa REQUEST_CODES = [ 0x1ff8, 0x7fffd8, 0xfffffe2, 0xfffffe3, 0xfffffe4, 0xfffffe5, 0xfffffe6, 0xfffffe7, 0xfffffe8, 0xffffea, 0x3ffffffc, 0xfffffe9, 0xfffffea, 0x3ffffffd, 0xfffffeb, 0xfffffec, 0xfffffed, 0xfffffee, 0xfffffef, 0xffffff0, 0xffffff1, 0xffffff2, 0x3ffffffe, 0xffffff3, 0xffffff4, 0xffffff5, 0xffffff6, 0xffffff7, 0xffffff8, 0xffffff9, 0xffffffa, 0xffffffb, 0x14, 0x3f8, 0x3f9, 0xffa, 0x1ff9, 0x15, 0xf8, 0x7fa, 0x3fa, 0x3fb, 0xf9, 0x7fb, 0xfa, 0x16, 0x17, 0x18, 0x0, 0x1, 0x2, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x5c, 0xfb, 0x7ffc, 0x20, 0xffb, 0x3fc, 0x1ffa, 0x21, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0xfc, 0x73, 0xfd, 0x1ffb, 0x7fff0, 0x1ffc, 0x3ffc, 0x22, 0x7ffd, 0x3, 0x23, 0x4, 0x24, 0x5, 0x25, 0x26, 0x27, 0x6, 0x74, 0x75, 0x28, 0x29, 0x2a, 0x7, 0x2b, 0x76, 0x2c, 0x8, 0x9, 0x2d, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7ffe, 0x7fc, 0x3ffd, 0x1ffd, 0xffffffc, 0xfffe6, 0x3fffd2, 0xfffe7, 0xfffe8, 0x3fffd3, 0x3fffd4, 0x3fffd5, 0x7fffd9, 0x3fffd6, 0x7fffda, 0x7fffdb, 0x7fffdc, 0x7fffdd, 0x7fffde, 0xffffeb, 0x7fffdf, 0xffffec, 0xffffed, 0x3fffd7, 0x7fffe0, 0xffffee, 0x7fffe1, 0x7fffe2, 0x7fffe3, 0x7fffe4, 0x1fffdc, 0x3fffd8, 0x7fffe5, 0x3fffd9, 0x7fffe6, 0x7fffe7, 0xffffef, 0x3fffda, 0x1fffdd, 0xfffe9, 0x3fffdb, 0x3fffdc, 0x7fffe8, 0x7fffe9, 0x1fffde, 0x7fffea, 0x3fffdd, 0x3fffde, 0xfffff0, 0x1fffdf, 0x3fffdf, 0x7fffeb, 0x7fffec, 0x1fffe0, 0x1fffe1, 0x3fffe0, 0x1fffe2, 0x7fffed, 0x3fffe1, 0x7fffee, 0x7fffef, 0xfffea, 0x3fffe2, 0x3fffe3, 0x3fffe4, 0x7ffff0, 0x3fffe5, 0x3fffe6, 0x7ffff1, 0x3ffffe0, 0x3ffffe1, 0xfffeb, 0x7fff1, 0x3fffe7, 0x7ffff2, 0x3fffe8, 0x1ffffec, 0x3ffffe2, 0x3ffffe3, 0x3ffffe4, 0x7ffffde, 0x7ffffdf, 0x3ffffe5, 0xfffff1, 0x1ffffed, 0x7fff2, 0x1fffe3, 0x3ffffe6, 0x7ffffe0, 0x7ffffe1, 0x3ffffe7, 0x7ffffe2, 0xfffff2, 0x1fffe4, 0x1fffe5, 0x3ffffe8, 0x3ffffe9, 0xffffffd, 0x7ffffe3, 0x7ffffe4, 0x7ffffe5, 0xfffec, 0xfffff3, 0xfffed, 0x1fffe6, 0x3fffe9, 0x1fffe7, 0x1fffe8, 0x7ffff3, 0x3fffea, 0x3fffeb, 0x1ffffee, 0x1ffffef, 0xfffff4, 0xfffff5, 0x3ffffea, 0x7ffff4, 0x3ffffeb, 0x7ffffe6, 0x3ffffec, 0x3ffffed, 0x7ffffe7, 0x7ffffe8, 0x7ffffe9, 0x7ffffea, 0x7ffffeb, 0xffffffe, 0x7ffffec, 0x7ffffed, 0x7ffffee, 0x7ffffef, 0x7fffff0, 0x3ffffee, 0x3fffffff, ] REQUEST_CODES_LENGTH = [ 13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28, 6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10, 13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6, 15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5, 6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28, 20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23, 24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24, 22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23, 21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23, 26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25, 19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27, 20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23, 26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26, 30, ] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/huffman_table.py0000644000076500000240000051120400000000000020370 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack/huffman_table ~~~~~~~~~~~~~~~~~~~ This implementation of a Huffman decoding table for HTTP/2 is essentially a Python port of the work originally done for nghttp2's Huffman decoding. For this reason, while this file is made available under the MIT license as is the rest of this module, this file is undoubtedly a derivative work of the nghttp2 file ``nghttp2_hd_huffman_data.c``, obtained from https://github.com/tatsuhiro-t/nghttp2/ at commit d2b55ad1a245e1d1964579fa3fac36ebf3939e72. That work is made available under the Apache 2.0 license under the following terms: Copyright (c) 2013 Tatsuhiro Tsujikawa Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. The essence of this approach is that it builds a finite state machine out of 4-bit nibbles of Huffman coded data. The input function passes 4 bits worth of data to the state machine each time, which uses those 4 bits of data along with the current accumulated state data to process the data given. For the sake of efficiency, the in-memory representation of the states, transitions, and result values of the state machine are represented as a long list containing three-tuples. This list is enormously long, and viewing it as an in-memory representation is not very clear, but it is laid out here in a way that is intended to be *somewhat* more clear. Essentially, the list is structured as 256 collections of 16 entries (one for each nibble) of three-tuples. Each collection is called a "node", and the zeroth collection is called the "root node". The state machine tracks one value: the "state" byte. For each nibble passed to the state machine, it first multiplies the "state" byte by 16 and adds the numerical value of the nibble. This number is the index into the large flat list. The three-tuple that is found by looking up that index consists of three values: - a new state value, used for subsequent decoding - a collection of flags, used to determine whether data is emitted or whether the state machine is complete. - the byte value to emit, assuming that emitting a byte is required. The flags are consulted, if necessary a byte is emitted, and then the next nibble is used. This continues until the state machine believes it has completely Huffman-decoded the data. This approach has relatively little indirection, and therefore performs relatively well, particularly on implementations like PyPy where the cost of loops at the Python-level is not too expensive. The total number of loop iterations is 4x the number of bytes passed to the decoder. """ from .exceptions import HPACKDecodingError # This defines the state machine "class" at the top of the file. The reason we # do this is to keep the terrifing monster state table at the *bottom* of the # file so you don't have to actually *look* at the damn thing. def decode_huffman(huffman_string): """ Given a bytestring of Huffman-encoded data for HPACK, returns a bytestring of the decompressed data. """ if not huffman_string: return b'' state = 0 flags = 0 decoded_bytes = bytearray() # Perversely, bytearrays are a lot more convenient across Python 2 and # Python 3 because they behave *the same way* on both platforms. Given that # we really do want numerical bytes when we iterate here, let's use a # bytearray. huffman_string = bytearray(huffman_string) # This loop is unrolled somewhat. Because we use a nibble, not a byte, we # need to handle each nibble twice. We unroll that: it makes the loop body # a bit longer, but that's ok. for input_byte in huffman_string: index = (state * 16) + (input_byte >> 4) state, flags, output_byte = HUFFMAN_TABLE[index] if flags & HUFFMAN_FAIL: raise HPACKDecodingError("Invalid Huffman String") if flags & HUFFMAN_EMIT_SYMBOL: decoded_bytes.append(output_byte) index = (state * 16) + (input_byte & 0x0F) state, flags, output_byte = HUFFMAN_TABLE[index] if flags & HUFFMAN_FAIL: raise HPACKDecodingError("Invalid Huffman String") if flags & HUFFMAN_EMIT_SYMBOL: decoded_bytes.append(output_byte) if not (flags & HUFFMAN_COMPLETE): raise HPACKDecodingError("Incomplete Huffman string") return bytes(decoded_bytes) # Some decoder flags to control state transitions. HUFFMAN_COMPLETE = 1 HUFFMAN_EMIT_SYMBOL = (1 << 1) HUFFMAN_FAIL = (1 << 2) # This is the monster table. Avert your eyes, children. HUFFMAN_TABLE = [ # Node 0 (Root Node, never emits symbols.) (4, 0, 0), (5, 0, 0), (7, 0, 0), (8, 0, 0), (11, 0, 0), (12, 0, 0), (16, 0, 0), (19, 0, 0), (25, 0, 0), (28, 0, 0), (32, 0, 0), (35, 0, 0), (42, 0, 0), (49, 0, 0), (57, 0, 0), (64, HUFFMAN_COMPLETE, 0), # Node 1 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 48), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 49), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 50), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 97), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 99), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 101), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 105), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 111), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 115), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 116), (13, 0, 0), (14, 0, 0), (17, 0, 0), (18, 0, 0), (20, 0, 0), (21, 0, 0), # Node 2 (1, HUFFMAN_EMIT_SYMBOL, 48), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 48), (1, HUFFMAN_EMIT_SYMBOL, 49), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 49), (1, HUFFMAN_EMIT_SYMBOL, 50), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 50), (1, HUFFMAN_EMIT_SYMBOL, 97), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 97), (1, HUFFMAN_EMIT_SYMBOL, 99), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 99), (1, HUFFMAN_EMIT_SYMBOL, 101), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 101), (1, HUFFMAN_EMIT_SYMBOL, 105), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 105), (1, HUFFMAN_EMIT_SYMBOL, 111), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 111), # Node 3 (2, HUFFMAN_EMIT_SYMBOL, 48), (9, HUFFMAN_EMIT_SYMBOL, 48), (23, HUFFMAN_EMIT_SYMBOL, 48), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 48), (2, HUFFMAN_EMIT_SYMBOL, 49), (9, HUFFMAN_EMIT_SYMBOL, 49), (23, HUFFMAN_EMIT_SYMBOL, 49), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 49), (2, HUFFMAN_EMIT_SYMBOL, 50), (9, HUFFMAN_EMIT_SYMBOL, 50), (23, HUFFMAN_EMIT_SYMBOL, 50), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 50), (2, HUFFMAN_EMIT_SYMBOL, 97), (9, HUFFMAN_EMIT_SYMBOL, 97), (23, HUFFMAN_EMIT_SYMBOL, 97), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 97), # Node 4 (3, HUFFMAN_EMIT_SYMBOL, 48), (6, HUFFMAN_EMIT_SYMBOL, 48), (10, HUFFMAN_EMIT_SYMBOL, 48), (15, HUFFMAN_EMIT_SYMBOL, 48), (24, HUFFMAN_EMIT_SYMBOL, 48), (31, HUFFMAN_EMIT_SYMBOL, 48), (41, HUFFMAN_EMIT_SYMBOL, 48), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 48), (3, HUFFMAN_EMIT_SYMBOL, 49), (6, HUFFMAN_EMIT_SYMBOL, 49), (10, HUFFMAN_EMIT_SYMBOL, 49), (15, HUFFMAN_EMIT_SYMBOL, 49), (24, HUFFMAN_EMIT_SYMBOL, 49), (31, HUFFMAN_EMIT_SYMBOL, 49), (41, HUFFMAN_EMIT_SYMBOL, 49), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 49), # Node 5 (3, HUFFMAN_EMIT_SYMBOL, 50), (6, HUFFMAN_EMIT_SYMBOL, 50), (10, HUFFMAN_EMIT_SYMBOL, 50), (15, HUFFMAN_EMIT_SYMBOL, 50), (24, HUFFMAN_EMIT_SYMBOL, 50), (31, HUFFMAN_EMIT_SYMBOL, 50), (41, HUFFMAN_EMIT_SYMBOL, 50), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 50), (3, HUFFMAN_EMIT_SYMBOL, 97), (6, HUFFMAN_EMIT_SYMBOL, 97), (10, HUFFMAN_EMIT_SYMBOL, 97), (15, HUFFMAN_EMIT_SYMBOL, 97), (24, HUFFMAN_EMIT_SYMBOL, 97), (31, HUFFMAN_EMIT_SYMBOL, 97), (41, HUFFMAN_EMIT_SYMBOL, 97), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 97), # Node 6 (2, HUFFMAN_EMIT_SYMBOL, 99), (9, HUFFMAN_EMIT_SYMBOL, 99), (23, HUFFMAN_EMIT_SYMBOL, 99), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 99), (2, HUFFMAN_EMIT_SYMBOL, 101), (9, HUFFMAN_EMIT_SYMBOL, 101), (23, HUFFMAN_EMIT_SYMBOL, 101), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 101), (2, HUFFMAN_EMIT_SYMBOL, 105), (9, HUFFMAN_EMIT_SYMBOL, 105), (23, HUFFMAN_EMIT_SYMBOL, 105), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 105), (2, HUFFMAN_EMIT_SYMBOL, 111), (9, HUFFMAN_EMIT_SYMBOL, 111), (23, HUFFMAN_EMIT_SYMBOL, 111), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 111), # Node 7 (3, HUFFMAN_EMIT_SYMBOL, 99), (6, HUFFMAN_EMIT_SYMBOL, 99), (10, HUFFMAN_EMIT_SYMBOL, 99), (15, HUFFMAN_EMIT_SYMBOL, 99), (24, HUFFMAN_EMIT_SYMBOL, 99), (31, HUFFMAN_EMIT_SYMBOL, 99), (41, HUFFMAN_EMIT_SYMBOL, 99), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 99), (3, HUFFMAN_EMIT_SYMBOL, 101), (6, HUFFMAN_EMIT_SYMBOL, 101), (10, HUFFMAN_EMIT_SYMBOL, 101), (15, HUFFMAN_EMIT_SYMBOL, 101), (24, HUFFMAN_EMIT_SYMBOL, 101), (31, HUFFMAN_EMIT_SYMBOL, 101), (41, HUFFMAN_EMIT_SYMBOL, 101), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 101), # Node 8 (3, HUFFMAN_EMIT_SYMBOL, 105), (6, HUFFMAN_EMIT_SYMBOL, 105), (10, HUFFMAN_EMIT_SYMBOL, 105), (15, HUFFMAN_EMIT_SYMBOL, 105), (24, HUFFMAN_EMIT_SYMBOL, 105), (31, HUFFMAN_EMIT_SYMBOL, 105), (41, HUFFMAN_EMIT_SYMBOL, 105), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 105), (3, HUFFMAN_EMIT_SYMBOL, 111), (6, HUFFMAN_EMIT_SYMBOL, 111), (10, HUFFMAN_EMIT_SYMBOL, 111), (15, HUFFMAN_EMIT_SYMBOL, 111), (24, HUFFMAN_EMIT_SYMBOL, 111), (31, HUFFMAN_EMIT_SYMBOL, 111), (41, HUFFMAN_EMIT_SYMBOL, 111), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 111), # Node 9 (1, HUFFMAN_EMIT_SYMBOL, 115), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 115), (1, HUFFMAN_EMIT_SYMBOL, 116), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 116), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 32), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 37), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 45), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 46), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 47), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 51), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 52), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 53), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 54), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 55), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 56), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 57), # Node 10 (2, HUFFMAN_EMIT_SYMBOL, 115), (9, HUFFMAN_EMIT_SYMBOL, 115), (23, HUFFMAN_EMIT_SYMBOL, 115), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 115), (2, HUFFMAN_EMIT_SYMBOL, 116), (9, HUFFMAN_EMIT_SYMBOL, 116), (23, HUFFMAN_EMIT_SYMBOL, 116), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 116), (1, HUFFMAN_EMIT_SYMBOL, 32), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 32), (1, HUFFMAN_EMIT_SYMBOL, 37), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 37), (1, HUFFMAN_EMIT_SYMBOL, 45), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 45), (1, HUFFMAN_EMIT_SYMBOL, 46), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 46), # Node 11 (3, HUFFMAN_EMIT_SYMBOL, 115), (6, HUFFMAN_EMIT_SYMBOL, 115), (10, HUFFMAN_EMIT_SYMBOL, 115), (15, HUFFMAN_EMIT_SYMBOL, 115), (24, HUFFMAN_EMIT_SYMBOL, 115), (31, HUFFMAN_EMIT_SYMBOL, 115), (41, HUFFMAN_EMIT_SYMBOL, 115), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 115), (3, HUFFMAN_EMIT_SYMBOL, 116), (6, HUFFMAN_EMIT_SYMBOL, 116), (10, HUFFMAN_EMIT_SYMBOL, 116), (15, HUFFMAN_EMIT_SYMBOL, 116), (24, HUFFMAN_EMIT_SYMBOL, 116), (31, HUFFMAN_EMIT_SYMBOL, 116), (41, HUFFMAN_EMIT_SYMBOL, 116), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 116), # Node 12 (2, HUFFMAN_EMIT_SYMBOL, 32), (9, HUFFMAN_EMIT_SYMBOL, 32), (23, HUFFMAN_EMIT_SYMBOL, 32), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 32), (2, HUFFMAN_EMIT_SYMBOL, 37), (9, HUFFMAN_EMIT_SYMBOL, 37), (23, HUFFMAN_EMIT_SYMBOL, 37), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 37), (2, HUFFMAN_EMIT_SYMBOL, 45), (9, HUFFMAN_EMIT_SYMBOL, 45), (23, HUFFMAN_EMIT_SYMBOL, 45), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 45), (2, HUFFMAN_EMIT_SYMBOL, 46), (9, HUFFMAN_EMIT_SYMBOL, 46), (23, HUFFMAN_EMIT_SYMBOL, 46), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 46), # Node 13 (3, HUFFMAN_EMIT_SYMBOL, 32), (6, HUFFMAN_EMIT_SYMBOL, 32), (10, HUFFMAN_EMIT_SYMBOL, 32), (15, HUFFMAN_EMIT_SYMBOL, 32), (24, HUFFMAN_EMIT_SYMBOL, 32), (31, HUFFMAN_EMIT_SYMBOL, 32), (41, HUFFMAN_EMIT_SYMBOL, 32), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 32), (3, HUFFMAN_EMIT_SYMBOL, 37), (6, HUFFMAN_EMIT_SYMBOL, 37), (10, HUFFMAN_EMIT_SYMBOL, 37), (15, HUFFMAN_EMIT_SYMBOL, 37), (24, HUFFMAN_EMIT_SYMBOL, 37), (31, HUFFMAN_EMIT_SYMBOL, 37), (41, HUFFMAN_EMIT_SYMBOL, 37), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 37), # Node 14 (3, HUFFMAN_EMIT_SYMBOL, 45), (6, HUFFMAN_EMIT_SYMBOL, 45), (10, HUFFMAN_EMIT_SYMBOL, 45), (15, HUFFMAN_EMIT_SYMBOL, 45), (24, HUFFMAN_EMIT_SYMBOL, 45), (31, HUFFMAN_EMIT_SYMBOL, 45), (41, HUFFMAN_EMIT_SYMBOL, 45), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 45), (3, HUFFMAN_EMIT_SYMBOL, 46), (6, HUFFMAN_EMIT_SYMBOL, 46), (10, HUFFMAN_EMIT_SYMBOL, 46), (15, HUFFMAN_EMIT_SYMBOL, 46), (24, HUFFMAN_EMIT_SYMBOL, 46), (31, HUFFMAN_EMIT_SYMBOL, 46), (41, HUFFMAN_EMIT_SYMBOL, 46), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 46), # Node 15 (1, HUFFMAN_EMIT_SYMBOL, 47), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 47), (1, HUFFMAN_EMIT_SYMBOL, 51), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 51), (1, HUFFMAN_EMIT_SYMBOL, 52), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 52), (1, HUFFMAN_EMIT_SYMBOL, 53), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 53), (1, HUFFMAN_EMIT_SYMBOL, 54), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 54), (1, HUFFMAN_EMIT_SYMBOL, 55), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 55), (1, HUFFMAN_EMIT_SYMBOL, 56), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 56), (1, HUFFMAN_EMIT_SYMBOL, 57), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 57), # Node 16 (2, HUFFMAN_EMIT_SYMBOL, 47), (9, HUFFMAN_EMIT_SYMBOL, 47), (23, HUFFMAN_EMIT_SYMBOL, 47), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 47), (2, HUFFMAN_EMIT_SYMBOL, 51), (9, HUFFMAN_EMIT_SYMBOL, 51), (23, HUFFMAN_EMIT_SYMBOL, 51), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 51), (2, HUFFMAN_EMIT_SYMBOL, 52), (9, HUFFMAN_EMIT_SYMBOL, 52), (23, HUFFMAN_EMIT_SYMBOL, 52), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 52), (2, HUFFMAN_EMIT_SYMBOL, 53), (9, HUFFMAN_EMIT_SYMBOL, 53), (23, HUFFMAN_EMIT_SYMBOL, 53), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 53), # Node 17 (3, HUFFMAN_EMIT_SYMBOL, 47), (6, HUFFMAN_EMIT_SYMBOL, 47), (10, HUFFMAN_EMIT_SYMBOL, 47), (15, HUFFMAN_EMIT_SYMBOL, 47), (24, HUFFMAN_EMIT_SYMBOL, 47), (31, HUFFMAN_EMIT_SYMBOL, 47), (41, HUFFMAN_EMIT_SYMBOL, 47), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 47), (3, HUFFMAN_EMIT_SYMBOL, 51), (6, HUFFMAN_EMIT_SYMBOL, 51), (10, HUFFMAN_EMIT_SYMBOL, 51), (15, HUFFMAN_EMIT_SYMBOL, 51), (24, HUFFMAN_EMIT_SYMBOL, 51), (31, HUFFMAN_EMIT_SYMBOL, 51), (41, HUFFMAN_EMIT_SYMBOL, 51), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 51), # Node 18 (3, HUFFMAN_EMIT_SYMBOL, 52), (6, HUFFMAN_EMIT_SYMBOL, 52), (10, HUFFMAN_EMIT_SYMBOL, 52), (15, HUFFMAN_EMIT_SYMBOL, 52), (24, HUFFMAN_EMIT_SYMBOL, 52), (31, HUFFMAN_EMIT_SYMBOL, 52), (41, HUFFMAN_EMIT_SYMBOL, 52), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 52), (3, HUFFMAN_EMIT_SYMBOL, 53), (6, HUFFMAN_EMIT_SYMBOL, 53), (10, HUFFMAN_EMIT_SYMBOL, 53), (15, HUFFMAN_EMIT_SYMBOL, 53), (24, HUFFMAN_EMIT_SYMBOL, 53), (31, HUFFMAN_EMIT_SYMBOL, 53), (41, HUFFMAN_EMIT_SYMBOL, 53), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 53), # Node 19 (2, HUFFMAN_EMIT_SYMBOL, 54), (9, HUFFMAN_EMIT_SYMBOL, 54), (23, HUFFMAN_EMIT_SYMBOL, 54), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 54), (2, HUFFMAN_EMIT_SYMBOL, 55), (9, HUFFMAN_EMIT_SYMBOL, 55), (23, HUFFMAN_EMIT_SYMBOL, 55), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 55), (2, HUFFMAN_EMIT_SYMBOL, 56), (9, HUFFMAN_EMIT_SYMBOL, 56), (23, HUFFMAN_EMIT_SYMBOL, 56), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 56), (2, HUFFMAN_EMIT_SYMBOL, 57), (9, HUFFMAN_EMIT_SYMBOL, 57), (23, HUFFMAN_EMIT_SYMBOL, 57), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 57), # Node 20 (3, HUFFMAN_EMIT_SYMBOL, 54), (6, HUFFMAN_EMIT_SYMBOL, 54), (10, HUFFMAN_EMIT_SYMBOL, 54), (15, HUFFMAN_EMIT_SYMBOL, 54), (24, HUFFMAN_EMIT_SYMBOL, 54), (31, HUFFMAN_EMIT_SYMBOL, 54), (41, HUFFMAN_EMIT_SYMBOL, 54), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 54), (3, HUFFMAN_EMIT_SYMBOL, 55), (6, HUFFMAN_EMIT_SYMBOL, 55), (10, HUFFMAN_EMIT_SYMBOL, 55), (15, HUFFMAN_EMIT_SYMBOL, 55), (24, HUFFMAN_EMIT_SYMBOL, 55), (31, HUFFMAN_EMIT_SYMBOL, 55), (41, HUFFMAN_EMIT_SYMBOL, 55), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 55), # Node 21 (3, HUFFMAN_EMIT_SYMBOL, 56), (6, HUFFMAN_EMIT_SYMBOL, 56), (10, HUFFMAN_EMIT_SYMBOL, 56), (15, HUFFMAN_EMIT_SYMBOL, 56), (24, HUFFMAN_EMIT_SYMBOL, 56), (31, HUFFMAN_EMIT_SYMBOL, 56), (41, HUFFMAN_EMIT_SYMBOL, 56), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 56), (3, HUFFMAN_EMIT_SYMBOL, 57), (6, HUFFMAN_EMIT_SYMBOL, 57), (10, HUFFMAN_EMIT_SYMBOL, 57), (15, HUFFMAN_EMIT_SYMBOL, 57), (24, HUFFMAN_EMIT_SYMBOL, 57), (31, HUFFMAN_EMIT_SYMBOL, 57), (41, HUFFMAN_EMIT_SYMBOL, 57), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 57), # Node 22 (26, 0, 0), (27, 0, 0), (29, 0, 0), (30, 0, 0), (33, 0, 0), (34, 0, 0), (36, 0, 0), (37, 0, 0), (43, 0, 0), (46, 0, 0), (50, 0, 0), (53, 0, 0), (58, 0, 0), (61, 0, 0), (65, 0, 0), (68, HUFFMAN_COMPLETE, 0), # Node 23 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 61), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 65), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 95), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 98), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 100), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 102), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 103), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 104), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 108), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 109), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 110), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 112), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 114), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 117), (38, 0, 0), (39, 0, 0), # Node 24 (1, HUFFMAN_EMIT_SYMBOL, 61), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 61), (1, HUFFMAN_EMIT_SYMBOL, 65), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 65), (1, HUFFMAN_EMIT_SYMBOL, 95), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 95), (1, HUFFMAN_EMIT_SYMBOL, 98), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 98), (1, HUFFMAN_EMIT_SYMBOL, 100), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 100), (1, HUFFMAN_EMIT_SYMBOL, 102), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 102), (1, HUFFMAN_EMIT_SYMBOL, 103), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 103), (1, HUFFMAN_EMIT_SYMBOL, 104), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 104), # Node 25 (2, HUFFMAN_EMIT_SYMBOL, 61), (9, HUFFMAN_EMIT_SYMBOL, 61), (23, HUFFMAN_EMIT_SYMBOL, 61), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 61), (2, HUFFMAN_EMIT_SYMBOL, 65), (9, HUFFMAN_EMIT_SYMBOL, 65), (23, HUFFMAN_EMIT_SYMBOL, 65), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 65), (2, HUFFMAN_EMIT_SYMBOL, 95), (9, HUFFMAN_EMIT_SYMBOL, 95), (23, HUFFMAN_EMIT_SYMBOL, 95), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 95), (2, HUFFMAN_EMIT_SYMBOL, 98), (9, HUFFMAN_EMIT_SYMBOL, 98), (23, HUFFMAN_EMIT_SYMBOL, 98), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 98), # Node 26 (3, HUFFMAN_EMIT_SYMBOL, 61), (6, HUFFMAN_EMIT_SYMBOL, 61), (10, HUFFMAN_EMIT_SYMBOL, 61), (15, HUFFMAN_EMIT_SYMBOL, 61), (24, HUFFMAN_EMIT_SYMBOL, 61), (31, HUFFMAN_EMIT_SYMBOL, 61), (41, HUFFMAN_EMIT_SYMBOL, 61), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 61), (3, HUFFMAN_EMIT_SYMBOL, 65), (6, HUFFMAN_EMIT_SYMBOL, 65), (10, HUFFMAN_EMIT_SYMBOL, 65), (15, HUFFMAN_EMIT_SYMBOL, 65), (24, HUFFMAN_EMIT_SYMBOL, 65), (31, HUFFMAN_EMIT_SYMBOL, 65), (41, HUFFMAN_EMIT_SYMBOL, 65), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 65), # Node 27 (3, HUFFMAN_EMIT_SYMBOL, 95), (6, HUFFMAN_EMIT_SYMBOL, 95), (10, HUFFMAN_EMIT_SYMBOL, 95), (15, HUFFMAN_EMIT_SYMBOL, 95), (24, HUFFMAN_EMIT_SYMBOL, 95), (31, HUFFMAN_EMIT_SYMBOL, 95), (41, HUFFMAN_EMIT_SYMBOL, 95), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 95), (3, HUFFMAN_EMIT_SYMBOL, 98), (6, HUFFMAN_EMIT_SYMBOL, 98), (10, HUFFMAN_EMIT_SYMBOL, 98), (15, HUFFMAN_EMIT_SYMBOL, 98), (24, HUFFMAN_EMIT_SYMBOL, 98), (31, HUFFMAN_EMIT_SYMBOL, 98), (41, HUFFMAN_EMIT_SYMBOL, 98), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 98), # Node 28 (2, HUFFMAN_EMIT_SYMBOL, 100), (9, HUFFMAN_EMIT_SYMBOL, 100), (23, HUFFMAN_EMIT_SYMBOL, 100), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 100), (2, HUFFMAN_EMIT_SYMBOL, 102), (9, HUFFMAN_EMIT_SYMBOL, 102), (23, HUFFMAN_EMIT_SYMBOL, 102), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 102), (2, HUFFMAN_EMIT_SYMBOL, 103), (9, HUFFMAN_EMIT_SYMBOL, 103), (23, HUFFMAN_EMIT_SYMBOL, 103), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 103), (2, HUFFMAN_EMIT_SYMBOL, 104), (9, HUFFMAN_EMIT_SYMBOL, 104), (23, HUFFMAN_EMIT_SYMBOL, 104), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 104), # Node 29 (3, HUFFMAN_EMIT_SYMBOL, 100), (6, HUFFMAN_EMIT_SYMBOL, 100), (10, HUFFMAN_EMIT_SYMBOL, 100), (15, HUFFMAN_EMIT_SYMBOL, 100), (24, HUFFMAN_EMIT_SYMBOL, 100), (31, HUFFMAN_EMIT_SYMBOL, 100), (41, HUFFMAN_EMIT_SYMBOL, 100), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 100), (3, HUFFMAN_EMIT_SYMBOL, 102), (6, HUFFMAN_EMIT_SYMBOL, 102), (10, HUFFMAN_EMIT_SYMBOL, 102), (15, HUFFMAN_EMIT_SYMBOL, 102), (24, HUFFMAN_EMIT_SYMBOL, 102), (31, HUFFMAN_EMIT_SYMBOL, 102), (41, HUFFMAN_EMIT_SYMBOL, 102), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 102), # Node 30 (3, HUFFMAN_EMIT_SYMBOL, 103), (6, HUFFMAN_EMIT_SYMBOL, 103), (10, HUFFMAN_EMIT_SYMBOL, 103), (15, HUFFMAN_EMIT_SYMBOL, 103), (24, HUFFMAN_EMIT_SYMBOL, 103), (31, HUFFMAN_EMIT_SYMBOL, 103), (41, HUFFMAN_EMIT_SYMBOL, 103), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 103), (3, HUFFMAN_EMIT_SYMBOL, 104), (6, HUFFMAN_EMIT_SYMBOL, 104), (10, HUFFMAN_EMIT_SYMBOL, 104), (15, HUFFMAN_EMIT_SYMBOL, 104), (24, HUFFMAN_EMIT_SYMBOL, 104), (31, HUFFMAN_EMIT_SYMBOL, 104), (41, HUFFMAN_EMIT_SYMBOL, 104), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 104), # Node 31 (1, HUFFMAN_EMIT_SYMBOL, 108), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 108), (1, HUFFMAN_EMIT_SYMBOL, 109), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 109), (1, HUFFMAN_EMIT_SYMBOL, 110), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 110), (1, HUFFMAN_EMIT_SYMBOL, 112), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 112), (1, HUFFMAN_EMIT_SYMBOL, 114), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 114), (1, HUFFMAN_EMIT_SYMBOL, 117), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 117), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 58), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 66), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 67), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 68), # Node 32 (2, HUFFMAN_EMIT_SYMBOL, 108), (9, HUFFMAN_EMIT_SYMBOL, 108), (23, HUFFMAN_EMIT_SYMBOL, 108), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 108), (2, HUFFMAN_EMIT_SYMBOL, 109), (9, HUFFMAN_EMIT_SYMBOL, 109), (23, HUFFMAN_EMIT_SYMBOL, 109), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 109), (2, HUFFMAN_EMIT_SYMBOL, 110), (9, HUFFMAN_EMIT_SYMBOL, 110), (23, HUFFMAN_EMIT_SYMBOL, 110), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 110), (2, HUFFMAN_EMIT_SYMBOL, 112), (9, HUFFMAN_EMIT_SYMBOL, 112), (23, HUFFMAN_EMIT_SYMBOL, 112), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 112), # Node 33 (3, HUFFMAN_EMIT_SYMBOL, 108), (6, HUFFMAN_EMIT_SYMBOL, 108), (10, HUFFMAN_EMIT_SYMBOL, 108), (15, HUFFMAN_EMIT_SYMBOL, 108), (24, HUFFMAN_EMIT_SYMBOL, 108), (31, HUFFMAN_EMIT_SYMBOL, 108), (41, HUFFMAN_EMIT_SYMBOL, 108), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 108), (3, HUFFMAN_EMIT_SYMBOL, 109), (6, HUFFMAN_EMIT_SYMBOL, 109), (10, HUFFMAN_EMIT_SYMBOL, 109), (15, HUFFMAN_EMIT_SYMBOL, 109), (24, HUFFMAN_EMIT_SYMBOL, 109), (31, HUFFMAN_EMIT_SYMBOL, 109), (41, HUFFMAN_EMIT_SYMBOL, 109), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 109), # Node 34 (3, HUFFMAN_EMIT_SYMBOL, 110), (6, HUFFMAN_EMIT_SYMBOL, 110), (10, HUFFMAN_EMIT_SYMBOL, 110), (15, HUFFMAN_EMIT_SYMBOL, 110), (24, HUFFMAN_EMIT_SYMBOL, 110), (31, HUFFMAN_EMIT_SYMBOL, 110), (41, HUFFMAN_EMIT_SYMBOL, 110), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 110), (3, HUFFMAN_EMIT_SYMBOL, 112), (6, HUFFMAN_EMIT_SYMBOL, 112), (10, HUFFMAN_EMIT_SYMBOL, 112), (15, HUFFMAN_EMIT_SYMBOL, 112), (24, HUFFMAN_EMIT_SYMBOL, 112), (31, HUFFMAN_EMIT_SYMBOL, 112), (41, HUFFMAN_EMIT_SYMBOL, 112), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 112), # Node 35 (2, HUFFMAN_EMIT_SYMBOL, 114), (9, HUFFMAN_EMIT_SYMBOL, 114), (23, HUFFMAN_EMIT_SYMBOL, 114), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 114), (2, HUFFMAN_EMIT_SYMBOL, 117), (9, HUFFMAN_EMIT_SYMBOL, 117), (23, HUFFMAN_EMIT_SYMBOL, 117), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 117), (1, HUFFMAN_EMIT_SYMBOL, 58), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 58), (1, HUFFMAN_EMIT_SYMBOL, 66), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 66), (1, HUFFMAN_EMIT_SYMBOL, 67), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 67), (1, HUFFMAN_EMIT_SYMBOL, 68), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 68), # Node 36 (3, HUFFMAN_EMIT_SYMBOL, 114), (6, HUFFMAN_EMIT_SYMBOL, 114), (10, HUFFMAN_EMIT_SYMBOL, 114), (15, HUFFMAN_EMIT_SYMBOL, 114), (24, HUFFMAN_EMIT_SYMBOL, 114), (31, HUFFMAN_EMIT_SYMBOL, 114), (41, HUFFMAN_EMIT_SYMBOL, 114), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 114), (3, HUFFMAN_EMIT_SYMBOL, 117), (6, HUFFMAN_EMIT_SYMBOL, 117), (10, HUFFMAN_EMIT_SYMBOL, 117), (15, HUFFMAN_EMIT_SYMBOL, 117), (24, HUFFMAN_EMIT_SYMBOL, 117), (31, HUFFMAN_EMIT_SYMBOL, 117), (41, HUFFMAN_EMIT_SYMBOL, 117), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 117), # Node 37 (2, HUFFMAN_EMIT_SYMBOL, 58), (9, HUFFMAN_EMIT_SYMBOL, 58), (23, HUFFMAN_EMIT_SYMBOL, 58), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 58), (2, HUFFMAN_EMIT_SYMBOL, 66), (9, HUFFMAN_EMIT_SYMBOL, 66), (23, HUFFMAN_EMIT_SYMBOL, 66), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 66), (2, HUFFMAN_EMIT_SYMBOL, 67), (9, HUFFMAN_EMIT_SYMBOL, 67), (23, HUFFMAN_EMIT_SYMBOL, 67), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 67), (2, HUFFMAN_EMIT_SYMBOL, 68), (9, HUFFMAN_EMIT_SYMBOL, 68), (23, HUFFMAN_EMIT_SYMBOL, 68), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 68), # Node 38 (3, HUFFMAN_EMIT_SYMBOL, 58), (6, HUFFMAN_EMIT_SYMBOL, 58), (10, HUFFMAN_EMIT_SYMBOL, 58), (15, HUFFMAN_EMIT_SYMBOL, 58), (24, HUFFMAN_EMIT_SYMBOL, 58), (31, HUFFMAN_EMIT_SYMBOL, 58), (41, HUFFMAN_EMIT_SYMBOL, 58), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 58), (3, HUFFMAN_EMIT_SYMBOL, 66), (6, HUFFMAN_EMIT_SYMBOL, 66), (10, HUFFMAN_EMIT_SYMBOL, 66), (15, HUFFMAN_EMIT_SYMBOL, 66), (24, HUFFMAN_EMIT_SYMBOL, 66), (31, HUFFMAN_EMIT_SYMBOL, 66), (41, HUFFMAN_EMIT_SYMBOL, 66), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 66), # Node 39 (3, HUFFMAN_EMIT_SYMBOL, 67), (6, HUFFMAN_EMIT_SYMBOL, 67), (10, HUFFMAN_EMIT_SYMBOL, 67), (15, HUFFMAN_EMIT_SYMBOL, 67), (24, HUFFMAN_EMIT_SYMBOL, 67), (31, HUFFMAN_EMIT_SYMBOL, 67), (41, HUFFMAN_EMIT_SYMBOL, 67), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 67), (3, HUFFMAN_EMIT_SYMBOL, 68), (6, HUFFMAN_EMIT_SYMBOL, 68), (10, HUFFMAN_EMIT_SYMBOL, 68), (15, HUFFMAN_EMIT_SYMBOL, 68), (24, HUFFMAN_EMIT_SYMBOL, 68), (31, HUFFMAN_EMIT_SYMBOL, 68), (41, HUFFMAN_EMIT_SYMBOL, 68), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 68), # Node 40 (44, 0, 0), (45, 0, 0), (47, 0, 0), (48, 0, 0), (51, 0, 0), (52, 0, 0), (54, 0, 0), (55, 0, 0), (59, 0, 0), (60, 0, 0), (62, 0, 0), (63, 0, 0), (66, 0, 0), (67, 0, 0), (69, 0, 0), (72, HUFFMAN_COMPLETE, 0), # Node 41 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 69), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 70), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 71), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 72), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 73), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 74), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 75), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 76), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 77), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 78), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 79), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 80), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 81), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 82), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 83), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 84), # Node 42 (1, HUFFMAN_EMIT_SYMBOL, 69), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 69), (1, HUFFMAN_EMIT_SYMBOL, 70), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 70), (1, HUFFMAN_EMIT_SYMBOL, 71), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 71), (1, HUFFMAN_EMIT_SYMBOL, 72), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 72), (1, HUFFMAN_EMIT_SYMBOL, 73), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 73), (1, HUFFMAN_EMIT_SYMBOL, 74), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 74), (1, HUFFMAN_EMIT_SYMBOL, 75), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 75), (1, HUFFMAN_EMIT_SYMBOL, 76), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 76), # Node 43 (2, HUFFMAN_EMIT_SYMBOL, 69), (9, HUFFMAN_EMIT_SYMBOL, 69), (23, HUFFMAN_EMIT_SYMBOL, 69), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 69), (2, HUFFMAN_EMIT_SYMBOL, 70), (9, HUFFMAN_EMIT_SYMBOL, 70), (23, HUFFMAN_EMIT_SYMBOL, 70), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 70), (2, HUFFMAN_EMIT_SYMBOL, 71), (9, HUFFMAN_EMIT_SYMBOL, 71), (23, HUFFMAN_EMIT_SYMBOL, 71), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 71), (2, HUFFMAN_EMIT_SYMBOL, 72), (9, HUFFMAN_EMIT_SYMBOL, 72), (23, HUFFMAN_EMIT_SYMBOL, 72), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 72), # Node 44 (3, HUFFMAN_EMIT_SYMBOL, 69), (6, HUFFMAN_EMIT_SYMBOL, 69), (10, HUFFMAN_EMIT_SYMBOL, 69), (15, HUFFMAN_EMIT_SYMBOL, 69), (24, HUFFMAN_EMIT_SYMBOL, 69), (31, HUFFMAN_EMIT_SYMBOL, 69), (41, HUFFMAN_EMIT_SYMBOL, 69), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 69), (3, HUFFMAN_EMIT_SYMBOL, 70), (6, HUFFMAN_EMIT_SYMBOL, 70), (10, HUFFMAN_EMIT_SYMBOL, 70), (15, HUFFMAN_EMIT_SYMBOL, 70), (24, HUFFMAN_EMIT_SYMBOL, 70), (31, HUFFMAN_EMIT_SYMBOL, 70), (41, HUFFMAN_EMIT_SYMBOL, 70), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 70), # Node 45 (3, HUFFMAN_EMIT_SYMBOL, 71), (6, HUFFMAN_EMIT_SYMBOL, 71), (10, HUFFMAN_EMIT_SYMBOL, 71), (15, HUFFMAN_EMIT_SYMBOL, 71), (24, HUFFMAN_EMIT_SYMBOL, 71), (31, HUFFMAN_EMIT_SYMBOL, 71), (41, HUFFMAN_EMIT_SYMBOL, 71), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 71), (3, HUFFMAN_EMIT_SYMBOL, 72), (6, HUFFMAN_EMIT_SYMBOL, 72), (10, HUFFMAN_EMIT_SYMBOL, 72), (15, HUFFMAN_EMIT_SYMBOL, 72), (24, HUFFMAN_EMIT_SYMBOL, 72), (31, HUFFMAN_EMIT_SYMBOL, 72), (41, HUFFMAN_EMIT_SYMBOL, 72), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 72), # Node 46 (2, HUFFMAN_EMIT_SYMBOL, 73), (9, HUFFMAN_EMIT_SYMBOL, 73), (23, HUFFMAN_EMIT_SYMBOL, 73), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 73), (2, HUFFMAN_EMIT_SYMBOL, 74), (9, HUFFMAN_EMIT_SYMBOL, 74), (23, HUFFMAN_EMIT_SYMBOL, 74), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 74), (2, HUFFMAN_EMIT_SYMBOL, 75), (9, HUFFMAN_EMIT_SYMBOL, 75), (23, HUFFMAN_EMIT_SYMBOL, 75), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 75), (2, HUFFMAN_EMIT_SYMBOL, 76), (9, HUFFMAN_EMIT_SYMBOL, 76), (23, HUFFMAN_EMIT_SYMBOL, 76), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 76), # Node 47 (3, HUFFMAN_EMIT_SYMBOL, 73), (6, HUFFMAN_EMIT_SYMBOL, 73), (10, HUFFMAN_EMIT_SYMBOL, 73), (15, HUFFMAN_EMIT_SYMBOL, 73), (24, HUFFMAN_EMIT_SYMBOL, 73), (31, HUFFMAN_EMIT_SYMBOL, 73), (41, HUFFMAN_EMIT_SYMBOL, 73), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 73), (3, HUFFMAN_EMIT_SYMBOL, 74), (6, HUFFMAN_EMIT_SYMBOL, 74), (10, HUFFMAN_EMIT_SYMBOL, 74), (15, HUFFMAN_EMIT_SYMBOL, 74), (24, HUFFMAN_EMIT_SYMBOL, 74), (31, HUFFMAN_EMIT_SYMBOL, 74), (41, HUFFMAN_EMIT_SYMBOL, 74), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 74), # Node 48 (3, HUFFMAN_EMIT_SYMBOL, 75), (6, HUFFMAN_EMIT_SYMBOL, 75), (10, HUFFMAN_EMIT_SYMBOL, 75), (15, HUFFMAN_EMIT_SYMBOL, 75), (24, HUFFMAN_EMIT_SYMBOL, 75), (31, HUFFMAN_EMIT_SYMBOL, 75), (41, HUFFMAN_EMIT_SYMBOL, 75), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 75), (3, HUFFMAN_EMIT_SYMBOL, 76), (6, HUFFMAN_EMIT_SYMBOL, 76), (10, HUFFMAN_EMIT_SYMBOL, 76), (15, HUFFMAN_EMIT_SYMBOL, 76), (24, HUFFMAN_EMIT_SYMBOL, 76), (31, HUFFMAN_EMIT_SYMBOL, 76), (41, HUFFMAN_EMIT_SYMBOL, 76), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 76), # Node 49 (1, HUFFMAN_EMIT_SYMBOL, 77), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 77), (1, HUFFMAN_EMIT_SYMBOL, 78), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 78), (1, HUFFMAN_EMIT_SYMBOL, 79), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 79), (1, HUFFMAN_EMIT_SYMBOL, 80), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 80), (1, HUFFMAN_EMIT_SYMBOL, 81), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 81), (1, HUFFMAN_EMIT_SYMBOL, 82), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 82), (1, HUFFMAN_EMIT_SYMBOL, 83), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 83), (1, HUFFMAN_EMIT_SYMBOL, 84), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 84), # Node 50 (2, HUFFMAN_EMIT_SYMBOL, 77), (9, HUFFMAN_EMIT_SYMBOL, 77), (23, HUFFMAN_EMIT_SYMBOL, 77), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 77), (2, HUFFMAN_EMIT_SYMBOL, 78), (9, HUFFMAN_EMIT_SYMBOL, 78), (23, HUFFMAN_EMIT_SYMBOL, 78), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 78), (2, HUFFMAN_EMIT_SYMBOL, 79), (9, HUFFMAN_EMIT_SYMBOL, 79), (23, HUFFMAN_EMIT_SYMBOL, 79), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 79), (2, HUFFMAN_EMIT_SYMBOL, 80), (9, HUFFMAN_EMIT_SYMBOL, 80), (23, HUFFMAN_EMIT_SYMBOL, 80), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 80), # Node 51 (3, HUFFMAN_EMIT_SYMBOL, 77), (6, HUFFMAN_EMIT_SYMBOL, 77), (10, HUFFMAN_EMIT_SYMBOL, 77), (15, HUFFMAN_EMIT_SYMBOL, 77), (24, HUFFMAN_EMIT_SYMBOL, 77), (31, HUFFMAN_EMIT_SYMBOL, 77), (41, HUFFMAN_EMIT_SYMBOL, 77), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 77), (3, HUFFMAN_EMIT_SYMBOL, 78), (6, HUFFMAN_EMIT_SYMBOL, 78), (10, HUFFMAN_EMIT_SYMBOL, 78), (15, HUFFMAN_EMIT_SYMBOL, 78), (24, HUFFMAN_EMIT_SYMBOL, 78), (31, HUFFMAN_EMIT_SYMBOL, 78), (41, HUFFMAN_EMIT_SYMBOL, 78), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 78), # Node 52 (3, HUFFMAN_EMIT_SYMBOL, 79), (6, HUFFMAN_EMIT_SYMBOL, 79), (10, HUFFMAN_EMIT_SYMBOL, 79), (15, HUFFMAN_EMIT_SYMBOL, 79), (24, HUFFMAN_EMIT_SYMBOL, 79), (31, HUFFMAN_EMIT_SYMBOL, 79), (41, HUFFMAN_EMIT_SYMBOL, 79), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 79), (3, HUFFMAN_EMIT_SYMBOL, 80), (6, HUFFMAN_EMIT_SYMBOL, 80), (10, HUFFMAN_EMIT_SYMBOL, 80), (15, HUFFMAN_EMIT_SYMBOL, 80), (24, HUFFMAN_EMIT_SYMBOL, 80), (31, HUFFMAN_EMIT_SYMBOL, 80), (41, HUFFMAN_EMIT_SYMBOL, 80), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 80), # Node 53 (2, HUFFMAN_EMIT_SYMBOL, 81), (9, HUFFMAN_EMIT_SYMBOL, 81), (23, HUFFMAN_EMIT_SYMBOL, 81), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 81), (2, HUFFMAN_EMIT_SYMBOL, 82), (9, HUFFMAN_EMIT_SYMBOL, 82), (23, HUFFMAN_EMIT_SYMBOL, 82), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 82), (2, HUFFMAN_EMIT_SYMBOL, 83), (9, HUFFMAN_EMIT_SYMBOL, 83), (23, HUFFMAN_EMIT_SYMBOL, 83), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 83), (2, HUFFMAN_EMIT_SYMBOL, 84), (9, HUFFMAN_EMIT_SYMBOL, 84), (23, HUFFMAN_EMIT_SYMBOL, 84), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 84), # Node 54 (3, HUFFMAN_EMIT_SYMBOL, 81), (6, HUFFMAN_EMIT_SYMBOL, 81), (10, HUFFMAN_EMIT_SYMBOL, 81), (15, HUFFMAN_EMIT_SYMBOL, 81), (24, HUFFMAN_EMIT_SYMBOL, 81), (31, HUFFMAN_EMIT_SYMBOL, 81), (41, HUFFMAN_EMIT_SYMBOL, 81), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 81), (3, HUFFMAN_EMIT_SYMBOL, 82), (6, HUFFMAN_EMIT_SYMBOL, 82), (10, HUFFMAN_EMIT_SYMBOL, 82), (15, HUFFMAN_EMIT_SYMBOL, 82), (24, HUFFMAN_EMIT_SYMBOL, 82), (31, HUFFMAN_EMIT_SYMBOL, 82), (41, HUFFMAN_EMIT_SYMBOL, 82), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 82), # Node 55 (3, HUFFMAN_EMIT_SYMBOL, 83), (6, HUFFMAN_EMIT_SYMBOL, 83), (10, HUFFMAN_EMIT_SYMBOL, 83), (15, HUFFMAN_EMIT_SYMBOL, 83), (24, HUFFMAN_EMIT_SYMBOL, 83), (31, HUFFMAN_EMIT_SYMBOL, 83), (41, HUFFMAN_EMIT_SYMBOL, 83), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 83), (3, HUFFMAN_EMIT_SYMBOL, 84), (6, HUFFMAN_EMIT_SYMBOL, 84), (10, HUFFMAN_EMIT_SYMBOL, 84), (15, HUFFMAN_EMIT_SYMBOL, 84), (24, HUFFMAN_EMIT_SYMBOL, 84), (31, HUFFMAN_EMIT_SYMBOL, 84), (41, HUFFMAN_EMIT_SYMBOL, 84), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 84), # Node 56 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 85), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 86), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 87), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 89), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 106), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 107), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 113), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 118), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 119), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 120), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 121), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 122), (70, 0, 0), (71, 0, 0), (73, 0, 0), (74, HUFFMAN_COMPLETE, 0), # Node 57 (1, HUFFMAN_EMIT_SYMBOL, 85), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 85), (1, HUFFMAN_EMIT_SYMBOL, 86), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 86), (1, HUFFMAN_EMIT_SYMBOL, 87), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 87), (1, HUFFMAN_EMIT_SYMBOL, 89), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 89), (1, HUFFMAN_EMIT_SYMBOL, 106), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 106), (1, HUFFMAN_EMIT_SYMBOL, 107), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 107), (1, HUFFMAN_EMIT_SYMBOL, 113), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 113), (1, HUFFMAN_EMIT_SYMBOL, 118), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 118), # Node 58 (2, HUFFMAN_EMIT_SYMBOL, 85), (9, HUFFMAN_EMIT_SYMBOL, 85), (23, HUFFMAN_EMIT_SYMBOL, 85), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 85), (2, HUFFMAN_EMIT_SYMBOL, 86), (9, HUFFMAN_EMIT_SYMBOL, 86), (23, HUFFMAN_EMIT_SYMBOL, 86), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 86), (2, HUFFMAN_EMIT_SYMBOL, 87), (9, HUFFMAN_EMIT_SYMBOL, 87), (23, HUFFMAN_EMIT_SYMBOL, 87), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 87), (2, HUFFMAN_EMIT_SYMBOL, 89), (9, HUFFMAN_EMIT_SYMBOL, 89), (23, HUFFMAN_EMIT_SYMBOL, 89), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 89), # Node 59 (3, HUFFMAN_EMIT_SYMBOL, 85), (6, HUFFMAN_EMIT_SYMBOL, 85), (10, HUFFMAN_EMIT_SYMBOL, 85), (15, HUFFMAN_EMIT_SYMBOL, 85), (24, HUFFMAN_EMIT_SYMBOL, 85), (31, HUFFMAN_EMIT_SYMBOL, 85), (41, HUFFMAN_EMIT_SYMBOL, 85), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 85), (3, HUFFMAN_EMIT_SYMBOL, 86), (6, HUFFMAN_EMIT_SYMBOL, 86), (10, HUFFMAN_EMIT_SYMBOL, 86), (15, HUFFMAN_EMIT_SYMBOL, 86), (24, HUFFMAN_EMIT_SYMBOL, 86), (31, HUFFMAN_EMIT_SYMBOL, 86), (41, HUFFMAN_EMIT_SYMBOL, 86), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 86), # Node 60 (3, HUFFMAN_EMIT_SYMBOL, 87), (6, HUFFMAN_EMIT_SYMBOL, 87), (10, HUFFMAN_EMIT_SYMBOL, 87), (15, HUFFMAN_EMIT_SYMBOL, 87), (24, HUFFMAN_EMIT_SYMBOL, 87), (31, HUFFMAN_EMIT_SYMBOL, 87), (41, HUFFMAN_EMIT_SYMBOL, 87), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 87), (3, HUFFMAN_EMIT_SYMBOL, 89), (6, HUFFMAN_EMIT_SYMBOL, 89), (10, HUFFMAN_EMIT_SYMBOL, 89), (15, HUFFMAN_EMIT_SYMBOL, 89), (24, HUFFMAN_EMIT_SYMBOL, 89), (31, HUFFMAN_EMIT_SYMBOL, 89), (41, HUFFMAN_EMIT_SYMBOL, 89), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 89), # Node 61 (2, HUFFMAN_EMIT_SYMBOL, 106), (9, HUFFMAN_EMIT_SYMBOL, 106), (23, HUFFMAN_EMIT_SYMBOL, 106), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 106), (2, HUFFMAN_EMIT_SYMBOL, 107), (9, HUFFMAN_EMIT_SYMBOL, 107), (23, HUFFMAN_EMIT_SYMBOL, 107), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 107), (2, HUFFMAN_EMIT_SYMBOL, 113), (9, HUFFMAN_EMIT_SYMBOL, 113), (23, HUFFMAN_EMIT_SYMBOL, 113), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 113), (2, HUFFMAN_EMIT_SYMBOL, 118), (9, HUFFMAN_EMIT_SYMBOL, 118), (23, HUFFMAN_EMIT_SYMBOL, 118), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 118), # Node 62 (3, HUFFMAN_EMIT_SYMBOL, 106), (6, HUFFMAN_EMIT_SYMBOL, 106), (10, HUFFMAN_EMIT_SYMBOL, 106), (15, HUFFMAN_EMIT_SYMBOL, 106), (24, HUFFMAN_EMIT_SYMBOL, 106), (31, HUFFMAN_EMIT_SYMBOL, 106), (41, HUFFMAN_EMIT_SYMBOL, 106), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 106), (3, HUFFMAN_EMIT_SYMBOL, 107), (6, HUFFMAN_EMIT_SYMBOL, 107), (10, HUFFMAN_EMIT_SYMBOL, 107), (15, HUFFMAN_EMIT_SYMBOL, 107), (24, HUFFMAN_EMIT_SYMBOL, 107), (31, HUFFMAN_EMIT_SYMBOL, 107), (41, HUFFMAN_EMIT_SYMBOL, 107), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 107), # Node 63 (3, HUFFMAN_EMIT_SYMBOL, 113), (6, HUFFMAN_EMIT_SYMBOL, 113), (10, HUFFMAN_EMIT_SYMBOL, 113), (15, HUFFMAN_EMIT_SYMBOL, 113), (24, HUFFMAN_EMIT_SYMBOL, 113), (31, HUFFMAN_EMIT_SYMBOL, 113), (41, HUFFMAN_EMIT_SYMBOL, 113), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 113), (3, HUFFMAN_EMIT_SYMBOL, 118), (6, HUFFMAN_EMIT_SYMBOL, 118), (10, HUFFMAN_EMIT_SYMBOL, 118), (15, HUFFMAN_EMIT_SYMBOL, 118), (24, HUFFMAN_EMIT_SYMBOL, 118), (31, HUFFMAN_EMIT_SYMBOL, 118), (41, HUFFMAN_EMIT_SYMBOL, 118), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 118), # Node 64 (1, HUFFMAN_EMIT_SYMBOL, 119), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 119), (1, HUFFMAN_EMIT_SYMBOL, 120), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 120), (1, HUFFMAN_EMIT_SYMBOL, 121), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 121), (1, HUFFMAN_EMIT_SYMBOL, 122), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 122), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 38), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 42), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 44), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 59), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 88), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 90), (75, 0, 0), (78, 0, 0), # Node 65 (2, HUFFMAN_EMIT_SYMBOL, 119), (9, HUFFMAN_EMIT_SYMBOL, 119), (23, HUFFMAN_EMIT_SYMBOL, 119), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 119), (2, HUFFMAN_EMIT_SYMBOL, 120), (9, HUFFMAN_EMIT_SYMBOL, 120), (23, HUFFMAN_EMIT_SYMBOL, 120), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 120), (2, HUFFMAN_EMIT_SYMBOL, 121), (9, HUFFMAN_EMIT_SYMBOL, 121), (23, HUFFMAN_EMIT_SYMBOL, 121), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 121), (2, HUFFMAN_EMIT_SYMBOL, 122), (9, HUFFMAN_EMIT_SYMBOL, 122), (23, HUFFMAN_EMIT_SYMBOL, 122), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 122), # Node 66 (3, HUFFMAN_EMIT_SYMBOL, 119), (6, HUFFMAN_EMIT_SYMBOL, 119), (10, HUFFMAN_EMIT_SYMBOL, 119), (15, HUFFMAN_EMIT_SYMBOL, 119), (24, HUFFMAN_EMIT_SYMBOL, 119), (31, HUFFMAN_EMIT_SYMBOL, 119), (41, HUFFMAN_EMIT_SYMBOL, 119), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 119), (3, HUFFMAN_EMIT_SYMBOL, 120), (6, HUFFMAN_EMIT_SYMBOL, 120), (10, HUFFMAN_EMIT_SYMBOL, 120), (15, HUFFMAN_EMIT_SYMBOL, 120), (24, HUFFMAN_EMIT_SYMBOL, 120), (31, HUFFMAN_EMIT_SYMBOL, 120), (41, HUFFMAN_EMIT_SYMBOL, 120), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 120), # Node 67 (3, HUFFMAN_EMIT_SYMBOL, 121), (6, HUFFMAN_EMIT_SYMBOL, 121), (10, HUFFMAN_EMIT_SYMBOL, 121), (15, HUFFMAN_EMIT_SYMBOL, 121), (24, HUFFMAN_EMIT_SYMBOL, 121), (31, HUFFMAN_EMIT_SYMBOL, 121), (41, HUFFMAN_EMIT_SYMBOL, 121), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 121), (3, HUFFMAN_EMIT_SYMBOL, 122), (6, HUFFMAN_EMIT_SYMBOL, 122), (10, HUFFMAN_EMIT_SYMBOL, 122), (15, HUFFMAN_EMIT_SYMBOL, 122), (24, HUFFMAN_EMIT_SYMBOL, 122), (31, HUFFMAN_EMIT_SYMBOL, 122), (41, HUFFMAN_EMIT_SYMBOL, 122), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 122), # Node 68 (1, HUFFMAN_EMIT_SYMBOL, 38), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 38), (1, HUFFMAN_EMIT_SYMBOL, 42), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 42), (1, HUFFMAN_EMIT_SYMBOL, 44), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 44), (1, HUFFMAN_EMIT_SYMBOL, 59), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 59), (1, HUFFMAN_EMIT_SYMBOL, 88), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 88), (1, HUFFMAN_EMIT_SYMBOL, 90), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 90), (76, 0, 0), (77, 0, 0), (79, 0, 0), (81, 0, 0), # Node 69 (2, HUFFMAN_EMIT_SYMBOL, 38), (9, HUFFMAN_EMIT_SYMBOL, 38), (23, HUFFMAN_EMIT_SYMBOL, 38), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 38), (2, HUFFMAN_EMIT_SYMBOL, 42), (9, HUFFMAN_EMIT_SYMBOL, 42), (23, HUFFMAN_EMIT_SYMBOL, 42), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 42), (2, HUFFMAN_EMIT_SYMBOL, 44), (9, HUFFMAN_EMIT_SYMBOL, 44), (23, HUFFMAN_EMIT_SYMBOL, 44), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 44), (2, HUFFMAN_EMIT_SYMBOL, 59), (9, HUFFMAN_EMIT_SYMBOL, 59), (23, HUFFMAN_EMIT_SYMBOL, 59), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 59), # Node 70 (3, HUFFMAN_EMIT_SYMBOL, 38), (6, HUFFMAN_EMIT_SYMBOL, 38), (10, HUFFMAN_EMIT_SYMBOL, 38), (15, HUFFMAN_EMIT_SYMBOL, 38), (24, HUFFMAN_EMIT_SYMBOL, 38), (31, HUFFMAN_EMIT_SYMBOL, 38), (41, HUFFMAN_EMIT_SYMBOL, 38), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 38), (3, HUFFMAN_EMIT_SYMBOL, 42), (6, HUFFMAN_EMIT_SYMBOL, 42), (10, HUFFMAN_EMIT_SYMBOL, 42), (15, HUFFMAN_EMIT_SYMBOL, 42), (24, HUFFMAN_EMIT_SYMBOL, 42), (31, HUFFMAN_EMIT_SYMBOL, 42), (41, HUFFMAN_EMIT_SYMBOL, 42), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 42), # Node 71 (3, HUFFMAN_EMIT_SYMBOL, 44), (6, HUFFMAN_EMIT_SYMBOL, 44), (10, HUFFMAN_EMIT_SYMBOL, 44), (15, HUFFMAN_EMIT_SYMBOL, 44), (24, HUFFMAN_EMIT_SYMBOL, 44), (31, HUFFMAN_EMIT_SYMBOL, 44), (41, HUFFMAN_EMIT_SYMBOL, 44), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 44), (3, HUFFMAN_EMIT_SYMBOL, 59), (6, HUFFMAN_EMIT_SYMBOL, 59), (10, HUFFMAN_EMIT_SYMBOL, 59), (15, HUFFMAN_EMIT_SYMBOL, 59), (24, HUFFMAN_EMIT_SYMBOL, 59), (31, HUFFMAN_EMIT_SYMBOL, 59), (41, HUFFMAN_EMIT_SYMBOL, 59), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 59), # Node 72 (2, HUFFMAN_EMIT_SYMBOL, 88), (9, HUFFMAN_EMIT_SYMBOL, 88), (23, HUFFMAN_EMIT_SYMBOL, 88), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 88), (2, HUFFMAN_EMIT_SYMBOL, 90), (9, HUFFMAN_EMIT_SYMBOL, 90), (23, HUFFMAN_EMIT_SYMBOL, 90), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 90), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 33), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 34), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 40), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 41), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 63), (80, 0, 0), (82, 0, 0), (84, 0, 0), # Node 73 (3, HUFFMAN_EMIT_SYMBOL, 88), (6, HUFFMAN_EMIT_SYMBOL, 88), (10, HUFFMAN_EMIT_SYMBOL, 88), (15, HUFFMAN_EMIT_SYMBOL, 88), (24, HUFFMAN_EMIT_SYMBOL, 88), (31, HUFFMAN_EMIT_SYMBOL, 88), (41, HUFFMAN_EMIT_SYMBOL, 88), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 88), (3, HUFFMAN_EMIT_SYMBOL, 90), (6, HUFFMAN_EMIT_SYMBOL, 90), (10, HUFFMAN_EMIT_SYMBOL, 90), (15, HUFFMAN_EMIT_SYMBOL, 90), (24, HUFFMAN_EMIT_SYMBOL, 90), (31, HUFFMAN_EMIT_SYMBOL, 90), (41, HUFFMAN_EMIT_SYMBOL, 90), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 90), # Node 74 (1, HUFFMAN_EMIT_SYMBOL, 33), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 33), (1, HUFFMAN_EMIT_SYMBOL, 34), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 34), (1, HUFFMAN_EMIT_SYMBOL, 40), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 40), (1, HUFFMAN_EMIT_SYMBOL, 41), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 41), (1, HUFFMAN_EMIT_SYMBOL, 63), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 63), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 39), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 43), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 124), (83, 0, 0), (85, 0, 0), (88, 0, 0), # Node 75 (2, HUFFMAN_EMIT_SYMBOL, 33), (9, HUFFMAN_EMIT_SYMBOL, 33), (23, HUFFMAN_EMIT_SYMBOL, 33), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 33), (2, HUFFMAN_EMIT_SYMBOL, 34), (9, HUFFMAN_EMIT_SYMBOL, 34), (23, HUFFMAN_EMIT_SYMBOL, 34), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 34), (2, HUFFMAN_EMIT_SYMBOL, 40), (9, HUFFMAN_EMIT_SYMBOL, 40), (23, HUFFMAN_EMIT_SYMBOL, 40), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 40), (2, HUFFMAN_EMIT_SYMBOL, 41), (9, HUFFMAN_EMIT_SYMBOL, 41), (23, HUFFMAN_EMIT_SYMBOL, 41), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 41), # Node 76 (3, HUFFMAN_EMIT_SYMBOL, 33), (6, HUFFMAN_EMIT_SYMBOL, 33), (10, HUFFMAN_EMIT_SYMBOL, 33), (15, HUFFMAN_EMIT_SYMBOL, 33), (24, HUFFMAN_EMIT_SYMBOL, 33), (31, HUFFMAN_EMIT_SYMBOL, 33), (41, HUFFMAN_EMIT_SYMBOL, 33), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 33), (3, HUFFMAN_EMIT_SYMBOL, 34), (6, HUFFMAN_EMIT_SYMBOL, 34), (10, HUFFMAN_EMIT_SYMBOL, 34), (15, HUFFMAN_EMIT_SYMBOL, 34), (24, HUFFMAN_EMIT_SYMBOL, 34), (31, HUFFMAN_EMIT_SYMBOL, 34), (41, HUFFMAN_EMIT_SYMBOL, 34), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 34), # Node 77 (3, HUFFMAN_EMIT_SYMBOL, 40), (6, HUFFMAN_EMIT_SYMBOL, 40), (10, HUFFMAN_EMIT_SYMBOL, 40), (15, HUFFMAN_EMIT_SYMBOL, 40), (24, HUFFMAN_EMIT_SYMBOL, 40), (31, HUFFMAN_EMIT_SYMBOL, 40), (41, HUFFMAN_EMIT_SYMBOL, 40), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 40), (3, HUFFMAN_EMIT_SYMBOL, 41), (6, HUFFMAN_EMIT_SYMBOL, 41), (10, HUFFMAN_EMIT_SYMBOL, 41), (15, HUFFMAN_EMIT_SYMBOL, 41), (24, HUFFMAN_EMIT_SYMBOL, 41), (31, HUFFMAN_EMIT_SYMBOL, 41), (41, HUFFMAN_EMIT_SYMBOL, 41), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 41), # Node 78 (2, HUFFMAN_EMIT_SYMBOL, 63), (9, HUFFMAN_EMIT_SYMBOL, 63), (23, HUFFMAN_EMIT_SYMBOL, 63), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 63), (1, HUFFMAN_EMIT_SYMBOL, 39), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 39), (1, HUFFMAN_EMIT_SYMBOL, 43), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 43), (1, HUFFMAN_EMIT_SYMBOL, 124), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 124), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 35), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 62), (86, 0, 0), (87, 0, 0), (89, 0, 0), (90, 0, 0), # Node 79 (3, HUFFMAN_EMIT_SYMBOL, 63), (6, HUFFMAN_EMIT_SYMBOL, 63), (10, HUFFMAN_EMIT_SYMBOL, 63), (15, HUFFMAN_EMIT_SYMBOL, 63), (24, HUFFMAN_EMIT_SYMBOL, 63), (31, HUFFMAN_EMIT_SYMBOL, 63), (41, HUFFMAN_EMIT_SYMBOL, 63), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 63), (2, HUFFMAN_EMIT_SYMBOL, 39), (9, HUFFMAN_EMIT_SYMBOL, 39), (23, HUFFMAN_EMIT_SYMBOL, 39), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 39), (2, HUFFMAN_EMIT_SYMBOL, 43), (9, HUFFMAN_EMIT_SYMBOL, 43), (23, HUFFMAN_EMIT_SYMBOL, 43), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 43), # Node 80 (3, HUFFMAN_EMIT_SYMBOL, 39), (6, HUFFMAN_EMIT_SYMBOL, 39), (10, HUFFMAN_EMIT_SYMBOL, 39), (15, HUFFMAN_EMIT_SYMBOL, 39), (24, HUFFMAN_EMIT_SYMBOL, 39), (31, HUFFMAN_EMIT_SYMBOL, 39), (41, HUFFMAN_EMIT_SYMBOL, 39), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 39), (3, HUFFMAN_EMIT_SYMBOL, 43), (6, HUFFMAN_EMIT_SYMBOL, 43), (10, HUFFMAN_EMIT_SYMBOL, 43), (15, HUFFMAN_EMIT_SYMBOL, 43), (24, HUFFMAN_EMIT_SYMBOL, 43), (31, HUFFMAN_EMIT_SYMBOL, 43), (41, HUFFMAN_EMIT_SYMBOL, 43), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 43), # Node 81 (2, HUFFMAN_EMIT_SYMBOL, 124), (9, HUFFMAN_EMIT_SYMBOL, 124), (23, HUFFMAN_EMIT_SYMBOL, 124), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 124), (1, HUFFMAN_EMIT_SYMBOL, 35), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 35), (1, HUFFMAN_EMIT_SYMBOL, 62), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 62), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 0), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 36), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 64), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 91), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 93), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 126), (91, 0, 0), (92, 0, 0), # Node 82 (3, HUFFMAN_EMIT_SYMBOL, 124), (6, HUFFMAN_EMIT_SYMBOL, 124), (10, HUFFMAN_EMIT_SYMBOL, 124), (15, HUFFMAN_EMIT_SYMBOL, 124), (24, HUFFMAN_EMIT_SYMBOL, 124), (31, HUFFMAN_EMIT_SYMBOL, 124), (41, HUFFMAN_EMIT_SYMBOL, 124), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 124), (2, HUFFMAN_EMIT_SYMBOL, 35), (9, HUFFMAN_EMIT_SYMBOL, 35), (23, HUFFMAN_EMIT_SYMBOL, 35), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 35), (2, HUFFMAN_EMIT_SYMBOL, 62), (9, HUFFMAN_EMIT_SYMBOL, 62), (23, HUFFMAN_EMIT_SYMBOL, 62), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 62), # Node 83 (3, HUFFMAN_EMIT_SYMBOL, 35), (6, HUFFMAN_EMIT_SYMBOL, 35), (10, HUFFMAN_EMIT_SYMBOL, 35), (15, HUFFMAN_EMIT_SYMBOL, 35), (24, HUFFMAN_EMIT_SYMBOL, 35), (31, HUFFMAN_EMIT_SYMBOL, 35), (41, HUFFMAN_EMIT_SYMBOL, 35), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 35), (3, HUFFMAN_EMIT_SYMBOL, 62), (6, HUFFMAN_EMIT_SYMBOL, 62), (10, HUFFMAN_EMIT_SYMBOL, 62), (15, HUFFMAN_EMIT_SYMBOL, 62), (24, HUFFMAN_EMIT_SYMBOL, 62), (31, HUFFMAN_EMIT_SYMBOL, 62), (41, HUFFMAN_EMIT_SYMBOL, 62), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 62), # Node 84 (1, HUFFMAN_EMIT_SYMBOL, 0), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 0), (1, HUFFMAN_EMIT_SYMBOL, 36), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 36), (1, HUFFMAN_EMIT_SYMBOL, 64), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 64), (1, HUFFMAN_EMIT_SYMBOL, 91), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 91), (1, HUFFMAN_EMIT_SYMBOL, 93), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 93), (1, HUFFMAN_EMIT_SYMBOL, 126), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 126), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 94), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 125), (93, 0, 0), (94, 0, 0), # Node 85 (2, HUFFMAN_EMIT_SYMBOL, 0), (9, HUFFMAN_EMIT_SYMBOL, 0), (23, HUFFMAN_EMIT_SYMBOL, 0), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 0), (2, HUFFMAN_EMIT_SYMBOL, 36), (9, HUFFMAN_EMIT_SYMBOL, 36), (23, HUFFMAN_EMIT_SYMBOL, 36), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 36), (2, HUFFMAN_EMIT_SYMBOL, 64), (9, HUFFMAN_EMIT_SYMBOL, 64), (23, HUFFMAN_EMIT_SYMBOL, 64), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 64), (2, HUFFMAN_EMIT_SYMBOL, 91), (9, HUFFMAN_EMIT_SYMBOL, 91), (23, HUFFMAN_EMIT_SYMBOL, 91), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 91), # Node 86 (3, HUFFMAN_EMIT_SYMBOL, 0), (6, HUFFMAN_EMIT_SYMBOL, 0), (10, HUFFMAN_EMIT_SYMBOL, 0), (15, HUFFMAN_EMIT_SYMBOL, 0), (24, HUFFMAN_EMIT_SYMBOL, 0), (31, HUFFMAN_EMIT_SYMBOL, 0), (41, HUFFMAN_EMIT_SYMBOL, 0), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 0), (3, HUFFMAN_EMIT_SYMBOL, 36), (6, HUFFMAN_EMIT_SYMBOL, 36), (10, HUFFMAN_EMIT_SYMBOL, 36), (15, HUFFMAN_EMIT_SYMBOL, 36), (24, HUFFMAN_EMIT_SYMBOL, 36), (31, HUFFMAN_EMIT_SYMBOL, 36), (41, HUFFMAN_EMIT_SYMBOL, 36), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 36), # Node 87 (3, HUFFMAN_EMIT_SYMBOL, 64), (6, HUFFMAN_EMIT_SYMBOL, 64), (10, HUFFMAN_EMIT_SYMBOL, 64), (15, HUFFMAN_EMIT_SYMBOL, 64), (24, HUFFMAN_EMIT_SYMBOL, 64), (31, HUFFMAN_EMIT_SYMBOL, 64), (41, HUFFMAN_EMIT_SYMBOL, 64), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 64), (3, HUFFMAN_EMIT_SYMBOL, 91), (6, HUFFMAN_EMIT_SYMBOL, 91), (10, HUFFMAN_EMIT_SYMBOL, 91), (15, HUFFMAN_EMIT_SYMBOL, 91), (24, HUFFMAN_EMIT_SYMBOL, 91), (31, HUFFMAN_EMIT_SYMBOL, 91), (41, HUFFMAN_EMIT_SYMBOL, 91), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 91), # Node 88 (2, HUFFMAN_EMIT_SYMBOL, 93), (9, HUFFMAN_EMIT_SYMBOL, 93), (23, HUFFMAN_EMIT_SYMBOL, 93), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 93), (2, HUFFMAN_EMIT_SYMBOL, 126), (9, HUFFMAN_EMIT_SYMBOL, 126), (23, HUFFMAN_EMIT_SYMBOL, 126), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 126), (1, HUFFMAN_EMIT_SYMBOL, 94), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 94), (1, HUFFMAN_EMIT_SYMBOL, 125), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 125), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 60), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 96), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 123), (95, 0, 0), # Node 89 (3, HUFFMAN_EMIT_SYMBOL, 93), (6, HUFFMAN_EMIT_SYMBOL, 93), (10, HUFFMAN_EMIT_SYMBOL, 93), (15, HUFFMAN_EMIT_SYMBOL, 93), (24, HUFFMAN_EMIT_SYMBOL, 93), (31, HUFFMAN_EMIT_SYMBOL, 93), (41, HUFFMAN_EMIT_SYMBOL, 93), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 93), (3, HUFFMAN_EMIT_SYMBOL, 126), (6, HUFFMAN_EMIT_SYMBOL, 126), (10, HUFFMAN_EMIT_SYMBOL, 126), (15, HUFFMAN_EMIT_SYMBOL, 126), (24, HUFFMAN_EMIT_SYMBOL, 126), (31, HUFFMAN_EMIT_SYMBOL, 126), (41, HUFFMAN_EMIT_SYMBOL, 126), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 126), # Node 90 (2, HUFFMAN_EMIT_SYMBOL, 94), (9, HUFFMAN_EMIT_SYMBOL, 94), (23, HUFFMAN_EMIT_SYMBOL, 94), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 94), (2, HUFFMAN_EMIT_SYMBOL, 125), (9, HUFFMAN_EMIT_SYMBOL, 125), (23, HUFFMAN_EMIT_SYMBOL, 125), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 125), (1, HUFFMAN_EMIT_SYMBOL, 60), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 60), (1, HUFFMAN_EMIT_SYMBOL, 96), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 96), (1, HUFFMAN_EMIT_SYMBOL, 123), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 123), (96, 0, 0), (110, 0, 0), # Node 91 (3, HUFFMAN_EMIT_SYMBOL, 94), (6, HUFFMAN_EMIT_SYMBOL, 94), (10, HUFFMAN_EMIT_SYMBOL, 94), (15, HUFFMAN_EMIT_SYMBOL, 94), (24, HUFFMAN_EMIT_SYMBOL, 94), (31, HUFFMAN_EMIT_SYMBOL, 94), (41, HUFFMAN_EMIT_SYMBOL, 94), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 94), (3, HUFFMAN_EMIT_SYMBOL, 125), (6, HUFFMAN_EMIT_SYMBOL, 125), (10, HUFFMAN_EMIT_SYMBOL, 125), (15, HUFFMAN_EMIT_SYMBOL, 125), (24, HUFFMAN_EMIT_SYMBOL, 125), (31, HUFFMAN_EMIT_SYMBOL, 125), (41, HUFFMAN_EMIT_SYMBOL, 125), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 125), # Node 92 (2, HUFFMAN_EMIT_SYMBOL, 60), (9, HUFFMAN_EMIT_SYMBOL, 60), (23, HUFFMAN_EMIT_SYMBOL, 60), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 60), (2, HUFFMAN_EMIT_SYMBOL, 96), (9, HUFFMAN_EMIT_SYMBOL, 96), (23, HUFFMAN_EMIT_SYMBOL, 96), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 96), (2, HUFFMAN_EMIT_SYMBOL, 123), (9, HUFFMAN_EMIT_SYMBOL, 123), (23, HUFFMAN_EMIT_SYMBOL, 123), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 123), (97, 0, 0), (101, 0, 0), (111, 0, 0), (133, 0, 0), # Node 93 (3, HUFFMAN_EMIT_SYMBOL, 60), (6, HUFFMAN_EMIT_SYMBOL, 60), (10, HUFFMAN_EMIT_SYMBOL, 60), (15, HUFFMAN_EMIT_SYMBOL, 60), (24, HUFFMAN_EMIT_SYMBOL, 60), (31, HUFFMAN_EMIT_SYMBOL, 60), (41, HUFFMAN_EMIT_SYMBOL, 60), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 60), (3, HUFFMAN_EMIT_SYMBOL, 96), (6, HUFFMAN_EMIT_SYMBOL, 96), (10, HUFFMAN_EMIT_SYMBOL, 96), (15, HUFFMAN_EMIT_SYMBOL, 96), (24, HUFFMAN_EMIT_SYMBOL, 96), (31, HUFFMAN_EMIT_SYMBOL, 96), (41, HUFFMAN_EMIT_SYMBOL, 96), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 96), # Node 94 (3, HUFFMAN_EMIT_SYMBOL, 123), (6, HUFFMAN_EMIT_SYMBOL, 123), (10, HUFFMAN_EMIT_SYMBOL, 123), (15, HUFFMAN_EMIT_SYMBOL, 123), (24, HUFFMAN_EMIT_SYMBOL, 123), (31, HUFFMAN_EMIT_SYMBOL, 123), (41, HUFFMAN_EMIT_SYMBOL, 123), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 123), (98, 0, 0), (99, 0, 0), (102, 0, 0), (105, 0, 0), (112, 0, 0), (119, 0, 0), (134, 0, 0), (153, 0, 0), # Node 95 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 92), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 195), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 208), (100, 0, 0), (103, 0, 0), (104, 0, 0), (106, 0, 0), (107, 0, 0), (113, 0, 0), (116, 0, 0), (120, 0, 0), (126, 0, 0), (135, 0, 0), (142, 0, 0), (154, 0, 0), (169, 0, 0), # Node 96 (1, HUFFMAN_EMIT_SYMBOL, 92), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 92), (1, HUFFMAN_EMIT_SYMBOL, 195), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 195), (1, HUFFMAN_EMIT_SYMBOL, 208), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 208), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 128), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 130), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 131), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 162), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 184), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 194), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 224), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 226), (108, 0, 0), (109, 0, 0), # Node 97 (2, HUFFMAN_EMIT_SYMBOL, 92), (9, HUFFMAN_EMIT_SYMBOL, 92), (23, HUFFMAN_EMIT_SYMBOL, 92), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 92), (2, HUFFMAN_EMIT_SYMBOL, 195), (9, HUFFMAN_EMIT_SYMBOL, 195), (23, HUFFMAN_EMIT_SYMBOL, 195), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 195), (2, HUFFMAN_EMIT_SYMBOL, 208), (9, HUFFMAN_EMIT_SYMBOL, 208), (23, HUFFMAN_EMIT_SYMBOL, 208), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 208), (1, HUFFMAN_EMIT_SYMBOL, 128), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 128), (1, HUFFMAN_EMIT_SYMBOL, 130), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 130), # Node 98 (3, HUFFMAN_EMIT_SYMBOL, 92), (6, HUFFMAN_EMIT_SYMBOL, 92), (10, HUFFMAN_EMIT_SYMBOL, 92), (15, HUFFMAN_EMIT_SYMBOL, 92), (24, HUFFMAN_EMIT_SYMBOL, 92), (31, HUFFMAN_EMIT_SYMBOL, 92), (41, HUFFMAN_EMIT_SYMBOL, 92), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 92), (3, HUFFMAN_EMIT_SYMBOL, 195), (6, HUFFMAN_EMIT_SYMBOL, 195), (10, HUFFMAN_EMIT_SYMBOL, 195), (15, HUFFMAN_EMIT_SYMBOL, 195), (24, HUFFMAN_EMIT_SYMBOL, 195), (31, HUFFMAN_EMIT_SYMBOL, 195), (41, HUFFMAN_EMIT_SYMBOL, 195), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 195), # Node 99 (3, HUFFMAN_EMIT_SYMBOL, 208), (6, HUFFMAN_EMIT_SYMBOL, 208), (10, HUFFMAN_EMIT_SYMBOL, 208), (15, HUFFMAN_EMIT_SYMBOL, 208), (24, HUFFMAN_EMIT_SYMBOL, 208), (31, HUFFMAN_EMIT_SYMBOL, 208), (41, HUFFMAN_EMIT_SYMBOL, 208), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 208), (2, HUFFMAN_EMIT_SYMBOL, 128), (9, HUFFMAN_EMIT_SYMBOL, 128), (23, HUFFMAN_EMIT_SYMBOL, 128), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 128), (2, HUFFMAN_EMIT_SYMBOL, 130), (9, HUFFMAN_EMIT_SYMBOL, 130), (23, HUFFMAN_EMIT_SYMBOL, 130), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 130), # Node 100 (3, HUFFMAN_EMIT_SYMBOL, 128), (6, HUFFMAN_EMIT_SYMBOL, 128), (10, HUFFMAN_EMIT_SYMBOL, 128), (15, HUFFMAN_EMIT_SYMBOL, 128), (24, HUFFMAN_EMIT_SYMBOL, 128), (31, HUFFMAN_EMIT_SYMBOL, 128), (41, HUFFMAN_EMIT_SYMBOL, 128), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 128), (3, HUFFMAN_EMIT_SYMBOL, 130), (6, HUFFMAN_EMIT_SYMBOL, 130), (10, HUFFMAN_EMIT_SYMBOL, 130), (15, HUFFMAN_EMIT_SYMBOL, 130), (24, HUFFMAN_EMIT_SYMBOL, 130), (31, HUFFMAN_EMIT_SYMBOL, 130), (41, HUFFMAN_EMIT_SYMBOL, 130), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 130), # Node 101 (1, HUFFMAN_EMIT_SYMBOL, 131), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 131), (1, HUFFMAN_EMIT_SYMBOL, 162), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 162), (1, HUFFMAN_EMIT_SYMBOL, 184), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 184), (1, HUFFMAN_EMIT_SYMBOL, 194), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 194), (1, HUFFMAN_EMIT_SYMBOL, 224), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 224), (1, HUFFMAN_EMIT_SYMBOL, 226), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 226), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 153), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 161), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 167), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 172), # Node 102 (2, HUFFMAN_EMIT_SYMBOL, 131), (9, HUFFMAN_EMIT_SYMBOL, 131), (23, HUFFMAN_EMIT_SYMBOL, 131), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 131), (2, HUFFMAN_EMIT_SYMBOL, 162), (9, HUFFMAN_EMIT_SYMBOL, 162), (23, HUFFMAN_EMIT_SYMBOL, 162), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 162), (2, HUFFMAN_EMIT_SYMBOL, 184), (9, HUFFMAN_EMIT_SYMBOL, 184), (23, HUFFMAN_EMIT_SYMBOL, 184), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 184), (2, HUFFMAN_EMIT_SYMBOL, 194), (9, HUFFMAN_EMIT_SYMBOL, 194), (23, HUFFMAN_EMIT_SYMBOL, 194), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 194), # Node 103 (3, HUFFMAN_EMIT_SYMBOL, 131), (6, HUFFMAN_EMIT_SYMBOL, 131), (10, HUFFMAN_EMIT_SYMBOL, 131), (15, HUFFMAN_EMIT_SYMBOL, 131), (24, HUFFMAN_EMIT_SYMBOL, 131), (31, HUFFMAN_EMIT_SYMBOL, 131), (41, HUFFMAN_EMIT_SYMBOL, 131), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 131), (3, HUFFMAN_EMIT_SYMBOL, 162), (6, HUFFMAN_EMIT_SYMBOL, 162), (10, HUFFMAN_EMIT_SYMBOL, 162), (15, HUFFMAN_EMIT_SYMBOL, 162), (24, HUFFMAN_EMIT_SYMBOL, 162), (31, HUFFMAN_EMIT_SYMBOL, 162), (41, HUFFMAN_EMIT_SYMBOL, 162), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 162), # Node 104 (3, HUFFMAN_EMIT_SYMBOL, 184), (6, HUFFMAN_EMIT_SYMBOL, 184), (10, HUFFMAN_EMIT_SYMBOL, 184), (15, HUFFMAN_EMIT_SYMBOL, 184), (24, HUFFMAN_EMIT_SYMBOL, 184), (31, HUFFMAN_EMIT_SYMBOL, 184), (41, HUFFMAN_EMIT_SYMBOL, 184), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 184), (3, HUFFMAN_EMIT_SYMBOL, 194), (6, HUFFMAN_EMIT_SYMBOL, 194), (10, HUFFMAN_EMIT_SYMBOL, 194), (15, HUFFMAN_EMIT_SYMBOL, 194), (24, HUFFMAN_EMIT_SYMBOL, 194), (31, HUFFMAN_EMIT_SYMBOL, 194), (41, HUFFMAN_EMIT_SYMBOL, 194), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 194), # Node 105 (2, HUFFMAN_EMIT_SYMBOL, 224), (9, HUFFMAN_EMIT_SYMBOL, 224), (23, HUFFMAN_EMIT_SYMBOL, 224), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 224), (2, HUFFMAN_EMIT_SYMBOL, 226), (9, HUFFMAN_EMIT_SYMBOL, 226), (23, HUFFMAN_EMIT_SYMBOL, 226), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 226), (1, HUFFMAN_EMIT_SYMBOL, 153), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 153), (1, HUFFMAN_EMIT_SYMBOL, 161), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 161), (1, HUFFMAN_EMIT_SYMBOL, 167), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 167), (1, HUFFMAN_EMIT_SYMBOL, 172), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 172), # Node 106 (3, HUFFMAN_EMIT_SYMBOL, 224), (6, HUFFMAN_EMIT_SYMBOL, 224), (10, HUFFMAN_EMIT_SYMBOL, 224), (15, HUFFMAN_EMIT_SYMBOL, 224), (24, HUFFMAN_EMIT_SYMBOL, 224), (31, HUFFMAN_EMIT_SYMBOL, 224), (41, HUFFMAN_EMIT_SYMBOL, 224), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 224), (3, HUFFMAN_EMIT_SYMBOL, 226), (6, HUFFMAN_EMIT_SYMBOL, 226), (10, HUFFMAN_EMIT_SYMBOL, 226), (15, HUFFMAN_EMIT_SYMBOL, 226), (24, HUFFMAN_EMIT_SYMBOL, 226), (31, HUFFMAN_EMIT_SYMBOL, 226), (41, HUFFMAN_EMIT_SYMBOL, 226), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 226), # Node 107 (2, HUFFMAN_EMIT_SYMBOL, 153), (9, HUFFMAN_EMIT_SYMBOL, 153), (23, HUFFMAN_EMIT_SYMBOL, 153), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 153), (2, HUFFMAN_EMIT_SYMBOL, 161), (9, HUFFMAN_EMIT_SYMBOL, 161), (23, HUFFMAN_EMIT_SYMBOL, 161), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 161), (2, HUFFMAN_EMIT_SYMBOL, 167), (9, HUFFMAN_EMIT_SYMBOL, 167), (23, HUFFMAN_EMIT_SYMBOL, 167), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 167), (2, HUFFMAN_EMIT_SYMBOL, 172), (9, HUFFMAN_EMIT_SYMBOL, 172), (23, HUFFMAN_EMIT_SYMBOL, 172), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 172), # Node 108 (3, HUFFMAN_EMIT_SYMBOL, 153), (6, HUFFMAN_EMIT_SYMBOL, 153), (10, HUFFMAN_EMIT_SYMBOL, 153), (15, HUFFMAN_EMIT_SYMBOL, 153), (24, HUFFMAN_EMIT_SYMBOL, 153), (31, HUFFMAN_EMIT_SYMBOL, 153), (41, HUFFMAN_EMIT_SYMBOL, 153), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 153), (3, HUFFMAN_EMIT_SYMBOL, 161), (6, HUFFMAN_EMIT_SYMBOL, 161), (10, HUFFMAN_EMIT_SYMBOL, 161), (15, HUFFMAN_EMIT_SYMBOL, 161), (24, HUFFMAN_EMIT_SYMBOL, 161), (31, HUFFMAN_EMIT_SYMBOL, 161), (41, HUFFMAN_EMIT_SYMBOL, 161), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 161), # Node 109 (3, HUFFMAN_EMIT_SYMBOL, 167), (6, HUFFMAN_EMIT_SYMBOL, 167), (10, HUFFMAN_EMIT_SYMBOL, 167), (15, HUFFMAN_EMIT_SYMBOL, 167), (24, HUFFMAN_EMIT_SYMBOL, 167), (31, HUFFMAN_EMIT_SYMBOL, 167), (41, HUFFMAN_EMIT_SYMBOL, 167), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 167), (3, HUFFMAN_EMIT_SYMBOL, 172), (6, HUFFMAN_EMIT_SYMBOL, 172), (10, HUFFMAN_EMIT_SYMBOL, 172), (15, HUFFMAN_EMIT_SYMBOL, 172), (24, HUFFMAN_EMIT_SYMBOL, 172), (31, HUFFMAN_EMIT_SYMBOL, 172), (41, HUFFMAN_EMIT_SYMBOL, 172), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 172), # Node 110 (114, 0, 0), (115, 0, 0), (117, 0, 0), (118, 0, 0), (121, 0, 0), (123, 0, 0), (127, 0, 0), (130, 0, 0), (136, 0, 0), (139, 0, 0), (143, 0, 0), (146, 0, 0), (155, 0, 0), (162, 0, 0), (170, 0, 0), (180, 0, 0), # Node 111 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 176), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 177), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 179), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 209), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 216), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 217), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 227), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 229), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 230), (122, 0, 0), (124, 0, 0), (125, 0, 0), (128, 0, 0), (129, 0, 0), (131, 0, 0), (132, 0, 0), # Node 112 (1, HUFFMAN_EMIT_SYMBOL, 176), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 176), (1, HUFFMAN_EMIT_SYMBOL, 177), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 177), (1, HUFFMAN_EMIT_SYMBOL, 179), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 179), (1, HUFFMAN_EMIT_SYMBOL, 209), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 209), (1, HUFFMAN_EMIT_SYMBOL, 216), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 216), (1, HUFFMAN_EMIT_SYMBOL, 217), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 217), (1, HUFFMAN_EMIT_SYMBOL, 227), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 227), (1, HUFFMAN_EMIT_SYMBOL, 229), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 229), # Node 113 (2, HUFFMAN_EMIT_SYMBOL, 176), (9, HUFFMAN_EMIT_SYMBOL, 176), (23, HUFFMAN_EMIT_SYMBOL, 176), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 176), (2, HUFFMAN_EMIT_SYMBOL, 177), (9, HUFFMAN_EMIT_SYMBOL, 177), (23, HUFFMAN_EMIT_SYMBOL, 177), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 177), (2, HUFFMAN_EMIT_SYMBOL, 179), (9, HUFFMAN_EMIT_SYMBOL, 179), (23, HUFFMAN_EMIT_SYMBOL, 179), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 179), (2, HUFFMAN_EMIT_SYMBOL, 209), (9, HUFFMAN_EMIT_SYMBOL, 209), (23, HUFFMAN_EMIT_SYMBOL, 209), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 209), # Node 114 (3, HUFFMAN_EMIT_SYMBOL, 176), (6, HUFFMAN_EMIT_SYMBOL, 176), (10, HUFFMAN_EMIT_SYMBOL, 176), (15, HUFFMAN_EMIT_SYMBOL, 176), (24, HUFFMAN_EMIT_SYMBOL, 176), (31, HUFFMAN_EMIT_SYMBOL, 176), (41, HUFFMAN_EMIT_SYMBOL, 176), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 176), (3, HUFFMAN_EMIT_SYMBOL, 177), (6, HUFFMAN_EMIT_SYMBOL, 177), (10, HUFFMAN_EMIT_SYMBOL, 177), (15, HUFFMAN_EMIT_SYMBOL, 177), (24, HUFFMAN_EMIT_SYMBOL, 177), (31, HUFFMAN_EMIT_SYMBOL, 177), (41, HUFFMAN_EMIT_SYMBOL, 177), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 177), # Node 115 (3, HUFFMAN_EMIT_SYMBOL, 179), (6, HUFFMAN_EMIT_SYMBOL, 179), (10, HUFFMAN_EMIT_SYMBOL, 179), (15, HUFFMAN_EMIT_SYMBOL, 179), (24, HUFFMAN_EMIT_SYMBOL, 179), (31, HUFFMAN_EMIT_SYMBOL, 179), (41, HUFFMAN_EMIT_SYMBOL, 179), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 179), (3, HUFFMAN_EMIT_SYMBOL, 209), (6, HUFFMAN_EMIT_SYMBOL, 209), (10, HUFFMAN_EMIT_SYMBOL, 209), (15, HUFFMAN_EMIT_SYMBOL, 209), (24, HUFFMAN_EMIT_SYMBOL, 209), (31, HUFFMAN_EMIT_SYMBOL, 209), (41, HUFFMAN_EMIT_SYMBOL, 209), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 209), # Node 116 (2, HUFFMAN_EMIT_SYMBOL, 216), (9, HUFFMAN_EMIT_SYMBOL, 216), (23, HUFFMAN_EMIT_SYMBOL, 216), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 216), (2, HUFFMAN_EMIT_SYMBOL, 217), (9, HUFFMAN_EMIT_SYMBOL, 217), (23, HUFFMAN_EMIT_SYMBOL, 217), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 217), (2, HUFFMAN_EMIT_SYMBOL, 227), (9, HUFFMAN_EMIT_SYMBOL, 227), (23, HUFFMAN_EMIT_SYMBOL, 227), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 227), (2, HUFFMAN_EMIT_SYMBOL, 229), (9, HUFFMAN_EMIT_SYMBOL, 229), (23, HUFFMAN_EMIT_SYMBOL, 229), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 229), # Node 117 (3, HUFFMAN_EMIT_SYMBOL, 216), (6, HUFFMAN_EMIT_SYMBOL, 216), (10, HUFFMAN_EMIT_SYMBOL, 216), (15, HUFFMAN_EMIT_SYMBOL, 216), (24, HUFFMAN_EMIT_SYMBOL, 216), (31, HUFFMAN_EMIT_SYMBOL, 216), (41, HUFFMAN_EMIT_SYMBOL, 216), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 216), (3, HUFFMAN_EMIT_SYMBOL, 217), (6, HUFFMAN_EMIT_SYMBOL, 217), (10, HUFFMAN_EMIT_SYMBOL, 217), (15, HUFFMAN_EMIT_SYMBOL, 217), (24, HUFFMAN_EMIT_SYMBOL, 217), (31, HUFFMAN_EMIT_SYMBOL, 217), (41, HUFFMAN_EMIT_SYMBOL, 217), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 217), # Node 118 (3, HUFFMAN_EMIT_SYMBOL, 227), (6, HUFFMAN_EMIT_SYMBOL, 227), (10, HUFFMAN_EMIT_SYMBOL, 227), (15, HUFFMAN_EMIT_SYMBOL, 227), (24, HUFFMAN_EMIT_SYMBOL, 227), (31, HUFFMAN_EMIT_SYMBOL, 227), (41, HUFFMAN_EMIT_SYMBOL, 227), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 227), (3, HUFFMAN_EMIT_SYMBOL, 229), (6, HUFFMAN_EMIT_SYMBOL, 229), (10, HUFFMAN_EMIT_SYMBOL, 229), (15, HUFFMAN_EMIT_SYMBOL, 229), (24, HUFFMAN_EMIT_SYMBOL, 229), (31, HUFFMAN_EMIT_SYMBOL, 229), (41, HUFFMAN_EMIT_SYMBOL, 229), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 229), # Node 119 (1, HUFFMAN_EMIT_SYMBOL, 230), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 230), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 129), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 132), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 133), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 134), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 136), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 146), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 154), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 156), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 160), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 163), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 164), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 169), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 170), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 173), # Node 120 (2, HUFFMAN_EMIT_SYMBOL, 230), (9, HUFFMAN_EMIT_SYMBOL, 230), (23, HUFFMAN_EMIT_SYMBOL, 230), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 230), (1, HUFFMAN_EMIT_SYMBOL, 129), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 129), (1, HUFFMAN_EMIT_SYMBOL, 132), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 132), (1, HUFFMAN_EMIT_SYMBOL, 133), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 133), (1, HUFFMAN_EMIT_SYMBOL, 134), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 134), (1, HUFFMAN_EMIT_SYMBOL, 136), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 136), (1, HUFFMAN_EMIT_SYMBOL, 146), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 146), # Node 121 (3, HUFFMAN_EMIT_SYMBOL, 230), (6, HUFFMAN_EMIT_SYMBOL, 230), (10, HUFFMAN_EMIT_SYMBOL, 230), (15, HUFFMAN_EMIT_SYMBOL, 230), (24, HUFFMAN_EMIT_SYMBOL, 230), (31, HUFFMAN_EMIT_SYMBOL, 230), (41, HUFFMAN_EMIT_SYMBOL, 230), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 230), (2, HUFFMAN_EMIT_SYMBOL, 129), (9, HUFFMAN_EMIT_SYMBOL, 129), (23, HUFFMAN_EMIT_SYMBOL, 129), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 129), (2, HUFFMAN_EMIT_SYMBOL, 132), (9, HUFFMAN_EMIT_SYMBOL, 132), (23, HUFFMAN_EMIT_SYMBOL, 132), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 132), # Node 122 (3, HUFFMAN_EMIT_SYMBOL, 129), (6, HUFFMAN_EMIT_SYMBOL, 129), (10, HUFFMAN_EMIT_SYMBOL, 129), (15, HUFFMAN_EMIT_SYMBOL, 129), (24, HUFFMAN_EMIT_SYMBOL, 129), (31, HUFFMAN_EMIT_SYMBOL, 129), (41, HUFFMAN_EMIT_SYMBOL, 129), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 129), (3, HUFFMAN_EMIT_SYMBOL, 132), (6, HUFFMAN_EMIT_SYMBOL, 132), (10, HUFFMAN_EMIT_SYMBOL, 132), (15, HUFFMAN_EMIT_SYMBOL, 132), (24, HUFFMAN_EMIT_SYMBOL, 132), (31, HUFFMAN_EMIT_SYMBOL, 132), (41, HUFFMAN_EMIT_SYMBOL, 132), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 132), # Node 123 (2, HUFFMAN_EMIT_SYMBOL, 133), (9, HUFFMAN_EMIT_SYMBOL, 133), (23, HUFFMAN_EMIT_SYMBOL, 133), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 133), (2, HUFFMAN_EMIT_SYMBOL, 134), (9, HUFFMAN_EMIT_SYMBOL, 134), (23, HUFFMAN_EMIT_SYMBOL, 134), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 134), (2, HUFFMAN_EMIT_SYMBOL, 136), (9, HUFFMAN_EMIT_SYMBOL, 136), (23, HUFFMAN_EMIT_SYMBOL, 136), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 136), (2, HUFFMAN_EMIT_SYMBOL, 146), (9, HUFFMAN_EMIT_SYMBOL, 146), (23, HUFFMAN_EMIT_SYMBOL, 146), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 146), # Node 124 (3, HUFFMAN_EMIT_SYMBOL, 133), (6, HUFFMAN_EMIT_SYMBOL, 133), (10, HUFFMAN_EMIT_SYMBOL, 133), (15, HUFFMAN_EMIT_SYMBOL, 133), (24, HUFFMAN_EMIT_SYMBOL, 133), (31, HUFFMAN_EMIT_SYMBOL, 133), (41, HUFFMAN_EMIT_SYMBOL, 133), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 133), (3, HUFFMAN_EMIT_SYMBOL, 134), (6, HUFFMAN_EMIT_SYMBOL, 134), (10, HUFFMAN_EMIT_SYMBOL, 134), (15, HUFFMAN_EMIT_SYMBOL, 134), (24, HUFFMAN_EMIT_SYMBOL, 134), (31, HUFFMAN_EMIT_SYMBOL, 134), (41, HUFFMAN_EMIT_SYMBOL, 134), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 134), # Node 125 (3, HUFFMAN_EMIT_SYMBOL, 136), (6, HUFFMAN_EMIT_SYMBOL, 136), (10, HUFFMAN_EMIT_SYMBOL, 136), (15, HUFFMAN_EMIT_SYMBOL, 136), (24, HUFFMAN_EMIT_SYMBOL, 136), (31, HUFFMAN_EMIT_SYMBOL, 136), (41, HUFFMAN_EMIT_SYMBOL, 136), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 136), (3, HUFFMAN_EMIT_SYMBOL, 146), (6, HUFFMAN_EMIT_SYMBOL, 146), (10, HUFFMAN_EMIT_SYMBOL, 146), (15, HUFFMAN_EMIT_SYMBOL, 146), (24, HUFFMAN_EMIT_SYMBOL, 146), (31, HUFFMAN_EMIT_SYMBOL, 146), (41, HUFFMAN_EMIT_SYMBOL, 146), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 146), # Node 126 (1, HUFFMAN_EMIT_SYMBOL, 154), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 154), (1, HUFFMAN_EMIT_SYMBOL, 156), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 156), (1, HUFFMAN_EMIT_SYMBOL, 160), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 160), (1, HUFFMAN_EMIT_SYMBOL, 163), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 163), (1, HUFFMAN_EMIT_SYMBOL, 164), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 164), (1, HUFFMAN_EMIT_SYMBOL, 169), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 169), (1, HUFFMAN_EMIT_SYMBOL, 170), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 170), (1, HUFFMAN_EMIT_SYMBOL, 173), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 173), # Node 127 (2, HUFFMAN_EMIT_SYMBOL, 154), (9, HUFFMAN_EMIT_SYMBOL, 154), (23, HUFFMAN_EMIT_SYMBOL, 154), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 154), (2, HUFFMAN_EMIT_SYMBOL, 156), (9, HUFFMAN_EMIT_SYMBOL, 156), (23, HUFFMAN_EMIT_SYMBOL, 156), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 156), (2, HUFFMAN_EMIT_SYMBOL, 160), (9, HUFFMAN_EMIT_SYMBOL, 160), (23, HUFFMAN_EMIT_SYMBOL, 160), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 160), (2, HUFFMAN_EMIT_SYMBOL, 163), (9, HUFFMAN_EMIT_SYMBOL, 163), (23, HUFFMAN_EMIT_SYMBOL, 163), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 163), # Node 128 (3, HUFFMAN_EMIT_SYMBOL, 154), (6, HUFFMAN_EMIT_SYMBOL, 154), (10, HUFFMAN_EMIT_SYMBOL, 154), (15, HUFFMAN_EMIT_SYMBOL, 154), (24, HUFFMAN_EMIT_SYMBOL, 154), (31, HUFFMAN_EMIT_SYMBOL, 154), (41, HUFFMAN_EMIT_SYMBOL, 154), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 154), (3, HUFFMAN_EMIT_SYMBOL, 156), (6, HUFFMAN_EMIT_SYMBOL, 156), (10, HUFFMAN_EMIT_SYMBOL, 156), (15, HUFFMAN_EMIT_SYMBOL, 156), (24, HUFFMAN_EMIT_SYMBOL, 156), (31, HUFFMAN_EMIT_SYMBOL, 156), (41, HUFFMAN_EMIT_SYMBOL, 156), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 156), # Node 129 (3, HUFFMAN_EMIT_SYMBOL, 160), (6, HUFFMAN_EMIT_SYMBOL, 160), (10, HUFFMAN_EMIT_SYMBOL, 160), (15, HUFFMAN_EMIT_SYMBOL, 160), (24, HUFFMAN_EMIT_SYMBOL, 160), (31, HUFFMAN_EMIT_SYMBOL, 160), (41, HUFFMAN_EMIT_SYMBOL, 160), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 160), (3, HUFFMAN_EMIT_SYMBOL, 163), (6, HUFFMAN_EMIT_SYMBOL, 163), (10, HUFFMAN_EMIT_SYMBOL, 163), (15, HUFFMAN_EMIT_SYMBOL, 163), (24, HUFFMAN_EMIT_SYMBOL, 163), (31, HUFFMAN_EMIT_SYMBOL, 163), (41, HUFFMAN_EMIT_SYMBOL, 163), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 163), # Node 130 (2, HUFFMAN_EMIT_SYMBOL, 164), (9, HUFFMAN_EMIT_SYMBOL, 164), (23, HUFFMAN_EMIT_SYMBOL, 164), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 164), (2, HUFFMAN_EMIT_SYMBOL, 169), (9, HUFFMAN_EMIT_SYMBOL, 169), (23, HUFFMAN_EMIT_SYMBOL, 169), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 169), (2, HUFFMAN_EMIT_SYMBOL, 170), (9, HUFFMAN_EMIT_SYMBOL, 170), (23, HUFFMAN_EMIT_SYMBOL, 170), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 170), (2, HUFFMAN_EMIT_SYMBOL, 173), (9, HUFFMAN_EMIT_SYMBOL, 173), (23, HUFFMAN_EMIT_SYMBOL, 173), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 173), # Node 131 (3, HUFFMAN_EMIT_SYMBOL, 164), (6, HUFFMAN_EMIT_SYMBOL, 164), (10, HUFFMAN_EMIT_SYMBOL, 164), (15, HUFFMAN_EMIT_SYMBOL, 164), (24, HUFFMAN_EMIT_SYMBOL, 164), (31, HUFFMAN_EMIT_SYMBOL, 164), (41, HUFFMAN_EMIT_SYMBOL, 164), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 164), (3, HUFFMAN_EMIT_SYMBOL, 169), (6, HUFFMAN_EMIT_SYMBOL, 169), (10, HUFFMAN_EMIT_SYMBOL, 169), (15, HUFFMAN_EMIT_SYMBOL, 169), (24, HUFFMAN_EMIT_SYMBOL, 169), (31, HUFFMAN_EMIT_SYMBOL, 169), (41, HUFFMAN_EMIT_SYMBOL, 169), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 169), # Node 132 (3, HUFFMAN_EMIT_SYMBOL, 170), (6, HUFFMAN_EMIT_SYMBOL, 170), (10, HUFFMAN_EMIT_SYMBOL, 170), (15, HUFFMAN_EMIT_SYMBOL, 170), (24, HUFFMAN_EMIT_SYMBOL, 170), (31, HUFFMAN_EMIT_SYMBOL, 170), (41, HUFFMAN_EMIT_SYMBOL, 170), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 170), (3, HUFFMAN_EMIT_SYMBOL, 173), (6, HUFFMAN_EMIT_SYMBOL, 173), (10, HUFFMAN_EMIT_SYMBOL, 173), (15, HUFFMAN_EMIT_SYMBOL, 173), (24, HUFFMAN_EMIT_SYMBOL, 173), (31, HUFFMAN_EMIT_SYMBOL, 173), (41, HUFFMAN_EMIT_SYMBOL, 173), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 173), # Node 133 (137, 0, 0), (138, 0, 0), (140, 0, 0), (141, 0, 0), (144, 0, 0), (145, 0, 0), (147, 0, 0), (150, 0, 0), (156, 0, 0), (159, 0, 0), (163, 0, 0), (166, 0, 0), (171, 0, 0), (174, 0, 0), (181, 0, 0), (190, 0, 0), # Node 134 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 178), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 181), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 185), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 186), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 187), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 189), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 190), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 196), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 198), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 228), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 232), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 233), (148, 0, 0), (149, 0, 0), (151, 0, 0), (152, 0, 0), # Node 135 (1, HUFFMAN_EMIT_SYMBOL, 178), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 178), (1, HUFFMAN_EMIT_SYMBOL, 181), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 181), (1, HUFFMAN_EMIT_SYMBOL, 185), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 185), (1, HUFFMAN_EMIT_SYMBOL, 186), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 186), (1, HUFFMAN_EMIT_SYMBOL, 187), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 187), (1, HUFFMAN_EMIT_SYMBOL, 189), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 189), (1, HUFFMAN_EMIT_SYMBOL, 190), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 190), (1, HUFFMAN_EMIT_SYMBOL, 196), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 196), # Node 136 (2, HUFFMAN_EMIT_SYMBOL, 178), (9, HUFFMAN_EMIT_SYMBOL, 178), (23, HUFFMAN_EMIT_SYMBOL, 178), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 178), (2, HUFFMAN_EMIT_SYMBOL, 181), (9, HUFFMAN_EMIT_SYMBOL, 181), (23, HUFFMAN_EMIT_SYMBOL, 181), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 181), (2, HUFFMAN_EMIT_SYMBOL, 185), (9, HUFFMAN_EMIT_SYMBOL, 185), (23, HUFFMAN_EMIT_SYMBOL, 185), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 185), (2, HUFFMAN_EMIT_SYMBOL, 186), (9, HUFFMAN_EMIT_SYMBOL, 186), (23, HUFFMAN_EMIT_SYMBOL, 186), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 186), # Node 137 (3, HUFFMAN_EMIT_SYMBOL, 178), (6, HUFFMAN_EMIT_SYMBOL, 178), (10, HUFFMAN_EMIT_SYMBOL, 178), (15, HUFFMAN_EMIT_SYMBOL, 178), (24, HUFFMAN_EMIT_SYMBOL, 178), (31, HUFFMAN_EMIT_SYMBOL, 178), (41, HUFFMAN_EMIT_SYMBOL, 178), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 178), (3, HUFFMAN_EMIT_SYMBOL, 181), (6, HUFFMAN_EMIT_SYMBOL, 181), (10, HUFFMAN_EMIT_SYMBOL, 181), (15, HUFFMAN_EMIT_SYMBOL, 181), (24, HUFFMAN_EMIT_SYMBOL, 181), (31, HUFFMAN_EMIT_SYMBOL, 181), (41, HUFFMAN_EMIT_SYMBOL, 181), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 181), # Node 138 (3, HUFFMAN_EMIT_SYMBOL, 185), (6, HUFFMAN_EMIT_SYMBOL, 185), (10, HUFFMAN_EMIT_SYMBOL, 185), (15, HUFFMAN_EMIT_SYMBOL, 185), (24, HUFFMAN_EMIT_SYMBOL, 185), (31, HUFFMAN_EMIT_SYMBOL, 185), (41, HUFFMAN_EMIT_SYMBOL, 185), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 185), (3, HUFFMAN_EMIT_SYMBOL, 186), (6, HUFFMAN_EMIT_SYMBOL, 186), (10, HUFFMAN_EMIT_SYMBOL, 186), (15, HUFFMAN_EMIT_SYMBOL, 186), (24, HUFFMAN_EMIT_SYMBOL, 186), (31, HUFFMAN_EMIT_SYMBOL, 186), (41, HUFFMAN_EMIT_SYMBOL, 186), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 186), # Node 139 (2, HUFFMAN_EMIT_SYMBOL, 187), (9, HUFFMAN_EMIT_SYMBOL, 187), (23, HUFFMAN_EMIT_SYMBOL, 187), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 187), (2, HUFFMAN_EMIT_SYMBOL, 189), (9, HUFFMAN_EMIT_SYMBOL, 189), (23, HUFFMAN_EMIT_SYMBOL, 189), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 189), (2, HUFFMAN_EMIT_SYMBOL, 190), (9, HUFFMAN_EMIT_SYMBOL, 190), (23, HUFFMAN_EMIT_SYMBOL, 190), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 190), (2, HUFFMAN_EMIT_SYMBOL, 196), (9, HUFFMAN_EMIT_SYMBOL, 196), (23, HUFFMAN_EMIT_SYMBOL, 196), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 196), # Node 140 (3, HUFFMAN_EMIT_SYMBOL, 187), (6, HUFFMAN_EMIT_SYMBOL, 187), (10, HUFFMAN_EMIT_SYMBOL, 187), (15, HUFFMAN_EMIT_SYMBOL, 187), (24, HUFFMAN_EMIT_SYMBOL, 187), (31, HUFFMAN_EMIT_SYMBOL, 187), (41, HUFFMAN_EMIT_SYMBOL, 187), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 187), (3, HUFFMAN_EMIT_SYMBOL, 189), (6, HUFFMAN_EMIT_SYMBOL, 189), (10, HUFFMAN_EMIT_SYMBOL, 189), (15, HUFFMAN_EMIT_SYMBOL, 189), (24, HUFFMAN_EMIT_SYMBOL, 189), (31, HUFFMAN_EMIT_SYMBOL, 189), (41, HUFFMAN_EMIT_SYMBOL, 189), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 189), # Node 141 (3, HUFFMAN_EMIT_SYMBOL, 190), (6, HUFFMAN_EMIT_SYMBOL, 190), (10, HUFFMAN_EMIT_SYMBOL, 190), (15, HUFFMAN_EMIT_SYMBOL, 190), (24, HUFFMAN_EMIT_SYMBOL, 190), (31, HUFFMAN_EMIT_SYMBOL, 190), (41, HUFFMAN_EMIT_SYMBOL, 190), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 190), (3, HUFFMAN_EMIT_SYMBOL, 196), (6, HUFFMAN_EMIT_SYMBOL, 196), (10, HUFFMAN_EMIT_SYMBOL, 196), (15, HUFFMAN_EMIT_SYMBOL, 196), (24, HUFFMAN_EMIT_SYMBOL, 196), (31, HUFFMAN_EMIT_SYMBOL, 196), (41, HUFFMAN_EMIT_SYMBOL, 196), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 196), # Node 142 (1, HUFFMAN_EMIT_SYMBOL, 198), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 198), (1, HUFFMAN_EMIT_SYMBOL, 228), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 228), (1, HUFFMAN_EMIT_SYMBOL, 232), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 232), (1, HUFFMAN_EMIT_SYMBOL, 233), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 233), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 1), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 135), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 137), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 138), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 139), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 140), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 141), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 143), # Node 143 (2, HUFFMAN_EMIT_SYMBOL, 198), (9, HUFFMAN_EMIT_SYMBOL, 198), (23, HUFFMAN_EMIT_SYMBOL, 198), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 198), (2, HUFFMAN_EMIT_SYMBOL, 228), (9, HUFFMAN_EMIT_SYMBOL, 228), (23, HUFFMAN_EMIT_SYMBOL, 228), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 228), (2, HUFFMAN_EMIT_SYMBOL, 232), (9, HUFFMAN_EMIT_SYMBOL, 232), (23, HUFFMAN_EMIT_SYMBOL, 232), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 232), (2, HUFFMAN_EMIT_SYMBOL, 233), (9, HUFFMAN_EMIT_SYMBOL, 233), (23, HUFFMAN_EMIT_SYMBOL, 233), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 233), # Node 144 (3, HUFFMAN_EMIT_SYMBOL, 198), (6, HUFFMAN_EMIT_SYMBOL, 198), (10, HUFFMAN_EMIT_SYMBOL, 198), (15, HUFFMAN_EMIT_SYMBOL, 198), (24, HUFFMAN_EMIT_SYMBOL, 198), (31, HUFFMAN_EMIT_SYMBOL, 198), (41, HUFFMAN_EMIT_SYMBOL, 198), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 198), (3, HUFFMAN_EMIT_SYMBOL, 228), (6, HUFFMAN_EMIT_SYMBOL, 228), (10, HUFFMAN_EMIT_SYMBOL, 228), (15, HUFFMAN_EMIT_SYMBOL, 228), (24, HUFFMAN_EMIT_SYMBOL, 228), (31, HUFFMAN_EMIT_SYMBOL, 228), (41, HUFFMAN_EMIT_SYMBOL, 228), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 228), # Node 145 (3, HUFFMAN_EMIT_SYMBOL, 232), (6, HUFFMAN_EMIT_SYMBOL, 232), (10, HUFFMAN_EMIT_SYMBOL, 232), (15, HUFFMAN_EMIT_SYMBOL, 232), (24, HUFFMAN_EMIT_SYMBOL, 232), (31, HUFFMAN_EMIT_SYMBOL, 232), (41, HUFFMAN_EMIT_SYMBOL, 232), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 232), (3, HUFFMAN_EMIT_SYMBOL, 233), (6, HUFFMAN_EMIT_SYMBOL, 233), (10, HUFFMAN_EMIT_SYMBOL, 233), (15, HUFFMAN_EMIT_SYMBOL, 233), (24, HUFFMAN_EMIT_SYMBOL, 233), (31, HUFFMAN_EMIT_SYMBOL, 233), (41, HUFFMAN_EMIT_SYMBOL, 233), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 233), # Node 146 (1, HUFFMAN_EMIT_SYMBOL, 1), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 1), (1, HUFFMAN_EMIT_SYMBOL, 135), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 135), (1, HUFFMAN_EMIT_SYMBOL, 137), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 137), (1, HUFFMAN_EMIT_SYMBOL, 138), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 138), (1, HUFFMAN_EMIT_SYMBOL, 139), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 139), (1, HUFFMAN_EMIT_SYMBOL, 140), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 140), (1, HUFFMAN_EMIT_SYMBOL, 141), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 141), (1, HUFFMAN_EMIT_SYMBOL, 143), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 143), # Node 147 (2, HUFFMAN_EMIT_SYMBOL, 1), (9, HUFFMAN_EMIT_SYMBOL, 1), (23, HUFFMAN_EMIT_SYMBOL, 1), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 1), (2, HUFFMAN_EMIT_SYMBOL, 135), (9, HUFFMAN_EMIT_SYMBOL, 135), (23, HUFFMAN_EMIT_SYMBOL, 135), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 135), (2, HUFFMAN_EMIT_SYMBOL, 137), (9, HUFFMAN_EMIT_SYMBOL, 137), (23, HUFFMAN_EMIT_SYMBOL, 137), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 137), (2, HUFFMAN_EMIT_SYMBOL, 138), (9, HUFFMAN_EMIT_SYMBOL, 138), (23, HUFFMAN_EMIT_SYMBOL, 138), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 138), # Node 148 (3, HUFFMAN_EMIT_SYMBOL, 1), (6, HUFFMAN_EMIT_SYMBOL, 1), (10, HUFFMAN_EMIT_SYMBOL, 1), (15, HUFFMAN_EMIT_SYMBOL, 1), (24, HUFFMAN_EMIT_SYMBOL, 1), (31, HUFFMAN_EMIT_SYMBOL, 1), (41, HUFFMAN_EMIT_SYMBOL, 1), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 1), (3, HUFFMAN_EMIT_SYMBOL, 135), (6, HUFFMAN_EMIT_SYMBOL, 135), (10, HUFFMAN_EMIT_SYMBOL, 135), (15, HUFFMAN_EMIT_SYMBOL, 135), (24, HUFFMAN_EMIT_SYMBOL, 135), (31, HUFFMAN_EMIT_SYMBOL, 135), (41, HUFFMAN_EMIT_SYMBOL, 135), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 135), # Node 149 (3, HUFFMAN_EMIT_SYMBOL, 137), (6, HUFFMAN_EMIT_SYMBOL, 137), (10, HUFFMAN_EMIT_SYMBOL, 137), (15, HUFFMAN_EMIT_SYMBOL, 137), (24, HUFFMAN_EMIT_SYMBOL, 137), (31, HUFFMAN_EMIT_SYMBOL, 137), (41, HUFFMAN_EMIT_SYMBOL, 137), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 137), (3, HUFFMAN_EMIT_SYMBOL, 138), (6, HUFFMAN_EMIT_SYMBOL, 138), (10, HUFFMAN_EMIT_SYMBOL, 138), (15, HUFFMAN_EMIT_SYMBOL, 138), (24, HUFFMAN_EMIT_SYMBOL, 138), (31, HUFFMAN_EMIT_SYMBOL, 138), (41, HUFFMAN_EMIT_SYMBOL, 138), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 138), # Node 150 (2, HUFFMAN_EMIT_SYMBOL, 139), (9, HUFFMAN_EMIT_SYMBOL, 139), (23, HUFFMAN_EMIT_SYMBOL, 139), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 139), (2, HUFFMAN_EMIT_SYMBOL, 140), (9, HUFFMAN_EMIT_SYMBOL, 140), (23, HUFFMAN_EMIT_SYMBOL, 140), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 140), (2, HUFFMAN_EMIT_SYMBOL, 141), (9, HUFFMAN_EMIT_SYMBOL, 141), (23, HUFFMAN_EMIT_SYMBOL, 141), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 141), (2, HUFFMAN_EMIT_SYMBOL, 143), (9, HUFFMAN_EMIT_SYMBOL, 143), (23, HUFFMAN_EMIT_SYMBOL, 143), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 143), # Node 151 (3, HUFFMAN_EMIT_SYMBOL, 139), (6, HUFFMAN_EMIT_SYMBOL, 139), (10, HUFFMAN_EMIT_SYMBOL, 139), (15, HUFFMAN_EMIT_SYMBOL, 139), (24, HUFFMAN_EMIT_SYMBOL, 139), (31, HUFFMAN_EMIT_SYMBOL, 139), (41, HUFFMAN_EMIT_SYMBOL, 139), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 139), (3, HUFFMAN_EMIT_SYMBOL, 140), (6, HUFFMAN_EMIT_SYMBOL, 140), (10, HUFFMAN_EMIT_SYMBOL, 140), (15, HUFFMAN_EMIT_SYMBOL, 140), (24, HUFFMAN_EMIT_SYMBOL, 140), (31, HUFFMAN_EMIT_SYMBOL, 140), (41, HUFFMAN_EMIT_SYMBOL, 140), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 140), # Node 152 (3, HUFFMAN_EMIT_SYMBOL, 141), (6, HUFFMAN_EMIT_SYMBOL, 141), (10, HUFFMAN_EMIT_SYMBOL, 141), (15, HUFFMAN_EMIT_SYMBOL, 141), (24, HUFFMAN_EMIT_SYMBOL, 141), (31, HUFFMAN_EMIT_SYMBOL, 141), (41, HUFFMAN_EMIT_SYMBOL, 141), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 141), (3, HUFFMAN_EMIT_SYMBOL, 143), (6, HUFFMAN_EMIT_SYMBOL, 143), (10, HUFFMAN_EMIT_SYMBOL, 143), (15, HUFFMAN_EMIT_SYMBOL, 143), (24, HUFFMAN_EMIT_SYMBOL, 143), (31, HUFFMAN_EMIT_SYMBOL, 143), (41, HUFFMAN_EMIT_SYMBOL, 143), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 143), # Node 153 (157, 0, 0), (158, 0, 0), (160, 0, 0), (161, 0, 0), (164, 0, 0), (165, 0, 0), (167, 0, 0), (168, 0, 0), (172, 0, 0), (173, 0, 0), (175, 0, 0), (177, 0, 0), (182, 0, 0), (185, 0, 0), (191, 0, 0), (207, 0, 0), # Node 154 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 147), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 149), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 150), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 151), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 152), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 155), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 157), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 158), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 165), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 166), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 168), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 174), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 175), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 180), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 182), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 183), # Node 155 (1, HUFFMAN_EMIT_SYMBOL, 147), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 147), (1, HUFFMAN_EMIT_SYMBOL, 149), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 149), (1, HUFFMAN_EMIT_SYMBOL, 150), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 150), (1, HUFFMAN_EMIT_SYMBOL, 151), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 151), (1, HUFFMAN_EMIT_SYMBOL, 152), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 152), (1, HUFFMAN_EMIT_SYMBOL, 155), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 155), (1, HUFFMAN_EMIT_SYMBOL, 157), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 157), (1, HUFFMAN_EMIT_SYMBOL, 158), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 158), # Node 156 (2, HUFFMAN_EMIT_SYMBOL, 147), (9, HUFFMAN_EMIT_SYMBOL, 147), (23, HUFFMAN_EMIT_SYMBOL, 147), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 147), (2, HUFFMAN_EMIT_SYMBOL, 149), (9, HUFFMAN_EMIT_SYMBOL, 149), (23, HUFFMAN_EMIT_SYMBOL, 149), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 149), (2, HUFFMAN_EMIT_SYMBOL, 150), (9, HUFFMAN_EMIT_SYMBOL, 150), (23, HUFFMAN_EMIT_SYMBOL, 150), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 150), (2, HUFFMAN_EMIT_SYMBOL, 151), (9, HUFFMAN_EMIT_SYMBOL, 151), (23, HUFFMAN_EMIT_SYMBOL, 151), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 151), # Node 157 (3, HUFFMAN_EMIT_SYMBOL, 147), (6, HUFFMAN_EMIT_SYMBOL, 147), (10, HUFFMAN_EMIT_SYMBOL, 147), (15, HUFFMAN_EMIT_SYMBOL, 147), (24, HUFFMAN_EMIT_SYMBOL, 147), (31, HUFFMAN_EMIT_SYMBOL, 147), (41, HUFFMAN_EMIT_SYMBOL, 147), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 147), (3, HUFFMAN_EMIT_SYMBOL, 149), (6, HUFFMAN_EMIT_SYMBOL, 149), (10, HUFFMAN_EMIT_SYMBOL, 149), (15, HUFFMAN_EMIT_SYMBOL, 149), (24, HUFFMAN_EMIT_SYMBOL, 149), (31, HUFFMAN_EMIT_SYMBOL, 149), (41, HUFFMAN_EMIT_SYMBOL, 149), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 149), # Node 158 (3, HUFFMAN_EMIT_SYMBOL, 150), (6, HUFFMAN_EMIT_SYMBOL, 150), (10, HUFFMAN_EMIT_SYMBOL, 150), (15, HUFFMAN_EMIT_SYMBOL, 150), (24, HUFFMAN_EMIT_SYMBOL, 150), (31, HUFFMAN_EMIT_SYMBOL, 150), (41, HUFFMAN_EMIT_SYMBOL, 150), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 150), (3, HUFFMAN_EMIT_SYMBOL, 151), (6, HUFFMAN_EMIT_SYMBOL, 151), (10, HUFFMAN_EMIT_SYMBOL, 151), (15, HUFFMAN_EMIT_SYMBOL, 151), (24, HUFFMAN_EMIT_SYMBOL, 151), (31, HUFFMAN_EMIT_SYMBOL, 151), (41, HUFFMAN_EMIT_SYMBOL, 151), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 151), # Node 159 (2, HUFFMAN_EMIT_SYMBOL, 152), (9, HUFFMAN_EMIT_SYMBOL, 152), (23, HUFFMAN_EMIT_SYMBOL, 152), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 152), (2, HUFFMAN_EMIT_SYMBOL, 155), (9, HUFFMAN_EMIT_SYMBOL, 155), (23, HUFFMAN_EMIT_SYMBOL, 155), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 155), (2, HUFFMAN_EMIT_SYMBOL, 157), (9, HUFFMAN_EMIT_SYMBOL, 157), (23, HUFFMAN_EMIT_SYMBOL, 157), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 157), (2, HUFFMAN_EMIT_SYMBOL, 158), (9, HUFFMAN_EMIT_SYMBOL, 158), (23, HUFFMAN_EMIT_SYMBOL, 158), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 158), # Node 160 (3, HUFFMAN_EMIT_SYMBOL, 152), (6, HUFFMAN_EMIT_SYMBOL, 152), (10, HUFFMAN_EMIT_SYMBOL, 152), (15, HUFFMAN_EMIT_SYMBOL, 152), (24, HUFFMAN_EMIT_SYMBOL, 152), (31, HUFFMAN_EMIT_SYMBOL, 152), (41, HUFFMAN_EMIT_SYMBOL, 152), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 152), (3, HUFFMAN_EMIT_SYMBOL, 155), (6, HUFFMAN_EMIT_SYMBOL, 155), (10, HUFFMAN_EMIT_SYMBOL, 155), (15, HUFFMAN_EMIT_SYMBOL, 155), (24, HUFFMAN_EMIT_SYMBOL, 155), (31, HUFFMAN_EMIT_SYMBOL, 155), (41, HUFFMAN_EMIT_SYMBOL, 155), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 155), # Node 161 (3, HUFFMAN_EMIT_SYMBOL, 157), (6, HUFFMAN_EMIT_SYMBOL, 157), (10, HUFFMAN_EMIT_SYMBOL, 157), (15, HUFFMAN_EMIT_SYMBOL, 157), (24, HUFFMAN_EMIT_SYMBOL, 157), (31, HUFFMAN_EMIT_SYMBOL, 157), (41, HUFFMAN_EMIT_SYMBOL, 157), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 157), (3, HUFFMAN_EMIT_SYMBOL, 158), (6, HUFFMAN_EMIT_SYMBOL, 158), (10, HUFFMAN_EMIT_SYMBOL, 158), (15, HUFFMAN_EMIT_SYMBOL, 158), (24, HUFFMAN_EMIT_SYMBOL, 158), (31, HUFFMAN_EMIT_SYMBOL, 158), (41, HUFFMAN_EMIT_SYMBOL, 158), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 158), # Node 162 (1, HUFFMAN_EMIT_SYMBOL, 165), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 165), (1, HUFFMAN_EMIT_SYMBOL, 166), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 166), (1, HUFFMAN_EMIT_SYMBOL, 168), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 168), (1, HUFFMAN_EMIT_SYMBOL, 174), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 174), (1, HUFFMAN_EMIT_SYMBOL, 175), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 175), (1, HUFFMAN_EMIT_SYMBOL, 180), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 180), (1, HUFFMAN_EMIT_SYMBOL, 182), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 182), (1, HUFFMAN_EMIT_SYMBOL, 183), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 183), # Node 163 (2, HUFFMAN_EMIT_SYMBOL, 165), (9, HUFFMAN_EMIT_SYMBOL, 165), (23, HUFFMAN_EMIT_SYMBOL, 165), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 165), (2, HUFFMAN_EMIT_SYMBOL, 166), (9, HUFFMAN_EMIT_SYMBOL, 166), (23, HUFFMAN_EMIT_SYMBOL, 166), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 166), (2, HUFFMAN_EMIT_SYMBOL, 168), (9, HUFFMAN_EMIT_SYMBOL, 168), (23, HUFFMAN_EMIT_SYMBOL, 168), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 168), (2, HUFFMAN_EMIT_SYMBOL, 174), (9, HUFFMAN_EMIT_SYMBOL, 174), (23, HUFFMAN_EMIT_SYMBOL, 174), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 174), # Node 164 (3, HUFFMAN_EMIT_SYMBOL, 165), (6, HUFFMAN_EMIT_SYMBOL, 165), (10, HUFFMAN_EMIT_SYMBOL, 165), (15, HUFFMAN_EMIT_SYMBOL, 165), (24, HUFFMAN_EMIT_SYMBOL, 165), (31, HUFFMAN_EMIT_SYMBOL, 165), (41, HUFFMAN_EMIT_SYMBOL, 165), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 165), (3, HUFFMAN_EMIT_SYMBOL, 166), (6, HUFFMAN_EMIT_SYMBOL, 166), (10, HUFFMAN_EMIT_SYMBOL, 166), (15, HUFFMAN_EMIT_SYMBOL, 166), (24, HUFFMAN_EMIT_SYMBOL, 166), (31, HUFFMAN_EMIT_SYMBOL, 166), (41, HUFFMAN_EMIT_SYMBOL, 166), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 166), # Node 165 (3, HUFFMAN_EMIT_SYMBOL, 168), (6, HUFFMAN_EMIT_SYMBOL, 168), (10, HUFFMAN_EMIT_SYMBOL, 168), (15, HUFFMAN_EMIT_SYMBOL, 168), (24, HUFFMAN_EMIT_SYMBOL, 168), (31, HUFFMAN_EMIT_SYMBOL, 168), (41, HUFFMAN_EMIT_SYMBOL, 168), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 168), (3, HUFFMAN_EMIT_SYMBOL, 174), (6, HUFFMAN_EMIT_SYMBOL, 174), (10, HUFFMAN_EMIT_SYMBOL, 174), (15, HUFFMAN_EMIT_SYMBOL, 174), (24, HUFFMAN_EMIT_SYMBOL, 174), (31, HUFFMAN_EMIT_SYMBOL, 174), (41, HUFFMAN_EMIT_SYMBOL, 174), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 174), # Node 166 (2, HUFFMAN_EMIT_SYMBOL, 175), (9, HUFFMAN_EMIT_SYMBOL, 175), (23, HUFFMAN_EMIT_SYMBOL, 175), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 175), (2, HUFFMAN_EMIT_SYMBOL, 180), (9, HUFFMAN_EMIT_SYMBOL, 180), (23, HUFFMAN_EMIT_SYMBOL, 180), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 180), (2, HUFFMAN_EMIT_SYMBOL, 182), (9, HUFFMAN_EMIT_SYMBOL, 182), (23, HUFFMAN_EMIT_SYMBOL, 182), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 182), (2, HUFFMAN_EMIT_SYMBOL, 183), (9, HUFFMAN_EMIT_SYMBOL, 183), (23, HUFFMAN_EMIT_SYMBOL, 183), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 183), # Node 167 (3, HUFFMAN_EMIT_SYMBOL, 175), (6, HUFFMAN_EMIT_SYMBOL, 175), (10, HUFFMAN_EMIT_SYMBOL, 175), (15, HUFFMAN_EMIT_SYMBOL, 175), (24, HUFFMAN_EMIT_SYMBOL, 175), (31, HUFFMAN_EMIT_SYMBOL, 175), (41, HUFFMAN_EMIT_SYMBOL, 175), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 175), (3, HUFFMAN_EMIT_SYMBOL, 180), (6, HUFFMAN_EMIT_SYMBOL, 180), (10, HUFFMAN_EMIT_SYMBOL, 180), (15, HUFFMAN_EMIT_SYMBOL, 180), (24, HUFFMAN_EMIT_SYMBOL, 180), (31, HUFFMAN_EMIT_SYMBOL, 180), (41, HUFFMAN_EMIT_SYMBOL, 180), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 180), # Node 168 (3, HUFFMAN_EMIT_SYMBOL, 182), (6, HUFFMAN_EMIT_SYMBOL, 182), (10, HUFFMAN_EMIT_SYMBOL, 182), (15, HUFFMAN_EMIT_SYMBOL, 182), (24, HUFFMAN_EMIT_SYMBOL, 182), (31, HUFFMAN_EMIT_SYMBOL, 182), (41, HUFFMAN_EMIT_SYMBOL, 182), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 182), (3, HUFFMAN_EMIT_SYMBOL, 183), (6, HUFFMAN_EMIT_SYMBOL, 183), (10, HUFFMAN_EMIT_SYMBOL, 183), (15, HUFFMAN_EMIT_SYMBOL, 183), (24, HUFFMAN_EMIT_SYMBOL, 183), (31, HUFFMAN_EMIT_SYMBOL, 183), (41, HUFFMAN_EMIT_SYMBOL, 183), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 183), # Node 169 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 188), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 191), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 197), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 231), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 239), (176, 0, 0), (178, 0, 0), (179, 0, 0), (183, 0, 0), (184, 0, 0), (186, 0, 0), (187, 0, 0), (192, 0, 0), (199, 0, 0), (208, 0, 0), (223, 0, 0), # Node 170 (1, HUFFMAN_EMIT_SYMBOL, 188), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 188), (1, HUFFMAN_EMIT_SYMBOL, 191), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 191), (1, HUFFMAN_EMIT_SYMBOL, 197), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 197), (1, HUFFMAN_EMIT_SYMBOL, 231), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 231), (1, HUFFMAN_EMIT_SYMBOL, 239), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 239), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 9), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 142), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 144), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 145), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 148), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 159), # Node 171 (2, HUFFMAN_EMIT_SYMBOL, 188), (9, HUFFMAN_EMIT_SYMBOL, 188), (23, HUFFMAN_EMIT_SYMBOL, 188), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 188), (2, HUFFMAN_EMIT_SYMBOL, 191), (9, HUFFMAN_EMIT_SYMBOL, 191), (23, HUFFMAN_EMIT_SYMBOL, 191), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 191), (2, HUFFMAN_EMIT_SYMBOL, 197), (9, HUFFMAN_EMIT_SYMBOL, 197), (23, HUFFMAN_EMIT_SYMBOL, 197), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 197), (2, HUFFMAN_EMIT_SYMBOL, 231), (9, HUFFMAN_EMIT_SYMBOL, 231), (23, HUFFMAN_EMIT_SYMBOL, 231), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 231), # Node 172 (3, HUFFMAN_EMIT_SYMBOL, 188), (6, HUFFMAN_EMIT_SYMBOL, 188), (10, HUFFMAN_EMIT_SYMBOL, 188), (15, HUFFMAN_EMIT_SYMBOL, 188), (24, HUFFMAN_EMIT_SYMBOL, 188), (31, HUFFMAN_EMIT_SYMBOL, 188), (41, HUFFMAN_EMIT_SYMBOL, 188), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 188), (3, HUFFMAN_EMIT_SYMBOL, 191), (6, HUFFMAN_EMIT_SYMBOL, 191), (10, HUFFMAN_EMIT_SYMBOL, 191), (15, HUFFMAN_EMIT_SYMBOL, 191), (24, HUFFMAN_EMIT_SYMBOL, 191), (31, HUFFMAN_EMIT_SYMBOL, 191), (41, HUFFMAN_EMIT_SYMBOL, 191), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 191), # Node 173 (3, HUFFMAN_EMIT_SYMBOL, 197), (6, HUFFMAN_EMIT_SYMBOL, 197), (10, HUFFMAN_EMIT_SYMBOL, 197), (15, HUFFMAN_EMIT_SYMBOL, 197), (24, HUFFMAN_EMIT_SYMBOL, 197), (31, HUFFMAN_EMIT_SYMBOL, 197), (41, HUFFMAN_EMIT_SYMBOL, 197), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 197), (3, HUFFMAN_EMIT_SYMBOL, 231), (6, HUFFMAN_EMIT_SYMBOL, 231), (10, HUFFMAN_EMIT_SYMBOL, 231), (15, HUFFMAN_EMIT_SYMBOL, 231), (24, HUFFMAN_EMIT_SYMBOL, 231), (31, HUFFMAN_EMIT_SYMBOL, 231), (41, HUFFMAN_EMIT_SYMBOL, 231), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 231), # Node 174 (2, HUFFMAN_EMIT_SYMBOL, 239), (9, HUFFMAN_EMIT_SYMBOL, 239), (23, HUFFMAN_EMIT_SYMBOL, 239), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 239), (1, HUFFMAN_EMIT_SYMBOL, 9), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 9), (1, HUFFMAN_EMIT_SYMBOL, 142), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 142), (1, HUFFMAN_EMIT_SYMBOL, 144), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 144), (1, HUFFMAN_EMIT_SYMBOL, 145), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 145), (1, HUFFMAN_EMIT_SYMBOL, 148), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 148), (1, HUFFMAN_EMIT_SYMBOL, 159), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 159), # Node 175 (3, HUFFMAN_EMIT_SYMBOL, 239), (6, HUFFMAN_EMIT_SYMBOL, 239), (10, HUFFMAN_EMIT_SYMBOL, 239), (15, HUFFMAN_EMIT_SYMBOL, 239), (24, HUFFMAN_EMIT_SYMBOL, 239), (31, HUFFMAN_EMIT_SYMBOL, 239), (41, HUFFMAN_EMIT_SYMBOL, 239), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 239), (2, HUFFMAN_EMIT_SYMBOL, 9), (9, HUFFMAN_EMIT_SYMBOL, 9), (23, HUFFMAN_EMIT_SYMBOL, 9), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 9), (2, HUFFMAN_EMIT_SYMBOL, 142), (9, HUFFMAN_EMIT_SYMBOL, 142), (23, HUFFMAN_EMIT_SYMBOL, 142), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 142), # Node 176 (3, HUFFMAN_EMIT_SYMBOL, 9), (6, HUFFMAN_EMIT_SYMBOL, 9), (10, HUFFMAN_EMIT_SYMBOL, 9), (15, HUFFMAN_EMIT_SYMBOL, 9), (24, HUFFMAN_EMIT_SYMBOL, 9), (31, HUFFMAN_EMIT_SYMBOL, 9), (41, HUFFMAN_EMIT_SYMBOL, 9), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 9), (3, HUFFMAN_EMIT_SYMBOL, 142), (6, HUFFMAN_EMIT_SYMBOL, 142), (10, HUFFMAN_EMIT_SYMBOL, 142), (15, HUFFMAN_EMIT_SYMBOL, 142), (24, HUFFMAN_EMIT_SYMBOL, 142), (31, HUFFMAN_EMIT_SYMBOL, 142), (41, HUFFMAN_EMIT_SYMBOL, 142), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 142), # Node 177 (2, HUFFMAN_EMIT_SYMBOL, 144), (9, HUFFMAN_EMIT_SYMBOL, 144), (23, HUFFMAN_EMIT_SYMBOL, 144), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 144), (2, HUFFMAN_EMIT_SYMBOL, 145), (9, HUFFMAN_EMIT_SYMBOL, 145), (23, HUFFMAN_EMIT_SYMBOL, 145), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 145), (2, HUFFMAN_EMIT_SYMBOL, 148), (9, HUFFMAN_EMIT_SYMBOL, 148), (23, HUFFMAN_EMIT_SYMBOL, 148), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 148), (2, HUFFMAN_EMIT_SYMBOL, 159), (9, HUFFMAN_EMIT_SYMBOL, 159), (23, HUFFMAN_EMIT_SYMBOL, 159), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 159), # Node 178 (3, HUFFMAN_EMIT_SYMBOL, 144), (6, HUFFMAN_EMIT_SYMBOL, 144), (10, HUFFMAN_EMIT_SYMBOL, 144), (15, HUFFMAN_EMIT_SYMBOL, 144), (24, HUFFMAN_EMIT_SYMBOL, 144), (31, HUFFMAN_EMIT_SYMBOL, 144), (41, HUFFMAN_EMIT_SYMBOL, 144), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 144), (3, HUFFMAN_EMIT_SYMBOL, 145), (6, HUFFMAN_EMIT_SYMBOL, 145), (10, HUFFMAN_EMIT_SYMBOL, 145), (15, HUFFMAN_EMIT_SYMBOL, 145), (24, HUFFMAN_EMIT_SYMBOL, 145), (31, HUFFMAN_EMIT_SYMBOL, 145), (41, HUFFMAN_EMIT_SYMBOL, 145), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 145), # Node 179 (3, HUFFMAN_EMIT_SYMBOL, 148), (6, HUFFMAN_EMIT_SYMBOL, 148), (10, HUFFMAN_EMIT_SYMBOL, 148), (15, HUFFMAN_EMIT_SYMBOL, 148), (24, HUFFMAN_EMIT_SYMBOL, 148), (31, HUFFMAN_EMIT_SYMBOL, 148), (41, HUFFMAN_EMIT_SYMBOL, 148), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 148), (3, HUFFMAN_EMIT_SYMBOL, 159), (6, HUFFMAN_EMIT_SYMBOL, 159), (10, HUFFMAN_EMIT_SYMBOL, 159), (15, HUFFMAN_EMIT_SYMBOL, 159), (24, HUFFMAN_EMIT_SYMBOL, 159), (31, HUFFMAN_EMIT_SYMBOL, 159), (41, HUFFMAN_EMIT_SYMBOL, 159), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 159), # Node 180 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 171), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 206), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 215), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 225), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 236), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 237), (188, 0, 0), (189, 0, 0), (193, 0, 0), (196, 0, 0), (200, 0, 0), (203, 0, 0), (209, 0, 0), (216, 0, 0), (224, 0, 0), (238, 0, 0), # Node 181 (1, HUFFMAN_EMIT_SYMBOL, 171), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 171), (1, HUFFMAN_EMIT_SYMBOL, 206), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 206), (1, HUFFMAN_EMIT_SYMBOL, 215), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 215), (1, HUFFMAN_EMIT_SYMBOL, 225), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 225), (1, HUFFMAN_EMIT_SYMBOL, 236), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 236), (1, HUFFMAN_EMIT_SYMBOL, 237), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 237), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 199), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 207), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 234), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 235), # Node 182 (2, HUFFMAN_EMIT_SYMBOL, 171), (9, HUFFMAN_EMIT_SYMBOL, 171), (23, HUFFMAN_EMIT_SYMBOL, 171), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 171), (2, HUFFMAN_EMIT_SYMBOL, 206), (9, HUFFMAN_EMIT_SYMBOL, 206), (23, HUFFMAN_EMIT_SYMBOL, 206), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 206), (2, HUFFMAN_EMIT_SYMBOL, 215), (9, HUFFMAN_EMIT_SYMBOL, 215), (23, HUFFMAN_EMIT_SYMBOL, 215), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 215), (2, HUFFMAN_EMIT_SYMBOL, 225), (9, HUFFMAN_EMIT_SYMBOL, 225), (23, HUFFMAN_EMIT_SYMBOL, 225), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 225), # Node 183 (3, HUFFMAN_EMIT_SYMBOL, 171), (6, HUFFMAN_EMIT_SYMBOL, 171), (10, HUFFMAN_EMIT_SYMBOL, 171), (15, HUFFMAN_EMIT_SYMBOL, 171), (24, HUFFMAN_EMIT_SYMBOL, 171), (31, HUFFMAN_EMIT_SYMBOL, 171), (41, HUFFMAN_EMIT_SYMBOL, 171), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 171), (3, HUFFMAN_EMIT_SYMBOL, 206), (6, HUFFMAN_EMIT_SYMBOL, 206), (10, HUFFMAN_EMIT_SYMBOL, 206), (15, HUFFMAN_EMIT_SYMBOL, 206), (24, HUFFMAN_EMIT_SYMBOL, 206), (31, HUFFMAN_EMIT_SYMBOL, 206), (41, HUFFMAN_EMIT_SYMBOL, 206), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 206), # Node 184 (3, HUFFMAN_EMIT_SYMBOL, 215), (6, HUFFMAN_EMIT_SYMBOL, 215), (10, HUFFMAN_EMIT_SYMBOL, 215), (15, HUFFMAN_EMIT_SYMBOL, 215), (24, HUFFMAN_EMIT_SYMBOL, 215), (31, HUFFMAN_EMIT_SYMBOL, 215), (41, HUFFMAN_EMIT_SYMBOL, 215), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 215), (3, HUFFMAN_EMIT_SYMBOL, 225), (6, HUFFMAN_EMIT_SYMBOL, 225), (10, HUFFMAN_EMIT_SYMBOL, 225), (15, HUFFMAN_EMIT_SYMBOL, 225), (24, HUFFMAN_EMIT_SYMBOL, 225), (31, HUFFMAN_EMIT_SYMBOL, 225), (41, HUFFMAN_EMIT_SYMBOL, 225), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 225), # Node 185 (2, HUFFMAN_EMIT_SYMBOL, 236), (9, HUFFMAN_EMIT_SYMBOL, 236), (23, HUFFMAN_EMIT_SYMBOL, 236), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 236), (2, HUFFMAN_EMIT_SYMBOL, 237), (9, HUFFMAN_EMIT_SYMBOL, 237), (23, HUFFMAN_EMIT_SYMBOL, 237), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 237), (1, HUFFMAN_EMIT_SYMBOL, 199), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 199), (1, HUFFMAN_EMIT_SYMBOL, 207), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 207), (1, HUFFMAN_EMIT_SYMBOL, 234), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 234), (1, HUFFMAN_EMIT_SYMBOL, 235), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 235), # Node 186 (3, HUFFMAN_EMIT_SYMBOL, 236), (6, HUFFMAN_EMIT_SYMBOL, 236), (10, HUFFMAN_EMIT_SYMBOL, 236), (15, HUFFMAN_EMIT_SYMBOL, 236), (24, HUFFMAN_EMIT_SYMBOL, 236), (31, HUFFMAN_EMIT_SYMBOL, 236), (41, HUFFMAN_EMIT_SYMBOL, 236), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 236), (3, HUFFMAN_EMIT_SYMBOL, 237), (6, HUFFMAN_EMIT_SYMBOL, 237), (10, HUFFMAN_EMIT_SYMBOL, 237), (15, HUFFMAN_EMIT_SYMBOL, 237), (24, HUFFMAN_EMIT_SYMBOL, 237), (31, HUFFMAN_EMIT_SYMBOL, 237), (41, HUFFMAN_EMIT_SYMBOL, 237), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 237), # Node 187 (2, HUFFMAN_EMIT_SYMBOL, 199), (9, HUFFMAN_EMIT_SYMBOL, 199), (23, HUFFMAN_EMIT_SYMBOL, 199), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 199), (2, HUFFMAN_EMIT_SYMBOL, 207), (9, HUFFMAN_EMIT_SYMBOL, 207), (23, HUFFMAN_EMIT_SYMBOL, 207), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 207), (2, HUFFMAN_EMIT_SYMBOL, 234), (9, HUFFMAN_EMIT_SYMBOL, 234), (23, HUFFMAN_EMIT_SYMBOL, 234), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 234), (2, HUFFMAN_EMIT_SYMBOL, 235), (9, HUFFMAN_EMIT_SYMBOL, 235), (23, HUFFMAN_EMIT_SYMBOL, 235), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 235), # Node 188 (3, HUFFMAN_EMIT_SYMBOL, 199), (6, HUFFMAN_EMIT_SYMBOL, 199), (10, HUFFMAN_EMIT_SYMBOL, 199), (15, HUFFMAN_EMIT_SYMBOL, 199), (24, HUFFMAN_EMIT_SYMBOL, 199), (31, HUFFMAN_EMIT_SYMBOL, 199), (41, HUFFMAN_EMIT_SYMBOL, 199), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 199), (3, HUFFMAN_EMIT_SYMBOL, 207), (6, HUFFMAN_EMIT_SYMBOL, 207), (10, HUFFMAN_EMIT_SYMBOL, 207), (15, HUFFMAN_EMIT_SYMBOL, 207), (24, HUFFMAN_EMIT_SYMBOL, 207), (31, HUFFMAN_EMIT_SYMBOL, 207), (41, HUFFMAN_EMIT_SYMBOL, 207), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 207), # Node 189 (3, HUFFMAN_EMIT_SYMBOL, 234), (6, HUFFMAN_EMIT_SYMBOL, 234), (10, HUFFMAN_EMIT_SYMBOL, 234), (15, HUFFMAN_EMIT_SYMBOL, 234), (24, HUFFMAN_EMIT_SYMBOL, 234), (31, HUFFMAN_EMIT_SYMBOL, 234), (41, HUFFMAN_EMIT_SYMBOL, 234), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 234), (3, HUFFMAN_EMIT_SYMBOL, 235), (6, HUFFMAN_EMIT_SYMBOL, 235), (10, HUFFMAN_EMIT_SYMBOL, 235), (15, HUFFMAN_EMIT_SYMBOL, 235), (24, HUFFMAN_EMIT_SYMBOL, 235), (31, HUFFMAN_EMIT_SYMBOL, 235), (41, HUFFMAN_EMIT_SYMBOL, 235), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 235), # Node 190 (194, 0, 0), (195, 0, 0), (197, 0, 0), (198, 0, 0), (201, 0, 0), (202, 0, 0), (204, 0, 0), (205, 0, 0), (210, 0, 0), (213, 0, 0), (217, 0, 0), (220, 0, 0), (225, 0, 0), (231, 0, 0), (239, 0, 0), (246, 0, 0), # Node 191 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 192), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 193), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 200), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 201), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 202), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 205), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 210), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 213), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 218), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 219), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 238), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 240), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 242), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 243), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 255), (206, 0, 0), # Node 192 (1, HUFFMAN_EMIT_SYMBOL, 192), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 192), (1, HUFFMAN_EMIT_SYMBOL, 193), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 193), (1, HUFFMAN_EMIT_SYMBOL, 200), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 200), (1, HUFFMAN_EMIT_SYMBOL, 201), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 201), (1, HUFFMAN_EMIT_SYMBOL, 202), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 202), (1, HUFFMAN_EMIT_SYMBOL, 205), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 205), (1, HUFFMAN_EMIT_SYMBOL, 210), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 210), (1, HUFFMAN_EMIT_SYMBOL, 213), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 213), # Node 193 (2, HUFFMAN_EMIT_SYMBOL, 192), (9, HUFFMAN_EMIT_SYMBOL, 192), (23, HUFFMAN_EMIT_SYMBOL, 192), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 192), (2, HUFFMAN_EMIT_SYMBOL, 193), (9, HUFFMAN_EMIT_SYMBOL, 193), (23, HUFFMAN_EMIT_SYMBOL, 193), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 193), (2, HUFFMAN_EMIT_SYMBOL, 200), (9, HUFFMAN_EMIT_SYMBOL, 200), (23, HUFFMAN_EMIT_SYMBOL, 200), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 200), (2, HUFFMAN_EMIT_SYMBOL, 201), (9, HUFFMAN_EMIT_SYMBOL, 201), (23, HUFFMAN_EMIT_SYMBOL, 201), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 201), # Node 194 (3, HUFFMAN_EMIT_SYMBOL, 192), (6, HUFFMAN_EMIT_SYMBOL, 192), (10, HUFFMAN_EMIT_SYMBOL, 192), (15, HUFFMAN_EMIT_SYMBOL, 192), (24, HUFFMAN_EMIT_SYMBOL, 192), (31, HUFFMAN_EMIT_SYMBOL, 192), (41, HUFFMAN_EMIT_SYMBOL, 192), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 192), (3, HUFFMAN_EMIT_SYMBOL, 193), (6, HUFFMAN_EMIT_SYMBOL, 193), (10, HUFFMAN_EMIT_SYMBOL, 193), (15, HUFFMAN_EMIT_SYMBOL, 193), (24, HUFFMAN_EMIT_SYMBOL, 193), (31, HUFFMAN_EMIT_SYMBOL, 193), (41, HUFFMAN_EMIT_SYMBOL, 193), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 193), # Node 195 (3, HUFFMAN_EMIT_SYMBOL, 200), (6, HUFFMAN_EMIT_SYMBOL, 200), (10, HUFFMAN_EMIT_SYMBOL, 200), (15, HUFFMAN_EMIT_SYMBOL, 200), (24, HUFFMAN_EMIT_SYMBOL, 200), (31, HUFFMAN_EMIT_SYMBOL, 200), (41, HUFFMAN_EMIT_SYMBOL, 200), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 200), (3, HUFFMAN_EMIT_SYMBOL, 201), (6, HUFFMAN_EMIT_SYMBOL, 201), (10, HUFFMAN_EMIT_SYMBOL, 201), (15, HUFFMAN_EMIT_SYMBOL, 201), (24, HUFFMAN_EMIT_SYMBOL, 201), (31, HUFFMAN_EMIT_SYMBOL, 201), (41, HUFFMAN_EMIT_SYMBOL, 201), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 201), # Node 196 (2, HUFFMAN_EMIT_SYMBOL, 202), (9, HUFFMAN_EMIT_SYMBOL, 202), (23, HUFFMAN_EMIT_SYMBOL, 202), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 202), (2, HUFFMAN_EMIT_SYMBOL, 205), (9, HUFFMAN_EMIT_SYMBOL, 205), (23, HUFFMAN_EMIT_SYMBOL, 205), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 205), (2, HUFFMAN_EMIT_SYMBOL, 210), (9, HUFFMAN_EMIT_SYMBOL, 210), (23, HUFFMAN_EMIT_SYMBOL, 210), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 210), (2, HUFFMAN_EMIT_SYMBOL, 213), (9, HUFFMAN_EMIT_SYMBOL, 213), (23, HUFFMAN_EMIT_SYMBOL, 213), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 213), # Node 197 (3, HUFFMAN_EMIT_SYMBOL, 202), (6, HUFFMAN_EMIT_SYMBOL, 202), (10, HUFFMAN_EMIT_SYMBOL, 202), (15, HUFFMAN_EMIT_SYMBOL, 202), (24, HUFFMAN_EMIT_SYMBOL, 202), (31, HUFFMAN_EMIT_SYMBOL, 202), (41, HUFFMAN_EMIT_SYMBOL, 202), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 202), (3, HUFFMAN_EMIT_SYMBOL, 205), (6, HUFFMAN_EMIT_SYMBOL, 205), (10, HUFFMAN_EMIT_SYMBOL, 205), (15, HUFFMAN_EMIT_SYMBOL, 205), (24, HUFFMAN_EMIT_SYMBOL, 205), (31, HUFFMAN_EMIT_SYMBOL, 205), (41, HUFFMAN_EMIT_SYMBOL, 205), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 205), # Node 198 (3, HUFFMAN_EMIT_SYMBOL, 210), (6, HUFFMAN_EMIT_SYMBOL, 210), (10, HUFFMAN_EMIT_SYMBOL, 210), (15, HUFFMAN_EMIT_SYMBOL, 210), (24, HUFFMAN_EMIT_SYMBOL, 210), (31, HUFFMAN_EMIT_SYMBOL, 210), (41, HUFFMAN_EMIT_SYMBOL, 210), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 210), (3, HUFFMAN_EMIT_SYMBOL, 213), (6, HUFFMAN_EMIT_SYMBOL, 213), (10, HUFFMAN_EMIT_SYMBOL, 213), (15, HUFFMAN_EMIT_SYMBOL, 213), (24, HUFFMAN_EMIT_SYMBOL, 213), (31, HUFFMAN_EMIT_SYMBOL, 213), (41, HUFFMAN_EMIT_SYMBOL, 213), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 213), # Node 199 (1, HUFFMAN_EMIT_SYMBOL, 218), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 218), (1, HUFFMAN_EMIT_SYMBOL, 219), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 219), (1, HUFFMAN_EMIT_SYMBOL, 238), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 238), (1, HUFFMAN_EMIT_SYMBOL, 240), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 240), (1, HUFFMAN_EMIT_SYMBOL, 242), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 242), (1, HUFFMAN_EMIT_SYMBOL, 243), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 243), (1, HUFFMAN_EMIT_SYMBOL, 255), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 255), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 203), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 204), # Node 200 (2, HUFFMAN_EMIT_SYMBOL, 218), (9, HUFFMAN_EMIT_SYMBOL, 218), (23, HUFFMAN_EMIT_SYMBOL, 218), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 218), (2, HUFFMAN_EMIT_SYMBOL, 219), (9, HUFFMAN_EMIT_SYMBOL, 219), (23, HUFFMAN_EMIT_SYMBOL, 219), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 219), (2, HUFFMAN_EMIT_SYMBOL, 238), (9, HUFFMAN_EMIT_SYMBOL, 238), (23, HUFFMAN_EMIT_SYMBOL, 238), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 238), (2, HUFFMAN_EMIT_SYMBOL, 240), (9, HUFFMAN_EMIT_SYMBOL, 240), (23, HUFFMAN_EMIT_SYMBOL, 240), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 240), # Node 201 (3, HUFFMAN_EMIT_SYMBOL, 218), (6, HUFFMAN_EMIT_SYMBOL, 218), (10, HUFFMAN_EMIT_SYMBOL, 218), (15, HUFFMAN_EMIT_SYMBOL, 218), (24, HUFFMAN_EMIT_SYMBOL, 218), (31, HUFFMAN_EMIT_SYMBOL, 218), (41, HUFFMAN_EMIT_SYMBOL, 218), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 218), (3, HUFFMAN_EMIT_SYMBOL, 219), (6, HUFFMAN_EMIT_SYMBOL, 219), (10, HUFFMAN_EMIT_SYMBOL, 219), (15, HUFFMAN_EMIT_SYMBOL, 219), (24, HUFFMAN_EMIT_SYMBOL, 219), (31, HUFFMAN_EMIT_SYMBOL, 219), (41, HUFFMAN_EMIT_SYMBOL, 219), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 219), # Node 202 (3, HUFFMAN_EMIT_SYMBOL, 238), (6, HUFFMAN_EMIT_SYMBOL, 238), (10, HUFFMAN_EMIT_SYMBOL, 238), (15, HUFFMAN_EMIT_SYMBOL, 238), (24, HUFFMAN_EMIT_SYMBOL, 238), (31, HUFFMAN_EMIT_SYMBOL, 238), (41, HUFFMAN_EMIT_SYMBOL, 238), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 238), (3, HUFFMAN_EMIT_SYMBOL, 240), (6, HUFFMAN_EMIT_SYMBOL, 240), (10, HUFFMAN_EMIT_SYMBOL, 240), (15, HUFFMAN_EMIT_SYMBOL, 240), (24, HUFFMAN_EMIT_SYMBOL, 240), (31, HUFFMAN_EMIT_SYMBOL, 240), (41, HUFFMAN_EMIT_SYMBOL, 240), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 240), # Node 203 (2, HUFFMAN_EMIT_SYMBOL, 242), (9, HUFFMAN_EMIT_SYMBOL, 242), (23, HUFFMAN_EMIT_SYMBOL, 242), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 242), (2, HUFFMAN_EMIT_SYMBOL, 243), (9, HUFFMAN_EMIT_SYMBOL, 243), (23, HUFFMAN_EMIT_SYMBOL, 243), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 243), (2, HUFFMAN_EMIT_SYMBOL, 255), (9, HUFFMAN_EMIT_SYMBOL, 255), (23, HUFFMAN_EMIT_SYMBOL, 255), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 255), (1, HUFFMAN_EMIT_SYMBOL, 203), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 203), (1, HUFFMAN_EMIT_SYMBOL, 204), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 204), # Node 204 (3, HUFFMAN_EMIT_SYMBOL, 242), (6, HUFFMAN_EMIT_SYMBOL, 242), (10, HUFFMAN_EMIT_SYMBOL, 242), (15, HUFFMAN_EMIT_SYMBOL, 242), (24, HUFFMAN_EMIT_SYMBOL, 242), (31, HUFFMAN_EMIT_SYMBOL, 242), (41, HUFFMAN_EMIT_SYMBOL, 242), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 242), (3, HUFFMAN_EMIT_SYMBOL, 243), (6, HUFFMAN_EMIT_SYMBOL, 243), (10, HUFFMAN_EMIT_SYMBOL, 243), (15, HUFFMAN_EMIT_SYMBOL, 243), (24, HUFFMAN_EMIT_SYMBOL, 243), (31, HUFFMAN_EMIT_SYMBOL, 243), (41, HUFFMAN_EMIT_SYMBOL, 243), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 243), # Node 205 (3, HUFFMAN_EMIT_SYMBOL, 255), (6, HUFFMAN_EMIT_SYMBOL, 255), (10, HUFFMAN_EMIT_SYMBOL, 255), (15, HUFFMAN_EMIT_SYMBOL, 255), (24, HUFFMAN_EMIT_SYMBOL, 255), (31, HUFFMAN_EMIT_SYMBOL, 255), (41, HUFFMAN_EMIT_SYMBOL, 255), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 255), (2, HUFFMAN_EMIT_SYMBOL, 203), (9, HUFFMAN_EMIT_SYMBOL, 203), (23, HUFFMAN_EMIT_SYMBOL, 203), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 203), (2, HUFFMAN_EMIT_SYMBOL, 204), (9, HUFFMAN_EMIT_SYMBOL, 204), (23, HUFFMAN_EMIT_SYMBOL, 204), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 204), # Node 206 (3, HUFFMAN_EMIT_SYMBOL, 203), (6, HUFFMAN_EMIT_SYMBOL, 203), (10, HUFFMAN_EMIT_SYMBOL, 203), (15, HUFFMAN_EMIT_SYMBOL, 203), (24, HUFFMAN_EMIT_SYMBOL, 203), (31, HUFFMAN_EMIT_SYMBOL, 203), (41, HUFFMAN_EMIT_SYMBOL, 203), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 203), (3, HUFFMAN_EMIT_SYMBOL, 204), (6, HUFFMAN_EMIT_SYMBOL, 204), (10, HUFFMAN_EMIT_SYMBOL, 204), (15, HUFFMAN_EMIT_SYMBOL, 204), (24, HUFFMAN_EMIT_SYMBOL, 204), (31, HUFFMAN_EMIT_SYMBOL, 204), (41, HUFFMAN_EMIT_SYMBOL, 204), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 204), # Node 207 (211, 0, 0), (212, 0, 0), (214, 0, 0), (215, 0, 0), (218, 0, 0), (219, 0, 0), (221, 0, 0), (222, 0, 0), (226, 0, 0), (228, 0, 0), (232, 0, 0), (235, 0, 0), (240, 0, 0), (243, 0, 0), (247, 0, 0), (250, 0, 0), # Node 208 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 211), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 212), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 214), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 221), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 222), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 223), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 241), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 244), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 245), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 246), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 247), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 248), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 250), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 251), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 252), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 253), # Node 209 (1, HUFFMAN_EMIT_SYMBOL, 211), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 211), (1, HUFFMAN_EMIT_SYMBOL, 212), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 212), (1, HUFFMAN_EMIT_SYMBOL, 214), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 214), (1, HUFFMAN_EMIT_SYMBOL, 221), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 221), (1, HUFFMAN_EMIT_SYMBOL, 222), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 222), (1, HUFFMAN_EMIT_SYMBOL, 223), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 223), (1, HUFFMAN_EMIT_SYMBOL, 241), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 241), (1, HUFFMAN_EMIT_SYMBOL, 244), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 244), # Node 210 (2, HUFFMAN_EMIT_SYMBOL, 211), (9, HUFFMAN_EMIT_SYMBOL, 211), (23, HUFFMAN_EMIT_SYMBOL, 211), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 211), (2, HUFFMAN_EMIT_SYMBOL, 212), (9, HUFFMAN_EMIT_SYMBOL, 212), (23, HUFFMAN_EMIT_SYMBOL, 212), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 212), (2, HUFFMAN_EMIT_SYMBOL, 214), (9, HUFFMAN_EMIT_SYMBOL, 214), (23, HUFFMAN_EMIT_SYMBOL, 214), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 214), (2, HUFFMAN_EMIT_SYMBOL, 221), (9, HUFFMAN_EMIT_SYMBOL, 221), (23, HUFFMAN_EMIT_SYMBOL, 221), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 221), # Node 211 (3, HUFFMAN_EMIT_SYMBOL, 211), (6, HUFFMAN_EMIT_SYMBOL, 211), (10, HUFFMAN_EMIT_SYMBOL, 211), (15, HUFFMAN_EMIT_SYMBOL, 211), (24, HUFFMAN_EMIT_SYMBOL, 211), (31, HUFFMAN_EMIT_SYMBOL, 211), (41, HUFFMAN_EMIT_SYMBOL, 211), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 211), (3, HUFFMAN_EMIT_SYMBOL, 212), (6, HUFFMAN_EMIT_SYMBOL, 212), (10, HUFFMAN_EMIT_SYMBOL, 212), (15, HUFFMAN_EMIT_SYMBOL, 212), (24, HUFFMAN_EMIT_SYMBOL, 212), (31, HUFFMAN_EMIT_SYMBOL, 212), (41, HUFFMAN_EMIT_SYMBOL, 212), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 212), # Node 212 (3, HUFFMAN_EMIT_SYMBOL, 214), (6, HUFFMAN_EMIT_SYMBOL, 214), (10, HUFFMAN_EMIT_SYMBOL, 214), (15, HUFFMAN_EMIT_SYMBOL, 214), (24, HUFFMAN_EMIT_SYMBOL, 214), (31, HUFFMAN_EMIT_SYMBOL, 214), (41, HUFFMAN_EMIT_SYMBOL, 214), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 214), (3, HUFFMAN_EMIT_SYMBOL, 221), (6, HUFFMAN_EMIT_SYMBOL, 221), (10, HUFFMAN_EMIT_SYMBOL, 221), (15, HUFFMAN_EMIT_SYMBOL, 221), (24, HUFFMAN_EMIT_SYMBOL, 221), (31, HUFFMAN_EMIT_SYMBOL, 221), (41, HUFFMAN_EMIT_SYMBOL, 221), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 221), # Node 213 (2, HUFFMAN_EMIT_SYMBOL, 222), (9, HUFFMAN_EMIT_SYMBOL, 222), (23, HUFFMAN_EMIT_SYMBOL, 222), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 222), (2, HUFFMAN_EMIT_SYMBOL, 223), (9, HUFFMAN_EMIT_SYMBOL, 223), (23, HUFFMAN_EMIT_SYMBOL, 223), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 223), (2, HUFFMAN_EMIT_SYMBOL, 241), (9, HUFFMAN_EMIT_SYMBOL, 241), (23, HUFFMAN_EMIT_SYMBOL, 241), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 241), (2, HUFFMAN_EMIT_SYMBOL, 244), (9, HUFFMAN_EMIT_SYMBOL, 244), (23, HUFFMAN_EMIT_SYMBOL, 244), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 244), # Node 214 (3, HUFFMAN_EMIT_SYMBOL, 222), (6, HUFFMAN_EMIT_SYMBOL, 222), (10, HUFFMAN_EMIT_SYMBOL, 222), (15, HUFFMAN_EMIT_SYMBOL, 222), (24, HUFFMAN_EMIT_SYMBOL, 222), (31, HUFFMAN_EMIT_SYMBOL, 222), (41, HUFFMAN_EMIT_SYMBOL, 222), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 222), (3, HUFFMAN_EMIT_SYMBOL, 223), (6, HUFFMAN_EMIT_SYMBOL, 223), (10, HUFFMAN_EMIT_SYMBOL, 223), (15, HUFFMAN_EMIT_SYMBOL, 223), (24, HUFFMAN_EMIT_SYMBOL, 223), (31, HUFFMAN_EMIT_SYMBOL, 223), (41, HUFFMAN_EMIT_SYMBOL, 223), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 223), # Node 215 (3, HUFFMAN_EMIT_SYMBOL, 241), (6, HUFFMAN_EMIT_SYMBOL, 241), (10, HUFFMAN_EMIT_SYMBOL, 241), (15, HUFFMAN_EMIT_SYMBOL, 241), (24, HUFFMAN_EMIT_SYMBOL, 241), (31, HUFFMAN_EMIT_SYMBOL, 241), (41, HUFFMAN_EMIT_SYMBOL, 241), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 241), (3, HUFFMAN_EMIT_SYMBOL, 244), (6, HUFFMAN_EMIT_SYMBOL, 244), (10, HUFFMAN_EMIT_SYMBOL, 244), (15, HUFFMAN_EMIT_SYMBOL, 244), (24, HUFFMAN_EMIT_SYMBOL, 244), (31, HUFFMAN_EMIT_SYMBOL, 244), (41, HUFFMAN_EMIT_SYMBOL, 244), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 244), # Node 216 (1, HUFFMAN_EMIT_SYMBOL, 245), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 245), (1, HUFFMAN_EMIT_SYMBOL, 246), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 246), (1, HUFFMAN_EMIT_SYMBOL, 247), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 247), (1, HUFFMAN_EMIT_SYMBOL, 248), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 248), (1, HUFFMAN_EMIT_SYMBOL, 250), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 250), (1, HUFFMAN_EMIT_SYMBOL, 251), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 251), (1, HUFFMAN_EMIT_SYMBOL, 252), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 252), (1, HUFFMAN_EMIT_SYMBOL, 253), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 253), # Node 217 (2, HUFFMAN_EMIT_SYMBOL, 245), (9, HUFFMAN_EMIT_SYMBOL, 245), (23, HUFFMAN_EMIT_SYMBOL, 245), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 245), (2, HUFFMAN_EMIT_SYMBOL, 246), (9, HUFFMAN_EMIT_SYMBOL, 246), (23, HUFFMAN_EMIT_SYMBOL, 246), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 246), (2, HUFFMAN_EMIT_SYMBOL, 247), (9, HUFFMAN_EMIT_SYMBOL, 247), (23, HUFFMAN_EMIT_SYMBOL, 247), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 247), (2, HUFFMAN_EMIT_SYMBOL, 248), (9, HUFFMAN_EMIT_SYMBOL, 248), (23, HUFFMAN_EMIT_SYMBOL, 248), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 248), # Node 218 (3, HUFFMAN_EMIT_SYMBOL, 245), (6, HUFFMAN_EMIT_SYMBOL, 245), (10, HUFFMAN_EMIT_SYMBOL, 245), (15, HUFFMAN_EMIT_SYMBOL, 245), (24, HUFFMAN_EMIT_SYMBOL, 245), (31, HUFFMAN_EMIT_SYMBOL, 245), (41, HUFFMAN_EMIT_SYMBOL, 245), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 245), (3, HUFFMAN_EMIT_SYMBOL, 246), (6, HUFFMAN_EMIT_SYMBOL, 246), (10, HUFFMAN_EMIT_SYMBOL, 246), (15, HUFFMAN_EMIT_SYMBOL, 246), (24, HUFFMAN_EMIT_SYMBOL, 246), (31, HUFFMAN_EMIT_SYMBOL, 246), (41, HUFFMAN_EMIT_SYMBOL, 246), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 246), # Node 219 (3, HUFFMAN_EMIT_SYMBOL, 247), (6, HUFFMAN_EMIT_SYMBOL, 247), (10, HUFFMAN_EMIT_SYMBOL, 247), (15, HUFFMAN_EMIT_SYMBOL, 247), (24, HUFFMAN_EMIT_SYMBOL, 247), (31, HUFFMAN_EMIT_SYMBOL, 247), (41, HUFFMAN_EMIT_SYMBOL, 247), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 247), (3, HUFFMAN_EMIT_SYMBOL, 248), (6, HUFFMAN_EMIT_SYMBOL, 248), (10, HUFFMAN_EMIT_SYMBOL, 248), (15, HUFFMAN_EMIT_SYMBOL, 248), (24, HUFFMAN_EMIT_SYMBOL, 248), (31, HUFFMAN_EMIT_SYMBOL, 248), (41, HUFFMAN_EMIT_SYMBOL, 248), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 248), # Node 220 (2, HUFFMAN_EMIT_SYMBOL, 250), (9, HUFFMAN_EMIT_SYMBOL, 250), (23, HUFFMAN_EMIT_SYMBOL, 250), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 250), (2, HUFFMAN_EMIT_SYMBOL, 251), (9, HUFFMAN_EMIT_SYMBOL, 251), (23, HUFFMAN_EMIT_SYMBOL, 251), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 251), (2, HUFFMAN_EMIT_SYMBOL, 252), (9, HUFFMAN_EMIT_SYMBOL, 252), (23, HUFFMAN_EMIT_SYMBOL, 252), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 252), (2, HUFFMAN_EMIT_SYMBOL, 253), (9, HUFFMAN_EMIT_SYMBOL, 253), (23, HUFFMAN_EMIT_SYMBOL, 253), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 253), # Node 221 (3, HUFFMAN_EMIT_SYMBOL, 250), (6, HUFFMAN_EMIT_SYMBOL, 250), (10, HUFFMAN_EMIT_SYMBOL, 250), (15, HUFFMAN_EMIT_SYMBOL, 250), (24, HUFFMAN_EMIT_SYMBOL, 250), (31, HUFFMAN_EMIT_SYMBOL, 250), (41, HUFFMAN_EMIT_SYMBOL, 250), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 250), (3, HUFFMAN_EMIT_SYMBOL, 251), (6, HUFFMAN_EMIT_SYMBOL, 251), (10, HUFFMAN_EMIT_SYMBOL, 251), (15, HUFFMAN_EMIT_SYMBOL, 251), (24, HUFFMAN_EMIT_SYMBOL, 251), (31, HUFFMAN_EMIT_SYMBOL, 251), (41, HUFFMAN_EMIT_SYMBOL, 251), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 251), # Node 222 (3, HUFFMAN_EMIT_SYMBOL, 252), (6, HUFFMAN_EMIT_SYMBOL, 252), (10, HUFFMAN_EMIT_SYMBOL, 252), (15, HUFFMAN_EMIT_SYMBOL, 252), (24, HUFFMAN_EMIT_SYMBOL, 252), (31, HUFFMAN_EMIT_SYMBOL, 252), (41, HUFFMAN_EMIT_SYMBOL, 252), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 252), (3, HUFFMAN_EMIT_SYMBOL, 253), (6, HUFFMAN_EMIT_SYMBOL, 253), (10, HUFFMAN_EMIT_SYMBOL, 253), (15, HUFFMAN_EMIT_SYMBOL, 253), (24, HUFFMAN_EMIT_SYMBOL, 253), (31, HUFFMAN_EMIT_SYMBOL, 253), (41, HUFFMAN_EMIT_SYMBOL, 253), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 253), # Node 223 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 254), (227, 0, 0), (229, 0, 0), (230, 0, 0), (233, 0, 0), (234, 0, 0), (236, 0, 0), (237, 0, 0), (241, 0, 0), (242, 0, 0), (244, 0, 0), (245, 0, 0), (248, 0, 0), (249, 0, 0), (251, 0, 0), (252, 0, 0), # Node 224 (1, HUFFMAN_EMIT_SYMBOL, 254), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 254), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 2), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 3), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 4), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 5), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 6), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 7), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 8), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 11), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 12), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 14), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 15), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 16), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 17), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 18), # Node 225 (2, HUFFMAN_EMIT_SYMBOL, 254), (9, HUFFMAN_EMIT_SYMBOL, 254), (23, HUFFMAN_EMIT_SYMBOL, 254), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 254), (1, HUFFMAN_EMIT_SYMBOL, 2), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 2), (1, HUFFMAN_EMIT_SYMBOL, 3), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 3), (1, HUFFMAN_EMIT_SYMBOL, 4), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 4), (1, HUFFMAN_EMIT_SYMBOL, 5), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 5), (1, HUFFMAN_EMIT_SYMBOL, 6), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 6), (1, HUFFMAN_EMIT_SYMBOL, 7), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 7), # Node 226 (3, HUFFMAN_EMIT_SYMBOL, 254), (6, HUFFMAN_EMIT_SYMBOL, 254), (10, HUFFMAN_EMIT_SYMBOL, 254), (15, HUFFMAN_EMIT_SYMBOL, 254), (24, HUFFMAN_EMIT_SYMBOL, 254), (31, HUFFMAN_EMIT_SYMBOL, 254), (41, HUFFMAN_EMIT_SYMBOL, 254), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 254), (2, HUFFMAN_EMIT_SYMBOL, 2), (9, HUFFMAN_EMIT_SYMBOL, 2), (23, HUFFMAN_EMIT_SYMBOL, 2), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 2), (2, HUFFMAN_EMIT_SYMBOL, 3), (9, HUFFMAN_EMIT_SYMBOL, 3), (23, HUFFMAN_EMIT_SYMBOL, 3), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 3), # Node 227 (3, HUFFMAN_EMIT_SYMBOL, 2), (6, HUFFMAN_EMIT_SYMBOL, 2), (10, HUFFMAN_EMIT_SYMBOL, 2), (15, HUFFMAN_EMIT_SYMBOL, 2), (24, HUFFMAN_EMIT_SYMBOL, 2), (31, HUFFMAN_EMIT_SYMBOL, 2), (41, HUFFMAN_EMIT_SYMBOL, 2), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 2), (3, HUFFMAN_EMIT_SYMBOL, 3), (6, HUFFMAN_EMIT_SYMBOL, 3), (10, HUFFMAN_EMIT_SYMBOL, 3), (15, HUFFMAN_EMIT_SYMBOL, 3), (24, HUFFMAN_EMIT_SYMBOL, 3), (31, HUFFMAN_EMIT_SYMBOL, 3), (41, HUFFMAN_EMIT_SYMBOL, 3), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 3), # Node 228 (2, HUFFMAN_EMIT_SYMBOL, 4), (9, HUFFMAN_EMIT_SYMBOL, 4), (23, HUFFMAN_EMIT_SYMBOL, 4), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 4), (2, HUFFMAN_EMIT_SYMBOL, 5), (9, HUFFMAN_EMIT_SYMBOL, 5), (23, HUFFMAN_EMIT_SYMBOL, 5), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 5), (2, HUFFMAN_EMIT_SYMBOL, 6), (9, HUFFMAN_EMIT_SYMBOL, 6), (23, HUFFMAN_EMIT_SYMBOL, 6), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 6), (2, HUFFMAN_EMIT_SYMBOL, 7), (9, HUFFMAN_EMIT_SYMBOL, 7), (23, HUFFMAN_EMIT_SYMBOL, 7), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 7), # Node 229 (3, HUFFMAN_EMIT_SYMBOL, 4), (6, HUFFMAN_EMIT_SYMBOL, 4), (10, HUFFMAN_EMIT_SYMBOL, 4), (15, HUFFMAN_EMIT_SYMBOL, 4), (24, HUFFMAN_EMIT_SYMBOL, 4), (31, HUFFMAN_EMIT_SYMBOL, 4), (41, HUFFMAN_EMIT_SYMBOL, 4), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 4), (3, HUFFMAN_EMIT_SYMBOL, 5), (6, HUFFMAN_EMIT_SYMBOL, 5), (10, HUFFMAN_EMIT_SYMBOL, 5), (15, HUFFMAN_EMIT_SYMBOL, 5), (24, HUFFMAN_EMIT_SYMBOL, 5), (31, HUFFMAN_EMIT_SYMBOL, 5), (41, HUFFMAN_EMIT_SYMBOL, 5), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 5), # Node 230 (3, HUFFMAN_EMIT_SYMBOL, 6), (6, HUFFMAN_EMIT_SYMBOL, 6), (10, HUFFMAN_EMIT_SYMBOL, 6), (15, HUFFMAN_EMIT_SYMBOL, 6), (24, HUFFMAN_EMIT_SYMBOL, 6), (31, HUFFMAN_EMIT_SYMBOL, 6), (41, HUFFMAN_EMIT_SYMBOL, 6), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 6), (3, HUFFMAN_EMIT_SYMBOL, 7), (6, HUFFMAN_EMIT_SYMBOL, 7), (10, HUFFMAN_EMIT_SYMBOL, 7), (15, HUFFMAN_EMIT_SYMBOL, 7), (24, HUFFMAN_EMIT_SYMBOL, 7), (31, HUFFMAN_EMIT_SYMBOL, 7), (41, HUFFMAN_EMIT_SYMBOL, 7), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 7), # Node 231 (1, HUFFMAN_EMIT_SYMBOL, 8), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 8), (1, HUFFMAN_EMIT_SYMBOL, 11), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 11), (1, HUFFMAN_EMIT_SYMBOL, 12), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 12), (1, HUFFMAN_EMIT_SYMBOL, 14), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 14), (1, HUFFMAN_EMIT_SYMBOL, 15), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 15), (1, HUFFMAN_EMIT_SYMBOL, 16), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 16), (1, HUFFMAN_EMIT_SYMBOL, 17), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 17), (1, HUFFMAN_EMIT_SYMBOL, 18), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 18), # Node 232 (2, HUFFMAN_EMIT_SYMBOL, 8), (9, HUFFMAN_EMIT_SYMBOL, 8), (23, HUFFMAN_EMIT_SYMBOL, 8), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 8), (2, HUFFMAN_EMIT_SYMBOL, 11), (9, HUFFMAN_EMIT_SYMBOL, 11), (23, HUFFMAN_EMIT_SYMBOL, 11), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 11), (2, HUFFMAN_EMIT_SYMBOL, 12), (9, HUFFMAN_EMIT_SYMBOL, 12), (23, HUFFMAN_EMIT_SYMBOL, 12), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 12), (2, HUFFMAN_EMIT_SYMBOL, 14), (9, HUFFMAN_EMIT_SYMBOL, 14), (23, HUFFMAN_EMIT_SYMBOL, 14), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 14), # Node 233 (3, HUFFMAN_EMIT_SYMBOL, 8), (6, HUFFMAN_EMIT_SYMBOL, 8), (10, HUFFMAN_EMIT_SYMBOL, 8), (15, HUFFMAN_EMIT_SYMBOL, 8), (24, HUFFMAN_EMIT_SYMBOL, 8), (31, HUFFMAN_EMIT_SYMBOL, 8), (41, HUFFMAN_EMIT_SYMBOL, 8), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 8), (3, HUFFMAN_EMIT_SYMBOL, 11), (6, HUFFMAN_EMIT_SYMBOL, 11), (10, HUFFMAN_EMIT_SYMBOL, 11), (15, HUFFMAN_EMIT_SYMBOL, 11), (24, HUFFMAN_EMIT_SYMBOL, 11), (31, HUFFMAN_EMIT_SYMBOL, 11), (41, HUFFMAN_EMIT_SYMBOL, 11), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 11), # Node 234 (3, HUFFMAN_EMIT_SYMBOL, 12), (6, HUFFMAN_EMIT_SYMBOL, 12), (10, HUFFMAN_EMIT_SYMBOL, 12), (15, HUFFMAN_EMIT_SYMBOL, 12), (24, HUFFMAN_EMIT_SYMBOL, 12), (31, HUFFMAN_EMIT_SYMBOL, 12), (41, HUFFMAN_EMIT_SYMBOL, 12), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 12), (3, HUFFMAN_EMIT_SYMBOL, 14), (6, HUFFMAN_EMIT_SYMBOL, 14), (10, HUFFMAN_EMIT_SYMBOL, 14), (15, HUFFMAN_EMIT_SYMBOL, 14), (24, HUFFMAN_EMIT_SYMBOL, 14), (31, HUFFMAN_EMIT_SYMBOL, 14), (41, HUFFMAN_EMIT_SYMBOL, 14), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 14), # Node 235 (2, HUFFMAN_EMIT_SYMBOL, 15), (9, HUFFMAN_EMIT_SYMBOL, 15), (23, HUFFMAN_EMIT_SYMBOL, 15), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 15), (2, HUFFMAN_EMIT_SYMBOL, 16), (9, HUFFMAN_EMIT_SYMBOL, 16), (23, HUFFMAN_EMIT_SYMBOL, 16), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 16), (2, HUFFMAN_EMIT_SYMBOL, 17), (9, HUFFMAN_EMIT_SYMBOL, 17), (23, HUFFMAN_EMIT_SYMBOL, 17), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 17), (2, HUFFMAN_EMIT_SYMBOL, 18), (9, HUFFMAN_EMIT_SYMBOL, 18), (23, HUFFMAN_EMIT_SYMBOL, 18), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 18), # Node 236 (3, HUFFMAN_EMIT_SYMBOL, 15), (6, HUFFMAN_EMIT_SYMBOL, 15), (10, HUFFMAN_EMIT_SYMBOL, 15), (15, HUFFMAN_EMIT_SYMBOL, 15), (24, HUFFMAN_EMIT_SYMBOL, 15), (31, HUFFMAN_EMIT_SYMBOL, 15), (41, HUFFMAN_EMIT_SYMBOL, 15), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 15), (3, HUFFMAN_EMIT_SYMBOL, 16), (6, HUFFMAN_EMIT_SYMBOL, 16), (10, HUFFMAN_EMIT_SYMBOL, 16), (15, HUFFMAN_EMIT_SYMBOL, 16), (24, HUFFMAN_EMIT_SYMBOL, 16), (31, HUFFMAN_EMIT_SYMBOL, 16), (41, HUFFMAN_EMIT_SYMBOL, 16), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 16), # Node 237 (3, HUFFMAN_EMIT_SYMBOL, 17), (6, HUFFMAN_EMIT_SYMBOL, 17), (10, HUFFMAN_EMIT_SYMBOL, 17), (15, HUFFMAN_EMIT_SYMBOL, 17), (24, HUFFMAN_EMIT_SYMBOL, 17), (31, HUFFMAN_EMIT_SYMBOL, 17), (41, HUFFMAN_EMIT_SYMBOL, 17), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 17), (3, HUFFMAN_EMIT_SYMBOL, 18), (6, HUFFMAN_EMIT_SYMBOL, 18), (10, HUFFMAN_EMIT_SYMBOL, 18), (15, HUFFMAN_EMIT_SYMBOL, 18), (24, HUFFMAN_EMIT_SYMBOL, 18), (31, HUFFMAN_EMIT_SYMBOL, 18), (41, HUFFMAN_EMIT_SYMBOL, 18), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 18), # Node 238 (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 19), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 20), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 21), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 23), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 24), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 25), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 26), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 27), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 28), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 29), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 30), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 31), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 127), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 220), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 249), (253, 0, 0), # Node 239 (1, HUFFMAN_EMIT_SYMBOL, 19), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 19), (1, HUFFMAN_EMIT_SYMBOL, 20), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 20), (1, HUFFMAN_EMIT_SYMBOL, 21), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 21), (1, HUFFMAN_EMIT_SYMBOL, 23), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 23), (1, HUFFMAN_EMIT_SYMBOL, 24), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 24), (1, HUFFMAN_EMIT_SYMBOL, 25), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 25), (1, HUFFMAN_EMIT_SYMBOL, 26), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 26), (1, HUFFMAN_EMIT_SYMBOL, 27), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 27), # Node 240 (2, HUFFMAN_EMIT_SYMBOL, 19), (9, HUFFMAN_EMIT_SYMBOL, 19), (23, HUFFMAN_EMIT_SYMBOL, 19), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 19), (2, HUFFMAN_EMIT_SYMBOL, 20), (9, HUFFMAN_EMIT_SYMBOL, 20), (23, HUFFMAN_EMIT_SYMBOL, 20), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 20), (2, HUFFMAN_EMIT_SYMBOL, 21), (9, HUFFMAN_EMIT_SYMBOL, 21), (23, HUFFMAN_EMIT_SYMBOL, 21), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 21), (2, HUFFMAN_EMIT_SYMBOL, 23), (9, HUFFMAN_EMIT_SYMBOL, 23), (23, HUFFMAN_EMIT_SYMBOL, 23), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 23), # Node 241 (3, HUFFMAN_EMIT_SYMBOL, 19), (6, HUFFMAN_EMIT_SYMBOL, 19), (10, HUFFMAN_EMIT_SYMBOL, 19), (15, HUFFMAN_EMIT_SYMBOL, 19), (24, HUFFMAN_EMIT_SYMBOL, 19), (31, HUFFMAN_EMIT_SYMBOL, 19), (41, HUFFMAN_EMIT_SYMBOL, 19), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 19), (3, HUFFMAN_EMIT_SYMBOL, 20), (6, HUFFMAN_EMIT_SYMBOL, 20), (10, HUFFMAN_EMIT_SYMBOL, 20), (15, HUFFMAN_EMIT_SYMBOL, 20), (24, HUFFMAN_EMIT_SYMBOL, 20), (31, HUFFMAN_EMIT_SYMBOL, 20), (41, HUFFMAN_EMIT_SYMBOL, 20), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 20), # Node 242 (3, HUFFMAN_EMIT_SYMBOL, 21), (6, HUFFMAN_EMIT_SYMBOL, 21), (10, HUFFMAN_EMIT_SYMBOL, 21), (15, HUFFMAN_EMIT_SYMBOL, 21), (24, HUFFMAN_EMIT_SYMBOL, 21), (31, HUFFMAN_EMIT_SYMBOL, 21), (41, HUFFMAN_EMIT_SYMBOL, 21), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 21), (3, HUFFMAN_EMIT_SYMBOL, 23), (6, HUFFMAN_EMIT_SYMBOL, 23), (10, HUFFMAN_EMIT_SYMBOL, 23), (15, HUFFMAN_EMIT_SYMBOL, 23), (24, HUFFMAN_EMIT_SYMBOL, 23), (31, HUFFMAN_EMIT_SYMBOL, 23), (41, HUFFMAN_EMIT_SYMBOL, 23), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 23), # Node 243 (2, HUFFMAN_EMIT_SYMBOL, 24), (9, HUFFMAN_EMIT_SYMBOL, 24), (23, HUFFMAN_EMIT_SYMBOL, 24), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 24), (2, HUFFMAN_EMIT_SYMBOL, 25), (9, HUFFMAN_EMIT_SYMBOL, 25), (23, HUFFMAN_EMIT_SYMBOL, 25), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 25), (2, HUFFMAN_EMIT_SYMBOL, 26), (9, HUFFMAN_EMIT_SYMBOL, 26), (23, HUFFMAN_EMIT_SYMBOL, 26), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 26), (2, HUFFMAN_EMIT_SYMBOL, 27), (9, HUFFMAN_EMIT_SYMBOL, 27), (23, HUFFMAN_EMIT_SYMBOL, 27), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 27), # Node 244 (3, HUFFMAN_EMIT_SYMBOL, 24), (6, HUFFMAN_EMIT_SYMBOL, 24), (10, HUFFMAN_EMIT_SYMBOL, 24), (15, HUFFMAN_EMIT_SYMBOL, 24), (24, HUFFMAN_EMIT_SYMBOL, 24), (31, HUFFMAN_EMIT_SYMBOL, 24), (41, HUFFMAN_EMIT_SYMBOL, 24), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 24), (3, HUFFMAN_EMIT_SYMBOL, 25), (6, HUFFMAN_EMIT_SYMBOL, 25), (10, HUFFMAN_EMIT_SYMBOL, 25), (15, HUFFMAN_EMIT_SYMBOL, 25), (24, HUFFMAN_EMIT_SYMBOL, 25), (31, HUFFMAN_EMIT_SYMBOL, 25), (41, HUFFMAN_EMIT_SYMBOL, 25), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 25), # Node 245 (3, HUFFMAN_EMIT_SYMBOL, 26), (6, HUFFMAN_EMIT_SYMBOL, 26), (10, HUFFMAN_EMIT_SYMBOL, 26), (15, HUFFMAN_EMIT_SYMBOL, 26), (24, HUFFMAN_EMIT_SYMBOL, 26), (31, HUFFMAN_EMIT_SYMBOL, 26), (41, HUFFMAN_EMIT_SYMBOL, 26), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 26), (3, HUFFMAN_EMIT_SYMBOL, 27), (6, HUFFMAN_EMIT_SYMBOL, 27), (10, HUFFMAN_EMIT_SYMBOL, 27), (15, HUFFMAN_EMIT_SYMBOL, 27), (24, HUFFMAN_EMIT_SYMBOL, 27), (31, HUFFMAN_EMIT_SYMBOL, 27), (41, HUFFMAN_EMIT_SYMBOL, 27), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 27), # Node 246 (1, HUFFMAN_EMIT_SYMBOL, 28), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 28), (1, HUFFMAN_EMIT_SYMBOL, 29), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 29), (1, HUFFMAN_EMIT_SYMBOL, 30), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 30), (1, HUFFMAN_EMIT_SYMBOL, 31), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 31), (1, HUFFMAN_EMIT_SYMBOL, 127), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 127), (1, HUFFMAN_EMIT_SYMBOL, 220), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 220), (1, HUFFMAN_EMIT_SYMBOL, 249), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 249), (254, 0, 0), (255, 0, 0), # Node 247 (2, HUFFMAN_EMIT_SYMBOL, 28), (9, HUFFMAN_EMIT_SYMBOL, 28), (23, HUFFMAN_EMIT_SYMBOL, 28), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 28), (2, HUFFMAN_EMIT_SYMBOL, 29), (9, HUFFMAN_EMIT_SYMBOL, 29), (23, HUFFMAN_EMIT_SYMBOL, 29), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 29), (2, HUFFMAN_EMIT_SYMBOL, 30), (9, HUFFMAN_EMIT_SYMBOL, 30), (23, HUFFMAN_EMIT_SYMBOL, 30), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 30), (2, HUFFMAN_EMIT_SYMBOL, 31), (9, HUFFMAN_EMIT_SYMBOL, 31), (23, HUFFMAN_EMIT_SYMBOL, 31), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 31), # Node 248 (3, HUFFMAN_EMIT_SYMBOL, 28), (6, HUFFMAN_EMIT_SYMBOL, 28), (10, HUFFMAN_EMIT_SYMBOL, 28), (15, HUFFMAN_EMIT_SYMBOL, 28), (24, HUFFMAN_EMIT_SYMBOL, 28), (31, HUFFMAN_EMIT_SYMBOL, 28), (41, HUFFMAN_EMIT_SYMBOL, 28), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 28), (3, HUFFMAN_EMIT_SYMBOL, 29), (6, HUFFMAN_EMIT_SYMBOL, 29), (10, HUFFMAN_EMIT_SYMBOL, 29), (15, HUFFMAN_EMIT_SYMBOL, 29), (24, HUFFMAN_EMIT_SYMBOL, 29), (31, HUFFMAN_EMIT_SYMBOL, 29), (41, HUFFMAN_EMIT_SYMBOL, 29), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 29), # Node 249 (3, HUFFMAN_EMIT_SYMBOL, 30), (6, HUFFMAN_EMIT_SYMBOL, 30), (10, HUFFMAN_EMIT_SYMBOL, 30), (15, HUFFMAN_EMIT_SYMBOL, 30), (24, HUFFMAN_EMIT_SYMBOL, 30), (31, HUFFMAN_EMIT_SYMBOL, 30), (41, HUFFMAN_EMIT_SYMBOL, 30), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 30), (3, HUFFMAN_EMIT_SYMBOL, 31), (6, HUFFMAN_EMIT_SYMBOL, 31), (10, HUFFMAN_EMIT_SYMBOL, 31), (15, HUFFMAN_EMIT_SYMBOL, 31), (24, HUFFMAN_EMIT_SYMBOL, 31), (31, HUFFMAN_EMIT_SYMBOL, 31), (41, HUFFMAN_EMIT_SYMBOL, 31), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 31), # Node 250 (2, HUFFMAN_EMIT_SYMBOL, 127), (9, HUFFMAN_EMIT_SYMBOL, 127), (23, HUFFMAN_EMIT_SYMBOL, 127), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 127), (2, HUFFMAN_EMIT_SYMBOL, 220), (9, HUFFMAN_EMIT_SYMBOL, 220), (23, HUFFMAN_EMIT_SYMBOL, 220), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 220), (2, HUFFMAN_EMIT_SYMBOL, 249), (9, HUFFMAN_EMIT_SYMBOL, 249), (23, HUFFMAN_EMIT_SYMBOL, 249), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 249), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 10), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 13), (0, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 22), (0, HUFFMAN_FAIL, 0), # Node 251 (3, HUFFMAN_EMIT_SYMBOL, 127), (6, HUFFMAN_EMIT_SYMBOL, 127), (10, HUFFMAN_EMIT_SYMBOL, 127), (15, HUFFMAN_EMIT_SYMBOL, 127), (24, HUFFMAN_EMIT_SYMBOL, 127), (31, HUFFMAN_EMIT_SYMBOL, 127), (41, HUFFMAN_EMIT_SYMBOL, 127), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 127), (3, HUFFMAN_EMIT_SYMBOL, 220), (6, HUFFMAN_EMIT_SYMBOL, 220), (10, HUFFMAN_EMIT_SYMBOL, 220), (15, HUFFMAN_EMIT_SYMBOL, 220), (24, HUFFMAN_EMIT_SYMBOL, 220), (31, HUFFMAN_EMIT_SYMBOL, 220), (41, HUFFMAN_EMIT_SYMBOL, 220), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 220), # Node 252 (3, HUFFMAN_EMIT_SYMBOL, 249), (6, HUFFMAN_EMIT_SYMBOL, 249), (10, HUFFMAN_EMIT_SYMBOL, 249), (15, HUFFMAN_EMIT_SYMBOL, 249), (24, HUFFMAN_EMIT_SYMBOL, 249), (31, HUFFMAN_EMIT_SYMBOL, 249), (41, HUFFMAN_EMIT_SYMBOL, 249), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 249), (1, HUFFMAN_EMIT_SYMBOL, 10), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 10), (1, HUFFMAN_EMIT_SYMBOL, 13), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 13), (1, HUFFMAN_EMIT_SYMBOL, 22), (22, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 22), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), # Node 253 (2, HUFFMAN_EMIT_SYMBOL, 10), (9, HUFFMAN_EMIT_SYMBOL, 10), (23, HUFFMAN_EMIT_SYMBOL, 10), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 10), (2, HUFFMAN_EMIT_SYMBOL, 13), (9, HUFFMAN_EMIT_SYMBOL, 13), (23, HUFFMAN_EMIT_SYMBOL, 13), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 13), (2, HUFFMAN_EMIT_SYMBOL, 22), (9, HUFFMAN_EMIT_SYMBOL, 22), (23, HUFFMAN_EMIT_SYMBOL, 22), (40, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 22), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), # Node 254 (3, HUFFMAN_EMIT_SYMBOL, 10), (6, HUFFMAN_EMIT_SYMBOL, 10), (10, HUFFMAN_EMIT_SYMBOL, 10), (15, HUFFMAN_EMIT_SYMBOL, 10), (24, HUFFMAN_EMIT_SYMBOL, 10), (31, HUFFMAN_EMIT_SYMBOL, 10), (41, HUFFMAN_EMIT_SYMBOL, 10), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 10), (3, HUFFMAN_EMIT_SYMBOL, 13), (6, HUFFMAN_EMIT_SYMBOL, 13), (10, HUFFMAN_EMIT_SYMBOL, 13), (15, HUFFMAN_EMIT_SYMBOL, 13), (24, HUFFMAN_EMIT_SYMBOL, 13), (31, HUFFMAN_EMIT_SYMBOL, 13), (41, HUFFMAN_EMIT_SYMBOL, 13), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 13), # Node 255 (3, HUFFMAN_EMIT_SYMBOL, 22), (6, HUFFMAN_EMIT_SYMBOL, 22), (10, HUFFMAN_EMIT_SYMBOL, 22), (15, HUFFMAN_EMIT_SYMBOL, 22), (24, HUFFMAN_EMIT_SYMBOL, 22), (31, HUFFMAN_EMIT_SYMBOL, 22), (41, HUFFMAN_EMIT_SYMBOL, 22), (56, HUFFMAN_COMPLETE | HUFFMAN_EMIT_SYMBOL, 22), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), (0, HUFFMAN_FAIL, 0), ] ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/struct.py0000644000076500000240000000203200000000000017113 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ hpack/struct ~~~~~~~~~~~~ Contains structures for representing header fields with associated metadata. """ class HeaderTuple(tuple): """ A data structure that stores a single header field. HTTP headers can be thought of as tuples of ``(field name, field value)``. A single header block is a sequence of such tuples. In HTTP/2, however, certain bits of additional information are required for compressing these headers: in particular, whether the header field can be safely added to the HPACK compression context. This class stores a header that can be added to the compression context. In all other ways it behaves exactly like a tuple. """ __slots__ = () indexable = True def __new__(cls, *args): return tuple.__new__(cls, args) class NeverIndexedHeaderTuple(HeaderTuple): """ A data structure that stores a single header field that cannot be added to a HTTP/2 header compression context. """ __slots__ = () indexable = False ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/src/hpack/table.py0000644000076500000240000002264300000000000016670 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- # flake8: noqa from collections import deque import logging from .exceptions import InvalidTableIndex log = logging.getLogger(__name__) def table_entry_size(name, value): """ Calculates the size of a single entry This size is mostly irrelevant to us and defined specifically to accommodate memory management for lower level implementations. The 32 extra bytes are considered the "maximum" overhead that would be required to represent each entry in the table. See RFC7541 Section 4.1 """ return 32 + len(name) + len(value) class HeaderTable: """ Implements the combined static and dynamic header table The name and value arguments for all the functions should ONLY be byte strings (b'') however this is not strictly enforced in the interface. See RFC7541 Section 2.3 """ #: Default maximum size of the dynamic table. See #: RFC7540 Section 6.5.2. DEFAULT_SIZE = 4096 #: Constant list of static headers. See RFC7541 Section #: 2.3.1 and Appendix A STATIC_TABLE = ( (b':authority' , b'' ), # noqa (b':method' , b'GET' ), # noqa (b':method' , b'POST' ), # noqa (b':path' , b'/' ), # noqa (b':path' , b'/index.html' ), # noqa (b':scheme' , b'http' ), # noqa (b':scheme' , b'https' ), # noqa (b':status' , b'200' ), # noqa (b':status' , b'204' ), # noqa (b':status' , b'206' ), # noqa (b':status' , b'304' ), # noqa (b':status' , b'400' ), # noqa (b':status' , b'404' ), # noqa (b':status' , b'500' ), # noqa (b'accept-charset' , b'' ), # noqa (b'accept-encoding' , b'gzip, deflate'), # noqa (b'accept-language' , b'' ), # noqa (b'accept-ranges' , b'' ), # noqa (b'accept' , b'' ), # noqa (b'access-control-allow-origin' , b'' ), # noqa (b'age' , b'' ), # noqa (b'allow' , b'' ), # noqa (b'authorization' , b'' ), # noqa (b'cache-control' , b'' ), # noqa (b'content-disposition' , b'' ), # noqa (b'content-encoding' , b'' ), # noqa (b'content-language' , b'' ), # noqa (b'content-length' , b'' ), # noqa (b'content-location' , b'' ), # noqa (b'content-range' , b'' ), # noqa (b'content-type' , b'' ), # noqa (b'cookie' , b'' ), # noqa (b'date' , b'' ), # noqa (b'etag' , b'' ), # noqa (b'expect' , b'' ), # noqa (b'expires' , b'' ), # noqa (b'from' , b'' ), # noqa (b'host' , b'' ), # noqa (b'if-match' , b'' ), # noqa (b'if-modified-since' , b'' ), # noqa (b'if-none-match' , b'' ), # noqa (b'if-range' , b'' ), # noqa (b'if-unmodified-since' , b'' ), # noqa (b'last-modified' , b'' ), # noqa (b'link' , b'' ), # noqa (b'location' , b'' ), # noqa (b'max-forwards' , b'' ), # noqa (b'proxy-authenticate' , b'' ), # noqa (b'proxy-authorization' , b'' ), # noqa (b'range' , b'' ), # noqa (b'referer' , b'' ), # noqa (b'refresh' , b'' ), # noqa (b'retry-after' , b'' ), # noqa (b'server' , b'' ), # noqa (b'set-cookie' , b'' ), # noqa (b'strict-transport-security' , b'' ), # noqa (b'transfer-encoding' , b'' ), # noqa (b'user-agent' , b'' ), # noqa (b'vary' , b'' ), # noqa (b'via' , b'' ), # noqa (b'www-authenticate' , b'' ), # noqa ) # noqa STATIC_TABLE_LENGTH = len(STATIC_TABLE) def __init__(self): self._maxsize = HeaderTable.DEFAULT_SIZE self._current_size = 0 self.resized = False self.dynamic_entries = deque() def get_by_index(self, index): """ Returns the entry specified by index Note that the table is 1-based ie an index of 0 is invalid. This is due to the fact that a zero value index signals that a completely unindexed header follows. The entry will either be from the static table or the dynamic table depending on the value of index. """ original_index = index index -= 1 if 0 <= index: if index < HeaderTable.STATIC_TABLE_LENGTH: return HeaderTable.STATIC_TABLE[index] index -= HeaderTable.STATIC_TABLE_LENGTH if index < len(self.dynamic_entries): return self.dynamic_entries[index] raise InvalidTableIndex("Invalid table index %d" % original_index) def __repr__(self): return "HeaderTable(%d, %s, %r)" % ( self._maxsize, self.resized, self.dynamic_entries ) def add(self, name, value): """ Adds a new entry to the table We reduce the table size if the entry will make the table size greater than maxsize. """ # We just clear the table if the entry is too big size = table_entry_size(name, value) if size > self._maxsize: self.dynamic_entries.clear() self._current_size = 0 else: # Add new entry self.dynamic_entries.appendleft((name, value)) self._current_size += size self._shrink() def search(self, name, value): """ Searches the table for the entry specified by name and value Returns one of the following: - ``None``, no match at all - ``(index, name, None)`` for partial matches on name only. - ``(index, name, value)`` for perfect matches. """ partial = None header_name_search_result = HeaderTable.STATIC_TABLE_MAPPING.get(name) if header_name_search_result: index = header_name_search_result[1].get(value) if index is not None: return index, name, value else: partial = (header_name_search_result[0], name, None) offset = HeaderTable.STATIC_TABLE_LENGTH + 1 for (i, (n, v)) in enumerate(self.dynamic_entries): if n == name: if v == value: return i + offset, n, v elif partial is None: partial = (i + offset, n, None) return partial @property def maxsize(self): return self._maxsize @maxsize.setter def maxsize(self, newmax): newmax = int(newmax) log.debug("Resizing header table to %d from %d", newmax, self._maxsize) oldmax = self._maxsize self._maxsize = newmax self.resized = (newmax != oldmax) if newmax <= 0: self.dynamic_entries.clear() self._current_size = 0 elif oldmax > newmax: self._shrink() def _shrink(self): """ Shrinks the dynamic table to be at or below maxsize """ cursize = self._current_size while cursize > self._maxsize: name, value = self.dynamic_entries.pop() cursize -= table_entry_size(name, value) log.debug("Evicting %s: %s from the header table", name, value) self._current_size = cursize def _build_static_table_mapping(): """ Build static table mapping from header name to tuple with next structure: (, ). static_table_mapping used for hash searching. """ static_table_mapping = {} for index, (name, value) in enumerate(HeaderTable.STATIC_TABLE, 1): header_name_search_result = static_table_mapping.setdefault(name, (index, {})) header_name_search_result[1][value] = index return static_table_mapping HeaderTable.STATIC_TABLE_MAPPING = _build_static_table_mapping() ././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1598783094.611225 hpack-4.0.0/src/hpack.egg-info/0000755000076500000240000000000000000000000016712 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598783094.0 hpack-4.0.0/src/hpack.egg-info/PKG-INFO0000644000076500000240000000553000000000000020012 0ustar00kriechistaff00000000000000Metadata-Version: 2.1 Name: hpack Version: 4.0.0 Summary: Pure-Python HPACK header compression Home-page: https://github.com/python-hyper/hpack Author: Cory Benfield Author-email: cory@lukasa.co.uk License: MIT License Description: ======================================== hpack: HTTP/2 Header Encoding for Python ======================================== .. image:: https://github.com/python-hyper/hpack/workflows/CI/badge.svg :target: https://github.com/python-hyper/hpack/actions :alt: Build Status .. image:: https://codecov.io/gh/python-hyper/hpack/branch/master/graph/badge.svg :target: https://codecov.io/gh/python-hyper/hpack :alt: Code Coverage .. image:: https://readthedocs.org/projects/hpack/badge/?version=latest :target: https://hpack.readthedocs.io/en/latest/ :alt: Documentation Status .. image:: https://img.shields.io/badge/chat-join_now-brightgreen.svg :target: https://gitter.im/python-hyper/community :alt: Chat community .. image:: https://raw.github.com/Lukasa/hyper/development/docs/source/images/hyper.png This module contains a pure-Python HTTP/2 header encoding (HPACK) logic for use in Python programs that implement HTTP/2. Contributing ============ ``hpack`` welcomes contributions from anyone! Unlike many other projects we are happy to accept cosmetic contributions and small contributions, in addition to large feature requests and changes. Before you contribute (either by opening an issue or filing a pull request), please `read the contribution guidelines`_. .. _read the contribution guidelines: http://hyper.readthedocs.org/en/development/contributing.html License ======= ``hpack`` is made available under the MIT License. For more details, see the ``LICENSE`` file in the repository. Authors ======= ``hpack`` is maintained by Cory Benfield, with contributions from others. For more details about the contributors, please see ``CONTRIBUTORS.rst``. Platform: UNKNOWN Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3.6 Classifier: Programming Language :: Python :: 3.7 Classifier: Programming Language :: Python :: 3.8 Classifier: Programming Language :: Python :: Implementation :: CPython Classifier: Programming Language :: Python :: Implementation :: PyPy Requires-Python: >=3.6.1 Description-Content-Type: text/x-rst ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598783094.0 hpack-4.0.0/src/hpack.egg-info/SOURCES.txt0000644000076500000240000000135600000000000020603 0ustar00kriechistaff00000000000000CHANGELOG.rst CONTRIBUTORS.rst LICENSE MANIFEST.in Makefile README.rst setup.cfg setup.py tox.ini docs/Makefile docs/make.bat docs/source/api.rst docs/source/conf.py docs/source/index.rst docs/source/installation.rst docs/source/_static/.keep docs/source/security/CVE-2016-6581.rst docs/source/security/index.rst src/hpack/__init__.py src/hpack/exceptions.py src/hpack/hpack.py src/hpack/huffman.py src/hpack/huffman_constants.py src/hpack/huffman_table.py src/hpack/struct.py src/hpack/table.py src/hpack.egg-info/PKG-INFO src/hpack.egg-info/SOURCES.txt src/hpack.egg-info/dependency_links.txt src/hpack.egg-info/top_level.txt test/conftest.py test/test_encode_decode.py test/test_hpack.py test/test_huffman.py test/test_struct.py test/test_table.py././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598783094.0 hpack-4.0.0/src/hpack.egg-info/dependency_links.txt0000644000076500000240000000000100000000000022760 0ustar00kriechistaff00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1598783094.0 hpack-4.0.0/src/hpack.egg-info/top_level.txt0000644000076500000240000000000600000000000021440 0ustar00kriechistaff00000000000000hpack ././@PaxHeader0000000000000000000000000000003400000000000011452 xustar000000000000000028 mtime=1598783094.6146574 hpack-4.0.0/test/0000755000076500000240000000000000000000000014322 5ustar00kriechistaff00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1596300891.0 hpack-4.0.0/test/conftest.py0000644000076500000240000000237600000000000016531 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- import pytest import os import json import sys from hypothesis.strategies import text if sys.version_info[0] == 2: from codecs import open # We need to grab one text example from hypothesis to prime its cache. text().example() # This pair of generator expressions are pretty lame, but building lists is a # bad idea as I plan to have a substantial number of tests here. story_directories = ( os.path.join('test/test_fixtures', d) for d in os.listdir('test/test_fixtures') ) story_files = ( os.path.join(storydir, name) for storydir in story_directories for name in os.listdir(storydir) if 'raw-data' not in storydir ) raw_story_files = ( os.path.join('test/test_fixtures/raw-data', name) for name in os.listdir('test/test_fixtures/raw-data') ) @pytest.fixture(scope='class', params=story_files) def story(request): """ Provides a detailed HPACK story to test with. """ with open(request.param, 'r', encoding='utf-8') as f: return json.load(f) @pytest.fixture(scope='class', params=raw_story_files) def raw_story(request): """ Provides a detailed HPACK story to test the encoder with. """ with open(request.param, 'r', encoding='utf-8') as f: return json.load(f) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/test/test_encode_decode.py0000644000076500000240000001043700000000000020500 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ Test for the integer encoding/decoding functionality in the HPACK library. """ import pytest from hypothesis import given from hypothesis.strategies import integers, binary, one_of from hpack import HPACKDecodingError from hpack.hpack import encode_integer, decode_integer class TestIntegerEncoding: # These tests are stolen from the HPACK spec. def test_encoding_10_with_5_bit_prefix(self): val = encode_integer(10, 5) assert len(val) == 1 assert val == bytearray(b'\x0a') def test_encoding_1337_with_5_bit_prefix(self): val = encode_integer(1337, 5) assert len(val) == 3 assert val == bytearray(b'\x1f\x9a\x0a') def test_encoding_42_with_8_bit_prefix(self): val = encode_integer(42, 8) assert len(val) == 1 assert val == bytearray(b'\x2a') class TestIntegerDecoding: # These tests are stolen from the HPACK spec. def test_decoding_10_with_5_bit_prefix(self): val = decode_integer(b'\x0a', 5) assert val == (10, 1) def test_encoding_1337_with_5_bit_prefix(self): val = decode_integer(b'\x1f\x9a\x0a', 5) assert val == (1337, 3) def test_encoding_42_with_8_bit_prefix(self): val = decode_integer(b'\x2a', 8) assert val == (42, 1) def test_decode_empty_string_fails(self): with pytest.raises(HPACKDecodingError): decode_integer(b'', 8) def test_decode_insufficient_data_fails(self): with pytest.raises(HPACKDecodingError): decode_integer(b'\x1f', 5) class TestEncodingProperties: """ Property-based tests for our integer encoder and decoder. """ @given( integer=integers(min_value=0), prefix_bits=integers(min_value=1, max_value=8) ) def test_encode_positive_integer_always_valid(self, integer, prefix_bits): """ So long as the prefix bits are between 1 and 8, any positive integer can be represented. """ result = encode_integer(integer, prefix_bits) assert isinstance(result, bytearray) assert len(result) > 0 @given( integer=integers(max_value=-1), prefix_bits=integers(min_value=1, max_value=8) ) def test_encode_fails_for_negative_integers(self, integer, prefix_bits): """ If the integer to encode is negative, the encoder fails. """ with pytest.raises(ValueError): encode_integer(integer, prefix_bits) @given( integer=integers(min_value=0), prefix_bits=one_of( integers(max_value=0), integers(min_value=9) ) ) def test_encode_fails_for_invalid_prefixes(self, integer, prefix_bits): """ If the prefix is out of the range [1,8], the encoder fails. """ with pytest.raises(ValueError): encode_integer(integer, prefix_bits) @given( prefix_bits=one_of( integers(max_value=0), integers(min_value=9) ) ) def test_decode_fails_for_invalid_prefixes(self, prefix_bits): """ If the prefix is out of the range [1,8], the encoder fails. """ with pytest.raises(ValueError): decode_integer(b'\x00', prefix_bits) @given( data=binary(), prefix_bits=integers(min_value=1, max_value=8) ) def test_decode_either_succeeds_or_raises_error(self, data, prefix_bits): """ Attempting to decode data either returns a positive integer or throws a HPACKDecodingError. """ try: result, consumed = decode_integer(data, prefix_bits) except HPACKDecodingError: pass else: assert isinstance(result, int) assert result >= 0 assert consumed > 0 @given( integer=integers(min_value=0), prefix_bits=integers(min_value=1, max_value=8) ) def test_encode_decode_round_trips(self, integer, prefix_bits): """ Given valid data, the encoder and decoder can round trip. """ encoded_result = encode_integer(integer, prefix_bits) decoded_integer, consumed = decode_integer( bytes(encoded_result), prefix_bits ) assert integer == decoded_integer assert consumed > 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/test/test_hpack.py0000644000076500000240000006774400000000000017043 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- import itertools import pytest from hypothesis import given from hypothesis.strategies import text, binary, sets, one_of from hpack import ( Encoder, Decoder, HeaderTuple, NeverIndexedHeaderTuple, HPACKDecodingError, InvalidTableIndex, OversizedHeaderListError, InvalidTableSizeError, ) from hpack.hpack import _dict_to_iterable, _to_bytes class TestHPACKEncoder: # These tests are stolen entirely from the IETF specification examples. def test_literal_header_field_with_indexing(self): """ The header field representation uses a literal name and a literal value. """ e = Encoder() header_set = {'custom-key': 'custom-header'} result = b'\x40\x0acustom-key\x0dcustom-header' assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in header_set.items() ] def test_sensitive_headers(self): """ Test encoding header values """ e = Encoder() result = (b'\x82\x14\x88\x63\xa1\xa9' + b'\x32\x08\x73\xd0\xc7\x10' + b'\x87\x25\xa8\x49\xe9\xea' + b'\x5f\x5f\x89\x41\x6a\x41' + b'\x92\x6e\xe5\x35\x52\x9f') header_set = [ (':method', 'GET', True), (':path', '/jimiscool/', True), ('customkey', 'sensitiveinfo', True), ] assert e.encode(header_set, huffman=True) == result def test_non_sensitive_headers_with_header_tuples(self): """ A header field stored in a HeaderTuple emits a representation that allows indexing. """ e = Encoder() result = (b'\x82\x44\x88\x63\xa1\xa9' + b'\x32\x08\x73\xd0\xc7\x40' + b'\x87\x25\xa8\x49\xe9\xea' + b'\x5f\x5f\x89\x41\x6a\x41' + b'\x92\x6e\xe5\x35\x52\x9f') header_set = [ HeaderTuple(':method', 'GET'), HeaderTuple(':path', '/jimiscool/'), HeaderTuple('customkey', 'sensitiveinfo'), ] assert e.encode(header_set, huffman=True) == result def test_sensitive_headers_with_header_tuples(self): """ A header field stored in a NeverIndexedHeaderTuple emits a representation that forbids indexing. """ e = Encoder() result = (b'\x82\x14\x88\x63\xa1\xa9' + b'\x32\x08\x73\xd0\xc7\x10' + b'\x87\x25\xa8\x49\xe9\xea' + b'\x5f\x5f\x89\x41\x6a\x41' + b'\x92\x6e\xe5\x35\x52\x9f') header_set = [ NeverIndexedHeaderTuple(':method', 'GET'), NeverIndexedHeaderTuple(':path', '/jimiscool/'), NeverIndexedHeaderTuple('customkey', 'sensitiveinfo'), ] assert e.encode(header_set, huffman=True) == result def test_header_table_size_getter(self): e = Encoder() assert e.header_table_size == 4096 def test_indexed_literal_header_field_with_indexing(self): """ The header field representation uses an indexed name and a literal value and performs incremental indexing. """ e = Encoder() header_set = {':path': '/sample/path'} result = b'\x44\x0c/sample/path' assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in header_set.items() ] def test_indexed_header_field(self): """ The header field representation uses an indexed header field, from the static table. """ e = Encoder() header_set = {':method': 'GET'} result = b'\x82' assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == [] def test_indexed_header_field_from_static_table(self): e = Encoder() e.header_table_size = 0 header_set = {':method': 'GET'} result = b'\x82' # Make sure we don't emit an encoding context update. e.header_table.resized = False assert e.encode(header_set, huffman=False) == result assert list(e.header_table.dynamic_entries) == [] def test_request_examples_without_huffman(self): """ This section shows several consecutive header sets, corresponding to HTTP requests, on the same connection. """ e = Encoder() first_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com'), ] # We should have :authority in first_header_table since we index it first_header_table = [(':authority', 'www.example.com')] first_result = b'\x82\x86\x84\x41\x0fwww.example.com' assert e.encode(first_header_set, huffman=False) == first_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in first_header_table ] second_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com',), ('cache-control', 'no-cache'), ] second_header_table = [ ('cache-control', 'no-cache'), (':authority', 'www.example.com') ] second_result = b'\x82\x86\x84\xbeX\x08no-cache' assert e.encode(second_header_set, huffman=False) == second_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in second_header_table ] third_header_set = [ (':method', 'GET',), (':scheme', 'https',), (':path', '/index.html',), (':authority', 'www.example.com',), ('custom-key', 'custom-value'), ] third_result = ( b'\x82\x87\x85\xbf@\ncustom-key\x0ccustom-value' ) assert e.encode(third_header_set, huffman=False) == third_result # Don't check the header table here, it's just too complex to be # reliable. Check its length though. assert len(e.header_table.dynamic_entries) == 3 def test_request_examples_with_huffman(self): """ This section shows the same examples as the previous section, but using Huffman encoding for the literal values. """ e = Encoder() first_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com'), ] first_header_table = [(':authority', 'www.example.com')] first_result = ( b'\x82\x86\x84\x41\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff' ) assert e.encode(first_header_set, huffman=True) == first_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in first_header_table ] second_header_table = [ ('cache-control', 'no-cache'), (':authority', 'www.example.com') ] second_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com',), ('cache-control', 'no-cache'), ] second_result = b'\x82\x86\x84\xbeX\x86\xa8\xeb\x10d\x9c\xbf' assert e.encode(second_header_set, huffman=True) == second_result assert list(e.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in second_header_table ] third_header_set = [ (':method', 'GET',), (':scheme', 'https',), (':path', '/index.html',), (':authority', 'www.example.com',), ('custom-key', 'custom-value'), ] third_result = ( b'\x82\x87\x85\xbf' b'@\x88%\xa8I\xe9[\xa9}\x7f\x89%\xa8I\xe9[\xb8\xe8\xb4\xbf' ) assert e.encode(third_header_set, huffman=True) == third_result assert len(e.header_table.dynamic_entries) == 3 # These tests are custom, for hyper. def test_resizing_header_table(self): # We need to encode a substantial number of headers, to populate the # header table. e = Encoder() header_set = [ (':method', 'GET'), (':scheme', 'https'), (':path', '/some/path'), (':authority', 'www.example.com'), ('custom-key', 'custom-value'), ( "user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:16.0) " "Gecko/20100101 Firefox/16.0", ), ( "accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;" "q=0.8", ), ('X-Lukasa-Test', '88989'), ] e.encode(header_set, huffman=True) # Resize the header table to a size so small that nothing can be in it. e.header_table_size = 40 assert len(e.header_table.dynamic_entries) == 0 def test_resizing_header_table_sends_multiple_updates(self): e = Encoder() e.header_table_size = 40 e.header_table_size = 100 e.header_table_size = 40 header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x3F\x09\x3F\x45\x3F\x09\x82' def test_resizing_header_table_to_same_size_ignored(self): e = Encoder() # These size changes should be ignored e.header_table_size = 4096 e.header_table_size = 4096 e.header_table_size = 4096 # These size changes should be encoded e.header_table_size = 40 e.header_table_size = 100 e.header_table_size = 40 header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x3F\x09\x3F\x45\x3F\x09\x82' def test_resizing_header_table_sends_context_update(self): e = Encoder() # Resize the header table to a size so small that nothing can be in it. e.header_table_size = 40 # Now, encode a header set. Just a small one, with a well-defined # output. header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'?\t\x82' def test_setting_table_size_to_the_same_does_nothing(self): e = Encoder() # Set the header table size to the default. e.header_table_size = 4096 # Now encode a header set. Just a small one, with a well-defined # output. header_set = [(':method', 'GET')] out = e.encode(header_set, huffman=True) assert out == b'\x82' def test_evicting_header_table_objects(self): e = Encoder() # Set the header table size large enough to include one header. e.header_table_size = 66 header_set = [('a', 'b'), ('long-custom-header', 'longish value')] e.encode(header_set) assert len(e.header_table.dynamic_entries) == 1 def test_headers_generator(self): e = Encoder() def headers_generator(): return (("k" + str(i), "v" + str(i)) for i in range(3)) header_set = headers_generator() out = e.encode(header_set) assert Decoder().decode(out) == list(headers_generator()) class TestHPACKDecoder: # These tests are stolen entirely from the IETF specification examples. def test_literal_header_field_with_indexing(self): """ The header field representation uses a literal name and a literal value. """ d = Decoder() header_set = [('custom-key', 'custom-header')] data = b'\x40\x0acustom-key\x0dcustom-header' assert d.decode(data) == header_set assert list(d.header_table.dynamic_entries) == [ (n.encode('utf-8'), v.encode('utf-8')) for n, v in header_set ] def test_raw_decoding(self): """ The header field representation is decoded as a raw byte string instead of UTF-8 """ d = Decoder() header_set = [ (b'\x00\x01\x99\x30\x11\x22\x55\x21\x89\x14', b'custom-header') ] data = ( b'\x40\x0a\x00\x01\x99\x30\x11\x22\x55\x21\x89\x14\x0d' b'custom-header' ) assert d.decode(data, raw=True) == header_set def test_literal_header_field_without_indexing(self): """ The header field representation uses an indexed name and a literal value. """ d = Decoder() header_set = [(':path', '/sample/path')] data = b'\x04\x0c/sample/path' assert d.decode(data) == header_set assert list(d.header_table.dynamic_entries) == [] def test_header_table_size_getter(self): d = Decoder() assert d.header_table_size def test_indexed_header_field(self): """ The header field representation uses an indexed header field, from the static table. """ d = Decoder() header_set = [(':method', 'GET')] data = b'\x82' assert d.decode(data) == header_set assert list(d.header_table.dynamic_entries) == [] def test_request_examples_without_huffman(self): """ This section shows several consecutive header sets, corresponding to HTTP requests, on the same connection. """ d = Decoder() first_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com'), ] # The first_header_table doesn't contain 'authority' first_data = b'\x82\x86\x84\x01\x0fwww.example.com' assert d.decode(first_data) == first_header_set assert list(d.header_table.dynamic_entries) == [] # This request takes advantage of the differential encoding of header # sets. second_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com',), ('cache-control', 'no-cache'), ] second_data = ( b'\x82\x86\x84\x01\x0fwww.example.com\x0f\t\x08no-cache' ) assert d.decode(second_data) == second_header_set assert list(d.header_table.dynamic_entries) == [] third_header_set = [ (':method', 'GET',), (':scheme', 'https',), (':path', '/index.html',), (':authority', 'www.example.com',), ('custom-key', 'custom-value'), ] third_data = ( b'\x82\x87\x85\x01\x0fwww.example.com@\ncustom-key\x0ccustom-value' ) assert d.decode(third_data) == third_header_set # Don't check the header table here, it's just too complex to be # reliable. Check its length though. assert len(d.header_table.dynamic_entries) == 1 def test_request_examples_with_huffman(self): """ This section shows the same examples as the previous section, but using Huffman encoding for the literal values. """ d = Decoder() first_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com'), ] first_data = ( b'\x82\x86\x84\x01\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff' ) assert d.decode(first_data) == first_header_set assert list(d.header_table.dynamic_entries) == [] second_header_set = [ (':method', 'GET',), (':scheme', 'http',), (':path', '/',), (':authority', 'www.example.com',), ('cache-control', 'no-cache'), ] second_data = ( b'\x82\x86\x84\x01\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff' b'\x0f\t\x86\xa8\xeb\x10d\x9c\xbf' ) assert d.decode(second_data) == second_header_set assert list(d.header_table.dynamic_entries) == [] third_header_set = [ (':method', 'GET',), (':scheme', 'https',), (':path', '/index.html',), (':authority', 'www.example.com',), ('custom-key', 'custom-value'), ] third_data = ( b'\x82\x87\x85\x01\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff@' b'\x88%\xa8I\xe9[\xa9}\x7f\x89%\xa8I\xe9[\xb8\xe8\xb4\xbf' ) assert d.decode(third_data) == third_header_set assert len(d.header_table.dynamic_entries) == 1 # These tests are custom, for hyper. def test_resizing_header_table(self): # We need to decode a substantial number of headers, to populate the # header table. This string isn't magic: it's the output from the # equivalent test for the Encoder. d = Decoder() data = ( b'\x82\x87D\x87a\x07\xa4\xacV4\xcfA\x8c\xf1\xe3\xc2\xe5\xf2:k\xa0' b'\xab\x90\xf4\xff@\x88%\xa8I\xe9[\xa9}\x7f\x89%\xa8I\xe9[\xb8\xe8' b'\xb4\xbfz\xbc\xd0\x7ff\xa2\x81\xb0\xda\xe0S\xfa\xd02\x1a\xa4\x9d' b'\x13\xfd\xa9\x92\xa4\x96\x854\x0c\x8aj\xdc\xa7\xe2\x81\x02\xef}' b'\xa9g{\x81qp\x7fjb):\x9d\x81\x00 \x00@\x150\x9a\xc2\xca\x7f,\x05' b'\xc5\xc1S\xb0I|\xa5\x89\xd3M\x1fC\xae\xba\x0cA\xa4\xc7\xa9\x8f3' b'\xa6\x9a?\xdf\x9ah\xfa\x1du\xd0b\r&=Ly\xa6\x8f\xbe\xd0\x01w\xfe' b'\xbeX\xf9\xfb\xed\x00\x17{@\x8a\xfc[=\xbdF\x81\xad\xbc\xa8O\x84y' b'\xe7\xde\x7f' ) d.decode(data) # Resize the header table to a size so small that nothing can be in it. d.header_table_size = 40 assert len(d.header_table.dynamic_entries) == 0 def test_apache_trafficserver(self): # This test reproduces the bug in #110, using exactly the same header # data. d = Decoder() data = ( b'\x10\x07:status\x03200@\x06server\tATS/6.0.0' b'@\x04date\x1dTue, 31 Mar 2015 08:09:51 GMT' b'@\x0ccontent-type\ttext/html@\x0econtent-length\x0542468' b'@\rlast-modified\x1dTue, 31 Mar 2015 01:55:51 GMT' b'@\x04vary\x0fAccept-Encoding@\x04etag\x0f"5519fea7-a5e4"' b'@\x08x-served\x05Nginx@\x14x-subdomain-tryfiles\x04True' b'@\x07x-deity\thydra-lts@\raccept-ranges\x05bytes@\x03age\x010' b'@\x19strict-transport-security\rmax-age=86400' b'@\x03via2https/1.1 ATS (ApacheTrafficServer/6.0.0 [cSsNfU])' ) expect = [ (':status', '200'), ('server', 'ATS/6.0.0'), ('date', 'Tue, 31 Mar 2015 08:09:51 GMT'), ('content-type', 'text/html'), ('content-length', '42468'), ('last-modified', 'Tue, 31 Mar 2015 01:55:51 GMT'), ('vary', 'Accept-Encoding'), ('etag', '"5519fea7-a5e4"'), ('x-served', 'Nginx'), ('x-subdomain-tryfiles', 'True'), ('x-deity', 'hydra-lts'), ('accept-ranges', 'bytes'), ('age', '0'), ('strict-transport-security', 'max-age=86400'), ('via', 'https/1.1 ATS (ApacheTrafficServer/6.0.0 [cSsNfU])'), ] result = d.decode(data) assert result == expect # The status header shouldn't be indexed. assert len(d.header_table.dynamic_entries) == len(expect) - 1 def test_utf8_errors_raise_hpack_decoding_error(self): d = Decoder() # Invalid UTF-8 data. data = b'\x82\x86\x84\x01\x10www.\x07\xaa\xd7\x95\xd7\xa8\xd7\x94.com' with pytest.raises(HPACKDecodingError): d.decode(data) def test_invalid_indexed_literal(self): d = Decoder() # Refer to an index that is too large. data = b'\x82\x86\x84\x7f\x0a\x0fwww.example.com' with pytest.raises(InvalidTableIndex): d.decode(data) def test_invalid_indexed_header(self): d = Decoder() # Refer to an indexed header that is too large. data = b'\xBE\x86\x84\x01\x0fwww.example.com' with pytest.raises(InvalidTableIndex): d.decode(data) def test_literal_header_field_with_indexing_emits_headertuple(self): """ A header field with indexing emits a HeaderTuple. """ d = Decoder() data = b'\x00\x0acustom-key\x0dcustom-header' headers = d.decode(data) assert len(headers) == 1 header = headers[0] assert isinstance(header, HeaderTuple) assert not isinstance(header, NeverIndexedHeaderTuple) def test_literal_never_indexed_emits_neverindexedheadertuple(self): """ A literal header field that must never be indexed emits a NeverIndexedHeaderTuple. """ d = Decoder() data = b'\x10\x0acustom-key\x0dcustom-header' headers = d.decode(data) assert len(headers) == 1 header = headers[0] assert isinstance(header, NeverIndexedHeaderTuple) def test_indexed_never_indexed_emits_neverindexedheadertuple(self): """ A header field with an indexed name that must never be indexed emits a NeverIndexedHeaderTuple. """ d = Decoder() data = b'\x14\x0c/sample/path' headers = d.decode(data) assert len(headers) == 1 header = headers[0] assert isinstance(header, NeverIndexedHeaderTuple) def test_max_header_list_size(self): """ If the header block is larger than the max_header_list_size, the HPACK decoder throws an OversizedHeaderListError. """ d = Decoder(max_header_list_size=44) data = b'\x14\x0c/sample/path' with pytest.raises(OversizedHeaderListError): d.decode(data) def test_can_decode_multiple_header_table_size_changes(self): """ If multiple header table size changes are sent in at once, they are successfully decoded. """ d = Decoder() data = b'?a?\xe1\x1f\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' expect = [ (':method', 'GET'), (':scheme', 'https'), (':path', '/'), (':authority', '127.0.0.1:8443') ] assert d.decode(data) == expect def test_header_table_size_change_above_maximum(self): """ If a header table size change is received that exceeds the maximum allowed table size, it is rejected. """ d = Decoder() d.max_allowed_table_size = 127 data = b'?a\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' with pytest.raises(InvalidTableSizeError): d.decode(data) def test_table_size_not_adjusting(self): """ If the header table size is shrunk, and then the remote peer doesn't join in the shrinking, then an error is raised. """ d = Decoder() d.max_allowed_table_size = 128 data = b'\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' with pytest.raises(InvalidTableSizeError): d.decode(data) def test_table_size_last_rejected(self): """ If a header table size change comes last in the header block, it is forbidden. """ d = Decoder() data = b'\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99?a' with pytest.raises(HPACKDecodingError): d.decode(data) def test_table_size_middle_rejected(self): """ If a header table size change comes anywhere but first in the header block, it is forbidden. """ d = Decoder() data = b'\x82?a\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' with pytest.raises(HPACKDecodingError): d.decode(data) def test_truncated_header_name(self): """ If a header name is truncated an error is raised. """ d = Decoder() # This is a simple header block that has a bad ending. The interesting # part begins on the second line. This indicates a string that has # literal name and value. The name is a 5 character huffman-encoded # string that is only three bytes long. data = ( b'\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' b'\x00\x85\xf2\xb2J' ) with pytest.raises(HPACKDecodingError): d.decode(data) def test_truncated_header_value(self): """ If a header value is truncated an error is raised. """ d = Decoder() # This is a simple header block that has a bad ending. The interesting # part begins on the second line. This indicates a string that has # literal name and value. The name is a 5 character huffman-encoded # string, but the entire EOS character has been written over the end. # This causes hpack to see the header value as being supposed to be # 622462 bytes long, which it clearly is not, and so this must fail. data = ( b'\x82\x87\x84A\x8a\x08\x9d\\\x0b\x81p\xdcy\xa6\x99' b'\x00\x85\xf2\xb2J\x87\xff\xff\xff\xfd%B\x7f' ) with pytest.raises(HPACKDecodingError): d.decode(data) class TestDictToIterable: """ The dict_to_iterable function has some subtle requirements: validates that everything behaves as expected. As much as possible this tries to be exhaustive. """ keys = one_of( text().filter(lambda k: k and not k.startswith(':')), binary().filter(lambda k: k and not k.startswith(b':')) ) @given( special_keys=sets(keys), boring_keys=sets(keys), ) def test_ordering(self, special_keys, boring_keys): """ _dict_to_iterable produces an iterable where all the keys beginning with a colon are emitted first. """ def _prepend_colon(k): if isinstance(k, str): return ':' + k else: return b':' + k special_keys = set(map(_prepend_colon, special_keys)) input_dict = { k: b'testval' for k in itertools.chain( special_keys, boring_keys ) } filtered = _dict_to_iterable(input_dict) received_special = set() received_boring = set() for _ in special_keys: k, _ = next(filtered) received_special.add(k) for _ in boring_keys: k, _ = next(filtered) received_boring.add(k) assert special_keys == received_special assert boring_keys == received_boring @given( special_keys=sets(keys), boring_keys=sets(keys), ) def test_ordering_applies_to_encoding(self, special_keys, boring_keys): """ When encoding a dictionary the special keys all appear first. """ def _prepend_colon(k): if isinstance(k, str): return ':' + k else: return b':' + k special_keys = set(map(_prepend_colon, special_keys)) input_dict = { k: b'testval' for k in itertools.chain( special_keys, boring_keys ) } e = Encoder() d = Decoder() encoded = e.encode(input_dict) decoded = iter(d.decode(encoded, raw=True)) received_special = set() received_boring = set() expected_special = set(map(_to_bytes, special_keys)) expected_boring = set(map(_to_bytes, boring_keys)) for _ in special_keys: k, _ = next(decoded) received_special.add(k) for _ in boring_keys: k, _ = next(decoded) received_boring.add(k) assert expected_special == received_special assert expected_boring == received_boring ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/test/test_huffman.py0000644000076500000240000000364200000000000017364 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- from hpack import HPACKDecodingError from hpack.huffman import HuffmanEncoder from hpack.huffman_constants import REQUEST_CODES, REQUEST_CODES_LENGTH from hpack.huffman_table import decode_huffman from hypothesis import given, example from hypothesis.strategies import binary class TestHuffman: def test_request_huffman_decoder(self): assert ( decode_huffman(b'\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff') == b"www.example.com" ) assert decode_huffman(b'\xa8\xeb\x10d\x9c\xbf') == b"no-cache" assert decode_huffman(b'%\xa8I\xe9[\xa9}\x7f') == b"custom-key" assert ( decode_huffman(b'%\xa8I\xe9[\xb8\xe8\xb4\xbf') == b"custom-value" ) def test_request_huffman_encode(self): encoder = HuffmanEncoder(REQUEST_CODES, REQUEST_CODES_LENGTH) assert ( encoder.encode(b"www.example.com") == b'\xf1\xe3\xc2\xe5\xf2:k\xa0\xab\x90\xf4\xff' ) assert encoder.encode(b"no-cache") == b'\xa8\xeb\x10d\x9c\xbf' assert encoder.encode(b"custom-key") == b'%\xa8I\xe9[\xa9}\x7f' assert ( encoder.encode(b"custom-value") == b'%\xa8I\xe9[\xb8\xe8\xb4\xbf' ) class TestHuffmanDecoder: @given(data=binary()) @example(b'\xff') @example(b'\x5f\xff\xff\xff\xff') @example(b'\x00\x3f\xff\xff\xff') def test_huffman_decoder_properly_handles_all_bytestrings(self, data): """ When given random bytestrings, either we get HPACKDecodingError or we get a bytestring back. """ # The examples aren't special, they're just known to hit specific error # paths through the state machine. Basically, they are strings that are # definitely invalid. try: result = decode_huffman(data) except HPACKDecodingError: result = b'' assert isinstance(result, bytes) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/test/test_struct.py0000644000076500000240000000372300000000000017264 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- """ test_struct ~~~~~~~~~~~ Tests for the Header tuples. """ import pytest from hpack import HeaderTuple, NeverIndexedHeaderTuple class TestHeaderTuple: def test_is_tuple(self): """ HeaderTuple objects are tuples. """ h = HeaderTuple('name', 'value') assert isinstance(h, tuple) def test_unpacks_properly(self): """ HeaderTuple objects unpack like tuples. """ h = HeaderTuple('name', 'value') k, v = h assert k == 'name' assert v == 'value' def test_header_tuples_are_indexable(self): """ HeaderTuple objects can be indexed. """ h = HeaderTuple('name', 'value') assert h.indexable def test_never_indexed_tuples_are_not_indexable(self): """ NeverIndexedHeaderTuple objects cannot be indexed. """ h = NeverIndexedHeaderTuple('name', 'value') assert not h.indexable @pytest.mark.parametrize('cls', (HeaderTuple, NeverIndexedHeaderTuple)) def test_equal_to_tuples(self, cls): """ HeaderTuples and NeverIndexedHeaderTuples are equal to equivalent tuples. """ t1 = ('name', 'value') t2 = cls('name', 'value') assert t1 == t2 assert t1 is not t2 @pytest.mark.parametrize('cls', (HeaderTuple, NeverIndexedHeaderTuple)) def test_equal_to_self(self, cls): """ HeaderTuples and NeverIndexedHeaderTuples are always equal when compared to the same class. """ t1 = cls('name', 'value') t2 = cls('name', 'value') assert t1 == t2 assert t1 is not t2 def test_equal_for_different_indexes(self): """ HeaderTuples compare equal to equivalent NeverIndexedHeaderTuples. """ t1 = HeaderTuple('name', 'value') t2 = NeverIndexedHeaderTuple('name', 'value') assert t1 == t2 assert t1 is not t2 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597493598.0 hpack-4.0.0/test/test_table.py0000644000076500000240000001051200000000000017021 0ustar00kriechistaff00000000000000# -*- coding: utf-8 -*- import pytest from hpack import InvalidTableIndex from hpack.table import HeaderTable, table_entry_size class TestPackageFunctions: def test_table_entry_size(self): res = table_entry_size(b'TestName', b'TestValue') assert res == 49 class TestHeaderTable: def test_get_by_index_dynamic_table(self): tbl = HeaderTable() off = len(HeaderTable.STATIC_TABLE) val = (b'TestName', b'TestValue') tbl.add(*val) res = tbl.get_by_index(off + 1) assert res == val def test_get_by_index_static_table(self): tbl = HeaderTable() exp = (b':authority', b'') res = tbl.get_by_index(1) assert res == exp idx = len(HeaderTable.STATIC_TABLE) exp = (b'www-authenticate', b'') res = tbl.get_by_index(idx) assert res == exp def test_get_by_index_zero_index(self): tbl = HeaderTable() with pytest.raises(InvalidTableIndex): tbl.get_by_index(0) def test_get_by_index_out_of_range(self): tbl = HeaderTable() off = len(HeaderTable.STATIC_TABLE) tbl.add(b'TestName', b'TestValue') with pytest.raises(InvalidTableIndex) as e: tbl.get_by_index(off + 2) assert ( "Invalid table index %d" % (off + 2) in str(e.value) ) def test_repr(self): tbl = HeaderTable() tbl.add(b'TestName1', b'TestValue1') tbl.add(b'TestName2', b'TestValue2') tbl.add(b'TestName2', b'TestValue2') exp = ( "HeaderTable(4096, False, deque([" "(b'TestName2', b'TestValue2'), " "(b'TestName2', b'TestValue2'), " "(b'TestName1', b'TestValue1')" "]))" ) res = repr(tbl) assert res == exp def test_add_to_large(self): tbl = HeaderTable() # Max size to small to hold the value we specify tbl.maxsize = 1 tbl.add(b'TestName', b'TestValue') # Table length should be 0 assert len(tbl.dynamic_entries) == 0 def test_search_in_static_full(self): tbl = HeaderTable() itm = (b':authority', b'') exp = (1, itm[0], itm[1]) res = tbl.search(itm[0], itm[1]) assert res == exp def test_search_in_static_partial(self): tbl = HeaderTable() exp = (1, b':authority', None) res = tbl.search(b':authority', b'NotInTable') assert res == exp def test_search_in_dynamic_full(self): tbl = HeaderTable() idx = len(HeaderTable.STATIC_TABLE) + 1 tbl.add(b'TestName', b'TestValue') exp = (idx, b'TestName', b'TestValue') res = tbl.search(b'TestName', b'TestValue') assert res == exp def test_search_in_dynamic_partial(self): tbl = HeaderTable() idx = len(HeaderTable.STATIC_TABLE) + 1 tbl.add(b'TestName', b'TestValue') exp = (idx, b'TestName', None) res = tbl.search(b'TestName', b'NotInTable') assert res == exp def test_search_no_match(self): tbl = HeaderTable() tbl.add(b'TestName', b'TestValue') res = tbl.search(b'NotInTable', b'NotInTable') assert res is None def test_maxsize_prop_getter(self): tbl = HeaderTable() assert tbl.maxsize == HeaderTable.DEFAULT_SIZE def test_maxsize_prop_setter(self): tbl = HeaderTable() exp = int(HeaderTable.DEFAULT_SIZE / 2) tbl.maxsize = exp assert tbl.resized is True assert tbl.maxsize == exp tbl.resized = False tbl.maxsize = exp assert tbl.resized is False assert tbl.maxsize == exp def test_size(self): tbl = HeaderTable() for i in range(3): tbl.add(b'TestName', b'TestValue') res = tbl._current_size assert res == 147 def test_shrink_maxsize_is_zero(self): tbl = HeaderTable() tbl.add(b'TestName', b'TestValue') assert len(tbl.dynamic_entries) == 1 tbl.maxsize = 0 assert len(tbl.dynamic_entries) == 0 def test_shrink_maxsize(self): tbl = HeaderTable() for i in range(3): tbl.add(b'TestName', b'TestValue') assert tbl._current_size == 147 tbl.maxsize = 146 assert len(tbl.dynamic_entries) == 2 assert tbl._current_size == 98 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1597495970.0 hpack-4.0.0/tox.ini0000644000076500000240000000250600000000000014661 0ustar00kriechistaff00000000000000[tox] envlist = py36, py37, py38, pypy3, lint, docs, packaging [gh-actions] python = 3.6: py36 3.7: py37 3.8: py38, lint, docs, packaging pypy3: pypy3 [testenv] passenv = GITHUB_* deps = pytest==6.0.1 pytest-cov==2.10.1 pytest-xdist==2.0.0 hypothesis>=5.5,<6 attrs==19.3.0 commands = pytest --cov-report=xml --cov-report=term --cov=hpack {posargs} [testenv:pypy3] # temporarily disable coverage testing on PyPy due to performance problems commands = pytest {posargs} [testenv:lint] basepython = python3.8 deps = flake8==3.8.3 commands = flake8 --max-complexity 10 src test utils [testenv:docs] basepython = python3.8 deps = sphinx==3.2.1 whitelist_externals = make changedir = {toxinidir}/docs commands = make clean make html [testenv:packaging] basepython = python3.8 deps = check-manifest==0.42 readme-renderer==26.0 twine==3.2.0 commands = check-manifest python setup.py sdist bdist_wheel twine check dist/* [testenv:bench] deps = {[testenv]deps} pytest-benchmark==3.2.3 commands = pytest {toxinidir}/bench/ --benchmark-only --benchmark-group-by=name --benchmark-autosave --benchmark-compare --benchmark-min-rounds=500000 [testenv:create_test_output] basepython = python3.7 commands = python {toxinidir}/utils/create_test_output.py {posargs}