Full Code of openlgtv/epk2extract for AI

Repository: openlgtv/epk2extract
Branch: master
Commit: 22a910d5578d
Files: 237
Total size: 1.5 MB

Directory structure:
gitextract_meo9h1xu/

├── .cirrus.yml
├── .editorconfig
├── .gitattributes
├── .github/
│   └── workflows/
│       └── build.yml
├── .gitignore
├── .sonarcloud_gen.sh
├── AUTHORS
├── CMakeLists.txt
├── COPYING
├── README.md
├── build.sh
├── cmake-modules/
│   └── FindLZO.cmake
├── code_format.sh
├── include/
│   ├── common.h
│   ├── config.h
│   ├── cramfs/
│   │   ├── cramfs.h
│   │   ├── cramfs_fs.h
│   │   └── cramfsswap.h
│   ├── crc.h
│   ├── epk.h
│   ├── epk1.h
│   ├── epk2.h
│   ├── epk3.h
│   ├── jffs2/
│   │   ├── jffs2.h
│   │   └── mini_inflate.h
│   ├── log.h
│   ├── lz4/
│   │   ├── bench.h
│   │   ├── lz4.h
│   │   └── lz4hc.h
│   ├── lzhs/
│   │   ├── lzhs.h
│   │   └── tables.h
│   ├── lzma/
│   │   ├── LzFind.h
│   │   ├── LzHash.h
│   │   ├── LzmaDec.h
│   │   ├── LzmaEnc.h
│   │   └── Types.h
│   ├── lzma.h
│   ├── lzo/
│   │   ├── lzo.h
│   │   ├── miniacc.h
│   │   ├── portab.h
│   │   └── portab_a.h
│   ├── main.h
│   ├── mediatek.h
│   ├── mediatek_pkg.h
│   ├── mfile.h
│   ├── minigzip.h
│   ├── os_byteswap.h
│   ├── osx/
│   │   └── elf.h
│   ├── philips.h
│   ├── realtek/
│   │   └── rtsplit.h
│   ├── realtek.h
│   ├── sniptype.h
│   ├── squashfs/
│   │   ├── action.h
│   │   ├── caches-queues-lists.h
│   │   ├── compressor.h
│   │   ├── error.h
│   │   ├── gzip_wrapper.h
│   │   ├── info.h
│   │   ├── lz4_wrapper.h
│   │   ├── lzo_wrapper.h
│   │   ├── mksquashfs.h
│   │   ├── process_fragments.h
│   │   ├── progressbar.h
│   │   ├── pseudo.h
│   │   ├── read_fs.h
│   │   ├── restore.h
│   │   ├── sort.h
│   │   ├── squashfs_compat.h
│   │   ├── squashfs_fs.h
│   │   ├── squashfs_swap.h
│   │   ├── unsquashfs.h
│   │   ├── unsquashfs_info.h
│   │   ├── xattr.h
│   │   └── xz_wrapper.h
│   ├── stream/
│   │   ├── crc32.h
│   │   └── tsfile.h
│   ├── symfile.h
│   ├── thpool.h
│   ├── u-boot/
│   │   ├── image.h
│   │   ├── mtdinfo.h
│   │   ├── partcommon.h
│   │   ├── partinfo.h
│   │   ├── partinfov1.h
│   │   └── partinfov2.h
│   ├── util.h
│   └── util_crypto.h
├── keys/
│   ├── AES.key
│   ├── MTK.key
│   ├── README.md
│   ├── e60.pem
│   ├── e60n.pem
│   ├── general_pub.pem
│   ├── h15.pem
│   ├── k24.pem
│   ├── k24n.pem
│   ├── k24t.pem
│   ├── k25lp.pem
│   ├── k2l.pem
│   ├── k2lp.pem
│   ├── k3lp.pem
│   ├── k5lp.pem
│   ├── k6hp.pem
│   ├── k6lp.pem
│   ├── k6lpfhd.pem
│   ├── k6lpwee.pem
│   ├── k7lp.pem
│   ├── k8ap.pem
│   ├── k8apwee.pem
│   ├── k8hp-hotel.pem
│   ├── k8hp.pem
│   ├── k8hpp.pem
│   ├── k8hpt.pem
│   ├── k8hpwee.pem
│   ├── k8lp-hotel.pem
│   ├── k8lp.pem
│   ├── k8lpn-hotel.pem
│   ├── k8lpn.pem
│   ├── k8lpn2.pem
│   ├── k8lpwee.pem
│   ├── kf23f-mnt.pem
│   ├── kf23f.pem
│   ├── kf23fwee.pem
│   ├── kid23q.pem
│   ├── lg1152.pem
│   ├── lg1154_netcast.pem
│   ├── lg1154_webos.pem
│   ├── lm14.pem
│   ├── lm15u.pem
│   ├── lm18a.pem
│   ├── lm21a.pem
│   ├── lm21an.pem
│   ├── lm21ann.pem
│   ├── lm21u.pem
│   ├── lm21ut.pem
│   ├── m14.pem
│   ├── m16.pem
│   ├── m16p.pem
│   ├── m16p3.pem
│   ├── m16pp.pem
│   ├── m23.pem
│   ├── m2_sspm.pem
│   ├── m3.pem
│   ├── mtk5369.pem
│   ├── mtk5398.pem
│   ├── netflix_pub.pem
│   ├── o18.pem
│   ├── o18_2019.pem
│   ├── o18k.pem
│   ├── o20.pem
│   ├── o208k.pem
│   ├── o20n.pem
│   ├── o22.pem
│   ├── o22n.pem
│   ├── o22n2.pem
│   ├── o22n28k.pem
│   ├── o22n3.pem
│   ├── o24.pem
│   └── o24n.pem
├── partinfo.py
├── sonar-project.properties
└── src/
    ├── CMakeLists.txt
    ├── cramfs/
    │   ├── CMakeLists.txt
    │   ├── cramfsswap.c
    │   └── uncramfs.c
    ├── crc32.c
    ├── epk.c
    ├── epk1.c
    ├── epk2.c
    ├── epk3.c
    ├── jffs2/
    │   ├── CMakeLists.txt
    │   ├── crc32.cpp
    │   ├── jffs2extract.cpp
    │   └── mini_inflate.cpp
    ├── lz4/
    │   ├── CMakeLists.txt
    │   ├── bench.c
    │   ├── lz4.c
    │   ├── lz4_format_description.txt
    │   ├── lz4demo.c
    │   └── lz4hc.c
    ├── lzhs/
    │   ├── CMakeLists.txt
    │   ├── lzhs.c
    │   └── lzhs_lib.c
    ├── lzma/
    │   ├── CMakeLists.txt
    │   ├── LzFind.c
    │   ├── LzmaDec.c
    │   └── LzmaEnc.c
    ├── lzo-lg.c
    ├── main.c
    ├── mediatek.c
    ├── mediatek_pkg.c
    ├── mfile.c
    ├── minigzip.c
    ├── partinfo.c
    ├── philips.c
    ├── realtek.c
    ├── squashfs/
    │   ├── CMakeLists.txt
    │   ├── action.c
    │   ├── caches-queues-lists.c
    │   ├── compressor.c
    │   ├── gzip_wrapper.c
    │   ├── info.c
    │   ├── lz4_wrapper.c
    │   ├── lzma_wrapper.c
    │   ├── lzma_xz_wrapper.c
    │   ├── lzo_wrapper.c
    │   ├── mksquashfs.c
    │   ├── process_fragments.c
    │   ├── progressbar.c
    │   ├── pseudo.c
    │   ├── read_file.c
    │   ├── read_fs.c
    │   ├── read_xattrs.c
    │   ├── restore.c
    │   ├── sort.c
    │   ├── swap.c
    │   ├── unsquash-1.c
    │   ├── unsquash-2.c
    │   ├── unsquash-3.c
    │   ├── unsquash-4.c
    │   ├── unsquashfs.c
    │   ├── unsquashfs_info.c
    │   ├── unsquashfs_xattr.c
    │   ├── xattr.c
    │   └── xz_wrapper.c
    ├── stream/
    │   ├── CMakeLists.txt
    │   ├── crc32.c
    │   └── tsfile.c
    ├── symfile.c
    ├── thpool.c
    ├── tools/
    │   ├── CMakeLists.txt
    │   ├── idb_extract.c
    │   ├── jffs2extract.c
    │   ├── lzhs_scanner.c
    │   ├── lzhsenc.c
    │   └── tsfile.c
    ├── util.c
    └── util_crypto.c

================================================
FILE CONTENTS
================================================

================================================
FILE: .cirrus.yml
================================================
env:
  CIRRUS_CLONE_DEPTH: 1

linux_x64_task:
  container:
    cpu: 2
    memory: 2G
    image: gcc:15.2.0

  install_script:
    - apt-get update -qq
    - apt-get install -qq liblzo2-dev libssl-dev libc6-dev cmake

  build_script:
    - ./build.sh

darwin_aarch64_task:
  macos_instance:
    image: ghcr.io/cirruslabs/macos-ventura-base:latest

  install_script:
    - brew install openssl@3 lzo
    - brew reinstall openssl@3

  build_script:
    - ./build.sh


================================================
FILE: .editorconfig
================================================
root = true

[*]
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true


================================================
FILE: .gitattributes
================================================
# auto-detect text files; use LF
* text=auto eol=lf

# text extensions
*.txt text
*.md text
*.c text
*.h text
*.cpp text
*.yml text
*.cmake text

# important that these use LF
*.sh text eol=lf
*.py text eol=lf

# specific text filenames
.gitattributes text
.gitignore text
.editorconfig text
AUTHORS text
COPYING text


================================================
FILE: .github/workflows/build.yml
================================================
name: SonarQube
on:
  push:
    branches:
      - master
      - develop
  pull_request:
    types: [opened, synchronize, reopened]
jobs:
  build:
    name: Build and analyze
    runs-on: ubuntu-latest
    env:
      BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory # Directory where build-wrapper output will be placed
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
      - name: Install Dependencies
        run: |
          sudo apt-get install -y git build-essential cmake liblzo2-dev libssl-dev libc6-dev
      - name: Install Build Wrapper
        uses: SonarSource/sonarqube-scan-action/install-build-wrapper@v5
      - name: Run Build Wrapper
        run: |
          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} ./build.sh
      - name: SonarQube Scan
        uses: SonarSource/sonarqube-scan-action@v5
        env:
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
        with:
          args: >
            --define sonar.cfamily.compile-commands="${{ env.BUILD_WRAPPER_OUT_DIR }}/compile_commands.json"



================================================
FILE: .gitignore
================================================
### CMake ###
CMakeCache.txt
CMakeFiles
Makefile
cmake_install.cmake
install_manifest.txt

### C ###
# Object files
*.o

# Libraries
*.a
*.la

# Executables
*.exe
*.out


### Epk2Extract ###

# build
build_linux
build_cygwin
build_osx

# Linux build artifacts
src/epk2extract
src/tools/idb_extract
src/tools/jffs2extract
src/tools/lzhs_scanner
src/tools/lzhsenc


================================================
FILE: .sonarcloud_gen.sh
================================================
#!/bin/sh
csv_prop(){
	echo -ne "$1="
	cat | paste -sd,
}

gen(){
	cat <<-EOF
	## THIS FILE IS AUTOGENERATED
	## edit .sonarcloud_gen.sh instead
	sonar.projectKey=openlgtv_epk2extract
	sonar.organization=openlgtv

	EOF

	(cat <<-EOF
	r1
	EOF
	) | csv_prop "sonar.issue.ignore.multicriteria"

	echo ""

	cat <<-EOF
	# format string is not a string literal
	sonar.issue.ignore.multicriteria.r1.ruleKey=c:S5281
	sonar.issue.ignore.multicriteria.r1.resourceKey=**
	EOF

	echo ""

	(cat <<-EOF
	src/*.c
	src/lzhs/*.c
	src/stream/*.c
	src/tools/*.c
	include/*.h
	include/lzhs/*.h
	include/realtek/*.h
	include/stream/*.h
	EOF
	) | csv_prop "sonar.inclusions"

}

cd "$(dirname "$(readlink -f "$0")")"
gen > sonar-project.properties


================================================
FILE: AUTHORS
================================================
This project is covered by the GPL licence. See COPYING for details.

epk2extract contributors list:
- Arno1
- cronix
- jenya
- lprot
- rtokarev (sym handling)
- Smx (smxdev4@gmail.com, current maintainer)
- sirius (original author of epk2extract)
- tbage
- xeros

Special thanks to:
- All the testers
- Authors of the original compression algorithms and libraries


================================================
FILE: CMakeLists.txt
================================================
set(CMAKE_LEGACY_CYGWIN_WIN32 0)

cmake_minimum_required(VERSION 3.13)
project(epk2extract)

if( NOT CMAKE_BUILD_TYPE )
	set(CMAKE_BUILD_TYPE Debug)
endif()

set(CMAKE_CXX_FLAGS_TEST "-Ofast")
set(CMAKE_C_FLAGS_TEST "-Ofast -funroll-loops -fprefetch-loop-arrays -march=native")

set(CMAKE_C_STANDARD 99)
set(CMAKE_CXX_STANDARD 11)

set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake-modules/")
find_package(OpenSSL REQUIRED)
find_package(LZO REQUIRED)
find_package(Threads REQUIRED)
find_package(ZLIB REQUIRED)
find_library(M_LIB m REQUIRED)

add_subdirectory(src)


================================================
FILE: COPYING
================================================
                    GNU GENERAL PUBLIC LICENSE
                       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Lesser General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

                    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

                            NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.


================================================
FILE: README.md
================================================
[![Build Status](https://travis-ci.org/openlgtv/epk2extract.svg?branch=master)](https://travis-ci.org/openlgtv/epk2extract)

epk2extract
===========

[![Join the chat at https://gitter.im/openlgtv/epk2extract](https://badges.gitter.im/openlgtv/epk2extract.svg)](https://gitter.im/openlgtv/epk2extract?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Join on Discord: https://discord.gg/xWqRVEm

epk2extract is a tool that can extract, decrypt, convert multiple file formats that can be found in LG TV sets and similar devices.

Supported Formats:
===========================================
**NOTE: To unpack epk v2 and v3 you need proper AES and RSA keys for decryption. To get them you will need to dump them from a running TV.**

**NOTE: To decrypt PVR recordings you need a dump of the unique AES-128 key from your TV**

| Format	| Notes
| :-----	| :-----
| epk v1	| First version of epk format, not encrypted and not signed
| epk v2	| Introduces signing and encryption, keys needed
| epk v3   	| Introduced with WebOS. Keys needed
| Mediatek pkg | UPG/PKG files used by Hisense/Sharp/Philips (missing Philips AES key) and possibly others
| Philips "fusion" | Upgrade files used by some Philips TVs
| squashfs	|
| cramfs	|
| lz4		| Slightly modified version with header magic
| lzo		|
| gzip		|
| jffs2		|
| lzhs		| Special compression for MTK bootloaders (boot.pak, tzfw.pak), uses lzss + huffman
| lzhs_fs   | LZHS compressed filesystem used in MTK Upgrade files for the external writable partition (3rdw)
| mtdinfo/partinfo |  LG Partition table format (mtdi.pak, part.pak)
| str/pif	| PVR recording format that can be found in netcast models
| sym		| LG Debugging symbols. Can extract function names and addresses to an IDA script file (idc)

Although epk2extract is only tested on LG firmware files, you may use it to extract other files like a general unpack tool, as long as they are supported according to the table above.

**!!WARNING!!**<br>
**epk2extract isn't designed to repack files**<br>
**If you wish to repack modified files, follow the openlgtv wiki/forum, and do it in a Linux environment (no cygwin)**<br>
**Don't repack files extracted in cygwin environment**<br>
**In any case, you do so at your own risk**<br>

*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*

| Tools:	| Description
| :----		| :----
| lzhsenc	| Compresses a given file with lzhs algorithm
| lzhs_scanner	| Scans a given file to find lzhs files, and extracts them
| idb_extract | Extracts Image Database (IDB) files that can be found in LG firmwares
| jffs2extract | Extracts JFFS2 images. Supports various compression algorithms


To compile on Linux:
===========================================

### Install build dependencies:
Ubuntu/Debian:
```shell
apt-get install git build-essential cmake liblzo2-dev libssl-dev libc6-dev zlib1g-dev
```
Mandriva/Mageia:
```shell
urpmi git task-c++-devel cmake liblzo-devel libopenssl-devel glibc-devel --auto
```

### Build it
```shell
./build.sh
```

After building, epk2extract can be found in ./build_\<platform\>/


To compile on Cygwin:
=====================

### Install Cygwin and during setup select following packages:

    Devel -> gcc-g++, git, cmake, make
    Libs  -> liblzo2-devel, zlib-devel
    Net   -> openssl-devel
    Utils -> ncurses

### Build it
```shell
./build.sh
```

The build script automatically copies required shared libraries to the ./build_cygwin/ folder, so you can use epk2extract standalone/portable without a full cygwin installation.


=====================
### How to speed up extraction process
You can build the test build, which contains compiler optimizations, with this command
```shell
CMAKE_FLAGS=-DCMAKE_BUILD_TYPE=Test ./build.sh
```
The Test build is orders of magnitude faster than the Debug build

### To use:

Put *.pem and AES.key files in the same directory as the epk2extract binary.

Run it via sudo/fakeroot to avoid warnings (while extracting device nodes from rootfs):

    fakeroot ./epk2extract file

## To get IDC from SYM run:

    ./epk2extract xxxxxxxx.sym

## To decode part.pak or mtdi.pak do:

    ./epk2extract part.pak

Or use partinfo.py (**deprected**)

    python partinfo.py part.pak


================================================
FILE: build.sh
================================================
#!/bin/bash
#epk2extract build script
#Copyright 2016 Smx <smxdev4@gmail.com>
#All right reserved

normal='tput sgr0'
lred='printf \033[01;31m'
lgreen='printf \033[01;32m'
lyellow='printf \033[01;33m'
lblue='printf \033[01;34m'
white='printf \033[01;37m'

cwd=$(pwd)
srcdir=`cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd`

exe=(
	"epk2extract" "tools/lzhsenc"
	"tools/lzhs_scanner" "tools/idb_extract"
	"tools/jffs2extract" "tools/tsfile"
)

nproc_cmd="nproc"

if [ "$OSTYPE" == "cygwin" ]; then rel=build_cygwin
elif [[ "$OSTYPE" =~ "linux" ]]; then rel=build_linux
elif [[ "$OSTYPE" =~ "darwin" ]]; then
	nproc_cmd="sysctl -n hw.logicalcpu"
	rel=build_osx
	CMAKE_FLAGS="-DOPENSSL_ROOT_DIR=$(brew --prefix)/opt/openssl ${CMAKE_FLAGS}"
else
	$lred; "Can't build - unknown OS type. Aborting..."; $normal
	exit 1
fi

installdir=$srcdir/$rel
objdir=$installdir/obj

cd $srcdir

if [ "$1" == "clean" ]; then
	$lyellow; echo "Removing cmake cache and make files"; $normal
	rm -r $objdir
	if [ -d "$installdir" ]; then
		$lyellow; echo "Removing build dir"; $normal
		rm -r "$installdir"
	fi
	$lgreen; echo "Done!"; $normal
	exit 0
fi

$lyellow; echo "Building epk2extract"; $normal
if [ ! -e "$rel/obj" ]; then
	mkdir -p $objdir
fi

cd $objdir

NUM_THREADS=$($nproc_cmd)

case "$1" in
	"-v")
		MAKE_FLAGS="${MAKE_ARGS} VERBOSE=1 -j${NUM_THREADS}"
		;;
esac

cmake $srcdir $CMAKE_FLAGS
make $MAKE_FLAGS
RESULT=$?
cd src

if [ ! $RESULT -eq 0 ]; then
	$lred; echo "Build Failed!"; $normal
	exit 1
fi

if [ "$rel" == "build_cygwin" ]; then
	for exe in ${exe[@]}; do
		cp $exe.exe $installdir/
	done
	if [ "$HOSTTYPE" == "i686" ]; then #cygwin32
		sharedlibs=("cygz.dll" "cygwin1.dll" "cyglzo2-2.dll" "cyggcc_s-1.dll" "cygcrypto-1.1.dll" "cygstdc++-6.dll")
	elif [ "$HOSTTYPE" == "x86_64" ]; then #cygwin64
		sharedlibs=("cygz.dll" "cygwin1.dll" "cyglzo2-2.dll" "cygcrypto-1.1.dll" "cyggcc_s-seh-1.dll" "cygstdc++-6.dll")
	fi
	for cyglib in ${sharedlibs[@]}; do
		$white; echo "Installing $cyglib"; $normal
		islibok=$(which "$cyglib" &>/dev/null; echo $?)
		if [ $islibok == 0 ]; then
			cp `which $cyglib` $installdir/
		else
			$lred
			echo "Something wrong! $cyglib not found."
			echo "Verify your cygwin installation and try again."
			$normal
			exit 1
		fi
	done
else
	for exe in ${exe[@]}; do
		cp $exe $installdir/
	done
fi

if [ -d "$srcdir/keys" ]; then
	for key in $(find ${srcdir}/keys -iname "*.pem" -or -iname "*.key" | sort); do
		$lblue; echo "Installing $(basename $key)"; $normal
		cp $key $installdir/
	done
fi
$lgreen; echo "Build completed!"; $normal
exit 0


================================================
FILE: cmake-modules/FindLZO.cmake
================================================
# Find liblzo2
# LZO_FOUND - system has the LZO library
# LZO_INCLUDE_DIR - the LZO include directory
# LZO_LIBRARIES - The libraries needed to use LZO

if (LZO_INCLUDE_DIR AND LZO_LIBRARIES)
	# in cache already
	SET(LZO_FOUND TRUE)
else (LZO_INCLUDE_DIR AND LZO_LIBRARIES)
	FIND_PATH(LZO_INCLUDE_DIR lzo/lzo1x.h
		 ${LZO_ROOT}/include/
		 /usr/include/
		 /usr/local/include/
		 /sw/lib/
		 /sw/local/lib/
	)

	if(WIN32 AND MSVC)
	else(WIN32 AND MSVC)
		FIND_LIBRARY(LZO_LIBRARIES NAMES lzo2
			PATHS
			${LZO_ROOT}/lib
			/usr/lib
			/usr/local/lib
			/sw/lib
			/sw/local/lib
		)
	endif(WIN32 AND MSVC)

	if (LZO_INCLUDE_DIR AND LZO_LIBRARIES)
		 set(LZO_FOUND TRUE)
	endif (LZO_INCLUDE_DIR AND LZO_LIBRARIES)

	if (LZO_FOUND)
		 if (NOT LZO_FIND_QUIETLY)
				message(STATUS "Found LZO: ${LZO_LIBRARIES}")
		 endif (NOT LZO_FIND_QUIETLY)
	else (LZO_FOUND)
		 if (LZO_FIND_REQUIRED)
				message(FATAL_ERROR "Could NOT find LZO")
		 endif (LZO_FIND_REQUIRED)
	endif (LZO_FOUND)

	MARK_AS_ADVANCED(LZO_INCLUDE_DIR LZO_LIBRARIES)
endif (LZO_INCLUDE_DIR AND LZO_LIBRARIES)


================================================
FILE: code_format.sh
================================================
#!/bin/bash
function my_indent() {
	file="$1"
	indent \
		--linux-style \
		--use-tabs \
		--tab-size4 \
		--indent-level4 \
		--preprocessor-indentation4 \
		--else-endif-column0 \
		--braces-on-if-line \
		--braces-on-func-def-line \
		--braces-on-struct-decl-line \
		--line-length0 \
			"$file"
}

if [ -z "$1" ]; then
	dirs="src include"
elif [ -d "$1" ]; then
	dirs="$1"
elif [ -f "$1" ]; then
	echo "Reindenting ${1}..."
	my_indent "$1"
	exit 0
fi

for file in `find src include -type f -name "*.c" -or -name "*.cpp" -or -name "*.h"`; do
	echo "Reindenting ${file}..."
	my_indent "$file"
done
exit 0


================================================
FILE: include/common.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * All right reserved
 */
#ifndef __COMMON_H
#define __COMMON_H

/* Branch Prediction Hints */
#ifdef __GNUC__
#define LIKELY(x)    __builtin_expect (!!(x), 1)
#define UNLIKELY(x)  __builtin_expect (!!(x), 0)
#else
#define LIKELY(x)	(x)
#define UNLIKELY(x)	(x)
#endif

#ifdef __GNUC__
#define UNUSED(x) UNUSED_ ## x __attribute__((__unused__))
#else
#define UNUSED(x) UNUSED_ ## x
#endif

#ifdef __GNUC__
#define UNUSED_FUNCTION(x) __attribute__((__unused__)) UNUSED_ ## x
#else
#define UNUSED_FUNCTION(x) UNUSED_ ## x
#endif

#ifdef __GNUC__
#define FORMAT_PRINTF(x, y) __attribute__((__format__(__printf__, (x), (y))))
#else
#define FORMAT_PRINTF(x, y)
#endif

#define countof(x) (sizeof(x) / sizeof((x)[0]))

#endif


================================================
FILE: include/config.h
================================================
/**
 * Copyright 20xx sirius
 * All right reserved
 */
#ifndef CONFIG_H_
#    define CONFIG_H_

#include <stdbool.h>

typedef struct {
	char *config_dir;
	char *dest_dir;
	int enableSignatureChecking;
	bool noAutoUnsquashfs;
	bool signatureOnly;
} config_opts_t;

extern config_opts_t config_opts;

#    define G_DIR_SEPARATOR_S "/"

#    if defined(__APPLE__)
#        include <sys/syslimits.h>
#    elif defined(__CYGWIN__)
#        include <limits.h>
#    else
#        include <linux/limits.h>
#    endif

#    ifndef PATH_MAX
#        define PATH_MAX        4096	/* # chars in a path name including nul */
#    endif

#endif /* CONFIG_H_ */


================================================
FILE: include/cramfs/cramfs.h
================================================
#ifndef __CRAMFS_H
#define __CRAMFS_H

#define CRAMFS_MAGIC		0x28cd3d45
										/* some random number */
#define CRAMFS_SIGNATURE	"Compressed ROMFS"

// Needed by cramfs
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

/*
 * Reasonably terse representation of the inode data.
 */
struct cramfs_inode {
	u32 mode:16, uid:16;
	/* SIZE for device files is i_rdev */
	u32 size:24, gid:8;
	/* NAMELEN is the length of the file name, divided by 4 and
	   rounded up.  (cramfs doesn't support hard links.) */
	/* OFFSET: For symlinks and non-empty regular files, this
	   contains the offset (divided by 4) of the file data in
	   compressed form (starting with an array of block pointers;
	   see README).  For non-empty directories it is the offset
	   (divided by 4) of the inode of the first file in that
	   directory.  For anything else, offset is zero. */
	u32 namelen:6, offset:26;
};

/*
 * Superblock information at the beginning of the FS.
 */
struct cramfs_super {
	u32 magic;					/* 0x28cd3d45 - random number */
	u32 size;					/* Not used.  mkcramfs currently
								   writes a constant 1<<16 here. */
	u32 flags;					/* 0 */
	u32 future;					/* 0 */
	u8 signature[16];			/* "Compressed ROMFS" */
	u8 fsid[16];				/* random number */
	u8 name[16];				/* user-defined name */
	struct cramfs_inode root;	/* Root inode data */
};

/*
 * Valid values in super.flags.  Currently we refuse to mount
 * if (flags & ~CRAMFS_SUPPORTED_FLAGS).  Maybe that should be
 * changed to test super.future instead.
 */
#define CRAMFS_SUPPORTED_FLAGS (0xff)

/* Uncompression interfaces to the underlying zlib */
int cramfs_uncompress_block(void *dst, int dstlen, void *src, int srclen);
int cramfs_uncompress_init(void);
int cramfs_uncompress_exit(void);

int is_cramfs_image(char const *imagefile, char *endian);
int uncramfs(char const *dirname, char const *imagefile);

#endif


================================================
FILE: include/cramfs/cramfs_fs.h
================================================
#ifndef __CRAMFS_FS_H
#    define __CRAMFS_FS_H

#    include <sys/types.h>

#    define CRAMFS_MAGIC		0x28cd3d45
										/* some random number */

// Needed by cramfs
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

/*
 * Width of various bitfields in struct cramfs_inode.
 * Primarily used to generate warnings in mkcramfs.
 */
#    define CRAMFS_MODE_WIDTH 16
#    define CRAMFS_UID_WIDTH 16
#    define CRAMFS_SIZE_WIDTH 24
#    define CRAMFS_GID_WIDTH 8
#    define CRAMFS_NAMELEN_WIDTH 6
#    define CRAMFS_OFFSET_WIDTH 26

/*
 * Since inode.namelen is a unsigned 6-bit number, the maximum cramfs
 * path length is 63 << 2 = 252.
 */
#    define CRAMFS_MAXPATHLEN (((1 << CRAMFS_NAMELEN_WIDTH) - 1) << 2)

/*
 * Reasonably terse representation of the inode data.
 */
struct cramfs_inode {
	u32 mode:CRAMFS_MODE_WIDTH, uid:CRAMFS_UID_WIDTH;
	/* SIZE for device files is i_rdev */
	u32 size:CRAMFS_SIZE_WIDTH, gid:CRAMFS_GID_WIDTH;
	/* NAMELEN is the length of the file name, divided by 4 and
	   rounded up.  (cramfs doesn't support hard links.) */
	/* OFFSET: For symlinks and non-empty regular files, this
	   contains the offset (divided by 4) of the file data in
	   compressed form (starting with an array of block pointers;
	   see README).  For non-empty directories it is the offset
	   (divided by 4) of the inode of the first file in that
	   directory.  For anything else, offset is zero. */
	u32 namelen:CRAMFS_NAMELEN_WIDTH, offset:CRAMFS_OFFSET_WIDTH;
};

struct cramfs_info {
	u32 crc;
	u32 edition;
	u32 blocks;
	u32 files;
};

/*
 * Superblock information at the beginning of the FS.
 */
struct cramfs_super {
	u32 magic;					/* 0x28cd3d45 - random number */
	u32 size;					/* length in bytes */
	u32 flags;					/* feature flags */
	u32 future;					/* reserved for future use */
	u8 signature[16];			/* "Compressed ROMFS" */
	struct cramfs_info fsid;	/* unique filesystem info */
	u8 name[16];				/* user-defined name */
	struct cramfs_inode root;	/* root inode data */
};

/*
 * Feature flags
 *
 * 0x00000000 - 0x000000ff: features that work for all past kernels
 * 0x00000100 - 0xffffffff: features that don't work for past kernels
 */
#    define CRAMFS_FLAG_FSID_VERSION_2	0x00000001
												/* fsid version #2 */
#    define CRAMFS_FLAG_SORTED_DIRS		0x00000002
												/* sorted dirs */
#    define CRAMFS_FLAG_HOLES		0x00000100
											/* support for holes */
#    define CRAMFS_FLAG_WRONG_SIGNATURE	0x00000200
												/* reserved */
#    define CRAMFS_FLAG_SHIFTED_ROOT_OFFSET	0x00000400
													/* shifted root fs */

/*
 * Valid values in super.flags.  Currently we refuse to mount
 * if (flags & ~CRAMFS_SUPPORTED_FLAGS).  Maybe that should be
 * changed to test super.future instead.
 */
#    define CRAMFS_SUPPORTED_FLAGS	( 0x000000ff \
				| CRAMFS_FLAG_HOLES \
				| CRAMFS_FLAG_WRONG_SIGNATURE \
				| CRAMFS_FLAG_SHIFTED_ROOT_OFFSET )

#endif /* __CRAMFS_FS_H */


================================================
FILE: include/cramfs/cramfsswap.h
================================================
#ifndef __CRAMFSSWAP_H
#define __CRAMFSSWAP_H
int cramswap(char *sinfile, char *soutfile);
#endif //__CRAMFSSWAP_H


================================================
FILE: include/crc.h
================================================
/*
**  CRC.H - header file for SNIPPETS CRC and checksum functions
*/

#ifndef CRC__H
#    define CRC__H

#    include <stdlib.h>			/* For size_t                 */
#    include "sniptype.h"		/* For BYTE, WORD, DWORD      */

/*
**  File: ARCCRC16.C
*/

void init_crc_table(void);
WORD crc_calc(WORD crc, char *buf, unsigned nbytes);
void do_file(char *fn);

/*
**  File: CRC-16.C
*/

WORD crc16(char *data_p, WORD length);

/*
**  File: CRC-16F.C
*/

WORD updcrc(WORD icrc, BYTE * icp, size_t icnt);

/*
**  File: CRC_32.C
*/

#    define UPDC32(octet,crc) (crc_32_tab[((crc)\
     ^ ((BYTE)octet)) & 0xff] ^ ((crc) >> 8))

