--- /dev/null
+Description: Add support for LZO compression in btrfs
+Author: Szymon Janc <szymon@janc.net.pl>
+Author: Vladimir Serbinenko <phcoder@gmail.com>
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3436
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3459
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3551
+Origin: backport, http://bazaar.launchpad.net/~vcs-imports/grub/grub2-bzr/revision/3804
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/727535
+Forwarded: not-needed
+Last-Update: 2012-03-12
+
+Index: b/Makefile.util.def
+===================================================================
+--- a/Makefile.util.def
++++ b/Makefile.util.def
+@@ -24,8 +24,8 @@
+
+ library = {
+ name = libgrubmods.a;
+- cflags = '$(CFLAGS_GCRY)';
+- cppflags = '$(CPPFLAGS_GCRY)';
++ cflags = '$(CFLAGS_GCRY) $(CFLAGS_POSIX) -Wno-undef';
++ cppflags = '$(CPPFLAGS_GCRY) -I$(srcdir)/lib/posix_wrap -I$(top_srcdir)/grub-core/lib/minilzo -DMINILZO_HAVE_CONFIG_H';
+
+ common_nodist = grub_script.tab.c;
+ common_nodist = grub_script.yy.c;
+@@ -85,6 +85,7 @@
+ common = grub-core/lib/LzmaEnc.c;
+ common = grub-core/lib/pbkdf2.c;
+ common = grub-core/lib/crc.c;
++ common = grub-core/lib/adler32.c;
+ common = grub-core/normal/datetime.c;
+ common = grub-core/normal/misc.c;
+ common = grub-core/partmap/acorn.c;
+@@ -101,6 +102,8 @@
+ common = grub-core/script/script.c;
+ common = grub-core/script/argv.c;
+ common = grub-core/io/gzio.c;
++ common = grub-core/io/lzopio.c;
++ common = grub-core/lib/minilzo/minilzo.c;
+ };
+
+ program = {
+Index: b/configure.ac
+===================================================================
+--- a/configure.ac
++++ b/configure.ac
+@@ -483,6 +483,7 @@
+ # Force 32-bit mode.
+ TARGET_CFLAGS="$TARGET_CFLAGS -m32"
+ TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m32"
++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m32"
+ TARGET_LDFLAGS="$TARGET_LDFLAGS -m32"
+ TARGET_MODULE_FORMAT="elf32"
+ fi
+@@ -491,6 +492,7 @@
+ # Force 64-bit mode.
+ TARGET_CFLAGS="$TARGET_CFLAGS -m64"
+ TARGET_CCASFLAGS="$TARGET_CCASFLAGS -m64"
++ TARGET_CPPFLAGS="$TARGET_CPPFLAGS -m64"
+ TARGET_LDFLAGS="$TARGET_LDFLAGS -m64"
+ TARGET_MODULE_FORMAT="elf64"
+ fi
+Index: b/grub-core/Makefile.core.def
+===================================================================
+--- a/grub-core/Makefile.core.def
++++ b/grub-core/Makefile.core.def
+@@ -908,6 +908,8 @@
+ name = btrfs;
+ common = fs/btrfs.c;
+ common = lib/crc.c;
++ cflags = '$(CFLAGS_POSIX) -Wno-undef';
++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H';
+ };
+
+ module = {
+@@ -1509,6 +1511,14 @@
+ };
+
+ module = {
++ name = lzopio;
++ common = io/lzopio.c;
++ common = lib/minilzo/minilzo.c;
++ cflags = '$(CFLAGS_POSIX) -Wno-undef';
++ cppflags = '-I$(srcdir)/lib/posix_wrap -I$(srcdir)/lib/minilzo -DMINILZO_HAVE_CONFIG_H';
++};
++
++module = {
+ name = testload;
+ common = commands/testload.c;
+ };
+@@ -1524,3 +1534,8 @@
+ common = commands/keylayouts.c;
+ enable = videomodules;
+ };
++
++module = {
++ name = adler32;
++ common = lib/adler32.c;
++};
+Index: b/grub-core/fs/btrfs.c
+===================================================================
+--- a/grub-core/fs/btrfs.c
++++ b/grub-core/fs/btrfs.c
+@@ -26,11 +26,23 @@
+ #include <grub/types.h>
+ #include <grub/lib/crc.h>
+ #include <grub/deflate.h>
++#include <minilzo.h>
+
+ GRUB_MOD_LICENSE ("GPLv3+");
+
+ #define GRUB_BTRFS_SIGNATURE "_BHRfS_M"
+
++/* From http://www.oberhumer.com/opensource/lzo/lzofaq.php
++ * LZO will expand incompressible data by a little amount. I still haven't
++ * computed the exact values, but I suggest using these formulas for
++ * a worst-case expansion calculation:
++ *
++ * output_block_size = input_block_size + (input_block_size / 16) + 64 + 3
++ * */
++#define GRUB_BTRFS_LZO_BLOCK_SIZE 4096
++#define GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE (GRUB_BTRFS_LZO_BLOCK_SIZE + \
++ (GRUB_BTRFS_LZO_BLOCK_SIZE / 16) + 64 + 3)
++
+ typedef grub_uint8_t grub_btrfs_checksum_t[0x20];
+ typedef grub_uint16_t grub_btrfs_uuid_t[8];
+
+@@ -41,7 +53,7 @@
+ } __attribute__ ((packed));
+
+ struct grub_btrfs_superblock
+-{
++{
+ grub_btrfs_checksum_t checksum;
+ grub_btrfs_uuid_t uuid;
+ grub_uint8_t dummy[0x10];
+@@ -160,7 +172,8 @@
+ {
+ unsigned depth;
+ unsigned allocated;
+- struct {
++ struct
++ {
+ grub_disk_addr_t addr;
+ unsigned iter;
+ unsigned maxiter;
+@@ -179,7 +192,7 @@
+ {
+ grub_int64_t sec;
+ grub_uint32_t nanosec;
+-} __attribute__ ((aligned(4)));
++} __attribute__ ((aligned (4)));
+
+ struct grub_btrfs_inode
+ {
+@@ -215,12 +228,13 @@
+
+ #define GRUB_BTRFS_COMPRESSION_NONE 0
+ #define GRUB_BTRFS_COMPRESSION_ZLIB 1
++#define GRUB_BTRFS_COMPRESSION_LZO 2
+
+ #define GRUB_BTRFS_OBJECT_ID_CHUNK 0x100
+
+ static grub_disk_addr_t superblock_sectors[] = { 64 * 2, 64 * 1024 * 2,
+- 256 * 1048576 * 2,
+- 1048576ULL * 1048576ULL * 2 };
++ 256 * 1048576 * 2, 1048576ULL * 1048576ULL * 2
++};
+
+ static grub_err_t
+ grub_btrfs_read_logical (struct grub_btrfs_data *data,
+@@ -283,7 +297,7 @@
+ }
+
+ static grub_err_t
+-save_ref (struct grub_btrfs_leaf_descriptor *desc,
++save_ref (struct grub_btrfs_leaf_descriptor *desc,
+ grub_disk_addr_t addr, unsigned i, unsigned m, int l)
+ {
+ desc->depth++;
+@@ -307,7 +321,7 @@
+ static int
+ next (struct grub_btrfs_data *data,
+ struct grub_btrfs_leaf_descriptor *desc,
+- grub_disk_addr_t *outaddr, grub_size_t *outsize,
++ grub_disk_addr_t * outaddr, grub_size_t * outsize,
+ struct grub_btrfs_key *key_out)
+ {
+ grub_err_t err;
+@@ -330,17 +344,17 @@
+ err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter
+ * sizeof (node)
+ + sizeof (struct btrfs_header)
+- + desc->data[desc->depth - 1].addr, &node,
+- sizeof (node));
++ + desc->data[desc->depth - 1].addr,
++ &node, sizeof (node));
+ if (err)
+ return -err;
+
+- err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr), &head,
+- sizeof (head));
++ err = grub_btrfs_read_logical (data, grub_le_to_cpu64 (node.addr),
++ &head, sizeof (head));
+ if (err)
+ return -err;
+
+- save_ref (desc, grub_le_to_cpu64 (node.addr), 0,
++ save_ref (desc, grub_le_to_cpu64 (node.addr), 0,
+ grub_le_to_cpu32 (head.nitems), !head.level);
+ }
+ err = grub_btrfs_read_logical (data, desc->data[desc->depth - 1].iter
+@@ -354,12 +368,12 @@
+ *outaddr = desc->data[desc->depth - 1].addr + sizeof (struct btrfs_header)
+ + grub_le_to_cpu32 (leaf.offset);
+ *key_out = leaf.key;
+- return 1;
++ return 1;
+ }
+
+ static grub_err_t
+ lower_bound (struct grub_btrfs_data *data,
+- const struct grub_btrfs_key *key_in,
++ const struct grub_btrfs_key *key_in,
+ struct grub_btrfs_key *key_out,
+ grub_disk_addr_t root,
+ grub_disk_addr_t *outaddr, grub_size_t *outsize,
+@@ -410,8 +424,9 @@
+ grub_dprintf ("btrfs",
+ "internal node (depth %d) %" PRIxGRUB_UINT64_T
+ " %x %" PRIxGRUB_UINT64_T "\n", depth,
+- node.key.object_id, node.key.type, node.key.offset);
+-
++ node.key.object_id, node.key.type,
++ node.key.offset);
++
+ if (key_cmp (&node.key, key_in) == 0)
+ {
+ err = GRUB_ERR_NONE;
+@@ -433,7 +448,7 @@
+ err = GRUB_ERR_NONE;
+ if (desc)
+ err = save_ref (desc, addr - sizeof (head), i - 1,
+- grub_le_to_cpu32 (head.nitems), 0);
++ grub_le_to_cpu32 (head.nitems), 0);
+ if (err)
+ return err;
+ addr = grub_le_to_cpu64 (node_last.addr);
+@@ -457,7 +472,7 @@
+ &leaf, sizeof (leaf));
+ if (err)
+ return err;
+-
++
+ grub_dprintf ("btrfs",
+ "leaf (depth %d) %" PRIxGRUB_UINT64_T
+ " %x %" PRIxGRUB_UINT64_T "\n", depth,
+@@ -465,31 +480,31 @@
+
+ if (key_cmp (&leaf.key, key_in) == 0)
+ {
+- grub_memcpy (key_out, &leaf.key, sizeof(*key_out));
++ grub_memcpy (key_out, &leaf.key, sizeof (*key_out));
+ *outsize = grub_le_to_cpu32 (leaf.size);
+ *outaddr = addr + grub_le_to_cpu32 (leaf.offset);
+ if (desc)
+ return save_ref (desc, addr - sizeof (head), i,
+ grub_le_to_cpu32 (head.nitems), 1);
+- return GRUB_ERR_NONE;
++ return GRUB_ERR_NONE;
+ }
+-
++
+ if (key_cmp (&leaf.key, key_in) > 0)
+ break;
+-
++
+ have_last = 1;
+ leaf_last = leaf;
+ }
+
+ if (have_last)
+ {
+- grub_memcpy (key_out, &leaf_last.key, sizeof(*key_out));
++ grub_memcpy (key_out, &leaf_last.key, sizeof (*key_out));
+ *outsize = grub_le_to_cpu32 (leaf_last.size);
+ *outaddr = addr + grub_le_to_cpu32 (leaf_last.offset);
+ if (desc)
+ return save_ref (desc, addr - sizeof (head), i - 1,
+ grub_le_to_cpu32 (head.nitems), 1);
+- return GRUB_ERR_NONE;
++ return GRUB_ERR_NONE;
+ }
+ *outsize = 0;
+ *outaddr = 0;
+@@ -503,8 +518,7 @@
+ }
+
+ static grub_device_t
+-find_device (struct grub_btrfs_data *data, grub_uint64_t id,
+- int do_rescan)
++find_device (struct grub_btrfs_data *data, grub_uint64_t id, int do_rescan)
+ {
+ grub_device_t dev_found = NULL;
+ auto int hook (const char *name);
+@@ -540,7 +554,7 @@
+ grub_device_close (dev);
+ return 0;
+ }
+-
++
+ dev_found = dev;
+ return 1;
+ }
+@@ -579,17 +593,16 @@
+ }
+
+ static grub_err_t
+-grub_btrfs_read_logical (struct grub_btrfs_data *data,
+- grub_disk_addr_t addr,
++grub_btrfs_read_logical (struct grub_btrfs_data *data, grub_disk_addr_t addr,
+ void *buf, grub_size_t size)
+ {
+ while (size > 0)
+ {
+ grub_uint8_t *ptr;
+ struct grub_btrfs_key *key;
+- struct grub_btrfs_chunk_item *chunk;
++ struct grub_btrfs_chunk_item *chunk;
+ grub_uint64_t csize;
+- grub_err_t err;
++ grub_err_t err = 0;
+ struct grub_btrfs_key key_out;
+ int challoc = 0;
+ grub_device_t dev;
+@@ -597,15 +610,15 @@
+ addr);
+ for (ptr = data->sblock.bootstrap_mapping;
+ ptr < data->sblock.bootstrap_mapping
+- + sizeof (data->sblock.bootstrap_mapping)
+- - sizeof (struct grub_btrfs_key);
+- )
++ + sizeof (data->sblock.bootstrap_mapping)
++ - sizeof (struct grub_btrfs_key);)
+ {
+ key = (struct grub_btrfs_key *) ptr;
+ if (key->type != GRUB_BTRFS_ITEM_TYPE_CHUNK)
+ break;
+ chunk = (struct grub_btrfs_chunk_item *) (key + 1);
+- grub_dprintf ("btrfs", "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n",
++ grub_dprintf ("btrfs",
++ "%" PRIxGRUB_UINT64_T " %" PRIxGRUB_UINT64_T " \n",
+ grub_le_to_cpu64 (key->offset),
+ grub_le_to_cpu64 (chunk->size));
+ if (grub_le_to_cpu64 (key->offset) <= addr
+@@ -702,11 +715,11 @@
+ middle = grub_divmod64 (off,
+ grub_le_to_cpu64 (chunk->stripe_length),
+ &low);
+-
++
+ high = grub_divmod64 (middle, grub_le_to_cpu16 (chunk->nstripes),
+ &stripen);
+- stripe_offset = low + grub_le_to_cpu64 (chunk->stripe_length)
+- * high;
++ stripe_offset =
++ low + grub_le_to_cpu64 (chunk->stripe_length) * high;
+ csize = grub_le_to_cpu64 (chunk->stripe_length) - low;
+ break;
+ }
+@@ -717,7 +730,7 @@
+ middle = grub_divmod64 (off,
+ grub_le_to_cpu64 (chunk->stripe_length),
+ &low);
+-
++
+ high = grub_divmod64 (middle,
+ grub_le_to_cpu16 (chunk->nsubstripes),
+ &stripen);
+@@ -757,7 +770,8 @@
+ paddr = stripe->offset + stripe_offset;
+
+ grub_dprintf ("btrfs", "chunk 0x%" PRIxGRUB_UINT64_T
+- "+0x%" PRIxGRUB_UINT64_T " (%d stripes (%d substripes) of %"
++ "+0x%" PRIxGRUB_UINT64_T
++ " (%d stripes (%d substripes) of %"
+ PRIxGRUB_UINT64_T ") stripe %" PRIxGRUB_UINT32_T
+ " maps to 0x%" PRIxGRUB_UINT64_T "\n",
+ grub_le_to_cpu64 (key->offset),
+@@ -767,7 +781,7 @@
+ grub_le_to_cpu64 (chunk->stripe_length),
+ stripen, stripe->offset);
+ grub_dprintf ("btrfs", "reading paddr 0x%" PRIxGRUB_UINT64_T
+- " for laddr 0x%" PRIxGRUB_UINT64_T"\n", paddr,
++ " for laddr 0x%" PRIxGRUB_UINT64_T "\n", paddr,
+ addr);
+
+ dev = find_device (data, stripe->device_id, j);
+@@ -813,7 +827,7 @@
+ }
+
+ data = grub_zalloc (sizeof (*data));
+- if (! data)
++ if (!data)
+ return NULL;
+
+ err = read_sblock (dev->disk, &data->sblock);
+@@ -864,8 +878,7 @@
+ key_in.type = GRUB_BTRFS_ITEM_TYPE_INODE_ITEM;
+ key_in.offset = 0;
+
+- err = lower_bound (data, &key_in, &key_out, tree,
+- &elemaddr, &elemsize, NULL);
++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, NULL);
+ if (err)
+ return err;
+ if (num != key_out.object_id
+@@ -876,6 +889,76 @@
+ }
+
+ static grub_ssize_t
++grub_btrfs_lzo_decompress(char *ibuf, grub_size_t isize, grub_off_t off,
++ char *obuf, grub_size_t osize)
++{
++ grub_uint32_t total_size, cblock_size, ret = 0;
++ unsigned char buf[GRUB_BTRFS_LZO_BLOCK_SIZE];
++
++ total_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
++ ibuf += sizeof (total_size);
++
++ if (isize < total_size)
++ return -1;
++
++ /* Jump forward to first block with requested data. */
++ while (off >= GRUB_BTRFS_LZO_BLOCK_SIZE)
++ {
++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
++ ibuf += sizeof (cblock_size);
++
++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE)
++ return -1;
++
++ off -= GRUB_BTRFS_LZO_BLOCK_SIZE;
++ ibuf += cblock_size;
++ }
++
++ while (osize > 0)
++ {
++ lzo_uint usize = GRUB_BTRFS_LZO_BLOCK_SIZE;
++
++ cblock_size = grub_le_to_cpu32 (grub_get_unaligned32 (ibuf));
++ ibuf += sizeof (cblock_size);
++
++ if (cblock_size > GRUB_BTRFS_LZO_BLOCK_MAX_CSIZE)
++ return -1;
++
++ /* Block partially filled with requested data. */
++ if (off > 0 || osize < GRUB_BTRFS_LZO_BLOCK_SIZE)
++ {
++ grub_size_t to_copy = grub_min(osize, GRUB_BTRFS_LZO_BLOCK_SIZE - off);
++
++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, buf, &usize,
++ NULL) != LZO_E_OK)
++ return -1;
++
++ to_copy = grub_min(to_copy, usize);
++ grub_memcpy(obuf, buf + off, to_copy);
++
++ osize -= to_copy;
++ ret += to_copy;
++ obuf += to_copy;
++ ibuf += cblock_size;
++ off = 0;
++ continue;
++ }
++
++ /* Decompress whole block directly to output buffer. */
++ if (lzo1x_decompress_safe ((lzo_bytep)ibuf, cblock_size, (lzo_bytep)obuf,
++ &usize, NULL) != LZO_E_OK)
++ return -1;
++
++ osize -= usize;
++ ret += usize;
++ obuf += usize;
++ ibuf += cblock_size;
++ }
++
++ return ret;
++}
++
++static grub_ssize_t
+ grub_btrfs_extent_read (struct grub_btrfs_data *data,
+ grub_uint64_t ino, grub_uint64_t tree,
+ grub_off_t pos0, char *buf, grub_size_t len)
+@@ -915,19 +998,17 @@
+ if (!data->extent)
+ return grub_errno;
+
+- err = grub_btrfs_read_logical (data, elemaddr,
+- data->extent, elemsize);
++ err = grub_btrfs_read_logical (data, elemaddr, data->extent,
++ elemsize);
+ if (err)
+ return err;
+
+- data->extend = data->extstart
+- + grub_le_to_cpu64 (data->extent->size);
++ data->extend = data->extstart + grub_le_to_cpu64 (data->extent->size);
+ if (data->extent->type == GRUB_BTRFS_EXTENT_REGULAR
+ && (char *) &data->extent + elemsize
+- >= (char *) &data->extent->filled
+- + sizeof (data->extent->filled))
+- data->extend = data->extstart
+- + grub_le_to_cpu64 (data->extent->filled);
++ >= (char *) &data->extent->filled + sizeof (data->extent->filled))
++ data->extend =
++ data->extstart + grub_le_to_cpu64 (data->extent->filled);
+
+ grub_dprintf ("btrfs", "extent 0x%" PRIxGRUB_UINT64_T "+0x%"
+ PRIxGRUB_UINT64_T " (0x%"
+@@ -954,7 +1035,8 @@
+ }
+
+ if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE
+- && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB)
++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_ZLIB
++ && data->extent->compression != GRUB_BTRFS_COMPRESSION_LZO)
+ {
+ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+ "compression type 0x%x not supported",
+@@ -964,8 +1046,7 @@
+
+ if (data->extent->encoding)
+ {
+- grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+- "encoding not supported");
++ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "encoding not supported");
+ return -1;
+ }
+
+@@ -981,6 +1062,15 @@
+ != (grub_ssize_t) csize)
+ return -1;
+ }
++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO)
++ {
++ if (grub_btrfs_lzo_decompress(data->extent->inl, data->extsize -
++ ((grub_uint8_t *) data->extent->inl
++ - (grub_uint8_t *) data->extent),
++ extoff, buf, csize)
++ != (grub_ssize_t) csize)
++ return -1;
++ }
+ else
+ grub_memcpy (buf, data->extent->inl + extoff, csize);
+ break;
+@@ -990,10 +1080,13 @@
+ grub_memset (buf, 0, csize);
+ break;
+ }
+- if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB)
++
++ if (data->extent->compression != GRUB_BTRFS_COMPRESSION_NONE)
+ {
+ char *tmp;
+ grub_uint64_t zsize;
++ grub_ssize_t ret;
++
+ zsize = grub_le_to_cpu64 (data->extent->compressed_size);
+ tmp = grub_malloc (zsize);
+ if (!tmp)
+@@ -1006,27 +1099,35 @@
+ grub_free (tmp);
+ return -1;
+ }
+- if (grub_zlib_decompress (tmp, zsize, extoff
+- + grub_le_to_cpu64 (data->extent->offset),
+- buf, csize) != (grub_ssize_t) csize)
+- {
+- grub_free (tmp);
+- return -1;
+- }
++
++ if (data->extent->compression == GRUB_BTRFS_COMPRESSION_ZLIB)
++ ret = grub_zlib_decompress (tmp, zsize, extoff
++ + grub_le_to_cpu64 (data->extent->offset),
++ buf, csize);
++ else if (data->extent->compression == GRUB_BTRFS_COMPRESSION_LZO)
++ ret = grub_btrfs_lzo_decompress (tmp, zsize, extoff
++ + grub_le_to_cpu64 (data->extent->offset),
++ buf, csize);
++ else
++ ret = -1;
++
+ grub_free (tmp);
++
++ if (ret != (grub_ssize_t) csize)
++ return -1;
++
+ break;
+ }
+ err = grub_btrfs_read_logical (data,
+ grub_le_to_cpu64 (data->extent->laddr)
+ + grub_le_to_cpu64 (data->extent->offset)
+- + extoff,
+- buf, csize);
++ + extoff, buf, csize);
+ if (err)
+ return -1;
+ break;
+ default:
+ grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+- "unsupported extent type 0x%x", data->extent->type);
++ "unsupported extent type 0x%x", data->extent->type);
+ return -1;
+ }
+ buf += csize;
+@@ -1089,9 +1190,9 @@
+
+ key->type = GRUB_BTRFS_ITEM_TYPE_DIR_ITEM;
+ key->offset = grub_cpu_to_le64 (~grub_getcrc32c (1, ctoken, ctokenlen));
+-
+- err = lower_bound (data, key, &key_out, *tree,
+- &elemaddr, &elemsize, NULL);
++
++ err = lower_bound (data, key, &key_out, *tree, &elemaddr, &elemsize,
++ NULL);
+ if (err)
+ {
+ grub_free (direl);
+@@ -1128,7 +1229,7 @@
+
+ for (cdirel = direl;
+ (grub_uint8_t *) cdirel - (grub_uint8_t *) direl
+- < (grub_ssize_t) elemsize;
++ < (grub_ssize_t) elemsize;
+ cdirel = (void *) ((grub_uint8_t *) (direl + 1)
+ + grub_le_to_cpu16 (cdirel->n)
+ + grub_le_to_cpu16 (cdirel->m)))
+@@ -1159,7 +1260,7 @@
+ return grub_error (GRUB_ERR_SYMLINK_LOOP,
+ "too deep nesting of symlinks");
+ }
+-
++
+ err = grub_btrfs_read_inode (data, &inode,
+ cdirel->key.object_id, *tree);
+ if (err)
+@@ -1187,7 +1288,7 @@
+ grub_free (tmp);
+ return grub_errno;
+ }
+- grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path,
++ grub_memcpy (tmp + grub_le_to_cpu64 (inode.size), path,
+ grub_strlen (path) + 1);
+ grub_free (path_alloc);
+ path = path_alloc = tmp;
+@@ -1225,8 +1326,7 @@
+ grub_free (path_alloc);
+ return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
+ }
+- err = grub_btrfs_read_logical (data, elemaddr,
+- &ri, sizeof (ri));
++ err = grub_btrfs_read_logical (data, elemaddr, &ri, sizeof (ri));
+ if (err)
+ {
+ grub_free (direl);
+@@ -1253,7 +1353,7 @@
+ default:
+ grub_free (path_alloc);
+ grub_free (direl);
+- return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x",
++ return grub_error (GRUB_ERR_BAD_FS, "unrecognised object type 0x%x",
+ cdirel->key.type);
+ }
+ }
+@@ -1264,8 +1364,8 @@
+
+ static grub_err_t
+ grub_btrfs_dir (grub_device_t device, const char *path,
+- int (*hook) (const char *filename,
+- const struct grub_dirhook_info *info))
++ int (*hook) (const char *filename,
++ const struct grub_dirhook_info *info))
+ {
+ struct grub_btrfs_data *data = grub_btrfs_mount (device);
+ struct grub_btrfs_key key_in, key_out;
+@@ -1286,10 +1386,9 @@
+ if (err)
+ return err;
+ if (type != GRUB_BTRFS_DIR_ITEM_TYPE_DIRECTORY)
+- return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
++ return grub_error (GRUB_ERR_BAD_FILE_TYPE, "not a directory");
+
+- err = lower_bound (data, &key_in, &key_out, tree,
+- &elemaddr, &elemsize, &desc);
++ err = lower_bound (data, &key_in, &key_out, tree, &elemaddr, &elemsize, &desc);
+ if (err)
+ return err;
+ if (key_out.type != GRUB_BTRFS_ITEM_TYPE_DIR_ITEM
+@@ -1329,7 +1428,7 @@
+
+ for (cdirel = direl;
+ (grub_uint8_t *) cdirel - (grub_uint8_t *) direl
+- < (grub_ssize_t) elemsize;
++ < (grub_ssize_t) elemsize;
+ cdirel = (void *) ((grub_uint8_t *) (direl + 1)
+ + grub_le_to_cpu16 (cdirel->n)
+ + grub_le_to_cpu16 (cdirel->m)))
+@@ -1358,7 +1457,7 @@
+ }
+ while (r > 0);
+
+- out:
++out:
+ grub_free (direl);
+
+ free_iterator (&desc);
+@@ -1430,7 +1529,7 @@
+ *uuid = NULL;
+
+ data = grub_btrfs_mount (device);
+- if (! data)
++ if (!data)
+ return grub_errno;
+
+ *uuid = grub_xasprintf ("%04x%04x-%04x-%04x-%04x-%04x%04x%04x",
+@@ -1456,7 +1555,7 @@
+ *label = NULL;
+
+ data = grub_btrfs_mount (device);
+- if (! data)
++ if (!data)
+ return grub_errno;
+
+ *label = grub_strndup (data->sblock.label, sizeof (data->sblock.label));
+@@ -1466,26 +1565,25 @@
+ return grub_errno;
+ }
+
+-static struct grub_fs grub_btrfs_fs =
+- {
+- .name = "btrfs",
+- .dir = grub_btrfs_dir,
+- .open = grub_btrfs_open,
+- .read = grub_btrfs_read,
+- .close = grub_btrfs_close,
+- .uuid = grub_btrfs_uuid,
+- .label = grub_btrfs_label,
++static struct grub_fs grub_btrfs_fs = {
++ .name = "btrfs",
++ .dir = grub_btrfs_dir,
++ .open = grub_btrfs_open,
++ .read = grub_btrfs_read,
++ .close = grub_btrfs_close,
++ .uuid = grub_btrfs_uuid,
++ .label = grub_btrfs_label,
+ #ifdef GRUB_UTIL
+- .reserved_first_sector = 1,
++ .reserved_first_sector = 1,
+ #endif
+- };
++};
+
+-GRUB_MOD_INIT(btrfs)
++GRUB_MOD_INIT (btrfs)
+ {
+ grub_fs_register (&grub_btrfs_fs);
+ }
+
+-GRUB_MOD_FINI(btrfs)
++GRUB_MOD_FINI (btrfs)
+ {
+ grub_fs_unregister (&grub_btrfs_fs);
+ }
+Index: b/grub-core/io/lzopio.c
+===================================================================
+--- /dev/null
++++ b/grub-core/io/lzopio.c
+@@ -0,0 +1,564 @@
++/* lzopio.c - decompression support for lzop */
++/*
++ * GRUB -- GRand Unified Bootloader
++ * Copyright (C) 2011 Free Software Foundation, Inc.
++ *
++ * GRUB is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation, either version 3 of the License, or
++ * (at your option) any later version.
++ *
++ * GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <grub/err.h>
++#include <grub/mm.h>
++#include <grub/file.h>
++#include <grub/fs.h>
++#include <grub/dl.h>
++#include <grub/crypto.h>
++#include <minilzo.h>
++
++GRUB_MOD_LICENSE ("GPLv3+");
++
++#define LZOP_MAGIC "\x89\x4c\x5a\x4f\x00\x0d\x0a\x1a\x0a"
++#define LZOP_MAGIC_SIZE 9
++#define LZOP_CHECK_SIZE 4
++#define LZOP_NEW_LIB 0x0940
++
++/* Header flags - copied from conf.h of LZOP source code. */
++#define F_ADLER32_D 0x00000001L
++#define F_ADLER32_C 0x00000002L
++#define F_STDIN 0x00000004L
++#define F_STDOUT 0x00000008L
++#define F_NAME_DEFAULT 0x00000010L
++#define F_DOSISH 0x00000020L
++#define F_H_EXTRA_FIELD 0x00000040L
++#define F_H_GMTDIFF 0x00000080L
++#define F_CRC32_D 0x00000100L
++#define F_CRC32_C 0x00000200L
++#define F_MULTIPART 0x00000400L
++#define F_H_FILTER 0x00000800L
++#define F_H_CRC32 0x00001000L
++#define F_H_PATH 0x00002000L
++#define F_MASK 0x00003FFFL
++
++struct block_header
++{
++ grub_uint32_t usize;
++ grub_uint32_t csize;
++ grub_uint32_t ucheck;
++ grub_uint32_t ccheck;
++ unsigned char *cdata;
++ unsigned char *udata;
++};
++
++struct grub_lzopio
++{
++ grub_file_t file;
++ int has_ccheck;
++ int has_ucheck;
++ const gcry_md_spec_t *ucheck_fun;
++ const gcry_md_spec_t *ccheck_fun;
++ grub_off_t saved_off; /* Rounded down to block boundary. */
++ grub_off_t start_block_off;
++ struct block_header block;
++};
++
++typedef struct grub_lzopio *grub_lzopio_t;
++static struct grub_fs grub_lzopio_fs;
++
++/* Some helper functions. On errors memory allocated by those function is free
++ * either on close() so no risk of leaks. This makes functions simpler. */
++
++/* Read block header from file, after successful exit file points to
++ * beginning of block data. */
++static int
++read_block_header (struct grub_lzopio *lzopio)
++{
++ lzopio->saved_off += lzopio->block.usize;
++
++ /* Free cached block data if any. */
++ grub_free (lzopio->block.udata);
++ grub_free (lzopio->block.cdata);
++ lzopio->block.udata = NULL;
++ lzopio->block.cdata = NULL;
++
++ if (grub_file_read (lzopio->file, &lzopio->block.usize,
++ sizeof (lzopio->block.usize)) !=
++ sizeof (lzopio->block.usize))
++ return -1;
++
++ lzopio->block.usize = grub_be_to_cpu32 (lzopio->block.usize);
++
++ /* Last block has uncompressed data size == 0 and no other fields. */
++ if (lzopio->block.usize == 0)
++ {
++ if (grub_file_tell (lzopio->file) == grub_file_size (lzopio->file))
++ return 0;
++ else
++ return -1;
++ }
++
++ /* Read compressed data block size. */
++ if (grub_file_read (lzopio->file, &lzopio->block.csize,
++ sizeof (lzopio->block.csize)) !=
++ sizeof (lzopio->block.csize))
++ return -1;
++
++ lzopio->block.csize = grub_be_to_cpu32 (lzopio->block.csize);
++
++ /* Corrupted. */
++ if (lzopio->block.csize > lzopio->block.usize)
++ return -1;
++
++ /* Read checksum of uncompressed data. */
++ if (lzopio->has_ucheck)
++ {
++ if (grub_file_read (lzopio->file, &lzopio->block.ucheck,
++ sizeof (lzopio->block.ucheck)) !=
++ sizeof (lzopio->block.ucheck))
++ return -1;
++
++ lzopio->block.ucheck = grub_be_to_cpu32 (lzopio->block.ucheck);
++ }
++
++ /* Read checksum of compressed data. */
++ if (lzopio->has_ccheck)
++ {
++ /* Incompressible data block. */
++ if (lzopio->block.csize == lzopio->block.usize)
++ {
++ lzopio->block.ccheck = lzopio->block.ucheck;
++ }
++ else
++ {
++ if (grub_file_read (lzopio->file, &lzopio->block.ccheck,
++ sizeof (lzopio->block.ccheck)) !=
++ sizeof (lzopio->block.ccheck))
++ return -1;
++
++ lzopio->block.ccheck = grub_be_to_cpu32 (lzopio->block.ccheck);
++ }
++ }
++
++ return 0;
++}
++
++/* Read block data into memory. File must be set to beginning of block data.
++ * Can't be called on last block. */
++static int
++read_block_data (struct grub_lzopio *lzopio)
++{
++ lzopio->block.cdata = grub_malloc (lzopio->block.csize);
++ if (!lzopio->block.cdata)
++ return -1;
++
++ if (grub_file_read (lzopio->file, lzopio->block.cdata, lzopio->block.csize)
++ != (grub_ssize_t) lzopio->block.csize)
++ return -1;
++
++ if (lzopio->ccheck_fun)
++ {
++ grub_uint64_t context[(lzopio->ccheck_fun->contextsize + 7) / 8];
++
++ lzopio->ccheck_fun->init (context);
++ lzopio->ccheck_fun->write (context, lzopio->block.cdata,
++ lzopio->block.csize);
++ lzopio->ccheck_fun->final (context);
++
++ if (grub_memcmp
++ (lzopio->ccheck_fun->read (context), &lzopio->block.ccheck,
++ sizeof (lzopio->block.ccheck)) != 0)
++ return -1;
++ }
++
++ return 0;
++}
++
++/* Read block data, uncompressed and also store it in memory. */
++/* XXX Investigate possibility of in-place decompression to reduce memory
++ * footprint. Or try to uncompress directly to buf if possible. */
++static int
++uncompress_block (struct grub_lzopio *lzopio)
++{
++ lzo_uint usize = lzopio->block.usize;
++
++ if (read_block_data (lzopio) < 0)
++ return -1;
++
++ /* Incompressible data. */
++ if (lzopio->block.csize == lzopio->block.usize)
++ {
++ lzopio->block.udata = lzopio->block.cdata;
++ lzopio->block.cdata = NULL;
++ }
++ else
++ {
++ lzopio->block.udata = grub_malloc (lzopio->block.usize);
++ if (!lzopio->block.udata)
++ return -1;
++
++ if (lzo1x_decompress_safe (lzopio->block.cdata, lzopio->block.csize,
++ lzopio->block.udata, &usize, NULL)
++ != LZO_E_OK)
++ return -1;
++
++ if (lzopio->ucheck_fun)
++ {
++ grub_uint64_t context[(lzopio->ucheck_fun->contextsize + 7) / 8];
++
++ lzopio->ucheck_fun->init (context);
++ lzopio->ucheck_fun->write (context, lzopio->block.udata,
++ lzopio->block.usize);
++ lzopio->ucheck_fun->final (context);
++
++ if (grub_memcmp
++ (lzopio->ucheck_fun->read (context), &lzopio->block.ucheck,
++ sizeof (lzopio->block.ucheck)) != 0)
++ return -1;
++ }
++
++ /* Compressed data can be free now. */
++ grub_free (lzopio->block.cdata);
++ lzopio->block.cdata = NULL;
++ }
++
++ return 0;
++}
++
++/* Jump to next block and read its header. */
++static int
++jump_block (struct grub_lzopio *lzopio)
++{
++ /* only jump if block was not decompressed (and read from disk) */
++ if (!lzopio->block.udata)
++ {
++ grub_off_t off = grub_file_tell (lzopio->file) + lzopio->block.csize;
++
++ if (grub_file_seek (lzopio->file, off) == ((grub_off_t) - 1))
++ return -1;
++ }
++
++ return read_block_header (lzopio);
++}
++
++static int
++calculate_uncompressed_size (grub_file_t file)
++{
++ grub_lzopio_t lzopio = file->data;
++ grub_off_t usize_total = 0;
++
++ if (read_block_header (lzopio) < 0)
++ return -1;
++
++ /* FIXME: Don't do this for not easily seekable files. */
++ while (lzopio->block.usize != 0)
++ {
++ usize_total += lzopio->block.usize;
++
++ if (jump_block (lzopio) < 0)
++ return -1;
++ }
++
++ file->size = usize_total;
++
++ return 0;
++}
++
++struct lzop_header
++{
++ grub_uint8_t magic[LZOP_MAGIC_SIZE];
++ grub_uint16_t lzop_version;
++ grub_uint16_t lib_version;
++ grub_uint16_t lib_version_ext;
++ grub_uint8_t method;
++ grub_uint8_t level;
++ grub_uint32_t flags;
++ /* grub_uint32_t filter; */ /* No filters support. Rarely used anyway. */
++ grub_uint32_t mode;
++ grub_uint32_t mtime_lo;
++ grub_uint32_t mtime_hi;
++ grub_uint8_t name_len;
++} __attribute__ ((packed));
++
++static int
++test_header (grub_file_t file)
++{
++ grub_lzopio_t lzopio = file->data;
++ struct lzop_header header;
++ grub_uint32_t flags, checksum;
++ const gcry_md_spec_t *hcheck;
++ grub_uint8_t *context = NULL;
++ grub_uint8_t *name = NULL;
++
++ if (grub_file_read (lzopio->file, &header, sizeof (header)) != sizeof (header))
++ {
++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found");
++ return 0;
++ }
++
++ if (grub_memcmp (header.magic, LZOP_MAGIC, LZOP_MAGIC_SIZE) != 0)
++ {
++ grub_error (GRUB_ERR_BAD_FILE_TYPE, "no lzop magic found");
++ return 0;
++ }
++
++ if (grub_be_to_cpu16(header.lib_version) < LZOP_NEW_LIB)
++ {
++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA,
++ "unsupported (too old) LZOP version");
++ return 0;
++ }
++
++ /* Too new version, should upgrade minilzo? */
++ if (grub_be_to_cpu16 (header.lib_version_ext) > MINILZO_VERSION)
++ {
++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA,
++ "unsupported (too new) LZO version");
++ return 0;
++ }
++
++ flags = grub_be_to_cpu32 (header.flags);
++
++ if (flags & F_CRC32_D)
++ {
++ lzopio->has_ucheck = 1;
++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("crc32");
++ }
++ else if (flags & F_ADLER32_D)
++ {
++ lzopio->has_ucheck = 1;
++ lzopio->ucheck_fun = grub_crypto_lookup_md_by_name ("adler32");
++ }
++
++ if (flags & F_CRC32_C)
++ {
++ lzopio->has_ccheck = 1;
++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("crc32");
++ }
++ else if (flags & F_ADLER32_C)
++ {
++ lzopio->has_ccheck = 1;
++ lzopio->ccheck_fun = grub_crypto_lookup_md_by_name ("adler32");
++ }
++
++ if (flags & F_H_CRC32)
++ hcheck = grub_crypto_lookup_md_by_name ("crc32");
++ else
++ hcheck = grub_crypto_lookup_md_by_name ("adler32");
++
++ if (hcheck) {
++ context = grub_malloc(hcheck->contextsize);
++ if (! context)
++ return 0;
++
++ hcheck->init(context);
++
++ /* MAGIC is not included in check calculation. */
++ hcheck->write(context, &header.lzop_version, sizeof(header)- LZOP_MAGIC_SIZE);
++ }
++
++ if (header.name_len != 0)
++ {
++ name = grub_malloc (header.name_len);
++ if (! name)
++ {
++ grub_free (context);
++ return 0;
++ }
++
++ if (grub_file_read (lzopio->file, name, header.name_len) !=
++ header.name_len)
++ {
++ grub_free(name);
++ goto CORRUPTED;
++ }
++
++ if (hcheck)
++ hcheck->write(context, name, header.name_len);
++
++ grub_free(name);
++ }
++
++ if (hcheck)
++ hcheck->final(context);
++
++ if (grub_file_read (lzopio->file, &checksum, sizeof (checksum)) !=
++ sizeof (checksum))
++ goto CORRUPTED;
++
++ if (hcheck)
++ {
++ checksum = grub_cpu_to_be32(checksum);
++ if (grub_memcmp (&checksum, hcheck->read(context), sizeof(checksum)) != 0)
++ goto CORRUPTED;
++ }
++
++ lzopio->start_block_off = grub_file_tell (lzopio->file);
++
++ if (calculate_uncompressed_size (file) < 0)
++ goto CORRUPTED;
++
++ /* Get back to start block. */
++ grub_file_seek (lzopio->file, lzopio->start_block_off);
++
++ /* Read first block - grub_lzopio_read() expects valid block. */
++ if (read_block_header (lzopio) < 0)
++ goto CORRUPTED;
++
++ lzopio->saved_off = 0;
++ return 1;
++
++CORRUPTED:
++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted");
++
++ grub_free(name);
++
++ return 0;
++}
++
++static grub_file_t
++grub_lzopio_open (grub_file_t io)
++{
++ grub_file_t file;
++ grub_lzopio_t lzopio;
++
++ file = (grub_file_t) grub_zalloc (sizeof (*file));
++ if (!file)
++ return 0;
++
++ lzopio = grub_zalloc (sizeof (*lzopio));
++ if (!lzopio)
++ {
++ grub_free (file);
++ return 0;
++ }
++
++ lzopio->file = io;
++
++ file->device = io->device;
++ file->offset = 0;
++ file->data = lzopio;
++ file->read_hook = 0;
++ file->fs = &grub_lzopio_fs;
++ file->size = GRUB_FILE_SIZE_UNKNOWN;
++ file->not_easily_seekable = 1;
++
++ if (grub_file_tell (lzopio->file) != 0)
++ grub_file_seek (lzopio->file, 0);
++
++ if (!test_header (file))
++ {
++ grub_errno = GRUB_ERR_NONE;
++ grub_file_seek (io, 0);
++ grub_free (lzopio);
++ grub_free (file);
++
++ return io;
++ }
++
++ return file;
++}
++
++static grub_ssize_t
++grub_lzopio_read (grub_file_t file, char *buf, grub_size_t len)
++{
++ grub_lzopio_t lzopio = file->data;
++ grub_ssize_t ret = 0;
++ grub_off_t off;
++
++ /* Backward seek before last read block. */
++ if (lzopio->saved_off > grub_file_tell (file))
++ {
++ grub_file_seek (lzopio->file, lzopio->start_block_off);
++
++ if (read_block_header (lzopio) < 0)
++ goto CORRUPTED;
++
++ lzopio->saved_off = 0;
++ }
++
++ /* Forward to first block with requested data. */
++ while (lzopio->saved_off + lzopio->block.usize <= grub_file_tell (file))
++ {
++ /* EOF, could be possible files with unknown size. */
++ if (lzopio->block.usize == 0)
++ return 0;
++
++ if (jump_block (lzopio) < 0)
++ goto CORRUPTED;
++ }
++
++ off = grub_file_tell (file) - lzopio->saved_off;
++
++ while (len != 0 && lzopio->block.usize != 0)
++ {
++ long to_copy;
++
++ /* Block not decompressed yet. */
++ if (!lzopio->block.udata && uncompress_block (lzopio) < 0)
++ goto CORRUPTED;
++
++ /* Copy requested data into buffer. */
++ to_copy = grub_min (lzopio->block.usize - off, len);
++ grub_memcpy (buf, lzopio->block.udata + off, to_copy);
++
++ len -= to_copy;
++ buf += to_copy;
++ ret += to_copy;
++ off = 0;
++
++ /* Read next block if needed. */
++ if (len > 0 && read_block_header (lzopio) < 0)
++ goto CORRUPTED;
++ }
++
++ return ret;
++
++CORRUPTED:
++ grub_error (GRUB_ERR_BAD_COMPRESSED_DATA, "lzop file corrupted");
++ return -1;
++}
++
++/* Release everything, including the underlying file object. */
++static grub_err_t
++grub_lzopio_close (grub_file_t file)
++{
++ grub_lzopio_t lzopio = file->data;
++
++ grub_file_close (lzopio->file);
++ grub_free (lzopio->block.cdata);
++ grub_free (lzopio->block.udata);
++ grub_free (lzopio);
++
++ /* Device must not be closed twice. */
++ file->device = 0;
++ return grub_errno;
++}
++
++static struct grub_fs grub_lzopio_fs = {
++ .name = "lzopio",
++ .dir = 0,
++ .open = 0,
++ .read = grub_lzopio_read,
++ .close = grub_lzopio_close,
++ .label = 0,
++ .next = 0
++};
++
++GRUB_MOD_INIT (lzopio)
++{
++ grub_file_filter_register (GRUB_FILE_FILTER_LZOPIO, grub_lzopio_open);
++}
++
++GRUB_MOD_FINI (lzopio)
++{
++ grub_file_filter_unregister (GRUB_FILE_FILTER_LZOPIO);
++}
+Index: b/grub-core/lib/adler32.c
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/adler32.c
+@@ -0,0 +1,151 @@
++/* adler32.c - adler32 check. */
++/*
++ * GRUB -- GRand Unified Bootloader
++ * Copyright (C) 2011 Free Software Foundation, Inc.
++ *
++ * GRUB is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation, either version 3 of the License, or
++ * (at your option) any later version.
++ *
++ * GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#include <grub/types.h>
++#include <grub/dl.h>
++#include <grub/crypto.h>
++
++/* Based on adler32() from adler32.c of zlib-1.2.5 library. */
++
++#define BASE 65521UL
++#define NMAX 5552
++
++#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;}
++#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
++#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
++#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
++#define DO16(buf) DO8(buf,0); DO8(buf,8);
++
++static grub_uint32_t
++update_adler32 (grub_uint32_t adler, const grub_uint8_t *buf, grub_size_t len)
++{
++ unsigned long sum2;
++ unsigned int n;
++
++ sum2 = (adler >> 16) & 0xffff;
++ adler &= 0xffff;
++
++ if (len == 1)
++ {
++ adler += buf[0];
++ if (adler >= BASE)
++ adler -= BASE;
++ sum2 += adler;
++ if (sum2 >= BASE)
++ sum2 -= BASE;
++ return adler | (sum2 << 16);
++ }
++
++ if (len < 16)
++ {
++ while (len--)
++ {
++ adler += *buf++;
++ sum2 += adler;
++ }
++ if (adler >= BASE)
++ adler -= BASE;
++ sum2 %= BASE;
++ return adler | (sum2 << 16);
++ }
++
++ while (len >= NMAX)
++ {
++ len -= NMAX;
++ n = NMAX / 16;
++ do
++ {
++ DO16 (buf);
++ buf += 16;
++ }
++ while (--n);
++ adler %= BASE;
++ sum2 %= BASE;
++ }
++
++ if (len)
++ {
++ while (len >= 16)
++ {
++ len -= 16;
++ DO16 (buf);
++ buf += 16;
++ }
++ while (len--)
++ {
++ adler += *buf++;
++ sum2 += adler;
++ }
++ adler %= BASE;
++ sum2 %= BASE;
++ }
++
++ return adler | (sum2 << 16);
++}
++
++typedef struct
++{
++ grub_uint32_t adler;
++}
++adler32_context;
++
++static void
++adler32_init (void *context)
++{
++ adler32_context *ctx = (adler32_context *) context;
++ ctx->adler = 1;
++}
++
++static void
++adler32_write (void *context, const void *inbuf, grub_size_t inlen)
++{
++ adler32_context *ctx = (adler32_context *) context;
++ if (!inbuf)
++ return;
++ ctx->adler = update_adler32 (ctx->adler, inbuf, inlen);
++}
++
++static grub_uint8_t *
++adler32_read (void *context)
++{
++ adler32_context *ctx = (adler32_context *) context;
++ return (grub_uint8_t *) &ctx->adler;
++}
++
++static void
++adler32_final (void *context __attribute__ ((unused)))
++{
++}
++
++gcry_md_spec_t _gcry_digest_spec_adler32 = {
++ "ADLER32",0 , 0, 0 , 4,
++ adler32_init, adler32_write, adler32_final, adler32_read,
++ sizeof (adler32_context),
++ .blocksize = 64
++};
++
++GRUB_MOD_INIT(adler32)
++{
++ grub_md_register (&_gcry_digest_spec_adler32);
++}
++
++GRUB_MOD_FINI(adler32)
++{
++ grub_md_unregister (&_gcry_digest_spec_adler32);
++}
+Index: b/grub-core/lib/minilzo/lzoconf.h
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/minilzo/lzoconf.h
+@@ -0,0 +1,446 @@
++/* lzoconf.h -- configuration of the LZO data compression library
++
++ This file is part of the LZO real-time data compression library.
++
++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
++ 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 __LZOCONF_H_INCLUDED
++#define __LZOCONF_H_INCLUDED 1
++
++#define LZO_VERSION 0x2050
++#define LZO_VERSION_STRING "2.05"
++#define LZO_VERSION_DATE "Apr 23 2011"
++
++/* internal Autoconf configuration file - only used when building LZO */
++#if defined(LZO_HAVE_CONFIG_H)
++# include <config.h>
++#endif
++#include <limits.h>
++#include <stddef.h>
++
++
++/***********************************************************************
++// LZO requires a conforming <limits.h>
++************************************************************************/
++
++#if !defined(CHAR_BIT) || (CHAR_BIT != 8)
++# error "invalid CHAR_BIT"
++#endif
++#if !defined(UCHAR_MAX) || !defined(UINT_MAX) || !defined(ULONG_MAX)
++# error "check your compiler installation"
++#endif
++#if (USHRT_MAX < 1) || (UINT_MAX < 1) || (ULONG_MAX < 1)
++# error "your limits.h macros are broken"
++#endif
++
++/* get OS and architecture defines */
++#ifndef __LZODEFS_H_INCLUDED
++#include "lzodefs.h"
++#endif
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++/***********************************************************************
++// some core defines
++************************************************************************/
++
++#if !defined(LZO_UINT32_C)
++# if (UINT_MAX < LZO_0xffffffffL)
++# define LZO_UINT32_C(c) c ## UL
++# else
++# define LZO_UINT32_C(c) ((c) + 0U)
++# endif
++#endif
++
++/* memory checkers */
++#if !defined(__LZO_CHECKER)
++# if defined(__BOUNDS_CHECKING_ON)
++# define __LZO_CHECKER 1
++# elif defined(__CHECKER__)
++# define __LZO_CHECKER 1
++# elif defined(__INSURE__)
++# define __LZO_CHECKER 1
++# elif defined(__PURIFY__)
++# define __LZO_CHECKER 1
++# endif
++#endif
++
++
++/***********************************************************************
++// integral and pointer types
++************************************************************************/
++
++/* lzo_uint should match size_t */
++#if !defined(LZO_UINT_MAX)
++# if defined(LZO_ABI_LLP64) /* WIN64 */
++# if defined(LZO_OS_WIN64)
++ typedef unsigned __int64 lzo_uint;
++ typedef __int64 lzo_int;
++# else
++ typedef unsigned long long lzo_uint;
++ typedef long long lzo_int;
++# endif
++# define LZO_UINT_MAX 0xffffffffffffffffull
++# define LZO_INT_MAX 9223372036854775807LL
++# define LZO_INT_MIN (-1LL - LZO_INT_MAX)
++# elif defined(LZO_ABI_IP32L64) /* MIPS R5900 */
++ typedef unsigned int lzo_uint;
++ typedef int lzo_int;
++# define LZO_UINT_MAX UINT_MAX
++# define LZO_INT_MAX INT_MAX
++# define LZO_INT_MIN INT_MIN
++# elif (ULONG_MAX >= LZO_0xffffffffL)
++ typedef unsigned long lzo_uint;
++ typedef long lzo_int;
++# define LZO_UINT_MAX ULONG_MAX
++# define LZO_INT_MAX LONG_MAX
++# define LZO_INT_MIN LONG_MIN
++# else
++# error "lzo_uint"
++# endif
++#endif
++
++/* Integral types with 32 bits or more. */
++#if !defined(LZO_UINT32_MAX)
++# if (UINT_MAX >= LZO_0xffffffffL)
++ typedef unsigned int lzo_uint32;
++ typedef int lzo_int32;
++# define LZO_UINT32_MAX UINT_MAX
++# define LZO_INT32_MAX INT_MAX
++# define LZO_INT32_MIN INT_MIN
++# elif (ULONG_MAX >= LZO_0xffffffffL)
++ typedef unsigned long lzo_uint32;
++ typedef long lzo_int32;
++# define LZO_UINT32_MAX ULONG_MAX
++# define LZO_INT32_MAX LONG_MAX
++# define LZO_INT32_MIN LONG_MIN
++# else
++# error "lzo_uint32"
++# endif
++#endif
++
++/* Integral types with exactly 64 bits. */
++#if !defined(LZO_UINT64_MAX)
++# if (LZO_UINT_MAX >= LZO_0xffffffffL)
++# if ((((LZO_UINT_MAX) >> 31) >> 31) == 3)
++# define lzo_uint64 lzo_uint
++# define lzo_int64 lzo_int
++# define LZO_UINT64_MAX LZO_UINT_MAX
++# define LZO_INT64_MAX LZO_INT_MAX
++# define LZO_INT64_MIN LZO_INT_MIN
++# endif
++# elif (ULONG_MAX >= LZO_0xffffffffL)
++# if ((((ULONG_MAX) >> 31) >> 31) == 3)
++ typedef unsigned long lzo_uint64;
++ typedef long lzo_int64;
++# define LZO_UINT64_MAX ULONG_MAX
++# define LZO_INT64_MAX LONG_MAX
++# define LZO_INT64_MIN LONG_MIN
++# endif
++# endif
++#endif
++
++/* The larger type of lzo_uint and lzo_uint32. */
++#if (LZO_UINT_MAX >= LZO_UINT32_MAX)
++# define lzo_xint lzo_uint
++#else
++# define lzo_xint lzo_uint32
++#endif
++
++/* Memory model that allows to access memory at offsets of lzo_uint. */
++#if !defined(__LZO_MMODEL)
++# if (LZO_UINT_MAX <= UINT_MAX)
++# define __LZO_MMODEL /*empty*/
++# elif defined(LZO_HAVE_MM_HUGE_PTR)
++# define __LZO_MMODEL_HUGE 1
++# define __LZO_MMODEL __huge
++# else
++# define __LZO_MMODEL /*empty*/
++# endif
++#endif
++
++/* no typedef here because of const-pointer issues */
++#define lzo_bytep unsigned char __LZO_MMODEL *
++#define lzo_charp char __LZO_MMODEL *
++#define lzo_voidp void __LZO_MMODEL *
++#define lzo_shortp short __LZO_MMODEL *
++#define lzo_ushortp unsigned short __LZO_MMODEL *
++#define lzo_uint32p lzo_uint32 __LZO_MMODEL *
++#define lzo_int32p lzo_int32 __LZO_MMODEL *
++#if defined(LZO_UINT64_MAX)
++#define lzo_uint64p lzo_uint64 __LZO_MMODEL *
++#define lzo_int64p lzo_int64 __LZO_MMODEL *
++#endif
++#define lzo_uintp lzo_uint __LZO_MMODEL *
++#define lzo_intp lzo_int __LZO_MMODEL *
++#define lzo_xintp lzo_xint __LZO_MMODEL *
++#define lzo_voidpp lzo_voidp __LZO_MMODEL *
++#define lzo_bytepp lzo_bytep __LZO_MMODEL *
++/* deprecated - use 'lzo_bytep' instead of 'lzo_byte *' */
++#define lzo_byte unsigned char __LZO_MMODEL
++
++typedef int lzo_bool;
++
++
++/***********************************************************************
++// function types
++************************************************************************/
++
++/* name mangling */
++#if !defined(__LZO_EXTERN_C)
++# ifdef __cplusplus
++# define __LZO_EXTERN_C extern "C"
++# else
++# define __LZO_EXTERN_C extern
++# endif
++#endif
++
++/* calling convention */
++#if !defined(__LZO_CDECL)
++# define __LZO_CDECL __lzo_cdecl
++#endif
++
++/* DLL export information */
++#if !defined(__LZO_EXPORT1)
++# define __LZO_EXPORT1 /*empty*/
++#endif
++#if !defined(__LZO_EXPORT2)
++# define __LZO_EXPORT2 /*empty*/
++#endif
++
++/* __cdecl calling convention for public C and assembly functions */
++#if !defined(LZO_PUBLIC)
++# define LZO_PUBLIC(_rettype) __LZO_EXPORT1 _rettype __LZO_EXPORT2 __LZO_CDECL
++#endif
++#if !defined(LZO_EXTERN)
++# define LZO_EXTERN(_rettype) __LZO_EXTERN_C LZO_PUBLIC(_rettype)
++#endif
++#if !defined(LZO_PRIVATE)
++# define LZO_PRIVATE(_rettype) static _rettype __LZO_CDECL
++#endif
++
++/* function types */
++typedef int
++(__LZO_CDECL *lzo_compress_t) ( const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem );
++
++typedef int
++(__LZO_CDECL *lzo_decompress_t) ( const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem );
++
++typedef int
++(__LZO_CDECL *lzo_optimize_t) ( lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem );
++
++typedef int
++(__LZO_CDECL *lzo_compress_dict_t)(const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem,
++ const lzo_bytep dict, lzo_uint dict_len );
++
++typedef int
++(__LZO_CDECL *lzo_decompress_dict_t)(const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem,
++ const lzo_bytep dict, lzo_uint dict_len );
++
++
++/* Callback interface. Currently only the progress indicator ("nprogress")
++ * is used, but this may change in a future release. */
++
++struct lzo_callback_t;
++typedef struct lzo_callback_t lzo_callback_t;
++#define lzo_callback_p lzo_callback_t __LZO_MMODEL *
++
++/* malloc & free function types */
++typedef lzo_voidp (__LZO_CDECL *lzo_alloc_func_t)
++ (lzo_callback_p self, lzo_uint items, lzo_uint size);
++typedef void (__LZO_CDECL *lzo_free_func_t)
++ (lzo_callback_p self, lzo_voidp ptr);
++
++/* a progress indicator callback function */
++typedef void (__LZO_CDECL *lzo_progress_func_t)
++ (lzo_callback_p, lzo_uint, lzo_uint, int);
++
++struct lzo_callback_t
++{
++ /* custom allocators (set to 0 to disable) */
++ lzo_alloc_func_t nalloc; /* [not used right now] */
++ lzo_free_func_t nfree; /* [not used right now] */
++
++ /* a progress indicator callback function (set to 0 to disable) */
++ lzo_progress_func_t nprogress;
++
++ /* NOTE: the first parameter "self" of the nalloc/nfree/nprogress
++ * callbacks points back to this struct, so you are free to store
++ * some extra info in the following variables. */
++ lzo_voidp user1;
++ lzo_xint user2;
++ lzo_xint user3;
++};
++
++
++/***********************************************************************
++// error codes and prototypes
++************************************************************************/
++
++/* Error codes for the compression/decompression functions. Negative
++ * values are errors, positive values will be used for special but
++ * normal events.
++ */
++#define LZO_E_OK 0
++#define LZO_E_ERROR (-1)
++#define LZO_E_OUT_OF_MEMORY (-2) /* [lzo_alloc_func_t failure] */
++#define LZO_E_NOT_COMPRESSIBLE (-3) /* [not used right now] */
++#define LZO_E_INPUT_OVERRUN (-4)
++#define LZO_E_OUTPUT_OVERRUN (-5)
++#define LZO_E_LOOKBEHIND_OVERRUN (-6)
++#define LZO_E_EOF_NOT_FOUND (-7)
++#define LZO_E_INPUT_NOT_CONSUMED (-8)
++#define LZO_E_NOT_YET_IMPLEMENTED (-9) /* [not used right now] */
++#define LZO_E_INVALID_ARGUMENT (-10)
++
++
++#ifndef lzo_sizeof_dict_t
++# define lzo_sizeof_dict_t ((unsigned)sizeof(lzo_bytep))
++#endif
++
++/* lzo_init() should be the first function you call.
++ * Check the return code !
++ *
++ * lzo_init() is a macro to allow checking that the library and the
++ * compiler's view of various types are consistent.
++ */
++#define lzo_init() __lzo_init_v2(LZO_VERSION,(int)sizeof(short),(int)sizeof(int),\
++ (int)sizeof(long),(int)sizeof(lzo_uint32),(int)sizeof(lzo_uint),\
++ (int)lzo_sizeof_dict_t,(int)sizeof(char *),(int)sizeof(lzo_voidp),\
++ (int)sizeof(lzo_callback_t))
++LZO_EXTERN(int) __lzo_init_v2(unsigned,int,int,int,int,int,int,int,int,int);
++
++/* version functions (useful for shared libraries) */
++LZO_EXTERN(unsigned) lzo_version(void);
++LZO_EXTERN(const char *) lzo_version_string(void);
++LZO_EXTERN(const char *) lzo_version_date(void);
++LZO_EXTERN(const lzo_charp) _lzo_version_string(void);
++LZO_EXTERN(const lzo_charp) _lzo_version_date(void);
++
++/* string functions */
++LZO_EXTERN(int)
++ lzo_memcmp(const lzo_voidp a, const lzo_voidp b, lzo_uint len);
++LZO_EXTERN(lzo_voidp)
++ lzo_memcpy(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
++LZO_EXTERN(lzo_voidp)
++ lzo_memmove(lzo_voidp dst, const lzo_voidp src, lzo_uint len);
++LZO_EXTERN(lzo_voidp)
++ lzo_memset(lzo_voidp buf, int c, lzo_uint len);
++
++/* checksum functions */
++LZO_EXTERN(lzo_uint32)
++ lzo_adler32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len);
++LZO_EXTERN(lzo_uint32)
++ lzo_crc32(lzo_uint32 c, const lzo_bytep buf, lzo_uint len);
++LZO_EXTERN(const lzo_uint32p)
++ lzo_get_crc32_table(void);
++
++/* misc. */
++LZO_EXTERN(int) _lzo_config_check(void);
++typedef union { lzo_bytep p; lzo_uint u; } __lzo_pu_u;
++typedef union { lzo_bytep p; lzo_uint32 u32; } __lzo_pu32_u;
++typedef union { void *vp; lzo_bytep bp; lzo_uint u; lzo_uint32 u32; unsigned long l; } lzo_align_t;
++
++/* align a char pointer on a boundary that is a multiple of 'size' */
++LZO_EXTERN(unsigned) __lzo_align_gap(const lzo_voidp p, lzo_uint size);
++#define LZO_PTR_ALIGN_UP(p,size) \
++ ((p) + (lzo_uint) __lzo_align_gap((const lzo_voidp)(p),(lzo_uint)(size)))
++
++
++/***********************************************************************
++// deprecated macros - only for backward compatibility with LZO v1.xx
++************************************************************************/
++
++#if defined(LZO_CFG_COMPAT)
++
++#define __LZOCONF_H 1
++
++#if defined(LZO_ARCH_I086)
++# define __LZO_i386 1
++#elif defined(LZO_ARCH_I386)
++# define __LZO_i386 1
++#endif
++
++#if defined(LZO_OS_DOS16)
++# define __LZO_DOS 1
++# define __LZO_DOS16 1
++#elif defined(LZO_OS_DOS32)
++# define __LZO_DOS 1
++#elif defined(LZO_OS_WIN16)
++# define __LZO_WIN 1
++# define __LZO_WIN16 1
++#elif defined(LZO_OS_WIN32)
++# define __LZO_WIN 1
++#endif
++
++#define __LZO_CMODEL /*empty*/
++#define __LZO_DMODEL /*empty*/
++#define __LZO_ENTRY __LZO_CDECL
++#define LZO_EXTERN_CDECL LZO_EXTERN
++#define LZO_ALIGN LZO_PTR_ALIGN_UP
++
++#define lzo_compress_asm_t lzo_compress_t
++#define lzo_decompress_asm_t lzo_decompress_t
++
++#endif /* LZO_CFG_COMPAT */
++
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* already included */
++
++
++/* vim:set ts=4 et: */
+Index: b/grub-core/lib/minilzo/lzodefs.h
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/minilzo/lzodefs.h
+@@ -0,0 +1,1852 @@
++/* lzodefs.h -- architecture, OS and compiler specific defines
++
++ This file is part of the LZO real-time data compression library.
++
++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
++ 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 __LZODEFS_H_INCLUDED
++#define __LZODEFS_H_INCLUDED 1
++
++#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 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 0
++#define LZO_0xffffL 0xfffful
++#define LZO_0xffffffffL 0xfffffffful
++#else
++#define LZO_0xffffL 65535ul
++#define LZO_0xffffffffL 4294967295ul
++#endif
++#if (LZO_0xffffL == LZO_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 == LZO_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 == LZO_0xffffL)
++# define ptrdiff_t long
++# define _PTRDIFF_T_DEFINED 1
++#endif
++#if (UINT_MAX == LZO_0xffffL)
++# undef __LZO_RENAME_A
++# undef __LZO_RENAME_B
++# if defined(__AZTEC_C__) && defined(__DOS__)
++# define __LZO_RENAME_A 1
++# elif defined(_MSC_VER) && defined(MSDOS)
++# if (_MSC_VER < 600)
++# define __LZO_RENAME_A 1
++# elif (_MSC_VER < 700)
++# define __LZO_RENAME_B 1
++# endif
++# elif defined(__TSC__) && defined(__OS2__)
++# define __LZO_RENAME_A 1
++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410)
++# define __LZO_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(__LZO_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(__LZO_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 __LZO_RENAME_A
++# undef __LZO_RENAME_B
++#endif
++#if (UINT_MAX == LZO_0xffffL)
++#if defined(__AZTEC_C__) && defined(__DOS__)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++#elif defined(_MSC_VER) && defined(MSDOS)
++# if (_MSC_VER < 600)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++# endif
++# if (_MSC_VER < 700)
++# define LZO_BROKEN_INTEGRAL_PROMOTION 1
++# define LZO_BROKEN_SIZEOF 1
++# endif
++#elif defined(__PACIFIC__) && defined(DOS)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++#elif defined(__TURBOC__) && defined(__MSDOS__)
++# if (__TURBOC__ < 0x0150)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++# define LZO_BROKEN_INTEGRAL_PROMOTION 1
++# endif
++# if (__TURBOC__ < 0x0200)
++# define LZO_BROKEN_SIZEOF 1
++# endif
++# if (__TURBOC__ < 0x0400) && defined(__cplusplus)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# endif
++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# define LZO_BROKEN_SIZEOF 1
++#endif
++#endif
++#if defined(__WATCOMC__) && (__WATCOMC__ < 900)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++#endif
++#if defined(_CRAY) && defined(_CRAY1)
++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1
++#endif
++#define LZO_PP_STRINGIZE(x) #x
++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x)
++#define LZO_PP_CONCAT2(a,b) a ## b
++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c
++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d
++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b)
++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c)
++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d)
++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e)
++#if 1
++#define LZO_CPP_STRINGIZE(x) #x
++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x)
++#define LZO_CPP_CONCAT2(a,b) a ## b
++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c
++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d
++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b)
++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c)
++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d)
++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e)
++#endif
++#define __LZO_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 LZO_EXTERN_C extern "C"
++#else
++# define LZO_EXTERN_C extern
++#endif
++#if !defined(__LZO_OS_OVERRIDE)
++#if (LZO_OS_FREESTANDING)
++# define LZO_INFO_OS "freestanding"
++#elif (LZO_OS_EMBEDDED)
++# define LZO_INFO_OS "embedded"
++#elif 1 && defined(__IAR_SYSTEMS_ICC__)
++# define LZO_OS_EMBEDDED 1
++# define LZO_INFO_OS "embedded"
++#elif defined(__CYGWIN__) && defined(__GNUC__)
++# define LZO_OS_CYGWIN 1
++# define LZO_INFO_OS "cygwin"
++#elif defined(__EMX__) && defined(__GNUC__)
++# define LZO_OS_EMX 1
++# define LZO_INFO_OS "emx"
++#elif defined(__BEOS__)
++# define LZO_OS_BEOS 1
++# define LZO_INFO_OS "beos"
++#elif defined(__Lynx__)
++# define LZO_OS_LYNXOS 1
++# define LZO_INFO_OS "lynxos"
++#elif defined(__OS400__)
++# define LZO_OS_OS400 1
++# define LZO_INFO_OS "os400"
++#elif defined(__QNX__)
++# define LZO_OS_QNX 1
++# define LZO_INFO_OS "qnx"
++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++#elif defined(__BORLANDC__) && defined(__DPMI16__)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++#elif defined(__ZTC__) && defined(DOS386)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++#elif defined(__OS2__) || defined(__OS2V2__)
++# if (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_OS216 1
++# define LZO_INFO_OS "os216"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_OS2 1
++# define LZO_INFO_OS "os2"
++# else
++# error "check your limits.h header"
++# endif
++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64)
++# define LZO_OS_WIN64 1
++# define LZO_INFO_OS "win64"
++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++#elif defined(__MWERKS__) && defined(__INTEL__)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows)
++# if (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_WIN16 1
++# define LZO_INFO_OS "win16"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_WIN32 1
++# define LZO_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 == LZO_0xffffL)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++# else
++# error "check your limits.h header"
++# endif
++#elif defined(__WATCOMC__)
++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++# elif defined(__NT__) && (__WATCOMC__ < 1100)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++# elif defined(__linux__) || defined(__LINUX__)
++# define LZO_OS_POSIX 1
++# define LZO_INFO_OS "posix"
++# else
++# error "please specify a target using the -bt compiler option"
++# endif
++#elif defined(__palmos__)
++# define LZO_OS_PALMOS 1
++# define LZO_INFO_OS "palmos"
++#elif defined(__TOS__) || defined(__atarist__)
++# define LZO_OS_TOS 1
++# define LZO_INFO_OS "tos"
++#elif defined(macintosh) && !defined(__ppc__)
++# define LZO_OS_MACCLASSIC 1
++# define LZO_INFO_OS "macclassic"
++#elif defined(__VMS)
++# define LZO_OS_VMS 1
++# define LZO_INFO_OS "vms"
++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
++# define LZO_OS_CONSOLE 1
++# define LZO_OS_CONSOLE_PS2 1
++# define LZO_INFO_OS "console"
++# define LZO_INFO_OS_CONSOLE "ps2"
++#elif (defined(__mips__) && defined(__psp__))
++# define LZO_OS_CONSOLE 1
++# define LZO_OS_CONSOLE_PSP 1
++# define LZO_INFO_OS "console"
++# define LZO_INFO_OS_CONSOLE "psp"
++#else
++# define LZO_OS_POSIX 1
++# define LZO_INFO_OS "posix"
++#endif
++#if (LZO_OS_POSIX)
++# if defined(_AIX) || defined(__AIX__) || defined(__aix__)
++# define LZO_OS_POSIX_AIX 1
++# define LZO_INFO_OS_POSIX "aix"
++# elif defined(__FreeBSD__)
++# define LZO_OS_POSIX_FREEBSD 1
++# define LZO_INFO_OS_POSIX "freebsd"
++# elif defined(__hpux__) || defined(__hpux)
++# define LZO_OS_POSIX_HPUX 1
++# define LZO_INFO_OS_POSIX "hpux"
++# elif defined(__INTERIX)
++# define LZO_OS_POSIX_INTERIX 1
++# define LZO_INFO_OS_POSIX "interix"
++# elif defined(__IRIX__) || defined(__irix__)
++# define LZO_OS_POSIX_IRIX 1
++# define LZO_INFO_OS_POSIX "irix"
++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__)
++# define LZO_OS_POSIX_LINUX 1
++# define LZO_INFO_OS_POSIX "linux"
++# elif defined(__APPLE__) || defined(__MACOS__)
++# define LZO_OS_POSIX_MACOSX 1
++# define LZO_INFO_OS_POSIX "macosx"
++# elif defined(__minix__) || defined(__minix)
++# define LZO_OS_POSIX_MINIX 1
++# define LZO_INFO_OS_POSIX "minix"
++# elif defined(__NetBSD__)
++# define LZO_OS_POSIX_NETBSD 1
++# define LZO_INFO_OS_POSIX "netbsd"
++# elif defined(__OpenBSD__)
++# define LZO_OS_POSIX_OPENBSD 1
++# define LZO_INFO_OS_POSIX "openbsd"
++# elif defined(__osf__)
++# define LZO_OS_POSIX_OSF 1
++# define LZO_INFO_OS_POSIX "osf"
++# elif defined(__solaris__) || defined(__sun)
++# if defined(__SVR4) || defined(__svr4__)
++# define LZO_OS_POSIX_SOLARIS 1
++# define LZO_INFO_OS_POSIX "solaris"
++# else
++# define LZO_OS_POSIX_SUNOS 1
++# define LZO_INFO_OS_POSIX "sunos"
++# endif
++# elif defined(__ultrix__) || defined(__ultrix)
++# define LZO_OS_POSIX_ULTRIX 1
++# define LZO_INFO_OS_POSIX "ultrix"
++# elif defined(_UNICOS)
++# define LZO_OS_POSIX_UNICOS 1
++# define LZO_INFO_OS_POSIX "unicos"
++# else
++# define LZO_OS_POSIX_UNKNOWN 1
++# define LZO_INFO_OS_POSIX "unknown"
++# endif
++#endif
++#endif
++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++# if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (UINT_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__)
++# define LZO_CC_CILLY 1
++# define LZO_INFO_CC "Cilly"
++# if defined(__CILLY__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__)
++# define LZO_CC_SDCC 1
++# define LZO_INFO_CC "sdcc"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC)
++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__)
++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__)
++# define LZO_INFO_CC "Pathscale C"
++# define LZO_INFO_CCVER __PATHSCALE__
++#elif defined(__INTEL_COMPILER)
++# define LZO_CC_INTELC 1
++# define LZO_INFO_CC "Intel C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER)
++# if defined(_WIN32) || defined(_WIN64)
++# define LZO_CC_SYNTAX_MSC 1
++# else
++# define LZO_CC_SYNTAX_GNUC 1
++# endif
++#elif defined(__POCC__) && defined(_WIN32)
++# define LZO_CC_PELLESC 1
++# define LZO_INFO_CC "Pelles C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__)
++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__)
++# if defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# else
++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# endif
++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__)
++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__)
++# else
++# define LZO_CC_CLANG_CLANG 0x010000L
++# endif
++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC
++# define LZO_INFO_CC "clang"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__)
++# if defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# else
++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# endif
++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC
++# define LZO_INFO_CC "llvm-gcc"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__GNUC__) && defined(__VERSION__)
++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# elif defined(__GNUC_MINOR__)
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# else
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L)
++# endif
++# define LZO_INFO_CC "gcc"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__ACK__) && defined(_ACK)
++# define LZO_CC_ACK 1
++# define LZO_INFO_CC "Amsterdam Compiler Kit C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__AZTEC_C__)
++# define LZO_CC_AZTECC 1
++# define LZO_INFO_CC "Aztec C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__)
++#elif defined(__CODEGEARC__)
++# define LZO_CC_CODEGEARC 1
++# define LZO_INFO_CC "CodeGear C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__)
++#elif defined(__BORLANDC__)
++# define LZO_CC_BORLANDC 1
++# define LZO_INFO_CC "Borland C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__)
++#elif defined(_CRAYC) && defined(_RELEASE)
++# define LZO_CC_CRAYC 1
++# define LZO_INFO_CC "Cray C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE)
++#elif defined(__DMC__) && defined(__SC__)
++# define LZO_CC_DMC 1
++# define LZO_INFO_CC "Digital Mars C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__)
++#elif defined(__DECC)
++# define LZO_CC_DECC 1
++# define LZO_INFO_CC "DEC C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC)
++#elif defined(__HIGHC__)
++# define LZO_CC_HIGHC 1
++# define LZO_INFO_CC "MetaWare High C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__IAR_SYSTEMS_ICC__)
++# define LZO_CC_IARC 1
++# define LZO_INFO_CC "IAR C"
++# if defined(__VER__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__IBMC__)
++# define LZO_CC_IBMC 1
++# define LZO_INFO_CC "IBM C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__)
++#elif defined(__KEIL__) && defined(__C166__)
++# define LZO_CC_KEILC 1
++# define LZO_INFO_CC "Keil C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__)
++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL)
++# define LZO_CC_LCCWIN32 1
++# define LZO_INFO_CC "lcc-win32"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__LCC__)
++# define LZO_CC_LCC 1
++# define LZO_INFO_CC "lcc"
++# if defined(__LCC_VERSION__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(_MSC_VER)
++# define LZO_CC_MSC 1
++# define LZO_INFO_CC "Microsoft C"
++# if defined(_MSC_FULL_VER)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER)
++# else
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER)
++# endif
++#elif defined(__MWERKS__)
++# define LZO_CC_MWERKS 1
++# define LZO_INFO_CC "Metrowerks C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__)
++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386)
++# define LZO_CC_NDPC 1
++# define LZO_INFO_CC "Microway NDP C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__PACIFIC__)
++# define LZO_CC_PACIFICC 1
++# define LZO_INFO_CC "Pacific C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__)
++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__))
++# define LZO_CC_PGI 1
++# define LZO_INFO_CC "Portland Group PGI C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__PUREC__) && defined(__TOS__)
++# define LZO_CC_PUREC 1
++# define LZO_INFO_CC "Pure C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__)
++#elif defined(__SC__) && defined(__ZTC__)
++# define LZO_CC_SYMANTECC 1
++# define LZO_INFO_CC "Symantec C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__)
++#elif defined(__SUNPRO_C)
++# define LZO_INFO_CC "SunPro C"
++# if ((__SUNPRO_C)+0 > 0)
++# define LZO_CC_SUNPROC __SUNPRO_C
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C)
++# else
++# define LZO_CC_SUNPROC 1
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__SUNPRO_CC)
++# define LZO_INFO_CC "SunPro C"
++# if ((__SUNPRO_CC)+0 > 0)
++# define LZO_CC_SUNPROC __SUNPRO_CC
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC)
++# else
++# define LZO_CC_SUNPROC 1
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__TINYC__)
++# define LZO_CC_TINYC 1
++# define LZO_INFO_CC "Tiny C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__)
++#elif defined(__TSC__)
++# define LZO_CC_TOPSPEEDC 1
++# define LZO_INFO_CC "TopSpeed C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__)
++#elif defined(__WATCOMC__)
++# define LZO_CC_WATCOMC 1
++# define LZO_INFO_CC "Watcom C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__)
++#elif defined(__TURBOC__)
++# define LZO_CC_TURBOC 1
++# define LZO_INFO_CC "Turbo C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__)
++#elif defined(__ZTC__)
++# define LZO_CC_ZORTECHC 1
++# define LZO_INFO_CC "Zortech C"
++# if (__ZTC__ == 0x310)
++# define LZO_INFO_CCVER "0x310"
++# else
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__)
++# endif
++#else
++# define LZO_CC_UNKNOWN 1
++# define LZO_INFO_CC "unknown"
++# define LZO_INFO_CCVER "unknown"
++#endif
++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER)
++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined"
++#endif
++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY)
++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY)
++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E)
++# define LZO_ARCH_CRAY_MPP 1
++# elif defined(_CRAY1)
++# define LZO_ARCH_CRAY_PVP 1
++# endif
++# endif
++#endif
++#if !defined(__LZO_ARCH_OVERRIDE)
++#if (LZO_ARCH_GENERIC)
++# define LZO_INFO_ARCH "generic"
++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++# define LZO_ARCH_I086 1
++# define LZO_ARCH_IA16 1
++# define LZO_INFO_ARCH "i086"
++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA)
++# define LZO_ARCH_ALPHA 1
++# define LZO_INFO_ARCH "alpha"
++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E))
++# define LZO_ARCH_ALPHA 1
++# define LZO_INFO_ARCH "alpha"
++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
++# define LZO_ARCH_AMD64 1
++# define LZO_INFO_ARCH "amd64"
++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB))
++# define LZO_ARCH_ARM 1
++# define LZO_ARCH_ARM_THUMB 1
++# define LZO_INFO_ARCH "arm_thumb"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__)
++# define LZO_ARCH_ARM 1
++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1)
++# define LZO_ARCH_ARM_THUMB 1
++# define LZO_INFO_ARCH "arm_thumb"
++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2)
++# define LZO_INFO_ARCH "arm"
++# else
++# define LZO_INFO_ARCH "arm"
++# endif
++#elif defined(__arm__) || defined(_M_ARM)
++# define LZO_ARCH_ARM 1
++# define LZO_INFO_ARCH "arm"
++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__)
++# define LZO_ARCH_AVR 1
++# define LZO_INFO_ARCH "avr"
++#elif defined(__avr32__) || defined(__AVR32__)
++# define LZO_ARCH_AVR32 1
++# define LZO_INFO_ARCH "avr32"
++#elif defined(__bfin__)
++# define LZO_ARCH_BLACKFIN 1
++# define LZO_INFO_ARCH "blackfin"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__)
++# define LZO_ARCH_C166 1
++# define LZO_INFO_ARCH "c166"
++#elif defined(__cris__)
++# define LZO_ARCH_CRIS 1
++# define LZO_INFO_ARCH "cris"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__)
++# define LZO_ARCH_EZ80 1
++# define LZO_INFO_ARCH "ez80"
++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
++# define LZO_ARCH_H8300 1
++# define LZO_INFO_ARCH "h8300"
++#elif defined(__hppa__) || defined(__hppa)
++# define LZO_ARCH_HPPA 1
++# define LZO_INFO_ARCH "hppa"
++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386)
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif (LZO_CC_ZORTECHC && defined(__I86__))
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386)
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64)
++# define LZO_ARCH_IA64 1
++# define LZO_INFO_ARCH "ia64"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__)
++# define LZO_ARCH_M16C 1
++# define LZO_INFO_ARCH "m16c"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__)
++# define LZO_ARCH_M16C 1
++# define LZO_INFO_ARCH "m16c"
++#elif defined(__m32r__)
++# define LZO_ARCH_M32R 1
++# define LZO_INFO_ARCH "m32r"
++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K)
++# define LZO_ARCH_M68K 1
++# define LZO_INFO_ARCH "m68k"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__)
++# define LZO_ARCH_MCS251 1
++# define LZO_INFO_ARCH "mcs251"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__)
++# define LZO_ARCH_MCS51 1
++# define LZO_INFO_ARCH "mcs51"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__)
++# define LZO_ARCH_MCS51 1
++# define LZO_INFO_ARCH "mcs51"
++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000)
++# define LZO_ARCH_MIPS 1
++# define LZO_INFO_ARCH "mips"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__)
++# define LZO_ARCH_MSP430 1
++# define LZO_INFO_ARCH "msp430"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__)
++# define LZO_ARCH_MSP430 1
++# define LZO_INFO_ARCH "msp430"
++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR)
++# define LZO_ARCH_POWERPC 1
++# define LZO_INFO_ARCH "powerpc"
++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x)
++# define LZO_ARCH_S390 1
++# define LZO_INFO_ARCH "s390"
++#elif defined(__sh__) || defined(_M_SH)
++# define LZO_ARCH_SH 1
++# define LZO_INFO_ARCH "sh"
++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8)
++# define LZO_ARCH_SPARC 1
++# define LZO_INFO_ARCH "sparc"
++#elif defined(__SPU__)
++# define LZO_ARCH_SPU 1
++# define LZO_INFO_ARCH "spu"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80)
++# define LZO_ARCH_Z80 1
++# define LZO_INFO_ARCH "z80"
++#elif (LZO_ARCH_CRAY_PVP)
++# if defined(_CRAYSV1)
++# define LZO_ARCH_CRAY_SV1 1
++# define LZO_INFO_ARCH "cray_sv1"
++# elif (_ADDR64)
++# define LZO_ARCH_CRAY_T90 1
++# define LZO_INFO_ARCH "cray_t90"
++# elif (_ADDR32)
++# define LZO_ARCH_CRAY_YMP 1
++# define LZO_INFO_ARCH "cray_ymp"
++# else
++# define LZO_ARCH_CRAY_XMP 1
++# define LZO_INFO_ARCH "cray_xmp"
++# endif
++#else
++# define LZO_ARCH_UNKNOWN 1
++# define LZO_INFO_ARCH "unknown"
++#endif
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2)
++# error "FIXME - missing define for CPU architecture"
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32)
++# error "FIXME - missing WIN32 define for CPU architecture"
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64)
++# error "FIXME - missing WIN64 define for CPU architecture"
++#endif
++#if (LZO_OS_OS216 || LZO_OS_WIN16)
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && defined(BLX286))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#endif
++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM)
++# error "this should not happen"
++#endif
++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086)
++# error "this should not happen"
++#endif
++#if (LZO_ARCH_I086)
++# if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if (LZO_ARCH_I386)
++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__)
++# error "this should not happen"
++# endif
++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if !defined(__LZO_MM_OVERRIDE)
++#if (LZO_ARCH_I086)
++#if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++#endif
++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM)
++# define LZO_MM_TINY 1
++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM)
++# define LZO_MM_HUGE 1
++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL)
++# define LZO_MM_SMALL 1
++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM)
++# define LZO_MM_MEDIUM 1
++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM)
++# define LZO_MM_COMPACT 1
++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL)
++# define LZO_MM_LARGE 1
++#elif (LZO_CC_AZTECC)
++# if defined(_LARGE_CODE) && defined(_LARGE_DATA)
++# define LZO_MM_LARGE 1
++# elif defined(_LARGE_CODE)
++# define LZO_MM_MEDIUM 1
++# elif defined(_LARGE_DATA)
++# define LZO_MM_COMPACT 1
++# else
++# define LZO_MM_SMALL 1
++# endif
++#elif (LZO_CC_ZORTECHC && defined(__VCM__))
++# define LZO_MM_LARGE 1
++#else
++# error "unknown memory model"
++#endif
++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++#define LZO_HAVE_MM_HUGE_PTR 1
++#define LZO_HAVE_MM_HUGE_ARRAY 1
++#if (LZO_MM_TINY)
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#endif
++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC)
++# undef LZO_HAVE_MM_HUGE_PTR
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC)
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#elif (LZO_CC_MSC && defined(_QC))
++# undef LZO_HAVE_MM_HUGE_ARRAY
++# if (_MSC_VER < 600)
++# undef LZO_HAVE_MM_HUGE_PTR
++# endif
++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295))
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#endif
++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR)
++# if (LZO_OS_DOS16)
++# error "this should not happen"
++# elif (LZO_CC_ZORTECHC)
++# else
++# error "this should not happen"
++# endif
++#endif
++#ifdef __cplusplus
++extern "C" {
++#endif
++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200))
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC)
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295))
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16)
++# define LZO_MM_AHSHIFT 12
++#elif (LZO_CC_WATCOMC)
++ extern unsigned char _HShift;
++# define LZO_MM_AHSHIFT ((unsigned) _HShift)
++#else
++# error "FIXME - implement LZO_MM_AHSHIFT"
++#endif
++#ifdef __cplusplus
++}
++#endif
++#endif
++#elif (LZO_ARCH_C166)
++#if !defined(__MODEL__)
++# error "FIXME - C166 __MODEL__"
++#elif ((__MODEL__) == 0)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 1)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - C166 __MODEL__"
++#endif
++#elif (LZO_ARCH_MCS251)
++#if !defined(__MODEL__)
++# error "FIXME - MCS251 __MODEL__"
++#elif ((__MODEL__) == 0)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - MCS251 __MODEL__"
++#endif
++#elif (LZO_ARCH_MCS51)
++#if !defined(__MODEL__)
++# error "FIXME - MCS51 __MODEL__"
++#elif ((__MODEL__) == 1)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - MCS51 __MODEL__"
++#endif
++#elif (LZO_ARCH_CRAY_PVP)
++# define LZO_MM_PVP 1
++#else
++# define LZO_MM_FLAT 1
++#endif
++#if (LZO_MM_COMPACT)
++# define LZO_INFO_MM "compact"
++#elif (LZO_MM_FLAT)
++# define LZO_INFO_MM "flat"
++#elif (LZO_MM_HUGE)
++# define LZO_INFO_MM "huge"
++#elif (LZO_MM_LARGE)
++# define LZO_INFO_MM "large"
++#elif (LZO_MM_MEDIUM)
++# define LZO_INFO_MM "medium"
++#elif (LZO_MM_PVP)
++# define LZO_INFO_MM "pvp"
++#elif (LZO_MM_SMALL)
++# define LZO_INFO_MM "small"
++#elif (LZO_MM_TINY)
++# define LZO_INFO_MM "tiny"
++#else
++# error "unknown memory model"
++#endif
++#endif
++#if defined(SIZEOF_SHORT)
++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT)
++#endif
++#if defined(SIZEOF_INT)
++# define LZO_SIZEOF_INT (SIZEOF_INT)
++#endif
++#if defined(SIZEOF_LONG)
++# define LZO_SIZEOF_LONG (SIZEOF_LONG)
++#endif
++#if defined(SIZEOF_LONG_LONG)
++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG)
++#endif
++#if defined(SIZEOF___INT16)
++# define LZO_SIZEOF___INT16 (SIZEOF___INT16)
++#endif
++#if defined(SIZEOF___INT32)
++# define LZO_SIZEOF___INT32 (SIZEOF___INT32)
++#endif
++#if defined(SIZEOF___INT64)
++# define LZO_SIZEOF___INT64 (SIZEOF___INT64)
++#endif
++#if defined(SIZEOF_VOID_P)
++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P)
++#endif
++#if defined(SIZEOF_SIZE_T)
++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T)
++#endif
++#if defined(SIZEOF_PTRDIFF_T)
++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T)
++#endif
++#define __LZO_LSR(x,b) (((x)+0ul) >> (b))
++#if !defined(LZO_SIZEOF_SHORT)
++# if (LZO_ARCH_CRAY_PVP)
++# define LZO_SIZEOF_SHORT 8
++# elif (USHRT_MAX == LZO_0xffffL)
++# define LZO_SIZEOF_SHORT 2
++# elif (__LZO_LSR(USHRT_MAX,7) == 1)
++# define LZO_SIZEOF_SHORT 1
++# elif (__LZO_LSR(USHRT_MAX,15) == 1)
++# define LZO_SIZEOF_SHORT 2
++# elif (__LZO_LSR(USHRT_MAX,31) == 1)
++# define LZO_SIZEOF_SHORT 4
++# elif (__LZO_LSR(USHRT_MAX,63) == 1)
++# define LZO_SIZEOF_SHORT 8
++# elif (__LZO_LSR(USHRT_MAX,127) == 1)
++# define LZO_SIZEOF_SHORT 16
++# else
++# error "LZO_SIZEOF_SHORT"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_INT)
++# if (LZO_ARCH_CRAY_PVP)
++# define LZO_SIZEOF_INT 8
++# elif (UINT_MAX == LZO_0xffffL)
++# define LZO_SIZEOF_INT 2
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_SIZEOF_INT 4
++# elif (__LZO_LSR(UINT_MAX,7) == 1)
++# define LZO_SIZEOF_INT 1
++# elif (__LZO_LSR(UINT_MAX,15) == 1)
++# define LZO_SIZEOF_INT 2
++# elif (__LZO_LSR(UINT_MAX,31) == 1)
++# define LZO_SIZEOF_INT 4
++# elif (__LZO_LSR(UINT_MAX,63) == 1)
++# define LZO_SIZEOF_INT 8
++# elif (__LZO_LSR(UINT_MAX,127) == 1)
++# define LZO_SIZEOF_INT 16
++# else
++# error "LZO_SIZEOF_INT"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_LONG)
++# if (ULONG_MAX == LZO_0xffffffffL)
++# define LZO_SIZEOF_LONG 4
++# elif (__LZO_LSR(ULONG_MAX,7) == 1)
++# define LZO_SIZEOF_LONG 1
++# elif (__LZO_LSR(ULONG_MAX,15) == 1)
++# define LZO_SIZEOF_LONG 2
++# elif (__LZO_LSR(ULONG_MAX,31) == 1)
++# define LZO_SIZEOF_LONG 4
++# elif (__LZO_LSR(ULONG_MAX,63) == 1)
++# define LZO_SIZEOF_LONG 8
++# elif (__LZO_LSR(ULONG_MAX,127) == 1)
++# define LZO_SIZEOF_LONG 16
++# else
++# error "LZO_SIZEOF_LONG"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64)
++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8)
++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__)
++# if (LZO_CC_GNUC >= 0x030300ul)
++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0)
++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG
++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1)
++# define LZO_SIZEOF_LONG_LONG 4
++# endif
++# endif
++# endif
++#endif
++#endif
++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64)
++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8)
++#if (LZO_ARCH_I086 && LZO_CC_DMC)
++#elif (LZO_CC_CILLY) && defined(__GNUC__)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_OS_WIN64 || defined(_WIN64))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_DMC))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700)))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__)))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC))
++# define LZO_SIZEOF___INT64 8
++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520)))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100)))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2)
++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
++# define LZO_SIZEOF_LONG_LONG 8
++#endif
++#endif
++#endif
++#if defined(__cplusplus) && (LZO_CC_GNUC)
++# if (LZO_CC_GNUC < 0x020800ul)
++# undef LZO_SIZEOF_LONG_LONG
++# endif
++#endif
++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG)
++# undef LZO_SIZEOF_LONG_LONG
++#endif
++#if !defined(LZO_SIZEOF_VOID_P)
++#if (LZO_ARCH_I086)
++# define __LZO_WORDSIZE 2
++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM)
++# define LZO_SIZEOF_VOID_P 2
++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE)
++# define LZO_SIZEOF_VOID_P 4
++# else
++# error "LZO_MM"
++# endif
++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80)
++# define __LZO_WORDSIZE 1
++# define LZO_SIZEOF_VOID_P 2
++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430)
++# define LZO_SIZEOF_VOID_P 2
++#elif (LZO_ARCH_H8300)
++# if defined(__NORMAL_MODE__)
++# define __LZO_WORDSIZE 4
++# define LZO_SIZEOF_VOID_P 2
++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
++# define __LZO_WORDSIZE 4
++# define LZO_SIZEOF_VOID_P 4
++# else
++# define __LZO_WORDSIZE 2
++# define LZO_SIZEOF_VOID_P 2
++# endif
++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4)
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT
++# endif
++#elif (LZO_ARCH_M16C)
++# define __LZO_WORDSIZE 2
++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__)
++# define LZO_SIZEOF_VOID_P 4
++# else
++# define LZO_SIZEOF_VOID_P 2
++# endif
++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
++# define __LZO_WORDSIZE 8
++# define LZO_SIZEOF_VOID_P 4
++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64)
++# define __LZO_WORDSIZE 8
++# define LZO_SIZEOF_VOID_P 8
++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (LZO_OS_OS400 || defined(__OS400__))
++# define __LZO_WORDSIZE LZO_SIZEOF_LONG
++# define LZO_SIZEOF_VOID_P 16
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
++# define LZO_SIZEOF_VOID_P 8
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (LZO_ARCH_SPU)
++# if 0
++# define __LZO_WORDSIZE 16
++# endif
++# define LZO_SIZEOF_VOID_P 4
++#else
++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG
++#endif
++#endif
++#if !defined(LZO_WORDSIZE)
++# if defined(__LZO_WORDSIZE)
++# define LZO_WORDSIZE __LZO_WORDSIZE
++# else
++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P
++# endif
++#endif
++#if !defined(LZO_SIZEOF_SIZE_T)
++#if (LZO_ARCH_I086 || LZO_ARCH_M16C)
++# define LZO_SIZEOF_SIZE_T 2
++#else
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P
++#endif
++#endif
++#if !defined(LZO_SIZEOF_PTRDIFF_T)
++#if (LZO_ARCH_I086)
++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE)
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P
++# elif (LZO_MM_COMPACT || LZO_MM_LARGE)
++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC)
++# define LZO_SIZEOF_PTRDIFF_T 4
++# else
++# define LZO_SIZEOF_PTRDIFF_T 2
++# endif
++# else
++# error "LZO_MM"
++# endif
++#else
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T
++#endif
++#endif
++#if (LZO_ABI_NEUTRAL_ENDIAN)
++# undef LZO_ABI_BIG_ENDIAN
++# undef LZO_ABI_LITTLE_ENDIAN
++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN)
++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__)
++# if (__LITTLE_ENDIAN__ == 1)
++# define LZO_ABI_LITTLE_ENDIAN 1
++# else
++# define LZO_ABI_BIG_ENDIAN 1
++# endif
++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#endif
++#endif
++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN)
++# error "this should not happen"
++#endif
++#if (LZO_ABI_BIG_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "be"
++#elif (LZO_ABI_LITTLE_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "le"
++#elif (LZO_ABI_NEUTRAL_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "neutral"
++#endif
++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
++# define LZO_ABI_I8LP16 1
++# define LZO_INFO_ABI_PM "i8lp16"
++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
++# define LZO_ABI_ILP16 1
++# define LZO_INFO_ABI_PM "ilp16"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4)
++# define LZO_ABI_ILP32 1
++# define LZO_INFO_ABI_PM "ilp32"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8)
++# define LZO_ABI_LLP64 1
++# define LZO_INFO_ABI_PM "llp64"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
++# define LZO_ABI_LP64 1
++# define LZO_INFO_ABI_PM "lp64"
++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
++# define LZO_ABI_ILP64 1
++# define LZO_INFO_ABI_PM "ilp64"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4)
++# define LZO_ABI_IP32L64 1
++# define LZO_INFO_ABI_PM "ip32l64"
++#endif
++#if !defined(__LZO_LIBC_OVERRIDE)
++#if (LZO_LIBC_NAKED)
++# define LZO_INFO_LIBC "naked"
++#elif (LZO_LIBC_FREESTANDING)
++# define LZO_INFO_LIBC "freestanding"
++#elif (LZO_LIBC_MOSTLY_FREESTANDING)
++# define LZO_INFO_LIBC "mfreestanding"
++#elif (LZO_LIBC_ISOC90)
++# define LZO_INFO_LIBC "isoc90"
++#elif (LZO_LIBC_ISOC99)
++# define LZO_INFO_LIBC "isoc99"
++#elif defined(__dietlibc__)
++# define LZO_LIBC_DIETLIBC 1
++# define LZO_INFO_LIBC "dietlibc"
++#elif defined(_NEWLIB_VERSION)
++# define LZO_LIBC_NEWLIB 1
++# define LZO_INFO_LIBC "newlib"
++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__)
++# if defined(__UCLIBC_SUBLEVEL__)
++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__)
++# else
++# define LZO_LIBC_UCLIBC 0x00090bL
++# endif
++# define LZO_INFO_LIBC "uclibc"
++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__)
++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100)
++# define LZO_INFO_LIBC "glibc"
++#elif (LZO_CC_MWERKS) && defined(__MSL__)
++# define LZO_LIBC_MSL __MSL__
++# define LZO_INFO_LIBC "msl"
++#elif 1 && defined(__IAR_SYSTEMS_ICC__)
++# define LZO_LIBC_ISOC90 1
++# define LZO_INFO_LIBC "isoc90"
++#else
++# define LZO_LIBC_DEFAULT 1
++# define LZO_INFO_LIBC "default"
++#endif
++#endif
++#if !defined(__lzo_gnuc_extension__)
++#if (LZO_CC_GNUC >= 0x020800ul)
++# define __lzo_gnuc_extension__ __extension__
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_gnuc_extension__ __extension__
++#else
++# define __lzo_gnuc_extension__ /*empty*/
++#endif
++#endif
++#if !defined(__lzo_ua_volatile)
++# define __lzo_ua_volatile volatile
++#endif
++#if !defined(__lzo_alignof)
++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI)
++# define __lzo_alignof(e) __alignof__(e)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700))
++# define __lzo_alignof(e) __alignof__(e)
++#elif (LZO_CC_MSC && (_MSC_VER >= 1300))
++# define __lzo_alignof(e) __alignof(e)
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_alignof(e) __alignof__(e)
++#endif
++#endif
++#if defined(__lzo_alignof)
++# define __lzo_HAVE_alignof 1
++#endif
++#if !defined(__lzo_constructor)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_constructor __attribute__((__constructor__,__used__))
++#elif (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_constructor __attribute__((__constructor__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_constructor __attribute__((__constructor__))
++#endif
++#endif
++#if defined(__lzo_constructor)
++# define __lzo_HAVE_constructor 1
++#endif
++#if !defined(__lzo_destructor)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_destructor __attribute__((__destructor__,__used__))
++#elif (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_destructor __attribute__((__destructor__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_destructor __attribute__((__destructor__))
++#endif
++#endif
++#if defined(__lzo_destructor)
++# define __lzo_HAVE_destructor 1
++#endif
++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor)
++# error "this should not happen"
++#endif
++#if !defined(__lzo_inline)
++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295))
++#elif defined(__cplusplus)
++# define __lzo_inline inline
++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550))
++# define __lzo_inline __inline
++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI)
++# define __lzo_inline __inline__
++#elif (LZO_CC_DMC)
++# define __lzo_inline __inline
++#elif (LZO_CC_INTELC)
++# define __lzo_inline __inline
++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405))
++# define __lzo_inline __inline
++#elif (LZO_CC_MSC && (_MSC_VER >= 900))
++# define __lzo_inline __inline
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_inline __inline__
++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
++# define __lzo_inline inline
++#endif
++#endif
++#if defined(__lzo_inline)
++# define __lzo_HAVE_inline 1
++#else
++# define __lzo_inline /*empty*/
++#endif
++#if !defined(__lzo_forceinline)
++#if (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC)
++# define __lzo_forceinline __forceinline
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200))
++# define __lzo_forceinline __forceinline
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#endif
++#endif
++#if defined(__lzo_forceinline)
++# define __lzo_HAVE_forceinline 1
++#else
++# define __lzo_forceinline /*empty*/
++#endif
++#if !defined(__lzo_noinline)
++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul)
++# define __lzo_noinline __attribute__((__noinline__,__used__))
++#elif (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC)
++# define __lzo_noinline __declspec(noinline)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1300))
++# define __lzo_noinline __declspec(noinline)
++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64))
++# if defined(__cplusplus)
++# else
++# define __lzo_noinline __declspec(noinline)
++# endif
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_noinline __attribute__((__noinline__))
++#endif
++#endif
++#if defined(__lzo_noinline)
++# define __lzo_HAVE_noinline 1
++#else
++# define __lzo_noinline /*empty*/
++#endif
++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline)
++# error "this should not happen"
++#endif
++#if !defined(__lzo_noreturn)
++#if (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC)
++# define __lzo_noreturn __declspec(noreturn)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200))
++# define __lzo_noreturn __declspec(noreturn)
++#endif
++#endif
++#if defined(__lzo_noreturn)
++# define __lzo_HAVE_noreturn 1
++#else
++# define __lzo_noreturn /*empty*/
++#endif
++#if !defined(__lzo_nothrow)
++#if (LZO_CC_GNUC >= 0x030300ul)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus)
++# define __lzo_nothrow __declspec(nothrow)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus)
++# define __lzo_nothrow __declspec(nothrow)
++#endif
++#endif
++#if defined(__lzo_nothrow)
++# define __lzo_HAVE_nothrow 1
++#else
++# define __lzo_nothrow /*empty*/
++#endif
++#if !defined(__lzo_restrict)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_CLANG || LZO_CC_LLVM)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_MSC && (_MSC_VER >= 1400))
++# define __lzo_restrict __restrict
++#endif
++#endif
++#if defined(__lzo_restrict)
++# define __lzo_HAVE_restrict 1
++#else
++# define __lzo_restrict /*empty*/
++#endif
++#if !defined(__lzo_likely) && !defined(__lzo_unlikely)
++#if (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800))
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#endif
++#endif
++#if defined(__lzo_likely)
++# define __lzo_HAVE_likely 1
++#else
++# define __lzo_likely(e) (e)
++#endif
++#if defined(__lzo_unlikely)
++# define __lzo_HAVE_unlikely 1
++#else
++# define __lzo_unlikely(e) (e)
++#endif
++#if !defined(LZO_UNUSED)
++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
++# define LZO_UNUSED(var) ((void) &var)
++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC)
++# define LZO_UNUSED(var) if (&var) ; else
++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_UNUSED(var) ((void) var)
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_UNUSED(var) if (&var) ; else
++# elif (LZO_CC_KEILC)
++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];}
++# elif (LZO_CC_PACIFICC)
++# define LZO_UNUSED(var) ((void) sizeof(var))
++# elif (LZO_CC_WATCOMC) && defined(__cplusplus)
++# define LZO_UNUSED(var) ((void) var)
++# else
++# define LZO_UNUSED(var) ((void) &var)
++# endif
++#endif
++#if !defined(LZO_UNUSED_FUNC)
++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
++# define LZO_UNUSED_FUNC(func) ((void) func)
++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC)
++# define LZO_UNUSED_FUNC(func) if (func) ; else
++# elif (LZO_CC_CLANG || LZO_CC_LLVM)
++# define LZO_UNUSED_FUNC(func) ((void) &func)
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_UNUSED_FUNC(func) if (func) ; else
++# elif (LZO_CC_MSC)
++# define LZO_UNUSED_FUNC(func) ((void) &func)
++# elif (LZO_CC_KEILC || LZO_CC_PELLESC)
++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];}
++# else
++# define LZO_UNUSED_FUNC(func) ((void) func)
++# endif
++#endif
++#if !defined(LZO_UNUSED_LABEL)
++# if (LZO_CC_WATCOMC) && defined(__cplusplus)
++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l
++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC)
++# define LZO_UNUSED_LABEL(l) if (0) goto l
++# else
++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l
++# endif
++#endif
++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR)
++# if 0
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var
++# elif 0 && (LZO_CC_GNUC)
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var
++# else
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init
++# endif
++#endif
++#if !defined(LZO_UNCONST_CAST)
++# if 0 && defined(__cplusplus)
++# define LZO_UNCONST_CAST(t,e) (const_cast<t> (e))
++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e))))))
++# else
++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e)))))
++# endif
++#endif
++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER)
++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC)
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)];
++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC)
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)];
++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295))
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)];
++# else
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)];
++# endif
++#endif
++#if !defined(LZO_COMPILE_TIME_ASSERT)
++# if (LZO_CC_AZTECC)
++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];}
++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295))
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# else
++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];}
++# endif
++#endif
++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC)
++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++# define __lzo_cdecl __cdecl
++# define __lzo_cdecl_atexit /*empty*/
++# define __lzo_cdecl_main __cdecl
++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC))
++# define __lzo_cdecl_qsort __pascal
++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC))
++# define __lzo_cdecl_qsort _stdcall
++# else
++# define __lzo_cdecl_qsort __cdecl
++# endif
++# elif (LZO_CC_WATCOMC)
++# define __lzo_cdecl __cdecl
++# else
++# define __lzo_cdecl __cdecl
++# define __lzo_cdecl_atexit __cdecl
++# define __lzo_cdecl_main __cdecl
++# define __lzo_cdecl_qsort __cdecl
++# endif
++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC)
++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC))
++# define __lzo_cdecl_sighandler __pascal
++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC))
++# define __lzo_cdecl_sighandler _stdcall
++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE)
++# define __lzo_cdecl_sighandler __clrcall
++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700))
++# if defined(_DLL)
++# define __lzo_cdecl_sighandler _far _cdecl _loadds
++# elif defined(_MT)
++# define __lzo_cdecl_sighandler _far _cdecl
++# else
++# define __lzo_cdecl_sighandler _cdecl
++# endif
++# else
++# define __lzo_cdecl_sighandler __cdecl
++# endif
++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC)
++# define __lzo_cdecl __cdecl
++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC))
++# define __lzo_cdecl cdecl
++#endif
++#if !defined(__lzo_cdecl)
++# define __lzo_cdecl /*empty*/
++#endif
++#if !defined(__lzo_cdecl_atexit)
++# define __lzo_cdecl_atexit /*empty*/
++#endif
++#if !defined(__lzo_cdecl_main)
++# define __lzo_cdecl_main /*empty*/
++#endif
++#if !defined(__lzo_cdecl_qsort)
++# define __lzo_cdecl_qsort /*empty*/
++#endif
++#if !defined(__lzo_cdecl_sighandler)
++# define __lzo_cdecl_sighandler /*empty*/
++#endif
++#if !defined(__lzo_cdecl_va)
++# define __lzo_cdecl_va __lzo_cdecl
++#endif
++#if !(LZO_CFG_NO_WINDOWS_H)
++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000))
++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__)
++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul)))
++# else
++# define LZO_HAVE_WINDOWS_H 1
++# endif
++#endif
++#endif
++#if (LZO_ARCH_ALPHA)
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_AVOID_SHORT 1
++# define LZO_OPT_AVOID_USHORT 1
++#elif (LZO_ARCH_AMD64)
++# define LZO_OPT_AVOID_INT_INDEX 1
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# define LZO_OPT_UNALIGNED64 1
++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB)
++#elif (LZO_ARCH_ARM)
++# define LZO_OPT_AVOID_SHORT 1
++# define LZO_OPT_AVOID_USHORT 1
++#elif (LZO_ARCH_CRIS)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++#elif (LZO_ARCH_I386)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++#elif (LZO_ARCH_IA64)
++# define LZO_OPT_AVOID_INT_INDEX 1
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_PREFER_POSTINC 1
++#elif (LZO_ARCH_M68K)
++# define LZO_OPT_PREFER_POSTINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++# if defined(__mc68020__) && !defined(__mcoldfire__)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# endif
++#elif (LZO_ARCH_MIPS)
++# define LZO_OPT_AVOID_UINT_INDEX 1
++#elif (LZO_ARCH_POWERPC)
++# define LZO_OPT_PREFER_PREINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++# if (LZO_ABI_BIG_ENDIAN)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# endif
++#elif (LZO_ARCH_S390)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# if (LZO_SIZEOF_SIZE_T == 8)
++# define LZO_OPT_UNALIGNED64 1
++# endif
++#elif (LZO_ARCH_SH)
++# define LZO_OPT_PREFER_POSTINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++#endif
++#ifndef LZO_CFG_NO_INLINE_ASM
++#if (LZO_CC_LLVM)
++# define LZO_CFG_NO_INLINE_ASM 1
++#endif
++#endif
++#ifndef LZO_CFG_NO_UNALIGNED
++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC)
++# define LZO_CFG_NO_UNALIGNED 1
++#endif
++#endif
++#if (LZO_CFG_NO_UNALIGNED)
++# undef LZO_OPT_UNALIGNED16
++# undef LZO_OPT_UNALIGNED32
++# undef LZO_OPT_UNALIGNED64
++#endif
++#if (LZO_CFG_NO_INLINE_ASM)
++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC))
++# define LZO_ASM_SYNTAX_MSC 1
++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC))
++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul))
++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE))
++# define LZO_ASM_SYNTAX_GNUC 1
++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE))
++# define LZO_ASM_SYNTAX_GNUC 1
++#endif
++#if (LZO_ASM_SYNTAX_GNUC)
++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul))
++# define __LZO_ASM_CLOBBER "ax"
++#elif (LZO_CC_INTELC)
++# define __LZO_ASM_CLOBBER "memory"
++#else
++# define __LZO_ASM_CLOBBER "cc", "memory"
++#endif
++#endif
++#if defined(__LZO_INFOSTR_MM)
++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM))
++# define __LZO_INFOSTR_MM ""
++#elif defined(LZO_INFO_MM)
++# define __LZO_INFOSTR_MM "." LZO_INFO_MM
++#else
++# define __LZO_INFOSTR_MM ""
++#endif
++#if defined(__LZO_INFOSTR_PM)
++#elif defined(LZO_INFO_ABI_PM)
++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM
++#else
++# define __LZO_INFOSTR_PM ""
++#endif
++#if defined(__LZO_INFOSTR_ENDIAN)
++#elif defined(LZO_INFO_ABI_ENDIAN)
++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN
++#else
++# define __LZO_INFOSTR_ENDIAN ""
++#endif
++#if defined(__LZO_INFOSTR_OSNAME)
++#elif defined(LZO_INFO_OS_CONSOLE)
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE
++#elif defined(LZO_INFO_OS_POSIX)
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX
++#else
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS
++#endif
++#if defined(__LZO_INFOSTR_LIBC)
++#elif defined(LZO_INFO_LIBC)
++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC
++#else
++# define __LZO_INFOSTR_LIBC ""
++#endif
++#if defined(__LZO_INFOSTR_CCVER)
++#elif defined(LZO_INFO_CCVER)
++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER
++#else
++# define __LZO_INFOSTR_CCVER ""
++#endif
++#define LZO_INFO_STRING \
++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \
++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER
++
++#endif /* already included */
++
++/* vim:set ts=4 et: */
+Index: b/grub-core/lib/minilzo/minilzo.c
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/minilzo/minilzo.c
+@@ -0,0 +1,4562 @@
++/* minilzo.c -- mini subset of the LZO real-time data compression library
++
++ This file is part of the LZO real-time data compression library.
++
++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
++ 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/
++ */
++
++/*
++ * NOTE:
++ * the full LZO package can be found at
++ * http://www.oberhumer.com/opensource/lzo/
++ */
++
++#define __LZO_IN_MINILZO 1
++
++#if defined(LZO_CFG_FREESTANDING)
++# undef MINILZO_HAVE_CONFIG_H
++# define LZO_LIBC_FREESTANDING 1
++# define LZO_OS_FREESTANDING 1
++#endif
++
++#ifdef MINILZO_HAVE_CONFIG_H
++# include <config.h>
++#endif
++#include <limits.h>
++#include <stddef.h>
++#if defined(MINILZO_CFG_USE_INTERNAL_LZODEFS)
++
++#ifndef __LZODEFS_H_INCLUDED
++#define __LZODEFS_H_INCLUDED 1
++
++#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 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 0
++#define LZO_0xffffL 0xfffful
++#define LZO_0xffffffffL 0xfffffffful
++#else
++#define LZO_0xffffL 65535ul
++#define LZO_0xffffffffL 4294967295ul
++#endif
++#if (LZO_0xffffL == LZO_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 == LZO_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 == LZO_0xffffL)
++# define ptrdiff_t long
++# define _PTRDIFF_T_DEFINED 1
++#endif
++#if (UINT_MAX == LZO_0xffffL)
++# undef __LZO_RENAME_A
++# undef __LZO_RENAME_B
++# if defined(__AZTEC_C__) && defined(__DOS__)
++# define __LZO_RENAME_A 1
++# elif defined(_MSC_VER) && defined(MSDOS)
++# if (_MSC_VER < 600)
++# define __LZO_RENAME_A 1
++# elif (_MSC_VER < 700)
++# define __LZO_RENAME_B 1
++# endif
++# elif defined(__TSC__) && defined(__OS2__)
++# define __LZO_RENAME_A 1
++# elif defined(__MSDOS__) && defined(__TURBOC__) && (__TURBOC__ < 0x0410)
++# define __LZO_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(__LZO_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(__LZO_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 __LZO_RENAME_A
++# undef __LZO_RENAME_B
++#endif
++#if (UINT_MAX == LZO_0xffffL)
++#if defined(__AZTEC_C__) && defined(__DOS__)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++#elif defined(_MSC_VER) && defined(MSDOS)
++# if (_MSC_VER < 600)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++# endif
++# if (_MSC_VER < 700)
++# define LZO_BROKEN_INTEGRAL_PROMOTION 1
++# define LZO_BROKEN_SIZEOF 1
++# endif
++#elif defined(__PACIFIC__) && defined(DOS)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++#elif defined(__TURBOC__) && defined(__MSDOS__)
++# if (__TURBOC__ < 0x0150)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++# define LZO_BROKEN_INTEGRAL_PROMOTION 1
++# endif
++# if (__TURBOC__ < 0x0200)
++# define LZO_BROKEN_SIZEOF 1
++# endif
++# if (__TURBOC__ < 0x0400) && defined(__cplusplus)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# endif
++#elif (defined(__PUREC__) || defined(__TURBOC__)) && defined(__TOS__)
++# define LZO_BROKEN_CDECL_ALT_SYNTAX 1
++# define LZO_BROKEN_SIZEOF 1
++#endif
++#endif
++#if defined(__WATCOMC__) && (__WATCOMC__ < 900)
++# define LZO_BROKEN_INTEGRAL_CONSTANTS 1
++#endif
++#if defined(_CRAY) && defined(_CRAY1)
++# define LZO_BROKEN_SIGNED_RIGHT_SHIFT 1
++#endif
++#define LZO_PP_STRINGIZE(x) #x
++#define LZO_PP_MACRO_EXPAND(x) LZO_PP_STRINGIZE(x)
++#define LZO_PP_CONCAT2(a,b) a ## b
++#define LZO_PP_CONCAT3(a,b,c) a ## b ## c
++#define LZO_PP_CONCAT4(a,b,c,d) a ## b ## c ## d
++#define LZO_PP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
++#define LZO_PP_ECONCAT2(a,b) LZO_PP_CONCAT2(a,b)
++#define LZO_PP_ECONCAT3(a,b,c) LZO_PP_CONCAT3(a,b,c)
++#define LZO_PP_ECONCAT4(a,b,c,d) LZO_PP_CONCAT4(a,b,c,d)
++#define LZO_PP_ECONCAT5(a,b,c,d,e) LZO_PP_CONCAT5(a,b,c,d,e)
++#if 1
++#define LZO_CPP_STRINGIZE(x) #x
++#define LZO_CPP_MACRO_EXPAND(x) LZO_CPP_STRINGIZE(x)
++#define LZO_CPP_CONCAT2(a,b) a ## b
++#define LZO_CPP_CONCAT3(a,b,c) a ## b ## c
++#define LZO_CPP_CONCAT4(a,b,c,d) a ## b ## c ## d
++#define LZO_CPP_CONCAT5(a,b,c,d,e) a ## b ## c ## d ## e
++#define LZO_CPP_ECONCAT2(a,b) LZO_CPP_CONCAT2(a,b)
++#define LZO_CPP_ECONCAT3(a,b,c) LZO_CPP_CONCAT3(a,b,c)
++#define LZO_CPP_ECONCAT4(a,b,c,d) LZO_CPP_CONCAT4(a,b,c,d)
++#define LZO_CPP_ECONCAT5(a,b,c,d,e) LZO_CPP_CONCAT5(a,b,c,d,e)
++#endif
++#define __LZO_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 LZO_EXTERN_C extern "C"
++#else
++# define LZO_EXTERN_C extern
++#endif
++#if !defined(__LZO_OS_OVERRIDE)
++#if (LZO_OS_FREESTANDING)
++# define LZO_INFO_OS "freestanding"
++#elif (LZO_OS_EMBEDDED)
++# define LZO_INFO_OS "embedded"
++#elif 1 && defined(__IAR_SYSTEMS_ICC__)
++# define LZO_OS_EMBEDDED 1
++# define LZO_INFO_OS "embedded"
++#elif defined(__CYGWIN__) && defined(__GNUC__)
++# define LZO_OS_CYGWIN 1
++# define LZO_INFO_OS "cygwin"
++#elif defined(__EMX__) && defined(__GNUC__)
++# define LZO_OS_EMX 1
++# define LZO_INFO_OS "emx"
++#elif defined(__BEOS__)
++# define LZO_OS_BEOS 1
++# define LZO_INFO_OS "beos"
++#elif defined(__Lynx__)
++# define LZO_OS_LYNXOS 1
++# define LZO_INFO_OS "lynxos"
++#elif defined(__OS400__)
++# define LZO_OS_OS400 1
++# define LZO_INFO_OS "os400"
++#elif defined(__QNX__)
++# define LZO_OS_QNX 1
++# define LZO_INFO_OS "qnx"
++#elif defined(__BORLANDC__) && defined(__DPMI32__) && (__BORLANDC__ >= 0x0460)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++#elif defined(__BORLANDC__) && defined(__DPMI16__)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++#elif defined(__ZTC__) && defined(DOS386)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++#elif defined(__OS2__) || defined(__OS2V2__)
++# if (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_OS216 1
++# define LZO_INFO_OS "os216"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_OS2 1
++# define LZO_INFO_OS "os2"
++# else
++# error "check your limits.h header"
++# endif
++#elif defined(__WIN64__) || defined(_WIN64) || defined(WIN64)
++# define LZO_OS_WIN64 1
++# define LZO_INFO_OS "win64"
++#elif defined(__WIN32__) || defined(_WIN32) || defined(WIN32) || defined(__WINDOWS_386__)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++#elif defined(__MWERKS__) && defined(__INTEL__)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++#elif defined(__WINDOWS__) || defined(_WINDOWS) || defined(_Windows)
++# if (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_WIN16 1
++# define LZO_INFO_OS "win16"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_WIN32 1
++# define LZO_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 == LZO_0xffffL)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_OS_DOS32 1
++# define LZO_INFO_OS "dos32"
++# else
++# error "check your limits.h header"
++# endif
++#elif defined(__WATCOMC__)
++# if defined(__NT__) && (UINT_MAX == LZO_0xffffL)
++# define LZO_OS_DOS16 1
++# define LZO_INFO_OS "dos16"
++# elif defined(__NT__) && (__WATCOMC__ < 1100)
++# define LZO_OS_WIN32 1
++# define LZO_INFO_OS "win32"
++# elif defined(__linux__) || defined(__LINUX__)
++# define LZO_OS_POSIX 1
++# define LZO_INFO_OS "posix"
++# else
++# error "please specify a target using the -bt compiler option"
++# endif
++#elif defined(__palmos__)
++# define LZO_OS_PALMOS 1
++# define LZO_INFO_OS "palmos"
++#elif defined(__TOS__) || defined(__atarist__)
++# define LZO_OS_TOS 1
++# define LZO_INFO_OS "tos"
++#elif defined(macintosh) && !defined(__ppc__)
++# define LZO_OS_MACCLASSIC 1
++# define LZO_INFO_OS "macclassic"
++#elif defined(__VMS)
++# define LZO_OS_VMS 1
++# define LZO_INFO_OS "vms"
++#elif ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
++# define LZO_OS_CONSOLE 1
++# define LZO_OS_CONSOLE_PS2 1
++# define LZO_INFO_OS "console"
++# define LZO_INFO_OS_CONSOLE "ps2"
++#elif (defined(__mips__) && defined(__psp__))
++# define LZO_OS_CONSOLE 1
++# define LZO_OS_CONSOLE_PSP 1
++# define LZO_INFO_OS "console"
++# define LZO_INFO_OS_CONSOLE "psp"
++#else
++# define LZO_OS_POSIX 1
++# define LZO_INFO_OS "posix"
++#endif
++#if (LZO_OS_POSIX)
++# if defined(_AIX) || defined(__AIX__) || defined(__aix__)
++# define LZO_OS_POSIX_AIX 1
++# define LZO_INFO_OS_POSIX "aix"
++# elif defined(__FreeBSD__)
++# define LZO_OS_POSIX_FREEBSD 1
++# define LZO_INFO_OS_POSIX "freebsd"
++# elif defined(__hpux__) || defined(__hpux)
++# define LZO_OS_POSIX_HPUX 1
++# define LZO_INFO_OS_POSIX "hpux"
++# elif defined(__INTERIX)
++# define LZO_OS_POSIX_INTERIX 1
++# define LZO_INFO_OS_POSIX "interix"
++# elif defined(__IRIX__) || defined(__irix__)
++# define LZO_OS_POSIX_IRIX 1
++# define LZO_INFO_OS_POSIX "irix"
++# elif defined(__linux__) || defined(__linux) || defined(__LINUX__)
++# define LZO_OS_POSIX_LINUX 1
++# define LZO_INFO_OS_POSIX "linux"
++# elif defined(__APPLE__) || defined(__MACOS__)
++# define LZO_OS_POSIX_MACOSX 1
++# define LZO_INFO_OS_POSIX "macosx"
++# elif defined(__minix__) || defined(__minix)
++# define LZO_OS_POSIX_MINIX 1
++# define LZO_INFO_OS_POSIX "minix"
++# elif defined(__NetBSD__)
++# define LZO_OS_POSIX_NETBSD 1
++# define LZO_INFO_OS_POSIX "netbsd"
++# elif defined(__OpenBSD__)
++# define LZO_OS_POSIX_OPENBSD 1
++# define LZO_INFO_OS_POSIX "openbsd"
++# elif defined(__osf__)
++# define LZO_OS_POSIX_OSF 1
++# define LZO_INFO_OS_POSIX "osf"
++# elif defined(__solaris__) || defined(__sun)
++# if defined(__SVR4) || defined(__svr4__)
++# define LZO_OS_POSIX_SOLARIS 1
++# define LZO_INFO_OS_POSIX "solaris"
++# else
++# define LZO_OS_POSIX_SUNOS 1
++# define LZO_INFO_OS_POSIX "sunos"
++# endif
++# elif defined(__ultrix__) || defined(__ultrix)
++# define LZO_OS_POSIX_ULTRIX 1
++# define LZO_INFO_OS_POSIX "ultrix"
++# elif defined(_UNICOS)
++# define LZO_OS_POSIX_UNICOS 1
++# define LZO_INFO_OS_POSIX "unicos"
++# else
++# define LZO_OS_POSIX_UNKNOWN 1
++# define LZO_INFO_OS_POSIX "unknown"
++# endif
++#endif
++#endif
++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++# if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if (LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (UINT_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if defined(CIL) && defined(_GNUCC) && defined(__GNUC__)
++# define LZO_CC_CILLY 1
++# define LZO_INFO_CC "Cilly"
++# if defined(__CILLY__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CILLY__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif 0 && defined(SDCC) && defined(__VERSION__) && !defined(__GNUC__)
++# define LZO_CC_SDCC 1
++# define LZO_INFO_CC "sdcc"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(SDCC)
++#elif defined(__PATHSCALE__) && defined(__PATHCC_PATCHLEVEL__)
++# define LZO_CC_PATHSCALE (__PATHCC__ * 0x10000L + __PATHCC_MINOR__ * 0x100 + __PATHCC_PATCHLEVEL__)
++# define LZO_INFO_CC "Pathscale C"
++# define LZO_INFO_CCVER __PATHSCALE__
++#elif defined(__INTEL_COMPILER)
++# define LZO_CC_INTELC 1
++# define LZO_INFO_CC "Intel C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__INTEL_COMPILER)
++# if defined(_WIN32) || defined(_WIN64)
++# define LZO_CC_SYNTAX_MSC 1
++# else
++# define LZO_CC_SYNTAX_GNUC 1
++# endif
++#elif defined(__POCC__) && defined(_WIN32)
++# define LZO_CC_PELLESC 1
++# define LZO_INFO_CC "Pelles C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__POCC__)
++#elif defined(__clang__) && defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__)
++# if defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# else
++# define LZO_CC_CLANG_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# endif
++# if defined(__clang_major__) && defined(__clang_minor__) && defined(__clang_patchlevel__)
++# define LZO_CC_CLANG_CLANG (__clang_major__ * 0x10000L + __clang_minor__ * 0x100 + __clang_patchlevel__)
++# else
++# define LZO_CC_CLANG_CLANG 0x010000L
++# endif
++# define LZO_CC_CLANG LZO_CC_CLANG_GNUC
++# define LZO_INFO_CC "clang"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__llvm__) && defined(__GNUC__) && defined(__GNUC_MINOR__) && defined(__VERSION__)
++# if defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# else
++# define LZO_CC_LLVM_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# endif
++# define LZO_CC_LLVM LZO_CC_LLVM_GNUC
++# define LZO_INFO_CC "llvm-gcc"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__GNUC__) && defined(__VERSION__)
++# if defined(__GNUC_MINOR__) && defined(__GNUC_PATCHLEVEL__)
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100 + __GNUC_PATCHLEVEL__)
++# elif defined(__GNUC_MINOR__)
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L + __GNUC_MINOR__ * 0x100)
++# else
++# define LZO_CC_GNUC (__GNUC__ * 0x10000L)
++# endif
++# define LZO_INFO_CC "gcc"
++# define LZO_INFO_CCVER __VERSION__
++#elif defined(__ACK__) && defined(_ACK)
++# define LZO_CC_ACK 1
++# define LZO_INFO_CC "Amsterdam Compiler Kit C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__AZTEC_C__)
++# define LZO_CC_AZTECC 1
++# define LZO_INFO_CC "Aztec C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__AZTEC_C__)
++#elif defined(__CODEGEARC__)
++# define LZO_CC_CODEGEARC 1
++# define LZO_INFO_CC "CodeGear C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__CODEGEARC__)
++#elif defined(__BORLANDC__)
++# define LZO_CC_BORLANDC 1
++# define LZO_INFO_CC "Borland C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__BORLANDC__)
++#elif defined(_CRAYC) && defined(_RELEASE)
++# define LZO_CC_CRAYC 1
++# define LZO_INFO_CC "Cray C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_RELEASE)
++#elif defined(__DMC__) && defined(__SC__)
++# define LZO_CC_DMC 1
++# define LZO_INFO_CC "Digital Mars C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DMC__)
++#elif defined(__DECC)
++# define LZO_CC_DECC 1
++# define LZO_INFO_CC "DEC C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__DECC)
++#elif defined(__HIGHC__)
++# define LZO_CC_HIGHC 1
++# define LZO_INFO_CC "MetaWare High C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__IAR_SYSTEMS_ICC__)
++# define LZO_CC_IARC 1
++# define LZO_INFO_CC "IAR C"
++# if defined(__VER__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__VER__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__IBMC__)
++# define LZO_CC_IBMC 1
++# define LZO_INFO_CC "IBM C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__IBMC__)
++#elif defined(__KEIL__) && defined(__C166__)
++# define LZO_CC_KEILC 1
++# define LZO_INFO_CC "Keil C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__C166__)
++#elif defined(__LCC__) && defined(_WIN32) && defined(__LCCOPTIMLEVEL)
++# define LZO_CC_LCCWIN32 1
++# define LZO_INFO_CC "lcc-win32"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__LCC__)
++# define LZO_CC_LCC 1
++# define LZO_INFO_CC "lcc"
++# if defined(__LCC_VERSION__)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__LCC_VERSION__)
++# else
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(_MSC_VER)
++# define LZO_CC_MSC 1
++# define LZO_INFO_CC "Microsoft C"
++# if defined(_MSC_FULL_VER)
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER) "." LZO_PP_MACRO_EXPAND(_MSC_FULL_VER)
++# else
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(_MSC_VER)
++# endif
++#elif defined(__MWERKS__)
++# define LZO_CC_MWERKS 1
++# define LZO_INFO_CC "Metrowerks C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__MWERKS__)
++#elif (defined(__NDPC__) || defined(__NDPX__)) && defined(__i386)
++# define LZO_CC_NDPC 1
++# define LZO_INFO_CC "Microway NDP C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__PACIFIC__)
++# define LZO_CC_PACIFICC 1
++# define LZO_INFO_CC "Pacific C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PACIFIC__)
++#elif defined(__PGI) && (defined(__linux__) || defined(__WIN32__))
++# define LZO_CC_PGI 1
++# define LZO_INFO_CC "Portland Group PGI C"
++# define LZO_INFO_CCVER "unknown"
++#elif defined(__PUREC__) && defined(__TOS__)
++# define LZO_CC_PUREC 1
++# define LZO_INFO_CC "Pure C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__PUREC__)
++#elif defined(__SC__) && defined(__ZTC__)
++# define LZO_CC_SYMANTECC 1
++# define LZO_INFO_CC "Symantec C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SC__)
++#elif defined(__SUNPRO_C)
++# define LZO_INFO_CC "SunPro C"
++# if ((__SUNPRO_C)+0 > 0)
++# define LZO_CC_SUNPROC __SUNPRO_C
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_C)
++# else
++# define LZO_CC_SUNPROC 1
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__SUNPRO_CC)
++# define LZO_INFO_CC "SunPro C"
++# if ((__SUNPRO_CC)+0 > 0)
++# define LZO_CC_SUNPROC __SUNPRO_CC
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__SUNPRO_CC)
++# else
++# define LZO_CC_SUNPROC 1
++# define LZO_INFO_CCVER "unknown"
++# endif
++#elif defined(__TINYC__)
++# define LZO_CC_TINYC 1
++# define LZO_INFO_CC "Tiny C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TINYC__)
++#elif defined(__TSC__)
++# define LZO_CC_TOPSPEEDC 1
++# define LZO_INFO_CC "TopSpeed C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TSC__)
++#elif defined(__WATCOMC__)
++# define LZO_CC_WATCOMC 1
++# define LZO_INFO_CC "Watcom C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__WATCOMC__)
++#elif defined(__TURBOC__)
++# define LZO_CC_TURBOC 1
++# define LZO_INFO_CC "Turbo C"
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__TURBOC__)
++#elif defined(__ZTC__)
++# define LZO_CC_ZORTECHC 1
++# define LZO_INFO_CC "Zortech C"
++# if (__ZTC__ == 0x310)
++# define LZO_INFO_CCVER "0x310"
++# else
++# define LZO_INFO_CCVER LZO_PP_MACRO_EXPAND(__ZTC__)
++# endif
++#else
++# define LZO_CC_UNKNOWN 1
++# define LZO_INFO_CC "unknown"
++# define LZO_INFO_CCVER "unknown"
++#endif
++#if 0 && (LZO_CC_MSC && (_MSC_VER >= 1200)) && !defined(_MSC_FULL_VER)
++# error "LZO_CC_MSC: _MSC_FULL_VER is not defined"
++#endif
++#if !defined(__LZO_ARCH_OVERRIDE) && !(LZO_ARCH_GENERIC) && defined(_CRAY)
++# if (UINT_MAX > LZO_0xffffffffL) && defined(_CRAY)
++# if defined(_CRAYMPP) || defined(_CRAYT3D) || defined(_CRAYT3E)
++# define LZO_ARCH_CRAY_MPP 1
++# elif defined(_CRAY1)
++# define LZO_ARCH_CRAY_PVP 1
++# endif
++# endif
++#endif
++#if !defined(__LZO_ARCH_OVERRIDE)
++#if (LZO_ARCH_GENERIC)
++# define LZO_INFO_ARCH "generic"
++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++# define LZO_ARCH_I086 1
++# define LZO_ARCH_IA16 1
++# define LZO_INFO_ARCH "i086"
++#elif defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA)
++# define LZO_ARCH_ALPHA 1
++# define LZO_INFO_ARCH "alpha"
++#elif (LZO_ARCH_CRAY_MPP) && (defined(_CRAYT3D) || defined(_CRAYT3E))
++# define LZO_ARCH_ALPHA 1
++# define LZO_INFO_ARCH "alpha"
++#elif defined(__amd64__) || defined(__x86_64__) || defined(_M_AMD64)
++# define LZO_ARCH_AMD64 1
++# define LZO_INFO_ARCH "amd64"
++#elif defined(__thumb__) || (defined(_M_ARM) && defined(_M_THUMB))
++# define LZO_ARCH_ARM 1
++# define LZO_ARCH_ARM_THUMB 1
++# define LZO_INFO_ARCH "arm_thumb"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCARM__)
++# define LZO_ARCH_ARM 1
++# if defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 1)
++# define LZO_ARCH_ARM_THUMB 1
++# define LZO_INFO_ARCH "arm_thumb"
++# elif defined(__CPU_MODE__) && ((__CPU_MODE__)+0 == 2)
++# define LZO_INFO_ARCH "arm"
++# else
++# define LZO_INFO_ARCH "arm"
++# endif
++#elif defined(__arm__) || defined(_M_ARM)
++# define LZO_ARCH_ARM 1
++# define LZO_INFO_ARCH "arm"
++#elif (UINT_MAX <= LZO_0xffffL) && defined(__AVR__)
++# define LZO_ARCH_AVR 1
++# define LZO_INFO_ARCH "avr"
++#elif defined(__avr32__) || defined(__AVR32__)
++# define LZO_ARCH_AVR32 1
++# define LZO_INFO_ARCH "avr32"
++#elif defined(__bfin__)
++# define LZO_ARCH_BLACKFIN 1
++# define LZO_INFO_ARCH "blackfin"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C166__)
++# define LZO_ARCH_C166 1
++# define LZO_INFO_ARCH "c166"
++#elif defined(__cris__)
++# define LZO_ARCH_CRIS 1
++# define LZO_INFO_ARCH "cris"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCEZ80__)
++# define LZO_ARCH_EZ80 1
++# define LZO_INFO_ARCH "ez80"
++#elif defined(__H8300__) || defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
++# define LZO_ARCH_H8300 1
++# define LZO_INFO_ARCH "h8300"
++#elif defined(__hppa__) || defined(__hppa)
++# define LZO_ARCH_HPPA 1
++# define LZO_INFO_ARCH "hppa"
++#elif defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386)
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif (LZO_CC_ZORTECHC && defined(__I86__))
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif (LZO_OS_DOS32 && LZO_CC_HIGHC) && defined(_I386)
++# define LZO_ARCH_I386 1
++# define LZO_ARCH_IA32 1
++# define LZO_INFO_ARCH "i386"
++#elif defined(__ia64__) || defined(__ia64) || defined(_M_IA64)
++# define LZO_ARCH_IA64 1
++# define LZO_INFO_ARCH "ia64"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__m32c__)
++# define LZO_ARCH_M16C 1
++# define LZO_INFO_ARCH "m16c"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICCM16C__)
++# define LZO_ARCH_M16C 1
++# define LZO_INFO_ARCH "m16c"
++#elif defined(__m32r__)
++# define LZO_ARCH_M32R 1
++# define LZO_INFO_ARCH "m32r"
++#elif (LZO_OS_TOS) || defined(__m68k__) || defined(__m68000__) || defined(__mc68000__) || defined(__mc68020__) || defined(_M_M68K)
++# define LZO_ARCH_M68K 1
++# define LZO_INFO_ARCH "m68k"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C251__)
++# define LZO_ARCH_MCS251 1
++# define LZO_INFO_ARCH "mcs251"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__C51__)
++# define LZO_ARCH_MCS51 1
++# define LZO_INFO_ARCH "mcs51"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC8051__)
++# define LZO_ARCH_MCS51 1
++# define LZO_INFO_ARCH "mcs51"
++#elif defined(__mips__) || defined(__mips) || defined(_MIPS_ARCH) || defined(_M_MRX000)
++# define LZO_ARCH_MIPS 1
++# define LZO_INFO_ARCH "mips"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__MSP430__)
++# define LZO_ARCH_MSP430 1
++# define LZO_INFO_ARCH "msp430"
++#elif defined(__IAR_SYSTEMS_ICC__) && defined(__ICC430__)
++# define LZO_ARCH_MSP430 1
++# define LZO_INFO_ARCH "msp430"
++#elif defined(__powerpc__) || defined(__powerpc) || defined(__ppc__) || defined(__PPC__) || defined(_M_PPC) || defined(_ARCH_PPC) || defined(_ARCH_PWR)
++# define LZO_ARCH_POWERPC 1
++# define LZO_INFO_ARCH "powerpc"
++#elif defined(__s390__) || defined(__s390) || defined(__s390x__) || defined(__s390x)
++# define LZO_ARCH_S390 1
++# define LZO_INFO_ARCH "s390"
++#elif defined(__sh__) || defined(_M_SH)
++# define LZO_ARCH_SH 1
++# define LZO_INFO_ARCH "sh"
++#elif defined(__sparc__) || defined(__sparc) || defined(__sparcv8)
++# define LZO_ARCH_SPARC 1
++# define LZO_INFO_ARCH "sparc"
++#elif defined(__SPU__)
++# define LZO_ARCH_SPU 1
++# define LZO_INFO_ARCH "spu"
++#elif (UINT_MAX == LZO_0xffffL) && defined(__z80)
++# define LZO_ARCH_Z80 1
++# define LZO_INFO_ARCH "z80"
++#elif (LZO_ARCH_CRAY_PVP)
++# if defined(_CRAYSV1)
++# define LZO_ARCH_CRAY_SV1 1
++# define LZO_INFO_ARCH "cray_sv1"
++# elif (_ADDR64)
++# define LZO_ARCH_CRAY_T90 1
++# define LZO_INFO_ARCH "cray_t90"
++# elif (_ADDR32)
++# define LZO_ARCH_CRAY_YMP 1
++# define LZO_INFO_ARCH "cray_ymp"
++# else
++# define LZO_ARCH_CRAY_XMP 1
++# define LZO_INFO_ARCH "cray_xmp"
++# endif
++#else
++# define LZO_ARCH_UNKNOWN 1
++# define LZO_INFO_ARCH "unknown"
++#endif
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_DOS32 || LZO_OS_OS2)
++# error "FIXME - missing define for CPU architecture"
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN32)
++# error "FIXME - missing WIN32 define for CPU architecture"
++#endif
++#if 1 && (LZO_ARCH_UNKNOWN) && (LZO_OS_WIN64)
++# error "FIXME - missing WIN64 define for CPU architecture"
++#endif
++#if (LZO_OS_OS216 || LZO_OS_WIN16)
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && defined(BLX286))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && defined(DOSX286))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#elif 1 && (LZO_OS_DOS16 && LZO_CC_BORLANDC && defined(__DPMI16__))
++# define LZO_ARCH_I086PM 1
++# define LZO_ARCH_IA16PM 1
++#endif
++#if (LZO_ARCH_ARM_THUMB) && !(LZO_ARCH_ARM)
++# error "this should not happen"
++#endif
++#if (LZO_ARCH_I086PM) && !(LZO_ARCH_I086)
++# error "this should not happen"
++#endif
++#if (LZO_ARCH_I086)
++# if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if (LZO_ARCH_I386)
++# if (UINT_MAX != LZO_0xffffL) && defined(__i386_int16__)
++# error "this should not happen"
++# endif
++# if (UINT_MAX != LZO_0xffffffffL) && !defined(__i386_int16__)
++# error "this should not happen"
++# endif
++# if (ULONG_MAX != LZO_0xffffffffL)
++# error "this should not happen"
++# endif
++#endif
++#if !defined(__LZO_MM_OVERRIDE)
++#if (LZO_ARCH_I086)
++#if (UINT_MAX != LZO_0xffffL)
++# error "this should not happen"
++#endif
++#if defined(__TINY__) || defined(M_I86TM) || defined(_M_I86TM)
++# define LZO_MM_TINY 1
++#elif defined(__HUGE__) || defined(_HUGE_) || defined(M_I86HM) || defined(_M_I86HM)
++# define LZO_MM_HUGE 1
++#elif defined(__SMALL__) || defined(M_I86SM) || defined(_M_I86SM) || defined(SMALL_MODEL)
++# define LZO_MM_SMALL 1
++#elif defined(__MEDIUM__) || defined(M_I86MM) || defined(_M_I86MM)
++# define LZO_MM_MEDIUM 1
++#elif defined(__COMPACT__) || defined(M_I86CM) || defined(_M_I86CM)
++# define LZO_MM_COMPACT 1
++#elif defined(__LARGE__) || defined(M_I86LM) || defined(_M_I86LM) || defined(LARGE_MODEL)
++# define LZO_MM_LARGE 1
++#elif (LZO_CC_AZTECC)
++# if defined(_LARGE_CODE) && defined(_LARGE_DATA)
++# define LZO_MM_LARGE 1
++# elif defined(_LARGE_CODE)
++# define LZO_MM_MEDIUM 1
++# elif defined(_LARGE_DATA)
++# define LZO_MM_COMPACT 1
++# else
++# define LZO_MM_SMALL 1
++# endif
++#elif (LZO_CC_ZORTECHC && defined(__VCM__))
++# define LZO_MM_LARGE 1
++#else
++# error "unknown memory model"
++#endif
++#if (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++#define LZO_HAVE_MM_HUGE_PTR 1
++#define LZO_HAVE_MM_HUGE_ARRAY 1
++#if (LZO_MM_TINY)
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#endif
++#if (LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_ZORTECHC)
++# undef LZO_HAVE_MM_HUGE_PTR
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC)
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#elif (LZO_CC_MSC && defined(_QC))
++# undef LZO_HAVE_MM_HUGE_ARRAY
++# if (_MSC_VER < 600)
++# undef LZO_HAVE_MM_HUGE_PTR
++# endif
++#elif (LZO_CC_TURBOC && (__TURBOC__ < 0x0295))
++# undef LZO_HAVE_MM_HUGE_ARRAY
++#endif
++#if (LZO_ARCH_I086PM) && !(LZO_HAVE_MM_HUGE_PTR)
++# if (LZO_OS_DOS16)
++# error "this should not happen"
++# elif (LZO_CC_ZORTECHC)
++# else
++# error "this should not happen"
++# endif
++#endif
++#ifdef __cplusplus
++extern "C" {
++#endif
++#if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0200))
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_MSC || LZO_CC_TOPSPEEDC)
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif (LZO_CC_TURBOC && (__TURBOC__ >= 0x0295))
++ extern void __near __cdecl _AHSHIFT(void);
++# define LZO_MM_AHSHIFT ((unsigned) _AHSHIFT)
++#elif ((LZO_CC_AZTECC || LZO_CC_PACIFICC || LZO_CC_TURBOC) && LZO_OS_DOS16)
++# define LZO_MM_AHSHIFT 12
++#elif (LZO_CC_WATCOMC)
++ extern unsigned char _HShift;
++# define LZO_MM_AHSHIFT ((unsigned) _HShift)
++#else
++# error "FIXME - implement LZO_MM_AHSHIFT"
++#endif
++#ifdef __cplusplus
++}
++#endif
++#endif
++#elif (LZO_ARCH_C166)
++#if !defined(__MODEL__)
++# error "FIXME - C166 __MODEL__"
++#elif ((__MODEL__) == 0)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 1)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - C166 __MODEL__"
++#endif
++#elif (LZO_ARCH_MCS251)
++#if !defined(__MODEL__)
++# error "FIXME - MCS251 __MODEL__"
++#elif ((__MODEL__) == 0)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - MCS251 __MODEL__"
++#endif
++#elif (LZO_ARCH_MCS51)
++#if !defined(__MODEL__)
++# error "FIXME - MCS51 __MODEL__"
++#elif ((__MODEL__) == 1)
++# define LZO_MM_SMALL 1
++#elif ((__MODEL__) == 2)
++# define LZO_MM_LARGE 1
++#elif ((__MODEL__) == 3)
++# define LZO_MM_TINY 1
++#elif ((__MODEL__) == 4)
++# define LZO_MM_XTINY 1
++#elif ((__MODEL__) == 5)
++# define LZO_MM_XSMALL 1
++#else
++# error "FIXME - MCS51 __MODEL__"
++#endif
++#elif (LZO_ARCH_CRAY_PVP)
++# define LZO_MM_PVP 1
++#else
++# define LZO_MM_FLAT 1
++#endif
++#if (LZO_MM_COMPACT)
++# define LZO_INFO_MM "compact"
++#elif (LZO_MM_FLAT)
++# define LZO_INFO_MM "flat"
++#elif (LZO_MM_HUGE)
++# define LZO_INFO_MM "huge"
++#elif (LZO_MM_LARGE)
++# define LZO_INFO_MM "large"
++#elif (LZO_MM_MEDIUM)
++# define LZO_INFO_MM "medium"
++#elif (LZO_MM_PVP)
++# define LZO_INFO_MM "pvp"
++#elif (LZO_MM_SMALL)
++# define LZO_INFO_MM "small"
++#elif (LZO_MM_TINY)
++# define LZO_INFO_MM "tiny"
++#else
++# error "unknown memory model"
++#endif
++#endif
++#if defined(SIZEOF_SHORT)
++# define LZO_SIZEOF_SHORT (SIZEOF_SHORT)
++#endif
++#if defined(SIZEOF_INT)
++# define LZO_SIZEOF_INT (SIZEOF_INT)
++#endif
++#if defined(SIZEOF_LONG)
++# define LZO_SIZEOF_LONG (SIZEOF_LONG)
++#endif
++#if defined(SIZEOF_LONG_LONG)
++# define LZO_SIZEOF_LONG_LONG (SIZEOF_LONG_LONG)
++#endif
++#if defined(SIZEOF___INT16)
++# define LZO_SIZEOF___INT16 (SIZEOF___INT16)
++#endif
++#if defined(SIZEOF___INT32)
++# define LZO_SIZEOF___INT32 (SIZEOF___INT32)
++#endif
++#if defined(SIZEOF___INT64)
++# define LZO_SIZEOF___INT64 (SIZEOF___INT64)
++#endif
++#if defined(SIZEOF_VOID_P)
++# define LZO_SIZEOF_VOID_P (SIZEOF_VOID_P)
++#endif
++#if defined(SIZEOF_SIZE_T)
++# define LZO_SIZEOF_SIZE_T (SIZEOF_SIZE_T)
++#endif
++#if defined(SIZEOF_PTRDIFF_T)
++# define LZO_SIZEOF_PTRDIFF_T (SIZEOF_PTRDIFF_T)
++#endif
++#define __LZO_LSR(x,b) (((x)+0ul) >> (b))
++#if !defined(LZO_SIZEOF_SHORT)
++# if (LZO_ARCH_CRAY_PVP)
++# define LZO_SIZEOF_SHORT 8
++# elif (USHRT_MAX == LZO_0xffffL)
++# define LZO_SIZEOF_SHORT 2
++# elif (__LZO_LSR(USHRT_MAX,7) == 1)
++# define LZO_SIZEOF_SHORT 1
++# elif (__LZO_LSR(USHRT_MAX,15) == 1)
++# define LZO_SIZEOF_SHORT 2
++# elif (__LZO_LSR(USHRT_MAX,31) == 1)
++# define LZO_SIZEOF_SHORT 4
++# elif (__LZO_LSR(USHRT_MAX,63) == 1)
++# define LZO_SIZEOF_SHORT 8
++# elif (__LZO_LSR(USHRT_MAX,127) == 1)
++# define LZO_SIZEOF_SHORT 16
++# else
++# error "LZO_SIZEOF_SHORT"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_INT)
++# if (LZO_ARCH_CRAY_PVP)
++# define LZO_SIZEOF_INT 8
++# elif (UINT_MAX == LZO_0xffffL)
++# define LZO_SIZEOF_INT 2
++# elif (UINT_MAX == LZO_0xffffffffL)
++# define LZO_SIZEOF_INT 4
++# elif (__LZO_LSR(UINT_MAX,7) == 1)
++# define LZO_SIZEOF_INT 1
++# elif (__LZO_LSR(UINT_MAX,15) == 1)
++# define LZO_SIZEOF_INT 2
++# elif (__LZO_LSR(UINT_MAX,31) == 1)
++# define LZO_SIZEOF_INT 4
++# elif (__LZO_LSR(UINT_MAX,63) == 1)
++# define LZO_SIZEOF_INT 8
++# elif (__LZO_LSR(UINT_MAX,127) == 1)
++# define LZO_SIZEOF_INT 16
++# else
++# error "LZO_SIZEOF_INT"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_LONG)
++# if (ULONG_MAX == LZO_0xffffffffL)
++# define LZO_SIZEOF_LONG 4
++# elif (__LZO_LSR(ULONG_MAX,7) == 1)
++# define LZO_SIZEOF_LONG 1
++# elif (__LZO_LSR(ULONG_MAX,15) == 1)
++# define LZO_SIZEOF_LONG 2
++# elif (__LZO_LSR(ULONG_MAX,31) == 1)
++# define LZO_SIZEOF_LONG 4
++# elif (__LZO_LSR(ULONG_MAX,63) == 1)
++# define LZO_SIZEOF_LONG 8
++# elif (__LZO_LSR(ULONG_MAX,127) == 1)
++# define LZO_SIZEOF_LONG 16
++# else
++# error "LZO_SIZEOF_LONG"
++# endif
++#endif
++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64)
++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8)
++# if defined(__LONG_MAX__) && defined(__LONG_LONG_MAX__)
++# if (LZO_CC_GNUC >= 0x030300ul)
++# if ((__LONG_MAX__)+0 == (__LONG_LONG_MAX__)+0)
++# define LZO_SIZEOF_LONG_LONG LZO_SIZEOF_LONG
++# elif (__LZO_LSR(__LONG_LONG_MAX__,30) == 1)
++# define LZO_SIZEOF_LONG_LONG 4
++# endif
++# endif
++# endif
++#endif
++#endif
++#if !defined(LZO_SIZEOF_LONG_LONG) && !defined(LZO_SIZEOF___INT64)
++#if (LZO_SIZEOF_LONG > 0 && LZO_SIZEOF_LONG < 8)
++#if (LZO_ARCH_I086 && LZO_CC_DMC)
++#elif (LZO_CC_CILLY) && defined(__GNUC__)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif ((LZO_OS_WIN32 || LZO_OS_WIN64 || defined(_WIN32)) && LZO_CC_MSC && (_MSC_VER >= 1400))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_OS_WIN64 || defined(_WIN64))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_DMC))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_SYMANTECC && (__SC__ >= 0x700)))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC && defined(__linux__)))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_MWERKS || LZO_CC_PELLESC || LZO_CC_PGI || LZO_CC_SUNPROC))
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_ARCH_I386 && (LZO_CC_INTELC || LZO_CC_MSC))
++# define LZO_SIZEOF___INT64 8
++#elif ((LZO_OS_WIN32 || defined(_WIN32)) && (LZO_CC_MSC))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0520)))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_ARCH_I386 && (LZO_CC_WATCOMC && (__WATCOMC__ >= 1100)))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_CC_WATCOMC && defined(_INTEGRAL_MAX_BITS) && (_INTEGRAL_MAX_BITS == 64))
++# define LZO_SIZEOF___INT64 8
++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
++# define LZO_SIZEOF_LONG_LONG 8
++#elif (LZO_CC_SDCC) && (LZO_SIZEOF_INT == 2)
++#elif 1 && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
++# define LZO_SIZEOF_LONG_LONG 8
++#endif
++#endif
++#endif
++#if defined(__cplusplus) && (LZO_CC_GNUC)
++# if (LZO_CC_GNUC < 0x020800ul)
++# undef LZO_SIZEOF_LONG_LONG
++# endif
++#endif
++#if (LZO_CFG_NO_LONG_LONG) || defined(__NO_LONG_LONG)
++# undef LZO_SIZEOF_LONG_LONG
++#endif
++#if !defined(LZO_SIZEOF_VOID_P)
++#if (LZO_ARCH_I086)
++# define __LZO_WORDSIZE 2
++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM)
++# define LZO_SIZEOF_VOID_P 2
++# elif (LZO_MM_COMPACT || LZO_MM_LARGE || LZO_MM_HUGE)
++# define LZO_SIZEOF_VOID_P 4
++# else
++# error "LZO_MM"
++# endif
++#elif (LZO_ARCH_AVR || LZO_ARCH_Z80)
++# define __LZO_WORDSIZE 1
++# define LZO_SIZEOF_VOID_P 2
++#elif (LZO_ARCH_C166 || LZO_ARCH_MCS51 || LZO_ARCH_MCS251 || LZO_ARCH_MSP430)
++# define LZO_SIZEOF_VOID_P 2
++#elif (LZO_ARCH_H8300)
++# if defined(__NORMAL_MODE__)
++# define __LZO_WORDSIZE 4
++# define LZO_SIZEOF_VOID_P 2
++# elif defined(__H8300H__) || defined(__H8300S__) || defined(__H8300SX__)
++# define __LZO_WORDSIZE 4
++# define LZO_SIZEOF_VOID_P 4
++# else
++# define __LZO_WORDSIZE 2
++# define LZO_SIZEOF_VOID_P 2
++# endif
++# if (LZO_CC_GNUC && (LZO_CC_GNUC < 0x040000ul)) && (LZO_SIZEOF_INT == 4)
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_INT
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_INT
++# endif
++#elif (LZO_ARCH_M16C)
++# define __LZO_WORDSIZE 2
++# if defined(__m32c_cpu__) || defined(__m32cm_cpu__)
++# define LZO_SIZEOF_VOID_P 4
++# else
++# define LZO_SIZEOF_VOID_P 2
++# endif
++#elif (LZO_SIZEOF_LONG == 8) && ((defined(__mips__) && defined(__R5900__)) || defined(__MIPS_PSX2__))
++# define __LZO_WORDSIZE 8
++# define LZO_SIZEOF_VOID_P 4
++#elif defined(__LLP64__) || defined(__LLP64) || defined(_LLP64) || defined(_WIN64)
++# define __LZO_WORDSIZE 8
++# define LZO_SIZEOF_VOID_P 8
++#elif (LZO_OS_OS400 || defined(__OS400__)) && defined(__LLP64_IFC__)
++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (LZO_OS_OS400 || defined(__OS400__))
++# define __LZO_WORDSIZE LZO_SIZEOF_LONG
++# define LZO_SIZEOF_VOID_P 16
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (defined(__vms) || defined(__VMS)) && (__INITIAL_POINTER_SIZE+0 == 64)
++# define LZO_SIZEOF_VOID_P 8
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_LONG
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_LONG
++#elif (LZO_ARCH_SPU)
++# if 0
++# define __LZO_WORDSIZE 16
++# endif
++# define LZO_SIZEOF_VOID_P 4
++#else
++# define LZO_SIZEOF_VOID_P LZO_SIZEOF_LONG
++#endif
++#endif
++#if !defined(LZO_WORDSIZE)
++# if defined(__LZO_WORDSIZE)
++# define LZO_WORDSIZE __LZO_WORDSIZE
++# else
++# define LZO_WORDSIZE LZO_SIZEOF_VOID_P
++# endif
++#endif
++#if !defined(LZO_SIZEOF_SIZE_T)
++#if (LZO_ARCH_I086 || LZO_ARCH_M16C)
++# define LZO_SIZEOF_SIZE_T 2
++#else
++# define LZO_SIZEOF_SIZE_T LZO_SIZEOF_VOID_P
++#endif
++#endif
++#if !defined(LZO_SIZEOF_PTRDIFF_T)
++#if (LZO_ARCH_I086)
++# if (LZO_MM_TINY || LZO_MM_SMALL || LZO_MM_MEDIUM || LZO_MM_HUGE)
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_VOID_P
++# elif (LZO_MM_COMPACT || LZO_MM_LARGE)
++# if (LZO_CC_BORLANDC || LZO_CC_TURBOC)
++# define LZO_SIZEOF_PTRDIFF_T 4
++# else
++# define LZO_SIZEOF_PTRDIFF_T 2
++# endif
++# else
++# error "LZO_MM"
++# endif
++#else
++# define LZO_SIZEOF_PTRDIFF_T LZO_SIZEOF_SIZE_T
++#endif
++#endif
++#if (LZO_ABI_NEUTRAL_ENDIAN)
++# undef LZO_ABI_BIG_ENDIAN
++# undef LZO_ABI_LITTLE_ENDIAN
++#elif !(LZO_ABI_BIG_ENDIAN) && !(LZO_ABI_LITTLE_ENDIAN)
++#if (LZO_ARCH_ALPHA) && (LZO_ARCH_CRAY_MPP)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif (LZO_ARCH_IA64) && (LZO_OS_POSIX_LINUX || LZO_OS_WIN64)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif (LZO_ARCH_ALPHA || LZO_ARCH_AMD64 || LZO_ARCH_BLACKFIN || LZO_ARCH_CRIS || LZO_ARCH_I086 || LZO_ARCH_I386 || LZO_ARCH_MSP430)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif (LZO_ARCH_AVR32 || LZO_ARCH_M68K || LZO_ARCH_S390)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && defined(__IAR_SYSTEMS_ICC__) && defined(__LITTLE_ENDIAN__)
++# if (__LITTLE_ENDIAN__ == 1)
++# define LZO_ABI_LITTLE_ENDIAN 1
++# else
++# define LZO_ABI_BIG_ENDIAN 1
++# endif
++#elif 1 && defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEB__) && !defined(__ARMEL__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && (LZO_ARCH_ARM) && defined(__ARMEL__) && !defined(__ARMEB__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEB__) && !defined(__MIPSEL__)
++# define LZO_ABI_BIG_ENDIAN 1
++#elif 1 && (LZO_ARCH_MIPS) && defined(__MIPSEL__) && !defined(__MIPSEB__)
++# define LZO_ABI_LITTLE_ENDIAN 1
++#endif
++#endif
++#if (LZO_ABI_BIG_ENDIAN) && (LZO_ABI_LITTLE_ENDIAN)
++# error "this should not happen"
++#endif
++#if (LZO_ABI_BIG_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "be"
++#elif (LZO_ABI_LITTLE_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "le"
++#elif (LZO_ABI_NEUTRAL_ENDIAN)
++# define LZO_INFO_ABI_ENDIAN "neutral"
++#endif
++#if (LZO_SIZEOF_INT == 1 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
++# define LZO_ABI_I8LP16 1
++# define LZO_INFO_ABI_PM "i8lp16"
++#elif (LZO_SIZEOF_INT == 2 && LZO_SIZEOF_LONG == 2 && LZO_SIZEOF_VOID_P == 2)
++# define LZO_ABI_ILP16 1
++# define LZO_INFO_ABI_PM "ilp16"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 4)
++# define LZO_ABI_ILP32 1
++# define LZO_INFO_ABI_PM "ilp32"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 4 && LZO_SIZEOF_VOID_P == 8 && LZO_SIZEOF_SIZE_T == 8)
++# define LZO_ABI_LLP64 1
++# define LZO_INFO_ABI_PM "llp64"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
++# define LZO_ABI_LP64 1
++# define LZO_INFO_ABI_PM "lp64"
++#elif (LZO_SIZEOF_INT == 8 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 8)
++# define LZO_ABI_ILP64 1
++# define LZO_INFO_ABI_PM "ilp64"
++#elif (LZO_SIZEOF_INT == 4 && LZO_SIZEOF_LONG == 8 && LZO_SIZEOF_VOID_P == 4)
++# define LZO_ABI_IP32L64 1
++# define LZO_INFO_ABI_PM "ip32l64"
++#endif
++#if !defined(__LZO_LIBC_OVERRIDE)
++#if (LZO_LIBC_NAKED)
++# define LZO_INFO_LIBC "naked"
++#elif (LZO_LIBC_FREESTANDING)
++# define LZO_INFO_LIBC "freestanding"
++#elif (LZO_LIBC_MOSTLY_FREESTANDING)
++# define LZO_INFO_LIBC "mfreestanding"
++#elif (LZO_LIBC_ISOC90)
++# define LZO_INFO_LIBC "isoc90"
++#elif (LZO_LIBC_ISOC99)
++# define LZO_INFO_LIBC "isoc99"
++#elif defined(__dietlibc__)
++# define LZO_LIBC_DIETLIBC 1
++# define LZO_INFO_LIBC "dietlibc"
++#elif defined(_NEWLIB_VERSION)
++# define LZO_LIBC_NEWLIB 1
++# define LZO_INFO_LIBC "newlib"
++#elif defined(__UCLIBC__) && defined(__UCLIBC_MAJOR__) && defined(__UCLIBC_MINOR__)
++# if defined(__UCLIBC_SUBLEVEL__)
++# define LZO_LIBC_UCLIBC (__UCLIBC_MAJOR__ * 0x10000L + __UCLIBC_MINOR__ * 0x100 + __UCLIBC_SUBLEVEL__)
++# else
++# define LZO_LIBC_UCLIBC 0x00090bL
++# endif
++# define LZO_INFO_LIBC "uclibc"
++#elif defined(__GLIBC__) && defined(__GLIBC_MINOR__)
++# define LZO_LIBC_GLIBC (__GLIBC__ * 0x10000L + __GLIBC_MINOR__ * 0x100)
++# define LZO_INFO_LIBC "glibc"
++#elif (LZO_CC_MWERKS) && defined(__MSL__)
++# define LZO_LIBC_MSL __MSL__
++# define LZO_INFO_LIBC "msl"
++#elif 1 && defined(__IAR_SYSTEMS_ICC__)
++# define LZO_LIBC_ISOC90 1
++# define LZO_INFO_LIBC "isoc90"
++#else
++# define LZO_LIBC_DEFAULT 1
++# define LZO_INFO_LIBC "default"
++#endif
++#endif
++#if !defined(__lzo_gnuc_extension__)
++#if (LZO_CC_GNUC >= 0x020800ul)
++# define __lzo_gnuc_extension__ __extension__
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_gnuc_extension__ __extension__
++#else
++# define __lzo_gnuc_extension__ /*empty*/
++#endif
++#endif
++#if !defined(__lzo_ua_volatile)
++# define __lzo_ua_volatile volatile
++#endif
++#if !defined(__lzo_alignof)
++#if (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI)
++# define __lzo_alignof(e) __alignof__(e)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 700))
++# define __lzo_alignof(e) __alignof__(e)
++#elif (LZO_CC_MSC && (_MSC_VER >= 1300))
++# define __lzo_alignof(e) __alignof(e)
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_alignof(e) __alignof__(e)
++#endif
++#endif
++#if defined(__lzo_alignof)
++# define __lzo_HAVE_alignof 1
++#endif
++#if !defined(__lzo_constructor)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_constructor __attribute__((__constructor__,__used__))
++#elif (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_constructor __attribute__((__constructor__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_constructor __attribute__((__constructor__))
++#endif
++#endif
++#if defined(__lzo_constructor)
++# define __lzo_HAVE_constructor 1
++#endif
++#if !defined(__lzo_destructor)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_destructor __attribute__((__destructor__,__used__))
++#elif (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_destructor __attribute__((__destructor__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_destructor __attribute__((__destructor__))
++#endif
++#endif
++#if defined(__lzo_destructor)
++# define __lzo_HAVE_destructor 1
++#endif
++#if (__lzo_HAVE_destructor) && !(__lzo_HAVE_constructor)
++# error "this should not happen"
++#endif
++#if !defined(__lzo_inline)
++#if (LZO_CC_TURBOC && (__TURBOC__ <= 0x0295))
++#elif defined(__cplusplus)
++# define __lzo_inline inline
++#elif (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0550))
++# define __lzo_inline __inline
++#elif (LZO_CC_CILLY || LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE || LZO_CC_PGI)
++# define __lzo_inline __inline__
++#elif (LZO_CC_DMC)
++# define __lzo_inline __inline
++#elif (LZO_CC_INTELC)
++# define __lzo_inline __inline
++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x2405))
++# define __lzo_inline __inline
++#elif (LZO_CC_MSC && (_MSC_VER >= 900))
++# define __lzo_inline __inline
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_inline __inline__
++#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
++# define __lzo_inline inline
++#endif
++#endif
++#if defined(__lzo_inline)
++# define __lzo_HAVE_inline 1
++#else
++# define __lzo_inline /*empty*/
++#endif
++#if !defined(__lzo_forceinline)
++#if (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC)
++# define __lzo_forceinline __forceinline
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200))
++# define __lzo_forceinline __forceinline
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_forceinline __inline__ __attribute__((__always_inline__))
++#endif
++#endif
++#if defined(__lzo_forceinline)
++# define __lzo_HAVE_forceinline 1
++#else
++# define __lzo_forceinline /*empty*/
++#endif
++#if !defined(__lzo_noinline)
++#if 1 && (LZO_ARCH_I386) && (LZO_CC_GNUC >= 0x040000ul) && (LZO_CC_GNUC < 0x040003ul)
++# define __lzo_noinline __attribute__((__noinline__,__used__))
++#elif (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_MSC)
++# define __lzo_noinline __declspec(noinline)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_noinline __attribute__((__noinline__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1300))
++# define __lzo_noinline __declspec(noinline)
++#elif (LZO_CC_MWERKS && (__MWERKS__ >= 0x3200) && (LZO_OS_WIN32 || LZO_OS_WIN64))
++# if defined(__cplusplus)
++# else
++# define __lzo_noinline __declspec(noinline)
++# endif
++#elif (LZO_CC_SUNPROC && (LZO_CC_SUNPROC >= 0x5100))
++# define __lzo_noinline __attribute__((__noinline__))
++#endif
++#endif
++#if defined(__lzo_noinline)
++# define __lzo_HAVE_noinline 1
++#else
++# define __lzo_noinline /*empty*/
++#endif
++#if (__lzo_HAVE_forceinline || __lzo_HAVE_noinline) && !(__lzo_HAVE_inline)
++# error "this should not happen"
++#endif
++#if !defined(__lzo_noreturn)
++#if (LZO_CC_GNUC >= 0x020700ul)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC)
++# define __lzo_noreturn __declspec(noreturn)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_noreturn __attribute__((__noreturn__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200))
++# define __lzo_noreturn __declspec(noreturn)
++#endif
++#endif
++#if defined(__lzo_noreturn)
++# define __lzo_HAVE_noreturn 1
++#else
++# define __lzo_noreturn /*empty*/
++#endif
++#if !defined(__lzo_nothrow)
++#if (LZO_CC_GNUC >= 0x030300ul)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 450) && LZO_CC_SYNTAX_MSC) && defined(__cplusplus)
++# define __lzo_nothrow __declspec(nothrow)
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 900) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_nothrow __attribute__((__nothrow__))
++#elif (LZO_CC_MSC && (_MSC_VER >= 1200)) && defined(__cplusplus)
++# define __lzo_nothrow __declspec(nothrow)
++#endif
++#endif
++#if defined(__lzo_nothrow)
++# define __lzo_HAVE_nothrow 1
++#else
++# define __lzo_nothrow /*empty*/
++#endif
++#if !defined(__lzo_restrict)
++#if (LZO_CC_GNUC >= 0x030400ul)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 600) && LZO_CC_SYNTAX_GNUC)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_CLANG || LZO_CC_LLVM)
++# define __lzo_restrict __restrict__
++#elif (LZO_CC_MSC && (_MSC_VER >= 1400))
++# define __lzo_restrict __restrict
++#endif
++#endif
++#if defined(__lzo_restrict)
++# define __lzo_HAVE_restrict 1
++#else
++# define __lzo_restrict /*empty*/
++#endif
++#if !defined(__lzo_likely) && !defined(__lzo_unlikely)
++#if (LZO_CC_GNUC >= 0x030200ul)
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#elif (LZO_CC_INTELC && (__INTEL_COMPILER >= 800))
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#elif (LZO_CC_CLANG || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define __lzo_likely(e) (__builtin_expect(!!(e),1))
++# define __lzo_unlikely(e) (__builtin_expect(!!(e),0))
++#endif
++#endif
++#if defined(__lzo_likely)
++# define __lzo_HAVE_likely 1
++#else
++# define __lzo_likely(e) (e)
++#endif
++#if defined(__lzo_unlikely)
++# define __lzo_HAVE_unlikely 1
++#else
++# define __lzo_unlikely(e) (e)
++#endif
++#if !defined(LZO_UNUSED)
++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
++# define LZO_UNUSED(var) ((void) &var)
++# elif (LZO_CC_BORLANDC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PELLESC || LZO_CC_TURBOC)
++# define LZO_UNUSED(var) if (&var) ; else
++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_UNUSED(var) ((void) var)
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_UNUSED(var) if (&var) ; else
++# elif (LZO_CC_KEILC)
++# define LZO_UNUSED(var) {extern int __lzo_unused[1-2*!(sizeof(var)>0)];}
++# elif (LZO_CC_PACIFICC)
++# define LZO_UNUSED(var) ((void) sizeof(var))
++# elif (LZO_CC_WATCOMC) && defined(__cplusplus)
++# define LZO_UNUSED(var) ((void) var)
++# else
++# define LZO_UNUSED(var) ((void) &var)
++# endif
++#endif
++#if !defined(LZO_UNUSED_FUNC)
++# if (LZO_CC_BORLANDC && (__BORLANDC__ >= 0x0600))
++# define LZO_UNUSED_FUNC(func) ((void) func)
++# elif (LZO_CC_BORLANDC || LZO_CC_NDPC || LZO_CC_TURBOC)
++# define LZO_UNUSED_FUNC(func) if (func) ; else
++# elif (LZO_CC_CLANG || LZO_CC_LLVM)
++# define LZO_UNUSED_FUNC(func) ((void) &func)
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_UNUSED_FUNC(func) if (func) ; else
++# elif (LZO_CC_MSC)
++# define LZO_UNUSED_FUNC(func) ((void) &func)
++# elif (LZO_CC_KEILC || LZO_CC_PELLESC)
++# define LZO_UNUSED_FUNC(func) {extern int __lzo_unused[1-2*!(sizeof((int)func)>0)];}
++# else
++# define LZO_UNUSED_FUNC(func) ((void) func)
++# endif
++#endif
++#if !defined(LZO_UNUSED_LABEL)
++# if (LZO_CC_WATCOMC) && defined(__cplusplus)
++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l
++# elif (LZO_CC_CLANG || LZO_CC_INTELC || LZO_CC_WATCOMC)
++# define LZO_UNUSED_LABEL(l) if (0) goto l
++# else
++# define LZO_UNUSED_LABEL(l) switch(0) case 1:goto l
++# endif
++#endif
++#if !defined(LZO_DEFINE_UNINITIALIZED_VAR)
++# if 0
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var
++# elif 0 && (LZO_CC_GNUC)
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = var
++# else
++# define LZO_DEFINE_UNINITIALIZED_VAR(type,var,init) type var = init
++# endif
++#endif
++#if !defined(LZO_UNCONST_CAST)
++# if 0 && defined(__cplusplus)
++# define LZO_UNCONST_CAST(t,e) (const_cast<t> (e))
++# elif (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_LLVM || LZO_CC_PATHSCALE)
++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((lzo_uintptr_t) ((const void *) (e))))))
++# else
++# define LZO_UNCONST_CAST(t,e) ((t) ((void *) ((char *) ((const void *) (e)))))
++# endif
++#endif
++#if !defined(LZO_COMPILE_TIME_ASSERT_HEADER)
++# if (LZO_CC_AZTECC || LZO_CC_ZORTECHC)
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)];
++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC)
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1u-2*!(e)];
++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295))
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-!(e)];
++# else
++# define LZO_COMPILE_TIME_ASSERT_HEADER(e) extern int __lzo_cta[1-2*!(e)];
++# endif
++#endif
++#if !defined(LZO_COMPILE_TIME_ASSERT)
++# if (LZO_CC_AZTECC)
++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-!(e)];}
++# elif (LZO_CC_DMC || LZO_CC_PACIFICC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# elif (LZO_CC_MSC && (_MSC_VER < 900))
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# elif (LZO_CC_TURBOC && (__TURBOC__ == 0x0295))
++# define LZO_COMPILE_TIME_ASSERT(e) switch(0) case 1:case !(e):break;
++# else
++# define LZO_COMPILE_TIME_ASSERT(e) {typedef int __lzo_cta_t[1-2*!(e)];}
++# endif
++#endif
++#if (LZO_ARCH_I086 || LZO_ARCH_I386) && (LZO_OS_DOS16 || LZO_OS_DOS32 || LZO_OS_OS2 || LZO_OS_OS216 || LZO_OS_WIN16 || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC)
++# elif (LZO_CC_DMC || LZO_CC_SYMANTECC || LZO_CC_ZORTECHC)
++# define __lzo_cdecl __cdecl
++# define __lzo_cdecl_atexit /*empty*/
++# define __lzo_cdecl_main __cdecl
++# if (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC))
++# define __lzo_cdecl_qsort __pascal
++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC))
++# define __lzo_cdecl_qsort _stdcall
++# else
++# define __lzo_cdecl_qsort __cdecl
++# endif
++# elif (LZO_CC_WATCOMC)
++# define __lzo_cdecl __cdecl
++# else
++# define __lzo_cdecl __cdecl
++# define __lzo_cdecl_atexit __cdecl
++# define __lzo_cdecl_main __cdecl
++# define __lzo_cdecl_qsort __cdecl
++# endif
++# if (LZO_CC_GNUC || LZO_CC_HIGHC || LZO_CC_NDPC || LZO_CC_PACIFICC || LZO_CC_WATCOMC)
++# elif (LZO_OS_OS2 && (LZO_CC_DMC || LZO_CC_SYMANTECC))
++# define __lzo_cdecl_sighandler __pascal
++# elif (LZO_OS_OS2 && (LZO_CC_ZORTECHC))
++# define __lzo_cdecl_sighandler _stdcall
++# elif (LZO_CC_MSC && (_MSC_VER >= 1400)) && defined(_M_CEE_PURE)
++# define __lzo_cdecl_sighandler __clrcall
++# elif (LZO_CC_MSC && (_MSC_VER >= 600 && _MSC_VER < 700))
++# if defined(_DLL)
++# define __lzo_cdecl_sighandler _far _cdecl _loadds
++# elif defined(_MT)
++# define __lzo_cdecl_sighandler _far _cdecl
++# else
++# define __lzo_cdecl_sighandler _cdecl
++# endif
++# else
++# define __lzo_cdecl_sighandler __cdecl
++# endif
++#elif (LZO_ARCH_I386) && (LZO_CC_WATCOMC)
++# define __lzo_cdecl __cdecl
++#elif (LZO_ARCH_M68K && LZO_OS_TOS && (LZO_CC_PUREC || LZO_CC_TURBOC))
++# define __lzo_cdecl cdecl
++#endif
++#if !defined(__lzo_cdecl)
++# define __lzo_cdecl /*empty*/
++#endif
++#if !defined(__lzo_cdecl_atexit)
++# define __lzo_cdecl_atexit /*empty*/
++#endif
++#if !defined(__lzo_cdecl_main)
++# define __lzo_cdecl_main /*empty*/
++#endif
++#if !defined(__lzo_cdecl_qsort)
++# define __lzo_cdecl_qsort /*empty*/
++#endif
++#if !defined(__lzo_cdecl_sighandler)
++# define __lzo_cdecl_sighandler /*empty*/
++#endif
++#if !defined(__lzo_cdecl_va)
++# define __lzo_cdecl_va __lzo_cdecl
++#endif
++#if !(LZO_CFG_NO_WINDOWS_H)
++#if (LZO_OS_CYGWIN || (LZO_OS_EMX && defined(__RSXNT__)) || LZO_OS_WIN32 || LZO_OS_WIN64)
++# if (LZO_CC_WATCOMC && (__WATCOMC__ < 1000))
++# elif (LZO_OS_WIN32 && LZO_CC_GNUC) && defined(__PW32__)
++# elif ((LZO_OS_CYGWIN || defined(__MINGW32__)) && (LZO_CC_GNUC && (LZO_CC_GNUC < 0x025f00ul)))
++# else
++# define LZO_HAVE_WINDOWS_H 1
++# endif
++#endif
++#endif
++#if (LZO_ARCH_ALPHA)
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_AVOID_SHORT 1
++# define LZO_OPT_AVOID_USHORT 1
++#elif (LZO_ARCH_AMD64)
++# define LZO_OPT_AVOID_INT_INDEX 1
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# define LZO_OPT_UNALIGNED64 1
++#elif (LZO_ARCH_ARM && LZO_ARCH_ARM_THUMB)
++#elif (LZO_ARCH_ARM)
++# define LZO_OPT_AVOID_SHORT 1
++# define LZO_OPT_AVOID_USHORT 1
++#elif (LZO_ARCH_CRIS)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++#elif (LZO_ARCH_I386)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++#elif (LZO_ARCH_IA64)
++# define LZO_OPT_AVOID_INT_INDEX 1
++# define LZO_OPT_AVOID_UINT_INDEX 1
++# define LZO_OPT_PREFER_POSTINC 1
++#elif (LZO_ARCH_M68K)
++# define LZO_OPT_PREFER_POSTINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++# if defined(__mc68020__) && !defined(__mcoldfire__)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# endif
++#elif (LZO_ARCH_MIPS)
++# define LZO_OPT_AVOID_UINT_INDEX 1
++#elif (LZO_ARCH_POWERPC)
++# define LZO_OPT_PREFER_PREINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++# if (LZO_ABI_BIG_ENDIAN)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# endif
++#elif (LZO_ARCH_S390)
++# define LZO_OPT_UNALIGNED16 1
++# define LZO_OPT_UNALIGNED32 1
++# if (LZO_SIZEOF_SIZE_T == 8)
++# define LZO_OPT_UNALIGNED64 1
++# endif
++#elif (LZO_ARCH_SH)
++# define LZO_OPT_PREFER_POSTINC 1
++# define LZO_OPT_PREFER_PREDEC 1
++#endif
++#ifndef LZO_CFG_NO_INLINE_ASM
++#if (LZO_CC_LLVM)
++# define LZO_CFG_NO_INLINE_ASM 1
++#endif
++#endif
++#ifndef LZO_CFG_NO_UNALIGNED
++#if (LZO_ABI_NEUTRAL_ENDIAN) || (LZO_ARCH_GENERIC)
++# define LZO_CFG_NO_UNALIGNED 1
++#endif
++#endif
++#if (LZO_CFG_NO_UNALIGNED)
++# undef LZO_OPT_UNALIGNED16
++# undef LZO_OPT_UNALIGNED32
++# undef LZO_OPT_UNALIGNED64
++#endif
++#if (LZO_CFG_NO_INLINE_ASM)
++#elif (LZO_ARCH_I386 && (LZO_OS_DOS32 || LZO_OS_WIN32) && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC))
++# define LZO_ASM_SYNTAX_MSC 1
++#elif (LZO_OS_WIN64 && (LZO_CC_DMC || LZO_CC_INTELC || LZO_CC_MSC || LZO_CC_PELLESC))
++#elif (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC == 0x011f00ul))
++#elif (LZO_ARCH_I386 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE))
++# define LZO_ASM_SYNTAX_GNUC 1
++#elif (LZO_ARCH_AMD64 && (LZO_CC_CLANG || LZO_CC_GNUC || LZO_CC_INTELC || LZO_CC_PATHSCALE))
++# define LZO_ASM_SYNTAX_GNUC 1
++#endif
++#if (LZO_ASM_SYNTAX_GNUC)
++#if (LZO_ARCH_I386 && LZO_CC_GNUC && (LZO_CC_GNUC < 0x020000ul))
++# define __LZO_ASM_CLOBBER "ax"
++#elif (LZO_CC_INTELC)
++# define __LZO_ASM_CLOBBER "memory"
++#else
++# define __LZO_ASM_CLOBBER "cc", "memory"
++#endif
++#endif
++#if defined(__LZO_INFOSTR_MM)
++#elif (LZO_MM_FLAT) && (defined(__LZO_INFOSTR_PM) || defined(LZO_INFO_ABI_PM))
++# define __LZO_INFOSTR_MM ""
++#elif defined(LZO_INFO_MM)
++# define __LZO_INFOSTR_MM "." LZO_INFO_MM
++#else
++# define __LZO_INFOSTR_MM ""
++#endif
++#if defined(__LZO_INFOSTR_PM)
++#elif defined(LZO_INFO_ABI_PM)
++# define __LZO_INFOSTR_PM "." LZO_INFO_ABI_PM
++#else
++# define __LZO_INFOSTR_PM ""
++#endif
++#if defined(__LZO_INFOSTR_ENDIAN)
++#elif defined(LZO_INFO_ABI_ENDIAN)
++# define __LZO_INFOSTR_ENDIAN "." LZO_INFO_ABI_ENDIAN
++#else
++# define __LZO_INFOSTR_ENDIAN ""
++#endif
++#if defined(__LZO_INFOSTR_OSNAME)
++#elif defined(LZO_INFO_OS_CONSOLE)
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_CONSOLE
++#elif defined(LZO_INFO_OS_POSIX)
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS "." LZO_INFO_OS_POSIX
++#else
++# define __LZO_INFOSTR_OSNAME LZO_INFO_OS
++#endif
++#if defined(__LZO_INFOSTR_LIBC)
++#elif defined(LZO_INFO_LIBC)
++# define __LZO_INFOSTR_LIBC "." LZO_INFO_LIBC
++#else
++# define __LZO_INFOSTR_LIBC ""
++#endif
++#if defined(__LZO_INFOSTR_CCVER)
++#elif defined(LZO_INFO_CCVER)
++# define __LZO_INFOSTR_CCVER " " LZO_INFO_CCVER
++#else
++# define __LZO_INFOSTR_CCVER ""
++#endif
++#define LZO_INFO_STRING \
++ LZO_INFO_ARCH __LZO_INFOSTR_MM __LZO_INFOSTR_PM __LZO_INFOSTR_ENDIAN \
++ " " __LZO_INFOSTR_OSNAME __LZO_INFOSTR_LIBC " " LZO_INFO_CC __LZO_INFOSTR_CCVER
++
++#endif
++
++#endif
++
++#undef LZO_HAVE_CONFIG_H
++#include "minilzo.h"
++
++#if !defined(MINILZO_VERSION) || (MINILZO_VERSION != 0x2050)
++# error "version mismatch in miniLZO source files"
++#endif
++
++#ifdef MINILZO_HAVE_CONFIG_H
++# define LZO_HAVE_CONFIG_H 1
++#endif
++
++#ifndef __LZO_CONF_H
++#define __LZO_CONF_H 1
++
++#if !defined(__LZO_IN_MINILZO)
++#if (LZO_CFG_FREESTANDING)
++# define LZO_LIBC_FREESTANDING 1
++# define LZO_OS_FREESTANDING 1
++# define ACC_LIBC_FREESTANDING 1
++# define ACC_OS_FREESTANDING 1
++#endif
++#if (LZO_CFG_NO_UNALIGNED)
++# define ACC_CFG_NO_UNALIGNED 1
++#endif
++#if (LZO_ARCH_GENERIC)
++# define ACC_ARCH_GENERIC 1
++#endif
++#if (LZO_ABI_NEUTRAL_ENDIAN)
++# define ACC_ABI_NEUTRAL_ENDIAN 1
++#endif
++#if (LZO_HAVE_CONFIG_H)
++# define ACC_CONFIG_NO_HEADER 1
++#endif
++#if defined(LZO_CFG_EXTRA_CONFIG_HEADER)
++# include LZO_CFG_EXTRA_CONFIG_HEADER
++#endif
++#if defined(__LZOCONF_H) || defined(__LZOCONF_H_INCLUDED)
++# error "include this file first"
++#endif
++#include "lzo/lzoconf.h"
++#endif
++
++#if (LZO_VERSION < 0x02000) || !defined(__LZOCONF_H_INCLUDED)
++# error "version mismatch"
++#endif
++
++#if (LZO_CC_BORLANDC && LZO_ARCH_I086)
++# pragma option -h
++#endif
++
++#if (LZO_CC_MSC && (_MSC_VER >= 1000))
++# pragma warning(disable: 4127 4701)
++#endif
++#if (LZO_CC_MSC && (_MSC_VER >= 1300))
++# pragma warning(disable: 4820)
++# pragma warning(disable: 4514 4710 4711)
++#endif
++
++#if (LZO_CC_SUNPROC)
++#if !defined(__cplusplus)
++# pragma error_messages(off,E_END_OF_LOOP_CODE_NOT_REACHED)
++# pragma error_messages(off,E_LOOP_NOT_ENTERED_AT_TOP)
++# pragma error_messages(off,E_STATEMENT_NOT_REACHED)
++#endif
++#endif
++
++#if (__LZO_MMODEL_HUGE) && !(LZO_HAVE_MM_HUGE_PTR)
++# error "this should not happen - check defines for __huge"
++#endif
++
++#if defined(__LZO_IN_MINILZO) || defined(LZO_CFG_FREESTANDING)
++#elif (LZO_OS_DOS16 || LZO_OS_OS216 || LZO_OS_WIN16)
++# define ACC_WANT_ACC_INCD_H 1
++# define ACC_WANT_ACC_INCE_H 1
++# define ACC_WANT_ACC_INCI_H 1
++#elif 1
++# include <string.h>
++#else
++# define ACC_WANT_ACC_INCD_H 1
++#endif
++
++#if (LZO_ARCH_I086)
++# define ACC_MM_AHSHIFT LZO_MM_AHSHIFT
++# define ACC_PTR_FP_OFF(x) (((const unsigned __far*)&(x))[0])
++# define ACC_PTR_FP_SEG(x) (((const unsigned __far*)&(x))[1])
++# define ACC_PTR_MK_FP(s,o) ((void __far*)(((unsigned long)(s)<<16)+(unsigned)(o)))
++#endif
++
++#if !defined(lzo_uintptr_t)
++# if defined(__LZO_MMODEL_HUGE)
++# define lzo_uintptr_t unsigned long
++# elif 1 && defined(LZO_OS_OS400) && (LZO_SIZEOF_VOID_P == 16)
++# define __LZO_UINTPTR_T_IS_POINTER 1
++ typedef char* lzo_uintptr_t;
++# define lzo_uintptr_t lzo_uintptr_t
++# elif (LZO_SIZEOF_SIZE_T == LZO_SIZEOF_VOID_P)
++# define lzo_uintptr_t size_t
++# elif (LZO_SIZEOF_LONG == LZO_SIZEOF_VOID_P)
++# define lzo_uintptr_t unsigned long
++# elif (LZO_SIZEOF_INT == LZO_SIZEOF_VOID_P)
++# define lzo_uintptr_t unsigned int
++# elif (LZO_SIZEOF_LONG_LONG == LZO_SIZEOF_VOID_P)
++# define lzo_uintptr_t unsigned long long
++# else
++# define lzo_uintptr_t size_t
++# endif
++#endif
++LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))
++
++#if 1 && !defined(LZO_CFG_FREESTANDING)
++#if 1 && !defined(HAVE_STRING_H)
++#define HAVE_STRING_H 1
++#endif
++#if 1 && !defined(HAVE_MEMCMP)
++#define HAVE_MEMCMP 1
++#endif
++#if 1 && !defined(HAVE_MEMCPY)
++#define HAVE_MEMCPY 1
++#endif
++#if 1 && !defined(HAVE_MEMMOVE)
++#define HAVE_MEMMOVE 1
++#endif
++#if 1 && !defined(HAVE_MEMSET)
++#define HAVE_MEMSET 1
++#endif
++#endif
++
++#if 1 && defined(HAVE_STRING_H)
++#include <string.h>
++#endif
++
++#if (LZO_CFG_FREESTANDING)
++# undef HAVE_MEMCMP
++# undef HAVE_MEMCPY
++# undef HAVE_MEMMOVE
++# undef HAVE_MEMSET
++#endif
++
++#if !(HAVE_MEMCMP)
++# undef memcmp
++# define memcmp(a,b,c) lzo_memcmp(a,b,c)
++#elif !(__LZO_MMODEL_HUGE)
++# undef lzo_memcmp
++# define lzo_memcmp(a,b,c) memcmp(a,b,c)
++#endif
++#if !(HAVE_MEMCPY)
++# undef memcpy
++# define memcpy(a,b,c) lzo_memcpy(a,b,c)
++#elif !(__LZO_MMODEL_HUGE)
++# undef lzo_memcpy
++# define lzo_memcpy(a,b,c) memcpy(a,b,c)
++#endif
++#if !(HAVE_MEMMOVE)
++# undef memmove
++# define memmove(a,b,c) lzo_memmove(a,b,c)
++#elif !(__LZO_MMODEL_HUGE)
++# undef lzo_memmove
++# define lzo_memmove(a,b,c) memmove(a,b,c)
++#endif
++#if !(HAVE_MEMSET)
++# undef memset
++# define memset(a,b,c) lzo_memset(a,b,c)
++#elif !(__LZO_MMODEL_HUGE)
++# undef lzo_memset
++# define lzo_memset(a,b,c) memset(a,b,c)
++#endif
++
++#undef NDEBUG
++#if (LZO_CFG_FREESTANDING)
++# undef LZO_DEBUG
++# define NDEBUG 1
++# undef assert
++# define assert(e) ((void)0)
++#else
++# if !defined(LZO_DEBUG)
++# define NDEBUG 1
++# endif
++# include <assert.h>
++#endif
++
++#if 0 && defined(__BOUNDS_CHECKING_ON)
++# include <unchecked.h>
++#else
++# define BOUNDS_CHECKING_OFF_DURING(stmt) stmt
++# define BOUNDS_CHECKING_OFF_IN_EXPR(expr) (expr)
++#endif
++
++#if !defined(__lzo_inline)
++# define __lzo_inline /*empty*/
++#endif
++#if !defined(__lzo_forceinline)
++# define __lzo_forceinline /*empty*/
++#endif
++#if !defined(__lzo_noinline)
++# define __lzo_noinline /*empty*/
++#endif
++
++#if (LZO_CFG_PGO)
++# undef __acc_likely
++# undef __acc_unlikely
++# undef __lzo_likely
++# undef __lzo_unlikely
++# define __acc_likely(e) (e)
++# define __acc_unlikely(e) (e)
++# define __lzo_likely(e) (e)
++# define __lzo_unlikely(e) (e)
++#endif
++
++#if 1
++# define LZO_BYTE(x) ((unsigned char) (x))
++#else
++# define LZO_BYTE(x) ((unsigned char) ((x) & 0xff))
++#endif
++
++#define LZO_MAX(a,b) ((a) >= (b) ? (a) : (b))
++#define LZO_MIN(a,b) ((a) <= (b) ? (a) : (b))
++#define LZO_MAX3(a,b,c) ((a) >= (b) ? LZO_MAX(a,c) : LZO_MAX(b,c))
++#define LZO_MIN3(a,b,c) ((a) <= (b) ? LZO_MIN(a,c) : LZO_MIN(b,c))
++
++#define lzo_sizeof(type) ((lzo_uint) (sizeof(type)))
++
++#define LZO_HIGH(array) ((lzo_uint) (sizeof(array)/sizeof(*(array))))
++
++#define LZO_SIZE(bits) (1u << (bits))
++#define LZO_MASK(bits) (LZO_SIZE(bits) - 1)
++
++#define LZO_LSIZE(bits) (1ul << (bits))
++#define LZO_LMASK(bits) (LZO_LSIZE(bits) - 1)
++
++#define LZO_USIZE(bits) ((lzo_uint) 1 << (bits))
++#define LZO_UMASK(bits) (LZO_USIZE(bits) - 1)
++
++#if !defined(DMUL)
++#if 0
++
++# define DMUL(a,b) ((lzo_xint) ((lzo_uint32)(a) * (lzo_uint32)(b)))
++#else
++# define DMUL(a,b) ((lzo_xint) ((a) * (b)))
++#endif
++#endif
++
++#if 1 && (LZO_ARCH_AMD64 || LZO_ARCH_I386 || LZO_ARCH_POWERPC)
++# if (LZO_SIZEOF_SHORT == 2)
++# define LZO_UNALIGNED_OK_2 1
++# endif
++# if (LZO_SIZEOF_INT == 4)
++# define LZO_UNALIGNED_OK_4 1
++# endif
++#endif
++#if 1 && (LZO_ARCH_AMD64)
++# if defined(LZO_UINT64_MAX)
++# define LZO_UNALIGNED_OK_8 1
++# endif
++#endif
++#if (LZO_CFG_NO_UNALIGNED)
++# undef LZO_UNALIGNED_OK_2
++# undef LZO_UNALIGNED_OK_4
++# undef LZO_UNALIGNED_OK_8
++#endif
++
++#undef UA_GET16
++#undef UA_SET16
++#undef UA_COPY16
++#undef UA_GET32
++#undef UA_SET32
++#undef UA_COPY32
++#undef UA_GET64
++#undef UA_SET64
++#undef UA_COPY64
++#if defined(LZO_UNALIGNED_OK_2)
++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(unsigned short) == 2)
++# if 1 && defined(ACC_UA_COPY16)
++# define UA_GET16 ACC_UA_GET16
++# define UA_SET16 ACC_UA_SET16
++# define UA_COPY16 ACC_UA_COPY16
++# else
++# define UA_GET16(p) (* (__lzo_ua_volatile const lzo_ushortp) (__lzo_ua_volatile const lzo_voidp) (p))
++# define UA_SET16(p,v) ((* (__lzo_ua_volatile lzo_ushortp) (__lzo_ua_volatile lzo_voidp) (p)) = (unsigned short) (v))
++# define UA_COPY16(d,s) UA_SET16(d, UA_GET16(s))
++# endif
++#endif
++#if defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint32) == 4)
++# if 1 && defined(ACC_UA_COPY32)
++# define UA_GET32 ACC_UA_GET32
++# define UA_SET32 ACC_UA_SET32
++# define UA_COPY32 ACC_UA_COPY32
++# else
++# define UA_GET32(p) (* (__lzo_ua_volatile const lzo_uint32p) (__lzo_ua_volatile const lzo_voidp) (p))
++# define UA_SET32(p,v) ((* (__lzo_ua_volatile lzo_uint32p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint32) (v))
++# define UA_COPY32(d,s) UA_SET32(d, UA_GET32(s))
++# endif
++#endif
++#if defined(LZO_UNALIGNED_OK_8)
++ LZO_COMPILE_TIME_ASSERT_HEADER(sizeof(lzo_uint64) == 8)
++# if 1 && defined(ACC_UA_COPY64)
++# define UA_GET64 ACC_UA_GET64
++# define UA_SET64 ACC_UA_SET64
++# define UA_COPY64 ACC_UA_COPY64
++# else
++# define UA_GET64(p) (* (__lzo_ua_volatile const lzo_uint64p) (__lzo_ua_volatile const lzo_voidp) (p))
++# define UA_SET64(p,v) ((* (__lzo_ua_volatile lzo_uint64p) (__lzo_ua_volatile lzo_voidp) (p)) = (lzo_uint64) (v))
++# define UA_COPY64(d,s) UA_SET64(d, UA_GET64(s))
++# endif
++#endif
++
++#define MEMCPY8_DS(dest,src,len) \
++ lzo_memcpy(dest,src,len); dest += len; src += len
++
++#define BZERO8_PTR(s,l,n) \
++ lzo_memset((lzo_voidp)(s),0,(lzo_uint)(l)*(n))
++
++#define MEMCPY_DS(dest,src,len) \
++ do *dest++ = *src++; while (--len > 0)
++
++LZO_EXTERN(const lzo_bytep) lzo_copyright(void);
++
++#ifndef __LZO_PTR_H
++#define __LZO_PTR_H 1
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#if !defined(lzo_uintptr_t)
++# if (__LZO_MMODEL_HUGE)
++# define lzo_uintptr_t unsigned long
++# else
++# define lzo_uintptr_t acc_uintptr_t
++# ifdef __ACC_INTPTR_T_IS_POINTER
++# define __LZO_UINTPTR_T_IS_POINTER 1
++# endif
++# endif
++#endif
++
++#if (LZO_ARCH_I086)
++#define PTR(a) ((lzo_bytep) (a))
++#define PTR_ALIGNED_4(a) ((ACC_PTR_FP_OFF(a) & 3) == 0)
++#define PTR_ALIGNED2_4(a,b) (((ACC_PTR_FP_OFF(a) | ACC_PTR_FP_OFF(b)) & 3) == 0)
++#elif (LZO_MM_PVP)
++#define PTR(a) ((lzo_bytep) (a))
++#define PTR_ALIGNED_8(a) ((((lzo_uintptr_t)(a)) >> 61) == 0)
++#define PTR_ALIGNED2_8(a,b) ((((lzo_uintptr_t)(a)|(lzo_uintptr_t)(b)) >> 61) == 0)
++#else
++#define PTR(a) ((lzo_uintptr_t) (a))
++#define PTR_LINEAR(a) PTR(a)
++#define PTR_ALIGNED_4(a) ((PTR_LINEAR(a) & 3) == 0)
++#define PTR_ALIGNED_8(a) ((PTR_LINEAR(a) & 7) == 0)
++#define PTR_ALIGNED2_4(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 3) == 0)
++#define PTR_ALIGNED2_8(a,b) (((PTR_LINEAR(a) | PTR_LINEAR(b)) & 7) == 0)
++#endif
++
++#define PTR_LT(a,b) (PTR(a) < PTR(b))
++#define PTR_GE(a,b) (PTR(a) >= PTR(b))
++#define PTR_DIFF(a,b) (PTR(a) - PTR(b))
++#define pd(a,b) ((lzo_uint) ((a)-(b)))
++
++LZO_EXTERN(lzo_uintptr_t)
++__lzo_ptr_linear(const lzo_voidp ptr);
++
++typedef union
++{
++ char a_char;
++ unsigned char a_uchar;
++ short a_short;
++ unsigned short a_ushort;
++ int a_int;
++ unsigned int a_uint;
++ long a_long;
++ unsigned long a_ulong;
++ lzo_int a_lzo_int;
++ lzo_uint a_lzo_uint;
++ lzo_int32 a_lzo_int32;
++ lzo_uint32 a_lzo_uint32;
++#if defined(LZO_UINT64_MAX)
++ lzo_int64 a_lzo_int64;
++ lzo_uint64 a_lzo_uint64;
++#endif
++ ptrdiff_t a_ptrdiff_t;
++ lzo_uintptr_t a_lzo_uintptr_t;
++ lzo_voidp a_lzo_voidp;
++ void * a_void_p;
++ lzo_bytep a_lzo_bytep;
++ lzo_bytepp a_lzo_bytepp;
++ lzo_uintp a_lzo_uintp;
++ lzo_uint * a_lzo_uint_p;
++ lzo_uint32p a_lzo_uint32p;
++ lzo_uint32 * a_lzo_uint32_p;
++ unsigned char * a_uchar_p;
++ char * a_char_p;
++}
++lzo_full_align_t;
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++#ifndef LZO_DETERMINISTIC
++#define LZO_DETERMINISTIC 1
++#endif
++
++#ifndef LZO_DICT_USE_PTR
++#define LZO_DICT_USE_PTR 1
++#if 0 && (LZO_ARCH_I086)
++# undef LZO_DICT_USE_PTR
++# define LZO_DICT_USE_PTR 0
++#endif
++#endif
++
++#if (LZO_DICT_USE_PTR)
++# define lzo_dict_t const lzo_bytep
++# define lzo_dict_p lzo_dict_t __LZO_MMODEL *
++#else
++# define lzo_dict_t lzo_uint
++# define lzo_dict_p lzo_dict_t __LZO_MMODEL *
++#endif
++
++#endif
++
++#if !defined(MINILZO_CFG_SKIP_LZO_PTR)
++
++LZO_PUBLIC(lzo_uintptr_t)
++__lzo_ptr_linear(const lzo_voidp ptr)
++{
++ lzo_uintptr_t p;
++
++#if (LZO_ARCH_I086)
++ p = (((lzo_uintptr_t)(ACC_PTR_FP_SEG(ptr))) << (16 - ACC_MM_AHSHIFT)) + (ACC_PTR_FP_OFF(ptr));
++#elif (LZO_MM_PVP)
++ p = (lzo_uintptr_t) (ptr);
++ p = (p << 3) | (p >> 61);
++#else
++ p = (lzo_uintptr_t) PTR_LINEAR(ptr);
++#endif
++
++ return p;
++}
++
++LZO_PUBLIC(unsigned)
++__lzo_align_gap(const lzo_voidp ptr, lzo_uint size)
++{
++#if defined(__LZO_UINTPTR_T_IS_POINTER)
++ size_t n = (size_t) ptr;
++ n = (((n + size - 1) / size) * size) - n;
++#else
++ lzo_uintptr_t p, n;
++ p = __lzo_ptr_linear(ptr);
++ n = (((p + size - 1) / size) * size) - p;
++#endif
++
++ assert(size > 0);
++ assert((long)n >= 0);
++ assert(n <= size);
++ return (unsigned)n;
++}
++
++#endif
++#if !defined(MINILZO_CFG_SKIP_LZO_UTIL)
++
++/* If you use the LZO library in a product, I would appreciate that you
++ * keep this copyright string in the executable of your product.
++ */
++
++static const char __lzo_copyright[] =
++#if !defined(__LZO_IN_MINLZO)
++ LZO_VERSION_STRING;
++#else
++ "\r\n\n"
++ "LZO data compression library.\n"
++ "$Copyright: LZO Copyright (C) 1996-2011 Markus Franz Xaver Johannes Oberhumer\n"
++ "<markus@oberhumer.com>\n"
++ "http://www.oberhumer.com $\n\n"
++ "$Id: LZO version: v" LZO_VERSION_STRING ", " LZO_VERSION_DATE " $\n"
++ "$Info: " LZO_INFO_STRING " $\n";
++#endif
++
++LZO_PUBLIC(const lzo_bytep)
++lzo_copyright(void)
++{
++#if (LZO_OS_DOS16 && LZO_CC_TURBOC)
++ return (lzo_voidp) __lzo_copyright;
++#else
++ return (const lzo_bytep) __lzo_copyright;
++#endif
++}
++
++LZO_PUBLIC(unsigned)
++lzo_version(void)
++{
++ return LZO_VERSION;
++}
++
++LZO_PUBLIC(const char *)
++lzo_version_string(void)
++{
++ return LZO_VERSION_STRING;
++}
++
++LZO_PUBLIC(const char *)
++lzo_version_date(void)
++{
++ return LZO_VERSION_DATE;
++}
++
++LZO_PUBLIC(const lzo_charp)
++_lzo_version_string(void)
++{
++ return LZO_VERSION_STRING;
++}
++
++LZO_PUBLIC(const lzo_charp)
++_lzo_version_date(void)
++{
++ return LZO_VERSION_DATE;
++}
++
++#define LZO_BASE 65521u
++#define LZO_NMAX 5552
++
++#define LZO_DO1(buf,i) s1 += buf[i]; s2 += s1
++#define LZO_DO2(buf,i) LZO_DO1(buf,i); LZO_DO1(buf,i+1);
++#define LZO_DO4(buf,i) LZO_DO2(buf,i); LZO_DO2(buf,i+2);
++#define LZO_DO8(buf,i) LZO_DO4(buf,i); LZO_DO4(buf,i+4);
++#define LZO_DO16(buf,i) LZO_DO8(buf,i); LZO_DO8(buf,i+8);
++
++LZO_PUBLIC(lzo_uint32)
++lzo_adler32(lzo_uint32 adler, const lzo_bytep buf, lzo_uint len)
++{
++ lzo_uint32 s1 = adler & 0xffff;
++ lzo_uint32 s2 = (adler >> 16) & 0xffff;
++ unsigned k;
++
++ if (buf == NULL)
++ return 1;
++
++ while (len > 0)
++ {
++ k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
++ len -= k;
++ if (k >= 16) do
++ {
++ LZO_DO16(buf,0);
++ buf += 16;
++ k -= 16;
++ } while (k >= 16);
++ if (k != 0) do
++ {
++ s1 += *buf++;
++ s2 += s1;
++ } while (--k > 0);
++ s1 %= LZO_BASE;
++ s2 %= LZO_BASE;
++ }
++ return (s2 << 16) | s1;
++}
++
++#undef LZO_DO1
++#undef LZO_DO2
++#undef LZO_DO4
++#undef LZO_DO8
++#undef LZO_DO16
++
++#endif
++#if !defined(MINILZO_CFG_SKIP_LZO_STRING)
++#undef lzo_memcmp
++#undef lzo_memcpy
++#undef lzo_memmove
++#undef lzo_memset
++#if !defined(__LZO_MMODEL_HUGE)
++# undef LZO_HAVE_MM_HUGE_PTR
++#endif
++#define lzo_hsize_t lzo_uint
++#define lzo_hvoid_p lzo_voidp
++#define lzo_hbyte_p lzo_bytep
++#define LZOLIB_PUBLIC(r,f) LZO_PUBLIC(r) f
++#define lzo_hmemcmp lzo_memcmp
++#define lzo_hmemcpy lzo_memcpy
++#define lzo_hmemmove lzo_memmove
++#define lzo_hmemset lzo_memset
++#define __LZOLIB_HMEMCPY_CH_INCLUDED 1
++#if !defined(LZOLIB_PUBLIC)
++# define LZOLIB_PUBLIC(r,f) r __LZOLIB_FUNCNAME(f)
++#endif
++LZOLIB_PUBLIC(int, lzo_hmemcmp) (const lzo_hvoid_p s1, const lzo_hvoid_p s2, lzo_hsize_t len)
++{
++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCMP)
++ const lzo_hbyte_p p1 = (const lzo_hbyte_p) s1;
++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) s2;
++ if __lzo_likely(len > 0) do
++ {
++ int d = *p1 - *p2;
++ if (d != 0)
++ return d;
++ p1++; p2++;
++ } while __lzo_likely(--len > 0);
++ return 0;
++#else
++ return memcmp(s1, s2, len);
++#endif
++}
++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemcpy) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len)
++{
++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMCPY)
++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest;
++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src;
++ if (!(len > 0) || p1 == p2)
++ return dest;
++ do
++ *p1++ = *p2++;
++ while __lzo_likely(--len > 0);
++ return dest;
++#else
++ return memcpy(dest, src, len);
++#endif
++}
++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemmove) (lzo_hvoid_p dest, const lzo_hvoid_p src, lzo_hsize_t len)
++{
++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMMOVE)
++ lzo_hbyte_p p1 = (lzo_hbyte_p) dest;
++ const lzo_hbyte_p p2 = (const lzo_hbyte_p) src;
++ if (!(len > 0) || p1 == p2)
++ return dest;
++ if (p1 < p2)
++ {
++ do
++ *p1++ = *p2++;
++ while __lzo_likely(--len > 0);
++ }
++ else
++ {
++ p1 += len;
++ p2 += len;
++ do
++ *--p1 = *--p2;
++ while __lzo_likely(--len > 0);
++ }
++ return dest;
++#else
++ return memmove(dest, src, len);
++#endif
++}
++LZOLIB_PUBLIC(lzo_hvoid_p, lzo_hmemset) (lzo_hvoid_p s, int c, lzo_hsize_t len)
++{
++#if (LZO_HAVE_MM_HUGE_PTR) || !(HAVE_MEMSET)
++ lzo_hbyte_p p = (lzo_hbyte_p) s;
++ if __lzo_likely(len > 0) do
++ *p++ = (unsigned char) c;
++ while __lzo_likely(--len > 0);
++ return s;
++#else
++ return memset(s, c, len);
++#endif
++}
++#undef LZOLIB_PUBLIC
++#endif
++#if !defined(MINILZO_CFG_SKIP_LZO_INIT)
++
++#if !defined(__LZO_IN_MINILZO)
++
++#define ACC_WANT_ACC_CHK_CH 1
++#undef ACCCHK_ASSERT
++
++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int)
++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint)
++
++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int32)
++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint32)
++ ACCCHK_ASSERT((LZO_UINT32_C(1) << (int)(8*sizeof(LZO_UINT32_C(1))-1)) > 0)
++ ACCCHK_ASSERT(sizeof(lzo_uint32) >= 4)
++#if defined(LZO_UINT64_MAX)
++ ACCCHK_ASSERT(sizeof(lzo_uint64) == 8)
++ ACCCHK_ASSERT_IS_SIGNED_T(lzo_int64)
++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uint64)
++#endif
++
++#if !defined(__LZO_UINTPTR_T_IS_POINTER)
++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_uintptr_t)
++#endif
++ ACCCHK_ASSERT(sizeof(lzo_uintptr_t) >= sizeof(lzo_voidp))
++
++ ACCCHK_ASSERT_IS_UNSIGNED_T(lzo_xint)
++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint32))
++ ACCCHK_ASSERT(sizeof(lzo_xint) >= sizeof(lzo_uint))
++ ACCCHK_ASSERT(sizeof(lzo_xint) == sizeof(lzo_uint32) || sizeof(lzo_xint) == sizeof(lzo_uint))
++
++#endif
++#undef ACCCHK_ASSERT
++
++#if 0
++#define WANT_lzo_bitops_clz32 1
++#define WANT_lzo_bitops_clz64 1
++#endif
++#define WANT_lzo_bitops_ctz32 1
++#define WANT_lzo_bitops_ctz64 1
++
++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400)))
++#include <intrin.h>
++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0
++#pragma intrinsic(_BitScanReverse)
++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v)
++{
++ unsigned long r;
++ (void) _BitScanReverse(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_clz32 lzo_bitops_clz32
++#endif
++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0
++#pragma intrinsic(_BitScanReverse64)
++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v)
++{
++ unsigned long r;
++ (void) _BitScanReverse64(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_clz64 lzo_bitops_clz64
++#endif
++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32)
++#pragma intrinsic(_BitScanForward)
++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v)
++{
++ unsigned long r;
++ (void) _BitScanForward(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_ctz32 lzo_bitops_ctz32
++#endif
++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX)
++#pragma intrinsic(_BitScanForward64)
++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v)
++{
++ unsigned long r;
++ (void) _BitScanForward64(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_ctz64 lzo_bitops_ctz64
++#endif
++
++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM)
++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32)
++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v))
++#endif
++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v))
++#endif
++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32)
++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v))
++#endif
++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v))
++#endif
++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32)
++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v))
++#endif
++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v))
++#endif
++#endif
++
++#if 0
++#define u2p(ptr,off) ((lzo_voidp) (((lzo_bytep)(lzo_voidp)(ptr)) + (off)))
++#else
++static __lzo_noinline lzo_voidp u2p(lzo_voidp ptr, lzo_uint off)
++{
++ return (lzo_voidp) ((lzo_bytep) ptr + off);
++}
++#endif
++
++LZO_PUBLIC(int)
++_lzo_config_check(void)
++{
++ lzo_bool r = 1;
++ union {
++ lzo_xint a[2]; unsigned char b[2*LZO_MAX(8,sizeof(lzo_xint))];
++#if defined(LZO_UNALIGNED_OK_8)
++ lzo_uint64 c[2];
++#endif
++ unsigned short x[2]; lzo_uint32 y[2]; lzo_uint z[2];
++ } u;
++ lzo_voidp p;
++
++ u.a[0] = u.a[1] = 0;
++ p = u2p(&u, 0);
++ r &= ((* (lzo_bytep) p) == 0);
++#if !defined(LZO_CFG_NO_CONFIG_CHECK)
++#if defined(LZO_ABI_BIG_ENDIAN)
++ u.a[0] = u.a[1] = 0; u.b[sizeof(lzo_uint) - 1] = 128;
++ p = u2p(&u, 0);
++ r &= ((* (lzo_uintp) p) == 128);
++#endif
++#if defined(LZO_ABI_LITTLE_ENDIAN)
++ u.a[0] = u.a[1] = 0; u.b[0] = 128;
++ p = u2p(&u, 0);
++ r &= ((* (lzo_uintp) p) == 128);
++#endif
++#if defined(LZO_UNALIGNED_OK_2)
++ u.a[0] = u.a[1] = 0;
++ u.b[0] = 1; u.b[sizeof(unsigned short) + 1] = 2;
++ p = u2p(&u, 1);
++ r &= ((* (lzo_ushortp) p) == 0);
++#endif
++#if defined(LZO_UNALIGNED_OK_4)
++ u.a[0] = u.a[1] = 0;
++ u.b[0] = 3; u.b[sizeof(lzo_uint32) + 1] = 4;
++ p = u2p(&u, 1);
++ r &= ((* (lzo_uint32p) p) == 0);
++#endif
++#if defined(LZO_UNALIGNED_OK_8)
++ u.c[0] = u.c[1] = 0;
++ u.b[0] = 5; u.b[sizeof(lzo_uint64) + 1] = 6;
++ p = u2p(&u, 1);
++ r &= ((* (lzo_uint64p) p) == 0);
++#endif
++#if defined(lzo_bitops_clz32)
++ { unsigned i; lzo_uint32 v = 1;
++ for (i = 0; i < 31; i++, v <<= 1)
++ r &= lzo_bitops_clz32(v) == 31 - i;
++ }
++#endif
++#if defined(lzo_bitops_clz64)
++ { unsigned i; lzo_uint64 v = 1;
++ for (i = 0; i < 63; i++, v <<= 1)
++ r &= lzo_bitops_clz64(v) == 63 - i;
++ }
++#endif
++#if defined(lzo_bitops_ctz32)
++ { unsigned i; lzo_uint32 v = 1;
++ for (i = 0; i < 31; i++, v <<= 1)
++ r &= lzo_bitops_ctz32(v) == i;
++ }
++#endif
++#if defined(lzo_bitops_ctz64)
++ { unsigned i; lzo_uint64 v = 1;
++ for (i = 0; i < 63; i++, v <<= 1)
++ r &= lzo_bitops_ctz64(v) == i;
++ }
++#endif
++#endif
++
++ return r == 1 ? LZO_E_OK : LZO_E_ERROR;
++}
++
++LZO_PUBLIC(int)
++__lzo_init_v2(unsigned v, int s1, int s2, int s3, int s4, int s5,
++ int s6, int s7, int s8, int s9)
++{
++ int r;
++
++#if defined(__LZO_IN_MINILZO)
++#elif (LZO_CC_MSC && ((_MSC_VER) < 700))
++#else
++#define ACC_WANT_ACC_CHK_CH 1
++#undef ACCCHK_ASSERT
++#define ACCCHK_ASSERT(expr) LZO_COMPILE_TIME_ASSERT(expr)
++#endif
++#undef ACCCHK_ASSERT
++
++ if (v == 0)
++ return LZO_E_ERROR;
++
++ r = (s1 == -1 || s1 == (int) sizeof(short)) &&
++ (s2 == -1 || s2 == (int) sizeof(int)) &&
++ (s3 == -1 || s3 == (int) sizeof(long)) &&
++ (s4 == -1 || s4 == (int) sizeof(lzo_uint32)) &&
++ (s5 == -1 || s5 == (int) sizeof(lzo_uint)) &&
++ (s6 == -1 || s6 == (int) lzo_sizeof_dict_t) &&
++ (s7 == -1 || s7 == (int) sizeof(char *)) &&
++ (s8 == -1 || s8 == (int) sizeof(lzo_voidp)) &&
++ (s9 == -1 || s9 == (int) sizeof(lzo_callback_t));
++ if (!r)
++ return LZO_E_ERROR;
++
++ r = _lzo_config_check();
++ if (r != LZO_E_OK)
++ return r;
++
++ return r;
++}
++
++#if !defined(__LZO_IN_MINILZO)
++
++#if (LZO_OS_WIN16 && LZO_CC_WATCOMC) && defined(__SW_BD)
++
++#if 0
++BOOL FAR PASCAL LibMain ( HANDLE hInstance, WORD wDataSegment,
++ WORD wHeapSize, LPSTR lpszCmdLine )
++#else
++int __far __pascal LibMain ( int a, short b, short c, long d )
++#endif
++{
++ LZO_UNUSED(a); LZO_UNUSED(b); LZO_UNUSED(c); LZO_UNUSED(d);
++ return 1;
++}
++
++#endif
++
++#endif
++
++#endif
++
++#define LZO1X 1
++#define LZO_EOF_CODE 1
++#define M2_MAX_OFFSET 0x0800
++
++#if !defined(MINILZO_CFG_SKIP_LZO1X_1_COMPRESS)
++
++#if 1 && defined(UA_GET32)
++#undef LZO_DICT_USE_PTR
++#define LZO_DICT_USE_PTR 0
++#undef lzo_dict_t
++#define lzo_dict_t unsigned short
++#endif
++
++#define LZO_NEED_DICT_H 1
++#ifndef D_BITS
++#define D_BITS 14
++#endif
++#define D_INDEX1(d,p) d = DM(DMUL(0x21,DX3(p,5,5,6)) >> 5)
++#define D_INDEX2(d,p) d = (d & (D_MASK & 0x7ff)) ^ (D_HIGH | 0x1f)
++#if 1
++#define DINDEX(dv,p) DM(((DMUL(0x1824429d,dv)) >> (32-D_BITS)))
++#else
++#define DINDEX(dv,p) DM((dv) + ((dv) >> (32-D_BITS)))
++#endif
++
++#ifndef __LZO_CONFIG1X_H
++#define __LZO_CONFIG1X_H 1
++
++#if !defined(LZO1X) && !defined(LZO1Y) && !defined(LZO1Z)
++# define LZO1X 1
++#endif
++
++#if !defined(__LZO_IN_MINILZO)
++#include "lzo/lzo1x.h"
++#endif
++
++#ifndef LZO_EOF_CODE
++#define LZO_EOF_CODE 1
++#endif
++#undef LZO_DETERMINISTIC
++
++#define M1_MAX_OFFSET 0x0400
++#ifndef M2_MAX_OFFSET
++#define M2_MAX_OFFSET 0x0800
++#endif
++#define M3_MAX_OFFSET 0x4000
++#define M4_MAX_OFFSET 0xbfff
++
++#define MX_MAX_OFFSET (M1_MAX_OFFSET + M2_MAX_OFFSET)
++
++#define M1_MIN_LEN 2
++#define M1_MAX_LEN 2
++#define M2_MIN_LEN 3
++#ifndef M2_MAX_LEN
++#define M2_MAX_LEN 8
++#endif
++#define M3_MIN_LEN 3
++#define M3_MAX_LEN 33
++#define M4_MIN_LEN 3
++#define M4_MAX_LEN 9
++
++#define M1_MARKER 0
++#define M2_MARKER 64
++#define M3_MARKER 32
++#define M4_MARKER 16
++
++#ifndef MIN_LOOKAHEAD
++#define MIN_LOOKAHEAD (M2_MAX_LEN + 1)
++#endif
++
++#if defined(LZO_NEED_DICT_H)
++
++#ifndef LZO_HASH
++#define LZO_HASH LZO_HASH_LZO_INCREMENTAL_B
++#endif
++#define DL_MIN_LEN M2_MIN_LEN
++
++#ifndef __LZO_DICT_H
++#define __LZO_DICT_H 1
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#if !defined(D_BITS) && defined(DBITS)
++# define D_BITS DBITS
++#endif
++#if !defined(D_BITS)
++# error "D_BITS is not defined"
++#endif
++#if (D_BITS < 16)
++# define D_SIZE LZO_SIZE(D_BITS)
++# define D_MASK LZO_MASK(D_BITS)
++#else
++# define D_SIZE LZO_USIZE(D_BITS)
++# define D_MASK LZO_UMASK(D_BITS)
++#endif
++#define D_HIGH ((D_MASK >> 1) + 1)
++
++#if !defined(DD_BITS)
++# define DD_BITS 0
++#endif
++#define DD_SIZE LZO_SIZE(DD_BITS)
++#define DD_MASK LZO_MASK(DD_BITS)
++
++#if !defined(DL_BITS)
++# define DL_BITS (D_BITS - DD_BITS)
++#endif
++#if (DL_BITS < 16)
++# define DL_SIZE LZO_SIZE(DL_BITS)
++# define DL_MASK LZO_MASK(DL_BITS)
++#else
++# define DL_SIZE LZO_USIZE(DL_BITS)
++# define DL_MASK LZO_UMASK(DL_BITS)
++#endif
++
++#if (D_BITS != DL_BITS + DD_BITS)
++# error "D_BITS does not match"
++#endif
++#if (D_BITS < 6 || D_BITS > 18)
++# error "invalid D_BITS"
++#endif
++#if (DL_BITS < 6 || DL_BITS > 20)
++# error "invalid DL_BITS"
++#endif
++#if (DD_BITS < 0 || DD_BITS > 6)
++# error "invalid DD_BITS"
++#endif
++
++#if !defined(DL_MIN_LEN)
++# define DL_MIN_LEN 3
++#endif
++#if !defined(DL_SHIFT)
++# define DL_SHIFT ((DL_BITS + (DL_MIN_LEN - 1)) / DL_MIN_LEN)
++#endif
++
++#define LZO_HASH_GZIP 1
++#define LZO_HASH_GZIP_INCREMENTAL 2
++#define LZO_HASH_LZO_INCREMENTAL_A 3
++#define LZO_HASH_LZO_INCREMENTAL_B 4
++
++#if !defined(LZO_HASH)
++# error "choose a hashing strategy"
++#endif
++
++#undef DM
++#undef DX
++
++#if (DL_MIN_LEN == 3)
++# define _DV2_A(p,shift1,shift2) \
++ (((( (lzo_xint)((p)[0]) << shift1) ^ (p)[1]) << shift2) ^ (p)[2])
++# define _DV2_B(p,shift1,shift2) \
++ (((( (lzo_xint)((p)[2]) << shift1) ^ (p)[1]) << shift2) ^ (p)[0])
++# define _DV3_B(p,shift1,shift2,shift3) \
++ ((_DV2_B((p)+1,shift1,shift2) << (shift3)) ^ (p)[0])
++#elif (DL_MIN_LEN == 2)
++# define _DV2_A(p,shift1,shift2) \
++ (( (lzo_xint)(p[0]) << shift1) ^ p[1])
++# define _DV2_B(p,shift1,shift2) \
++ (( (lzo_xint)(p[1]) << shift1) ^ p[2])
++#else
++# error "invalid DL_MIN_LEN"
++#endif
++#define _DV_A(p,shift) _DV2_A(p,shift,shift)
++#define _DV_B(p,shift) _DV2_B(p,shift,shift)
++#define DA2(p,s1,s2) \
++ (((((lzo_xint)((p)[2]) << (s2)) + (p)[1]) << (s1)) + (p)[0])
++#define DS2(p,s1,s2) \
++ (((((lzo_xint)((p)[2]) << (s2)) - (p)[1]) << (s1)) - (p)[0])
++#define DX2(p,s1,s2) \
++ (((((lzo_xint)((p)[2]) << (s2)) ^ (p)[1]) << (s1)) ^ (p)[0])
++#define DA3(p,s1,s2,s3) ((DA2((p)+1,s2,s3) << (s1)) + (p)[0])
++#define DS3(p,s1,s2,s3) ((DS2((p)+1,s2,s3) << (s1)) - (p)[0])
++#define DX3(p,s1,s2,s3) ((DX2((p)+1,s2,s3) << (s1)) ^ (p)[0])
++#define DMS(v,s) ((lzo_uint) (((v) & (D_MASK >> (s))) << (s)))
++#define DM(v) DMS(v,0)
++
++#if (LZO_HASH == LZO_HASH_GZIP)
++# define _DINDEX(dv,p) (_DV_A((p),DL_SHIFT))
++
++#elif (LZO_HASH == LZO_HASH_GZIP_INCREMENTAL)
++# define __LZO_HASH_INCREMENTAL 1
++# define DVAL_FIRST(dv,p) dv = _DV_A((p),DL_SHIFT)
++# define DVAL_NEXT(dv,p) dv = (((dv) << DL_SHIFT) ^ p[2])
++# define _DINDEX(dv,p) (dv)
++# define DVAL_LOOKAHEAD DL_MIN_LEN
++
++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_A)
++# define __LZO_HASH_INCREMENTAL 1
++# define DVAL_FIRST(dv,p) dv = _DV_A((p),5)
++# define DVAL_NEXT(dv,p) \
++ dv ^= (lzo_xint)(p[-1]) << (2*5); dv = (((dv) << 5) ^ p[2])
++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5)
++# define DVAL_LOOKAHEAD DL_MIN_LEN
++
++#elif (LZO_HASH == LZO_HASH_LZO_INCREMENTAL_B)
++# define __LZO_HASH_INCREMENTAL 1
++# define DVAL_FIRST(dv,p) dv = _DV_B((p),5)
++# define DVAL_NEXT(dv,p) \
++ dv ^= p[-1]; dv = (((dv) >> 5) ^ ((lzo_xint)(p[2]) << (2*5)))
++# define _DINDEX(dv,p) ((DMUL(0x9f5f,dv)) >> 5)
++# define DVAL_LOOKAHEAD DL_MIN_LEN
++
++#else
++# error "choose a hashing strategy"
++#endif
++
++#ifndef DINDEX
++#define DINDEX(dv,p) ((lzo_uint)((_DINDEX(dv,p)) & DL_MASK) << DD_BITS)
++#endif
++#if !defined(DINDEX1) && defined(D_INDEX1)
++#define DINDEX1 D_INDEX1
++#endif
++#if !defined(DINDEX2) && defined(D_INDEX2)
++#define DINDEX2 D_INDEX2
++#endif
++
++#if !defined(__LZO_HASH_INCREMENTAL)
++# define DVAL_FIRST(dv,p) ((void) 0)
++# define DVAL_NEXT(dv,p) ((void) 0)
++# define DVAL_LOOKAHEAD 0
++#endif
++
++#if !defined(DVAL_ASSERT)
++#if defined(__LZO_HASH_INCREMENTAL) && !defined(NDEBUG)
++#if (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x020700ul) || LZO_CC_LLVM)
++static void __attribute__((__unused__))
++#else
++static void
++#endif
++DVAL_ASSERT(lzo_xint dv, const lzo_bytep p)
++{
++ lzo_xint df;
++ DVAL_FIRST(df,(p));
++ assert(DINDEX(dv,p) == DINDEX(df,p));
++}
++#else
++# define DVAL_ASSERT(dv,p) ((void) 0)
++#endif
++#endif
++
++#if (LZO_DICT_USE_PTR)
++# define DENTRY(p,in) (p)
++# define GINDEX(m_pos,m_off,dict,dindex,in) m_pos = dict[dindex]
++#else
++# define DENTRY(p,in) ((lzo_dict_t) pd(p, in))
++# define GINDEX(m_pos,m_off,dict,dindex,in) m_off = dict[dindex]
++#endif
++
++#if (DD_BITS == 0)
++
++# define UPDATE_D(dict,drun,dv,p,in) dict[ DINDEX(dv,p) ] = DENTRY(p,in)
++# define UPDATE_I(dict,drun,index,p,in) dict[index] = DENTRY(p,in)
++# define UPDATE_P(ptr,drun,p,in) (ptr)[0] = DENTRY(p,in)
++
++#else
++
++# define UPDATE_D(dict,drun,dv,p,in) \
++ dict[ DINDEX(dv,p) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
++# define UPDATE_I(dict,drun,index,p,in) \
++ dict[ (index) + drun++ ] = DENTRY(p,in); drun &= DD_MASK
++# define UPDATE_P(ptr,drun,p,in) \
++ (ptr) [ drun++ ] = DENTRY(p,in); drun &= DD_MASK
++
++#endif
++
++#if (LZO_DICT_USE_PTR)
++
++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
++ (m_pos == NULL || (m_off = pd(ip, m_pos)) > max_offset)
++
++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
++ (BOUNDS_CHECKING_OFF_IN_EXPR(( \
++ m_pos = ip - (lzo_uint) PTR_DIFF(ip,m_pos), \
++ PTR_LT(m_pos,in) || \
++ (m_off = (lzo_uint) PTR_DIFF(ip,m_pos)) == 0 || \
++ m_off > max_offset )))
++
++#else
++
++#define LZO_CHECK_MPOS_DET(m_pos,m_off,in,ip,max_offset) \
++ (m_off == 0 || \
++ ((m_off = pd(ip, in) - m_off) > max_offset) || \
++ (m_pos = (ip) - (m_off), 0) )
++
++#define LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,max_offset) \
++ (pd(ip, in) <= m_off || \
++ ((m_off = pd(ip, in) - m_off) > max_offset) || \
++ (m_pos = (ip) - (m_off), 0) )
++
++#endif
++
++#if (LZO_DETERMINISTIC)
++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_DET
++#else
++# define LZO_CHECK_MPOS LZO_CHECK_MPOS_NON_DET
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
++
++#endif
++
++#endif
++
++#define LZO_DETERMINISTIC !(LZO_DICT_USE_PTR)
++
++#ifndef DO_COMPRESS
++#define DO_COMPRESS lzo1x_1_compress
++#endif
++
++#if 1 && defined(DO_COMPRESS) && !defined(do_compress)
++# define do_compress LZO_CPP_ECONCAT2(DO_COMPRESS,_core)
++#endif
++
++#if defined(UA_GET64)
++# define WANT_lzo_bitops_ctz64 1
++#elif defined(UA_GET32)
++# define WANT_lzo_bitops_ctz32 1
++#endif
++
++#if (defined(_WIN32) || defined(_WIN64)) && ((LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || (LZO_CC_MSC && (_MSC_VER >= 1400)))
++#include <intrin.h>
++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32) && 0
++#pragma intrinsic(_BitScanReverse)
++static __lzo_inline unsigned lzo_bitops_clz32(lzo_uint32 v)
++{
++ unsigned long r;
++ (void) _BitScanReverse(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_clz32 lzo_bitops_clz32
++#endif
++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX) && 0
++#pragma intrinsic(_BitScanReverse64)
++static __lzo_inline unsigned lzo_bitops_clz64(lzo_uint64 v)
++{
++ unsigned long r;
++ (void) _BitScanReverse64(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_clz64 lzo_bitops_clz64
++#endif
++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32)
++#pragma intrinsic(_BitScanForward)
++static __lzo_inline unsigned lzo_bitops_ctz32(lzo_uint32 v)
++{
++ unsigned long r;
++ (void) _BitScanForward(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_ctz32 lzo_bitops_ctz32
++#endif
++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX)
++#pragma intrinsic(_BitScanForward64)
++static __lzo_inline unsigned lzo_bitops_ctz64(lzo_uint64 v)
++{
++ unsigned long r;
++ (void) _BitScanForward64(&r, v);
++ return (unsigned) r;
++}
++#define lzo_bitops_ctz64 lzo_bitops_ctz64
++#endif
++
++#elif (LZO_CC_CLANG || (LZO_CC_GNUC >= 0x030400ul) || (LZO_CC_INTELC && (__INTEL_COMPILER >= 1000)) || LZO_CC_LLVM)
++#if !defined(lzo_bitops_clz32) && defined(WANT_lzo_bitops_clz32)
++#define lzo_bitops_clz32(v) ((unsigned) __builtin_clz(v))
++#endif
++#if !defined(lzo_bitops_clz64) && defined(WANT_lzo_bitops_clz64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_clz64(v) ((unsigned) __builtin_clzll(v))
++#endif
++#if !defined(lzo_bitops_ctz32) && defined(WANT_lzo_bitops_ctz32)
++#define lzo_bitops_ctz32(v) ((unsigned) __builtin_ctz(v))
++#endif
++#if !defined(lzo_bitops_ctz64) && defined(WANT_lzo_bitops_ctz64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_ctz64(v) ((unsigned) __builtin_ctzll(v))
++#endif
++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount32)
++#define lzo_bitops_popcount32(v) ((unsigned) __builtin_popcount(v))
++#endif
++#if !defined(lzo_bitops_popcount32) && defined(WANT_lzo_bitops_popcount64) && defined(LZO_UINT64_MAX)
++#define lzo_bitops_popcount64(v) ((unsigned) __builtin_popcountll(v))
++#endif
++#endif
++
++static __lzo_noinline lzo_uint
++do_compress ( const lzo_bytep in , lzo_uint in_len,
++ lzo_bytep out, lzo_uintp out_len,
++ lzo_uint ti, lzo_voidp wrkmem)
++{
++ register const lzo_bytep ip;
++ lzo_bytep op;
++ const lzo_bytep const in_end = in + in_len;
++ const lzo_bytep const ip_end = in + in_len - 20;
++ const lzo_bytep ii;
++ lzo_dict_p const dict = (lzo_dict_p) wrkmem;
++
++ op = out;
++ ip = in;
++ ii = ip - ti;
++
++ ip += ti < 4 ? 4 - ti : 0;
++ for (;;)
++ {
++ const lzo_bytep m_pos;
++#if !(LZO_DETERMINISTIC)
++ LZO_DEFINE_UNINITIALIZED_VAR(lzo_uint, m_off, 0);
++ lzo_uint m_len;
++ lzo_uint dindex;
++next:
++ if __lzo_unlikely(ip >= ip_end)
++ break;
++ DINDEX1(dindex,ip);
++ GINDEX(m_pos,m_off,dict,dindex,in);
++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
++ goto literal;
++#if 1
++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
++ goto try_match;
++ DINDEX2(dindex,ip);
++#endif
++ GINDEX(m_pos,m_off,dict,dindex,in);
++ if (LZO_CHECK_MPOS_NON_DET(m_pos,m_off,in,ip,M4_MAX_OFFSET))
++ goto literal;
++ if (m_off <= M2_MAX_OFFSET || m_pos[3] == ip[3])
++ goto try_match;
++ goto literal;
++
++try_match:
++#if defined(UA_GET32)
++ if (UA_GET32(m_pos) != UA_GET32(ip))
++#else
++ if (m_pos[0] != ip[0] || m_pos[1] != ip[1] || m_pos[2] != ip[2] || m_pos[3] != ip[3])
++#endif
++ {
++literal:
++ UPDATE_I(dict,0,dindex,ip,in);
++ ip += 1 + ((ip - ii) >> 5);
++ continue;
++ }
++ UPDATE_I(dict,0,dindex,ip,in);
++#else
++ lzo_uint m_off;
++ lzo_uint m_len;
++ {
++ lzo_uint32 dv;
++ lzo_uint dindex;
++literal:
++ ip += 1 + ((ip - ii) >> 5);
++next:
++ if __lzo_unlikely(ip >= ip_end)
++ break;
++ dv = UA_GET32(ip);
++ dindex = DINDEX(dv,ip);
++ GINDEX(m_off,m_pos,in+dict,dindex,in);
++ UPDATE_I(dict,0,dindex,ip,in);
++ if __lzo_unlikely(dv != UA_GET32(m_pos))
++ goto literal;
++ }
++#endif
++
++ {
++ register lzo_uint t = pd(ip,ii);
++ if (t != 0)
++ {
++ if (t <= 3)
++ {
++ op[-2] |= LZO_BYTE(t);
++#if defined(UA_COPY32)
++ UA_COPY32(op, ii);
++ op += t;
++#else
++ { do *op++ = *ii++; while (--t > 0); }
++#endif
++ }
++#if defined(UA_COPY32) || defined(UA_COPY64)
++ else if (t <= 16)
++ {
++ *op++ = LZO_BYTE(t - 3);
++#if defined(UA_COPY64)
++ UA_COPY64(op, ii);
++ UA_COPY64(op+8, ii+8);
++#else
++ UA_COPY32(op, ii);
++ UA_COPY32(op+4, ii+4);
++ UA_COPY32(op+8, ii+8);
++ UA_COPY32(op+12, ii+12);
++#endif
++ op += t;
++ }
++#endif
++ else
++ {
++ if (t <= 18)
++ *op++ = LZO_BYTE(t - 3);
++ else
++ {
++ register lzo_uint tt = t - 18;
++ *op++ = 0;
++ while __lzo_unlikely(tt > 255)
++ {
++ tt -= 255;
++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400))
++ * (volatile unsigned char *) op++ = 0;
++#else
++ *op++ = 0;
++#endif
++ }
++ assert(tt > 0);
++ *op++ = LZO_BYTE(tt);
++ }
++#if defined(UA_COPY32) || defined(UA_COPY64)
++ do {
++#if defined(UA_COPY64)
++ UA_COPY64(op, ii);
++ UA_COPY64(op+8, ii+8);
++#else
++ UA_COPY32(op, ii);
++ UA_COPY32(op+4, ii+4);
++ UA_COPY32(op+8, ii+8);
++ UA_COPY32(op+12, ii+12);
++#endif
++ op += 16; ii += 16; t -= 16;
++ } while (t >= 16); if (t > 0)
++#endif
++ { do *op++ = *ii++; while (--t > 0); }
++ }
++ }
++ }
++ m_len = 4;
++ {
++#if defined(UA_GET64)
++ lzo_uint64 v;
++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len);
++ if __lzo_unlikely(v == 0) {
++ do {
++ m_len += 8;
++ v = UA_GET64(ip + m_len) ^ UA_GET64(m_pos + m_len);
++ if __lzo_unlikely(ip + m_len >= ip_end)
++ goto m_len_done;
++ } while (v == 0);
++ }
++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz64)
++ m_len += lzo_bitops_ctz64(v) / CHAR_BIT;
++#elif (LZO_ABI_LITTLE_ENDIAN)
++ if ((v & UCHAR_MAX) == 0) do {
++ v >>= CHAR_BIT;
++ m_len += 1;
++ } while ((v & UCHAR_MAX) == 0);
++#else
++ if (ip[m_len] == m_pos[m_len]) do {
++ m_len += 1;
++ } while (ip[m_len] == m_pos[m_len]);
++#endif
++#elif defined(UA_GET32)
++ lzo_uint32 v;
++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len);
++ if __lzo_unlikely(v == 0) {
++ do {
++ m_len += 4;
++ v = UA_GET32(ip + m_len) ^ UA_GET32(m_pos + m_len);
++ if __lzo_unlikely(ip + m_len >= ip_end)
++ goto m_len_done;
++ } while (v == 0);
++ }
++#if (LZO_ABI_LITTLE_ENDIAN) && defined(lzo_bitops_ctz32)
++ m_len += lzo_bitops_ctz32(v) / CHAR_BIT;
++#elif (LZO_ABI_LITTLE_ENDIAN)
++ if ((v & UCHAR_MAX) == 0) do {
++ v >>= CHAR_BIT;
++ m_len += 1;
++ } while ((v & UCHAR_MAX) == 0);
++#else
++ if (ip[m_len] == m_pos[m_len]) do {
++ m_len += 1;
++ } while (ip[m_len] == m_pos[m_len]);
++#endif
++#else
++ if __lzo_unlikely(ip[m_len] == m_pos[m_len]) {
++ do {
++ m_len += 1;
++ if __lzo_unlikely(ip + m_len >= ip_end)
++ goto m_len_done;
++ } while (ip[m_len] == m_pos[m_len]);
++ }
++#endif
++ }
++m_len_done:
++ m_off = pd(ip,m_pos);
++ ip += m_len;
++ ii = ip;
++ if (m_len <= M2_MAX_LEN && m_off <= M2_MAX_OFFSET)
++ {
++ m_off -= 1;
++#if defined(LZO1X)
++ *op++ = LZO_BYTE(((m_len - 1) << 5) | ((m_off & 7) << 2));
++ *op++ = LZO_BYTE(m_off >> 3);
++#elif defined(LZO1Y)
++ *op++ = LZO_BYTE(((m_len + 1) << 4) | ((m_off & 3) << 2));
++ *op++ = LZO_BYTE(m_off >> 2);
++#endif
++ }
++ else if (m_off <= M3_MAX_OFFSET)
++ {
++ m_off -= 1;
++ if (m_len <= M3_MAX_LEN)
++ *op++ = LZO_BYTE(M3_MARKER | (m_len - 2));
++ else
++ {
++ m_len -= M3_MAX_LEN;
++ *op++ = M3_MARKER | 0;
++ while __lzo_unlikely(m_len > 255)
++ {
++ m_len -= 255;
++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400))
++ * (volatile unsigned char *) op++ = 0;
++#else
++ *op++ = 0;
++#endif
++ }
++ *op++ = LZO_BYTE(m_len);
++ }
++ *op++ = LZO_BYTE(m_off << 2);
++ *op++ = LZO_BYTE(m_off >> 6);
++ }
++ else
++ {
++ m_off -= 0x4000;
++ if (m_len <= M4_MAX_LEN)
++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8) | (m_len - 2));
++ else
++ {
++ m_len -= M4_MAX_LEN;
++ *op++ = LZO_BYTE(M4_MARKER | ((m_off >> 11) & 8));
++ while __lzo_unlikely(m_len > 255)
++ {
++ m_len -= 255;
++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400))
++ * (volatile unsigned char *) op++ = 0;
++#else
++ *op++ = 0;
++#endif
++ }
++ *op++ = LZO_BYTE(m_len);
++ }
++ *op++ = LZO_BYTE(m_off << 2);
++ *op++ = LZO_BYTE(m_off >> 6);
++ }
++ goto next;
++ }
++
++ *out_len = pd(op, out);
++ return pd(in_end,ii);
++}
++
++LZO_PUBLIC(int)
++DO_COMPRESS ( const lzo_bytep in , lzo_uint in_len,
++ lzo_bytep out, lzo_uintp out_len,
++ lzo_voidp wrkmem )
++{
++ const lzo_bytep ip = in;
++ lzo_bytep op = out;
++ lzo_uint l = in_len;
++ lzo_uint t = 0;
++
++ while (l > 20)
++ {
++ lzo_uint ll = l;
++ lzo_uintptr_t ll_end;
++#if 0 || (LZO_DETERMINISTIC)
++ ll = LZO_MIN(ll, 49152);
++#endif
++ ll_end = (lzo_uintptr_t)ip + ll;
++ if ((ll_end + ((t + ll) >> 5)) <= ll_end || (const lzo_bytep)(ll_end + ((t + ll) >> 5)) <= ip + ll)
++ break;
++#if (LZO_DETERMINISTIC)
++ lzo_memset(wrkmem, 0, ((lzo_uint)1 << D_BITS) * sizeof(lzo_dict_t));
++#endif
++ t = do_compress(ip,ll,op,out_len,t,wrkmem);
++ ip += ll;
++ op += *out_len;
++ l -= ll;
++ }
++ t += l;
++
++ if (t > 0)
++ {
++ const lzo_bytep ii = in + in_len - t;
++
++ if (op == out && t <= 238)
++ *op++ = LZO_BYTE(17 + t);
++ else if (t <= 3)
++ op[-2] |= LZO_BYTE(t);
++ else if (t <= 18)
++ *op++ = LZO_BYTE(t - 3);
++ else
++ {
++ lzo_uint tt = t - 18;
++
++ *op++ = 0;
++ while (tt > 255)
++ {
++ tt -= 255;
++#if 1 && (LZO_CC_MSC && (_MSC_VER >= 1400))
++
++ * (volatile unsigned char *) op++ = 0;
++#else
++ *op++ = 0;
++#endif
++ }
++ assert(tt > 0);
++ *op++ = LZO_BYTE(tt);
++ }
++ do *op++ = *ii++; while (--t > 0);
++ }
++
++ *op++ = M4_MARKER | 1;
++ *op++ = 0;
++ *op++ = 0;
++
++ *out_len = pd(op, out);
++ return LZO_E_OK;
++}
++
++#endif
++
++#undef do_compress
++#undef DO_COMPRESS
++#undef LZO_HASH
++
++#undef LZO_TEST_OVERRUN
++#undef DO_DECOMPRESS
++#define DO_DECOMPRESS lzo1x_decompress
++
++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS)
++
++#if defined(LZO_TEST_OVERRUN)
++# if !defined(LZO_TEST_OVERRUN_INPUT)
++# define LZO_TEST_OVERRUN_INPUT 2
++# endif
++# if !defined(LZO_TEST_OVERRUN_OUTPUT)
++# define LZO_TEST_OVERRUN_OUTPUT 2
++# endif
++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++# define LZO_TEST_OVERRUN_LOOKBEHIND 1
++# endif
++#endif
++
++#undef TEST_IP
++#undef TEST_OP
++#undef TEST_LB
++#undef TEST_LBO
++#undef NEED_IP
++#undef NEED_OP
++#undef HAVE_TEST_IP
++#undef HAVE_TEST_OP
++#undef HAVE_NEED_IP
++#undef HAVE_NEED_OP
++#undef HAVE_ANY_IP
++#undef HAVE_ANY_OP
++
++#if defined(LZO_TEST_OVERRUN_INPUT)
++# if (LZO_TEST_OVERRUN_INPUT >= 1)
++# define TEST_IP (ip < ip_end)
++# endif
++# if (LZO_TEST_OVERRUN_INPUT >= 2)
++# define NEED_IP(x) \
++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
++# endif
++#endif
++
++#if defined(LZO_TEST_OVERRUN_OUTPUT)
++# if (LZO_TEST_OVERRUN_OUTPUT >= 1)
++# define TEST_OP (op <= op_end)
++# endif
++# if (LZO_TEST_OVERRUN_OUTPUT >= 2)
++# undef TEST_OP
++# define NEED_OP(x) \
++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
++# endif
++#endif
++
++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun
++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun
++#else
++# define TEST_LB(m_pos) ((void) 0)
++# define TEST_LBO(m_pos,o) ((void) 0)
++#endif
++
++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
++# define TEST_IP (ip < ip_end)
++#endif
++
++#if defined(TEST_IP)
++# define HAVE_TEST_IP 1
++#else
++# define TEST_IP 1
++#endif
++#if defined(TEST_OP)
++# define HAVE_TEST_OP 1
++#else
++# define TEST_OP 1
++#endif
++
++#if defined(NEED_IP)
++# define HAVE_NEED_IP 1
++#else
++# define NEED_IP(x) ((void) 0)
++#endif
++#if defined(NEED_OP)
++# define HAVE_NEED_OP 1
++#else
++# define NEED_OP(x) ((void) 0)
++#endif
++
++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
++# define HAVE_ANY_IP 1
++#endif
++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
++# define HAVE_ANY_OP 1
++#endif
++
++#if defined(DO_DECOMPRESS)
++LZO_PUBLIC(int)
++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
++ lzo_bytep out, lzo_uintp out_len,
++ lzo_voidp wrkmem )
++#endif
++{
++ register lzo_bytep op;
++ register const lzo_bytep ip;
++ register lzo_uint t;
++#if defined(COPY_DICT)
++ lzo_uint m_off;
++ const lzo_bytep dict_end;
++#else
++ register const lzo_bytep m_pos;
++#endif
++
++ const lzo_bytep const ip_end = in + in_len;
++#if defined(HAVE_ANY_OP)
++ lzo_bytep const op_end = out + *out_len;
++#endif
++#if defined(LZO1Z)
++ lzo_uint last_m_off = 0;
++#endif
++
++ LZO_UNUSED(wrkmem);
++
++#if defined(COPY_DICT)
++ if (dict)
++ {
++ if (dict_len > M4_MAX_OFFSET)
++ {
++ dict += dict_len - M4_MAX_OFFSET;
++ dict_len = M4_MAX_OFFSET;
++ }
++ dict_end = dict + dict_len;
++ }
++ else
++ {
++ dict_len = 0;
++ dict_end = NULL;
++ }
++#endif
++
++ *out_len = 0;
++
++ op = out;
++ ip = in;
++
++ if (*ip > 17)
++ {
++ t = *ip++ - 17;
++ if (t < 4)
++ goto match_next;
++ assert(t > 0); NEED_OP(t); NEED_IP(t+1);
++ do *op++ = *ip++; while (--t > 0);
++ goto first_literal_run;
++ }
++
++ while (TEST_IP && TEST_OP)
++ {
++ t = *ip++;
++ if (t >= 16)
++ goto match;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 15 + *ip++;
++ }
++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4);
++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
++ t += 3;
++ if (t >= 8) do
++ {
++ UA_COPY64(op,ip);
++ op += 8; ip += 8; t -= 8;
++ } while (t >= 8);
++ if (t >= 4)
++ {
++ UA_COPY32(op,ip);
++ op += 4; ip += 4; t -= 4;
++ }
++ if (t > 0)
++ {
++ *op++ = *ip++;
++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
++ }
++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
++#if !defined(LZO_UNALIGNED_OK_4)
++ if (PTR_ALIGNED2_4(op,ip))
++ {
++#endif
++ UA_COPY32(op,ip);
++ op += 4; ip += 4;
++ if (--t > 0)
++ {
++ if (t >= 4)
++ {
++ do {
++ UA_COPY32(op,ip);
++ op += 4; ip += 4; t -= 4;
++ } while (t >= 4);
++ if (t > 0) do *op++ = *ip++; while (--t > 0);
++ }
++ else
++ do *op++ = *ip++; while (--t > 0);
++ }
++#if !defined(LZO_UNALIGNED_OK_4)
++ }
++ else
++#endif
++#endif
++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8)
++ {
++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
++ do *op++ = *ip++; while (--t > 0);
++ }
++#endif
++
++first_literal_run:
++
++ t = *ip++;
++ if (t >= 16)
++ goto match;
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++#else
++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
++#endif
++ NEED_OP(3);
++ t = 3; COPY_DICT(t,m_off)
++#else
++#if defined(LZO1Z)
++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
++ m_pos = op - t;
++ last_m_off = t;
++#else
++ m_pos = op - (1 + M2_MAX_OFFSET);
++ m_pos -= t >> 2;
++ m_pos -= *ip++ << 2;
++#endif
++ TEST_LB(m_pos); NEED_OP(3);
++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
++#endif
++ goto match_done;
++
++ do {
++match:
++ if (t >= 64)
++ {
++#if defined(COPY_DICT)
++#if defined(LZO1X)
++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3);
++ t = (t >> 5) - 1;
++#elif defined(LZO1Y)
++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2);
++ t = (t >> 4) - 3;
++#elif defined(LZO1Z)
++ m_off = t & 0x1f;
++ if (m_off >= 0x1c)
++ m_off = last_m_off;
++ else
++ {
++ m_off = 1 + (m_off << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++ }
++ t = (t >> 5) - 1;
++#endif
++#else
++#if defined(LZO1X)
++ m_pos = op - 1;
++ m_pos -= (t >> 2) & 7;
++ m_pos -= *ip++ << 3;
++ t = (t >> 5) - 1;
++#elif defined(LZO1Y)
++ m_pos = op - 1;
++ m_pos -= (t >> 2) & 3;
++ m_pos -= *ip++ << 2;
++ t = (t >> 4) - 3;
++#elif defined(LZO1Z)
++ {
++ lzo_uint off = t & 0x1f;
++ m_pos = op;
++ if (off >= 0x1c)
++ {
++ assert(last_m_off > 0);
++ m_pos -= last_m_off;
++ }
++ else
++ {
++ off = 1 + (off << 6) + (*ip++ >> 2);
++ m_pos -= off;
++ last_m_off = off;
++ }
++ }
++ t = (t >> 5) - 1;
++#endif
++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
++ goto copy_match;
++#endif
++ }
++ else if (t >= 32)
++ {
++ t &= 31;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 31 + *ip++;
++ }
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
++ last_m_off = m_off;
++#else
++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6);
++#endif
++#else
++#if defined(LZO1Z)
++ {
++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2);
++ m_pos = op - off;
++ last_m_off = off;
++ }
++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
++ m_pos = op - 1;
++ m_pos -= UA_GET16(ip) >> 2;
++#else
++ m_pos = op - 1;
++ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
++#endif
++#endif
++ ip += 2;
++ }
++ else if (t >= 16)
++ {
++#if defined(COPY_DICT)
++ m_off = (t & 8) << 11;
++#else
++ m_pos = op;
++ m_pos -= (t & 8) << 11;
++#endif
++ t &= 7;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 7 + *ip++;
++ }
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off += (ip[0] << 6) + (ip[1] >> 2);
++#else
++ m_off += (ip[0] >> 2) + (ip[1] << 6);
++#endif
++ ip += 2;
++ if (m_off == 0)
++ goto eof_found;
++ m_off += 0x4000;
++#if defined(LZO1Z)
++ last_m_off = m_off;
++#endif
++#else
++#if defined(LZO1Z)
++ m_pos -= (ip[0] << 6) + (ip[1] >> 2);
++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
++ m_pos -= UA_GET16(ip) >> 2;
++#else
++ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
++#endif
++ ip += 2;
++ if (m_pos == op)
++ goto eof_found;
++ m_pos -= 0x4000;
++#if defined(LZO1Z)
++ last_m_off = pd((const lzo_bytep)op, m_pos);
++#endif
++#endif
++ }
++ else
++ {
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = 1 + (t << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++#else
++ m_off = 1 + (t >> 2) + (*ip++ << 2);
++#endif
++ NEED_OP(2);
++ t = 2; COPY_DICT(t,m_off)
++#else
++#if defined(LZO1Z)
++ t = 1 + (t << 6) + (*ip++ >> 2);
++ m_pos = op - t;
++ last_m_off = t;
++#else
++ m_pos = op - 1;
++ m_pos -= t >> 2;
++ m_pos -= *ip++ << 2;
++#endif
++ TEST_LB(m_pos); NEED_OP(2);
++ *op++ = *m_pos++; *op++ = *m_pos;
++#endif
++ goto match_done;
++ }
++
++#if defined(COPY_DICT)
++
++ NEED_OP(t+3-1);
++ t += 3-1; COPY_DICT(t,m_off)
++
++#else
++
++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
++ if (op - m_pos >= 8)
++ {
++ t += (3 - 1);
++ if (t >= 8) do
++ {
++ UA_COPY64(op,m_pos);
++ op += 8; m_pos += 8; t -= 8;
++ } while (t >= 8);
++ if (t >= 4)
++ {
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4;
++ }
++ if (t > 0)
++ {
++ *op++ = m_pos[0];
++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
++ }
++ }
++ else
++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
++#if !defined(LZO_UNALIGNED_OK_4)
++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos))
++ {
++ assert((op - m_pos) >= 4);
++#else
++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
++ {
++#endif
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4 - (3 - 1);
++ do {
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4;
++ } while (t >= 4);
++ if (t > 0) do *op++ = *m_pos++; while (--t > 0);
++ }
++ else
++#endif
++ {
++copy_match:
++ *op++ = *m_pos++; *op++ = *m_pos++;
++ do *op++ = *m_pos++; while (--t > 0);
++ }
++
++#endif
++
++match_done:
++#if defined(LZO1Z)
++ t = ip[-1] & 3;
++#else
++ t = ip[-2] & 3;
++#endif
++ if (t == 0)
++ break;
++
++match_next:
++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1);
++#if 0
++ do *op++ = *ip++; while (--t > 0);
++#else
++ *op++ = *ip++;
++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
++#endif
++ t = *ip++;
++ } while (TEST_IP && TEST_OP);
++ }
++
++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
++ *out_len = pd(op, out);
++ return LZO_E_EOF_NOT_FOUND;
++#endif
++
++eof_found:
++ assert(t == 1);
++ *out_len = pd(op, out);
++ return (ip == ip_end ? LZO_E_OK :
++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
++
++#if defined(HAVE_NEED_IP)
++input_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_INPUT_OVERRUN;
++#endif
++
++#if defined(HAVE_NEED_OP)
++output_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_OUTPUT_OVERRUN;
++#endif
++
++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++lookbehind_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_LOOKBEHIND_OVERRUN;
++#endif
++}
++
++#endif
++
++#define LZO_TEST_OVERRUN 1
++#undef DO_DECOMPRESS
++#define DO_DECOMPRESS lzo1x_decompress_safe
++
++#if !defined(MINILZO_CFG_SKIP_LZO1X_DECOMPRESS_SAFE)
++
++#if defined(LZO_TEST_OVERRUN)
++# if !defined(LZO_TEST_OVERRUN_INPUT)
++# define LZO_TEST_OVERRUN_INPUT 2
++# endif
++# if !defined(LZO_TEST_OVERRUN_OUTPUT)
++# define LZO_TEST_OVERRUN_OUTPUT 2
++# endif
++# if !defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++# define LZO_TEST_OVERRUN_LOOKBEHIND 1
++# endif
++#endif
++
++#undef TEST_IP
++#undef TEST_OP
++#undef TEST_LB
++#undef TEST_LBO
++#undef NEED_IP
++#undef NEED_OP
++#undef HAVE_TEST_IP
++#undef HAVE_TEST_OP
++#undef HAVE_NEED_IP
++#undef HAVE_NEED_OP
++#undef HAVE_ANY_IP
++#undef HAVE_ANY_OP
++
++#if defined(LZO_TEST_OVERRUN_INPUT)
++# if (LZO_TEST_OVERRUN_INPUT >= 1)
++# define TEST_IP (ip < ip_end)
++# endif
++# if (LZO_TEST_OVERRUN_INPUT >= 2)
++# define NEED_IP(x) \
++ if ((lzo_uint)(ip_end - ip) < (lzo_uint)(x)) goto input_overrun
++# endif
++#endif
++
++#if defined(LZO_TEST_OVERRUN_OUTPUT)
++# if (LZO_TEST_OVERRUN_OUTPUT >= 1)
++# define TEST_OP (op <= op_end)
++# endif
++# if (LZO_TEST_OVERRUN_OUTPUT >= 2)
++# undef TEST_OP
++# define NEED_OP(x) \
++ if ((lzo_uint)(op_end - op) < (lzo_uint)(x)) goto output_overrun
++# endif
++#endif
++
++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++# define TEST_LB(m_pos) if (m_pos < out || m_pos >= op) goto lookbehind_overrun
++# define TEST_LBO(m_pos,o) if (m_pos < out || m_pos >= op - (o)) goto lookbehind_overrun
++#else
++# define TEST_LB(m_pos) ((void) 0)
++# define TEST_LBO(m_pos,o) ((void) 0)
++#endif
++
++#if !defined(LZO_EOF_CODE) && !defined(TEST_IP)
++# define TEST_IP (ip < ip_end)
++#endif
++
++#if defined(TEST_IP)
++# define HAVE_TEST_IP 1
++#else
++# define TEST_IP 1
++#endif
++#if defined(TEST_OP)
++# define HAVE_TEST_OP 1
++#else
++# define TEST_OP 1
++#endif
++
++#if defined(NEED_IP)
++# define HAVE_NEED_IP 1
++#else
++# define NEED_IP(x) ((void) 0)
++#endif
++#if defined(NEED_OP)
++# define HAVE_NEED_OP 1
++#else
++# define NEED_OP(x) ((void) 0)
++#endif
++
++#if defined(HAVE_TEST_IP) || defined(HAVE_NEED_IP)
++# define HAVE_ANY_IP 1
++#endif
++#if defined(HAVE_TEST_OP) || defined(HAVE_NEED_OP)
++# define HAVE_ANY_OP 1
++#endif
++
++#if defined(DO_DECOMPRESS)
++LZO_PUBLIC(int)
++DO_DECOMPRESS ( const lzo_bytep in , lzo_uint in_len,
++ lzo_bytep out, lzo_uintp out_len,
++ lzo_voidp wrkmem )
++#endif
++{
++ register lzo_bytep op;
++ register const lzo_bytep ip;
++ register lzo_uint t;
++#if defined(COPY_DICT)
++ lzo_uint m_off;
++ const lzo_bytep dict_end;
++#else
++ register const lzo_bytep m_pos;
++#endif
++
++ const lzo_bytep const ip_end = in + in_len;
++#if defined(HAVE_ANY_OP)
++ lzo_bytep const op_end = out + *out_len;
++#endif
++#if defined(LZO1Z)
++ lzo_uint last_m_off = 0;
++#endif
++
++ LZO_UNUSED(wrkmem);
++
++#if defined(COPY_DICT)
++ if (dict)
++ {
++ if (dict_len > M4_MAX_OFFSET)
++ {
++ dict += dict_len - M4_MAX_OFFSET;
++ dict_len = M4_MAX_OFFSET;
++ }
++ dict_end = dict + dict_len;
++ }
++ else
++ {
++ dict_len = 0;
++ dict_end = NULL;
++ }
++#endif
++
++ *out_len = 0;
++
++ op = out;
++ ip = in;
++
++ if (*ip > 17)
++ {
++ t = *ip++ - 17;
++ if (t < 4)
++ goto match_next;
++ assert(t > 0); NEED_OP(t); NEED_IP(t+1);
++ do *op++ = *ip++; while (--t > 0);
++ goto first_literal_run;
++ }
++
++ while (TEST_IP && TEST_OP)
++ {
++ t = *ip++;
++ if (t >= 16)
++ goto match;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 15 + *ip++;
++ }
++ assert(t > 0); NEED_OP(t+3); NEED_IP(t+4);
++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
++ t += 3;
++ if (t >= 8) do
++ {
++ UA_COPY64(op,ip);
++ op += 8; ip += 8; t -= 8;
++ } while (t >= 8);
++ if (t >= 4)
++ {
++ UA_COPY32(op,ip);
++ op += 4; ip += 4; t -= 4;
++ }
++ if (t > 0)
++ {
++ *op++ = *ip++;
++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
++ }
++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
++#if !defined(LZO_UNALIGNED_OK_4)
++ if (PTR_ALIGNED2_4(op,ip))
++ {
++#endif
++ UA_COPY32(op,ip);
++ op += 4; ip += 4;
++ if (--t > 0)
++ {
++ if (t >= 4)
++ {
++ do {
++ UA_COPY32(op,ip);
++ op += 4; ip += 4; t -= 4;
++ } while (t >= 4);
++ if (t > 0) do *op++ = *ip++; while (--t > 0);
++ }
++ else
++ do *op++ = *ip++; while (--t > 0);
++ }
++#if !defined(LZO_UNALIGNED_OK_4)
++ }
++ else
++#endif
++#endif
++#if !defined(LZO_UNALIGNED_OK_4) && !defined(LZO_UNALIGNED_OK_8)
++ {
++ *op++ = *ip++; *op++ = *ip++; *op++ = *ip++;
++ do *op++ = *ip++; while (--t > 0);
++ }
++#endif
++
++first_literal_run:
++
++ t = *ip++;
++ if (t >= 16)
++ goto match;
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++#else
++ m_off = (1 + M2_MAX_OFFSET) + (t >> 2) + (*ip++ << 2);
++#endif
++ NEED_OP(3);
++ t = 3; COPY_DICT(t,m_off)
++#else
++#if defined(LZO1Z)
++ t = (1 + M2_MAX_OFFSET) + (t << 6) + (*ip++ >> 2);
++ m_pos = op - t;
++ last_m_off = t;
++#else
++ m_pos = op - (1 + M2_MAX_OFFSET);
++ m_pos -= t >> 2;
++ m_pos -= *ip++ << 2;
++#endif
++ TEST_LB(m_pos); NEED_OP(3);
++ *op++ = *m_pos++; *op++ = *m_pos++; *op++ = *m_pos;
++#endif
++ goto match_done;
++
++ do {
++match:
++ if (t >= 64)
++ {
++#if defined(COPY_DICT)
++#if defined(LZO1X)
++ m_off = 1 + ((t >> 2) & 7) + (*ip++ << 3);
++ t = (t >> 5) - 1;
++#elif defined(LZO1Y)
++ m_off = 1 + ((t >> 2) & 3) + (*ip++ << 2);
++ t = (t >> 4) - 3;
++#elif defined(LZO1Z)
++ m_off = t & 0x1f;
++ if (m_off >= 0x1c)
++ m_off = last_m_off;
++ else
++ {
++ m_off = 1 + (m_off << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++ }
++ t = (t >> 5) - 1;
++#endif
++#else
++#if defined(LZO1X)
++ m_pos = op - 1;
++ m_pos -= (t >> 2) & 7;
++ m_pos -= *ip++ << 3;
++ t = (t >> 5) - 1;
++#elif defined(LZO1Y)
++ m_pos = op - 1;
++ m_pos -= (t >> 2) & 3;
++ m_pos -= *ip++ << 2;
++ t = (t >> 4) - 3;
++#elif defined(LZO1Z)
++ {
++ lzo_uint off = t & 0x1f;
++ m_pos = op;
++ if (off >= 0x1c)
++ {
++ assert(last_m_off > 0);
++ m_pos -= last_m_off;
++ }
++ else
++ {
++ off = 1 + (off << 6) + (*ip++ >> 2);
++ m_pos -= off;
++ last_m_off = off;
++ }
++ }
++ t = (t >> 5) - 1;
++#endif
++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
++ goto copy_match;
++#endif
++ }
++ else if (t >= 32)
++ {
++ t &= 31;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 31 + *ip++;
++ }
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = 1 + (ip[0] << 6) + (ip[1] >> 2);
++ last_m_off = m_off;
++#else
++ m_off = 1 + (ip[0] >> 2) + (ip[1] << 6);
++#endif
++#else
++#if defined(LZO1Z)
++ {
++ lzo_uint off = 1 + (ip[0] << 6) + (ip[1] >> 2);
++ m_pos = op - off;
++ last_m_off = off;
++ }
++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
++ m_pos = op - 1;
++ m_pos -= UA_GET16(ip) >> 2;
++#else
++ m_pos = op - 1;
++ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
++#endif
++#endif
++ ip += 2;
++ }
++ else if (t >= 16)
++ {
++#if defined(COPY_DICT)
++ m_off = (t & 8) << 11;
++#else
++ m_pos = op;
++ m_pos -= (t & 8) << 11;
++#endif
++ t &= 7;
++ if (t == 0)
++ {
++ NEED_IP(1);
++ while (*ip == 0)
++ {
++ t += 255;
++ ip++;
++ NEED_IP(1);
++ }
++ t += 7 + *ip++;
++ }
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off += (ip[0] << 6) + (ip[1] >> 2);
++#else
++ m_off += (ip[0] >> 2) + (ip[1] << 6);
++#endif
++ ip += 2;
++ if (m_off == 0)
++ goto eof_found;
++ m_off += 0x4000;
++#if defined(LZO1Z)
++ last_m_off = m_off;
++#endif
++#else
++#if defined(LZO1Z)
++ m_pos -= (ip[0] << 6) + (ip[1] >> 2);
++#elif defined(LZO_UNALIGNED_OK_2) && defined(LZO_ABI_LITTLE_ENDIAN)
++ m_pos -= UA_GET16(ip) >> 2;
++#else
++ m_pos -= (ip[0] >> 2) + (ip[1] << 6);
++#endif
++ ip += 2;
++ if (m_pos == op)
++ goto eof_found;
++ m_pos -= 0x4000;
++#if defined(LZO1Z)
++ last_m_off = pd((const lzo_bytep)op, m_pos);
++#endif
++#endif
++ }
++ else
++ {
++#if defined(COPY_DICT)
++#if defined(LZO1Z)
++ m_off = 1 + (t << 6) + (*ip++ >> 2);
++ last_m_off = m_off;
++#else
++ m_off = 1 + (t >> 2) + (*ip++ << 2);
++#endif
++ NEED_OP(2);
++ t = 2; COPY_DICT(t,m_off)
++#else
++#if defined(LZO1Z)
++ t = 1 + (t << 6) + (*ip++ >> 2);
++ m_pos = op - t;
++ last_m_off = t;
++#else
++ m_pos = op - 1;
++ m_pos -= t >> 2;
++ m_pos -= *ip++ << 2;
++#endif
++ TEST_LB(m_pos); NEED_OP(2);
++ *op++ = *m_pos++; *op++ = *m_pos;
++#endif
++ goto match_done;
++ }
++
++#if defined(COPY_DICT)
++
++ NEED_OP(t+3-1);
++ t += 3-1; COPY_DICT(t,m_off)
++
++#else
++
++ TEST_LB(m_pos); assert(t > 0); NEED_OP(t+3-1);
++#if defined(LZO_UNALIGNED_OK_8) && defined(LZO_UNALIGNED_OK_4)
++ if (op - m_pos >= 8)
++ {
++ t += (3 - 1);
++ if (t >= 8) do
++ {
++ UA_COPY64(op,m_pos);
++ op += 8; m_pos += 8; t -= 8;
++ } while (t >= 8);
++ if (t >= 4)
++ {
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4;
++ }
++ if (t > 0)
++ {
++ *op++ = m_pos[0];
++ if (t > 1) { *op++ = m_pos[1]; if (t > 2) { *op++ = m_pos[2]; } }
++ }
++ }
++ else
++#elif defined(LZO_UNALIGNED_OK_4) || defined(LZO_ALIGNED_OK_4)
++#if !defined(LZO_UNALIGNED_OK_4)
++ if (t >= 2 * 4 - (3 - 1) && PTR_ALIGNED2_4(op,m_pos))
++ {
++ assert((op - m_pos) >= 4);
++#else
++ if (t >= 2 * 4 - (3 - 1) && (op - m_pos) >= 4)
++ {
++#endif
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4 - (3 - 1);
++ do {
++ UA_COPY32(op,m_pos);
++ op += 4; m_pos += 4; t -= 4;
++ } while (t >= 4);
++ if (t > 0) do *op++ = *m_pos++; while (--t > 0);
++ }
++ else
++#endif
++ {
++copy_match:
++ *op++ = *m_pos++; *op++ = *m_pos++;
++ do *op++ = *m_pos++; while (--t > 0);
++ }
++
++#endif
++
++match_done:
++#if defined(LZO1Z)
++ t = ip[-1] & 3;
++#else
++ t = ip[-2] & 3;
++#endif
++ if (t == 0)
++ break;
++
++match_next:
++ assert(t > 0); assert(t < 4); NEED_OP(t); NEED_IP(t+1);
++#if 0
++ do *op++ = *ip++; while (--t > 0);
++#else
++ *op++ = *ip++;
++ if (t > 1) { *op++ = *ip++; if (t > 2) { *op++ = *ip++; } }
++#endif
++ t = *ip++;
++ } while (TEST_IP && TEST_OP);
++ }
++
++#if defined(HAVE_TEST_IP) || defined(HAVE_TEST_OP)
++ *out_len = pd(op, out);
++ return LZO_E_EOF_NOT_FOUND;
++#endif
++
++eof_found:
++ assert(t == 1);
++ *out_len = pd(op, out);
++ return (ip == ip_end ? LZO_E_OK :
++ (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
++
++#if defined(HAVE_NEED_IP)
++input_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_INPUT_OVERRUN;
++#endif
++
++#if defined(HAVE_NEED_OP)
++output_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_OUTPUT_OVERRUN;
++#endif
++
++#if defined(LZO_TEST_OVERRUN_LOOKBEHIND)
++lookbehind_overrun:
++ *out_len = pd(op, out);
++ return LZO_E_LOOKBEHIND_OVERRUN;
++#endif
++}
++
++#endif
++
++/***** End of minilzo.c *****/
++
+Index: b/grub-core/lib/minilzo/minilzo.h
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/minilzo/minilzo.h
+@@ -0,0 +1,109 @@
++/* minilzo.h -- mini subset of the LZO real-time data compression library
++
++ This file is part of the LZO real-time data compression library.
++
++ Copyright (C) 2011 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2010 Markus Franz Xaver Johannes Oberhumer
++ Copyright (C) 2009 Markus Franz Xaver Johannes Oberhumer
++ 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/
++ */
++
++/*
++ * NOTE:
++ * the full LZO package can be found at
++ * http://www.oberhumer.com/opensource/lzo/
++ */
++
++
++#ifndef __MINILZO_H
++#define __MINILZO_H 1
++
++#define MINILZO_VERSION 0x2050
++
++#ifdef __LZOCONF_H
++# error "you cannot use both LZO and miniLZO"
++#endif
++
++#undef LZO_HAVE_CONFIG_H
++#include "lzoconf.h"
++
++#if !defined(LZO_VERSION) || (LZO_VERSION != MINILZO_VERSION)
++# error "version mismatch in header files"
++#endif
++
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++/***********************************************************************
++//
++************************************************************************/
++
++/* Memory required for the wrkmem parameter.
++ * When the required size is 0, you can also pass a NULL pointer.
++ */
++
++#define LZO1X_MEM_COMPRESS LZO1X_1_MEM_COMPRESS
++#define LZO1X_1_MEM_COMPRESS ((lzo_uint32) (16384L * lzo_sizeof_dict_t))
++#define LZO1X_MEM_DECOMPRESS (0)
++
++
++/* compression */
++LZO_EXTERN(int)
++lzo1x_1_compress ( const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem );
++
++/* decompression */
++LZO_EXTERN(int)
++lzo1x_decompress ( const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem /* NOT USED */ );
++
++/* safe decompression with overrun testing */
++LZO_EXTERN(int)
++lzo1x_decompress_safe ( const lzo_bytep src, lzo_uint src_len,
++ lzo_bytep dst, lzo_uintp dst_len,
++ lzo_voidp wrkmem /* NOT USED */ );
++
++
++#ifdef __cplusplus
++} /* extern "C" */
++#endif
++
++#endif /* already included */
++
+Index: b/grub-core/lib/posix_wrap/limits.h
+===================================================================
+--- /dev/null
++++ b/grub-core/lib/posix_wrap/limits.h
+@@ -0,0 +1,31 @@
++/*
++ * GRUB -- GRand Unified Bootloader
++ * Copyright (C) 2010 Free Software Foundation, Inc.
++ *
++ * GRUB is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License as published by
++ * the Free Software Foundation, either version 3 of the License, or
++ * (at your option) any later version.
++ *
++ * GRUB 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 GRUB. If not, see <http://www.gnu.org/licenses/>.
++ */
++
++#ifndef GRUB_POSIX_LIMITS_H
++#define GRUB_POSIX_LIMITS_H
++
++#include <grub/types.h>
++
++#define UCHAR_MAX GRUB_UCHAR_MAX
++#define USHRT_MAX GRUB_USHRT_MAX
++#define UINT_MAX GRUB_UINT_MAX
++#define ULONG_MAX GRUB_ULONG_MAX
++
++#define CHAR_BIT 8
++
++#endif
+Index: b/grub-core/lib/posix_wrap/sys/types.h
+===================================================================
+--- a/grub-core/lib/posix_wrap/sys/types.h
++++ b/grub-core/lib/posix_wrap/sys/types.h
+@@ -24,9 +24,6 @@
+ typedef grub_size_t size_t;
+ typedef enum { false = 0, true = 1 } bool;
+
+-#define ULONG_MAX GRUB_ULONG_MAX
+-#define UCHAR_MAX 0xff
+-
+ typedef grub_uint8_t uint8_t;
+ typedef grub_uint16_t uint16_t;
+ typedef grub_uint32_t uint32_t;
+Index: b/include/grub/file.h
+===================================================================
+--- a/include/grub/file.h
++++ b/include/grub/file.h
+@@ -56,9 +56,10 @@
+ {
+ GRUB_FILE_FILTER_GZIO,
+ GRUB_FILE_FILTER_XZIO,
++ GRUB_FILE_FILTER_LZOPIO,
+ GRUB_FILE_FILTER_MAX,
+ GRUB_FILE_FILTER_COMPRESSION_FIRST = GRUB_FILE_FILTER_GZIO,
+- GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_XZIO,
++ GRUB_FILE_FILTER_COMPRESSION_LAST = GRUB_FILE_FILTER_LZOPIO,
+ } grub_file_filter_id_t;
+
+ typedef grub_file_t (*grub_file_filter_t) (grub_file_t in);
+Index: b/include/grub/types.h
+===================================================================
+--- a/include/grub/types.h
++++ b/include/grub/types.h
+@@ -113,6 +113,10 @@
+ # define PRIuGRUB_SIZE "u"
+ #endif
+
++#define GRUB_UCHAR_MAX 0xFF
++#define GRUB_USHRT_MAX 65535
++#define GRUB_UINT_MAX 4294967295U
++
+ #if GRUB_CPU_SIZEOF_LONG == 8
+ # define GRUB_ULONG_MAX 18446744073709551615UL
+ # define GRUB_LONG_MAX 9223372036854775807L
+@@ -215,4 +219,31 @@
+ # define grub_cpu_to_le32_compile_time(x) ((grub_uint32_t) (x))
+ #endif /* ! WORDS_BIGENDIAN */
+
++static inline grub_uint16_t grub_get_unaligned16(void *ptr)
++{
++ struct
++ {
++ grub_uint16_t d;
++ } __attribute__((packed)) *dd = ptr;
++ return dd->d;
++}
++
++static inline grub_uint32_t grub_get_unaligned32(void *ptr)
++{
++ struct
++ {
++ grub_uint32_t d;
++ } __attribute__((packed)) *dd = ptr;
++ return dd->d;
++}
++
++static inline grub_uint64_t grub_get_unaligned64(void *ptr)
++{
++ struct
++ {
++ grub_uint64_t d;
++ } __attribute__((packed)) *dd = ptr;
++ return dd->d;
++}
++
+ #endif /* ! GRUB_TYPES_HEADER */
+Index: b/util/import_gcry.py
+===================================================================
+--- a/util/import_gcry.py
++++ b/util/import_gcry.py
+@@ -73,6 +73,8 @@
+ cryptolist.write ("AES-192: gcry_rijndael\n");
+ cryptolist.write ("AES-256: gcry_rijndael\n");
+
++cryptolist.write ("ADLER32: adler32\n");
++
+ for cipher_file in cipher_files:
+ infile = os.path.join (cipher_dir_in, cipher_file)
+ outfile = os.path.join (cipher_dir_out, cipher_file)
projects / grub2.git / commitdiff