DWORD updateCRC32(unsigned char ch, DWORD crc);
Boolean_T crc32file(char *name, DWORD * crc, long *charcnt);
DWORD crc32buf(char *buf, size_t len);

/*
**  File: CHECKSUM.C
*/

unsigned checksum(void *buffer, size_t len, unsigned int seed);

/*
**  File: CHECKEXE.C
*/

void checkexe(char *fname);

#endif /* CRC__H */


================================================
FILE: include/epk.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * All right reserved
 */

#ifndef __EPK_H
#define __EPK_H
#include <inttypes.h>
#include <stdint.h>
#include <stdbool.h>

#define SIGNATURE_SIZE 0x80  //RSA-1024
#define SIGNATURE_SIZE_NEW 0x100 //RSA-2048
typedef unsigned char signature_t[SIGNATURE_SIZE];
typedef unsigned char signature_new_t[SIGNATURE_SIZE_NEW];

typedef enum {
	RELEASE = 0,
	DEBUG,
	TEST,
	UNKNOWN,
} BUILD_TYPE_T;

typedef enum {
    EPK,
	EPK_V2,
	EPK_V3,
	EPK_V3_NEW,
    PAK_V2,
    RAW
} FILE_TYPE_T;

typedef enum {
	SIG_SHA1,
	SIG_SHA256
} SIG_TYPE_T;

#define EPK_VERSION_FORMAT "%02" PRIx8 ".%02" PRIx8 ".%02" PRIx8 ".%02" PRIx8
#define EPKV1_VERSION_FORMAT "%02" PRIx8 ".%02" PRIx8 ".%02" PRIx8

bool isEpkVersionString(const char *str);
int wrap_verifyimage(void *signature, void *data, size_t signSize, char *config_dir, SIG_TYPE_T sigType);
int wrap_decryptimage(void *src, size_t datalen, void *dest, char *config_dir, FILE_TYPE_T type, FILE_TYPE_T *outType);
void extractEPKfile(const char *epk_file, config_opts_t *config_opts);
#endif


================================================
FILE: include/epk1.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * Copyright 2016 lprot
 * Copyright 20?? sirius
 * All right reserved
 */

#ifndef EPK1_H_
#    define EPK1_H_

#    include <stdint.h>
#    include <sys/stat.h>
#    include <sys/types.h>
#    include <stdio.h>
#    include <epk.h>
#    include <string.h>

struct pakRec_t {
	uint32_t offset;
	uint32_t size;
};

struct epk1BEHeader_t {
	unsigned char epakMagic[4];
	uint32_t fileSize;
	uint32_t pakCount;
	uint32_t offset;
	uint32_t size;
};

struct epk1BEVersion_t {
	uint8_t pad;
	uint8_t major;
	uint8_t minor1;
	uint8_t minor2;
};

struct epk1Header_t {
	unsigned char epakMagic[4];
	uint32_t fileSize;
	uint32_t pakCount;
	struct pakRec_t pakRecs[20];
	unsigned char fwVer[4];
	unsigned char otaID[32];
};

struct epk1NewHeader_t {
	unsigned char epakMagic[4];
	uint32_t fileSize;
	uint32_t pakCount;
	unsigned char fwVer[4];
	unsigned char otaID[32];
	struct pakRec_t pakRecs[26];
};

struct pakHeader_t {
	unsigned char pakName[4];
	uint32_t pakSize;
	unsigned char platform[15];
	unsigned char unknown[105];
};

void extract_epk1_file(const char *epk_file, config_opts_t *config_opts);
bool isFileEPK1(const char *epk_file);

#endif /* EPK1_H_ */


================================================
FILE: include/epk2.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * All right reserved
 */
#ifndef _EPK2_H_
#define _EPK2_H_

#include <stdint.h>
#include "mfile.h"
#include "epk.h"

#define EPK2_MAGIC "EPK2"
#define PAK_MAGIC "MPAK"

int compare_pak2_header(uint8_t *header, size_t headerSize);
int compare_epk2_header(uint8_t *header, size_t headerSize);
MFILE *isFileEPK2(const char *epk_file);
void extractEPK2(MFILE *epk, config_opts_t *config_opts);

typedef struct {
	char imageType[4];
	uint32_t imageSize; //excluded headers and signatures
	char modelName[64];
	uint32_t swVersion;
	uint32_t swDate;
	BUILD_TYPE_T devMode;
	uint32_t segmentCount;
	uint32_t segmentSize;
	uint32_t segmentIndex;
	char pakMagic[4];
	unsigned char reserved[24];
	uint32_t segmentCrc32;
} PAK_V2_HEADER_T;

typedef struct {
	uint32_t imageOffset;
	uint32_t imageSize; //containing headers (excluded signatures)
	char imageType[4];
	uint32_t imageVersion;
	uint32_t segmentSize;
} PAK_V2_LOCATION_T;

/**
 * NOTE: the number of partitions is hardcoded in the structure
 * 16 - GP2
 * 32 - (not sure if some sets use 32)
 * 64 - NC4
 **/
typedef struct {
	char fileType[4];
	uint32_t fileSize;
	uint32_t fileNum;
	char epkMagic[4];
	uint8_t epakVersion[4];
	char otaId[32];
	PAK_V2_LOCATION_T imageLocation[64];
} EPK_V2_HEADER_T;

struct epk2_structure {
	signature_t signature;
	EPK_V2_HEADER_T epkHeader;
	uint32_t crc32Info[64];
	uint32_t reserved;
	char platformVersion[16];
	char sdkVersion[16];
};

struct pak2_structure {
	signature_t signature;
	PAK_V2_HEADER_T pakHeader;
	unsigned char pData[];
};
#endif


================================================
FILE: include/epk3.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * All right reserved
 */

#ifndef __EPK3_H
#define __EPK3_H
#include "mfile.h"
#include "epk.h"

#define EPK3_MAGIC "EPK3"

int compare_epk3_header(uint8_t *header, size_t headerSize);
int compare_epk3_new_header(uint8_t *header, size_t headerSize);
MFILE *isFileEPK3(const char *epk_file);
void extractEPK3(MFILE *epk, FILE_TYPE_T epkType, config_opts_t *config_opts);

typedef struct __attribute__((packed)) {
	char epkMagic[4];
	uint8_t epkVersion[4];
	char otaId[32];
	uint32_t packageInfoSize;
	uint32_t bChunked;
} EPK_V3_HEADER_T;

typedef struct __attribute__((packed)) {
	char epkMagic[4];
	char epkVersion[4];
	char otaId[32];
	uint32_t packageInfoSize;
	uint32_t bChunked;
	uint32_t pakInfoMagic;
	uint8_t encryptType[6];
	uint8_t updateType[3];
	uint8_t gap[3];
	float updatePlatformVersion;
	float compatibleMinimumVersion;
	int needToCheckCompatibleVersion;
	uint8_t reserved[1384];
} EPK_V3_NEW_HEADER_T;

typedef union __attribute__((packed)) {
	EPK_V3_HEADER_T old;
	EPK_V3_NEW_HEADER_T new;
} EPK_V3_HEADER_UNION;

typedef struct __attribute__((packed)) {
	// SegmentInfo
	uint32_t isSegmented;
	uint32_t segmentIndex;
	uint32_t segmentCount;
	uint32_t segmentSize;
} PACKAGE_SEGMENT_INFO_T;

typedef struct __attribute__((packed)) {
	// PackageData
	//void * pData;
	uint32_t reserved;
} PACKAGE_INFO_DATA_T;

typedef struct __attribute__((packed)) {
	// PackageInfo
	uint32_t packageType;
	uint32_t packageInfoSize;
	char packageName[128];
	char packageVersion[96];
	char packageArchitecture[32];
	unsigned char checkSum[32];
	uint32_t packageSize;
	uint32_t dipk;
	PACKAGE_SEGMENT_INFO_T segmentInfo;
	PACKAGE_INFO_DATA_T infoData;
} PAK_V3_HEADER_T;

typedef struct __attribute__((packed)) {
	// ListHeader
	uint32_t packageInfoListSize;
	uint32_t packageInfoCount;
	PAK_V3_HEADER_T packages[];
} PAK_V3_LISTHEADER_T;

typedef struct __attribute__((packed)) {
	uint32_t packageInfoListSize;
	uint32_t packageInfoCount;
	uint32_t pakInfoMagic;
	PAK_V3_HEADER_T packages[];
} PAK_V3_NEW_LISTHEADER_T;

typedef union __attribute__((packed)) {
	PAK_V3_LISTHEADER_T old;
	PAK_V3_NEW_LISTHEADER_T new;
} PAK_V3_LISTHEADER_UNION;

struct __attribute__((packed)) epk3_head_structure {
	signature_t signature;
	EPK_V3_HEADER_T epkHeader;
	uint32_t crc32Info[384];
	uint32_t reserved; //or unknown
	char platformVersion[16];
	char sdkVersion[16];
};

struct __attribute__((packed)) epk3_new_head_structure {
	signature_new_t signature;
	EPK_V3_NEW_HEADER_T epkHeader;
	char platformVersion[16];
	char sdkVersion[16];
};

struct  __attribute__((packed)) epk3_structure {
	struct epk3_head_structure head;
	signature_t packageInfo_signature;
	PAK_V3_LISTHEADER_T packageInfo;
};

struct __attribute__((packed)) epk3_new_structure {
	struct epk3_new_head_structure head;
	signature_new_t packageInfo_signature;
	PAK_V3_NEW_LISTHEADER_T packageInfo;
};

typedef union __attribute__((packed)) {
	struct epk3_structure old;
	struct epk3_new_structure new;
} epk3_union;

struct __attribute__((packed)) pak3_structure {
	signature_t signature;
	PAK_V3_HEADER_T header;
};
#endif


================================================
FILE: include/jffs2/jffs2.h
================================================
/*
 * JFFS2 -- Journalling Flash File System, Version 2.
 *
 * Copyright © 2001-2007 Red Hat, Inc.
 * Copyright © 2004-2010 David Woodhouse <dwmw2@infradead.org>
 *
 * Created by David Woodhouse <dwmw2@infradead.org>
 *
 * For licensing information, see the file 'LICENCE' in the
 * jffs2 directory.
 */

#ifndef __LINUX_JFFS2_H__
#define __LINUX_JFFS2_H__

#ifdef __APPLE__
typedef __signed__ char __s8;
typedef unsigned char __u8;

typedef __signed__ short __s16;
typedef unsigned short __u16;

typedef __signed__ int __s32;
typedef unsigned int __u32;

#ifdef __GNUC__
__extension__ typedef __signed__ long long __s64;
__extension__ typedef unsigned long long __u64;
#else
typedef __signed__ long long __s64;
typedef unsigned long long __u64;
#endif
#else
#include <asm/types.h>
#endif

/* Values we may expect to find in the 'magic' field */
#define JFFS2_OLD_MAGIC_BITMASK 0x1984
#define JFFS2_MAGIC_BITMASK 0x1985
#define KSAMTIB_CIGAM_2SFFJ 0x8519 /* For detecting wrong-endian fs */
#define JFFS2_EMPTY_BITMASK 0xffff
#define JFFS2_DIRTY_BITMASK 0x0000

/* Summary node MAGIC marker */
#define JFFS2_SUM_MAGIC	0x02851885

/* We only allow a single char for length, and 0xFF is empty flash so
   we don't want it confused with a real length. Hence max 254.
*/
#define JFFS2_MAX_NAME_LEN 254

/* How small can we sensibly write nodes? */
#define JFFS2_MIN_DATA_LEN 128

#define JFFS2_COMPR_NONE	0x00
#define JFFS2_COMPR_ZERO	0x01
#define JFFS2_COMPR_RTIME	0x02
#define JFFS2_COMPR_RUBINMIPS	0x03
#define JFFS2_COMPR_COPY	0x04
#define JFFS2_COMPR_DYNRUBIN	0x05
#define JFFS2_COMPR_ZLIB	0x06
#define JFFS2_COMPR_LZO		0x07
#define JFFS2_COMPR_LZMA	0x08
/* Compatibility flags. */
#define JFFS2_COMPAT_MASK 0xc000      /* What do to if an unknown nodetype is found */
#define JFFS2_NODE_ACCURATE 0x2000
/* INCOMPAT: Fail to mount the filesystem */
#define JFFS2_FEATURE_INCOMPAT 0xc000
/* ROCOMPAT: Mount read-only */
#define JFFS2_FEATURE_ROCOMPAT 0x8000
/* RWCOMPAT_COPY: Mount read/write, and copy the node when it's GC'd */
#define JFFS2_FEATURE_RWCOMPAT_COPY 0x4000
/* RWCOMPAT_DELETE: Mount read/write, and delete the node when it's GC'd */
#define JFFS2_FEATURE_RWCOMPAT_DELETE 0x0000

#define JFFS2_NODETYPE_DIRENT (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 1)
#define JFFS2_NODETYPE_INODE (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 2)
#define JFFS2_NODETYPE_CLEANMARKER (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
#define JFFS2_NODETYPE_PADDING (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 4)

#define JFFS2_NODETYPE_SUMMARY (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 6)

#define JFFS2_NODETYPE_XATTR (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 8)
#define JFFS2_NODETYPE_XREF (JFFS2_FEATURE_INCOMPAT | JFFS2_NODE_ACCURATE | 9)

/* XATTR Related */
#define JFFS2_XPREFIX_USER		1	/* for "user." */
#define JFFS2_XPREFIX_SECURITY		2	/* for "security." */
#define JFFS2_XPREFIX_ACL_ACCESS	3	/* for "system.posix_acl_access" */
#define JFFS2_XPREFIX_ACL_DEFAULT	4	/* for "system.posix_acl_default" */
#define JFFS2_XPREFIX_TRUSTED		5	/* for "trusted.*" */

#define JFFS2_ACL_VERSION		0x0001

// Maybe later...
//#define JFFS2_NODETYPE_CHECKPOINT (JFFS2_FEATURE_RWCOMPAT_DELETE | JFFS2_NODE_ACCURATE | 3)
//#define JFFS2_NODETYPE_OPTIONS (JFFS2_FEATURE_RWCOMPAT_COPY | JFFS2_NODE_ACCURATE | 4)


#define JFFS2_INO_FLAG_PREREAD	  1	/* Do read_inode() for this one at
					   mount time, don't wait for it to
					   happen later */
#define JFFS2_INO_FLAG_USERCOMPR  2	/* User has requested a specific
					   compression type */


struct jffs2_unknown_node
{
	/* All start like this */
	__u16 magic;
	__u16 nodetype;
	__u32 totlen; /* So we can skip over nodes we don't grok */
	__u32 hdr_crc;
};

struct jffs2_raw_dirent
{
	__u16 magic;
	__u16 nodetype;	/* == JFFS2_NODETYPE_DIRENT */
	__u32 totlen;
	__u32 hdr_crc;
	__u32 pino;
	__u32 version;
	__u32 ino; /* == zero for unlink */
	__u32 mctime;
	__u8 nsize;
	__u8 type;
	__u8 unused[2];
	__u32 node_crc;
	__u32 name_crc;
	__u8 name[0];
};

/* The JFFS2 raw inode structure: Used for storage on physical media.  */
/* The uid, gid, atime, mtime and ctime members could be longer, but
   are left like this for space efficiency. If and when people decide
   they really need them extended, it's simple enough to add support for
   a new type of raw node.
*/
struct jffs2_raw_inode
{
	__u16 magic;      /* A constant magic number.  */
	__u16 nodetype;   /* == JFFS2_NODETYPE_INODE */
	__u32 totlen;     /* Total length of this node (inc data, etc.) */
	__u32 hdr_crc;
	__u32 ino;        /* Inode number.  */
	__u32 version;    /* Version number.  */
	__u32 mode;       /* The file's type or mode.  */
	__u16 uid;        /* The file's owner.  */
	__u16 gid;        /* The file's group.  */
	__u32 isize;      /* Total resultant size of this inode (used for truncations)  */
	__u32 atime;      /* Last access time.  */
	__u32 mtime;      /* Last modification time.  */
	__u32 ctime;      /* Change time.  */
	__u32 offset;     /* Where to begin to write.  */
	__u32 csize;      /* (Compressed) data size */
	__u32 dsize;	     /* Size of the node's data. (after decompression) */
	__u8 compr;       /* Compression algorithm used */
	__u8 usercompr;   /* Compression algorithm requested by the user */
	__u16 flags;	     /* See JFFS2_INO_FLAG_* */
	__u32 data_crc;   /* CRC for the (compressed) data.  */
	__u32 node_crc;   /* CRC for the raw inode (excluding data)  */
	__u8 data[0];
};

struct jffs2_raw_xattr {
	__u16 magic;
	__u16 nodetype;	/* = JFFS2_NODETYPE_XATTR */
	__u32 totlen;
	__u32 hdr_crc;
	__u32 xid;		/* XATTR identifier number */
	__u32 version;
	__u8 xprefix;
	__u8 name_len;
	__u16 value_len;
	__u32 data_crc;
	__u32 node_crc;
	__u8 data[0];
} __attribute__((packed));

struct jffs2_raw_xref
{
	__u16 magic;
	__u16 nodetype;	/* = JFFS2_NODETYPE_XREF */
	__u32 totlen;
	__u32 hdr_crc;
	__u32 ino;		/* inode number */
	__u32 xid;		/* XATTR identifier number */
	__u32 xseqno;	/* xref sequential number */
	__u32 node_crc;
} __attribute__((packed));

struct jffs2_raw_summary
{
	__u16 magic;
	__u16 nodetype; 	/* = JFFS2_NODETYPE_SUMMARY */
	__u32 totlen;
	__u32 hdr_crc;
	__u32 sum_num;	/* number of sum entries*/
	__u32 cln_mkr;	/* clean marker size, 0 = no cleanmarker */
	__u32 padded;	/* sum of the size of padding nodes */
	__u32 sum_crc;	/* summary information crc */
	__u32 node_crc; 	/* node crc */
	__u32 sum[0]; 	/* inode summary info */
};

union jffs2_node_union
{
	struct jffs2_raw_inode i;
	struct jffs2_raw_dirent d;
	struct jffs2_raw_xattr x;
	struct jffs2_raw_xref r;
	struct jffs2_raw_summary s;
	struct jffs2_unknown_node u;
};

/* Data payload for device nodes. */
union jffs2_device_node {
	__u16 old_id;
	__u32 new_id;
};

#ifdef __cplusplus
extern "C" {
#endif

#include <stdbool.h>

struct jffs2_main_args {
	int erase_size;
	int verbose;
	bool keep_unlinked;
};

int jffs2extract(char *infile, char *outdir, struct jffs2_main_args);
#ifdef __cplusplus
}
#endif

#endif /* __LINUX_JFFS2_H__ */


================================================
FILE: include/jffs2/mini_inflate.h
================================================
/*-------------------------------------------------------------------------
 * Filename:      mini_inflate.h
 * Version:       $Id: mini_inflate.h,v 1.2 2002/01/17 00:53:20 nyet Exp $
 * Copyright:     Copyright (C) 2001, Russ Dill
 * Author:        Russ Dill <Russ.Dill@asu.edu>
 * Description:   Mini deflate implementation
 *-----------------------------------------------------------------------*/
/*
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

typedef __SIZE_TYPE__ size;

#define NO_ERROR 0
#define COMP_UNKNOWN 1			/* The specififed bytype is invalid */
#define CODE_NOT_FOUND 2		/* a huffman code in the stream could not be decoded */
#define TOO_MANY_BITS 3			/* pull_bits was passed an argument that is too
								 * large */

/* This struct represents an entire huffman code set. It has various lookup
 * tables to speed decoding */
struct huffman_set {
	int bits;					/* maximum bit length */
	int num_symbols;			/* Number of symbols this code can represent */
	int *lengths;				/* The bit length of symbols */
	int *symbols;				/* All of the symbols, sorted by the huffman code */
	int *count;					/* the number of codes of this bit length */
	int *first;					/* the first code of this bit length */
	int *pos;					/* the symbol that first represents (in the symbols
								 * array) */
};

struct bitstream {
	unsigned char *data;		/* increments as we move from byte to byte */
	unsigned char bit;			/* 0 to 7 */
	void *(*memcpy) (void *, const void *, size);
	unsigned long decoded;		/* The number of bytes decoded */
	int error;

	int distance_count[16];
	int distance_first[16];
	int distance_pos[16];
	int distance_lengths[32];
	int distance_symbols[32];

	int code_count[8];
	int code_first[8];
	int code_pos[8];
	int code_lengths[19];
	int code_symbols[19];

	int length_count[16];
	int length_first[16];
	int length_pos[16];
	int length_lengths[288];
	int length_symbols[288];

	struct huffman_set codes;
	struct huffman_set lengths;
	struct huffman_set distance;
};

#define NO_COMP 0
#define FIXED_COMP 1
#define DYNAMIC_COMP 2

long decompress_block(unsigned char *dest, unsigned char *source, void *(*inflate_memcpy) (void *dest, const void *src, size n));


================================================
FILE: include/log.h
================================================
#ifndef _LOG_H_
#    define _LOG_H_
/*
* Copyright (c) 2011 Roman Tokarev <roman.s.tokarev@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#    define error_level 0
#    define info_level 1
#    define debug_level 2

#    define say_error(format, args...) say(error_level, "error: "format, ##args)
#    define say_info(format, args...) say(info_level, "info: "format, ##args)
#    define say_debug(format, args...) say(debug_level, "debug: "format, ##args)

extern unsigned verbose;

int create_log(const char *fname);
void say(unsigned level, const char *format, ...);

#endif


================================================
FILE: include/lz4/bench.h
================================================
/*
    bench.h - Demo program to benchmark open-source compression algorithm
    Copyright (C) Yann Collet 2012

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

	You can contact the author at :
	- LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
	- LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once

#if defined (__cplusplus)
extern "C" {
#endif

	int BMK_benchFile(char **fileNamesTable, int nbFiles, int cLevel);

// Parameters
	void BMK_SetBlocksize(int bsize);
	void BMK_SetNbIterations(int nbLoops);

#if defined (__cplusplus)
}
#endif


================================================
FILE: include/lz4/lz4.h
================================================
/*
   LZ4 - Fast LZ compression algorithm
   Header File
   Copyright (C) 2011-2012, Yann Collet.
   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are
   met:

       * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
       * Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer
   in the documentation and/or other materials provided with the
   distribution.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   You can contact the author at :
   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
   - LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once

#if defined (__cplusplus)
extern "C" {
#endif

//****************************
// Simple Functions
//****************************

int LZ4_compress(const char *source, char *dest, int isize);
int LZ4_uncompress(const char *source, char *dest, int osize);

int LZ4_decode_file(const char *input_filename, const char *output_filename);

/*
LZ4_compress() :
	isize  : is the input size. Max supported value is ~1.9GB
	return : the number of bytes written in buffer dest
			 or 0 if the compression fails (if LZ4_COMPRESSMIN is set)
	note : destination buffer must be already allocated.
		destination buffer must be sized to handle worst cases situations (input data not compressible)
		worst case size evaluation is provided by function LZ4_compressBound()

LZ4_uncompress() :
	osize  : is the output size, therefore the original size
	return : the number of bytes read in the source buffer
			 If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
			 This function never writes beyond dest + osize, and is therefore protected against malicious data packets
	note : destination buffer must be already allocated
*/

//****************************
// Advanced Functions
//****************************

int LZ4_compressBound(int isize);

/*
LZ4_compressBound() :
	Provides the maximum size that LZ4 may output in a "worst case" scenario (input data not compressible)
	primarily useful for memory allocation of output buffer.

	isize  : is the input size. Max supported value is ~1.9GB
	return : maximum output size in a "worst case" scenario
	note : this function is limited by "int" range (2^31-1)
*/

int LZ4_uncompress_unknownOutputSize(const char *source, char *dest, int isize, int maxOutputSize);

/*
LZ4_uncompress_unknownOutputSize() :
	isize  : is the input size, therefore the compressed size
	maxOutputSize : is the size of the destination buffer (which must be already allocated)
	return : the number of bytes decoded in the destination buffer (necessarily <= maxOutputSize)
			 If the source stream is malformed, the function will stop decoding and return a negative result, indicating the byte position of the faulty instruction
			 This function never writes beyond dest + maxOutputSize, and is therefore protected against malicious data packets
	note   : Destination buffer must be already allocated.
	         This version is slightly slower than LZ4_uncompress()
*/

int LZ4_compressCtx(void **ctx, const char *source, char *dest, int isize);
int LZ4_compress64kCtx(void **ctx, const char *source, char *dest, int isize);

/*
LZ4_compressCtx() :
	This function explicitly handles the CTX memory structure.
	It avoids allocating/deallocating memory between each call, improving performance when malloc is heavily invoked.
	This function is only useful when memory is allocated into the heap (HASH_LOG value beyond STACK_LIMIT)
	Performance difference will be noticeable only when repetitively calling the compression function over many small segments.
	Note : by default, memory is allocated into the stack, therefore "malloc" is not invoked.
LZ4_compress64kCtx() :
	Same as LZ4_compressCtx(), but specific to small inputs (<64KB).
	isize *Must* be <64KB, otherwise the output will be corrupted.

	On first call : provide a *ctx=NULL; It will be automatically allocated.
	On next calls : reuse the same ctx pointer.
	Use different pointers for different threads when doing multi-threading.

*/

#if defined (__cplusplus)
}
#endif


================================================
FILE: include/lz4/lz4hc.h
================================================
/*
   LZ4 HC - High Compression Mode of LZ4
   Header File
   Copyright (C) 2011-2012, Yann Collet.
   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)

   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are
   met:

       * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
       * Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the following disclaimer
   in the documentation and/or other materials provided with the
   distribution.

   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

   You can contact the author at :
   - LZ4 homepage : http://fastcompression.blogspot.com/p/lz4.html
   - LZ4 source repository : http://code.google.com/p/lz4/
*/
#pragma once

#if defined (__cplusplus)
extern "C" {
#endif

	int LZ4_compressHC(const char *source, char *dest, int isize);

/*
LZ4_compressHC :
	return : the number of bytes in compressed buffer dest
	note : destination buffer must be already allocated.
		To avoid any problem, size it to handle worst cases situations (input data not compressible)
		Worst case size evaluation is provided by function LZ4_compressBound() (see "lz4.h")
*/

/* Note :
Decompression functions are provided within regular LZ4 source code (see "lz4.h") (BSD license)
*/

#if defined (__cplusplus)
}
#endif


================================================
FILE: include/lzhs/lzhs.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * Copyright 2016 lprot
 * All right reserved
 */
#ifndef _LZHS_H
#define _LZHS_H

#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "mfile.h"

struct lzhs_header {
	uint32_t uncompressedSize, compressedSize;
	uint16_t checksum; /* checksum is 1 byte, segment number is 2 bytes */
	uint8_t spare[6];
};

/* for LZSS */
#define N             4096
#define F             34
#define THRESHOLD     2

struct lzhs_ctx {
	/* LZSS  */
	unsigned long int textsize, codesize;
	uint8_t text_buf[N + F - 1];
	int32_t match_length, match_position, lson[N + 1], rson[N + 257], dad[N + 1];

	/* Huffman  */
	int32_t i, j, k;
	uint32_t c, code, len, code_buf_ptr;
	uint8_t code_buf[32], mask, bitno;
	uint32_t preno, precode;
};

/*for Huffman */
typedef struct __attribute__ ((__packed__)) {
	uint32_t code;
	uint32_t len;
} t_code;

struct lzhs_ctx *lzhs_ctx_new();
void lzhs_init_lookup();
void unlzss(struct lzhs_ctx *ctx, cursor_t *in, cursor_t *out);
void unhuff(struct lzhs_ctx *ctx, cursor_t *in, cursor_t *out);

MFILE *is_lzhs(const char *filename);
bool _is_lzhs_mem(struct lzhs_header *header);
bool is_lzhs_mem(MFILE *file, off_t offset);

void lzss(struct lzhs_ctx *ctx, FILE * infile, FILE * outfile, unsigned long int *p_textsize, unsigned long int *p_codesize);
void huff(struct lzhs_ctx *ctx, FILE * in, FILE * out, unsigned long int *p_textsize, unsigned long int *p_codesize);

int process_lzhs_segment(MFILE *in_file, off_t offset, const char *name);

int extract_lzhs(MFILE *in_file);
cursor_t *lzhs_decode(MFILE *in_file, off_t offset, const char *out_path, uint8_t *out_checksum);
void lzhs_encode(const char *infile, const char *outfile);
void scan_lzhs(const char *filename, int extract);

#endif


================================================
FILE: include/lzhs/tables.h
================================================
/**
 * Copyright 2016 Smx <smxdev4@gmail.com>
 * Copyright 2016 lprot
 * All right reserved
 */
#ifndef _LZHS_TAB_H
#    define _LZHS_TAB_H
static uint8_t charlen_table[2304] = {	//256 + 32 elements of t_code
	0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x0A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x29, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x2B, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x2D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x2E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x2F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x8A, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x8B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x8D, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8E, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x30, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x8F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x90, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x91, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x81, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x82, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x83, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x31, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x92, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x93, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x94, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x0B, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x84, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x85, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x86, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x0C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x33, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x95, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x96, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x97, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x87, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x88, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x34, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x99, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x89, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x9A, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x9B, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x8A, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x8B, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x35, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x9C, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x9D, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x8C, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x8D, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x8E, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x8F, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x90, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x9E, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x91, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x92, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x93, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x94, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x95, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x96, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x97, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x36, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x9F, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x37, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x98, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x99, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xA0, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x9A, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x39, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x3A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x3B, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xA1, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xA2, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xA3, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0x9B, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x9C, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x9D, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x9E, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x9F, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xA0, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xA1, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB0, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xB1, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xB2, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xA2, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xA3, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xA4, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB3, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xA5, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB4, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xB5, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xB6, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x3C, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xA5, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xA6, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xA7, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xA8, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xA6, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB7, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x0D, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xA9, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xA7, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xA8, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xA9, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xAA, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xAB, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xAC, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0x3D, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xAD, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xAA, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xAE, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xAF, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB0, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xB8, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xB9, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x3E, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xB1, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xB2, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB3, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xBA, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xBB, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xBC, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xBD, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x3F, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xAB, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xB4, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB5, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xB6, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xBE, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xBF, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xC0, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xAC, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xAD, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xB7, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xB8, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xB9, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xC1, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xC2, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xC3, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xAE, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xAF, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xB0, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xC4, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xC5, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xC6, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xC7, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xC8, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x40, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xB1, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xBA, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xBB, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xC9, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xCA, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xCB, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xCC, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xB2, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xB3, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xCD, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xCE, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xCF, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xD0, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xD1, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xDE, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xB4, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xBC, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xBD, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xBE, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xD2, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xD3, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xDF, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xE0, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xB5, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xD4, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xD5, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE1, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xD6, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xB6, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xD7, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE2, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xD8, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE3, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xE4, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xE5, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xD9, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xB7, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xE6, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xE7, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xB8, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xBF, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xDA, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xDB, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xDC, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE8, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xE9, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xEA, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xC0, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xC1, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xDD, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xEB, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xDE, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xEC, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xED, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xEE, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0x0E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x0F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0xC2, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xC3, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xDF, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xC4, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xEF, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xF0, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xC5, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xC6, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xE0, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE1, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xC7, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xE2, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xF1, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xF2, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0x10, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0xC8, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xC9, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xE3, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xE4, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xCA, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xCB, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0xCC, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xCD, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xCE, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xE5, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xE6, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE7, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xE8, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xE9, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0x42, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0xB9, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xF3, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xF4, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xEA, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xF5, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xCF, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xD0, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xBA, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xD1, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xD2, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xD3, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xD4, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xD5, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xBB, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x11, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x13, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x44, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
	0xBC, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xBD, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
	0xBE, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0xD6, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
	0xD7, 0x01, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0xEB, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xEC, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xED, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00,
	0xEE, 0x03, 0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0xF6, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xF7, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xF8, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xF9, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xFA, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00,
	0xFB, 0x07, 0x00, 0x00, 0x0B, 0x00, 0x00, 0x00, 0xF8, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
	0xF9, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xFA, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00,
	0xFB, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xFC, 0x1F, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
	0xFC, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xFD, 0x1F, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
	0xFD, 0x0F, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0xFE, 0x1F, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00,
	0xFF, 0x1F, 0x00, 0x00, 0x0D, 0x00, 0x00, 0x00, 0xBF, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00
};

static uint8_t pos_table[256] = {		//32 elements of t_code
	0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
	0x06, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x0E, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x0F, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x11, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x13, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
	0x2A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2B, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x2C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2D, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x2E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x2F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x30, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x32, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x34, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x36, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x38, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x3A, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3B, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x3C, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3D, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
	0x3E, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00
};
#endif


================================================
FILE: include/lzma/LzFind.h
================================================
/* LzFind.h -- Match finder for LZ algorithms
2009-04-22 : Igor Pavlov : Public domain */

#ifndef __LZ_FIND_H
#define __LZ_FIND_H

#include "Types.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef UInt32 CLzRef;

typedef struct _CMatchFinder
{
  Byte *buffer;
  UInt32 pos;
  UInt32 posLimit;
  UInt32 streamPos;
  UInt32 lenLimit;

  UInt32 cyclicBufferPos;
  UInt32 cyclicBufferSize; /* it must be = (historySize + 1) */

  UInt32 matchMaxLen;
  CLzRef *hash;
  CLzRef *son;
  UInt32 hashMask;
  UInt32 cutValue;

  Byte *bufferBase;
  ISeqInStream *stream;
  int streamEndWasReached;

  UInt32 blockSize;
  UInt32 keepSizeBefore;
  UInt32 keepSizeAfter;

  UInt32 numHashBytes;
  int directInput;
  size_t directInputRem;
  int btMode;
  int bigHash;
  UInt32 historySize;
  UInt32 fixedHashSize;
  UInt32 hashSizeSum;
  UInt32 numSons;
  SRes result;
  UInt32 crc[256];
} CMatchFinder;

#define Inline_MatchFinder_GetPointerToCurrentPos(p) ((p)->buffer)
#define Inline_MatchFinder_GetIndexByte(p, index) ((p)->buffer[(Int32)(index)])

#define Inline_MatchFinder_GetNumAvailableBytes(p) ((p)->streamPos - (p)->pos)

int MatchFinder_NeedMove(CMatchFinder *p);
Byte *MatchFinder_GetPointerToCurrentPos(CMatchFinder *p);
void MatchFinder_MoveBlock(CMatchFinder *p);
void MatchFinder_ReadIfRequired(CMatchFinder *p);

void MatchFinder_Construct(CMatchFinder *p);

/* Conditions:
     historySize <= 3 GB
     keepAddBufferBefore + matchMaxLen + keepAddBufferAfter < 511MB
*/
int MatchFinder_Create(CMatchFinder *p, UInt32 historySize,
    UInt32 keepAddBufferBefore, UInt32 matchMaxLen, UInt32 keepAddBufferAfter,
    ISzAlloc *alloc);
void MatchFinder_Free(CMatchFinder *p, ISzAlloc *alloc);
void MatchFinder_Normalize3(UInt32 subValue, CLzRef *items, UInt32 numItems);
void MatchFinder_ReduceOffsets(CMatchFinder *p, UInt32 subValue);

UInt32 * GetMatchesSpec1(UInt32 lenLimit, UInt32 curMatch, UInt32 pos, const Byte *buffer, CLzRef *son,
    UInt32 _cyclicBufferPos, UInt32 _cyclicBufferSize, UInt32 _cutValue,
    UInt32 *distances, UInt32 maxLen);

/*
Conditions:
  Mf_GetNumAvailableBytes_Func must be called before each Mf_GetMatchLen_Func.
  Mf_GetPointerToCurrentPos_Func's result must be used only before any other function
*/

typedef void (*Mf_Init_Func)(void *object);
typedef Byte (*Mf_GetIndexByte_Func)(void *object, Int32 index);
typedef UInt32 (*Mf_GetNumAvailableBytes_Func)(void *object);
typedef const Byte * (*Mf_GetPointerToCurrentPos_Func)(void *object);
typedef UInt32 (*Mf_GetMatches_Func)(void *object, UInt32 *distances);
typedef void (*Mf_Skip_Func)(void *object, UInt32);

typedef struct _IMatchFinder
{
  Mf_Init_Func Init;
  Mf_GetIndexByte_Func GetIndexByte;
  Mf_GetNumAvailableBytes_Func GetNumAvailableBytes;
  Mf_GetPointerToCurrentPos_Func GetPointerToCurrentPos;
  Mf_GetMatches_Func GetMatches;
  Mf_Skip_Func Skip;
} IMatchFinder;

void MatchFinder_CreateVTable(CMatchFinder *p, IMatchFinder *vTable);

void MatchFinder_Init(CMatchFinder *p);
UInt32 Bt3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
UInt32 Hc3Zip_MatchFinder_GetMatches(CMatchFinder *p, UInt32 *distances);
void Bt3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);
void Hc3Zip_MatchFinder_Skip(CMatchFinder *p, UInt32 num);

#ifdef __cplusplus
}
#endif

#endif


================================================
FILE: include/lzma/LzHash.h
================================================
/* LzHash.h -- HASH functions for LZ algorithms
2009-02-07 : Igor Pavlov : Public domain */

#ifndef __LZ_HASH_H
#define __LZ_HASH_H

#define kHash2Size (1 << 10)
#define kHash3Size (1 << 16)
#define kHash4Size (1 << 20)

#define kFix3HashSize (kHash2Size)
#define kFix4HashSize (kHash2Size + kHash3Size)
#define kFix5HashSize (kHash2Size + kHash3Size + kHash4Size)

#define HASH2_CALC hashValue = cur[0] | ((UInt32)cur[1] << 8);

#define HASH3_CALC { \
  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
  hash2Value = temp & (kHash2Size - 1); \
  hashValue = (temp ^ ((UInt32)cur[2] << 8)) & p->hashMask; }

#define HASH4_CALC { \
  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
  hash2Value = temp & (kHash2Size - 1); \
  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
  hashValue = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & p->hashMask; }

#define HASH5_CALC { \
  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
  hash2Value = temp & (kHash2Size - 1); \
  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)); \
  hashValue = (hash4Value ^ (p->crc[cur[4]] << 3)) & p->hashMask; \
  hash4Value &= (kHash4Size - 1); }

/* #define HASH_ZIP_CALC hashValue = ((cur[0] | ((UInt32)cur[1] << 8)) ^ p->crc[cur[2]]) & 0xFFFF; */
#define HASH_ZIP_CALC hashValue = ((cur[2] | ((UInt32)cur[0] << 8)) ^ p->crc[cur[1]]) & 0xFFFF;


#define MT_HASH2_CALC \
  hash2Value = (p->crc[cur[0]] ^ cur[1]) & (kHash2Size - 1);

#define MT_HASH3_CALC { \
  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
  hash2Value = temp & (kHash2Size - 1); \
  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); }

#define MT_HASH4_CALC { \
  UInt32 temp = p->crc[cur[0]] ^ cur[1]; \
  hash2Value = temp & (kHash2Size - 1); \
  hash3Value = (temp ^ ((UInt32)cur[2] << 8)) & (kHash3Size - 1); \
  hash4Value = (temp ^ ((UInt32)cur[2] << 8) ^ (p->crc[cur[3]] << 5)) & (kHash4Size - 1); }

#endif


================================================
FILE: include/lzma/LzmaDec.h
================================================
/* LzmaDec.h -- LZMA Decoder
2009-02-07 : Igor Pavlov : Public domain */

#ifndef __LZMA_DEC_H
#define __LZMA_DEC_H

#include "Types.h"

#ifdef __cplusplus
extern "C" {
#endif

/* #define _LZMA_PROB32 */
/* _LZMA_PROB32 can increase the speed on some CPUs,
   but memory usage for CLzmaDec::probs will be doubled in that case */

#ifdef _LZMA_PROB32
#define CLzmaProb UInt32
#else
#define CLzmaProb UInt16
#endif


/* ---------- LZMA Properties ---------- */

#define LZMA_PROPS_SIZE 5

typedef struct _CLzmaProps
{
  unsigned lc, lp, pb;
  UInt32 dicSize;
} CLzmaProps;

/* LzmaProps_Decode - decodes properties
Returns:
  SZ_OK
  SZ_ERROR_UNSUPPORTED - Unsupported properties
*/

SRes LzmaProps_Decode(CLzmaProps *p, const Byte *data, unsigned size);


/* ---------- LZMA Decoder state ---------- */

/* LZMA_REQUIRED_INPUT_MAX = number of required input bytes for worst case.
   Num bits = log2((2^11 / 31) ^ 22) + 26 < 134 + 26 = 160; */

#define LZMA_REQUIRED_INPUT_MAX 20

typedef struct
{
  CLzmaProps prop;
  CLzmaProb *probs;
  Byte *dic;
  const Byte *buf;
  UInt32 range, code;
  SizeT dicPos;
  SizeT dicBufSize;
  UInt32 processedPos;
  UInt32 checkDicSize;
  unsigned state;
  UInt32 reps[4];
  unsigned remainLen;
  int needFlush;
  int needInitState;
  UInt32 numProbs;
  unsigned tempBufSize;
  Byte tempBuf[LZMA_REQUIRED_INPUT_MAX];
} CLzmaDec;

#define LzmaDec_Construct(p) { (p)->dic = 0; (p)->probs = 0; }

void LzmaDec_Init(CLzmaDec *p);

/* There are two types of LZMA streams:
     0) Stream with end mark. That end mark adds about 6 bytes to compressed size.
     1) Stream without end mark. You must know exact uncompressed size to decompress such stream. */

typedef enum
{
  LZMA_FINISH_ANY,   /* finish at any point */
  LZMA_FINISH_END    /* block must be finished at the end */
} ELzmaFinishMode;

/* ELzmaFinishMode has meaning only if the decoding reaches output limit !!!

   You must use LZMA_FINISH_END, when you know that current output buffer
   covers last bytes of block. In other cases you must use LZMA_FINISH_ANY.

   If LZMA decoder sees end marker before reaching output limit, it returns SZ_OK,
   and output value of destLen will be less than output buffer size limit.
   You can check status result also.

   You can use multiple checks to test data integrity after full decompression:
     1) Check Result and "status" variable.
     2) Check that output(destLen) = uncompressedSize, if you know real uncompressedSize.
     3) Check that output(srcLen) = compressedSize, if you know real compressedSize.
        You must use correct finish mode in that case. */

typedef enum
{
  LZMA_STATUS_NOT_SPECIFIED,               /* use main error code instead */
  LZMA_STATUS_FINISHED_WITH_MARK,          /* stream was finished with end mark. */
  LZMA_STATUS_NOT_FINISHED,                /* stream was not finished */
  LZMA_STATUS_NEEDS_MORE_INPUT,            /* you must provide more input bytes */
  LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK  /* there is probability that stream was finished without end mark */
} ELzmaStatus;

/* ELzmaStatus is used only as output value for function call */


/* ---------- Interfaces ---------- */

/* There are 3 levels of interfaces:
     1) Dictionary Interface
     2) Buffer Interface
     3) One Call Interface
   You can select any of these interfaces, but don't mix functions from different
   groups for same object. */


/* There are two variants to allocate state for Dictionary Interface:
     1) LzmaDec_Allocate / LzmaDec_Free
     2) LzmaDec_AllocateProbs / LzmaDec_FreeProbs
   You can use variant 2, if you set dictionary buffer manually.
   For Buffer Interface you must always use variant 1.

LzmaDec_Allocate* can return:
  SZ_OK
  SZ_ERROR_MEM         - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
*/

SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_FreeProbs(CLzmaDec *p, ISzAlloc *alloc);

SRes LzmaDec_Allocate(CLzmaDec *state, const Byte *prop, unsigned propsSize, ISzAlloc *alloc);
void LzmaDec_Free(CLzmaDec *state, ISzAlloc *alloc);

/* ---------- Dictionary Interface ---------- */

/* You can use it, if you want to eliminate the overhead for data copying from
   dictionary to some other external buffer.
   You must work with CLzmaDec variables directly in this interface.

   STEPS:
     LzmaDec_Constr()
     LzmaDec_Allocate()
     for (each new stream)
     {
       LzmaDec_Init()
       while (it needs more decompression)
       {
         LzmaDec_DecodeToDic()
         use data from CLzmaDec::dic and update CLzmaDec::dicPos
       }
     }
     LzmaDec_Free()
*/

/* LzmaDec_DecodeToDic

   The decoding to internal dictionary buffer (CLzmaDec::dic).
   You must manually update CLzmaDec::dicPos, if it reaches CLzmaDec::dicBufSize !!!

finishMode:
  It has meaning only if the decoding reaches output limit (dicLimit).
  LZMA_FINISH_ANY - Decode just dicLimit bytes.
  LZMA_FINISH_END - Stream must be finished after dicLimit.

Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
      LZMA_STATUS_NEEDS_MORE_INPUT
      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
  SZ_ERROR_DATA - Data error
*/

SRes LzmaDec_DecodeToDic(CLzmaDec *p, SizeT dicLimit,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);


/* ---------- Buffer Interface ---------- */

/* It's zlib-like interface.
   See LzmaDec_DecodeToDic description for information about STEPS and return results,
   but you must use LzmaDec_DecodeToBuf instead of LzmaDec_DecodeToDic and you don't need
   to work with CLzmaDec variables manually.

finishMode:
  It has meaning only if the decoding reaches output limit (*destLen).
  LZMA_FINISH_ANY - Decode just destLen bytes.
  LZMA_FINISH_END - Stream must be finished after (*destLen).
*/

SRes LzmaDec_DecodeToBuf(CLzmaDec *p, Byte *dest, SizeT *destLen,
    const Byte *src, SizeT *srcLen, ELzmaFinishMode finishMode, ELzmaStatus *status);


/* ---------- One Call Interface ---------- */

/* LzmaDecode

finishMode:
  It has meaning only if the decoding reaches output limit (*destLen).
  LZMA_FINISH_ANY - Decode just destLen bytes.
  LZMA_FINISH_END - Stream must be finished after (*destLen).

Returns:
  SZ_OK
    status:
      LZMA_STATUS_FINISHED_WITH_MARK
      LZMA_STATUS_NOT_FINISHED
      LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK
  SZ_ERROR_DATA - Data error
  SZ_ERROR_MEM  - Memory allocation error
  SZ_ERROR_UNSUPPORTED - Unsupported properties
  SZ_ERROR_INPUT_EOF - It needs more bytes in input buffer (src).
*/

SRes LzmaDecode(Byte *dest, SizeT *destLen, const Byte *src, SizeT *srcLen,
    const Byte *propData, unsigned propSize, ELzmaFinishMode finishMode,
    ELzmaStatus *status, ISzAlloc *alloc);

#ifdef __cplusplus
}
#endif

#endif


================================================
FILE: include/lzma/LzmaEnc.h
================================================
/*  LzmaEnc.h -- LZMA Encoder
2009-02-07 : Igor Pavlov : Public domain */

#ifndef __LZMA_ENC_H
#define __LZMA_ENC_H

#include "Types.h"

#ifdef __cplusplus
extern "C" {
#endif

#define LZMA_PROPS_SIZE 5

typedef struct _CLzmaEncProps
{
  int level;       /*  0 <= level <= 9 */
  UInt32 dictSize; /* (1 << 12) <= dictSize <= (1 << 27) for 32-bit version
                      (1 << 12) <= dictSize <= (1 << 30) for 64-bit version
                       default = (1 << 24) */
  int lc;          /* 0 <= lc <= 8, default = 3 */
  int lp;          /* 0 <= lp <= 4, default = 0 */
  int pb;          /* 0 <= pb <= 4, default = 2 */
  int algo;        /* 0 - fast, 1 - normal, default = 1 */
  int fb;          /* 5 <= fb <= 273, default = 32 */
  int btMode;      /* 0 - hashChain Mode, 1 - binTree mode - normal, default = 1 */
  int numHashBytes; /* 2, 3 or 4, default = 4 */
  UInt32 mc;        /* 1 <= mc <= (1 << 30), default = 32 */
  unsigned writeEndMark;  /* 0 - do not write EOPM, 1 - write EOPM, default = 0 */
  int numThreads;  /* 1 or 2, default = 2 */
} CLzmaEncProps;

void LzmaEncProps_Init(CLzmaEncProps *p);
void LzmaEncProps_Normalize(CLzmaEncProps *p);
UInt32 LzmaEncProps_GetDictSize(const CLzmaEncProps *props2);


/* ---------- CLzmaEncHandle Interface ---------- */

/* LzmaEnc_* functions can return the following exit codes:
Returns:
  SZ_OK           - OK
  SZ_ERROR_MEM    - Memory allocation error
  SZ_ERROR_PARAM  - Incorrect paramater in props
  SZ_ERROR_WRITE  - Write callback error.
  SZ_ERROR_PROGRESS - some break from progress callback
  SZ_ERROR_THREAD - errors in multithreading functions (only for Mt version)
*/

typedef void * CLzmaEncHandle;

CLzmaEncHandle LzmaEnc_Create(ISzAlloc *alloc);
void LzmaEnc_Destroy(CLzmaEncHandle p, ISzAlloc *alloc, ISzAlloc *allocBig);
SRes LzmaEnc_SetProps(CLzmaEncHandle p, const CLzmaEncProps *props);
SRes LzmaEnc_WriteProperties(CLzmaEncHandle p, Byte *properties, SizeT *size);
SRes LzmaEnc_Encode(CLzmaEncHandle p, ISeqOutStream *outStream, ISeqInStream *inStream,
    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);
SRes LzmaEnc_MemEncode(CLzmaEncHandle p, Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    int writeEndMark, ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

/* ---------- One Call Interface ---------- */

/* LzmaEncode
Return code:
  SZ_OK               - OK
  SZ_ERROR_MEM        - Memory allocation error
  SZ_ERROR_PARAM      - Incorrect paramater
  SZ_ERROR_OUTPUT_EOF - output buffer overflow
  SZ_ERROR_THREAD     - errors in multithreading functions (only for Mt version)
*/

SRes LzmaEncode(Byte *dest, SizeT *destLen, const Byte *src, SizeT srcLen,
    const CLzmaEncProps *props, Byte *propsEncoded, SizeT *propsSize, int writeEndMark,
    ICompressProgress *progress, ISzAlloc *alloc, ISzAlloc *allocBig);

#ifdef __cplusplus
}
#endif

#endif


================================================
FILE: include/lzma/Types.h
================================================
/* Types.h -- Basic types
2009-11-23 : Igor Pavlov : Public domain */

#ifndef __7Z_TYPES_H
#define __7Z_TYPES_H

#include <stddef.h>

#ifdef _WIN32
#include <windows.h>
#endif

#ifndef EXTERN_C_BEGIN
#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#define EXTERN_C_END }
#else
#define EXTERN_C_BEGIN
#define EXTERN_C_END
#endif
#endif

EXTERN_C_BEGIN

#define SZ_OK 0

#define SZ_ERROR_DATA 1
#define SZ_ERROR_MEM 2
#define SZ_ERROR_CRC 3
#define SZ_ERROR_UNSUPPORTED 4
#define SZ_ERROR_PARAM 5
#define SZ_ERROR_INPUT_EOF 6
#define SZ_ERROR_OUTPUT_EOF 7
#define SZ_ERROR_READ 8
#define SZ_ERROR_WRITE 9
#define SZ_ERROR_PROGRESS 10
#define SZ_ERROR_FAIL 11
#define SZ_ERROR_THREAD 12

#define SZ_ERROR_ARCHIVE 16
#define SZ_ERROR_NO_ARCHIVE 17

typedef int SRes;

#ifdef _WIN32
typedef DWORD WRes;
#else
typedef int WRes;
#endif

#ifndef RINOK
#define RINOK(x) { int __result__ = (x); if (__result__ != 0) return __result__; }
#endif

typedef unsigned char Byte;
typedef short Int16;
typedef unsigned short UInt16;

#ifdef _LZMA_UINT32_IS_ULONG
typedef long Int32;
typedef unsigned long UInt32;
#else
typedef int Int32;
typedef unsigned int UInt32;
#endif

#ifdef _SZ_NO_INT_64

/* define _SZ_NO_INT_64, if your compiler doesn't support 64-bit integers.
   NOTES: Some code will work incorrectly in that case! */

typedef long Int64;
typedef unsigned long UInt64;

#else

#if defined(_MSC_VER) || defined(__BORLANDC__)
typedef __int64 Int64;
typedef unsigned __int64 UInt64;
#else
typedef long long int Int64;
typedef unsigned long long int UInt64;
#endif

#endif

#ifdef _LZMA_NO_SYSTEM_SIZE_T
typedef UInt32 SizeT;
#else
typedef size_t SizeT;
#endif

typedef int Bool;
#define True 1
#define False 0


#ifdef _WIN32
#define MY_STD_CALL __stdcall
#else
#define MY_STD_CALL
#endif

#ifdef _MSC_VER

#if _MSC_VER >= 1300
#define MY_NO_INLINE __declspec(noinline)
#else
#define MY_NO_INLINE
#endif

#define MY_CDECL __cdecl
#define MY_FAST_CALL __fastcall

#else

#define MY_CDECL
#define MY_FAST_CALL

#endif


/* The following interfaces use first parameter as pointer to structure */

typedef struct
{
  SRes (*Read)(void *p, void *buf, size_t *size);
    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
       (output(*size) < input(*size)) is allowed */
} ISeqInStream;

/* it can return SZ_ERROR_INPUT_EOF */
SRes SeqInStream_Read(ISeqInStream *stream, void *buf, size_t size);
SRes SeqInStream_Read2(ISeqInStream *stream, void *buf, size_t size, SRes errorType);
SRes SeqInStream_ReadByte(ISeqInStream *stream, Byte *buf);

typedef struct
{
  size_t (*Write)(void *p, const void *buf, size_t size);
    /* Returns: result - the number of actually written bytes.
       (result < size) means error */
} ISeqOutStream;

typedef enum
{
  SZ_SEEK_SET = 0,
  SZ_SEEK_CUR = 1,
  SZ_SEEK_END = 2
} ESzSeek;

typedef struct
{
  SRes (*Read)(void *p, void *buf, size_t *size);  /* same as ISeqInStream::Read */
  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
} ISeekInStream;

typedef struct
{
  SRes (*Look)(void *p, void **buf, size_t *size);
    /* if (input(*size) != 0 && output(*size) == 0) means end_of_stream.
       (output(*size) > input(*size)) is not allowed
       (output(*size) < input(*size)) is allowed */
  SRes (*Skip)(void *p, size_t offset);
    /* offset must be <= output(*size) of Look */

  SRes (*Read)(void *p, void *buf, size_t *size);
    /* reads directly (without buffer). It's same as ISeqInStream::Read */
  SRes (*Seek)(void *p, Int64 *pos, ESzSeek origin);
} ILookInStream;

SRes LookInStream_LookRead(ILookInStream *stream, void *buf, size_t *size);
SRes LookInStream_SeekTo(ILookInStream *stream, UInt64 offset);

/* reads via ILookInStream::Read */
SRes LookInStream_Read2(ILookInStream *stream, void *buf, size_t size, SRes errorType);
SRes LookInStream_Read(ILookInStream *stream, void *buf, size_t size);

#define LookToRead_BUF_SIZE (1 << 14)

typedef struct
{
  ILookInStream s;
  ISeekInStream *realStream;
  size_t pos;
  size_t size;
  Byte buf[LookToRead_BUF_SIZE];
} CLookToRead;

void LookToRead_CreateVTable(CLookToRead *p, int lookahead);
void LookToRead_Init(CLookToRead *p);

typedef struct
{
  ISeqInStream s;
  ILookInStream *realStream;
} CSecToLook;

void SecToLook_CreateVTable(CSecToLook *p);

typedef struct
{
  ISeqInStream s;
  ILookInStream *realStream;
} CSecToRead;

void SecToRead_CreateVTable(CSecToRead *p);

typedef struct
{
  SRes (*Progress)(void *p, UInt64 inSize, UInt64 outSize);
    /* Returns: result. (result != SZ_OK) means break.
       Value (UInt64)(Int64)-1 for size means unknown value. */
} ICompressProgress;

typedef struct
{
  void *(*Alloc)(void *p, size_t size);
  void (*Free)(void *p, void *address); /* address can be 0 */
} ISzAlloc;

#define IAlloc_Alloc(p, size) (p)->Alloc((p), size)
#define IAlloc_Free(p, a) (p)->Free((p), a)

EXTERN_C_END

#endif


================================================
FILE: include/lzma.h
================================================
#pragma once

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "jffs2/jffs2.h"
#ifndef PAGE_SIZE
	extern int page_size;
	#define PAGE_SIZE page_size
#endif
#define LZMA_MALLOC malloc
#define LZMA_FREE free
#define PRINT_ERROR(msg) fprintf(stderr, msg)
#define INIT
#define STATIC

#ifndef __APPLE__
#    include <asm/types.h>
#endif

#include "lzma/LzmaDec.h"
#include "lzma/LzmaEnc.h"

#define LZMA_BEST_LEVEL (9)
#define LZMA_BEST_LC    (0)
#define LZMA_BEST_LP    (0)
#define LZMA_BEST_PB    (0)
#define LZMA_BEST_FB  (273)

#define LZMA_BEST_DICT(n) (((int)((n) / 2)) * 2)

static void *p_lzma_malloc(void *p, size_t size)
{
        if (size == 0)
                return NULL;

        return LZMA_MALLOC(size);
}

static void p_lzma_free(void *p, void *address)
{
        if (address != NULL)
                LZMA_FREE(address);
}

static ISzAlloc lzma_alloc = {p_lzma_malloc, p_lzma_free};



================================================
FILE: include/lzo/lzo.h
================================================
#ifndef __LZO_LG_H
#define __LZO_LG_H
int check_lzo_header(const char *name);
int lzo_unpack(const char *in_name, const char *out_name);
#endif //__LZO_LG_H


================================================
FILE: include/lzo/miniacc.h
================================================
/* ACC --- Automatic Compiler Configuration

   This file is part of the LZO real-time data compression library.

   Copyright (C) 2008 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2007 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2006 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2005 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2004 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2003 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2002 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2001 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 2000 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1999 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1998 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1997 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1996 Markus Franz Xaver Johannes Oberhumer
   All Rights Reserved.

   The LZO library is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   The LZO library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with the LZO library; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

   Markus F.X.J. Oberhumer
   <markus@oberhumer.com>
   http://www.oberhumer.com/opensource/lzo/
 */

#ifndef __ACC_H_INCLUDED
#    define __ACC_H_INCLUDED 1
#    define ACC_VERSION     20080430L
#    if defined(__CYGWIN32__) && !defined(__CYGWIN__)
#        define __CYGWIN__ __CYGWIN32__
#    endif
#    if defined(__IBMCPP__) && !defined(__IBMC__)
#        define __IBMC__ __IBMCPP__
#    endif
#    if defined(__ICL) && defined(_WIN32) && !defined(__INTEL_COMPILER)
#        define __INTEL_COMPILER __ICL
#    endif
#    if 1 && defined(__INTERIX) && defined(__GNUC__) && !defined(_ALL_SOURCE)
#        define _ALL_SOURCE 1
#    endif
#    if defined(__mips__) && defined(__R5900__)
#        if !defined(__LONG_MAX__)
#            define __LONG_MAX__ 9223372036854775807L
#        endif
#    endif
#    if defined(__INTEL_COMPILER) && defined(__linux__)
#        pragma warning(disable: 193)
#    endif
#    if defined(__KEIL__) && defined(__C166__)
#        pragma warning disable = 322
#    elif 0 && defined(__C251__)
#        pragma warning disable = 322
#    endif
#    if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
#        if (_MSC_VER >= 1300)
#            pragma warning(disable: 4668)
#        endif
#    endif
#    if defined(__POCC__) && defined(_WIN32)
#        if (__POCC__ >= 400)
#            pragma warn(disable: 2216)
#        endif
#    endif
#    if 0 && defined(__WATCOMC__)
#        if (__WATCOMC__ >= 1050) && (__WATCOMC__ < 1060)
#            pragma warning 203 9
#        endif
#    endif
#    if defined(__BORLANDC__) && defined(__MSDOS__) && !defined(__FLAT__)
#        pragma option -h
#    endif
#    if defined(ACC_CFG_NO_CONFIG_HEADER)
#    elif defined(ACC_CFG_CONFIG_HEADER)
#        include ACC_CFG_CONFIG_HEADER
#    else
#    endif
#    if defined(ACC_CFG_NO_LIMITS_H)
#    elif defined(ACC_LIBC_NAKED) || defined(ACC_BROKEN_LIMITS_H)
#        ifndef __ACC_FALLBACK_LIMITS_H_INCLUDED
#            define __ACC_FALLBACK_LIMITS_H_INCLUDED
#            undef CHAR_BIT
#            define CHAR_BIT        8
#            ifndef MB_LEN_MAX
#                define MB_LEN_MAX      1
#            endif
#            ifndef __SCHAR_MAX__
#                define __SCHAR_MAX__   127
#            endif
#            ifndef __SHRT_MAX__
#                define __SHRT_MAX__    32767
#            endif
#            ifndef __INT_MAX__
#                define __INT_MAX__     2147483647
#            endif
#            ifndef __LONG_MAX__
#                if defined(__alpha__) || defined(_LP64) || defined(__MIPS_PSX2__)
#                    define __LONG_MAX__    9223372036854775807L
#                else
#                    define __LONG_MAX__    2147483647L
#                endif
#            endif
#            undef SCHAR_MIN
#            undef SCHAR_MAX
#            undef UCHAR_MAX
#            define SCHAR_MIN       (-1 - SCHAR_MAX)
#            define SCHAR_MAX       (__SCHAR_MAX__)
#            define UCHAR_MAX       (SCHAR_MAX * 2 + 1)
#            undef SHRT_MIN
#            undef SHRT_MAX
#            undef USHRT_MAX
#            define SHRT_MIN        (-1 - SHRT_MAX)
#            define SHRT_MAX        (__SHRT_MAX__)
#            if ((__INT_MAX__) == (__SHRT_MAX__))
#                define USHRT_MAX       (SHRT_MAX * 2U + 1U)
#            else
#                define USHRT_MAX       (SHRT_MAX * 2 + 1)
#            endif
#            undef INT_MIN
#            undef INT_MAX
#            undef UINT_MAX
#            define INT_MIN         (-1 - INT_MAX)
#            define INT_MAX         (__INT_MAX__)
#            define UINT_MAX        (INT_MAX * 2U + 1U)
#            undef LONG_MIN
#            undef LONG_MAX
#            undef ULONG_MAX
#            define LONG_MIN        (-1L - LONG_MAX)
#            define LONG_MAX        ((__LONG_MAX__) + 0L)
#            define ULONG_MAX       (LONG_MAX * 2UL + 1UL)
#            undef CHAR_MIN
#            undef CHAR_MAX
#            if defined(__CHAR_UNSIGNED__) || defined(_CHAR_UNSIGNED)
#                define CHAR_MIN        0
#                define CHAR_MAX        UCHAR_MAX
#            else
#                define CHAR_MIN        SCHAR_MIN
#                define CHAR_MAX        SCHAR_MAX
#            endif
#        endif
#    else
#        include <limits.h>
#    endif
#    if 0
#        define ACC_0xffffL             0xfffful
#        define ACC_0xffffffffL         0xfffffffful
#    else
#        define ACC_0xffffL             65535ul
#        define ACC_0xffffffffL         4294967295ul
#    endif
#    if (ACC_0xffffL == ACC_0xffffffffL)
#        error "your preprocessor is broken 1"
#    endif
#    if (16ul * 16384ul != 262144ul)
#        error "your preprocessor is broken 2"
#    endif
#    if 0
#        if (32767 >= 4294967295ul)
#            error "your preprocessor is broken 3"
#        endif
#        if (65535u >= 4294967295ul)
#            error "your preprocessor is broken 4"
#        endif
#    endif
#    if (UINT_MAX == ACC_0xffffL)
#        if defined(__ZTC__) && defined(__I86__) && !defined(__OS2__)
#            if !defined(MSDOS)
#                define MSDOS 1
#            endif
#            if !defined(_MSDOS)
#                define _MSDOS 1
#            endif
#        elif 0 && defined(__VERSION) && defined(MB_LEN_MAX)
#            if (__VERSION == 520) && (MB_LEN_MAX == 1)
#                if !defined(__AZTEC_C__)
#                    define __AZTEC_C__ __VERSION
#                endif
#                if !defined(__DOS__)
#                    define __DOS__ 1
#                endif
#            endif
#        endif
#    endif
#    if defined(_MSC_VER) && defined(M_I86HM) && (UINT_MAX == ACC_0xffffL)
#        define ptrdiff_t long
#        define _PTRDIFF_T_DEFINED
#    endif
#    if (UINT_MAX == ACC_0xffffL)
#        undef __ACC_RENAME_A
#        undef __ACC_RENAME_B
#        if defined(__AZTEC_C__) && defined(__DOS__)
#            define __ACC_RENAME_A 1
#        elif defined(_MSC_VER) && defined(MSDOS)
#            if (_MSC_VER < 600)
#                define __ACC_RENAME_A 1
#            elif (_MSC_VER < 700)
#                define __ACC_RENAME_B 1
#            endif
#        elif defined(__TSC__) && defined(__OS2__)
#            define __ACC_RENAME_A 1
#        elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410)
#            define __ACC_RENAME_A 1
#        elif defined(__PACIFIC__) && defined(DOS)
#            if !defined(__far)
#                define __far far
#            endif
#            if !defined(__near)
#                define __near near
#            endif
#        endif
#        if defined(__ACC_RENAME_A)
#            if !defined(__cdecl)
#                define __cdecl cdecl
#            endif
#            if !defined(__far)
#                define __far far
#            endif
#            if !defined(__huge)
#                define __huge huge
#            endif
#            if !defined(__near)
#                define __near near
#            endif
#            if !defined(__pascal)
#                define __pascal pascal
#            endif
#            if !defined(__huge)
#                define __huge huge
#            endif
#        elif defined(__ACC_RENAME_B)
#            if !defined(__cdecl)
#                define __cdecl _cdecl
#            endif
#            if !defined(__far)
#                define __far _far
#            endif
#            if !defined(__huge)
#                define __huge _huge
#            endif
#            if !defined(__near)
#                define __near _near
#            endif
#            if !defined(__pascal)
#                define __pascal _pascal
#            endif
#        elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__)
#            if !defined(__cdecl)
#                define __cdecl cdecl
#            endif
#            if !defined(__pascal)
#                define __pascal pascal
#            endif
#        endif
#        undef __ACC_RENAME_A
#        undef __ACC_RENAME_B
#    endif
#    if (UINT_MAX == ACC_0xffffL)
#        if defined(__AZTEC_C__) && defined(__DOS__)
#            define ACC_BROKEN_CDECL_ALT_SYNTAX 1
#        elif defined(_MSC_VER) && defined(MSDOS)
#            if (_MSC_VER < 600)
#                define ACC_BROKEN_INTEGRAL_CONSTANTS 1
#            endif
#            if (_MSC_VER < 700)
#                define ACC_BROKEN_INTEGRAL_PROMOTION 1
#                define ACC_BROKEN_SIZEOF 1
#            endif
#        elif defined(__PACIFIC__) && defined(DOS)
#            define ACC_BROKEN_INTEGRAL_CONSTANTS 1
#        elif defined(__TURBOC__) && defined(__MSDOS__)
#            if (__TURBOC__ < 0x0150)
#                define ACC_BROKEN_CDECL_ALT_SYNTAX 1
#                define ACC_BROKEN_INTEGRAL_CONSTANTS 1
#                define ACC_BROKEN_INTEGRAL_PROMOTION 1
#            endif
#            if (__TURBOC__ < 0x0200)
#                define ACC_BROKEN_SIZEOF 1
#            endif
#            if (__TURBOC__ < 0x0400) && defined(__cplusplus)
#                define ACC_BROKEN_CDECL_ALT_SYNTAX 1
#            endif
#        elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__)
#            define ACC_BROKEN_CDECL_ALT_SYNTAX 1
#            define ACC_BROKEN_SIZEOF 1
#        endif
#    endif
#    if defined(__WATCOMC__) && (__WATCOMC__ < 900)
#        define ACC_BROKEN_INTEGRAL_CONSTANTS 1
#    endif
#    if defined(_CRAY) && defined(_CRAY1)
#        define ACC_BROKEN_SIGNED_RIGHT_SHIFT 1
#    endif
#    define ACC_PP_STRINGIZE(x)             #x
#    define ACC_PP_MACRO_EXPAND(x)          ACC_PP_STRINGIZE(x)
#    define ACC_PP_CONCAT2(a,b)             a ## b
#    define ACC_PP_CONCAT3(a,b,c)           a ## b ## c
#    define ACC_PP_CONCAT4(a,b,c,d)         a ## b ## c ## d
#    define ACC_PP_CONCAT5(a,b,c,d,e)       a ## b ## c ## d ## e
#    define ACC_PP_ECONCAT2(a,b)            ACC_PP_CONCAT2(a,b)
#    define ACC_PP_ECONCAT3(a,b,c)          ACC_PP_CONCAT3(a,b,c)
#    define ACC_PP_ECONCAT4(a,b,c,d)        ACC_PP_CONCAT4(a,b,c,d)
#    define ACC_PP_ECONCAT5(a,b,c,d,e)      ACC_PP_CONCAT5(a,b,c,d,e)
#    if 1
#        define ACC_CPP_STRINGIZE(x)            #x
#        define ACC_CPP_MACRO_EXPAND(x)         ACC_CPP_STRINGIZE(x)
#        define ACC_CPP_CONCAT2(a,b)            a ## b
#        define ACC_CPP_CONCAT3(a,b,c)          a ## b ## c
#        define ACC_CPP_CONCAT4(a,b,c,d)        a ## b ## c ## d
#        define ACC_CPP_CONCAT5(a,b,c,d,e)      a ## b ## c ## d ## e
#        define ACC_CPP_ECONCAT2(a,b)           ACC_CPP_CONCAT2(a,b)
#        define ACC_CPP_ECONCAT3(a,b,c)         ACC_CPP_CONCAT3(a,b,c)
#        define ACC_CPP_ECONCAT4(a,b,c,d)       ACC_CPP_CONCAT4(a,b,c,d)
#        define ACC_CPP_ECONCAT5(a,b,c,d,e)     ACC_CPP_CONCAT5(a,b,c,d,e)
#    endif
#    define __ACC_MASK_GEN(o,b)     (((((o) << ((b)-1)) - (o)) << 1) + (o))
#    if 1 && defined(__cplusplus)
#        if !defined(__STDC_CONSTANT_MACROS)
#            define __STDC_CONSTANT_MACROS 1
#        endif
#        if !defined(__STDC_LIMIT_MACROS)
#            define __STDC_LIMIT_MACROS 1
#        endif
#    endif
#    if defined(__cplusplus)
#        define ACC_EXTERN_C extern "C"
#    else
#        define ACC_EXTERN_C extern
#    endif
#    if !defined(__ACC_OS_OVERRIDE)
#        if defined(ACC_OS_FREESTANDING)
#            define ACC_INFO_OS           "freestanding"
#        elif defined(ACC_OS_EMBEDDED)
#            define ACC_INFO_OS           "embedded"
#        elif 1 && defined(__IAR_SYSTEMS_ICC__)
#            define ACC_OS_EMBEDDED       1
#            define ACC_INFO_OS           "embedded"
#        elif defined(__CYGWIN__) && defined(__GNUC__)
#            define ACC_OS_CYGWIN         1
#            define ACC_INFO_OS           "cygwin"
#        elif defined(__EMX__) && defined(__GNUC__)
#            define ACC_OS_EMX            1
#            define ACC_INFO_OS           "emx"
#        elif defined(__BEOS__)
#            define ACC_OS_BEOS           1
#            define ACC_INFO_OS           "beos"
#        elif defined(__Lynx__)
#            define ACC_OS_LYNXOS         1
#            define ACC_INFO_OS           "lynxos"
#        elif defined(__OS400__)
#            define ACC_OS_OS400          1
#            define ACC_INFO_OS           "os400"
#        elif defined(__QNX__)
#            define ACC_OS_QNX            1
#            define ACC_INFO_OS           "qnx"
#        elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460)
#            define ACC_OS_DOS32          1
#            define ACC_INFO_OS           "dos32"
#        elif defined(__BORLANDC__) && defined(__DPMI16__)
#            define ACC_OS_DOS16          1
#            define ACC_INFO_OS           "dos16"
#        elif defined(__ZTC__) && defined(DOS386)
#            define ACC_OS_DOS32          1
#            define ACC_INFO_OS           "dos32"
#        elif defined(__OS2__) || defined(__OS2V2__)
#            if (UINT_MAX == ACC_0xffffL)
#                define ACC_OS_OS216        1
#                define ACC_INFO_OS         "os216"
#            elif (UINT_MAX == ACC_0xffffffffL)
#                define ACC_OS_OS2          1
#                define ACC_INFO_OS         "os2"
#            else
#                error "check your limits.h header"
#            endif
#        elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64)
#            define ACC_OS_WIN64          1
#            define ACC_INFO_OS           "win64"
#        elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__)
#            define ACC_OS_WIN32          1
#            define ACC_INFO_OS           "win32"
#        elif defined(__MWERKS__) && defined(__INTEL__)
#            define ACC_OS_WIN32          1
#            define ACC_INFO_OS           "win32"
#        elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows)
#            if (UINT_MAX == ACC_0xffffL)
#                define ACC_OS_WIN16        1
#                define ACC_INFO_OS         "win16"
#            elif (UINT_MAX == ACC_0xffffffffL)
#                define ACC_OS_WIN32        1
#                define ACC_INFO_OS         "win32"
#            else
#                error "check your limits.h header"
#            endif
#        elif defined(__DOS__) || defined(__MSDOS__) || defined(_MSDOS) || defined(MSDOS) || (defined(__PACIFIC__) && defined(DOS))
#            if (UINT_MAX == ACC_0xffffL)
#                define ACC_OS_DOS16        1
#                define ACC_INFO_OS         "dos16"
#            elif (UINT_MAX == ACC_0xffffffffL)
#                define ACC_OS_DOS32        1
#                define ACC_INFO_OS         "dos32"
#            else
#                error "check your limits.h header"
#            endif
#        elif defined(__WATCOMC__)
#            if defined(__NT__) && (UINT_MAX == ACC_0xffffL)
#                define ACC_OS_DOS16        1
#                define ACC_INFO_OS         "dos16"
#            elif defined(__NT__) && (__WATCOMC__ < 1100)
#                define ACC_OS_WIN32        1
#                define ACC_INFO_OS         "win32"
#            elif defined(__linux__) || defined(__LINUX__)
#                define ACC_OS_POSIX        1
#                define ACC_INFO_OS         "posix"
#            else
#                error "please specify a target using the -bt compiler option"
#            endif
#        elif defined(__palmos__)
#            define ACC_OS_PALMOS         1
#            define ACC_INFO_OS           "palmos"
#        elif defined(__TOS__) || defined(__atarist__)
#            define ACC_OS_TOS            1
#            define ACC_INFO_OS           "tos"
#        elif defined(macintosh) && !defined(__ppc__)
#            define ACC_OS_MACCLASSIC     1
#            define ACC_INFO_OS           "macclassic"
#        elif defined(__VMS)
#            define ACC_OS_VMS            1
#            define ACC_INFO_OS           "vms"
#        elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
#            define ACC_OS_CONSOLE        1
#            define ACC_OS_CONSOLE_PS2    1
#            define ACC_INFO_OS           "console"
#            define ACC_INFO_OS_CONSOLE   "ps2"
#        elif (defined(__mips__) && defined(__psp__))
#            define ACC_OS_CONSOLE        1
#            define ACC_OS_CONSOLE_PSP    1
#            define ACC_INFO_OS           "console"
#            define ACC_INFO_OS_CONSOLE   "psp"
#        else
#            define ACC_OS_POSIX          1
#            define ACC_INFO_OS           "posix"
#        endif
#        if (ACC_OS_POSIX)
#            if defined(_AIX) || defined(__AIX__) || defined(__aix__)
#                define ACC_OS_POSIX_AIX        1
#                define ACC_INFO_OS_POSIX       "aix"
#            elif defined(__FreeBSD__)
#                define ACC_OS_POSIX_FREEBSD    1
#                define ACC_INFO_OS_POSIX       "freebsd"
#            elif defined(__hpux__) || defined(__hpux)
#                define ACC_OS_POSIX_HPUX       1
#                define ACC_INFO_OS_POSIX       "hpux"
#            elif defined(__INTERIX)
#                define ACC_OS_POSIX_INTERIX    1
#                define ACC_INFO_OS_POSIX       "interix"
#            elif defined(__IRIX__) || defined(__irix__)
#                define ACC_OS_POSIX_IRIX       1
#                define ACC_INFO_OS_POSIX       "irix"
#            elif defined(__linux__) || defined(__linux) || defined(__LINUX__)
#                define ACC_OS_POSIX_LINUX      1
#                define ACC_INFO_OS_POSIX       "linux"
#            elif defined(__APPLE__) || defined(__MACOS__)
#                define ACC_OS_POSIX_MACOSX     1
#                define ACC_INFO_OS_POSIX       "macosx"
#            elif defined(__minix__) || defined(__minix)
#                define ACC_OS_POSIX_MINIX      1
#                define ACC_INFO_OS_POSIX       "minix"
#            elif defined(__NetBSD__)
#                define ACC_OS_POSIX_NETBSD     1
#                define ACC_INFO_OS_POSIX       "netbsd"
#            elif defined(__OpenBSD__)
#                define ACC_OS_POSIX_OPENBSD    1
#                define ACC_INFO_OS_POSIX       "openbsd"
#            elif defined(__osf__)
#                define ACC_OS_POSIX_OSF        1
#                define ACC_INFO_OS_POSIX       "osf"
#            elif defined(__solaris__) || defined(__sun)
#                if defined(__SVR4) || defined(__svr4__)
#                    define ACC_OS_POSIX_SOLARIS  1
#                    define ACC_INFO_OS_POSIX     "solaris"
#                else
#                    define ACC_OS_POSIX_SUNOS    1
#                    define ACC_INFO_OS_POSIX     "sunos"
#                endif
#            elif defined(__ultrix__) || defined(__ultrix)
#                define ACC_OS_POSIX_ULTRIX     1
#                define ACC_INFO_OS_POSIX       "ultrix"
#            elif defined(_UNICOS)
#                define ACC_OS_POSIX_UNICOS     1
#                define ACC_INFO_OS_POSIX       "unicos"
#            else
#                define ACC_OS_POSIX_UNKNOWN    1
#                define ACC_INFO_OS_POSIX       "unknown"
#            endif
#        endif
#    endif
#    if (ACC_OS_DOS16 || ACC_OS_OS216 || ACC_OS_WIN16)
#        if (UINT_MAX != ACC_0xffffL)
#            error "this should not happen"
#        endif
#        if (ULONG_MAX != ACC_0xffffffffL)
#            error "this should not happen"
#        endif
#    endif
#    if (ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_WIN32 || ACC_OS_WIN64)
#        if (UINT_MAX != ACC_0xffffffffL)
#            error "this should not happen"
#        endif
#        if (ULONG_MAX != ACC_0xffffffffL)
#            error "this should not happen"
#        endif
#    endif
#    if defined(CIL) && defined(_GNUCC) && defined(__GNUC__)
#        define ACC_CC_CILLY          1
#        define ACC_INFO_CC           "Cilly"
#        if defined(__CILLY__)
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__CILLY__)
#        else
#            define ACC_INFO_CCVER      "unknown"
#        endif
#    elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__)
#        define ACC_CC_SDCC           1
#        define ACC_INFO_CC           "sdcc"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(SDCC)
#    elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__)
#        define ACC_CC_PATHSCALE      (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__)
#        define ACC_INFO_CC           "Pathscale C"
#        define ACC_INFO_CCVER        __PATHSCALE__
#    elif defined(__INTEL_COMPILER)
#        define ACC_CC_INTELC         1
#        define ACC_INFO_CC           "Intel C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__INTEL_COMPILER)
#        if defined(_WIN32) || defined(_WIN64)
#            define ACC_CC_SYNTAX_MSC 1
#        else
#            define ACC_CC_SYNTAX_GNUC 1
#        endif
#    elif defined(__POCC__) && defined(_WIN32)
#        define ACC_CC_PELLESC        1
#        define ACC_INFO_CC           "Pelles C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__POCC__)
#    elif defined(__llvm__) && defined(__GNUC__) && defined(__VERSION__)
#        if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
#            define ACC_CC_LLVM         (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
#        else
#            define ACC_CC_LLVM         (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
#        endif
#        define ACC_INFO_CC           "llvm-gcc"
#        define ACC_INFO_CCVER        __VERSION__
#    elif defined(__GNUC__) && defined(__VERSION__)
#        if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
#            define ACC_CC_GNUC         (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
#        elif defined(__GNUC_MINOR__)
#            define ACC_CC_GNUC         (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
#        else
#            define ACC_CC_GNUC         (__GNUC__ * 0x10000L)
#        endif
#        define ACC_INFO_CC           "gcc"
#        define ACC_INFO_CCVER        __VERSION__
#    elif defined(__ACK__) && defined(_ACK)
#        define ACC_CC_ACK            1
#        define ACC_INFO_CC           "Amsterdam Compiler Kit C"
#        define ACC_INFO_CCVER        "unknown"
#    elif defined(__AZTEC_C__)
#        define ACC_CC_AZTECC         1
#        define ACC_INFO_CC           "Aztec C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__AZTEC_C__)
#    elif defined(__BORLANDC__)
#        define ACC_CC_BORLANDC       1
#        define ACC_INFO_CC           "Borland C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__BORLANDC__)
#    elif defined(_CRAYC) && defined(_RELEASE)
#        define ACC_CC_CRAYC          1
#        define ACC_INFO_CC           "Cray C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(_RELEASE)
#    elif defined(__DMC__) && defined(__SC__)
#        define ACC_CC_DMC            1
#        define ACC_INFO_CC           "Digital Mars C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__DMC__)
#    elif defined(__DECC)
#        define ACC_CC_DECC           1
#        define ACC_INFO_CC           "DEC C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__DECC)
#    elif defined(__HIGHC__)
#        define ACC_CC_HIGHC          1
#        define ACC_INFO_CC           "MetaWare High C"
#        define ACC_INFO_CCVER        "unknown"
#    elif defined(__IAR_SYSTEMS_ICC__)
#        define ACC_CC_IARC           1
#        define ACC_INFO_CC           "IAR C"
#        if defined(__VER__)
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__VER__)
#        else
#            define ACC_INFO_CCVER      "unknown"
#        endif
#    elif defined(__IBMC__)
#        define ACC_CC_IBMC           1
#        define ACC_INFO_CC           "IBM C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__IBMC__)
#    elif defined(__KEIL__) && defined(__C166__)
#        define ACC_CC_KEILC          1
#        define ACC_INFO_CC           "Keil C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__C166__)
#    elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL)
#        define ACC_CC_LCCWIN32       1
#        define ACC_INFO_CC           "lcc-win32"
#        define ACC_INFO_CCVER        "unknown"
#    elif defined(__LCC__)
#        define ACC_CC_LCC            1
#        define ACC_INFO_CC           "lcc"
#        if defined(__LCC_VERSION__)
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__LCC_VERSION__)
#        else
#            define ACC_INFO_CCVER      "unknown"
#        endif
#    elif defined(_MSC_VER)
#        define ACC_CC_MSC            1
#        define ACC_INFO_CC           "Microsoft C"
#        if defined(_MSC_FULL_VER)
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(_MSC_VER) "." ACC_PP_MACRO_EXPAND(_MSC_FULL_VER)
#        else
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(_MSC_VER)
#        endif
#    elif defined(__MWERKS__)
#        define ACC_CC_MWERKS         1
#        define ACC_INFO_CC           "Metrowerks C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__MWERKS__)
#    elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386)
#        define ACC_CC_NDPC           1
#        define ACC_INFO_CC           "Microway NDP C"
#        define ACC_INFO_CCVER        "unknown"
#    elif defined(__PACIFIC__)
#        define ACC_CC_PACIFICC       1
#        define ACC_INFO_CC           "Pacific C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__PACIFIC__)
#    elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__))
#        define ACC_CC_PGI            1
#        define ACC_INFO_CC           "Portland Group PGI C"
#        define ACC_INFO_CCVER        "unknown"
#    elif defined(__PUREC__) && defined(__TOS__)
#        define ACC_CC_PUREC          1
#        define ACC_INFO_CC           "Pure C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__PUREC__)
#    elif defined(__SC__) && defined(__ZTC__)
#        define ACC_CC_SYMANTECC      1
#        define ACC_INFO_CC           "Symantec C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__SC__)
#    elif defined(__SUNPRO_C)
#        define ACC_INFO_CC           "SunPro C"
#        if ((__SUNPRO_C)+0 > 0)
#            define ACC_CC_SUNPROC      __SUNPRO_C
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__SUNPRO_C)
#        else
#            define ACC_CC_SUNPROC      1
#            define ACC_INFO_CCVER      "unknown"
#        endif
#    elif defined(__SUNPRO_CC)
#        define ACC_INFO_CC           "SunPro C"
#        if ((__SUNPRO_CC)+0 > 0)
#            define ACC_CC_SUNPROC      __SUNPRO_CC
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__SUNPRO_CC)
#        else
#            define ACC_CC_SUNPROC      1
#            define ACC_INFO_CCVER      "unknown"
#        endif
#    elif defined(__TINYC__)
#        define ACC_CC_TINYC          1
#        define ACC_INFO_CC           "Tiny C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__TINYC__)
#    elif defined(__TSC__)
#        define ACC_CC_TOPSPEEDC      1
#        define ACC_INFO_CC           "TopSpeed C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__TSC__)
#    elif defined(__WATCOMC__)
#        define ACC_CC_WATCOMC        1
#        define ACC_INFO_CC           "Watcom C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__WATCOMC__)
#    elif defined(__TURBOC__)
#        define ACC_CC_TURBOC         1
#        define ACC_INFO_CC           "Turbo C"
#        define ACC_INFO_CCVER        ACC_PP_MACRO_EXPAND(__TURBOC__)
#    elif defined(__ZTC__)
#        define ACC_CC_ZORTECHC       1
#        define ACC_INFO_CC           "Zortech C"
#        if (__ZTC__ == 0x310)
#            define ACC_INFO_CCVER      "0x310"
#        else
#            define ACC_INFO_CCVER      ACC_PP_MACRO_EXPAND(__ZTC__)
#        endif
#    else
#        define ACC_CC_UNKNOWN        1
#        define ACC_INFO_CC           "unknown"
#        define ACC_INFO_CCVER        "unknown"
#    endif
#    if 0 && (ACC_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER)
#        error "ACC_CC_MSC: _MSC_FULL_VER is not defined"
#    endif
#    if !defined(__ACC_ARCH_OVERRIDE) && !defined(ACC_ARCH_GENERIC) && defined(_CRAY)
#        if (UINT_MAX > ACC_0xffffffffL) && defined(_CRAY)
#            if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E)
#                define ACC_ARCH_CRAY_MPP     1
#            elif defined(_CRAY1)
#                define ACC_ARCH_CRAY_PVP     1
#            endif
#        endif
#    endif
#    if !defined(__ACC_ARCH_OVERRIDE)
#        if defined(ACC_ARCH_GENERIC)
#            define ACC_INFO_ARCH             "generic"
#        elif (ACC_OS_DOS16 || ACC_OS_OS216 || ACC_OS_WIN16)
#            define ACC_ARCH_I086             1
#            define ACC_ARCH_IA16             1
#            define ACC_INFO_ARCH             "i086"
#        elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA)
#            define ACC_ARCH_ALPHA            1
#            define ACC_INFO_ARCH             "alpha"
#        elif (ACC_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E))
#            define ACC_ARCH_ALPHA            1
#            define ACC_INFO_ARCH             "alpha"
#        elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
#            define ACC_ARCH_AMD64            1
#            define ACC_INFO_ARCH             "amd64"
#        elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB))
#            define ACC_ARCH_ARM              1
#            define ACC_ARCH_ARM_THUMB        1
#            define ACC_INFO_ARCH             "arm_thumb"
#        elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__)
#            define ACC_ARCH_ARM              1
#            if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1)
#                define ACC_ARCH_ARM_THUMB      1
#                define ACC_INFO_ARCH           "arm_thumb"
#            elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2)
#                define ACC_INFO_ARCH           "arm"
#            else
#                define ACC_INFO_ARCH           "arm"
#            endif
#        elif defined(__arm__) || defined(_M_ARM)
#            define ACC_ARCH_ARM              1
#            define ACC_INFO_ARCH             "arm"
#        elif (UINT_MAX <= ACC_0xffffL) && defined(__AVR__)
#            define ACC_ARCH_AVR              1
#            define ACC_INFO_ARCH             "avr"
#        elif defined(__bfin__)
#            define ACC_ARCH_BLACKFIN         1
#            define ACC_INFO_ARCH             "blackfin"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__C166__)
#            define ACC_ARCH_C166             1
#            define ACC_INFO_ARCH             "c166"
#        elif defined(__cris__)
#            define ACC_ARCH_CRIS             1
#            define ACC_INFO_ARCH             "cris"
#        elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__)
#            define ACC_ARCH_EZ80             1
#            define ACC_INFO_ARCH             "ez80"
#        elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
#            define ACC_ARCH_H8300            1
#            define ACC_INFO_ARCH             "h8300"
#        elif defined(__hppa__) || defined(__hppa)
#            define ACC_ARCH_HPPA             1
#            define ACC_INFO_ARCH             "hppa"
#        elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386)
#            define ACC_ARCH_I386             1
#            define ACC_ARCH_IA32             1
#            define ACC_INFO_ARCH             "i386"
#        elif (ACC_CC_ZORTECHC && defined(__I86__))
#            define ACC_ARCH_I386             1
#            define ACC_ARCH_IA32             1
#            define ACC_INFO_ARCH             "i386"
#        elif (ACC_OS_DOS32 && ACC_CC_HIGHC) && defined(_I386)
#            define ACC_ARCH_I386             1
#            define ACC_ARCH_IA32             1
#            define ACC_INFO_ARCH             "i386"
#        elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64)
#            define ACC_ARCH_IA64             1
#            define ACC_INFO_ARCH             "ia64"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__m32c__)
#            define ACC_ARCH_M16C             1
#            define ACC_INFO_ARCH             "m16c"
#        elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__)
#            define ACC_ARCH_M16C             1
#            define ACC_INFO_ARCH             "m16c"
#        elif defined(__m32r__)
#            define ACC_ARCH_M32R             1
#            define ACC_INFO_ARCH             "m32r"
#        elif (ACC_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K)
#            define ACC_ARCH_M68K             1
#            define ACC_INFO_ARCH             "m68k"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__C251__)
#            define ACC_ARCH_MCS251           1
#            define ACC_INFO_ARCH             "mcs251"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__C51__)
#            define ACC_ARCH_MCS51            1
#            define ACC_INFO_ARCH             "mcs51"
#        elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__)
#            define ACC_ARCH_MCS51            1
#            define ACC_INFO_ARCH             "mcs51"
#        elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000)
#            define ACC_ARCH_MIPS             1
#            define ACC_INFO_ARCH             "mips"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__MSP430__)
#            define ACC_ARCH_MSP430           1
#            define ACC_INFO_ARCH             "msp430"
#        elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__)
#            define ACC_ARCH_MSP430           1
#            define ACC_INFO_ARCH             "msp430"
#        elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR)
#            define ACC_ARCH_POWERPC          1
#            define ACC_INFO_ARCH             "powerpc"
#        elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x)
#            define ACC_ARCH_S390             1
#            define ACC_INFO_ARCH             "s390"
#        elif defined(__sh__) || defined(_M_SH)
#            define ACC_ARCH_SH               1
#            define ACC_INFO_ARCH             "sh"
#        elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8)
#            define ACC_ARCH_SPARC            1
#            define ACC_INFO_ARCH             "sparc"
#        elif defined(__SPU__)
#            define ACC_ARCH_SPU              1
#            define ACC_INFO_ARCH             "spu"
#        elif (UINT_MAX == ACC_0xffffL) && defined(__z80)
#            define ACC_ARCH_Z80              1
#            define ACC_INFO_ARCH             "z80"
#        elif (ACC_ARCH_CRAY_PVP)
#            if defined(_CRAYSV1)
#                define ACC_ARCH_CRAY_SV1       1
#                define ACC_INFO_ARCH           "cray_sv1"
#            elif (_ADDR64)
#                define ACC_ARCH_CRAY_T90       1
#                define ACC_INFO_ARCH           "cray_t90"
#            elif (_ADDR32)
#                define ACC_ARCH_CRAY_YMP       1
#                define ACC_INFO_ARCH           "cray_ymp"
#            else
#                define ACC_ARCH_CRAY_XMP       1
#                define ACC_INFO_ARCH           "cray_xmp"
#            endif
#        else
#            define ACC_ARCH_UNKNOWN          1
#            define ACC_INFO_ARCH             "unknown"
#        endif
#    endif
#    if 1 && (ACC_ARCH_UNKNOWN) && (ACC_OS_DOS32 || ACC_OS_OS2)
#        error "FIXME - missing define for CPU architecture"
#    endif
#    if 1 && (ACC_ARCH_UNKNOWN) && (ACC_OS_WIN32)
#        error "FIXME - missing WIN32 define for CPU architecture"
#    endif
#    if 1 && (ACC_ARCH_UNKNOWN) && (ACC_OS_WIN64)
#        error "FIXME - missing WIN64 define for CPU architecture"
#    endif
#    if (ACC_OS_OS216 || ACC_OS_WIN16)
#        define ACC_ARCH_I086PM           1
#        define ACC_ARCH_IA16PM           1
#    elif 1 && (ACC_OS_DOS16 && defined(BLX286))
#        define ACC_ARCH_I086PM           1
#        define ACC_ARCH_IA16PM           1
#    elif 1 && (ACC_OS_DOS16 && defined(DOSX286))
#        define ACC_ARCH_I086PM           1
#        define ACC_ARCH_IA16PM           1
#    elif 1 && (ACC_OS_DOS16 && ACC_CC_BORLANDC && defined(__DPMI16__))
#        define ACC_ARCH_I086PM           1
#        define ACC_ARCH_IA16PM           1
#    endif
#    if defined(ACC_ARCH_ARM_THUMB) && !defined(ACC_ARCH_ARM)
#        error "this should not happen"
#    endif
#    if defined(ACC_ARCH_I086PM) && !defined(ACC_ARCH_I086)
#        error "this should not happen"
#    endif
#    if (ACC_ARCH_I086)
#        if (UINT_MAX != ACC_0xffffL)
#            error "this should not happen"
#        endif
#        if (ULONG_MAX != ACC_0xffffffffL)
#            error "this should not happen"
#        endif
#    endif
#    if (ACC_ARCH_I386)
#        if (UINT_MAX != ACC_0xffffL) && defined(__i386_int16__)
#            error "this should not happen"
#        endif
#        if (UINT_MAX != ACC_0xffffffffL) && !defined(__i386_int16__)
#            error "this should not happen"
#        endif
#        if (ULONG_MAX != ACC_0xffffffffL)
#            error "this should not happen"
#        endif
#    endif
#    if !defined(__ACC_MM_OVERRIDE)
#        if (ACC_ARCH_I086)
#            if (UINT_MAX != ACC_0xffffL)
#                error "this should not happen"
#            endif
#            if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM)
#                define ACC_MM_TINY           1
#            elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM)
#                define ACC_MM_HUGE           1
#            elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL)
#                define ACC_MM_SMALL          1
#            elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM)
#                define ACC_MM_MEDIUM         1
#            elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM)
#                define ACC_MM_COMPACT        1
#            elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL)
#                define ACC_MM_LARGE          1
#            elif (ACC_CC_AZTECC)
#                if defined(_LARGE_CODE) && defined(_LARGE_DATA)
#                    define ACC_MM_LARGE        1
#                elif defined(_LARGE_CODE)
#                    define ACC_MM_MEDIUM       1
#                elif defined(_LARGE_DATA)
#                    define ACC_MM_COMPACT      1
#                else
#                    define ACC_MM_SMALL        1
#                endif
#            elif (ACC_CC_ZORTECHC && defined(__VCM__))
#                define ACC_MM_LARGE          1
#            else
#                error "unknown memory model"
#            endif
#            if (ACC_OS_DOS16 || ACC_OS_OS216 || ACC_OS_WIN16)
#                define ACC_HAVE_MM_HUGE_PTR        1
#                define ACC_HAVE_MM_HUGE_ARRAY      1
#                if (ACC_MM_TINY)
#                    undef ACC_HAVE_MM_HUGE_ARRAY
#                endif
#                if (ACC_CC_AZTECC || ACC_CC_PACIFICC || ACC_CC_ZORTECHC)
#                    undef ACC_HAVE_MM_HUGE_PTR
#                    undef ACC_HAVE_MM_HUGE_ARRAY
#                elif (ACC_CC_DMC || ACC_CC_SYMANTECC)
#                    undef ACC_HAVE_MM_HUGE_ARRAY
#                elif (ACC_CC_MSC && defined(_QC))
#                    undef ACC_HAVE_MM_HUGE_ARRAY
#                    if (_MSC_VER < 600)
#                        undef ACC_HAVE_MM_HUGE_PTR
#                    endif
#                elif (ACC_CC_TURBOC && (__TURBOC__ < 0x0295))
#                    undef ACC_HAVE_MM_HUGE_ARRAY
#                endif
#                if (ACC_ARCH_I086PM) && !defined(ACC_HAVE_MM_HUGE_PTR)
#                    if (ACC_OS_DOS16)
#                        error "this should not happen"
#                    elif (ACC_CC_ZORTECHC)
#                    else
#                        error "this should not happen"
#                    endif
#                endif
#                ifdef __cplusplus
extern "C" {
#                endif
#                if (ACC_CC_BORLANDC && (__BORLANDC__ >= 0x0200))
	extern void __near __cdecl _AHSHIFT(void);
#                    define ACC_MM_AHSHIFT      ((unsigned) _AHSHIFT)
#                elif (ACC_CC_DMC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC)
	extern void __near __cdecl _AHSHIFT(void);
#                    define ACC_MM_AHSHIFT      ((unsigned) _AHSHIFT)
#                elif (ACC_CC_MSC || ACC_CC_TOPSPEEDC)
	extern void __near __cdecl _AHSHIFT(void);
#                    define ACC_MM_AHSHIFT      ((unsigned) _AHSHIFT)
#                elif (ACC_CC_TURBOC && (__TURBOC__ >= 0x0295))
	extern void __near __cdecl _AHSHIFT(void);
#                    define ACC_MM_AHSHIFT      ((unsigned) _AHSHIFT)
#                elif ((ACC_CC_AZTECC || ACC_CC_PACIFICC || ACC_CC_TURBOC) && ACC_OS_DOS16)
#                    define ACC_MM_AHSHIFT      12
#                elif (ACC_CC_WATCOMC)
	extern unsigned char _HShift;
#                    define ACC_MM_AHSHIFT      ((unsigned) _HShift)
#                else
#                    error "FIXME - implement ACC_MM_AHSHIFT"
#                endif
#                ifdef __cplusplus
}
#                endif
#            endif
#        elif (ACC_ARCH_C166)
#            if !defined(__MODEL__)
#                error "FIXME - C166 __MODEL__"
#            elif ((__MODEL__) == 0)
#                define ACC_MM_SMALL          1
#            elif ((__MODEL__) == 1)
#                define ACC_MM_SMALL          1
#            elif ((__MODEL__) == 2)
#                define ACC_MM_LARGE          1
#            elif ((__MODEL__) == 3)
#                define ACC_MM_TINY           1
#            elif ((__MODEL__) == 4)
#                define ACC_MM_XTINY          1
#            elif ((__MODEL__) == 5)
#                define ACC_MM_XSMALL         1
#            else
#                error "FIXME - C166 __MODEL__"
#            endif
#        elif (ACC_ARCH_MCS251)
#            if !defined(__MODEL__)
#                error "FIXME - MCS251 __MODEL__"
#            elif ((__MODEL__) == 0)
#                define ACC_MM_SMALL          1
#            elif ((__MODEL__) == 2)
#                define ACC_MM_LARGE          1
#            elif ((__MODEL__) == 3)
#                define ACC_MM_TINY           1
#            elif ((__MODEL__) == 4)
#                define ACC_MM_XTINY          1
#            elif ((__MODEL__) == 5)
#                define ACC_MM_XSMALL         1
#            else
#                error "FIXME - MCS251 __MODEL__"
#            endif
#        elif (ACC_ARCH_MCS51)
#            if !defined(__MODEL__)
#                error "FIXME - MCS51 __MODEL__"
#            elif ((__MODEL__) == 1)
#                define ACC_MM_SMALL          1
#            elif ((__MODEL__) == 2)
#                define ACC_MM_LARGE          1
#            elif ((__MODEL__) == 3)
#                define ACC_MM_TINY           1
#            elif ((__MODEL__) == 4)
#                define ACC_MM_XTINY          1
#            elif ((__MODEL__) == 5)
#                define ACC_MM_XSMALL         1
#            else
#                error "FIXME - MCS51 __MODEL__"
#            endif
#        elif (ACC_ARCH_CRAY_PVP)
#            define ACC_MM_PVP            1
#        else
#            define ACC_MM_FLAT           1
#        endif
#        if (ACC_MM_COMPACT)
#            define ACC_INFO_MM           "compact"
#        elif (ACC_MM_FLAT)
#            define ACC_INFO_MM           "flat"
#        elif (ACC_MM_HUGE)
#            define ACC_INFO_MM           "huge"
#        elif (ACC_MM_LARGE)
#            define ACC_INFO_MM           "large"
#        elif (ACC_MM_MEDIUM)
#            define ACC_INFO_MM           "medium"
#        elif (ACC_MM_PVP)
#            define ACC_INFO_MM           "pvp"
#        elif (ACC_MM_SMALL)
#            define ACC_INFO_MM           "small"
#        elif (ACC_MM_TINY)
#            define ACC_INFO_MM           "tiny"
#        else
#            error "unknown memory model"
#        endif
#    endif
#    if defined(SIZEOF_SHORT)
#        define ACC_SIZEOF_SHORT          (SIZEOF_SHORT)
#    endif
#    if defined(SIZEOF_INT)
#        define ACC_SIZEOF_INT            (SIZEOF_INT)
#    endif
#    if defined(SIZEOF_LONG)
#        define ACC_SIZEOF_LONG           (SIZEOF_LONG)
#    endif
#    if defined(SIZEOF_LONG_LONG)
#        define ACC_SIZEOF_LONG_LONG      (SIZEOF_LONG_LONG)
#    endif
#    if defined(SIZEOF___INT16)
#        define ACC_SIZEOF___INT16        (SIZEOF___INT16)
#    endif
#    if defined(SIZEOF___INT32)
#        define ACC_SIZEOF___INT32        (SIZEOF___INT32)
#    endif
#    if defined(SIZEOF___INT64)
#        define ACC_SIZEOF___INT64        (SIZEOF___INT64)
#    endif
#    if defined(SIZEOF_VOID_P)
#        define ACC_SIZEOF_VOID_P         (SIZEOF_VOID_P)
#    endif
#    if defined(SIZEOF_SIZE_T)
#        define ACC_SIZEOF_SIZE_T         (SIZEOF_SIZE_T)
#    endif
#    if defined(SIZEOF_PTRDIFF_T)
#        define ACC_SIZEOF_PTRDIFF_T      (SIZEOF_PTRDIFF_T)
#    endif
#    define __ACC_LSR(x,b)    (((x)+0ul) >> (b))
#    if !defined(ACC_SIZEOF_SHORT)
#        if (ACC_ARCH_CRAY_PVP)
#            define ACC_SIZEOF_SHORT        8
#        elif (USHRT_MAX == ACC_0xffffL)
#            define ACC_SIZEOF_SHORT        2
#        elif (__ACC_LSR(USHRT_MAX,7) == 1)
#            define ACC_SIZEOF_SHORT        1
#        elif (__ACC_LSR(USHRT_MAX,15) == 1)
#            define ACC_SIZEOF_SHORT        2
#        elif (__ACC_LSR(USHRT_MAX,31) == 1)
#            define ACC_SIZEOF_SHORT        4
#        elif (__ACC_LSR(USHRT_MAX,63) == 1)
#            define ACC_SIZEOF_SHORT        8
#        elif (__ACC_LSR(USHRT_MAX,127) == 1)
#            define ACC_SIZEOF_SHORT        16
#        else
#            error "ACC_SIZEOF_SHORT"
#        endif
#    endif
#    if !defined(ACC_SIZEOF_INT)
#        if (ACC_ARCH_CRAY_PVP)
#            define ACC_SIZEOF_INT          8
#        elif (UINT_MAX == ACC_0xffffL)
#            define ACC_SIZEOF_INT          2
#        elif (UINT_MAX == ACC_0xffffffffL)
#            define ACC_SIZEOF_INT          4
#        elif (__ACC_LSR(UINT_MAX,7) == 1)
#            define ACC_SIZEOF_INT          1
#        elif (__ACC_LSR(UINT_MAX,15) == 1)
#            define ACC_SIZEOF_INT          2
#        elif (__ACC_LSR(UINT_MAX,31) == 1)
#            define ACC_SIZEOF_INT          4
#        elif (__ACC_LSR(UINT_MAX,63) == 1)
#            define ACC_SIZEOF_INT          8
#        elif (__ACC_LSR(UINT_MAX,127) == 1)
#            define ACC_SIZEOF_INT          16
#        else
#            error "ACC_SIZEOF_INT"
#        endif
#    endif
#    if !defined(ACC_SIZEOF_LONG)
#        if (ULONG_MAX == ACC_0xffffffffL)
#            define ACC_SIZEOF_LONG         4
#        elif (__ACC_LSR(ULONG_MAX,7) == 1)
#            define ACC_SIZEOF_LONG         1
#        elif (__ACC_LSR(ULONG_MAX,15) == 1)
#            define ACC_SIZEOF_LONG         2
#        elif (__ACC_LSR(ULONG_MAX,31) == 1)
#            define ACC_SIZEOF_LONG         4
#        elif (__ACC_LSR(ULONG_MAX,63) == 1)
#            define ACC_SIZEOF_LONG         8
#        elif (__ACC_LSR(ULONG_MAX,127) == 1)
#            define ACC_SIZEOF_LONG         16
#        else
#            error "ACC_SIZEOF_LONG"
#        endif
#    endif
#    if !defined(ACC_SIZEOF_LONG_LONG) && !defined(ACC_SIZEOF___INT64)
#        if (ACC_SIZEOF_LONG > 0 && ACC_SIZEOF_LONG < 8)
#            if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__)
#                if (ACC_CC_GNUC >= 0x030300ul)
#                    if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0)
#                        define ACC_SIZEOF_LONG_LONG      ACC_SIZEOF_LONG
#                    elif (__ACC_LSR(__LONG_LONG_MAX__,30) == 1)
#                        define ACC_SIZEOF_LONG_LONG      4
#                    endif
#                endif
#            endif
#        endif
#    endif
#    if !defined(ACC_SIZEOF_LONG_LONG) && !defined(ACC_SIZEOF___INT64)
#        if (ACC_SIZEOF_LONG > 0 && ACC_SIZEOF_LONG < 8)
#            if (ACC_ARCH_I086 && ACC_CC_DMC)
#            elif (ACC_CC_CILLY) && defined(__GNUC__)
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
#                define ACC_SIZEOF_LONG_LONG      8
#            elif ((ACC_OS_WIN32 || ACC_OS_WIN64 || defined(_WIN32)) && ACC_CC_MSC && (_MSC_VER >= 1400))
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_OS_WIN64 || defined(_WIN64))
#                define ACC_SIZEOF___INT64        8
#            elif (ACC_ARCH_I386 && (ACC_CC_DMC))
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_ARCH_I386 && (ACC_CC_SYMANTECC && (__SC__ >= 0x700)))
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_ARCH_I386 && (ACC_CC_INTELC && defined(__linux__)))
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_ARCH_I386 && (ACC_CC_MWERKS || ACC_CC_PELLESC || ACC_CC_PGI || ACC_CC_SUNPROC))
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_ARCH_I386 && (ACC_CC_INTELC || ACC_CC_MSC))
#                define ACC_SIZEOF___INT64        8
#            elif ((ACC_OS_WIN32 || defined(_WIN32)) && (ACC_CC_MSC))
#                define ACC_SIZEOF___INT64        8
#            elif (ACC_ARCH_I386 && (ACC_CC_BORLANDC && (__BORLANDC__ >= 0x0520)))
#                define ACC_SIZEOF___INT64        8
#            elif (ACC_ARCH_I386 && (ACC_CC_WATCOMC && (__WATCOMC__ >= 1100)))
#                define ACC_SIZEOF___INT64        8
#            elif (ACC_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64))
#                define ACC_SIZEOF___INT64        8
#            elif (ACC_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
#                define ACC_SIZEOF_LONG_LONG      8
#            elif (ACC_CC_SDCC) && (ACC_SIZEOF_INT == 2)
#            elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
#                define ACC_SIZEOF_LONG_LONG      8
#            endif
#        endif
#    endif
#    if defined(__cplusplus) && defined(ACC_CC_GNUC)
#        if (ACC_CC_GNUC < 0x020800ul)
#            undef ACC_SIZEOF_LONG_LONG
#        endif
#    endif
#    if defined(ACC_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG)
#        undef ACC_SIZEOF_LONG_LONG
#    endif
#    if !defined(ACC_SIZEOF_VOID_P)
#        if (ACC_ARCH_I086)
#            define __ACC_WORDSIZE            2
#            if (ACC_MM_TINY || ACC_MM_SMALL || ACC_MM_MEDIUM)
#                define ACC_SIZEOF_VOID_P       2
#            elif (ACC_MM_COMPACT || ACC_MM_LARGE || ACC_MM_HUGE)
#                define ACC_SIZEOF_VOID_P       4
#            else
#                error "ACC_MM"
#            endif
#        elif (ACC_ARCH_AVR || ACC_ARCH_Z80)
#            define __ACC_WORDSIZE            1
#            define ACC_SIZEOF_VOID_P         2
#        elif (ACC_ARCH_C166 || ACC_ARCH_MCS51 || ACC_ARCH_MCS251 || ACC_ARCH_MSP430)
#            define ACC_SIZEOF_VOID_P         2
#        elif (ACC_ARCH_H8300)
#            if defined(__NORMAL_MODE__)
#                define __ACC_WORDSIZE          4
#                define ACC_SIZEOF_VOID_P       2
#            elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
#                define __ACC_WORDSIZE          4
#                define ACC_SIZEOF_VOID_P       4
#            else
#                define __ACC_WORDSIZE          2
#                define ACC_SIZEOF_VOID_P       2
#            endif
#            if (ACC_CC_GNUC && (ACC_CC_GNUC < 0x040000ul)) && (ACC_SIZEOF_INT == 4)
#                define ACC_SIZEOF_SIZE_T       ACC_SIZEOF_INT
#                define ACC_SIZEOF_PTRDIFF_T    ACC_SIZEOF_INT
#            endif
#        elif (ACC_ARCH_M16C)
#            define __ACC_WORDSIZE            2
#            if defined(__m32c_cpu__) || defined(__m32cm_cpu__)
#                define ACC_SIZEOF_VOID_P       4
#            else
#                define ACC_SIZEOF_VOID_P       2
#            endif
#        elif (ACC_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
#            define __ACC_WORDSIZE            8
#            define ACC_SIZEOF_VOID_P         4
#        elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64)
#            define __ACC_WORDSIZE            8
#            define ACC_SIZEOF_VOID_P         8
#        elif (ACC_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
#            define ACC_SIZEOF_VOID_P         ACC_SIZEOF_LONG
#            define ACC_SIZEOF_SIZE_T         ACC_SIZEOF_LONG
#            define ACC_SIZEOF_PTRDIFF_T      ACC_SIZEOF_LONG
#        elif (ACC_OS_OS400 || defined(__OS400__))
#            define __ACC_WORDSIZE            ACC_SIZEOF_LONG
#            define ACC_SIZEOF_VOID_P         16
#            define ACC_SIZEOF_SIZE_T         ACC_SIZEOF_LONG
#            define ACC_SIZEOF_PTRDIFF_T      ACC_SIZEOF_LONG
#        elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
#            define ACC_SIZEOF_VOID_P         8
#            define ACC_SIZEOF_SIZE_T         ACC_SIZEOF_LONG
#            define ACC_SIZEOF_PTRDIFF_T      ACC_SIZEOF_LONG
#        elif (ACC_ARCH_SPU)
#            if 0
#                define __ACC_WORDSIZE            16
#            endif
#            define ACC_SIZEOF_VOID_P         4
#        else
#            define ACC_SIZEOF_VOID_P         ACC_SIZEOF_LONG
#        endif
#    endif
#    if !defined(ACC_WORDSIZE)
#        if defined(__ACC_WORDSIZE)
#            define ACC_WORDSIZE            __ACC_WORDSIZE
#        else
#            define ACC_WORDSIZE            ACC_SIZEOF_VOID_P
#        endif
#    endif
#    if !defined(ACC_SIZEOF_SIZE_T)
#        if (ACC_ARCH_I086 || ACC_ARCH_M16C)
#            define ACC_SIZEOF_SIZE_T         2
#        else
#            define ACC_SIZEOF_SIZE_T         ACC_SIZEOF_VOID_P
#        endif
#    endif
#    if !defined(ACC_SIZEOF_PTRDIFF_T)
#        if (ACC_ARCH_I086)
#            if (ACC_MM_TINY || ACC_MM_SMALL || ACC_MM_MEDIUM || ACC_MM_HUGE)
#                define ACC_SIZEOF_PTRDIFF_T    ACC_SIZEOF_VOID_P
#            elif (ACC_MM_COMPACT || ACC_MM_LARGE)
#                if (ACC_CC_BORLANDC || ACC_CC_TURBOC)
#                    define ACC_SIZEOF_PTRDIFF_T  4
#                else
#                    define ACC_SIZEOF_PTRDIFF_T  2
#                endif
#            else
#                error "ACC_MM"
#            endif
#        else
#            define ACC_SIZEOF_PTRDIFF_T      ACC_SIZEOF_SIZE_T
#        endif
#    endif
#    if defined(ACC_ABI_NEUTRAL_ENDIAN)
#        undef ACC_ABI_BIG_ENDIAN
#        undef ACC_ABI_LITTLE_ENDIAN
#    elif !defined(ACC_ABI_BIG_ENDIAN) && !defined(ACC_ABI_LITTLE_ENDIAN)
#        if (ACC_ARCH_ALPHA) && (ACC_ARCH_CRAY_MPP)
#            define ACC_ABI_BIG_ENDIAN        1
#        elif (ACC_ARCH_ALPHA || ACC_ARCH_AMD64 || ACC_ARCH_BLACKFIN || ACC_ARCH_CRIS || ACC_ARCH_I086 || ACC_ARCH_I386 || ACC_ARCH_MSP430)
#            define ACC_ABI_LITTLE_ENDIAN     1
#        elif (ACC_ARCH_M68K || ACC_ARCH_S390)
#            define ACC_ABI_BIG_ENDIAN        1
#        elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__)
#            if (__LITTLE_ENDIAN__ == 1)
#                define ACC_ABI_LITTLE_ENDIAN   1
#            else
#                define ACC_ABI_BIG_ENDIAN      1
#            endif
#        elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
#            define ACC_ABI_BIG_ENDIAN        1
#        elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
#            define ACC_ABI_LITTLE_ENDIAN     1
#        elif 1 && (ACC_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__)
#            define ACC_ABI_BIG_ENDIAN        1
#        elif 1 && (ACC_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__)
#            define ACC_ABI_LITTLE_ENDIAN     1
#        elif 1 && (ACC_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__)
#            define ACC_ABI_BIG_ENDIAN        1
#        elif 1 && (ACC_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__)
#            define ACC_ABI_LITTLE_ENDIAN     1
#        endif
#    endif
#    if defined(ACC_ABI_BIG_ENDIAN) && defined(ACC_ABI_LITTLE_ENDIAN)
#        error "this should not happen"
#    endif
#    if defined(ACC_ABI_BIG_ENDIAN)
#        define ACC_INFO_ABI_ENDIAN       "be"
#    elif defined(ACC_ABI_LITTLE_ENDIAN)
#        define ACC_INFO_ABI_ENDIAN       "le"
#    elif defined(ACC_ABI_NEUTRAL_ENDIAN)
#        define ACC_INFO_ABI_ENDIAN       "neutral"
#    endif
#    if (ACC_SIZEOF_INT == 1 && ACC_SIZEOF_LONG == 2 && ACC_SIZEOF_VOID_P == 2)
#        define ACC_ABI_I8LP16         1
#        define ACC_INFO_ABI_PM       "i8lp16"
#    elif (ACC_SIZEOF_INT == 2 && ACC_SIZEOF_LONG == 2 && ACC_SIZEOF_VOID_P == 2)
#        define ACC_ABI_ILP16         1
#        define ACC_INFO_ABI_PM       "ilp16"
#    elif (ACC_SIZEOF_INT == 4 && ACC_SIZEOF_LONG == 4 && ACC_SIZEOF_VOID_P == 4)
#        define ACC_ABI_ILP32         1
#        define ACC_INFO_ABI_PM       "ilp32"
#    elif (ACC_SIZEOF_INT == 4 && ACC_SIZEOF_LONG == 4 && ACC_SIZEOF_VOID_P == 8 && ACC_SIZEOF_SIZE_T == 8)
#        define ACC_ABI_LLP64         1
#        define ACC_INFO_ABI_PM       "llp64"
#    elif (ACC_SIZEOF_INT == 4 && ACC_SIZEOF_LONG == 8 && ACC_SIZEOF_VOID_P == 8)
#        define ACC_ABI_LP64          1
#        define ACC_INFO_ABI_PM       "lp64"
#    elif (ACC_SIZEOF_INT == 8 && ACC_SIZEOF_LONG == 8 && ACC_SIZEOF_VOID_P == 8)
#        define ACC_ABI_ILP64         1
#        define ACC_INFO_ABI_PM       "ilp64"
#    elif (ACC_SIZEOF_INT == 4 && ACC_SIZEOF_LONG == 8 && ACC_SIZEOF_VOID_P == 4)
#        define ACC_ABI_IP32L64       1
#        define ACC_INFO_ABI_PM       "ip32l64"
#    endif
#    if !defined(__ACC_LIBC_OVERRIDE)
#        if defined(ACC_LIBC_NAKED)
#            define ACC_INFO_LIBC         "naked"
#        elif defined(ACC_LIBC_FREESTANDING)
#            define ACC_INFO_LIBC         "freestanding"
#        elif defined(ACC_LIBC_MOSTLY_FREESTANDING)
#            define ACC_INFO_LIBC         "mfreestanding"
#        elif defined(ACC_LIBC_ISOC90)
#            define ACC_INFO_LIBC         "isoc90"
#        elif defined(ACC_LIBC_ISOC99)
#            define ACC_INFO_LIBC         "isoc99"
#        elif defined(__dietlibc__)
#            define ACC_LIBC_DIETLIBC     1
#            define ACC_INFO_LIBC         "dietlibc"
#        elif defined(_NEWLIB_VERSION)
#            define ACC_LIBC_NEWLIB       1
#            define ACC_INFO_LIBC         "newlib"
#        elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__)
#            if defined(__UCLIBC_SUBLEVEL__)
#                define ACC_LIBC_UCLIBC     (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__)
#            else
#                define ACC_LIBC_UCLIBC     0x00090bL
#            endif
#            define ACC_INFO_LIBC         "uclibc"
#        elif defined(__GLIBC__) && defined(__GLIBC_MINOR__)
#            define ACC_LIBC_GLIBC        (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100)
#            define ACC_INFO_LIBC         "glibc"
#        elif (ACC_CC_MWERKS) && defined(__MSL__)
#            define ACC_LIBC_MSL          __MSL__
#            define ACC_INFO_LIBC         "msl"
#        elif 1 && defined(__IAR_SYSTEMS_ICC__)
#            define ACC_LIBC_ISOC90       1
#            define ACC_INFO_LIBC         "isoc90"
#        else
#            define ACC_LIBC_DEFAULT      1
#            define ACC_INFO_LIBC         "default"
#        endif
#    endif
#    if !defined(__acc_gnuc_extension__)
#        if (ACC_CC_GNUC >= 0x020800ul)
#            define __acc_gnuc_extension__    __extension__
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_gnuc_extension__    __extension__
#        else
#            define __acc_gnuc_extension__
#        endif
#    endif
#    if !defined(__acc_ua_volatile)
#        define __acc_ua_volatile     volatile
#    endif
#    if !defined(__acc_alignof)
#        if (ACC_CC_CILLY || ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE || ACC_CC_PGI)
#            define __acc_alignof(e)      __alignof__(e)
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 700))
#            define __acc_alignof(e)      __alignof__(e)
#        elif (ACC_CC_MSC && (_MSC_VER >= 1300))
#            define __acc_alignof(e)      __alignof(e)
#        endif
#    endif
#    if defined(__acc_alignof)
#        define __acc_HAVE_alignof 1
#    endif
#    if !defined(__acc_constructor)
#        if (ACC_CC_GNUC >= 0x030400ul)
#            define __acc_constructor     __attribute__((__constructor__,__used__))
#        elif (ACC_CC_GNUC >= 0x020700ul)
#            define __acc_constructor     __attribute__((__constructor__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_constructor     __attribute__((__constructor__))
#        endif
#    endif
#    if defined(__acc_constructor)
#        define __acc_HAVE_constructor 1
#    endif
#    if !defined(__acc_destructor)
#        if (ACC_CC_GNUC >= 0x030400ul)
#            define __acc_destructor      __attribute__((__destructor__,__used__))
#        elif (ACC_CC_GNUC >= 0x020700ul)
#            define __acc_destructor      __attribute__((__destructor__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_destructor      __attribute__((__destructor__))
#        endif
#    endif
#    if defined(__acc_destructor)
#        define __acc_HAVE_destructor 1
#    endif
#    if defined(__acc_HAVE_destructor) && !defined(__acc_HAVE_constructor)
#        error "this should not happen"
#    endif
#    if !defined(__acc_inline)
#        if (ACC_CC_TURBOC && (__TURBOC__ <= 0x0295))
#        elif defined(__cplusplus)
#            define __acc_inline          inline
#        elif (ACC_CC_BORLANDC && (__BORLANDC__ >= 0x0550))
#            define __acc_inline          __inline
#        elif (ACC_CC_CILLY || ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE || ACC_CC_PGI)
#            define __acc_inline          __inline__
#        elif (ACC_CC_DMC)
#            define __acc_inline          __inline
#        elif (ACC_CC_INTELC)
#            define __acc_inline          __inline
#        elif (ACC_CC_MWERKS && (__MWERKS__ >= 0x2405))
#            define __acc_inline          __inline
#        elif (ACC_CC_MSC && (_MSC_VER >= 900))
#            define __acc_inline          __inline
#        elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
#            define __acc_inline          inline
#        endif
#    endif
#    if defined(__acc_inline)
#        define __acc_HAVE_inline 1
#    else
#        define __acc_inline
#    endif
#    if !defined(__acc_forceinline)
#        if (ACC_CC_GNUC >= 0x030200ul)
#            define __acc_forceinline     __inline__ __attribute__((__always_inline__))
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 450) && ACC_CC_SYNTAX_MSC)
#            define __acc_forceinline     __forceinline
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 800) && ACC_CC_SYNTAX_GNUC)
#            define __acc_forceinline     __inline__ __attribute__((__always_inline__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_forceinline     __inline__ __attribute__((__always_inline__))
#        elif (ACC_CC_MSC && (_MSC_VER >= 1200))
#            define __acc_forceinline     __forceinline
#        endif
#    endif
#    if defined(__acc_forceinline)
#        define __acc_HAVE_forceinline 1
#    else
#        define __acc_forceinline
#    endif
#    if !defined(__acc_noinline)
#        if 1 && (ACC_ARCH_I386) && (ACC_CC_GNUC >= 0x040000ul) && (ACC_CC_GNUC < 0x040003ul)
#            define __acc_noinline        __attribute__((__noinline__,__used__))
#        elif (ACC_CC_GNUC >= 0x030200ul)
#            define __acc_noinline        __attribute__((__noinline__))
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 600) && ACC_CC_SYNTAX_MSC)
#            define __acc_noinline        __declspec(noinline)
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 800) && ACC_CC_SYNTAX_GNUC)
#            define __acc_noinline        __attribute__((__noinline__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_noinline        __attribute__((__noinline__))
#        elif (ACC_CC_MSC && (_MSC_VER >= 1300))
#            define __acc_noinline        __declspec(noinline)
#        elif (ACC_CC_MWERKS && (__MWERKS__ >= 0x3200) && (ACC_OS_WIN32 || ACC_OS_WIN64))
#            if defined(__cplusplus)
#            else
#                define __acc_noinline      __declspec(noinline)
#            endif
#        endif
#    endif
#    if defined(__acc_noinline)
#        define __acc_HAVE_noinline 1
#    else
#        define __acc_noinline
#    endif
#    if (defined(__acc_HAVE_forceinline) || defined(__acc_HAVE_noinline)) && !defined(__acc_HAVE_inline)
#        error "this should not happen"
#    endif
#    if !defined(__acc_noreturn)
#        if (ACC_CC_GNUC >= 0x020700ul)
#            define __acc_noreturn        __attribute__((__noreturn__))
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 450) && ACC_CC_SYNTAX_MSC)
#            define __acc_noreturn        __declspec(noreturn)
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 600) && ACC_CC_SYNTAX_GNUC)
#            define __acc_noreturn        __attribute__((__noreturn__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_noreturn        __attribute__((__noreturn__))
#        elif (ACC_CC_MSC && (_MSC_VER >= 1200))
#            define __acc_noreturn        __declspec(noreturn)
#        endif
#    endif
#    if defined(__acc_noreturn)
#        define __acc_HAVE_noreturn 1
#    else
#        define __acc_noreturn
#    endif
#    if !defined(__acc_nothrow)
#        if (ACC_CC_GNUC >= 0x030300ul)
#            define __acc_nothrow         __attribute__((__nothrow__))
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 450) && ACC_CC_SYNTAX_MSC) && defined(__cplusplus)
#            define __acc_nothrow         __declspec(nothrow)
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 800) && ACC_CC_SYNTAX_GNUC)
#            define __acc_nothrow         __attribute__((__nothrow__))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_nothrow         __attribute__((__nothrow__))
#        elif (ACC_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus)
#            define __acc_nothrow         __declspec(nothrow)
#        endif
#    endif
#    if defined(__acc_nothrow)
#        define __acc_HAVE_nothrow 1
#    else
#        define __acc_nothrow
#    endif
#    if !defined(__acc_restrict)
#        if (ACC_CC_GNUC >= 0x030400ul)
#            define __acc_restrict        __restrict__
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 600) && ACC_CC_SYNTAX_GNUC)
#            define __acc_restrict        __restrict__
#        elif (ACC_CC_LLVM)
#            define __acc_restrict        __restrict__
#        elif (ACC_CC_MSC && (_MSC_VER >= 1400))
#            define __acc_restrict        __restrict
#        endif
#    endif
#    if defined(__acc_restrict)
#        define __acc_HAVE_restrict 1
#    else
#        define __acc_restrict
#    endif
#    if !defined(__acc_likely) && !defined(__acc_unlikely)
#        if (ACC_CC_GNUC >= 0x030200ul)
#            define __acc_likely(e)       (__builtin_expect(!!(e),1))
#            define __acc_unlikely(e)     (__builtin_expect(!!(e),0))
#        elif (ACC_CC_INTELC && (__INTEL_COMPILER >= 800))
#            define __acc_likely(e)       (__builtin_expect(!!(e),1))
#            define __acc_unlikely(e)     (__builtin_expect(!!(e),0))
#        elif (ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define __acc_likely(e)       (__builtin_expect(!!(e),1))
#            define __acc_unlikely(e)     (__builtin_expect(!!(e),0))
#        endif
#    endif
#    if defined(__acc_likely)
#        define __acc_HAVE_likely 1
#    else
#        define __acc_likely(e)       (e)
#    endif
#    if defined(__acc_unlikely)
#        define __acc_HAVE_unlikely 1
#    else
#        define __acc_unlikely(e)     (e)
#    endif
#    if !defined(ACC_UNUSED)
#        if (ACC_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
#            define ACC_UNUSED(var)         ((void) &var)
#        elif (ACC_CC_BORLANDC || ACC_CC_HIGHC || ACC_CC_NDPC || ACC_CC_PELLESC || ACC_CC_TURBOC)
#            define ACC_UNUSED(var)         if (&var) ; else
#        elif (ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
#            define ACC_UNUSED(var)         ((void) var)
#        elif (ACC_CC_MSC && (_MSC_VER < 900))
#            define ACC_UNUSED(var)         if (&var) ; else
#        elif (ACC_CC_KEILC)
#            define ACC_UNUSED(var)         {extern int __acc_unused[1-2*!(sizeof(var)>0)];}
#        elif (ACC_CC_PACIFICC)
#            define ACC_UNUSED(var)         ((void) sizeof(var))
#        elif (ACC_CC_WATCOMC) && defined(__cplusplus)
#            define ACC_UNUSED(var)         ((void) var)
#        else
#            define ACC_UNUSED(var)         ((void) &var)
#        endif
#    endif
#    if !defined(ACC_UNUSED_FUNC)
#        if (ACC_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
#            define ACC_UNUSED_FUNC(func)   ((void) func)
#        elif (ACC_CC_BORLANDC || ACC_CC_NDPC || ACC_CC_TURBOC)
#            define ACC_UNUSED_FUNC(func)   if (func) ; else
#        elif (ACC_CC_LLVM)
#            define ACC_UNUSED_FUNC(func)   ((void) &func)
#        elif (ACC_CC_MSC && (_MSC_VER < 900))
#            define ACC_UNUSED_FUNC(func)   if (func) ; else
#        elif (ACC_CC_MSC)
#            define ACC_UNUSED_FUNC(func)   ((void) &func)
#        elif (ACC_CC_KEILC || ACC_CC_PELLESC)
#            define ACC_UNUSED_FUNC(func)   {extern int __acc_unused[1-2*!(sizeof((int)func)>0)];}
#        else
#            define ACC_UNUSED_FUNC(func)   ((void) func)
#        endif
#    endif
#    if !defined(ACC_UNUSED_LABEL)
#        if (ACC_CC_WATCOMC) && defined(__cplusplus)
#            define ACC_UNUSED_LABEL(l)     switch(0) case 1:goto l
#        elif (ACC_CC_INTELC || ACC_CC_WATCOMC)
#            define ACC_UNUSED_LABEL(l)     if (0) goto l
#        else
#            define ACC_UNUSED_LABEL(l)     switch(0) case 1:goto l
#        endif
#    endif
#    if !defined(ACC_DEFINE_UNINITIALIZED_VAR)
#        if 0
#            define ACC_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var
#        elif 0 && (ACC_CC_GNUC)
#            define ACC_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var = var
#        else
#            define ACC_DEFINE_UNINITIALIZED_VAR(type,var,init)  type var = init
#        endif
#    endif
#    if !defined(ACC_COMPILE_TIME_ASSERT_HEADER)
#        if (ACC_CC_AZTECC || ACC_CC_ZORTECHC)
#            define ACC_COMPILE_TIME_ASSERT_HEADER(e)  extern int __acc_cta[1-!(e)];
#        elif (ACC_CC_DMC || ACC_CC_SYMANTECC)
#            define ACC_COMPILE_TIME_ASSERT_HEADER(e)  extern int __acc_cta[1u-2*!(e)];
#        elif (ACC_CC_TURBOC && (__TURBOC__ == 0x0295))
#            define ACC_COMPILE_TIME_ASSERT_HEADER(e)  extern int __acc_cta[1-!(e)];
#        else
#            define ACC_COMPILE_TIME_ASSERT_HEADER(e)  extern int __acc_cta[1-2*!(e)];
#        endif
#    endif
#    if !defined(ACC_COMPILE_TIME_ASSERT)
#        if (ACC_CC_AZTECC)
#            define ACC_COMPILE_TIME_ASSERT(e)  {typedef int __acc_cta_t[1-!(e)];}
#        elif (ACC_CC_DMC || ACC_CC_PACIFICC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC)
#            define ACC_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
#        elif (ACC_CC_MSC && (_MSC_VER < 900))
#            define ACC_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
#        elif (ACC_CC_TURBOC && (__TURBOC__ == 0x0295))
#            define ACC_COMPILE_TIME_ASSERT(e)  switch(0) case 1:case !(e):break;
#        else
#            define ACC_COMPILE_TIME_ASSERT(e)  {typedef int __acc_cta_t[1-2*!(e)];}
#        endif
#    endif
#    if (ACC_ARCH_I086 || ACC_ARCH_I386) && (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
#        if (ACC_CC_GNUC || ACC_CC_HIGHC || ACC_CC_NDPC || ACC_CC_PACIFICC)
#        elif (ACC_CC_DMC || ACC_CC_SYMANTECC || ACC_CC_ZORTECHC)
#            define __acc_cdecl                 __cdecl
#            define __acc_cdecl_atexit
#            define __acc_cdecl_main            __cdecl
#            if (ACC_OS_OS2 && (ACC_CC_DMC || ACC_CC_SYMANTECC))
#                define __acc_cdecl_qsort         __pascal
#            elif (ACC_OS_OS2 && (ACC_CC_ZORTECHC))
#                define __acc_cdecl_qsort         _stdcall
#            else
#                define __acc_cdecl_qsort         __cdecl
#            endif
#        elif (ACC_CC_WATCOMC)
#            define __acc_cdecl                 __cdecl
#        else
#            define __acc_cdecl                 __cdecl
#            define __acc_cdecl_atexit          __cdecl
#            define __acc_cdecl_main            __cdecl
#            define __acc_cdecl_qsort           __cdecl
#        endif
#        if (ACC_CC_GNUC || ACC_CC_HIGHC || ACC_CC_NDPC || ACC_CC_PACIFICC || ACC_CC_WATCOMC)
#        elif (ACC_OS_OS2 && (ACC_CC_DMC || ACC_CC_SYMANTECC))
#            define __acc_cdecl_sighandler      __pascal
#        elif (ACC_OS_OS2 && (ACC_CC_ZORTECHC))
#            define __acc_cdecl_sighandler      _stdcall
#        elif (ACC_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE)
#            define __acc_cdecl_sighandler      __clrcall
#        elif (ACC_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700))
#            if defined(_DLL)
#                define __acc_cdecl_sighandler    _far _cdecl _loadds
#            elif defined(_MT)
#                define __acc_cdecl_sighandler    _far _cdecl
#            else
#                define __acc_cdecl_sighandler    _cdecl
#            endif
#        else
#            define __acc_cdecl_sighandler      __cdecl
#        endif
#    elif (ACC_ARCH_I386) && (ACC_CC_WATCOMC)
#        define __acc_cdecl                   __cdecl
#    elif (ACC_ARCH_M68K && ACC_OS_TOS && (ACC_CC_PUREC || ACC_CC_TURBOC))
#        define __acc_cdecl                   cdecl
#    endif
#    if !defined(__acc_cdecl)
#        define __acc_cdecl
#    endif
#    if !defined(__acc_cdecl_atexit)
#        define __acc_cdecl_atexit
#    endif
#    if !defined(__acc_cdecl_main)
#        define __acc_cdecl_main
#    endif
#    if !defined(__acc_cdecl_qsort)
#        define __acc_cdecl_qsort
#    endif
#    if !defined(__acc_cdecl_sighandler)
#        define __acc_cdecl_sighandler
#    endif
#    if !defined(__acc_cdecl_va)
#        define __acc_cdecl_va                __acc_cdecl
#    endif
#    if !defined(ACC_CFG_NO_WINDOWS_H)
#        if (ACC_OS_CYGWIN || (ACC_OS_EMX && defined(__RSXNT__)) || ACC_OS_WIN32 || ACC_OS_WIN64)
#            if (ACC_CC_WATCOMC && (__WATCOMC__ < 1000))
#            elif (ACC_OS_WIN32 && ACC_CC_GNUC) && defined(__PW32__)
#            elif ((ACC_OS_CYGWIN || defined(__MINGW32__)) && (ACC_CC_GNUC && (ACC_CC_GNUC < 0x025f00ul)))
#            else
#                define ACC_HAVE_WINDOWS_H 1
#            endif
#        endif
#    endif
#    if (ACC_ARCH_ALPHA)
#        define ACC_OPT_AVOID_UINT_INDEX  1
#        define ACC_OPT_AVOID_SHORT       1
#        define ACC_OPT_AVOID_USHORT      1
#    elif (ACC_ARCH_AMD64)
#        define ACC_OPT_AVOID_INT_INDEX   1
#        define ACC_OPT_AVOID_UINT_INDEX  1
#        define ACC_OPT_UNALIGNED16       1
#        define ACC_OPT_UNALIGNED32       1
#        define ACC_OPT_UNALIGNED64       1
#    elif (ACC_ARCH_ARM && ACC_ARCH_ARM_THUMB)
#    elif (ACC_ARCH_ARM)
#        define ACC_OPT_AVOID_SHORT       1
#        define ACC_OPT_AVOID_USHORT      1
#    elif (ACC_ARCH_CRIS)
#        define ACC_OPT_UNALIGNED16       1
#        define ACC_OPT_UNALIGNED32       1
#    elif (ACC_ARCH_I386)
#        define ACC_OPT_UNALIGNED16       1
#        define ACC_OPT_UNALIGNED32       1
#    elif (ACC_ARCH_IA64)
#        define ACC_OPT_AVOID_INT_INDEX   1
#        define ACC_OPT_AVOID_UINT_INDEX  1
#        define ACC_OPT_PREFER_POSTINC    1
#    elif (ACC_ARCH_M68K)
#        define ACC_OPT_PREFER_POSTINC    1
#        define ACC_OPT_PREFER_PREDEC     1
#        if defined(__mc68020__) && !defined(__mcoldfire__)
#            define ACC_OPT_UNALIGNED16     1
#            define ACC_OPT_UNALIGNED32     1
#        endif
#    elif (ACC_ARCH_MIPS)
#        define ACC_OPT_AVOID_UINT_INDEX  1
#    elif (ACC_ARCH_POWERPC)
#        define ACC_OPT_PREFER_PREINC     1
#        define ACC_OPT_PREFER_PREDEC     1
#        if defined(ACC_ABI_BIG_ENDIAN)
#            define ACC_OPT_UNALIGNED16     1
#            define ACC_OPT_UNALIGNED32     1
#        endif
#    elif (ACC_ARCH_S390)
#        define ACC_OPT_UNALIGNED16       1
#        define ACC_OPT_UNALIGNED32       1
#        if (ACC_SIZEOF_SIZE_T == 8)
#            define ACC_OPT_UNALIGNED64     1
#        endif
#    elif (ACC_ARCH_SH)
#        define ACC_OPT_PREFER_POSTINC    1
#        define ACC_OPT_PREFER_PREDEC     1
#    endif
#    if !defined(ACC_CFG_NO_INLINE_ASM)
#        if defined(ACC_CC_LLVM)
#            define ACC_CFG_NO_INLINE_ASM 1
#        endif
#    endif
#    if !defined(ACC_CFG_NO_UNALIGNED)
#        if defined(ACC_ABI_NEUTRAL_ENDIAN) || defined(ACC_ARCH_GENERIC)
#            define ACC_CFG_NO_UNALIGNED 1
#        endif
#    endif
#    if defined(ACC_CFG_NO_UNALIGNED)
#        undef ACC_OPT_UNALIGNED16
#        undef ACC_OPT_UNALIGNED32
#        undef ACC_OPT_UNALIGNED64
#    endif
#    if defined(ACC_CFG_NO_INLINE_ASM)
#    elif (ACC_ARCH_I386 && (ACC_OS_DOS32 || ACC_OS_WIN32) && (ACC_CC_DMC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_PELLESC))
#        define ACC_ASM_SYNTAX_MSC 1
#    elif (ACC_OS_WIN64 && (ACC_CC_DMC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_PELLESC))
#    elif (ACC_ARCH_I386 && (ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_PATHSCALE))
#        define ACC_ASM_SYNTAX_GNUC 1
#    elif (ACC_ARCH_AMD64 && (ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_PATHSCALE))
#        define ACC_ASM_SYNTAX_GNUC 1
#    endif
#    if (ACC_ASM_SYNTAX_GNUC)
#        if (ACC_ARCH_I386 && ACC_CC_GNUC && (ACC_CC_GNUC < 0x020000ul))
#            define __ACC_ASM_CLOBBER         "ax"
#        elif (ACC_CC_INTELC)
#            define __ACC_ASM_CLOBBER         "memory"
#        else
#            define __ACC_ASM_CLOBBER         "cc", "memory"
#        endif
#    endif
#    if defined(__ACC_INFOSTR_MM)
#    elif (ACC_MM_FLAT) && (defined(__ACC_INFOSTR_PM) || defined(ACC_INFO_ABI_PM))
#        define __ACC_INFOSTR_MM          ""
#    elif defined(ACC_INFO_MM)
#        define __ACC_INFOSTR_MM          "." ACC_INFO_MM
#    else
#        define __ACC_INFOSTR_MM          ""
#    endif
#    if defined(__ACC_INFOSTR_PM)
#    elif defined(ACC_INFO_ABI_PM)
#        define __ACC_INFOSTR_PM          "." ACC_INFO_ABI_PM
#    else
#        define __ACC_INFOSTR_PM          ""
#    endif
#    if defined(__ACC_INFOSTR_ENDIAN)
#    elif defined(ACC_INFO_ABI_ENDIAN)
#        define __ACC_INFOSTR_ENDIAN      "." ACC_INFO_ABI_ENDIAN
#    else
#        define __ACC_INFOSTR_ENDIAN      ""
#    endif
#    if defined(__ACC_INFOSTR_OSNAME)
#    elif defined(ACC_INFO_OS_CONSOLE)
#        define __ACC_INFOSTR_OSNAME      ACC_INFO_OS "." ACC_INFO_OS_CONSOLE
#    elif defined(ACC_INFO_OS_POSIX)
#        define __ACC_INFOSTR_OSNAME      ACC_INFO_OS "." ACC_INFO_OS_POSIX
#    else
#        define __ACC_INFOSTR_OSNAME      ACC_INFO_OS
#    endif
#    if defined(__ACC_INFOSTR_LIBC)
#    elif defined(ACC_INFO_LIBC)
#        define __ACC_INFOSTR_LIBC        "." ACC_INFO_LIBC
#    else
#        define __ACC_INFOSTR_LIBC        ""
#    endif
#    if defined(__ACC_INFOSTR_CCVER)
#    elif defined(ACC_INFO_CCVER)
#        define __ACC_INFOSTR_CCVER       " " ACC_INFO_CCVER
#    else
#        define __ACC_INFOSTR_CCVER       ""
#    endif
#    define ACC_INFO_STRING \
    ACC_INFO_ARCH __ACC_INFOSTR_MM __ACC_INFOSTR_PM __ACC_INFOSTR_ENDIAN \
    " " __ACC_INFOSTR_OSNAME __ACC_INFOSTR_LIBC " " ACC_INFO_CC __ACC_INFOSTR_CCVER
#    if defined(ACC_CFG_NO_CONFIG_HEADER)
#    elif defined(ACC_CFG_CONFIG_HEADER)
#    else
#        if !defined(ACC_CFG_AUTO_NO_HEADERS)
#            if defined(ACC_LIBC_NAKED)
#            elif defined(ACC_LIBC_FREESTANDING)
#                define HAVE_LIMITS_H 1
#                define HAVE_STDARG_H 1
#                define HAVE_STDDEF_H 1
#            elif defined(ACC_LIBC_MOSTLY_FREESTANDING)
#                define HAVE_LIMITS_H 1
#                define HAVE_SETJMP_H 1
#                define HAVE_STDARG_H 1
#                define HAVE_STDDEF_H 1
#                define HAVE_STDIO_H 1
#                define HAVE_STRING_H 1
#            else
#                define STDC_HEADERS 1
#                define HAVE_ASSERT_H 1
#                define HAVE_CTYPE_H 1
#                define HAVE_DIRENT_H 1
#                define HAVE_ERRNO_H 1
#                define HAVE_FCNTL_H 1
#                define HAVE_FLOAT_H 1
#                define HAVE_LIMITS_H 1
#                define HAVE_MALLOC_H 1
#                define HAVE_MEMORY_H 1
#                define HAVE_SETJMP_H 1
#                define HAVE_SIGNAL_H 1
#                define HAVE_STDARG_H 1
#                define HAVE_STDDEF_H 1
#                define HAVE_STDIO_H 1
#                define HAVE_STDLIB_H 1
#                define HAVE_STRING_H 1
#                define HAVE_TIME_H 1
#                define HAVE_UNISTD_H 1
#                define HAVE_UTIME_H 1
#                define HAVE_SYS_STAT_H 1
#                define HAVE_SYS_TIME_H 1
#                define HAVE_SYS_TYPES_H 1
#                if (ACC_OS_POSIX)
#                    if (ACC_OS_POSIX_AIX)
#                        define HAVE_SYS_RESOURCE_H 1
#                    elif (ACC_OS_POSIX_FREEBSD || ACC_OS_POSIX_MACOSX || ACC_OS_POSIX_NETBSD || ACC_OS_POSIX_OPENBSD)
#                        define HAVE_STRINGS_H 1
#                        undef HAVE_MALLOC_H
#                    elif (ACC_OS_POSIX_HPUX || ACC_OS_POSIX_INTERIX)
#                        define HAVE_ALLOCA_H 1
#                    elif (ACC_OS_POSIX_MACOSX && ACC_LIBC_MSL)
#                        undef HAVE_SYS_TIME_H
#                        undef HAVE_SYS_TYPES_H
#                    elif (ACC_OS_POSIX_SOLARIS || ACC_OS_POSIX_SUNOS)
#                        define HAVE_ALLOCA_H 1
#                    endif
#                    if (ACC_LIBC_DIETLIBC || ACC_LIBC_GLIBC || ACC_LIBC_UCLIBC)
#                        define HAVE_STRINGS_H 1
#                        define HAVE_SYS_MMAN_H 1
#                        define HAVE_SYS_RESOURCE_H 1
#                        define HAVE_SYS_WAIT_H 1
#                    endif
#                    if (ACC_LIBC_NEWLIB)
#                        undef HAVE_STRINGS_H
#                    endif
#                elif (ACC_OS_CYGWIN)
#                    define HAVE_IO_H 1
#                elif (ACC_OS_EMX)
#                    define HAVE_ALLOCA_H 1
#                    define HAVE_IO_H 1
#                elif (ACC_ARCH_M68K && ACC_OS_TOS && ACC_CC_GNUC)
#                    if !defined(__MINT__)
#                        undef HAVE_MALLOC_H
#                    endif
#                elif (ACC_ARCH_M68K && ACC_OS_TOS && (ACC_CC_PUREC || ACC_CC_TURBOC))
#                    undef HAVE_DIRENT_H
#                    undef HAVE_FCNTL_H
#                    undef HAVE_MALLOC_H
#                    undef HAVE_MEMORY_H
#                    undef HAVE_UNISTD_H
#                    undef HAVE_UTIME_H
#                    undef HAVE_SYS_STAT_H
#                    undef HAVE_SYS_TIME_H
#                    undef HAVE_SYS_TYPES_H
#                endif
#                if (ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
#                    define HAVE_CONIO_H 1
#                    define HAVE_DIRECT_H 1
#                    define HAVE_DOS_H 1
#                    define HAVE_IO_H 1
#                    define HAVE_SHARE_H 1
#                    if (ACC_CC_AZTECC)
#                        undef HAVE_CONIO_H
#                        undef HAVE_DIRECT_H
#                        undef HAVE_DIRENT_H
#                        undef HAVE_MALLOC_H
#                        undef HAVE_SHARE_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_STAT_H
#                        undef HAVE_SYS_TIME_H
#                        undef HAVE_SYS_TYPES_H
#                    elif (ACC_CC_BORLANDC)
#                        undef HAVE_UNISTD_H
#                        undef HAVE_SYS_TIME_H
#                        if (ACC_OS_WIN32 || ACC_OS_WIN64)
#                            undef HAVE_DIRENT_H
#                        endif
#                        if (__BORLANDC__ < 0x0400)
#                            undef HAVE_DIRENT_H
#                            undef HAVE_UTIME_H
#                        endif
#                    elif (ACC_CC_DMC)
#                        undef HAVE_DIRENT_H
#                        undef HAVE_UNISTD_H
#                        define HAVE_SYS_DIRENT_H 1
#                    elif (ACC_OS_DOS32 && ACC_CC_GNUC) && defined(__DJGPP__)
#                    elif (ACC_OS_DOS32 && ACC_CC_HIGHC)
#                        define HAVE_ALLOCA_H 1
#                        undef HAVE_DIRENT_H
#                        undef HAVE_UNISTD_H
#                    elif (ACC_CC_IBMC && ACC_OS_OS2)
#                        undef HAVE_DOS_H
#                        undef HAVE_DIRENT_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_TIME_H
#                        define HAVE_SYS_UTIME_H 1
#                    elif (ACC_CC_INTELC || ACC_CC_MSC)
#                        undef HAVE_DIRENT_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_TIME_H
#                        define HAVE_SYS_UTIME_H 1
#                    elif (ACC_CC_LCCWIN32)
#                        undef HAVE_DIRENT_H
#                        undef HAVE_DOS_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_SYS_TIME_H
#                    elif (ACC_OS_WIN32 && ACC_CC_GNUC) && defined(__MINGW32__)
#                        undef HAVE_UTIME_H
#                        define HAVE_SYS_UTIME_H 1
#                    elif (ACC_OS_WIN32 && ACC_LIBC_MSL)
#                        define HAVE_ALLOCA_H 1
#                        undef HAVE_DOS_H
#                        undef HAVE_SHARE_H
#                        undef HAVE_SYS_TIME_H
#                    elif (ACC_CC_NDPC)
#                        undef HAVE_DIRENT_H
#                        undef HAVE_DOS_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_TIME_H
#                    elif (ACC_CC_PACIFICC)
#                        undef HAVE_DIRECT_H
#                        undef HAVE_DIRENT_H
#                        undef HAVE_FCNTL_H
#                        undef HAVE_IO_H
#                        undef HAVE_MALLOC_H
#                        undef HAVE_MEMORY_H
#                        undef HAVE_SHARE_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_STAT_H
#                        undef HAVE_SYS_TIME_H
#                        undef HAVE_SYS_TYPES_H
#                    elif (ACC_OS_WIN32 && ACC_CC_PELLESC)
#                        undef HAVE_DIRENT_H
#                        undef HAVE_DOS_H
#                        undef HAVE_MALLOC_H
#                        undef HAVE_SHARE_H
#                        undef HAVE_UNISTD_H
#                        undef HAVE_UTIME_H
#                        undef HAVE_SYS_TIME_H
#                        if (__POCC__ < 280)
#                        else
#                            defi