Bump release date.

work with objcopy.

.hgtags

@@ -6,6 +6,8 @@
 a916a2fe22de45167d25abcb40008315f415221c RELEASE_201
 a935d577fc7dd9c2c87761c9c702805da6ce1e51 RELEASE_193
 b0353253b0b3d062eb5adb50d4b665a96620da45 RELEASE_195
+b82ef51896199484afe5b0553af7d1e59b7ce428 BRANCHPOINT_FOR_upx2.hg
 c2e0cd4d621b047f254f2def42132a03683ff52c RELEASE_192
+d276aa09033c24d0981bc3f4fee5628aecc988ad RELEASE_290
 eb1ce56dce7dd1835964362470610925963b9043 RELEASE_110
 ed96891ef795bceec6b7ff3ca1ca7764431bfb39 RELEASE_191

NEWS

@@ -2,22 +2,32 @@
 User visible changes for UPX
 ==================================================================
 
-Changes in 2.90 (08 Oct 2006):
+Changes in 2.91 beta (29 Nov 2006):
+  * assorted bug fixes
+  * arm/pe: fix "missing" icon & version info resource problem for wince 5
+  * win32/pe & arm/pe: added option --compress-icons=3 to compress all icons
+
+Changes in 2.90 beta (08 Oct 2006):
   * LZMA algorithm support for most of the 32-bit and 64-bit file formats;
     use new option '--lzma' to enable
   * new format: BSD/elf386 supporting FreeBSD, NetBSD and OpenBSD
     via auto-detection of PT_NOTE or EI_OSABI
   * arm/pe: all the NRV compression methods are now supported
     (only NRV2D is missing in thumb mode)
-  * linux/elf386, linux/ElfAMD remember /proc/self/exe in environment
+  * linux/elf386, linux/ElfAMD: remember /proc/self/exe in environment
-  * vmlinuz/386: fixed zlib uncompression problem on dos
+  * major source code changes: the runtime decompression stubs are now
-  * major source code change: the runtime decompression stubs are now
     built from internal ELF objects
 
+==================================================================
+
+Changes in 2.03 (07 Nov 2006):
+  * bvmlinuz/386: fix for kernels not at 0x100000; also allow x86_64
+  * linux/elf386: work around Linux kernel bug (0-length .bss needs PF_W)
+
 Changes in 2.02 (13 Aug 2006):
   * linux/386: work around Linux kernel bug (".bss" requires PF_W)
   * linux/ppc32, mach/ppc32: compressed programs now work on a 405 CPU
-  * vmlinuz/386: fixed zlib uncompression problem on dos
+  * vmlinuz/386: fixed zlib uncompression problem on DOS
 
 Changes in 2.01 (06 Jun 2006):
   * arm/pe: better DLL support

README.SRC

@@ -75,13 +75,18 @@ Tools needed to build/modify the UPX sources
 To compile the packer sources
 -----------------------------
 
-  set the environment variable UPX_UCLDIR to point to your
+  Set the environment variable UPX_UCLDIR to point to your
-  UCL installation, e.g.
+  UCL build directory, e.g.
 
      set UPX_UCLDIR=c:\src\ucl-1.03                   (DOS / Windows)
      export UPX_UCLDIR=$HOME/local/src/ucl-1.03       (Unix)
 
-  then type
+  Set the environment variable UPX_LZMADIR to point to your
+  to your unpacked lzma443.tar.bz2 source directory, e.g.
+
+     export UPX_LZMADIR=$HOME/local/src/lzma-4.43     (Unix)
+
+  Finally type
 
      make
 

doc/Makefile

@@ -25,7 +25,7 @@ endif
 # //
 # ************************************************************************/
 
-top_srcdir = ..
+top_srcdir ?= ..
 
 PACKAGE       = upx
 VERSION_DATE := $(shell sed -n 's/^.*UPX_VERSION_DATE_ISO .*"\(.*\)".*/\1/p' $(top_srcdir)/src/version.h)
@@ -81,4 +81,5 @@ mostlyclean clean distclean maintainer-clean:
 ###
 
 $(BUILT_SOURCES): $(top_srcdir)/src/version.h $(MAKEFILE_LIST)
+.DELETE_ON_ERROR: $(BUILT_SOURCES)
 

doc/upx.pod

@@ -138,6 +138,9 @@ B<--help>: prints the help
 
 B<--version>: print the version of B<UPX>
 
+B<--exact>: when compressing, require to be able to get a byte-identical file
+after decompression with option B<-d>
+
 [ ...to be written... - type `B<upx --help>' for now ]
 
 
@@ -872,6 +875,7 @@ Extra options available for this executable format:
   --compress-icons=1  Compress all but the first icon.
   --compress-icons=2  Compress all icons which are not in the
                       first icon directory. [DEFAULT]
+  --compress-icons=3  Compress all icons.
 
   --compress-resources=0  Don't compress any resources at all.
 

src/Makefile

@@ -51,22 +51,10 @@ ifneq ($(wildcard $(UPX_LZMADIR)/C/7zip/.),)
 DEFS += -DWITH_LZMA
 INCLUDES += -I$(UPX_LZMADIR)
 endif
-# you should set envvar UPX_LUADIR to point to your unpacked lua-5.1.1.tar.gz
-# [disabled for now]
-ifneq ($(wildcard $(UPX_LUADIR)/src/lua.h),)
-##DEFS += -DWITH_LUA
-##upx_SOURCES_LUA := $(wildcard $(UPX_LUADIR)/src/*.c)
-##upx_SOURCES_LUA := $(filter-out %lua.c, $(upx_SOURCES_LUA))
-##upx_SOURCES_LUA := $(filter-out %luac.c, $(upx_SOURCES_LUA))
-##upx_OBJECTS_LUA := $(notdir $(upx_SOURCES_LUA:.c=$(objext)))
-##upx_OBJECTS_LUA := $(addprefix lua_,$(upx_OBJECTS_LUA))
-##upx_OBJECTS     += $(upx_OBJECTS_LUA)
-else
-##$(error please set UPX_LUADIR)
-endif
 
 
 all: upx$(exeext)
+.DELETE_ON_ERROR: upx$(exeext) $(upx_OBJECTS)
 
 upx$(exeext): $(upx_OBJECTS) $(upx_DEPENDENCIES)
 	$($(notdir $@).PRE_LINK_STEP)
@@ -86,16 +74,6 @@ compress_lzma$(objext) : CXXFLAGS += -Wno-unused
 ##compress_lzma$(objext) : CXXFLAGS += -Wno-error
 endif
 
-ifneq ($(strip $(upx_OBJECTS_LUA)),)
-$(upx_OBJECTS_LUA) : lua_%.o : $(UPX_LUADIR)/src/%.c
-	$(strip $(CXX) $(call e,CPPFLAGS) $(call e,CXXFLAGS) -o $@ -c $<)
-ifeq ($(USE_GNUC),1)
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-cast-align
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-cast-qual
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-error
-endif
-endif
-
 
 mostlyclean clean distclean maintainer-clean:
 	rm -f *.d *.map *.o *.obj *.res upx.exe upx.out upx.ttp upx$(exeext)

src/bele.h

@@ -246,6 +246,58 @@ inline acc_int64l_t get_le64_signed(const void *p)
 }
 
 
+/*************************************************************************
+// swab (bswap)
+**************************************************************************/
+
+inline unsigned acc_swab16(unsigned v)
+{
+    return ((v & 0x00ff) << 8) |
+           ((v & 0xff00) >> 8);
+}
+
+inline unsigned acc_swab32(unsigned v)
+{
+    return ((v & 0x000000ff) << 24) |
+           ((v & 0x0000ff00) <<  8) |
+           ((v & 0x00ff0000) >>  8) |
+           ((v & 0xff000000) >> 24);
+}
+
+
+inline unsigned acc_swab16p(const acc_uint16e_t *p)
+{
+    return acc_swab16(*p);
+}
+
+inline unsigned acc_swap32p(const acc_uint32e_t *p)
+{
+    return acc_swab32(*p);
+}
+
+
+inline void acc_swab16s(acc_uint16e_t *p)
+{
+    *p = acc_swab16(*p);
+}
+
+inline void acc_swab32s(acc_uint32e_t *p)
+{
+    *p = acc_swab32(*p);
+}
+
+
+inline void acc_ua_swab16s(void *p)
+{
+    set_be16(p, get_le16(p));
+}
+
+inline void acc_ua_swab32s(void *p)
+{
+    set_be32(p, get_le32(p));
+}
+
+
 /*************************************************************************
 // classes for portable unaligned access
 //
@@ -496,12 +548,16 @@ namespace N_BELE_CTP {
 #define BELE_CTP 1
 #include "bele_policy.h"
 #undef BELE_CTP
+extern const BEPolicy be_policy;
+extern const LEPolicy le_policy;
 }
 
 namespace N_BELE_RTP {
 #define BELE_RTP 1
 #include "bele_policy.h"
 #undef BELE_RTP
+extern const BEPolicy be_policy;
+extern const LEPolicy le_policy;
 }
 
 

src/bele_policy.h

@@ -53,6 +53,7 @@
 #if defined(BELE_RTP)
 struct AbstractPolicy
 {
+    AbstractPolicy() {}
     virtual inline ~AbstractPolicy() {}
     V bool isBE() C = 0;
     V bool isLE() C = 0;
@@ -81,6 +82,9 @@ struct AbstractPolicy
     S u24_compare_signed(const void *a, const void *b) C = 0;
     S u32_compare_signed(const void *a, const void *b) C = 0;
     S u64_compare_signed(const void *a, const void *b) C = 0;
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
 };
 #endif
 
@@ -90,6 +94,7 @@ struct BEPolicy
     : public AbstractPolicy
 #endif
 {
+    BEPolicy() {}
 #if defined(BELE_CTP)
     typedef N_BELE_RTP::BEPolicy RTP_Policy;
     enum { isBE = 1, isLE = 0 };
@@ -156,6 +161,9 @@ struct BEPolicy
         COMPILE_TIME_ASSERT_ALIGNOF(U32, char)
         COMPILE_TIME_ASSERT_ALIGNOF(U64, char)
     }
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
 };
 
 
@@ -164,6 +172,7 @@ struct LEPolicy
     : public AbstractPolicy
 #endif
 {
+    LEPolicy() {}
 #if defined(BELE_CTP)
     typedef N_BELE_RTP::LEPolicy RTP_Policy;
     enum { isBE = 0, isLE = 1 };
@@ -230,6 +239,9 @@ struct LEPolicy
         COMPILE_TIME_ASSERT_ALIGNOF(U32, char)
         COMPILE_TIME_ASSERT_ALIGNOF(U64, char)
     }
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
 };
 
 

src/compress.cpp

@@ -106,7 +106,7 @@ int upx_compress           ( const upx_bytep src, unsigned  src_len,
     cresult->c_len = 0;
 #endif
 
-    if (method < 0) {
+    if (0) {
     }
 #if defined(WITH_LZMA)
     else if (M_IS_LZMA(method))
@@ -152,7 +152,7 @@ int upx_decompress         ( const upx_bytep src, unsigned  src_len,
     if (cresult && cresult->method == 0)
         cresult = NULL;
 
-    if (method < 0) {
+    if (0) {
     }
 #if defined(WITH_LZMA)
     else if (M_IS_LZMA(method))
@@ -165,6 +165,10 @@ int upx_decompress         ( const upx_bytep src, unsigned  src_len,
 #if defined(WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_decompress(src, src_len, dst, dst_len, method, cresult);
+#endif
+#if defined(WITH_ZLIB)
+    else if (M_IS_DEFLATE(method))
+        r = upx_zlib_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
     else {
         throwInternalError("unknown decompression method");
@@ -193,7 +197,7 @@ int upx_test_overlap       ( const upx_bytep buf, unsigned src_off,
     unsigned overlap_overhead = src_off + src_len - *dst_len;
     assert((int)overlap_overhead > 0);
 
-    if (method < 0) {
+    if (0) {
     }
 #if defined(WITH_LZMA)
     else if (M_IS_LZMA(method))

src/compress.h

@@ -35,6 +35,7 @@
 **************************************************************************/
 
 #if defined(WITH_LZMA)
+const char *upx_lzma_version_string(void);
 int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -53,6 +54,7 @@ int upx_lzma_test_overlap  ( const upx_bytep buf, unsigned src_off,
 
 
 #if defined(WITH_NRV)
+const char *upx_nrv_version_string(void);
 int upx_nrv_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -71,6 +73,7 @@ int upx_nrv_test_overlap   ( const upx_bytep buf, unsigned src_off,
 
 
 #if defined(WITH_UCL)
+const char *upx_ucl_version_string(void);
 int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -87,6 +90,24 @@ int upx_ucl_test_overlap   ( const upx_bytep buf, unsigned src_off,
                              const upx_compress_result_t *cresult );
 #endif
 
+#if defined(WITH_ZLIB)
+const char *upx_zlib_version_string(void);
+int upx_zlib_compress      ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult );
+int upx_zlib_decompress    ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+int upx_zlib_test_overlap  ( const upx_bytep buf, unsigned src_off,
+                                   unsigned  src_len, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+#endif
+
 
 #endif /* already included */
 

src/compress_lzma.cpp

@@ -28,6 +28,24 @@
 
 #include "conf.h"
 #include "compress.h"
+
+
+void lzma_compress_config_t::reset()
+{
+    memset(this, 0, sizeof(*this));
+
+    pos_bits.reset();
+    lit_pos_bits.reset();
+    lit_context_bits.reset();
+    dict_size.reset();
+    fast_mode = 2;
+    num_fast_bytes.reset();
+    match_finder_cycles = 0;
+
+    max_num_probs = 0;
+}
+
+
 #if !defined(WITH_LZMA)
 extern int compress_lzma_dummy;
 int compress_lzma_dummy = 0;
@@ -151,6 +169,19 @@ STDMETHODIMP ProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outS
 } // namespace
 
 
+#include "C/Common/Alloc.cpp"
+#include "C/Common/CRC.cpp"
+//#include "C/7zip/Common/InBuffer.cpp"
+#include "C/7zip/Common/OutBuffer.cpp"
+#include "C/7zip/Common/StreamUtils.cpp"
+#include "C/7zip/Compress/LZ/LZInWindow.cpp"
+//#include "C/7zip/Compress/LZ/LZOutWindow.cpp"
+//#include "C/7zip/Compress/LZMA/LZMADecoder.cpp"
+#include "C/7zip/Compress/LZMA/LZMAEncoder.cpp"
+#include "C/7zip/Compress/RangeCoder/RangeCoderBit.cpp"
+#undef RC_NORMALIZE
+
+
 int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -163,6 +194,7 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
 
     int r = UPX_E_ERROR;
     HRESULT rh;
+    const lzma_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_lzma : NULL;
     lzma_compress_result_t *res = &cresult->result_lzma;
 
     MyLzma::InStreamRam is; is.AddRef();
@@ -174,27 +206,41 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
     progress.cb = cb;
 
     NCompress::NLZMA::CEncoder enc;
-    const PROPID propIDs[7] = {
+    const PROPID propIDs[8] = {
         NCoderPropID::kPosStateBits,        // 0  pb    _posStateBits(2)
         NCoderPropID::kLitPosBits,          // 1  lp    _numLiteralPosStateBits(0)
         NCoderPropID::kLitContextBits,      // 2  lc    _numLiteralContextBits(3)
-        NCoderPropID::kDictionarySize,      // 3
+        NCoderPropID::kDictionarySize,      // 3  ds
-        NCoderPropID::kAlgorithm,           // 4      _fastmode
+        NCoderPropID::kAlgorithm,           // 4  fm    _fastmode
-        NCoderPropID::kNumFastBytes,        // 5
+        NCoderPropID::kNumFastBytes,        // 5  fb
-        NCoderPropID::kMatchFinderCycles    // 6
+        NCoderPropID::kMatchFinderCycles,   // 6  mfc   _matchFinderCycles, _cutValue
+        NCoderPropID::kMatchFinder          // 7  mf
     };
-    PROPVARIANT pr[7];
+    PROPVARIANT pr[8];
     pr[0].vt = pr[1].vt = pr[2].vt = pr[3].vt = VT_UI4;
     pr[4].vt = pr[5].vt = pr[6].vt = VT_UI4;
+    pr[7].vt = VT_BSTR;
 
     // setup defaults
     pr[0].uintVal = 2;                  // 0 .. 4
     pr[1].uintVal = 0;                  // 0 .. 4
     pr[2].uintVal = 3;                  // 0 .. 8
-    pr[3].uintVal = 1024 * 1024;
+    pr[3].uintVal = 4 * 1024 * 1024;    // 1 .. 2**30
     pr[4].uintVal = 2;
-    pr[5].uintVal = 64;             // 5..
+    pr[5].uintVal = 64;                 // 5 .. 273
     pr[6].uintVal = 0;
+#ifdef COMPRESS_MF_BT4
+    static wchar_t matchfinder[] = L"BT4";
+#endif
+    assert(NCompress::NLZMA::FindMatchFinder(matchfinder) >= 0);
+    pr[7].bstrVal = matchfinder;
+#if 1
+    pr[0].uintVal = lzma_compress_config_t::pos_bits_t::default_value_c;
+    pr[1].uintVal = lzma_compress_config_t::lit_pos_bits_t::default_value_c;
+    pr[2].uintVal = lzma_compress_config_t::lit_context_bits_t::default_value_c;
+    pr[3].uintVal = lzma_compress_config_t::dict_size_t::default_value_c;
+    pr[5].uintVal = lzma_compress_config_t::num_fast_bytes_t::default_value_c;
+#endif
 #if 0
     // DEBUG - set sizes so that we use a maxmimum amount of stack.
     //  These settings cause res->num_probs == 3147574, i.e. we will
@@ -209,8 +255,11 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
     case 1:
         pr[3].uintVal = 256 * 1024;
         pr[4].uintVal = 0;
+        pr[5].uintVal = 8;
         break;
     case 2:
+        pr[3].uintVal = 256 * 1024;
+        pr[4].uintVal = 0;
         break;
     case 3:
         break;
@@ -234,17 +283,27 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
         goto error;
     }
 
+    // cconf overrides
+    if (lcconf)
+    {
+        oassign(pr[0].uintVal, lcconf->pos_bits);
+        oassign(pr[1].uintVal, lcconf->lit_pos_bits);
+        oassign(pr[2].uintVal, lcconf->lit_context_bits);
+        oassign(pr[3].uintVal, lcconf->dict_size);
+        oassign(pr[5].uintVal, lcconf->num_fast_bytes);
+    }
+
     // limit dictionary size
     if (pr[3].uintVal > src_len)
         pr[3].uintVal = src_len;
 
     // limit num_probs
-    if (cconf_parm && cconf_parm->conf_lzma.max_num_probs)
+    if (lcconf && lcconf->max_num_probs)
     {
         for (;;)
         {
             unsigned n = 1846 + (768 << (pr[2].uintVal + pr[1].uintVal));
-            if (n <= cconf_parm->conf_lzma.max_num_probs)
+            if (n <= lcconf->max_num_probs)
                 break;
             if (pr[1].uintVal > pr[2].uintVal)
             {
@@ -265,9 +324,13 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
     res->lit_pos_bits = pr[1].uintVal;
     res->lit_context_bits = pr[2].uintVal;
     res->dict_size = pr[3].uintVal;
+    res->fast_mode = pr[4].uintVal;
+    res->num_fast_bytes = pr[5].uintVal;
+    res->match_finder_cycles = pr[6].uintVal;
     //res->num_probs = LzmaGetNumProbs(&s.Properties));
     //res->num_probs = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
     res->num_probs = 1846 + (768 << (res->lit_context_bits + res->lit_pos_bits));
+    //printf("\nlzma_compress config: %u %u %u %u %u\n", res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs);
 
 #ifndef _NO_EXCEPTIONS
     try {
@@ -275,7 +338,7 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
 #  error
 #endif
 
-    if (enc.SetCoderProperties(propIDs, pr, 7) != S_OK)
+    if (enc.SetCoderProperties(propIDs, pr, 8) != S_OK)
         goto error;
     if (enc.WriteCoderProperties(&os) != S_OK)
         goto error;
@@ -323,19 +386,6 @@ error:
 }
 
 
-#include "C/Common/Alloc.cpp"
-#include "C/Common/CRC.cpp"
-//#include "C/7zip/Common/InBuffer.cpp"
-#include "C/7zip/Common/OutBuffer.cpp"
-#include "C/7zip/Common/StreamUtils.cpp"
-#include "C/7zip/Compress/LZ/LZInWindow.cpp"
-//#include "C/7zip/Compress/LZ/LZOutWindow.cpp"
-//#include "C/7zip/Compress/LZMA/LZMADecoder.cpp"
-#include "C/7zip/Compress/LZMA/LZMAEncoder.cpp"
-#include "C/7zip/Compress/RangeCoder/RangeCoderBit.cpp"
-#undef RC_NORMALIZE
-
-
 /*************************************************************************
 // decompress
 **************************************************************************/
@@ -391,6 +441,9 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
         assert(cresult->result_lzma.lit_pos_bits == (unsigned) s.Properties.lp);
         assert(cresult->result_lzma.lit_context_bits == (unsigned) s.Properties.lc);
         assert(cresult->result_lzma.num_probs == (unsigned) LzmaGetNumProbs(&s.Properties));
+        const lzma_compress_result_t *res = &cresult->result_lzma;
+        UNUSED(res);
+        //printf("\nlzma_decompress config: %u %u %u %u %u\n", res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs);
     }
     s.Probs = (CProb *) malloc(sizeof(CProb) * LzmaGetNumProbs(&s.Properties));
     if (!s.Probs)
@@ -443,6 +496,18 @@ int upx_lzma_test_overlap  ( const upx_bytep buf, unsigned src_off,
 }
 
 
+/*************************************************************************
+// misc
+**************************************************************************/
+
+const char *upx_lzma_version_string(void)
+{
+    // FIXME
+//    return NULL;
+    return "4.43";
+}
+
+
 #endif /* WITH_LZMA */
 /*
 vi:ts=4:et:nowrap

src/compress_ucl.cpp

@@ -107,6 +107,8 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
     int r;
     assert(level > 0); assert(cresult != NULL);
 
+    COMPILE_TIME_ASSERT(sizeof(ucl_compress_config_t) == sizeof(REAL_ucl_compress_config_t))
+
     ucl_progress_callback_t cb;
     cb.callback = 0;
     cb.user = NULL;
@@ -115,8 +117,7 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
         cb.user = cb_parm;
     }
 
-    ucl_compress_config_t cconf;
+    ucl_compress_config_t cconf; cconf.reset();
-    memset(&cconf, 0xff, sizeof(cconf));
     if (cconf_parm)
         cconf = cconf_parm->conf_ucl; // struct copy
 
@@ -268,6 +269,16 @@ int upx_ucl_test_overlap   ( const upx_bytep buf, unsigned src_off,
 }
 
 
+/*************************************************************************
+// misc
+**************************************************************************/
+
+const char *upx_ucl_version_string(void)
+{
+    return ucl_version_string();
+}
+
+
 #endif /* WITH_UCL */
 /*
 vi:ts=4:et:nowrap

src/compress_zlib.cpp

@@ -0,0 +1,230 @@
+/* compress_zlib.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2006 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+ */
+
+
+#include "conf.h"
+#include "compress.h"
+
+
+void zlib_compress_config_t::reset()
+{
+    memset(this, 0, sizeof(*this));
+
+    mem_level.reset();
+    window_bits.reset();
+    strategy.reset();
+}
+
+
+#if !defined(WITH_ZLIB)
+extern int compress_zlib_dummy;
+int compress_zlib_dummy = 0;
+#else
+
+#include <zlib.h>
+
+
+static int convert_errno_from_zlib(int zr)
+{
+    switch (zr)
+    {
+    case Z_OK:                  return UPX_E_OK;
+    case Z_DATA_ERROR:          return UPX_E_ERROR;
+    case Z_NEED_DICT:           return UPX_E_ERROR;
+    }
+    return UPX_E_ERROR;
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_zlib_compress      ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb_parm,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf_parm,
+                                   upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+    assert(level > 0); assert(cresult != NULL);
+    UNUSED(cb_parm);
+    int r = UPX_E_ERROR;
+    int zr;
+    const zlib_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_zlib : NULL;
+    zlib_compress_result_t *res = &cresult->result_zlib;
+
+    if (level == 10)
+        level = 9;
+
+    zlib_compress_config_t::mem_level_t mem_level;
+    zlib_compress_config_t::window_bits_t window_bits;
+    zlib_compress_config_t::strategy_t strategy;
+    // cconf overrides
+    if (lcconf)
+    {
+        oassign(mem_level, lcconf->mem_level);
+        oassign(window_bits, lcconf->window_bits);
+        oassign(strategy, lcconf->strategy);
+    }
+
+    res->dummy = 0;
+
+    z_stream s;
+    s.zalloc = (alloc_func) 0;
+    s.zfree = (free_func) 0;
+    s.next_in = const_cast<upx_bytep>(src); // UNCONST
+    s.avail_in = src_len;
+    s.next_out = dst;
+    s.avail_out = *dst_len;
+    s.total_in = s.total_out = 0;
+
+    zr = deflateInit2(&s, level, Z_DEFLATED, 0 - (int)window_bits,
+                      mem_level, strategy);
+    if (zr != Z_OK)
+        goto error;
+    zr = deflate(&s, Z_FINISH);
+    if (zr != Z_STREAM_END)
+        goto error;
+    zr = deflateEnd(&s);
+    if (zr != Z_OK)
+        goto error;
+    r = UPX_E_OK;
+    goto done;
+error:
+    (void) deflateEnd(&s);
+    r = convert_errno_from_zlib(zr);
+    if (r == UPX_E_OK)
+        r = UPX_E_ERROR;
+done:
+    if (r == UPX_E_OK)
+    {
+        if (s.avail_in != 0 || s.total_in != src_len)
+            r = UPX_E_ERROR;
+    }
+    assert(s.total_in  <=  src_len);
+    assert(s.total_out <= *dst_len);
+    *dst_len = s.total_out;
+    return r;
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_zlib_decompress    ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+    UNUSED(method);
+    UNUSED(cresult);
+    int r = UPX_E_ERROR;
+    int zr;
+
+    z_stream s;
+    s.zalloc = (alloc_func) 0;
+    s.zfree = (free_func) 0;
+    s.next_in = const_cast<upx_bytep>(src); // UNCONST
+    s.avail_in = src_len;
+    s.next_out = dst;
+    s.avail_out = *dst_len;
+    s.total_in = s.total_out = 0;
+
+    zr = inflateInit2(&s, -15);
+    if (zr != Z_OK)
+        goto error;
+    zr = inflate(&s, Z_FINISH);
+    if (zr != Z_STREAM_END)
+        goto error;
+    zr = inflateEnd(&s);
+    if (zr != Z_OK)
+        goto error;
+    r = UPX_E_OK;
+    goto done;
+error:
+    (void) inflateEnd(&s);
+    r = convert_errno_from_zlib(zr);
+    if (r == UPX_E_OK)
+        r = UPX_E_ERROR;
+done:
+    if (r == UPX_E_OK)
+    {
+        if (s.avail_in != 0 || s.total_in != src_len)
+            r = UPX_E_INPUT_NOT_CONSUMED;
+    }
+    assert(s.total_in  <=  src_len);
+    assert(s.total_out <= *dst_len);
+    *dst_len = s.total_out;
+    return r;
+}
+
+
+/*************************************************************************
+// test_overlap
+**************************************************************************/
+
+int upx_zlib_test_overlap  ( const upx_bytep buf, unsigned src_off,
+                                   unsigned  src_len, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+
+    // FIXME - implement this
+    // Note that Packer::verifyOverlappingDecompression() will
+    // verify the final result in any case.
+    UNUSED(buf);
+
+    unsigned overlap_overhead = src_off + src_len - *dst_len;
+    //printf("upx_zlib_test_overlap: %d\n", overlap_overhead);
+    if ((int)overlap_overhead >= 256)
+        return UPX_E_OK;
+
+    UNUSED(cresult);
+    return UPX_E_ERROR;
+}
+
+
+/*************************************************************************
+// misc
+**************************************************************************/
+
+const char *upx_zlib_version_string(void)
+{
+    return zlibVersion();
+}
+
+
+#endif /* WITH_ZLIB */
+/*
+vi:ts=4:et:nowrap
+*/
+

src/conf.h

@@ -40,8 +40,16 @@
 #if ((ACC_OS_WIN32 || ACC_OS_WIN64) && ACC_CC_MWERKS) && defined(__MSL__)
 #  undef HAVE_UTIME_H /* this pulls in <windows.h> */
 #endif
+// FIXME - quick hack for arm-wince-gcc-3.4 (Debian pocketpc-*.deb packages)
+#if 1 && (ACC_ARCH_ARM) && defined(__pe__) && !defined(_WIN32)
+#  undef HAVE_CHMOD
+#  undef HAVE_CHOWN
+#  undef HAVE_LSTAT
+#  undef HAVE_UTIME
+#endif
 
 
+// pragmas
 #if (ACC_CC_BORLANDC)
 #  if (__BORLANDC__ < 0x0500)
 #    error "need Borland C++ 5.0 or newer"
@@ -159,11 +167,14 @@
 #  include <nrv/nrvconf.h>
 #endif
 #if defined(WITH_UCL)
+#  define ucl_compress_config_t REAL_ucl_compress_config_t
 #  include <ucl/uclconf.h>
 #  include <ucl/ucl.h>
 #  if !defined(UCL_VERSION) || (UCL_VERSION < 0x010300L)
 #    error "please upgrade your UCL installation"
 #  endif
+#  undef ucl_compress_config_t
+#  undef ucl_compress_config_p
 #endif
 #if !defined(__UPX_CHECKER)
 #  if defined(__UCL_CHECKER) || defined(__NRV_CHECKER)
@@ -199,67 +210,8 @@ typedef void (__acc_cdecl *upx_progress_func_t)
 
 struct upx_callback_t
 {
-#if 0
-    upx_alloc_func_t nalloc;
-    upx_free_func_t nfree;
-#endif
     upx_progress_func_t nprogress;
     void * user1;
-#if 0
-    unsigned user2;
-    unsigned user3;
-#endif
-};
-
-
-struct lzma_compress_config_t
-{
-    unsigned max_num_probs;
-#if 0
-    unsigned pos_bits;              // pb
-    unsigned lit_pos_bits;          // lp
-    unsigned lit_context_bits;      // lc
-    unsigned dict_size;
-    unsigned mf_passes;
-#endif
-    void reset() { memset(this, 0, sizeof(*this)); }
-};
-
-#define upx_compress_config_p upx_compress_config_t *
-struct upx_compress_config_t
-{
-    lzma_compress_config_t  conf_lzma;
-    ucl_compress_config_t   conf_ucl;
-    void reset() {
-        conf_lzma.reset();
-        memset(&conf_ucl, 0xff, sizeof(conf_ucl));
-    }
-};
-
-
-struct lzma_compress_result_t
-{
-    unsigned pos_bits;              // pb
-    unsigned lit_pos_bits;          // lp
-    unsigned lit_context_bits;      // lc
-    unsigned dict_size;
-    unsigned num_probs;
-};
-
-struct ucl_compress_result_t
-{
-    ucl_uint result[16];
-};
-
-struct upx_compress_result_t
-{
-#if 1
-    // debug
-    int method, level;
-    unsigned u_len, c_len;
-#endif
-    lzma_compress_result_t  result_lzma;
-    ucl_compress_result_t   result_ucl;
 };
 
 
@@ -270,18 +222,6 @@ struct upx_compress_result_t
 // malloc debuggers
 #if defined(WITH_VALGRIND)
 #  include <valgrind/memcheck.h>
-#elif defined(WITH_DMALLOC)
-#  define DMALLOC_FUNC_CHECK
-#  include <dmalloc.h>
-#elif defined(WITH_GC)
-#  define GC_DEBUG
-#  include <gc/gc.h>
-#  undef malloc
-#  undef realloc
-#  undef free
-#  define malloc            GC_MALLOC
-#  define realloc           GC_REALLOC
-#  define free              GC_FREE
 #endif
 
 #if !defined(VALGRIND_MAKE_WRITABLE)
@@ -299,6 +239,7 @@ struct upx_compress_result_t
 #endif
 
 
+// unconditionally turn on assertions
 #undef NDEBUG
 #include <assert.h>
 
@@ -433,39 +374,6 @@ struct upx_compress_result_t
 
 #define UPX_MAX(a,b)        ((a) >= (b) ? (a) : (b))
 #define UPX_MIN(a,b)        ((a) <= (b) ? (a) : (b))
-#define UPX_MAX3(a,b,c)     ((a) >= (b) ? UPX_MAX(a,c) : UPX_MAX(b,c))
-#define UPX_MIN3(a,b,c)     ((a) <= (b) ? UPX_MIN(a,c) : UPX_MIN(b,c))
-
-
-#if 0 && defined(__cplusplus) && !defined(new) && !defined(delete)
-// global operators - debug
-inline void *operator new(size_t l)
-{
-    void *p = malloc(l);
-    printf("new   %6ld %p\n",(long)l,p);
-    fflush(stdout);
-    return p;
-}
-inline void *operator new[](size_t l)
-{
-    void *p = malloc(l);
-    printf("new[] %6ld %p\n",(long)l,p);
-    fflush(stdout);
-    return p;
-}
-inline void operator delete(void *p)
-{
-    printf("delete       %p\n",p);
-    fflush(stdout);
-    if (p) free(p);
-}
-inline void operator delete[](void *p)
-{
-    printf("delete[]     %p\n",p);
-    fflush(stdout);
-    if (p) free(p);
-}
-#endif
 
 
 // An Array allocates memory on the heap, but automatically
@@ -477,6 +385,14 @@ inline void operator delete[](void *p)
 
 #define ByteArray(var, size)    Array(unsigned char, var, size)
 
+struct nocopy
+{
+    inline nocopy() {}
+private:
+    nocopy(const nocopy &); // undefined
+    nocopy& operator=(const nocopy &); // undefined
+};
+
 
 /*************************************************************************
 // constants
@@ -512,12 +428,14 @@ inline void operator delete[](void *p)
 #define M_CL1B_8        12
 #define M_CL1B_LE16     13
 #define M_LZMA          14
+#define M_DEFLATE       15      /* zlib */
 
 #define M_IS_NRV2B(x)   ((x) >= M_NRV2B_LE32 && (x) <= M_NRV2B_LE16)
 #define M_IS_NRV2D(x)   ((x) >= M_NRV2D_LE32 && (x) <= M_NRV2D_LE16)
 #define M_IS_NRV2E(x)   ((x) >= M_NRV2E_LE32 && (x) <= M_NRV2E_LE16)
 #define M_IS_CL1B(x)    ((x) >= M_CL1B_LE32  && (x) <= M_CL1B_LE16)
 #define M_IS_LZMA(x)    ((x) == M_LZMA)
+#define M_IS_DEFLATE(x) ((x) == M_DEFLATE)
 
 
 // Executable formats. Note: big endian types are >= 128.
@@ -544,7 +462,6 @@ inline void operator delete[](void *p)
 #define UPX_F_WINCE_ARM_PE      21
 #define UPX_F_LINUX_ELF64_AMD   22
 #define UPX_F_LINUX_ELF32_ARMLE 23
-
 #define UPX_F_BSD_i386          24
 #define UPX_F_BSD_ELF_i386      25
 #define UPX_F_BSD_SH_i386       26
@@ -562,6 +479,165 @@ inline void operator delete[](void *p)
 #define UPX_MAGIC2_LE32     0xD5D0D8A1
 
 
+/*************************************************************************
+// compression - config_t
+**************************************************************************/
+
+template <class T, T default_value, T min_value, T max_value>
+struct OptVar
+{
+    typedef T Type;
+    static const T default_value_c = default_value;
+    static const T min_value_c = min_value;
+    static const T max_value_c = max_value;
+
+    void assertValue() {
+        // FIXME: this generates annoying warnings "unsigned >= 0 is always true"
+        //assert((v >= min_value) && (v <= max_value));
+    }
+
+    OptVar() : v(default_value), is_set(0) { }
+    OptVar& operator= (const T other) {
+        v = other; is_set += 1;
+        assertValue();
+        return *this;
+    }
+#if 0
+#error
+    // there is too much implicit magic in this copy operator;
+    // better introduce an explicit "oassign" function.
+    OptVar& operator= (const OptVar& other) {
+        if (other.is_set) { v = other.v; is_set += 1; }
+        assertValue(); return *this;
+    }
+#endif
+
+    void reset() { v = default_value; is_set = 0; }
+    operator T () const { return v; }
+
+    T v;
+    unsigned is_set;
+};
+
+
+// optional assignments
+template <class T> void oassign(T& self, const T& other) {
+    if (other.is_set) { self.v = other.v; self.is_set += 1; }
+}
+#if 0
+template <class V, class T> void oassign(V& v, const T& other) {
+    if (other.is_set) { v = other.v; }
+}
+#else
+template <class T> void oassign(unsigned& v, const T& other) {
+    if (other.is_set) { v = other.v; }
+}
+#endif
+
+
+struct lzma_compress_config_t
+{
+    typedef OptVar<unsigned,  2u, 0u,   4u> pos_bits_t;             // pb
+    typedef OptVar<unsigned,  0u, 0u,   4u> lit_pos_bits_t;         // lb
+    typedef OptVar<unsigned,  3u, 0u,   8u> lit_context_bits_t;     // lc
+    typedef OptVar<unsigned, (1u<<22), 1u, (1u<<30) > dict_size_t;
+    typedef OptVar<unsigned, 64u, 5u, 273u> num_fast_bytes_t;
+
+    pos_bits_t          pos_bits;           // pb
+    lit_pos_bits_t      lit_pos_bits;       // lp
+    lit_context_bits_t  lit_context_bits;   // lc
+    dict_size_t         dict_size;
+    unsigned            fast_mode;
+    num_fast_bytes_t    num_fast_bytes;
+    unsigned            match_finder_cycles;
+
+    unsigned            max_num_probs;
+
+    void reset();
+};
+
+
+struct ucl_compress_config_t : public REAL_ucl_compress_config_t
+{
+    void reset() { memset(this, 0xff, sizeof(*this)); }
+};
+
+
+struct zlib_compress_config_t
+{
+    typedef OptVar<unsigned,  8u, 1u,   9u> mem_level_t;            // ml
+    typedef OptVar<unsigned, 15u, 9u,  15u> window_bits_t;          // wb
+    typedef OptVar<unsigned,  0u, 0u,   4u> strategy_t;             // st
+
+    mem_level_t         mem_level;          // ml
+    window_bits_t       window_bits;        // wb
+    strategy_t          strategy;           // st
+
+    void reset();
+};
+
+
+struct upx_compress_config_t
+{
+    lzma_compress_config_t  conf_lzma;
+    ucl_compress_config_t   conf_ucl;
+    zlib_compress_config_t  conf_zlib;
+    void reset() { conf_lzma.reset(); conf_ucl.reset(); conf_zlib.reset(); }
+};
+
+
+/*************************************************************************
+// compression - result_t
+**************************************************************************/
+
+struct lzma_compress_result_t
+{
+    unsigned pos_bits;              // pb
+    unsigned lit_pos_bits;          // lp
+    unsigned lit_context_bits;      // lc
+    unsigned dict_size;
+    unsigned fast_mode;
+    unsigned num_fast_bytes;
+    unsigned match_finder_cycles;
+    unsigned num_probs;             // (computed result)
+
+    void reset() { memset(this, 0, sizeof(*this)); }
+};
+
+
+struct ucl_compress_result_t
+{
+    ucl_uint result[16];
+
+    void reset() { memset(this, 0, sizeof(*this)); }
+};
+
+
+struct zlib_compress_result_t
+{
+    unsigned dummy;
+
+    void reset() { memset(this, 0, sizeof(*this)); }
+};
+
+
+struct upx_compress_result_t
+{
+    // debug
+    int method, level;
+    unsigned u_len, c_len;
+
+    lzma_compress_result_t  result_lzma;
+    ucl_compress_result_t   result_ucl;
+    zlib_compress_result_t  result_zlib;
+
+    void reset() {
+        memset(this, 0, sizeof(*this));
+        result_lzma.reset(); result_ucl.reset(); result_zlib.reset();
+    }
+};
+
+
 /*************************************************************************
 // globals
 **************************************************************************/
@@ -632,7 +708,7 @@ void do_files(int i, int argc, char *argv[]);
 
 // help.cpp
 void show_head(void);
-void show_help(int x = 0);
+void show_help(int verbose=0);
 void show_license(void);
 void show_usage(void);
 void show_version(int);

src/except.cpp

@@ -85,6 +85,11 @@ void throwCantPack(const char *msg)
         throw CantUnpackException(msg);
 }
 
+void throwCantPackExact()
+{
+    throwCantPack("option '--exact' does not work with this file");
+}
+
 void throwFilterException()
 {
     throwCantPack("filter problem");

src/except.h

@@ -208,6 +208,7 @@ public:
 #endif
 
 void throwCantPack(const char *msg) NORET;
+void throwCantPackExact() NORET;
 void throwUnknownExecutableFormat(const char *msg = NULL, bool warn = false) NORET;
 void throwNotCompressible(const char *msg = NULL) NORET;
 void throwAlreadyPacked(const char *msg = NULL) NORET;

src/help.cpp

@@ -27,6 +27,7 @@
 
 
 #include "conf.h"
+#include "compress.h"
 
 
 /*************************************************************************
@@ -88,7 +89,7 @@ void show_usage(void)
 //
 **************************************************************************/
 
-void show_help(int x)
+void show_help(int x/*verbose*/)
 {
     FILE *f = con_term;
     int fg;
@@ -340,27 +341,43 @@ void show_license(void)
 
 void show_version(int x)
 {
-    FILE *f = stdout;
+    FILE *fp = stdout;
+    const char *v;
     UNUSED(x);
+    UNUSED(v);
 
-    fprintf(f,"upx %s\n", UPX_VERSION_STRING);
+    fprintf(fp, "upx %s\n", UPX_VERSION_STRING);
 #if defined(WITH_NRV)
-    fprintf(f,"NRV data compression library %s\n", nrv_version_string());
+    v = upx_nrv_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "NRV data compression library %s\n", v);
 #endif
 #if defined(WITH_UCL)
-    fprintf(f,"UCL data compression library %s\n", ucl_version_string());
+    v = upx_ucl_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "UCL data compression library %s\n", v);
 #endif
-#if 0 && defined(WITH_LZMA)
+#if defined(WITH_ZLIB)
-    fprintf(f,"LZMA SDK version ???\n");
+    v = upx_zlib_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "zlib data compression library %s\n", v);
 #endif
-    fprintf(f,"Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer\n");
-    fprintf(f,"Copyright (C) 1996-2006 Laszlo Molnar\n");
-    fprintf(f,"Copyright (C) 2000-2006 John F. Reiser\n");
-    fprintf(f,"Copyright (C) 2002-2006 Jens Medoch\n");
 #if defined(WITH_LZMA)
-    fprintf(f,"Copyright (C) 1999-2006 Igor Pavlov\n");
+    v = upx_lzma_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "LZMA SDK version %s\n", v);
 #endif
-    fprintf(f,"UPX comes with ABSOLUTELY NO WARRANTY; for details type `%s -L'.\n", progname);
+    fprintf(fp, "Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer\n");
+    fprintf(fp, "Copyright (C) 1996-2006 Laszlo Molnar\n");
+    fprintf(fp, "Copyright (C) 2000-2006 John F. Reiser\n");
+    fprintf(fp, "Copyright (C) 2002-2006 Jens Medoch\n");
+#if defined(WITH_ZLIB)
+    fprintf(fp, "Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler\n");
+#endif
+#if defined(WITH_LZMA)
+    fprintf(fp, "Copyright (C) 1999-2006 Igor Pavlov\n");
+#endif
+    fprintf(fp, "UPX comes with ABSOLUTELY NO WARRANTY; for details type `%s -L'.\n", progname);
 }
 
 

src/linker.cpp

@@ -29,7 +29,7 @@
 #include "conf.h"
 #include "linker.h"
 
-static int hex(unsigned char c)
+static unsigned hex(unsigned char c)
 {
     return (c & 0xf) + (c > '9' ? 9 : 0);
 }
@@ -45,17 +45,20 @@ static bool update_capacity(unsigned size, unsigned *capacity)
     return true;
 }
 
+
 /*************************************************************************
-//
+// Section
 **************************************************************************/
 
 ElfLinker::Section::Section(const char *n, const void *i, unsigned s, unsigned a) :
-    name(strdup(n)), output(NULL), size(s), offset(0), align(a), next(NULL)
+    name(NULL), output(NULL), size(s), offset(0), p2align(a), next(NULL)
 {
-    assert(name);
+    name = strdup(n);
+    assert(name != NULL);
     input = malloc(s + 1);
-    assert(input);
+    assert(input != NULL);
     memcpy(input, i, s);
+    ((char *)input)[s] = 0;
 }
 
 ElfLinker::Section::~Section()
@@ -64,10 +67,17 @@ ElfLinker::Section::~Section()
     free(input);
 }
 
+
+/*************************************************************************
+// Symbol
+**************************************************************************/
+
 ElfLinker::Symbol::Symbol(const char *n, Section *s, unsigned o) :
-    name(strdup(n)), section(s), offset(o)
+    name(NULL), section(s), offset(o)
 {
-    assert(name);
+    name = strdup(n);
+    assert(name != NULL);
+    assert(section != NULL);
 }
 
 ElfLinker::Symbol::~Symbol()
@@ -75,12 +85,110 @@ ElfLinker::Symbol::~Symbol()
     free(name);
 }
 
+
+/*************************************************************************
+// Relocation
+**************************************************************************/
+
 ElfLinker::Relocation::Relocation(const Section *s, unsigned o, const char *t,
                                   const Symbol *v, unsigned a) :
     section(s), offset(o), type(t), value(v), add(a)
-{}
+{
+    assert(section != NULL);
+}
 
 
+/*************************************************************************
+// ElfLinker
+**************************************************************************/
+
+ElfLinker::ElfLinker() :
+    bele(&N_BELE_RTP::le_policy),
+    input(NULL), output(NULL), head(NULL), tail(NULL),
+    sections(NULL), symbols(NULL), relocations(NULL),
+    nsections(0), nsections_capacity(0),
+    nsymbols(0), nsymbols_capacity(0),
+    nrelocations(0), nrelocations_capacity(0),
+    reloc_done(false)
+{
+}
+
+ElfLinker::~ElfLinker()
+{
+    delete [] input;
+    delete [] output;
+
+    unsigned ic;
+    for (ic = 0; ic < nsections; ic++)
+        delete sections[ic];
+    free(sections);
+    for (ic = 0; ic < nsymbols; ic++)
+        delete symbols[ic];
+    free(symbols);
+    for (ic = 0; ic < nrelocations; ic++)
+        delete relocations[ic];
+    free(relocations);
+}
+
+void ElfLinker::init(const void *pdata_v, int plen)
+{
+    const upx_byte *pdata = (const upx_byte *) pdata_v;
+    if (plen >= 16 && memcmp(pdata, "UPX#", 4) == 0)
+    {
+        // decompress pre-compressed stub-loader
+        int method;
+        unsigned u_len, c_len;
+        if (pdata[4])
+        {
+            method = pdata[4];
+            u_len = get_le16(pdata + 5);
+            c_len = get_le16(pdata + 7);
+            pdata += 9;
+            assert(9 + c_len == (unsigned) plen);
+        }
+        else
+        {
+            method = pdata[5];
+            u_len = get_le32(pdata + 6);
+            c_len = get_le32(pdata + 10);
+            pdata += 14;
+            assert(14 + c_len == (unsigned) plen);
+        }
+        assert((unsigned) plen < u_len);
+        inputlen = u_len;
+        input = new upx_byte[inputlen + 1];
+        unsigned new_len = u_len;
+        int r = upx_decompress(pdata, c_len, input, &new_len, method, NULL);
+        if (r != 0 || new_len != u_len)
+            throwBadLoader();
+    }
+    else
+    {
+        inputlen = plen;
+        input = new upx_byte[inputlen + 1];
+        memcpy(input, pdata, inputlen);
+    }
+    input[inputlen] = 0; // NUL terminate
+
+    output = new upx_byte[inputlen];
+    outputlen = 0;
+
+    int pos = find(input, inputlen, "Sections:", 9);
+    assert(pos != -1);
+    char *psections = (char *) input + pos;
+
+    char *psymbols = strstr(psections, "SYMBOL TABLE:");
+    assert(psymbols != NULL);
+
+    char *prelocs = strstr(psymbols, "RELOCATION RECORDS FOR");
+    assert(prelocs != NULL);
+
+    preprocessSections(psections, psymbols);
+    preprocessSymbols(psymbols, prelocs);
+    preprocessRelocations(prelocs, (char*) input + inputlen);
+    addLoader("*UND*");
+}
+
 void ElfLinker::preprocessSections(char *start, const char *end)
 {
     nsections = 0;
@@ -114,22 +222,28 @@ void ElfLinker::preprocessSymbols(char *start, const char *end)
     {
         char section[1024];
         char symbol[1024];
-        unsigned offset;
+        unsigned value, offset;
 
         char *nextl = strchr(start, '\n');
         assert(nextl != NULL);
 
-        if (sscanf(start, "%x%*8c %1024s %*x %1023s",
+        if (sscanf(start, "%x g *ABS* %x %1023s",
+                        &value, &offset, symbol) == 3)
+        {
+            char *s = strstr(start, symbol);
+            s[strlen(symbol)] = 0;
+            addSymbol(s, "*ABS*", value);
+            assert(offset == 0);
+        }
+        else if (sscanf(start, "%x%*8c %1023s %*x %1023s",
                    &offset, section, symbol) == 3)
         {
             char *s = strstr(start, symbol);
             s[strlen(symbol)] = 0;
-
             if (strcmp(section, "*UND*") == 0)
                 offset = 0xdeaddead;
+            assert(strcmp(section, "*ABS*") != 0);
             addSymbol(s, section, offset);
-
-            //printf("symbol %s preprocessed o=%x\n", s, offset);
         }
 
         start = nextl + 1;
@@ -163,60 +277,80 @@ void ElfLinker::preprocessRelocations(char *start, const char *end)
             unsigned add = 0;
             if (char *p = strstr(symbol, "+0x"))
             {
-// Beware: sscanf("0xfffffffffffffffc", "%x", &add) ==> -1 == add
-// because conversion stops after 32 bits for a non-long.
-// Also, glibc-2.3.5 has a bug: even using "%lx" still gives -1 instead of -4.
-                long addend;
                 *p = 0;  // terminate the symbol name
                 p += 3;
-                if ('f'==p[0] && 0==strncmp(p, "ffffffff", 8)) {
+
-                    p+=8;  // workaround a bug in glibc-2.3.5
+                if (strlen(p) == 16) {
+                    // skip 8 leading chars if sign of char 9 matches
+                    if (memcmp(p, "000000000", 9))
+                        p += 8;
+                    else if (memcmp(p, "fffffffff", 9))
+                        p += 8;
                 }
-                sscanf(p, "%lx", &addend);
+                assert(strlen(p) == 8);
-                add = (unsigned)addend;
+                char *endptr = NULL;
+                unsigned long ul = strtoul(p, &endptr, 16);
+                add = (unsigned) ul;
+                assert(add == ul);
+                assert(endptr && *endptr == '\0');
             }
 
             addRelocation(section->name, offset, t, symbol, add);
-
+            //printf("relocation %s %s %x %d preprocessed\n", section->name, symbol, offset, add);
-            //printf("relocation %s %x preprocessed\n", section->name, offset);
         }
 
         start = nextl + 1;
     }
 }
 
-ElfLinker::Section *ElfLinker::findSection(const char *name) const
+ElfLinker::Section *ElfLinker::findSection(const char *name, bool fatal) const
 {
     for (unsigned ic = 0; ic < nsections; ic++)
         if (strcmp(sections[ic]->name, name) == 0)
             return sections[ic];
-
+    if (fatal)
+    {
         printf("unknown section %s\n", name);
         abort();
+    }
     return NULL;
 }
 
-ElfLinker::Symbol *ElfLinker::findSymbol(const char *name) /*const*/
+ElfLinker::Symbol *ElfLinker::findSymbol(const char *name, bool fatal) const
 {
     for (unsigned ic = 0; ic < nsymbols; ic++)
         if (strcmp(symbols[ic]->name, name) == 0)
             return symbols[ic];
-
+    if (fatal)
-    // FIXME: this should be a const method !
+    {
-    if ('*' == name[0]) // *ABS*
-        return addSymbol(name, name, 0);
-
         printf("unknown symbol %s\n", name);
         abort();
+    }
     return NULL;
 }
 
+ElfLinker::Section *ElfLinker::addSection(const char *sname, const void *sdata, int slen, unsigned p2align)
+{
+    //printf("addSection: %s len=%d align=%d\n", sname, slen, p2align);
+    if (update_capacity(nsections, &nsections_capacity))
+        sections = static_cast<Section **>(realloc(sections, nsections_capacity * sizeof(Section *)));
+    assert(sections);
+    assert(sname); assert(sname[0]); assert(sname[strlen(sname)-1] != ':');
+    assert(findSection(sname, false) == NULL);
+    Section *sec = new Section(sname, sdata, slen, p2align);
+    sections[nsections++] = sec;
+    return sec;
+}
+
 ElfLinker::Symbol *ElfLinker::addSymbol(const char *name, const char *section,
                                         unsigned offset)
 {
+    //printf("addSymbol: %s %s 0x%x\n", name, section, offset);
     if (update_capacity(nsymbols, &nsymbols_capacity))
         symbols = static_cast<Symbol **>(realloc(symbols, nsymbols_capacity * sizeof(Symbol *)));
     assert(symbols != NULL);
+    assert(name); assert(name[0]); assert(name[strlen(name)-1] != ':');
+    assert(findSymbol(name, false) == NULL);
     Symbol *sym = new Symbol(name, findSection(section), offset);
     symbols[nsymbols++] = sym;
     return sym;
@@ -235,59 +369,6 @@ ElfLinker::Relocation *ElfLinker::addRelocation(const char *section, unsigned of
     return rel;
 }
 
-ElfLinker::ElfLinker() :
-    frozen(false), input(NULL), output(NULL), head(NULL), tail(NULL),
-    sections(NULL), symbols(NULL), relocations(NULL),
-    nsections(0), nsections_capacity(0),
-    nsymbols(0), nsymbols_capacity(0),
-    nrelocations(0), nrelocations_capacity(0)
-{
-}
-
-ElfLinker::~ElfLinker()
-{
-    delete [] input;
-    delete [] output;
-
-    unsigned ic;
-    for (ic = 0; ic < nsections; ic++)
-        delete sections[ic];
-    free(sections);
-    for (ic = 0; ic < nsymbols; ic++)
-        delete symbols[ic];
-    free(symbols);
-    for (ic = 0; ic < nrelocations; ic++)
-        delete relocations[ic];
-    free(relocations);
-}
-
-void ElfLinker::init(const void *pdata, int plen)
-{
-    upx_byte *i = new upx_byte[plen + 1];
-    memcpy(i, pdata, plen);
-    input = i;
-    inputlen = plen;
-
-    output = new upx_byte[plen];
-    outputlen = 0;
-
-    int pos = find(input, plen, "Sections:", 9);
-    assert(pos != -1);
-    char *psections = pos + (char *) input;
-
-    char *psymbols = strstr(psections, "SYMBOL TABLE:");
-    assert(psymbols != NULL);
-
-    char *prelocs = strstr(psymbols, "RELOCATION RECORDS FOR");
-    assert(prelocs != NULL);
-    input[plen] = 0;
-
-    preprocessSections(psections, psymbols);
-    preprocessSymbols(psymbols, prelocs);
-    preprocessRelocations(prelocs, (char*) input + inputlen);
-    addLoader("*UND*");
-}
-
 void ElfLinker::setLoaderAlignOffset(int phase)
 {
     //assert(phase & 0);
@@ -296,8 +377,8 @@ void ElfLinker::setLoaderAlignOffset(int phase)
 
 int ElfLinker::addLoader(const char *sname)
 {
-    assert(!frozen);
+    assert(sname != NULL);
-    if (sname[0] == 0)
+    if (!sname[0])
         return outputlen;
 
     char *begin = strdup(sname);
@@ -311,33 +392,35 @@ int ElfLinker::addLoader(const char *sname)
                 break;
             }
 
-        if (*sect == '+') // alignment
+        if (sect[0] == '+') // alignment
         {
             assert(tail);
-            if (unsigned l = (hex(sect[2]) - tail->offset - tail->size)
+            unsigned l = (hex(sect[2]) - tail->offset - tail->size) % hex(sect[1]);
-                % hex(sect[1]))
+            if (l)
             {
+                if (sect[3] == 'D')
+                    alignData(l);
+                else
                     alignCode(l);
                 tail->size += l;
-                outputlen += l;
             }
         }
         else
         {
             Section *section = findSection(sect);
-            if (section->align) {
+            if (section->p2align) {
-                unsigned const v = ~0u << section->align;
                 assert(tail);
+                assert(tail != section);
+                unsigned const v = ~0u << section->p2align;
                 if (unsigned const l = ~v & -(tail->offset + tail->size)) {
                     alignCode(l);
                     tail->size += l;
-                    outputlen += l;
                 }
             }
             memcpy(output + outputlen, section->input, section->size);
             section->output = output + outputlen;
+            //printf("section added: 0x%04x %3d %s\n", outputlen, section->size, section->name);
             outputlen += section->size;
-            //printf("section added: %s\n", sect);
 
             if (head)
             {
@@ -354,38 +437,22 @@ int ElfLinker::addLoader(const char *sname)
     return outputlen;
 }
 
-void ElfLinker::addSection(const char *sname, const void *sdata, int slen, int align)
+int ElfLinker::getSection(const char *sname, int *slen) const
 {
-    assert(!frozen);
+    const Section *section = findSection(sname);
-    if (update_capacity(nsections, &nsections_capacity))
-        sections = static_cast<Section **>(realloc(sections, nsections_capacity * sizeof(Section *)));
-    assert(sections);
-    Section *sec = new Section(sname, sdata, slen, align);
-    sections[nsections++] = sec;
-    //return sec;
-}
-
-void ElfLinker::freeze()
-{
-    if (frozen)
-        return;
-
-    frozen = true;
-}
-
-int ElfLinker::getSection(const char *sname, int *slen)
-{
-    assert(frozen);
-    Section *section = findSection(sname);
     if (slen)
         *slen = section->size;
     return section->output - output;
 }
 
-upx_byte *ElfLinker::getLoader(int *llen)
+int ElfLinker::getSectionSize(const char *sname) const
 {
-    assert(frozen);
+    const Section *section = findSection(sname);
+    return section->size;
+}
 
+upx_byte *ElfLinker::getLoader(int *llen) const
+{
     if (llen)
         *llen = outputlen;
     return output;
@@ -393,31 +460,40 @@ upx_byte *ElfLinker::getLoader(int *llen)
 
 void ElfLinker::relocate()
 {
-    assert(frozen);
+    assert(!reloc_done);
-
+    reloc_done = true;
     for (unsigned ic = 0; ic < nrelocations; ic++)
     {
-        Relocation *rel = relocations[ic];
+        const Relocation *rel = relocations[ic];
+        unsigned value;
+
         if (rel->section->output == NULL)
             continue;
-        if (rel->value->section->output == NULL)
+        if (strcmp(rel->value->section->name, "*ABS*") == 0)
+        {
+            value = rel->value->offset;
+        }
+        else if (strcmp(rel->value->section->name, "*UND*") == 0 &&
+                 rel->value->offset == 0xdeaddead)
+        {
+            printf("undefined symbol '%s' referenced\n", rel->value->name);
+            abort();
+        }
+        else if (rel->value->section->output == NULL)
         {
             printf("can not apply reloc '%s:%x' without section '%s'\n",
                    rel->section->name, rel->offset,
                    rel->value->section->name);
             abort();
         }
-
+        else
-        if (strcmp(rel->value->section->name, "*UND*") == 0 &&
-            rel->value->offset == 0xdeaddead)
         {
-            printf("undefined symbol '%s' referenced\n", rel->value->name);
+            value = rel->value->section->offset +
-            abort();
-        }
-        unsigned value = rel->value->section->offset +
                     rel->value->offset + rel->add;
+        }
         upx_byte *location = rel->section->output + rel->offset;
-
+        //printf("%-28s %-28s %-10s 0x%08x 0x%08x\n", rel->section->name, rel->value->name, rel->type, value, value - rel->section->offset - rel->offset);
+        //printf("  %d %d %d %d %d : %d\n", value, rel->value->section->offset, rel->value->offset, rel->offset, rel->add, *location);
         relocate1(rel, location, value, rel->type);
     }
 }
@@ -425,7 +501,12 @@ void ElfLinker::relocate()
 void ElfLinker::defineSymbol(const char *name, unsigned value)
 {
     Symbol *symbol = findSymbol(name);
-    if (strcmp(symbol->section->name, "*UND*") == 0) // for undefined symbols
+    if (strcmp(symbol->section->name, "*ABS*") == 0)
+    {
+        printf("defineSymbol: symbol '%s' is *ABS*\n", name);
+        abort();
+    }
+    else if (strcmp(symbol->section->name, "*UND*") == 0) // for undefined symbols
         symbol->offset = value;
     else if (strcmp(symbol->section->name, name) == 0) // for sections
     {
@@ -438,36 +519,57 @@ void ElfLinker::defineSymbol(const char *name, unsigned value)
     }
     else
     {
-        printf("symbol '%s' already defined\n", name);
+        printf("defineSymbol: symbol '%s' already defined\n", name);
         abort();
     }
 }
 
 // debugging support
-void ElfLinker::dumpSymbols(FILE *fp) const
+void ElfLinker::dumpSymbol(const Symbol *symbol, unsigned flags, FILE *fp) const
+{
+    if ((flags & 1) && symbol->section->output == NULL)
+        return;
+    fprintf(fp, "%-28s 0x%08x | %-28s 0x%08x\n",
+            symbol->name, symbol->offset, symbol->section->name, symbol->section->offset);
+}
+void ElfLinker::dumpSymbols(unsigned flags, FILE *fp) const
 {
     if (fp == NULL)
         fp = stdout;
+    if ((flags & 2) == 0)
+    {
+        // default: dump symbols in used section order
+        for (const Section *section = head; section; section = section->next)
+        {
+            fprintf(fp, "%-42s%-28s 0x%08x\n", "", section->name, section->offset);
             for (unsigned ic = 0; ic < nsymbols; ic++)
             {
-        Symbol *symbol = symbols[ic];
+                const Symbol *symbol = symbols[ic];
-        fprintf(fp, "%-20s 0x%08x | %-20s 0x%08x\n",
+                if (symbol->section == section && strcmp(symbol->name, section->name) != 0)
-            symbol->name, symbol->offset, symbol->section->name, symbol->section->offset);
+                    dumpSymbol(symbol, flags, fp);
+            }
+        }
+    }
+    else
+    {
+        // dump all symbols
+        for (unsigned ic = 0; ic < nsymbols; ic++)
+            dumpSymbol(symbols[ic], flags, fp);
     }
 }
 
 unsigned ElfLinker::getSymbolOffset(const char *name) const
 {
-    assert(frozen);
+    const Symbol *symbol = findSymbol(name);
-    Symbol *symbol = const_cast<ElfLinker *>(this)->findSymbol(name);
     if (symbol->section->output == NULL)
         return 0xdeaddead;
     return symbol->section->offset + symbol->offset;
 }
 
-void ElfLinker::alignWithByte(unsigned len, upx_byte b)
+void ElfLinker::alignWithByte(unsigned len, unsigned char b)
 {
     memset(output + outputlen, b, len);
+    outputlen += len;
 }
 
 void ElfLinker::relocate1(const Relocation *rel, upx_byte *,
@@ -483,6 +585,23 @@ void ElfLinker::relocate1(const Relocation *rel, upx_byte *,
 // FIXME: add more displacment overflow checks
 **************************************************************************/
 
+#if 0 // FIXME
+static void check8(const Relocation *rel, const upx_byte *location, int v, int d)
+{
+    if (v < -128 || v > 127) {
+        printf("value out of range (%d) in reloc %s:%x\n",
+               v, rel->section->name, rel->offset);
+        abort();
+    }
+    if (d < -128 || d > 127) {
+        printf("displacement target out of range (%d) in reloc %s:%x\n",
+               v, rel->section->name, rel->offset);
+        abort();
+    }
+}
+#endif
+
+
 void ElfLinkerAMD64::relocate1(const Relocation *rel, upx_byte *location,
                                unsigned value, const char *type)
 {
@@ -580,6 +699,7 @@ void ElfLinkerM68k::alignCode(unsigned len)
     assert((outputlen & 1) == 0);
     for (unsigned i = 0; i < len; i += 2)
         set_be16(output + outputlen + i, 0x4e71); // "nop"
+    outputlen += len;
 }
 
 void ElfLinkerM68k::relocate1(const Relocation *rel, upx_byte *location,
@@ -594,17 +714,51 @@ void ElfLinkerM68k::relocate1(const Relocation *rel, upx_byte *location,
         value -= rel->section->offset + rel->offset;
         type += 2;
     }
-    if (strcmp(type, "8") == 0)
+    if (strcmp(type, "8") == 0) {
         *location += value;
-    else if (strcmp(type, "16") == 0)
+    }
+    else if (strcmp(type, "16") == 0) {
         set_be16(location, get_be16(location) + value);
-    else if (strcmp(type, "32") == 0)
+    }
+    else if (strcmp(type, "32") == 0) {
         set_be32(location, get_be32(location) + value);
+    }
     else
         super::relocate1(rel, location, value, type);
 }
 
 
+void ElfLinkerMipsLE::relocate1(const Relocation *rel, upx_byte *location,
+                                unsigned value, const char *type)
+{
+#define MIPS_HI(a)      (((a) >> 16) + (((a) & 0x8000) >> 15))
+#define MIPS_LO(a)      ((a) & 0xffff)
+#define MIPS_PC16(a)    ((a) >> 2)
+#define MIPS_PC26(a)    (((a) & 0x0fffffff) >> 2)
+
+    if (strcmp(type, "R_MIPS_HI16") == 0)
+        set_le16(location, get_le16(location) + MIPS_HI(value));
+    else if (strcmp(type, "R_MIPS_LO16") == 0)
+        set_le16(location, get_le16(location) + MIPS_LO(value));
+    else if (strcmp(type, "R_MIPS_PC16") == 0)
+    {
+        value -= rel->section->offset + rel->offset;
+        set_le16(location, get_le16(location) + MIPS_PC16(value));
+    }
+    else if (strcmp(type, "R_MIPS_26") == 0)
+        set_le32(location, get_le32(location) + MIPS_PC26(value));
+    else if (strcmp(type, "R_MIPS_32") == 0)
+        set_le32(location, get_le32(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
+
+#undef MIPS_HI
+#undef MIPS_LO
+#undef MIPS_PC16
+#undef MIPS_PC26
+}
+
+
 void ElfLinkerPpc32::relocate1(const Relocation *rel, upx_byte *location,
                                unsigned value, const char *type)
 {
@@ -651,12 +805,12 @@ void ElfLinkerX86::relocate1(const Relocation *rel, upx_byte *location,
         return super::relocate1(rel, location, value, type);
     type += 6;
 
-    int range_check = 0;
+    bool range_check = false;
     if (strncmp(type, "PC", 2) == 0)
     {
         value -= rel->section->offset + rel->offset;
         type += 2;
-        range_check = 1;
+        range_check = true;
     }
 
     if (strcmp(type, "8") == 0)

src/linker.h

@@ -36,13 +36,14 @@
 
 class ElfLinker : private nocopy
 {
+    friend class Packer;
+public:
+    const N_BELE_RTP::AbstractPolicy *bele;
 protected:
     struct      Section;
     struct      Symbol;
     struct      Relocation;
 
-    bool        frozen;         // FIXME: can we remove this ?
-
     upx_byte    *input;
     int         inputlen;
     upx_byte    *output;
@@ -62,11 +63,14 @@ protected:
     unsigned    nrelocations;
     unsigned    nrelocations_capacity;
 
+    bool        reloc_done;
+
+protected:
     void preprocessSections(char *start, const char *end);
     void preprocessSymbols(char *start, const char *end);
     void preprocessRelocations(char *start, const char *end);
-    Section *findSection(const char *name) const;
+    Section *findSection(const char *name, bool fatal=true) const;
-    Symbol *findSymbol(const char *name) /*const*/;
+    Symbol *findSymbol(const char *name, bool fatal=true) const;
 
     Symbol *addSymbol(const char *name, const char *section, unsigned offset);
     Relocation *addRelocation(const char *section, unsigned off, const char *type,
@@ -79,19 +83,22 @@ public:
     virtual void init(const void *pdata, int plen);
     virtual void setLoaderAlignOffset(int phase);
     virtual int addLoader(const char *sname);
-    virtual void addSection(const char *sname, const void *sdata, int slen, int align);
+    virtual Section *addSection(const char *sname, const void *sdata, int slen, unsigned p2align);
-    virtual void freeze();
+    virtual int getSection(const char *sname, int *slen=NULL) const;
-    virtual int getSection(const char *sname, int *slen=NULL);
+    virtual int getSectionSize(const char *sname) const;
-    virtual upx_byte *getLoader(int *llen=NULL);
+    virtual upx_byte *getLoader(int *llen=NULL) const;
-    virtual void relocate();
     virtual void defineSymbol(const char *name, unsigned value);
     virtual unsigned getSymbolOffset(const char *) const;
-    virtual void dumpSymbols(FILE *fp=NULL) const;
 
-    void alignWithByte(unsigned len, upx_byte b);
+    virtual void dumpSymbol(const Symbol *, unsigned flags, FILE *fp) const;
+    virtual void dumpSymbols(unsigned flags=0, FILE *fp=NULL) const;
+
+    void alignWithByte(unsigned len, unsigned char b);
     virtual void alignCode(unsigned len) { alignWithByte(len, 0); }
     virtual void alignData(unsigned len) { alignWithByte(len, 0); }
 
+protected:
+    virtual void relocate();
     virtual void relocate1(const Relocation *, upx_byte *location,
                            unsigned value, const char *type);
 };
@@ -104,7 +111,7 @@ struct ElfLinker::Section : private nocopy
     upx_byte *output;
     unsigned size;
     unsigned offset;
-    unsigned char align;  // log2
+    unsigned p2align;   // log2
     Section *next;
 
     Section(const char *n, const void *i, unsigned s, unsigned a=0);
@@ -153,6 +160,8 @@ protected:
 class ElfLinkerArmBE : public ElfLinker
 {
     typedef ElfLinker super;
+public:
+    ElfLinkerArmBE() { bele = &N_BELE_RTP::be_policy; }
 protected:
     virtual void relocate1(const Relocation *, upx_byte *location,
                            unsigned value, const char *type);
@@ -171,6 +180,8 @@ protected:
 class ElfLinkerM68k : public ElfLinker
 {
     typedef ElfLinker super;
+public:
+    ElfLinkerM68k() { bele = &N_BELE_RTP::be_policy; }
 protected:
     virtual void alignCode(unsigned len);
     virtual void relocate1(const Relocation *, upx_byte *location,
@@ -178,9 +189,20 @@ protected:
 };
 
 
+class ElfLinkerMipsLE : public ElfLinker
+{
+    typedef ElfLinker super;
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location,
+                           unsigned value, const char *type);
+};
+
+
 class ElfLinkerPpc32 : public ElfLinker
 {
     typedef ElfLinker super;
+public:
+    ElfLinkerPpc32() { bele = &N_BELE_RTP::be_policy; }
 protected:
     virtual void relocate1(const Relocation *, upx_byte *location,
                            unsigned value, const char *type);

src/main.cpp

@@ -43,8 +43,9 @@ int _crt0_startup_flags = _CRT0_FLAG_UNIX_SBRK;
 // options
 **************************************************************************/
 
-void init_options(struct options_t *o)
+void options_t::reset()
 {
+    options_t *o = this;
     memset(o, 0, sizeof(*o));
     o->crp.reset();
 
@@ -236,12 +237,24 @@ void check_options(int i, int argc)
 {
     assert(i <= argc);
 
+    if (opt->cmd != CMD_COMPRESS)
+    {
+        // invalidate compression options
+        opt->method = 0;
+        opt->level = 0;
+        opt->exact = 0;
+        opt->small = 0;
+        opt->crp.reset();
+    }
+
     // set default overlay action
     if (!(opt->cmd == CMD_COMPRESS || opt->cmd == CMD_DECOMPRESS))
         opt->overlay = opt->COPY_OVERLAY;
     else if (opt->overlay < 0)
         opt->overlay = opt->COPY_OVERLAY;
 
+    check_not_both(opt->exact, opt->overlay == opt->STRIP_OVERLAY, "--exact", "--overlay=strip");
+
     // set default backup option
     if (opt->backup < 0)
         opt->backup = 0;
@@ -299,9 +312,15 @@ static bool set_method(int m, int l)
     {
         if (!Packer::isValidCompressionMethod(m))
             return false;
+#if 1
+        // something like "--brute --lzma" should not disable "--brute"
+        if (!opt->all_methods)
+#endif
+        {
             opt->method = m;
             opt->all_methods = false;
         }
+    }
     if (l > 0)
         opt->level = l;
     set_cmd(CMD_COMPRESS);
@@ -405,28 +424,58 @@ char* prepare_shortopts(char *buf, const char *n,
 
 
 template <class T>
-int getoptvar(T *var, const T minval, const T maxval)
+int getoptvar(T *var, const T min_value, const T max_value, const char *arg_fatal)
 {
     const char *p = mfx_optarg;
     char *endptr;
+    int r = 0;
+    long n;
+    T v;
 
     if (!p || !p[0])
-        return -1;
+        { r = -1; goto error; }
     // avoid interpretation as octal value
     while (p[0] == '0' && isdigit(p[1]))
         p++;
-    long n = strtol(p, &endptr, 0);
+    n = strtol(p, &endptr, 0);
     if (*endptr != '\0')
-        return -2;
+        { r = -2; goto error; }
-    T v = (T) n;
+    v = (T) n;
-    if (v < minval)
+    if (v < min_value)
-        return -3;
+        { r = -3; goto error; }
-    if (v > maxval)
+    if (v > max_value)
-        return -4;
+        { r = -4; goto error; }
     *var = v;
-    return 0;
+    goto done;
+error:
+    if (arg_fatal != NULL)
+        e_optval(arg_fatal);
+done:
+    return r;
 }
 
+#if 1 && (ACC_CC_GNUC >= 0x030300)
+template <class T, T default_value, T min_value, T max_value>
+int getoptvar(OptVar<T,default_value,min_value,max_value> *var, const char *arg_fatal)
+{
+    T v = default_value;
+    int r = getoptvar(&v, min_value, max_value, arg_fatal);
+    if (r == 0)
+        *var = v;
+    return r;
+}
+#else
+template <class T>
+int getoptvar(T *var, const char *arg_fatal)
+{
+    typename T::Type v = T::default_value_c;
+    int r = getoptvar(&v, T::min_value_c, T::max_value_c, arg_fatal);
+    if (r == 0)
+        *var = v;
+    return r;
+}
+#endif
+
 
 static int do_option(int optc, const char *arg)
 {
@@ -517,6 +566,11 @@ static int do_option(int optc, const char *arg)
         if (!set_method(M_LZMA, -1))
             e_method(M_LZMA, opt->level);
         break;
+    case 722:
+        opt->all_methods_use_lzma = false;
+        if (opt->method == M_LZMA)
+            opt->method = -1;
+        break;
 
     // compression level
     case '1':
@@ -561,6 +615,9 @@ static int do_option(int optc, const char *arg)
             e_optarg(arg);
         opt->debug.dump_stub_loader = mfx_optarg;
         break;
+    case 545:
+        opt->debug.disable_random_id = true;
+        break;
 
     // misc
     case 512:
@@ -585,7 +642,7 @@ static int do_option(int optc, const char *arg)
         opt->small++;
         break;
     case 521:                               // --filter=
-        getoptvar(&opt->filter, 0, 255);
+        getoptvar(&opt->filter, 0, 255, arg);
         opt->all_filters = false;
         break;
     case 522:                               // --no-filter
@@ -601,28 +658,54 @@ static int do_option(int optc, const char *arg)
         opt->all_methods = true;
         opt->method = -1;
         break;
+    case 525:                               // --exact
+        opt->exact = true;
+        break;
     // compression runtime parameters
-    case 531:
+    case 801:
-        getoptvar(&opt->crp.crp_ucl.c_flags, 0, 3);
+        getoptvar(&opt->crp.crp_ucl.c_flags, 0, 3, arg);
         break;
-    case 532:
+    case 802:
-        getoptvar(&opt->crp.crp_ucl.s_level, 0, 2);
+        getoptvar(&opt->crp.crp_ucl.s_level, 0, 2, arg);
         break;
-    case 533:
+    case 803:
-        getoptvar(&opt->crp.crp_ucl.h_level, 0, 1);
+        getoptvar(&opt->crp.crp_ucl.h_level, 0, 1, arg);
         break;
-    case 534:
+    case 804:
-        getoptvar(&opt->crp.crp_ucl.p_level, 0, 7);
+        getoptvar(&opt->crp.crp_ucl.p_level, 0, 7, arg);
         break;
-    case 535:
+    case 805:
-        getoptvar(&opt->crp.crp_ucl.max_offset, 256u, ~0u);
+        getoptvar(&opt->crp.crp_ucl.max_offset, 256u, ~0u, arg);
         break;
-    case 536:
+    case 806:
-        getoptvar(&opt->crp.crp_ucl.max_match, 16u, ~0u);
+        getoptvar(&opt->crp.crp_ucl.max_match, 16u, ~0u, arg);
         break;
-    case 537:
+    case 807:
-        if (getoptvar(&opt->crp.crp_ucl.m_size, 10000u, 999999u) != 0)
+        getoptvar(&opt->crp.crp_ucl.m_size, 10000u, 999999u, arg);
-            e_optval("--crp-ms=");
+        break;
+    case 811:
+        getoptvar(&opt->crp.crp_lzma.pos_bits, arg);
+        break;
+    case 812:
+        getoptvar(&opt->crp.crp_lzma.lit_pos_bits, arg);
+        break;
+    case 813:
+        getoptvar(&opt->crp.crp_lzma.lit_context_bits, arg);
+        break;
+    case 814:
+        getoptvar(&opt->crp.crp_lzma.dict_size, arg);
+        break;
+    case 816:
+        getoptvar(&opt->crp.crp_lzma.num_fast_bytes, arg);
+        break;
+    case 821:
+        getoptvar(&opt->crp.crp_zlib.mem_level, arg);
+        break;
+    case 822:
+        getoptvar(&opt->crp.crp_zlib.window_bits, arg);
+        break;
+    case 823:
+        getoptvar(&opt->crp.crp_zlib.strategy, arg);
         break;
     // backup
     case 'k':
@@ -687,18 +770,20 @@ static int do_option(int optc, const char *arg)
         break;
     case 630:
         opt->win32_pe.compress_exports = 1;
-        getoptvar(&opt->win32_pe.compress_exports, 0, 1);
+        if (mfx_optarg && mfx_optarg[0])
+            getoptvar(&opt->win32_pe.compress_exports, 0, 1, arg);
         //printf("compress_exports: %d\n", opt->win32_pe.compress_exports);
         break;
     case 631:
         opt->win32_pe.compress_icons = 1;
-        getoptvar(&opt->win32_pe.compress_icons, 0, 2);
+        if (mfx_optarg && mfx_optarg[0])
+            getoptvar(&opt->win32_pe.compress_icons, 0, 3, arg);
         //printf("compress_icons: %d\n", opt->win32_pe.compress_icons);
         break;
     case 632:
-        opt->win32_pe.compress_resources = true;
+        opt->win32_pe.compress_resources = 1;
-        if (mfx_optarg && strcmp(mfx_optarg,"0") == 0)
+        if (mfx_optarg && mfx_optarg[0])
-            opt->win32_pe.compress_resources = false;
+            getoptvar(&opt->win32_pe.compress_resources, 0, 1, arg);
         //printf("compress_resources: %d\n", opt->win32_pe.compress_resources);
         break;
     case 633:
@@ -706,8 +791,8 @@ static int do_option(int optc, const char *arg)
         break;
     case 634:
         opt->win32_pe.strip_relocs = 1;
-        if (mfx_optarg && strcmp(mfx_optarg,"0") == 0)
+        if (mfx_optarg && mfx_optarg[0])
-            opt->win32_pe.strip_relocs = 0;
+            getoptvar(&opt->win32_pe.strip_relocs, 0, 1, arg);
         //printf("strip_relocs: %d\n", opt->win32_pe.strip_relocs);
         break;
     case 635:
@@ -719,7 +804,7 @@ static int do_option(int optc, const char *arg)
         opt->atari_tos.split_segments = true;
         break;
     case 660:
-        getoptvar(&opt->o_unix.blocksize, 8192u, ~0u);
+        getoptvar(&opt->o_unix.blocksize, 8192u, ~0u, arg);
         break;
     case 661:
         opt->o_unix.force_execve = true;
@@ -818,18 +903,19 @@ static const struct mfx_option longopts[] =
     {"dump-stub-loader" ,0x31, 0, 544},     // for internal debugging
     {"fake-stub-version",0x31, 0, 542},     // for internal debugging
     {"fake-stub-year"   ,0x31, 0, 543},     // for internal debugging
+    {"disable-random-id",0x10, 0, 545},     // for internal debugging
 
     // backup options
-    {"backup",              0, 0, 'k'},
+    {"backup",           0x10, 0, 'k'},
-    {"keep",                0, 0, 'k'},
+    {"keep",             0x10, 0, 'k'},
-    {"no-backup",           0, 0, 541},
+    {"no-backup",        0x10, 0, 541},
 
     // overlay options
     {"overlay",          0x31, 0, 551},     // --overlay=
-    {"skip-overlay",        0, 0, 552},
+    {"skip-overlay",     0x10, 0, 552},
-    {"no-overlay",          0, 0, 552},     // old name
+    {"no-overlay",       0x10, 0, 552},     // old name
-    {"copy-overlay",        0, 0, 553},
+    {"copy-overlay",     0x10, 0, 553},
-    {"strip-overlay",       0, 0, 554},
+    {"strip-overlay",    0x10, 0, 554},
 
     // CPU options
     {"cpu",              0x31, 0, 560},     // --cpu=
@@ -838,34 +924,53 @@ static const struct mfx_option longopts[] =
     {"486",              0x10, 0, 564},
 
     // color options
-    {"no-color",            0, 0, 512},
+    {"no-color",         0x10, 0, 512},
-    {"mono",                0, 0, 513},
+    {"mono",             0x10, 0, 513},
-    {"color",               0, 0, 514},
+    {"color",            0x10, 0, 514},
 
     // compression method
     {"nrv2b",            0x10, 0, 702},     // --nrv2b
     {"nrv2d",            0x10, 0, 704},     // --nrv2d
     {"nrv2e",            0x10, 0, 705},     // --nrv2e
     {"lzma",             0x10, 0, 721},     // --lzma
+    {"no-lzma",          0x10, 0, 722},     // (disable all_methods_use_lzma)
     // compression settings
     {"all-filters",      0x10, 0, 523},
     {"all-methods",      0x10, 0, 524},
+    {"exact",            0x10, 0, 525},     // user requires byte-identical decompression
     {"filter",           0x31, 0, 521},     // --filter=
     {"no-filter",        0x10, 0, 522},
     {"small",            0x10, 0, 520},
     // compression runtime parameters
-    {"crp-cf",           0x31, 0, 531},
+    {"crp-nrv-cf",       0x31, 0, 801},
-    {"crp-sl",           0x31, 0, 532},
+    {"crp-nrv-sl",       0x31, 0, 802},
-    {"crp-hl",           0x31, 0, 533},
+    {"crp-nrv-hl",       0x31, 0, 803},
-    {"crp-pl",           0x31, 0, 534},
+    {"crp-nrv-pl",       0x31, 0, 804},
-    {"crp-mo",           0x31, 0, 535},
+    {"crp-nrv-mo",       0x31, 0, 805},
-    {"crp-mm",           0x31, 0, 536},
+    {"crp-nrv-mm",       0x31, 0, 806},
-    {"crp-ms",           0x31, 0, 537},
+    {"crp-nrv-ms",       0x31, 0, 807},
+    {"crp-ucl-cf",       0x31, 0, 801},
+    {"crp-ucl-sl",       0x31, 0, 802},
+    {"crp-ucl-hl",       0x31, 0, 803},
+    {"crp-ucl-pl",       0x31, 0, 804},
+    {"crp-ucl-mo",       0x31, 0, 805},
+    {"crp-ucl-mm",       0x31, 0, 806},
+    {"crp-ucl-ms",       0x31, 0, 807},
+    {"crp-lzma-pb",      0x31, 0, 811},
+    {"crp-lzma-lp",      0x31, 0, 812},
+    {"crp-lzma-lc",      0x31, 0, 813},
+    {"crp-lzma-ds",      0x31, 0, 814},
+    {"crp-lzma-fb",      0x31, 0, 816},
+    {"crp-zlib-ml",      0x31, 0, 821},
+    {"crp-zlib-wb",      0x31, 0, 822},
+    {"crp-zlib-st",      0x31, 0, 823},
+    // [deprecated - only for compatibility with UPX 2.0x]
+    {"crp-ms",           0x31, 0, 807},
 
     // atari/tos
     {"split-segments",   0x10, 0, 650},
     // djgpp2/coff
-    {"coff",                0, 0, 610},     // produce COFF output
+    {"coff",             0x10, 0, 610},     // produce COFF output
     // dos/com
     // dos/exe
     //{"force-stub",             0x10, 0, 600},
@@ -877,15 +982,19 @@ static const struct mfx_option longopts[] =
 #if 0
     {"script",           0x31, 0, 662},     // --script=
 #endif
-    {"is_ptinterp",         0, 0, 663},     // linux/elf386 PT_INTERP program
+    {"is_ptinterp",      0x10, 0, 663},     // linux/elf386 PT_INTERP program
-    {"use_ptinterp",        0, 0, 664},     // linux/elf386 PT_INTERP program
+    {"use_ptinterp",     0x10, 0, 664},     // linux/elf386 PT_INTERP program
-    {"make_ptinterp",       0, 0, 665},     // linux/elf386 PT_INTERP program
+    {"make_ptinterp",    0x10, 0, 665},     // linux/elf386 PT_INTERP program
-    {"Linux",               0, 0, 666},
+    {"Linux",            0x10, 0, 666},
-    {"FreeBSD",             0, 0, 667},
+    {"linux",            0x10, 0, 666},
-    {"NetBSD",              0, 0, 668},
+    {"FreeBSD",          0x10, 0, 667},
-    {"OpenBSD",             0, 0, 669},
+    {"freebsd",          0x10, 0, 667},
+    {"NetBSD",           0x10, 0, 668},
+    {"netbsd",           0x10, 0, 668},
+    {"OpenBSD",          0x10, 0, 669},
+    {"openbsd",          0x10, 0, 669},
     // watcom/le
-    {"le",                  0, 0, 620},     // produce LE output
+    {"le",               0x10, 0, 620},     // produce LE output
     // win32/pe
     {"compress-exports",    2, 0, 630},
     {"compress-icons",      2, 0, 631},
@@ -939,17 +1048,20 @@ static const struct mfx_option longopts[] =
     {"silent",              0, 0, 'q'},     // quiet mode
     {"verbose",             0, 0, 'v'},     // verbose mode
 
+    // debug options
+    {"disable-random-id",0x10, 0, 545},     // for internal debugging
+
     // backup options
-    {"backup",              0, 0, 'k'},
+    {"backup",           0x10, 0, 'k'},
-    {"keep",                0, 0, 'k'},
+    {"keep",             0x10, 0, 'k'},
     {"no-backup",        0x10, 0, 541},
 
     // overlay options
     {"overlay",          0x31, 0, 551},     // --overlay=
-    {"skip-overlay",        0, 0, 552},
+    {"skip-overlay",     0x10, 0, 552},
-    {"no-overlay",          0, 0, 552},     // old name
+    {"no-overlay",       0x10, 0, 552},     // old name
-    {"copy-overlay",        0, 0, 553},
+    {"copy-overlay",     0x10, 0, 553},
-    {"strip-overlay",       0, 0, 554},
+    {"strip-overlay",    0x10, 0, 554},
 
     // CPU options
     {"cpu",              0x31, 0, 560},     // --cpu=
@@ -958,18 +1070,14 @@ static const struct mfx_option longopts[] =
     {"486",              0x10, 0, 564},
 
     // color options
-    {"no-color",            0, 0, 512},
+    {"no-color",         0x10, 0, 512},
-    {"mono",                0, 0, 513},
+    {"mono",             0x10, 0, 513},
-    {"color",               0, 0, 514},
+    {"color",            0x10, 0, 514},
+
+    // compression settings
+    {"exact",            0x10, 0, 525},     // user requires byte-identical decompression
 
     // compression runtime parameters
-    {"crp-cf",           0x31, 0, 531},
-    {"crp-sl",           0x31, 0, 532},
-    {"crp-hl",           0x31, 0, 533},
-    {"crp-pl",           0x31, 0, 534},
-    {"crp-mo",           0x31, 0, 535},
-    {"crp-mm",           0x31, 0, 536},
-    {"crp-ms",           0x31, 0, 537},
 
     // win32/pe
     {"compress-exports",    2, 0, 630},
@@ -1207,6 +1315,10 @@ void upx_sanity_check(void)
 
 #if !defined(WITH_GUI)
 
+#if (ACC_ARCH_M68K && ACC_OS_TOS && ACC_CC_GNUC) && defined(__MINT__)
+extern "C" { extern long _stksize; long _stksize = 256 * 1024L; }
+#endif
+
 int __acc_cdecl_main main(int argc, char *argv[])
 {
     int i;
@@ -1220,7 +1332,7 @@ int __acc_cdecl_main main(int argc, char *argv[])
     acc_wildargv(&argc, &argv);
 
     upx_sanity_check();
-    init_options(opt);
+    opt->reset();
 
     if (!argv[0] || !argv[0][0])
         argv[0] = default_argv0;
@@ -1321,14 +1433,6 @@ int __acc_cdecl_main main(int argc, char *argv[])
         break;
     }
 
-    if (opt->cmd != CMD_COMPRESS)
-    {
-        // invalidate compression options
-        opt->method = 0;
-        opt->level = 0;
-        memset(&opt->crp, 0xff, sizeof(opt->crp));
-    }
-
     /* check options */
     if (argc == 1)
         e_help();

src/mem.cpp

@@ -209,6 +209,8 @@ void MemBuffer::alloc(unsigned size)
     }
     else
         b = p ;
+
+    //fill(0, b_size, (rand() & 0xff) | 1); // debug
 }
 
 

src/mem.h

@@ -38,7 +38,7 @@ class MemBuffer
 {
 public:
     MemBuffer();
-    MemBuffer(unsigned size);
+    explicit MemBuffer(unsigned size);
     ~MemBuffer();
 
     static unsigned getSizeForCompression(unsigned uncompressed_size, unsigned extra=0);

src/options.h

@@ -53,6 +53,7 @@ struct options_t {
     bool all_methods_use_lzma;
     bool all_filters;       // try all available filters ?
     bool no_filter;         // force no filter
+    bool exact;             // user requires byte-identical decompression
 
     // other options
     int backup;
@@ -70,6 +71,7 @@ struct options_t {
     // debug options
     struct {
         int debug_level;
+        bool disable_random_id;         // for Packer::getRandomId()
         const char *dump_stub_loader;
         char fake_stub_version[4+1];    // for internal debugging
         char fake_stub_year[4+1];       // for internal debugging
@@ -83,32 +85,12 @@ struct options_t {
     };
     int overlay;
 
-    // compression runtime parameters - see struct ucl_compress_config_t
+    // compression runtime parameters - see struct XXX_compress_config_t
-    struct crp_lzma_t {
-        int dummy;
-#if 0
-        unsigned pos_bits;              // pb
-        unsigned lit_pos_bits;          // lp
-        unsigned lit_context_bits;      // lc
-        unsigned dict_size;
-        unsigned mf_passes;
-#endif
-        void reset() { memset(this, 0, sizeof(*this)); }
-    };
-    struct crp_ucl_t {
-        unsigned max_offset;
-        unsigned max_match;
-        int s_level;
-        int h_level;
-        int p_level;
-        int c_flags;
-        unsigned m_size;
-        void reset() { memset(this, 0xff, sizeof(*this)); }
-    };
     struct crp_t {
-        crp_lzma_t  crp_lzma;
+        lzma_compress_config_t  crp_lzma;
-        crp_ucl_t   crp_ucl;
+        ucl_compress_config_t   crp_ucl;
-        void reset() { crp_lzma.reset(); crp_ucl.reset(); }
+        zlib_compress_config_t  crp_zlib;
+        void reset() { crp_lzma.reset(); crp_ucl.reset(); crp_zlib.reset(); }
     };
     crp_t crp;
 
@@ -162,6 +144,8 @@ struct options_t {
         int strip_relocs;
         const char *keep_resource;
     } win32_pe;
+
+    void reset();
 };
 
 extern struct options_t *opt;

src/p_armpe.cpp

@@ -462,10 +462,10 @@ bool PackArmPe::canPack()
 }
 
 
-int PackArmPe::buildLoader(const Filter *ft)
+void PackArmPe::buildLoader(const Filter *ft)
 {
-    const unsigned char *loader = use_thumb_stub ? nrv_loader_thumb : nrv_loader_arm;
+    const unsigned char *loader = use_thumb_stub ? stub_arm_v4t_wince_pe : stub_arm_v4a_wince_pe;
-    unsigned size = use_thumb_stub ? sizeof(nrv_loader_thumb) : sizeof(nrv_loader_arm);
+    unsigned size = use_thumb_stub ? sizeof(stub_arm_v4t_wince_pe) : sizeof(stub_arm_v4a_wince_pe);
 
     // prepare loader
     initLoader(loader, size);
@@ -503,8 +503,6 @@ int PackArmPe::buildLoader(const Filter *ft)
         addLoader("+40C,LZMA_DECODE,LZMA_DEC10", NULL);
 
     addLoader("IDENTSTR,UPX1HEAD", NULL);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -729,13 +727,11 @@ void PackArmPe::pack(OutputFile *fo)
     getLoaderSection("UPX1HEAD",(int*)&ic);
     identsize += ic;
 
-    pe_section_t osection[3];
+    pe_section_t osection[4];
     // section 0 : bss
     //         1 : [ident + header] + packed_data + unpacker + tls
     //         2 : not compressed data
-
+    //         3 : resource data -- wince 5 needs a new section for this
-    // section 2 should start with the resource data, because lots of lame
-    // windoze codes assume that resources starts on the beginning of a section
 
     // identsplit - number of ident + (upx header) bytes to put into the PE header
     int identsplit = pe_offset + sizeof(osection) + sizeof(oh);
@@ -773,7 +769,7 @@ void PackArmPe::pack(OutputFile *fo)
     memset(osection,0,sizeof(osection));
 
     oh.entry = upxsection;
-    oh.objects = 3;
+    oh.objects = 4;
     oh.chksum = 0;
 
     // fill the data directory
@@ -802,12 +798,6 @@ void PackArmPe::pack(OutputFile *fo)
     ODSIZE(PEDIR_RELOC) = soxrelocs;
     ic += soxrelocs;
 
-    if (soresources)
-        processResources(&res,ic);
-    ODADDR(PEDIR_RESOURCE) = soresources ? ic : 0;
-    ODSIZE(PEDIR_RESOURCE) = soresources;
-    ic += soresources;
-
     processImports(ic, linker->getSymbolOffset("IATT") + upxsection);
     ODADDR(PEDIR_IMPORT) = ic;
     ODSIZE(PEDIR_IMPORT) = soimpdlls;
@@ -823,7 +813,15 @@ void PackArmPe::pack(OutputFile *fo)
     }
     ic += soexport;
 
-    const unsigned onam = ncsection + soxrelocs + soresources + ih.imagebase;
+    ic = (ic + oam1) &~ oam1;
+    const unsigned res_start = ic;
+    if (soresources)
+        processResources(&res,ic);
+    ODADDR(PEDIR_RESOURCE) = soresources ? ic : 0;
+    ODSIZE(PEDIR_RESOURCE) = soresources;
+    ic += soresources;
+
+    const unsigned onam = ncsection + soxrelocs + ih.imagebase;
     linker->defineSymbol("start_of_dll_names", onam);
     linker->defineSymbol("start_of_imports", ih.imagebase + rvamin + cimports);
     linker->defineSymbol("start_of_relocs", crelocs + rvamin + ih.imagebase);
@@ -835,54 +833,52 @@ void PackArmPe::pack(OutputFile *fo)
     linker->defineSymbol("compressed_length", ph.c_len);
     linker->defineSymbol("start_of_compressed", ih.imagebase + s1addr + identsize - identsplit);
     defineDecompressorSymbols();
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader, getLoader(), lsize);
     patchPackHeader(loader, lsize);
 
     // this is computed here, because soxrelocs changes some lines above
-    const unsigned ncsize = soxrelocs + soresources + soimpdlls + soexport;
+    const unsigned ncsize = soxrelocs + soimpdlls + soexport;
     const unsigned fam1 = oh.filealign - 1;
 
     // fill the sections
     strcpy(osection[0].name,"UPX0");
     strcpy(osection[1].name,"UPX1");
-    // after some windoze debugging I found that the name of the sections
+    strcpy(osection[2].name, "UPX2");
-    // DOES matter :( .rsrc is used by oleaut32.dll (TYPELIBS)
+    strcpy(osection[3].name, ".rsrc");
-    // and because of this lame dll, the resource stuff must be the
-    // first in the 3rd section - the author of this dll seems to be
-    // too idiot to use the data directories... M$ suxx 4 ever!
-    // ... even worse: exploder.exe in NiceTry also depends on this to
-    // locate version info
-
-    strcpy(osection[2].name,soresources ? ".rsrc" : "UPX2");
 
     osection[0].vaddr = rvamin;
     osection[1].vaddr = s1addr;
     osection[2].vaddr = ncsection;
+    osection[3].vaddr = res_start;
 
     osection[0].size = 0;
     osection[1].size = (s1size + fam1) &~ fam1;
     osection[2].size = (ncsize + fam1) &~ fam1;
+    osection[3].size = (soresources + fam1) &~ fam1;
 
     osection[0].vsize = osection[1].vaddr - osection[0].vaddr;
     //osection[1].vsize = (osection[1].size + oam1) &~ oam1;
     //osection[2].vsize = (osection[2].size + oam1) &~ oam1;
     osection[1].vsize = osection[1].size;
     osection[2].vsize = osection[2].size;
+    osection[3].vsize = osection[3].size;
 
     osection[0].rawdataptr = 0;
     osection[1].rawdataptr = (pe_offset + sizeof(oh) + sizeof(osection) + fam1) &~ fam1;
     osection[2].rawdataptr = osection[1].rawdataptr + osection[1].size;
+    osection[3].rawdataptr = osection[2].rawdataptr + osection[2].size;
 
     osection[0].flags = (unsigned) (PEFL_BSS|PEFL_EXEC|PEFL_WRITE|PEFL_READ);
     osection[1].flags = (unsigned) (PEFL_DATA|PEFL_EXEC|PEFL_WRITE|PEFL_READ);
     osection[2].flags = (unsigned) (PEFL_DATA|PEFL_READ);
+    osection[3].flags = (unsigned) (PEFL_DATA|PEFL_READ);
 
-    oh.imagesize = (osection[2].vaddr + osection[2].vsize + oam1) &~ oam1;
+    oh.imagesize = (osection[3].vaddr + osection[3].vsize + oam1) &~ oam1;
     oh.bsssize  = osection[0].vsize;
-    oh.datasize = osection[2].vsize;
+    oh.datasize = osection[2].vsize + osection[3].vsize;
     oh.database = osection[2].vaddr;
     oh.codesize = osection[1].vsize;
     oh.codebase = osection[1].vaddr;
@@ -900,6 +896,11 @@ void PackArmPe::pack(OutputFile *fo)
 
     infoHeader("[Writing compressed file]");
 
+    if (soresources == 0)
+    {
+        oh.objects = 3;
+        memset(&osection[3], 0, sizeof(osection[3]));
+    }
     // write loader + compressed file
     fo->write(&oh,sizeof(oh));
     fo->write(osection,sizeof(osection));
@@ -920,14 +921,17 @@ void PackArmPe::pack(OutputFile *fo)
     if ((ic = fo->getBytesWritten() & 3) != 0)
         fo->write(ibuf,4 - ic);
     fo->write(otls,sotls);
-    if ((ic = fo->getBytesWritten() & (oh.filealign-1)) != 0)
+    if ((ic = fo->getBytesWritten() & fam1) != 0)
         fo->write(ibuf,oh.filealign - ic);
     fo->write(oxrelocs,soxrelocs);
-    fo->write(oresources,soresources);
     fo->write(oimpdlls,soimpdlls);
     fo->write(oexport,soexport);
 
-    if ((ic = fo->getBytesWritten() & (oh.filealign-1)) != 0)
+    if ((ic = fo->getBytesWritten() & fam1) != 0)
+        fo->write(ibuf,oh.filealign - ic);
+
+    fo->write(oresources,soresources);
+    if ((ic = fo->getBytesWritten() & fam1) != 0)
         fo->write(ibuf,oh.filealign - ic);
 
 #if 0
@@ -970,7 +974,7 @@ int PackArmPe::canUnpack()
     fi->readx(isection,sizeof(pe_section_t)*objs);
     if (ih.objects < 3)
         return -1;
-    bool is_packed = (ih.objects == 3 &&
+    bool is_packed = ((ih.objects == 3 || ih.objects == 4) &&
                       (IDSIZE(15) || ih.entry > isection[1].vaddr));
     bool found_ph = false;
     if (memcmp(isection[0].name,"UPX",3) == 0)

src/p_armpe.h

@@ -39,7 +39,7 @@ class PackArmPe : public PeFile
 
 public:
     PackArmPe(InputFile *f);
-    ~PackArmPe();
+    virtual ~PackArmPe();
     virtual int getFormat() const { return UPX_F_WINCE_ARM_PE; }
     virtual const char *getName() const { return "arm/pe"; }
     virtual const int *getCompressionMethods(int method, int level) const;
@@ -51,7 +51,7 @@ public:
     virtual int canUnpack();
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
     virtual unsigned processImports();

src/p_com.cpp

@@ -101,7 +101,7 @@ void PackCom::patchLoader(OutputFile *fo,
 {
     const int e_len = getLoaderSectionStart("COMCUTPO");
     const int d_len = lsize - e_len;
-    assert(e_len > 0 && e_len < 256);
+    assert(e_len > 0 && e_len < 128);
     assert(d_len > 0 && d_len < 256);
 
     const unsigned upper_end = ph.u_len + ph.overlap_overhead + d_len + 0x100;
@@ -116,9 +116,10 @@ void PackCom::patchLoader(OutputFile *fo,
     linker->defineSymbol("bytes_to_copy", ph.c_len + lsize);
     linker->defineSymbol("copy_source", ph.c_len + lsize + 0x100);
     linker->defineSymbol("copy_destination", upper_end);
-    linker->defineSymbol("COMCUTPO", ph.u_len + ph.overlap_overhead);
+    linker->defineSymbol("neg_e_len", 0 - e_len);
+    linker->defineSymbol("NRV2B160", ph.u_len + ph.overlap_overhead);
 
-    linker->relocate();
+    relocateLoader();
     loader = getLoader();
 
     // some day we could use the relocation stuff for patchPackHeader too
@@ -135,9 +136,9 @@ void PackCom::patchLoader(OutputFile *fo,
 }
 
 
-int PackCom::buildLoader(const Filter *ft)
+void PackCom::buildLoader(const Filter *ft)
 {
-    initLoader(nrv2b_loader,sizeof(nrv2b_loader));
+    initLoader(stub_i086_dos16_com, sizeof(stub_i086_dos16_com));
     addLoader("COMMAIN1",
               ph.first_offset_found == 1 ? "COMSBBBP" : "",
               "COMPSHDI",
@@ -154,8 +155,6 @@ int PackCom::buildLoader(const Filter *ft)
         assert(ft->calls > 0);
         addFilter16(ft->id);
     }
-    freezeLoader();
-    return getLoaderSize();
 }
 
 

src/p_com.h

@@ -38,7 +38,7 @@ class PackCom : public Packer
 {
     typedef Packer super;
 public:
-    PackCom(InputFile *f) : super(f) { }
+    PackCom(InputFile *f) : super(f) { bele = &N_BELE_RTP::le_policy; }
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_DOS_COM; }
     virtual const char *getName() const { return "dos/com"; }
@@ -56,7 +56,7 @@ protected:
     virtual Linker* newLinker() const;
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual void patchLoader(OutputFile *fo, upx_byte *, int, unsigned);
     virtual void addFilter16(int filter_id);
 };

src/p_djgpp2.cpp

@@ -46,13 +46,14 @@ static const
 PackDjgpp2::PackDjgpp2(InputFile *f) :
     super(f), coff_offset(0)
 {
+    bele = &N_BELE_RTP::le_policy;
     COMPILE_TIME_ASSERT(sizeof(external_scnhdr_t) == 40);
     COMPILE_TIME_ASSERT(sizeof(coff_header_t) == 0xa8);
-    COMPILE_TIME_ASSERT(sizeof(stubify_stub) == 2048);
     COMPILE_TIME_ASSERT_ALIGNOF(external_scnhdr_t, char)
     COMPILE_TIME_ASSERT_ALIGNOF(coff_header_t, char)
-    COMPILE_TIME_ASSERT(STUBIFY_STUB_ADLER32 == 0xbf689ba8);
+    COMPILE_TIME_ASSERT(sizeof(stub_i386_dos32_djgpp2_stubify) == 2048);
-    COMPILE_TIME_ASSERT(STUBIFY_STUB_CRC32   == 0x2ae982b2);
+    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_ADLER32 == 0xbf689ba8)
+    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_CRC32   == 0x2ae982b2)
     //printf("0x%08x\n", upx_adler32(stubify_stub, sizeof(stubify_stub)));
     //assert(upx_adler32(stubify_stub, sizeof(stubify_stub)) == STUBIFY_STUB_ADLER32);
 }
@@ -89,10 +90,10 @@ Linker* PackDjgpp2::newLinker() const
 }
 
 
-int PackDjgpp2::buildLoader(const Filter *ft)
+void PackDjgpp2::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader, sizeof(nrv_loader));
+    initLoader(stub_i386_dos32_djgpp2, sizeof(stub_i386_dos32_djgpp2));
     addLoader("IDENTSTR,DJ2MAIN1",
               ft->id ? "DJCALLT1" : "",
               "DJ2MAIN2",
@@ -109,8 +110,6 @@ int PackDjgpp2::buildLoader(const Filter *ft)
         addFilter32(ft->id);
     }
     addLoader("DJRETURN,+40C,UPX1HEAD", NULL);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -130,8 +129,8 @@ void PackDjgpp2::handleStub(OutputFile *fo)
         else
         {
             // "stubify" stub
-            info("Adding stub: %ld bytes", (long)sizeof(stubify_stub));
+            info("Adding stub: %ld bytes", (long)sizeof(stub_i386_dos32_djgpp2_stubify));
-            fo->write(stubify_stub, sizeof(stubify_stub));
+            fo->write(stub_i386_dos32_djgpp2_stubify, sizeof(stub_i386_dos32_djgpp2_stubify));
         }
     }
 }
@@ -251,7 +250,7 @@ static bool defineFilterSymbols(Linker *linker, const Filter *ft)
         int const mru = ph.n_mru ? 1+ ph.n_mru : 0;
         if (mru && mru!=256) {
             unsigned const is_pwr2 = (0==((mru -1) & mru));
-            patch_le32(0x80 + (char *)loader, lsize - 0x80, "NMRU", mru - is_pwr2);
+            //patch_le32(0x80 + (char *)loader, lsize - 0x80, "NMRU", mru - is_pwr2);
         }
     }
 #endif
@@ -369,7 +368,7 @@ void PackDjgpp2::pack(OutputFile *fo)
     data->size = ALIGN_UP(data->size, 4);
 
     linker->defineSymbol("DJ2MAIN1", coff_hdr.a_entry);
-    linker->relocate();
+    relocateLoader();
 
     // prepare loader
     MemBuffer loader(lsize);

src/p_djgpp2.h

@@ -59,7 +59,7 @@ protected:
     virtual unsigned findOverlapOverhead(const upx_bytep buf,
                                          unsigned range = 0,
                                          unsigned upper_limit = ~0u) const;
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
     long coff_offset;

src/p_elks.cpp

@@ -94,14 +94,12 @@ void PackElks8086::readKernel()
 //
 **************************************************************************/
 
-int PackElks8086::buildLoader(const Filter *ft)
+void PackElks8086::buildLoader(const Filter *ft)
 {
     // prepare loader
     initLoader(nrv_loader, sizeof(nrv_loader));
     // FIXME
     UNUSED(ft);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -125,9 +123,9 @@ void PackElks8086::pack(OutputFile *fo)
     // FIXME
     defineFilterSymbols();
     defineDecompressorSymbols();
-    patch_le32(loader, lsize, "ESI1", zimage_offset + lsize);
+    //patch_le32(loader, lsize, "ESI1", zimage_offset + lsize);
-    patch_le32(loader, lsize, "KEIP", kernel_entry);
+    //patch_le32(loader, lsize, "KEIP", kernel_entry);
-    patch_le32(loader, lsize, "STAK", stack_during_uncompression);
+    //patch_le32(loader, lsize, "STAK", stack_during_uncompression);
 #endif
 
     boot_sect_t * const bs = (boot_sect_t *) ((unsigned char *) setup_buf);

src/p_exe.cpp

@@ -50,6 +50,7 @@ static const
 PackExe::PackExe(InputFile *f) :
     super(f)
 {
+    bele = &N_BELE_RTP::le_policy;
     COMPILE_TIME_ASSERT(sizeof(exe_header_t) == 32);
     ih_exesize = ih_imagesize = ih_overlay = 0;
 }
@@ -57,8 +58,20 @@ PackExe::PackExe(InputFile *f) :
 
 const int *PackExe::getCompressionMethods(int method, int level) const
 {
+    static const int m_nrv2b[] = { M_NRV2B_8, M_NRV2D_8, M_NRV2E_8, M_END };
+    static const int m_nrv2d[] = { M_NRV2D_8, M_NRV2B_8, M_NRV2E_8, M_END };
+    static const int m_nrv2e[] = { M_NRV2E_8, M_NRV2B_8, M_NRV2D_8, M_END };
+
     bool small = ih_imagesize <= 256*1024;
-    return Packer::getDefaultCompressionMethods_8(method, level, small);
+    if (M_IS_NRV2B(method))
+        return m_nrv2b;
+    if (M_IS_NRV2D(method))
+        return m_nrv2d;
+    if (M_IS_NRV2E(method))
+        return m_nrv2e;
+    if (level == 1 || small)
+        return m_nrv2b;
+    return m_nrv2e;
 }
 
 
@@ -101,13 +114,13 @@ int PackExe::fillExeHeader(struct exe_header_t *eh) const
 }
 
 
-int PackExe::buildLoader(const Filter *)
+void PackExe::buildLoader(const Filter *)
 {
     struct exe_header_t tmp_oh;
     int flag = fillExeHeader(&tmp_oh);
 
     // prepare loader
-    initLoader(nrv_loader,sizeof(nrv_loader));
+    initLoader(stub_i086_dos16_exe, sizeof(stub_i086_dos16_exe));
     if (device_driver)
         addLoader("DEVICEENTRY", NULL);
     addLoader("EXEENTRY",
@@ -177,8 +190,6 @@ int PackExe::buildLoader(const Filter *)
                   "EXERETIP",
                   NULL
                  );
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -237,6 +248,9 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
                          const upx_byte *relocs, const unsigned nrelocs,
                          upx_byte *crel, bool *has_9a)
 {
+    if (opt->exact)
+        throwCantPackExact();
+
     upx_byte * const crel_save = crel;
     unsigned i;
     unsigned seg_high = 0;
@@ -530,7 +544,7 @@ void PackExe::pack(OutputFile *fo)
 
     oh.ip = device_driver ? getLoaderSection("EXEENTRY") - 2 : 0;
 
-    linker->relocate();
+    relocateLoader();
     memcpy(loader, getLoader(), lsize);
     patchPackHeader(loader,e_len);
 

src/p_exe.h

@@ -68,7 +68,7 @@ protected:
     virtual int readFileHeader(void);
 
     virtual int fillExeHeader(struct exe_header_t *) const;
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
     struct exe_header_t

src/p_lx_elf.cpp

@@ -431,7 +431,7 @@ void PackLinuxElf32x86::defineSymbols(Filter const *const ft)
     }
 }
 
-int
+void
 PackLinuxElf32::buildLinuxLoader(
     upx_byte const *const proto,
     unsigned        const szproto,
@@ -488,13 +488,11 @@ PackLinuxElf32::buildLinuxLoader(
 
     addStubEntrySections(ft);
 
-    freezeLoader();
     defineSymbols(ft);
-    linker->relocate();
+    relocateLoader();
-    return getLoaderSize();
 }
 
-int
+void
 PackLinuxElf64::buildLinuxLoader(
     upx_byte const *const proto,
     unsigned        const szproto,
@@ -538,10 +536,8 @@ PackLinuxElf64::buildLinuxLoader(
 
     addStubEntrySections(ft);
 
-    freezeLoader();
     defineSymbols(ft);
-    linker->relocate();
+    relocateLoader();
-    return getLoaderSize();
 }
 
 void
@@ -567,7 +563,7 @@ PackLinuxElf64amd::defineSymbols(Filter const *)
 #define PAGE_MASK (~0u<<12)
 #define PAGE_SIZE (-PAGE_MASK)
     lsize = /*getLoaderSize()*/  64 * 1024;  // upper bound; avoid circularity
-    acc_uint64l_t       lo_va_stub = elfout.phdr[0].p_vaddr;
+    acc_uint64l_t       lo_va_stub = get_native64(&elfout.phdr[0].p_vaddr);
     acc_uint64l_t adrc;
     acc_uint64l_t adrm;
     acc_uint64l_t adru;
@@ -629,15 +625,15 @@ static const
 static const
 #include "stub/i386-linux.elf-fold.h"
 
-int
+void
 PackLinuxElf32x86::buildLoader(const Filter *ft)
 {
-    unsigned char tmp[sizeof(linux_i386elf_fold)];
+    unsigned char tmp[sizeof(stub_i386_linux_elf_fold)];
-    memcpy(tmp, linux_i386elf_fold, sizeof(linux_i386elf_fold));
+    memcpy(tmp, stub_i386_linux_elf_fold, sizeof(stub_i386_linux_elf_fold));
     checkPatch(NULL, 0, 0, 0);  // reset
     if (opt->o_unix.is_ptinterp) {
         unsigned j;
-        for (j = 0; j < sizeof(linux_i386elf_fold)-1; ++j) {
+        for (j = 0; j < sizeof(stub_i386_linux_elf_fold)-1; ++j) {
             if (0x60==tmp[  j]
             &&  0x47==tmp[1+j] ) {
                 /* put INC EDI before PUSHA: inhibits auxv_up for PT_INTERP */
@@ -647,9 +643,9 @@ PackLinuxElf32x86::buildLoader(const Filter *ft)
             }
         }
     }
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        linux_i386elf_loader, sizeof(linux_i386elf_loader),
+        stub_i386_linux_elf_entry, sizeof(stub_i386_linux_elf_entry),
-        tmp,                  sizeof(linux_i386elf_fold),  ft );
+        tmp,                       sizeof(stub_i386_linux_elf_fold),  ft );
 }
 
 static const
@@ -657,15 +653,15 @@ static const
 static const
 #include "stub/i386-bsd.elf-fold.h"
 
-int
+void
 PackBSDElf32x86::buildLoader(const Filter *ft)
 {
-    unsigned char tmp[sizeof(bsd_i386elf_fold)];
+    unsigned char tmp[sizeof(stub_i386_bsd_elf_fold)];
-    memcpy(tmp, bsd_i386elf_fold, sizeof(bsd_i386elf_fold));
+    memcpy(tmp, stub_i386_bsd_elf_fold, sizeof(stub_i386_bsd_elf_fold));
     checkPatch(NULL, 0, 0, 0);  // reset
     if (opt->o_unix.is_ptinterp) {
         unsigned j;
-        for (j = 0; j < sizeof(bsd_i386elf_fold)-1; ++j) {
+        for (j = 0; j < sizeof(stub_i386_bsd_elf_fold)-1; ++j) {
             if (0x60==tmp[  j]
             &&  0x47==tmp[1+j] ) {
                 /* put INC EDI before PUSHA: inhibits auxv_up for PT_INTERP */
@@ -675,9 +671,9 @@ PackBSDElf32x86::buildLoader(const Filter *ft)
             }
         }
     }
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        bsd_i386elf_loader, sizeof(bsd_i386elf_loader),
+        stub_i386_bsd_elf_entry, sizeof(stub_i386_bsd_elf_entry),
-        tmp,                sizeof(bsd_i386elf_fold),  ft );
+        tmp,                     sizeof(stub_i386_bsd_elf_fold), ft);
 }
 
 #if 0  //{  re-use for OpenBSD, too
@@ -687,15 +683,15 @@ static const
 static const
 #include "stub/i386-openbsd.elf-fold.h"
 
-int
+void
 PackOpenBSDElf32x86::buildLoader(const Filter *ft)
 {
-    unsigned char tmp[sizeof(openbsd_i386elf_fold)];
+    unsigned char tmp[sizeof(stub_i386_openbsd_elf_fold)];
-    memcpy(tmp, openbsd_i386elf_fold, sizeof(openbsd_i386elf_fold));
+    memcpy(tmp, stub_i386_openbsd_elf_fold, sizeof(stub_i386_openbsd_elf_fold));
     checkPatch(NULL, 0, 0, 0);  // reset
     if (opt->o_unix.is_ptinterp) {
         unsigned j;
-        for (j = 0; j < sizeof(openbsd_i386elf_fold)-1; ++j) {
+        for (j = 0; j < sizeof(stub_i386_openbsd_elf_fold)-1; ++j) {
             if (0x60==tmp[  j]
             &&  0x47==tmp[1+j] ) {
                 /* put INC EDI before PUSHA: inhibits auxv_up for PT_INTERP */
@@ -705,9 +701,9 @@ PackOpenBSDElf32x86::buildLoader(const Filter *ft)
             }
         }
     }
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        bsd_i386elf_loader, sizeof(bsd_i386elf_loader),
+        stub_i386_bsd_elf_entry, sizeof(stub_i386_bsd_elf_entry),
-        tmp,                sizeof(openbsd_i386elf_fold),  ft );
+        tmp,                     sizeof(stub_i386_openbsd_elf_fold), ft);
 }
 
 static const
@@ -715,78 +711,27 @@ static const
 static const
 #include "stub/arm-linux.elf-fold.h"
 
+static const
+#include "stub/armeb-linux.elf-entry.h"
+static const
+#include "stub/armeb-linux.elf-fold.h"
+
 #include "mem.h"
 
-static void brev(
+void
-    unsigned char       *const dst,
-    unsigned char const *const src,
-    unsigned len
-)
-{
-    assert(0==(3 & len));
-    // Detect overlap which over-writes src before it is used.
-    assert(!((4+ src)<=dst && dst < (len + src)));
-    for (unsigned j = 0; j < len; j += 4) {
-        // Simple way (and somewhat slow) to allow in-place brev().
-        unsigned char tmp[4];
-        memcpy(tmp, j + src, 4);
-        dst[0+ j] = tmp[3];
-        dst[1+ j] = tmp[2];
-        dst[2+ j] = tmp[1];
-        dst[3+ j] = tmp[0];
-    }
-}
-
-static void
-ehdr_bele(Elf_BE32_Ehdr *const ehdr_be, Elf_LE32_Ehdr const *const ehdr_le)
-{
-    memcpy(&ehdr_be->e_ident, &ehdr_le->e_ident, sizeof(ehdr_be->e_ident));
-    ehdr_be->e_ident[Elf32_Ehdr::EI_DATA] = Elf32_Ehdr::ELFDATA2MSB;
-    ehdr_be->e_type      = ehdr_le->e_type;
-    ehdr_be->e_machine   = ehdr_le->e_machine;
-    ehdr_be->e_version   = ehdr_le->e_version;
-    ehdr_be->e_entry     = ehdr_le->e_entry;
-    ehdr_be->e_phoff     = ehdr_le->e_phoff;
-    ehdr_be->e_shoff     = ehdr_le->e_shoff;
-    ehdr_be->e_flags     = ehdr_le->e_flags;
-    ehdr_be->e_ehsize    = ehdr_le->e_ehsize;
-    ehdr_be->e_phentsize = ehdr_le->e_phentsize;
-    ehdr_be->e_phnum     = ehdr_le->e_phnum;
-    ehdr_be->e_shentsize = ehdr_le->e_shentsize;
-    ehdr_be->e_shnum     = ehdr_le->e_shnum;
-    ehdr_be->e_shstrndx  = ehdr_le->e_shstrndx;
-}
-
-static void
-ehdr_lebe(Elf_LE32_Ehdr *const ehdr_le, Elf_BE32_Ehdr const *const ehdr_be)
-{
-    memcpy(&ehdr_le->e_ident, &ehdr_be->e_ident, sizeof(ehdr_le->e_ident));
-    ehdr_le->e_ident[Elf32_Ehdr::EI_DATA] = Elf32_Ehdr::ELFDATA2LSB;
-    ehdr_le->e_type      = ehdr_be->e_type;
-    ehdr_le->e_machine   = ehdr_be->e_machine;
-    ehdr_le->e_version   = ehdr_be->e_version;
-    ehdr_le->e_entry     = ehdr_be->e_entry;
-    ehdr_le->e_phoff     = ehdr_be->e_phoff;
-    ehdr_le->e_shoff     = ehdr_be->e_shoff;
-    ehdr_le->e_flags     = ehdr_be->e_flags;
-    ehdr_le->e_ehsize    = ehdr_be->e_ehsize;
-    ehdr_le->e_phentsize = ehdr_be->e_phentsize;
-    ehdr_le->e_phnum     = ehdr_be->e_phnum;
-    ehdr_le->e_shentsize = ehdr_be->e_shentsize;
-    ehdr_le->e_shnum     = ehdr_be->e_shnum;
-    ehdr_le->e_shstrndx  = ehdr_be->e_shstrndx;
-}
-
-int
 PackLinuxElf32armBe::buildLoader(Filter const *ft)
 {
-    return ARM_buildLoader(ft, true);
+    buildLinuxLoader(
+        stub_armeb_linux_elf_entry, sizeof(stub_armeb_linux_elf_entry),
+        stub_armeb_linux_elf_fold,  sizeof(stub_armeb_linux_elf_fold), ft);
 }
 
-int
+void
 PackLinuxElf32armLe::buildLoader(Filter const *ft)
 {
-    return ARM_buildLoader(ft, false);
+    buildLinuxLoader(
+        stub_arm_linux_elf_entry, sizeof(stub_arm_linux_elf_entry),
+        stub_arm_linux_elf_fold,  sizeof(stub_arm_linux_elf_fold), ft);
 }
 
 static const
@@ -794,12 +739,12 @@ static const
 static const
 #include "stub/powerpc-linux.elf-fold.h"
 
-int
+void
 PackLinuxElf32ppc::buildLoader(const Filter *ft)
 {
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        linux_elfppc32_loader, sizeof(linux_elfppc32_loader),
+        stub_powerpc_linux_elf_entry, sizeof(stub_powerpc_linux_elf_entry),
-        linux_elfppc32_fold,   sizeof(linux_elfppc32_fold),  ft );
+        stub_powerpc_linux_elf_fold,  sizeof(stub_powerpc_linux_elf_fold), ft);
 }
 
 static const
@@ -807,12 +752,12 @@ static const
 static const
 #include "stub/amd64-linux.elf-fold.h"
 
-int
+void
 PackLinuxElf64amd::buildLoader(const Filter *ft)
 {
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        linux_elf64amd_loader, sizeof(linux_elf64amd_loader),
+        stub_amd64_linux_elf_entry, sizeof(stub_amd64_linux_elf_entry),
-        linux_elf64amd_fold,   sizeof(linux_elf64amd_fold),  ft );
+        stub_amd64_linux_elf_fold,  sizeof(stub_amd64_linux_elf_fold), ft);
 }
 
 bool PackLinuxElf32::canPack()
@@ -1053,7 +998,7 @@ PackLinuxElf32::generateElfHdr(
                          h2->ehdr.e_shoff = 0;
     assert(get_native16(&h2->ehdr.e_ehsize)    == sizeof(Elf32_Ehdr));
     assert(get_native16(&h2->ehdr.e_phentsize) == sizeof(Elf32_Phdr));
-                         h2->ehdr.e_shentsize = 0;
+           set_native16(&h2->ehdr.e_shentsize, sizeof(Elf32_Shdr));
                          h2->ehdr.e_shnum = 0;
                          h2->ehdr.e_shstrndx = 0;
 
@@ -1103,7 +1048,7 @@ PackOpenBSDElf32x86::generateElfHdr(
                          h3->ehdr.e_shoff = 0;
     assert(get_native16(&h3->ehdr.e_ehsize)    == sizeof(Elf32_Ehdr));
     assert(get_native16(&h3->ehdr.e_phentsize) == sizeof(Elf32_Phdr));
-                         h3->ehdr.e_shentsize = 0;
+           set_native16(&h3->ehdr.e_shentsize, sizeof(Elf32_Shdr));
                          h3->ehdr.e_shnum = 0;
                          h3->ehdr.e_shstrndx = 0;
 
@@ -1165,7 +1110,7 @@ PackLinuxElf64::generateElfHdr(
                          h2->ehdr.e_shoff = 0;
     assert(get_native16(&h2->ehdr.e_ehsize)    == sizeof(Elf64_Ehdr));
     assert(get_native16(&h2->ehdr.e_phentsize) == sizeof(Elf64_Phdr));
-                         h2->ehdr.e_shentsize = 0;
+           set_native16(&h2->ehdr.e_shentsize, sizeof(Elf64_Shdr));
                          h2->ehdr.e_shnum = 0;
                          h2->ehdr.e_shstrndx = 0;
 
@@ -1217,52 +1162,35 @@ void PackLinuxElf32::pack1(OutputFile */*fo*/, Filter &/*ft*/)
 void PackLinuxElf32x86::pack1(OutputFile *fo, Filter &ft)
 {
     PackLinuxElf32::pack1(fo, ft);
-    generateElfHdr(fo, linux_i386elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
+    generateElfHdr(fo, stub_i386_linux_elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
 void PackBSDElf32x86::pack1(OutputFile *fo, Filter &ft)
 {
     PackLinuxElf32::pack1(fo, ft);
-    generateElfHdr(fo, bsd_i386elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
+    generateElfHdr(fo, stub_i386_bsd_elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
-}
-
-void PackLinuxElf32::ARM_pack1(OutputFile *fo, bool const isBE)
-{
-    Elf32_Ehdr const *const fold = (Elf32_Ehdr const *)&linux_elf32arm_fold;
-    cprElfHdr3 h3;
-    // We need Elf32_Ehdr and Elf32_Phdr with byte gender of target.
-    // The stub may have been compiled differently.
-    if (this->ei_data==fold->e_ident[Elf32_Ehdr::EI_DATA]) {
-        memcpy(&h3, (void const *)linux_elf32arm_fold,
-            sizeof(Elf32_Ehdr) + 2*sizeof(Elf32_Phdr) );
-    }
-    else {
-        (isBE ? (void (*)(void *, void const *))ehdr_bele
-              : (void (*)(void *, void const *))ehdr_lebe)
-                ((void *)&h3.ehdr, (void const *)linux_elf32arm_fold);
-        brev((unsigned char *)&h3.phdr[0],
-            sizeof(Elf32_Ehdr) + (unsigned char const *)&linux_elf32arm_fold,
-            3*sizeof(Elf32_Phdr) );
-    }
-    generateElfHdr(fo, &h3, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
 void PackLinuxElf32armLe::pack1(OutputFile *fo, Filter &ft)
 {
     super::pack1(fo, ft);
-    ARM_pack1(fo, false);
+    cprElfHdr3 h3;
+    memcpy(&h3, stub_arm_linux_elf_fold, sizeof(Elf32_Ehdr) + 2*sizeof(Elf32_Phdr));
+    generateElfHdr(fo, &h3, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
-void PackLinuxElf32armBe::pack1(OutputFile *fo, Filter &ft)  // FIXME
+void PackLinuxElf32armBe::pack1(OutputFile *fo, Filter &ft)
 {
     super::pack1(fo, ft);
-    ARM_pack1(fo, true);
+    cprElfHdr3 h3;
+    memcpy(&h3, stub_armeb_linux_elf_fold, sizeof(Elf32_Ehdr) + 2*sizeof(Elf32_Phdr));
+    generateElfHdr(fo, &h3, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
 void PackLinuxElf32ppc::pack1(OutputFile *fo, Filter &ft)
 {
     super::pack1(fo, ft);
-    generateElfHdr(fo, linux_elfppc32_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
+    generateElfHdr(fo, stub_powerpc_linux_elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
 void PackLinuxElf64::pack1(OutputFile */*fo*/, Filter &/*ft*/)
@@ -1284,7 +1212,7 @@ void PackLinuxElf64::pack1(OutputFile */*fo*/, Filter &/*ft*/)
 void PackLinuxElf64amd::pack1(OutputFile *fo, Filter &ft)
 {
     super::pack1(fo, ft);
-    generateElfHdr(fo, linux_elf64amd_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
+    generateElfHdr(fo, stub_amd64_linux_elf_fold, getbrk(phdri, get_native16(&ehdri.e_phnum)) );
 }
 
 // Determine length of gap between PT_LOAD phdr[k] and closest PT_LOAD
@@ -1498,7 +1426,7 @@ ARM_getFilters(bool const isBE)
 {
     static const int f50[] = { 0x50, -1 };
     static const int f51[] = { 0x51, -1 };
-    if (HostPolicy::isBE ^ isBE)
+    if (isBE)
         return f51;
     return f50;
 }
@@ -1515,62 +1443,6 @@ PackLinuxElf32armLe::getFilters() const
     return ARM_getFilters(false);
 }
 
-int
-PackLinuxElf32::ARM_buildLoader(const Filter *ft, bool const isBE)
-{
-    unsigned const sz_loader = sizeof(linux_elf32arm_loader);
-    unsigned const sz_fold   = sizeof(linux_elf32arm_fold);
-
-    // Was ARM code assembled for same endianness as the target?
-    bool const asm_brev = (this->ei_data
-        != ((Elf32_Ehdr const *)linux_elf32arm_fold)->e_ident[Elf32_Ehdr::EI_DATA] );
-
-    MemBuffer tmp_fold(sz_fold);
-    memcpy(tmp_fold, linux_elf32arm_fold, sz_fold);
-
-    // 0xe3530050  is  "cmp fid,#0x50" with fid .req r3
-    if (HostPolicy::isBE ^ isBE) { // change filter 0x50 to filter 0x51
-        if (HostPolicy::isBE ^ isBE ^ asm_brev) {  // find 0xe3530050 big-endian
-            checkPatch(NULL,0,0,0);  // reset
-            patch_be32(tmp_fold, sz_fold, "\xe3\x53\x00\x50", 0xe3530051);
-            checkPatch(NULL,0,0,0);  // reset
-        }
-        else { // find 0xe3530050 little-endian
-            checkPatch(NULL,0,0,0);  // reset
-            patch_le32(tmp_fold, sz_fold, "\x50\x00\x53\xe3", 0xe3530051);
-            checkPatch(NULL,0,0,0);  // reset
-        }
-    }
-    if (!asm_brev) { // was assembled to match target
-        return buildLinuxLoader(linux_elf32arm_loader, sz_loader,
-            tmp_fold, sz_fold, ft );
-    }
-    else { // was assembled brev() from target
-        // linux_elf32arm_loader[] is all instructions, except for two strings
-        // at the end: the copyright message, and the SELinux message.
-        // The copyright message begins and ends with '\n', and the SELinux
-        // message ends with '\n'.  So copy back to the third '\n' from the end,
-        // and apply brev() only before that point.
-        MemBuffer brev_loader(sz_loader);
-        int nl = 0;
-        int j;
-        for (j= sz_loader; --j>=0; ) {
-            unsigned char const c = linux_elf32arm_loader[j];
-            brev_loader[j] = c;
-            if ('\n'==c) {
-                if (3==++nl) {
-                    break;
-                }
-            }
-        }
-        brev(brev_loader, linux_elf32arm_loader, j);
-        (isBE ? (void (*)(void *, void const *))ehdr_bele
-              : (void (*)(void *, void const *))ehdr_lebe)
-                (tmp_fold.getVoidPtr(), (void const *)linux_elf32arm_fold);
-        return buildLinuxLoader(brev_loader, sz_loader, tmp_fold, sz_fold, ft);
-    }
-}
-
 void PackLinuxElf32::ARM_defineSymbols(Filter const * /*ft*/)
 {
     unsigned const hlen = sz_elf_hdrs + sizeof(l_info) + sizeof(p_info);

src/p_lx_elf.h

@@ -40,7 +40,7 @@ class PackLinuxElf : public PackUnix
 public:
     PackLinuxElf(InputFile *f);
     virtual ~PackLinuxElf();
-    /*virtual int buildLoader(const Filter *);*/
+    /*virtual void buildLoader(const Filter *);*/
     virtual bool canUnpackVersion(int version) const { return (version >= 11); }
 
 protected:
@@ -90,10 +90,8 @@ protected:
 
     // These ARM routines are essentially common to big/little endian,
     // but the class hierarchy splits after this class.
-    virtual int ARM_buildLoader(Filter const *ft, bool isBE);
     virtual void ARM_defineSymbols(Filter const *ft);
     virtual void ARM_updateLoader(OutputFile *);
-    virtual void ARM_pack1(OutputFile *, bool isBE);
 
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
     virtual void pack2(OutputFile *, Filter &);  // append compressed data
@@ -106,7 +104,7 @@ protected:
         void const *proto,
         unsigned const brka
     );
-    virtual int buildLinuxLoader(
+    virtual void buildLinuxLoader(
         upx_byte const *const proto,  // assembly-only sections
         unsigned const szproto,
         upx_byte const *const fold,  // linked assembly + C section
@@ -172,7 +170,7 @@ class PackLinuxElf64 : public PackLinuxElf
 public:
     PackLinuxElf64(InputFile *f);
     virtual ~PackLinuxElf64();
-    /*virtual int buildLoader(const Filter *);*/
+    /*virtual void buildLoader(const Filter *);*/
 
 protected:
     virtual int checkEhdr(Elf64_Ehdr const *ehdr) const;
@@ -188,7 +186,7 @@ protected:
         void const *proto,
         unsigned const brka
     );
-    virtual int buildLinuxLoader(
+    virtual void buildLinuxLoader(
         upx_byte const *const proto,  // assembly-only sections
         unsigned const szproto,
         upx_byte const *const fold,  // linked assembly + C section
@@ -233,7 +231,7 @@ class PackLinuxElf32Be : public PackLinuxElf32
 {
     typedef PackLinuxElf32 super;
 protected:
-    PackLinuxElf32Be(InputFile *f) : super(f) { }
+    PackLinuxElf32Be(InputFile *f) : super(f) { bele = &N_BELE_RTP::be_policy; }
 
     virtual acc_uint64l_t get_native64(const void *b) const { return get_be64(b); }
     virtual unsigned get_native32(const void *b) const { return get_be32(b); }
@@ -247,7 +245,7 @@ class PackLinuxElf32Le : public PackLinuxElf32
 {
     typedef PackLinuxElf32 super;
 protected:
-    PackLinuxElf32Le(InputFile *f) : super(f) { }
+    PackLinuxElf32Le(InputFile *f) : super(f) { bele = &N_BELE_RTP::le_policy; }
 
     virtual acc_uint64l_t get_native64(const void *b) const { return get_le64(b); }
     virtual unsigned get_native32(const void *b) const { return get_le32(b); }
@@ -261,7 +259,7 @@ class PackLinuxElf64Le : public PackLinuxElf64
 {
     typedef PackLinuxElf64 super;
 protected:
-    PackLinuxElf64Le(InputFile *f) : super(f) { }
+    PackLinuxElf64Le(InputFile *f) : super(f) { bele = &N_BELE_RTP::le_policy; }
 
     virtual acc_uint64l_t get_native64(const void *b) const { return get_le64(b); }
     virtual unsigned get_native32(const void *b) const { return get_le32(b); }
@@ -288,7 +286,7 @@ public:
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
     //virtual void pack3(OutputFile *, Filter &);  // append loader
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
     virtual Linker* newLinker() const;
     virtual void defineSymbols(Filter const *);
 };
@@ -308,7 +306,7 @@ public:
     virtual const int *getFilters() const;
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
     virtual Linker* newLinker() const;
 };
 
@@ -331,7 +329,7 @@ public:
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
 
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
     virtual void addStubEntrySections(Filter const *);
     virtual Linker* newLinker() const;
     virtual void defineSymbols(Filter const *);
@@ -349,7 +347,7 @@ public:
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
 
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
 };
 
 class PackFreeBSDElf32x86 : public PackBSDElf32x86
@@ -376,7 +374,7 @@ public:
     virtual ~PackOpenBSDElf32x86();
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual void generateElfHdr(
         OutputFile *,
         void const *proto,
@@ -402,7 +400,7 @@ protected:
     virtual const int *getCompressionMethods(int method, int level) const;
     virtual Linker* newLinker() const;
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
     virtual void updateLoader(OutputFile *);
     virtual void defineSymbols(Filter const *);
 };
@@ -421,7 +419,7 @@ protected:
     virtual const int *getCompressionMethods(int method, int level) const;
     virtual Linker* newLinker() const;
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
     virtual void updateLoader(OutputFile *);
     virtual void defineSymbols(Filter const *);
 };

src/p_lx_exc.cpp

@@ -57,6 +57,7 @@
 PackLinuxI386::PackLinuxI386(InputFile *f) : super(f),
     ei_osabi(Elf32_Ehdr::ELFOSABI_LINUX), osabi_note(NULL)
 {
+    bele = &N_BELE_RTP::le_policy;
 }
 
 PackBSDI386::PackBSDI386(InputFile *f) : super(f)
@@ -182,7 +183,7 @@ PackLinuxI386::pack1(OutputFile *fo, Filter &)
     // create a pseudo-unique program id for our paranoid stub
     progid = getRandomId();
 
-    generateElfHdr(fo, linux_i386exec_fold, 0);
+    generateElfHdr(fo, stub_i386_linux_elf_execve_fold, 0);
 }
 
 void
@@ -191,7 +192,7 @@ PackBSDI386::pack1(OutputFile *fo, Filter &)
     // create a pseudo-unique program id for our paranoid stub
     progid = getRandomId();
 
-    generateElfHdr(fo, bsd_i386exec_fold, 0);
+    generateElfHdr(fo, stub_i386_bsd_elf_execve_fold, 0);
 }
 
 void
@@ -292,7 +293,7 @@ Linker *PackLinuxI386::newLinker() const
     return new ElfLinkerX86;
 }
 
-int
+void
 PackLinuxI386::buildLinuxLoader(
     upx_byte const *const proto,
     unsigned        const szproto,
@@ -372,13 +373,14 @@ PackLinuxI386::buildLinuxLoader(
     addLoader("IDENTSTR", NULL);
     addLoader("LEXEC020", NULL);
     addLoader("FOLDEXEC", NULL);
-    freezeLoader();
     if (ph.method == M_LZMA) {
         const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
-        unsigned const properties = // lc, lp, pb, dummy
+        acc_uint32e_t properties = // lc, lp, pb, dummy
             (res->lit_context_bits << 0) |
             (res->lit_pos_bits << 8) |
             (res->pos_bits << 16);
+        if (linker->bele->isBE()) // big endian - bswap32
+            acc_swab32s(&properties);
         linker->defineSymbol("lzma_properties", properties);
         // -2 for properties
         linker->defineSymbol("lzma_c_len", ph.c_len - 2);
@@ -393,16 +395,15 @@ PackLinuxI386::buildLinuxLoader(
             linker->defineSymbol("NMRU", mru - is_pwr2);
         }
     }
-    linker->relocate();
+    relocateLoader();
-    return getLoaderSize();
 }
 
-int
+void
 PackLinuxI386::buildLoader(Filter const *ft)
 {
-    unsigned const sz_fold = sizeof(linux_i386exec_fold);
+    unsigned const sz_fold = sizeof(stub_i386_linux_elf_execve_fold);
     MemBuffer buf(sz_fold);
-    memcpy(buf, linux_i386exec_fold, sz_fold);
+    memcpy(buf, stub_i386_linux_elf_execve_fold, sz_fold);
 
     // patch loader
     // note: we only can use /proc/<pid>/fd when exetype > 0.
@@ -412,17 +413,17 @@ PackLinuxI386::buildLoader(Filter const *ft)
     patch_le32(buf,sz_fold,"UPX3",progid);
     patch_le32(buf,sz_fold,"UPX2",exetype > 0 ? 0 : 0x7fffffff);
 
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        linux_i386exec_loader, sizeof(linux_i386exec_loader),
+        stub_i386_linux_elf_execve_entry, sizeof(stub_i386_linux_elf_execve_entry),
         buf, sz_fold, ft );
 }
 
-int
+void
 PackBSDI386::buildLoader(Filter const *ft)
 {
-    unsigned const sz_fold = sizeof(bsd_i386exec_fold);
+    unsigned const sz_fold = sizeof(stub_i386_bsd_elf_execve_fold);
     MemBuffer buf(sz_fold);
-    memcpy(buf, bsd_i386exec_fold, sz_fold);
+    memcpy(buf, stub_i386_bsd_elf_execve_fold, sz_fold);
 
     // patch loader
     // note: we only can use /proc/<pid>/fd when exetype > 0.
@@ -432,8 +433,8 @@ PackBSDI386::buildLoader(Filter const *ft)
     patch_le32(buf,sz_fold,"UPX3",progid);
     patch_le32(buf,sz_fold,"UPX2",exetype > 0 ? 0 : 0x7fffffff);
 
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        bsd_i386exec_loader, sizeof(bsd_i386exec_loader),
+        stub_i386_bsd_elf_execve_entry, sizeof(stub_i386_bsd_elf_execve_entry),
         buf, sz_fold, ft );
 }
 
@@ -449,7 +450,7 @@ int PackLinuxI386::getLoaderPrefixSize() const
 **************************************************************************/
 
 // basic check of an Linux ELF Ehdr
-int PackLinuxI386::checkEhdr(const Elf32_Ehdr *ehdr) const
+int PackLinuxI386::checkEhdr(const Elf_LE32_Ehdr *ehdr) const
 {
     const unsigned char * const buf = ehdr->e_ident;
 
@@ -499,7 +500,7 @@ bool PackLinuxI386::canPack()
     if (exetype != 0)
         return super::canPack();
 
-    Elf32_Ehdr ehdr;
+    Elf_LE32_Ehdr ehdr;
     unsigned char *buf = ehdr.e_ident;
 
     fi->seek(0, SEEK_SET);

src/p_lx_exc.h

@@ -51,7 +51,7 @@ public:
     virtual const char *getName() const { return "linux/386"; }
     virtual const int *getCompressionMethods(int method, int level) const;
     virtual const int *getFilters() const;
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
 
     virtual bool canPack();
 
@@ -64,7 +64,7 @@ protected:
     // loader util
     virtual Linker* newLinker() const;
     virtual int getLoaderPrefixSize() const;
-    virtual int buildLinuxLoader(
+    virtual void buildLinuxLoader(
         upx_byte const *const proto,  // assembly-only sections
         unsigned const szproto,
         upx_byte const *const fold,  // linked assembly + C section
@@ -78,7 +78,7 @@ protected:
     virtual void updateLoader(OutputFile *);
 
     // ELF util
-    virtual int checkEhdr(const Elf32_Ehdr *ehdr) const;
+    virtual int checkEhdr(const Elf_LE32_Ehdr *ehdr) const;
 
     enum {
         UPX_ELF_MAGIC = 0x5850557f          // "\x7fUPX"
@@ -133,7 +133,7 @@ public:
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
 
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
 };
 #endif /* already included */
 

src/p_lx_interp.cpp

@@ -147,8 +147,8 @@ void PackLinuxElf32x86interp::pack3(OutputFile *fo, Filter &/*ft*/)
     }
     elfout.phdr[0].p_paddr = elfout.phdr[0].p_vaddr = base - sz;
     if (opt->o_unix.make_ptinterp) {
-        initLoader(linux_i386pti_loader, sizeof(linux_i386pti_loader));
+        initLoader(stub_i386_linux_elf_interp_entry, sizeof(stub_i386_linux_elf_interp_entry));
-        linker->addSection("FOLDEXEC", linux_i386pti_fold, sizeof(linux_i386pti_fold), 0);
+        linker->addSection("FOLDEXEC", stub_i386_linux_elf_interp_fold, sizeof(stub_i386_linux_elf_interp_fold), 0);
 
         addLoader("LXPTI000", NULL);
 
@@ -182,7 +182,6 @@ void PackLinuxElf32x86interp::pack3(OutputFile *fo, Filter &/*ft*/)
 
         addLoader("LXPTI200", NULL);
         addLoader("FOLDEXEC", NULL);
-        freezeLoader();
         upx_byte const *p = getLoader();
         lsize = getLoaderSize();
         updateLoader(fo);

src/p_lx_sh.cpp

@@ -71,12 +71,12 @@ umax(unsigned a, unsigned b)
     return a;
 }
 
-int
+void
 PackLinuxI386sh::buildLoader(Filter const *ft)
 {
-    unsigned const sz_fold = sizeof(linux_i386sh_fold);
+    unsigned const sz_fold = sizeof(stub_i386_linux_elf_shell_fold);
     MemBuffer buf(sz_fold);
-    memcpy(buf, linux_i386sh_fold, sz_fold);
+    memcpy(buf, stub_i386_linux_elf_shell_fold, sz_fold);
 
     checkPatch(NULL, 0, 0, 0);  // reset
     patch_le32(buf,sz_fold,"UPX3",l_shname);
@@ -99,8 +99,8 @@ PackLinuxI386sh::buildLoader(Filter const *ft)
     bool success = fold_ft.filter(buf + fold_hdrlen, sz_fold - fold_hdrlen);
     UNUSED(success);
 
-    return buildLinuxLoader(
+    buildLinuxLoader(
-        linux_i386sh_loader, sizeof(linux_i386sh_loader),
+        stub_i386_linux_elf_shell_entry, sizeof(stub_i386_linux_elf_shell_entry),
         buf, sz_fold, ft );
 }
 
@@ -158,7 +158,7 @@ bool PackLinuxI386sh::canPack()
 void
 PackLinuxI386sh::pack1(OutputFile *fo, Filter &)
 {
-    generateElfHdr(fo, linux_i386sh_fold, 0x08048000);
+    generateElfHdr(fo, stub_i386_linux_elf_shell_fold, 0x08048000);
 }
 
 void

src/p_lx_sh.h

@@ -48,7 +48,7 @@ public:
     virtual int getFormat() const { return UPX_F_LINUX_SH_i386; }
     virtual const char *getName() const { return "linux/sh386"; }
     virtual const int *getFilters() const { return NULL; }
-    virtual int buildLoader(const Filter *);
+    virtual void buildLoader(const Filter *);
 
     virtual void pack1(OutputFile *fo, Filter &ft);
     virtual void pack3(OutputFile *fo, Filter &ft);

src/p_mach.cpp

@@ -90,7 +90,7 @@ void PackMachPPC32::defineSymbols(Filter const *)
 }
 
 
-int
+void
 PackMachPPC32::buildMachLoader(
     upx_byte const *const proto,
     unsigned        const szproto,
@@ -131,18 +131,16 @@ PackMachPPC32::buildMachLoader(
 
     addStubEntrySections(ft);
 
-    freezeLoader();
     defineSymbols(ft);
-    linker->relocate();
+    relocateLoader();
-    return getLoaderSize();
 }
 
-int
+void
 PackMachPPC32::buildLoader(const Filter *ft)
 {
-    return buildMachLoader(
+    buildMachLoader(
-        l_mac_ppc32_loader, sizeof(l_mac_ppc32_loader),
+        stub_powerpc_darwin_macho_entry, sizeof(stub_powerpc_darwin_macho_entry),
-        fold_machppc32,     sizeof(fold_machppc32),  ft );
+        stub_powerpc_darwin_macho_fold,  sizeof(stub_powerpc_darwin_macho_fold),  ft );
 }
 void PackMachPPC32::patchLoader() { }
 void PackMachPPC32::updateLoader(OutputFile *) {}

src/p_mach.h

@@ -180,12 +180,12 @@ public:
     virtual unsigned find_SEGMENT_gap(unsigned const k);
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
     virtual void patchLoader();
     virtual void patchLoaderChecksum();
     virtual void updateLoader(OutputFile *);
-    virtual int buildMachLoader(
+    virtual void buildMachLoader(
         upx_byte const *const proto,
         unsigned        const szproto,
         upx_byte const *const fold,

src/p_ps1.cpp

@@ -61,6 +61,7 @@ static const
 #define MIPS_PC16(a)    ((a) >> 2)
 #define MIPS_PC26(a)    (((a) & 0x0fffffff) >> 2)
 
+
 /*************************************************************************
 // ps1 exe looks like this:
 // 1. <header>  2048 bytes
@@ -81,6 +82,7 @@ PackPs1::PackPs1(InputFile *f) :
     buildPart2(0), foundBss(0), sa_cnt(0), overlap(0), sz_lunc(0), sz_lcpr(0),
     pad_code(0), bss_start(0), bss_end(0)
 {
+    bele = &N_BELE_RTP::le_policy;
     COMPILE_TIME_ASSERT(sizeof(ps1_exe_t) == 136);
     COMPILE_TIME_ASSERT(sizeof(ps1_exe_hb_t) == 44);
     COMPILE_TIME_ASSERT(sizeof(ps1_exe_chb_t) == 5);
@@ -110,30 +112,6 @@ const int *PackPs1::getFilters() const
 
 Linker* PackPs1::newLinker() const
 {
-    class ElfLinkerMipsLE : public ElfLinker
-    {
-        typedef ElfLinker super;
-
-        virtual void relocate1(const Relocation *rel, upx_byte *location,
-                               unsigned value, const char *type)
-        {
-            if (strcmp(type, "R_MIPS_HI16") == 0)
-                set_le16(location, get_le16(location) + MIPS_HI(value));
-            else if (strcmp(type, "R_MIPS_LO16") == 0)
-                set_le16(location, get_le16(location) + MIPS_LO(value));
-            else if (strcmp(type, "R_MIPS_PC16") == 0)
-            {
-                value -= rel->section->offset + rel->offset;
-                set_le16(location, get_le16(location) + MIPS_PC16(value));
-            }
-            else if (strcmp(type, "R_MIPS_26") == 0)
-                set_le32(location, get_le32(location) + MIPS_PC26(value));
-            else if (strcmp(type, "R_MIPS_32") == 0)
-                set_le32(location, get_le32(location) + value);
-            else
-                super::relocate1(rel, location, value, type);
-        }
-    };
     return new ElfLinkerMipsLE;
 }
 
@@ -177,11 +155,11 @@ bool PackPs1::readBkupHeader()
 
 void PackPs1::putBkupHeader(const unsigned char *src, unsigned char *dst, unsigned *len)
 {
-    unsigned sz_cbh;
+    unsigned sz_cbh = MemBuffer::getSizeForCompression(SZ_IH_BKUP);
 
     if (src && dst)
     {
-        unsigned char *cpr_bh = new unsigned char[MemBuffer::getSizeForCompression(SZ_IH_BKUP)];
+        unsigned char *cpr_bh = new unsigned char[sz_cbh];
 
         memset(cpr_bh, 0, sizeof(bh));
         ps1_exe_chb_t * p = (ps1_exe_chb_t * )cpr_bh;
@@ -300,7 +278,7 @@ bool PackPs1::canPack()
 //
 **************************************************************************/
 
-int PackPs1::buildLoader(const Filter *)
+void PackPs1::buildLoader(const Filter *)
 {
     const char *method = NULL;
 
@@ -343,7 +321,7 @@ int PackPs1::buildLoader(const Filter *)
 
     if (ph.method == M_LZMA && !buildPart2)
     {
-        initLoader(nrv_loader, sizeof(nrv_loader));
+        initLoader(stub_mipsel_r3000_ps1, sizeof(stub_mipsel_r3000_ps1));
         addLoader("decompressor.start",
                   isCon ? "LZMA_DEC20" : "LZMA_DEC10", "lzma.init", NULL);
         addLoader(sa_tmp > (0x10000 << 2) ? "memset.long" : "memset.short",
@@ -359,16 +337,18 @@ int PackPs1::buildLoader(const Filter *)
                                  NULL, M_NRV2B_8, 10, NULL, NULL );
             if (r != UPX_E_OK || sz_lcpr >= sz_lunc)
                 throwInternalError("loader compression failed");
-            initLoader(nrv_loader, sizeof(nrv_loader),
+            initLoader(stub_mipsel_r3000_ps1, sizeof(stub_mipsel_r3000_ps1),
                       (ph.method != M_LZMA || isCon) ? 0 : 1);
             linker->addSection("lzma.exec", cprLoader, sz_lcpr, 0);
             delete [] cprLoader;
         }
         else
-            initLoader(nrv_loader, sizeof(nrv_loader));
+            initLoader(stub_mipsel_r3000_ps1, sizeof(stub_mipsel_r3000_ps1));
 
         pad_code = ALIGN_GAP((ph.c_len + (isCon ? sz_lcpr : 0)), 4);
-        linker->addSection("pad.code", &pad_code, pad_code, 0);
+        assert(pad_code < 4);
+        static const unsigned char pad_buffer[4] = { 0, 0, 0, 0 };
+        linker->addSection("pad.code", pad_buffer, pad_code, 0);
 
         if (isCon)
         {
@@ -402,8 +382,6 @@ int PackPs1::buildLoader(const Filter *)
         }
         addLoader("UPX1HEAD", "IDENTSTR", NULL);
     }
-    freezeLoader();
-    return getLoaderSize();
 }
 
 #define OPTYPE(x)     (((x) >> 13) & 0x7)
@@ -538,7 +516,7 @@ void PackPs1::pack(OutputFile *fo)
         linker->defineSymbol("entry", ih.epc);
         linker->defineSymbol("SC",
                              sa_cnt > (0x10000 << 2) ? sa_cnt >> 5 : sa_cnt >> 2);
-        linker->relocate();
+        relocateLoader();
 
         buildPart2 = true;
         buildLoader(&ft);
@@ -558,8 +536,6 @@ void PackPs1::pack(OutputFile *fo)
         oh.bs_ptr = oh.bs_len = 0;
 
     const int lsize = getLoaderSize();
-    MemBuffer loader(lsize);
-    memcpy(loader, getLoader(), lsize);
 
     unsigned filelen = ALIGN_UP(ih.tx_len, 4);
 
@@ -638,7 +614,10 @@ void PackPs1::pack(OutputFile *fo)
                                              - getLoaderSectionStart("cdb.entry.lzma"));
     }
 
-    linker->relocate();
+    relocateLoader();
+    //linker->dumpSymbols();
+    MemBuffer loader(lsize);
+    assert(lsize == getLoaderSize());
     memcpy(loader, getLoader(), lsize);
     patchPackHeader(loader, lsize);
 

src/p_ps1.h

@@ -59,7 +59,7 @@ protected:
     virtual void putBkupHeader(const unsigned char *src, unsigned char *dst, unsigned *len);
     virtual bool getBkupHeader(unsigned char *src, unsigned char * dst);
     virtual bool readBkupHeader();
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual bool findBssSection();
     virtual Linker* newLinker() const;
 

src/p_sys.cpp

@@ -70,7 +70,7 @@ void PackSys::patchLoader(OutputFile *fo,
 {
     const int e_len = getLoaderSectionStart("SYSCUTPO");
     const int d_len = lsize - e_len;
-    assert(e_len > 0 && e_len < 256);
+    assert(e_len > 0 && e_len < 128);
     assert(d_len > 0 && d_len < 256);
 
     if (ph.u_len + d_len + ph.overlap_overhead > 0xfffe)
@@ -85,10 +85,11 @@ void PackSys::patchLoader(OutputFile *fo,
     linker->defineSymbol("calltrick_calls", calls);
     linker->defineSymbol("copy_source", ph.c_len + lsize - 1);
     linker->defineSymbol("copy_destination", copy_to);
+    linker->defineSymbol("neg_e_len", 0 - e_len);
     linker->defineSymbol("NRV2B160", ph.u_len + ph.overlap_overhead + 1);
     linker->defineSymbol("original_strategy", get_le16(ibuf + 6));
 
-    linker->relocate();
+    relocateLoader();
     loader = getLoader();
 
     patchPackHeader(loader,e_len);
@@ -99,9 +100,9 @@ void PackSys::patchLoader(OutputFile *fo,
 }
 
 
-int PackSys::buildLoader(const Filter *ft)
+void PackSys::buildLoader(const Filter *ft)
 {
-    initLoader(nrv2b_loader,sizeof(nrv2b_loader));
+    initLoader(stub_i086_dos16_sys, sizeof(stub_i086_dos16_sys));
     addLoader("SYSMAIN1",
               opt->cpu == opt->CPU_8086 ? "SYSI0861" : "SYSI2861",
               "SYSMAIN2",
@@ -122,8 +123,6 @@ int PackSys::buildLoader(const Filter *ft)
               "SYSJUMP1",
               NULL
              );
-    freezeLoader();
-    return getLoaderSize();
 }
 
 

src/p_sys.h

@@ -49,7 +49,7 @@ protected:
     virtual unsigned getCallTrickOffset() const { return 0; }
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual void patchLoader(OutputFile *fo, upx_byte *, int, unsigned);
 };
 

src/p_tmt.cpp

@@ -45,6 +45,7 @@ static const
 
 PackTmt::PackTmt(InputFile *f) : super(f)
 {
+    bele = &N_BELE_RTP::le_policy;
     COMPILE_TIME_ASSERT(sizeof(tmt_header_t) == 44);
 }
 
@@ -81,10 +82,10 @@ Linker* PackTmt::newLinker() const
 }
 
 
-int PackTmt::buildLoader(const Filter *ft)
+void PackTmt::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader,sizeof(nrv_loader));
+    initLoader(stub_i386_dos32_tmt, sizeof(stub_i386_dos32_tmt));
     addLoader("IDENTSTR,TMTMAIN1",
               ft->id ? "TMTCALT1" : "",
               "TMTMAIN2,UPX1HEAD,TMTCUTPO",
@@ -105,8 +106,6 @@ int PackTmt::buildLoader(const Filter *ft)
               "RELOC32J,TMTJUMP1",
               NULL
              );
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -270,7 +269,7 @@ void PackTmt::pack(OutputFile *fo)
     //                e_len,d_len,copy_len,copy_to,ph.overlap_overhead,jmp_pos,ph.u_len,ph.c_len);
 
     linker->defineSymbol("TMTCUTPO", ph.u_len + ph.overlap_overhead);
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader,getLoader(),lsize);

src/p_tmt.h

@@ -57,7 +57,7 @@ protected:
     virtual unsigned findOverlapOverhead(const upx_bytep buf,
                                          unsigned range = 0,
                                          unsigned upper_limit = ~0u) const;
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
     unsigned adam_offset;

src/p_tos.cpp

@@ -37,7 +37,7 @@
 static const
 #include "stub/m68k-atari.tos.h"
 
-// #define TESTING
+//#define TESTING 1
 
 
 /*************************************************************************
@@ -49,6 +49,7 @@ static const
 PackTos::PackTos(InputFile *f) :
     super(f)
 {
+    bele = &N_BELE_RTP::be_policy;
     COMPILE_TIME_ASSERT(FH_SIZE == 28);
 }
 
@@ -72,42 +73,171 @@ Linker* PackTos::newLinker() const
 }
 
 
-int PackTos::buildLoader(const Filter *ft)
+void PackTos::LinkerSymbols::LoopInfo::init(unsigned count_, bool allow_dbra)
+{
+    count = value = count_;
+    if (count == 0)
+        mode = LOOP_NONE;
+    else if (count <= 65536 && allow_dbra)
+    {
+        mode = LOOP_DBRA;
+        value -= 1;
+        value &= 0xffff;
+    }
+    else if (count <= 65536)
+    {
+        mode = LOOP_SUBQ_W;
+        value &= 0xffff;
+    }
+    else
+        mode = LOOP_SUBQ_L;
+}
+
+
+unsigned PackTos::getDecomprOffset(int method, int small) const
+{
+    UNUSED(small);
+    if (M_IS_NRV2B(method))
+        return 2;   // FIXME: do not hardcode this value
+    else if (M_IS_NRV2D(method))
+        return 2;   // FIXME: do not hardcode this value
+    else if (M_IS_NRV2E(method))
+        return 2;   // FIXME: do not hardcode this value
+    else if (M_IS_LZMA(method))
+        return linker->getSectionSize("__mulsi3");
+    else
+        throwBadLoader();
+    return 0;
+}
+
+
+void PackTos::buildLoader(const Filter *ft)
 {
     assert(ft->id == 0);
 
-    const unsigned char *p = NULL;
+    initLoader(stub_m68k_atari_tos, sizeof(stub_m68k_atari_tos));
-    size_t l = 0;
+    //linker->dumpSymbols();
+
+    //
+    // part 1a
+    //
+
+    addLoader("entry");
+
+    if (symbols.up21_a6 <= 32767)
+        addLoader("set_up21_a6.w");
+    else if (symbols.up21_d4 <= 32767)
+        addLoader("set_up21_d4.w");
+    else
+        addLoader("set_up21_d4.l");
+
+    assert(symbols.loop1.count || symbols.loop2.count);
+    if (symbols.loop1.count)
+    {
+        if (symbols.loop1.value <= 127)
+            addLoader("loop1_set_count.b");
+        else if (symbols.loop1.value <= 65535)
+            addLoader("loop1_set_count.w");
+        else
+            addLoader("loop1_set_count.l");
+        addLoader("loop1_label");
+        addLoader(opt->small ? "loop1.small" : "loop1.fast");
+        if (symbols.loop1.mode == symbols.LOOP_SUBQ_L)
+            addLoader("loop1_subql");
+        else if (symbols.loop1.mode == symbols.LOOP_SUBQ_W)
+            addLoader("loop1_subqw");
+        else if (symbols.loop1.mode == symbols.LOOP_DBRA)
+            addLoader("loop1_dbra");
+        else
+            throwBadLoader();
+    }
+    if (symbols.loop2.count)
+    {
+        assert(symbols.loop2.mode == symbols.LOOP_DBRA);
+        addLoader(opt->small ? "loop2.small" : "loop2.fast");
+    }
+
+    addLoader("copy_to_stack");
+
+    if (M_IS_NRV2B(ph.method))
+        addLoader("nrv2b.init");
+    else if (M_IS_NRV2D(ph.method))
+        addLoader("nrv2d.init");
+    else if (M_IS_NRV2E(ph.method))
+        addLoader("nrv2e.init");
+    else if (M_IS_LZMA(ph.method))
+        addLoader("lzma.init");
+    else
+        throwBadLoader();
+
+    symbols.up31_d4 = symbols.up31_base_d4 + getDecomprOffset(ph.method, opt->small);
+    symbols.up31_a6 = symbols.up31_base_a6 + getDecomprOffset(ph.method, opt->small);
+    if (symbols.up31_a6 <= 32767)
+        addLoader("jmp_decompressor_a6.w");
+    else if (symbols.up31_d4 <= 32767)
+        addLoader("jmp_decompressor_d4.w");
+    else if (symbols.up31_a6 <= 65534)
+        addLoader("jmp_decompressor_a6.w2");
+    else
+        addLoader("jmp_decompressor_d4.l");
+
+    //
+    // part 1b
+    //
+
+    addLoader("code_on_stack");
+
+    addLoader("clear_dirty_bss");
+    addLoader("loop3_label");
+    addLoader(opt->small ? "loop3.small" : "loop3.fast");
+    if (symbols.loop3.mode == symbols.LOOP_SUBQ_L)
+        addLoader("loop3_subql");
+    else if (symbols.loop3.mode == symbols.LOOP_SUBQ_W)
+        addLoader("loop3_subqw");
+    else if (symbols.loop3.mode == symbols.LOOP_DBRA)
+        addLoader("loop3_dbra");
+    else
+        throwBadLoader();
+
+    addLoader("flush_cache");
+    addLoader("restore_stack");
+#if 0
+    addLoader("clear_dirty_stack");
+#endif
+    addLoader("start_program");
+
+    addLoader("IDENTSTR,+40D,UPX1HEAD,CUTPOINT");
+
+    //
+    // part 2
+    //
 
-    p = nrv_loader;
     if (M_IS_NRV2B(ph.method)) {
-//        p = opt->small ? nrv2b_loader_small : nrv2b_loader;
+        addLoader(opt->small ? "nrv2b_8.small" : "nrv2b_8.fast");
-//        l = opt->small ? sizeof(nrv2b_loader_small) : sizeof(nrv2b_loader);
+    } else if (M_IS_NRV2D(ph.method)) {
+        addLoader(opt->small ? "nrv2d_8.small" : "nrv2d_8.fast");
+    } else if (M_IS_NRV2E(ph.method)) {
+        addLoader(opt->small ? "nrv2e_8.small" : "nrv2e_8.fast");
+    } else if (M_IS_LZMA(ph.method)) {
+        addLoader("__mulsi3");
+        addLoader(opt->small ? "lzma.small" : "lzma.fast");
+        addLoader("lzma.finish");
     }
-    if (M_IS_NRV2D(ph.method)) {
+    else
-//        p = opt->small ? nrv2d_loader_small : nrv2d_loader;
+        throwBadLoader();
-//        l = opt->small ? sizeof(nrv2d_loader_small) : sizeof(nrv2d_loader);
-    }
-    if (M_IS_NRV2E(ph.method)) {
-//        p = opt->small ? nrv2e_loader_small : nrv2e_loader;
-//        l = opt->small ? sizeof(nrv2e_loader_small) : sizeof(nrv2e_loader);
-    }
-    initLoader(p, l);
 
-    addLoader("tos0",
+    if (symbols.need_reloc)
-              true ? "subql_1d0" : "subqw_1d0",
+        addLoader("reloc");
-              "s_bneloop0",
-              true ? "subql_1d6" : "subqw_1d6",
-              "s_bneloop3",
-              "IDENTSTR,+40,UPX1HEAD",
-              "CUTPOINT",
-              true ? "reloc" : "",
-              "jmpastack",
-              NULL
-             );
 
-    freezeLoader();
+    assert(symbols.loop3.count);
-    return getLoaderSize();
+    if (symbols.loop3.value <= 127)
+        addLoader("loop3_set_count.b");
+    else if (symbols.loop3.value <= 65535)
+        addLoader("loop3_set_count.w");
+    else
+        addLoader("loop3_set_count.l");
+
+    addLoader("jmp_stack");
 }
 
 
@@ -196,123 +326,6 @@ bool PackTos::checkFileHeader()
 }
 
 
-/*************************************************************************
-// some 68000 opcodes for patching
-**************************************************************************/
-
-#if 0
-enum m68k_reg_t {
-    REG_D0, REG_D1, REG_D2, REG_D3, REG_D4, REG_D5, REG_D6, REG_D7,
-    REG_A0, REG_A1, REG_A2, REG_A3, REG_A4, REG_A5, REG_A6, REG_A7
-};
-
-static unsigned OP_DBRA(int d_reg)
-{
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    return 0x51c8 | (d_reg & 7);
-}
-
-static unsigned OP_JMP(int a_reg)
-{
-    // jmp (a0)
-    assert(a_reg >= REG_A0 && a_reg <= REG_A7);
-    return 0x4ed0 | (a_reg & 7);
-}
-
-static unsigned OP_MOVEI_L(int d_reg)
-{
-    // movei.l #XXXXXXXX,d0
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    return 0x203c | ((d_reg & 7) << 9);
-}
-
-static unsigned OP_MOVEQ(int value, int d_reg)
-{
-    // moveq.l #0,d0
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    assert(value >= -128 && value <= 127);
-    return 0x7000 | ((d_reg & 7) << 9) | (value & 0xff);
-}
-
-static unsigned OP_SUBQ_L(int value, int d_reg)
-{
-    // subq.l #X,d0
-    assert(value >= 1 && value <= 8);
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    return 0x5180 | ((value & 7) << 9) | (d_reg & 7);
-}
-
-static unsigned OP_SUBQ_W(int value, int d_reg)
-{
-    // subq.w #X,d0
-    assert(value >= 1 && value <= 8);
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    return 0x5140 | ((value & 7) << 9) | (d_reg & 7);
-}
-
-/*************************************************************************
-//
-**************************************************************************/
-
-unsigned PackTos::patch_d_subq(void *b, int blen,
-                               int d_reg, unsigned d_value,
-                               const char *subq_marker)
-{
-    // patch a "subq.l #1,d0" or "subq.w #1,d0".
-    // also convert into "dbra" if possible
-    assert(d_reg >= REG_D0 && d_reg <= REG_D7);
-    assert((int)d_value > 0);
-
-    int boff =  find_be16(b, blen, get_be16(subq_marker));
-    if (boff < 0)
-        throwBadLoader();
-
-    upx_byte *p = (upx_byte *)b + boff;
-    if (p[2] == 0x66)                           // bne.b XXX
-        checkPatch(b, blen, boff, 4);
-    else
-        checkPatch(b, blen, boff, 2);
-
-    if (d_value > 65536)
-    {
-        set_be16(p, OP_SUBQ_L(1, d_reg));       // subq.l #1,d0
-    }
-    else
-    {
-        if (p[2] == 0x66)                       // bne.b XXX
-        {
-            set_be16(p, OP_DBRA(d_reg));        // dbra d0,XXX
-            // adjust and extend branch from 8 to 16 bits
-            int branch = (signed char) p[3];
-            set_be16(p+2, branch+2);
-            // adjust d0
-            d_value -= 1;
-        }
-        else
-        {
-            set_be16(p, OP_SUBQ_W(1, d_reg));   // subq.w #1,d0
-        }
-        d_value &= 0xffff;
-    }
-    return d_value;
-}
-
-
-unsigned PackTos::patch_d_loop(void *b, int blen,
-                               int d_reg, unsigned d_value,
-                               const char *d_marker, const char *subq_marker)
-{
-    d_value = patch_d_subq(b, blen, d_reg, d_value, subq_marker);
-
-    int boff = find_be32(b, blen, get_be32(d_marker));
-    checkPatch(b, blen, boff, 4);
-    upx_byte *p = (upx_byte *)b + boff;
-    assert(get_be16(p - 2) == OP_MOVEI_L(d_reg));    // move.l #XXXXXXXX,d0
-    set_be32(p, d_value);
-    return d_value;
-}
-#endif
-
 /*************************************************************************
 // relocs
 **************************************************************************/
@@ -366,18 +379,6 @@ static int check_relocs(const upx_byte *relocs, unsigned rsize, unsigned isize,
 
 bool PackTos::canPack()
 {
-#if 0 // debug
-# define p(x)    printf("%-30s 0x%04x\n", #x, x)
-    p(OP_DBRA(REG_D0));
-    p(OP_MOVEI_L(REG_D0));
-    p(OP_MOVEQ(-1, REG_D0));
-    p(OP_MOVEQ(1, REG_D2));
-    p(OP_MOVEQ(1, REG_D3));
-    p(OP_SUBQ_W(1, REG_D0));
-    p(OP_SUBQ_L(1, REG_D0));
-# undef p
-#endif
-
     if (!readFileHeader())
         return false;
 
@@ -409,7 +410,6 @@ void PackTos::fileInfo()
 
 void PackTos::pack(OutputFile *fo)
 {
-    throwInternalError("atari/tos is currenty broken; this will get fixed in UPX 2.91");
     unsigned t;
     unsigned nrelocs = 0;
     unsigned relocsize = 0;
@@ -421,6 +421,15 @@ void PackTos::pack(OutputFile *fo)
     const unsigned i_bss = ih.fh_bss;
 
     symbols.reset();
+    symbols.need_reloc = false;
+    // prepare symbols for buildLoader() - worst case
+    symbols.loop1.init(65536 + 1);
+    symbols.loop2.init((160 - 1) / 4);
+    symbols.loop3.init(65536 + 1);
+    symbols.up21_d4 = 65536 + 1;
+    symbols.up21_a6 = 65536 + 1;
+    symbols.up31_base_d4 = 65536 + 1;
+    symbols.up31_base_a6 = 65536 + 1;
 
     // read file
     const unsigned isize = file_size - i_sym;
@@ -430,6 +439,8 @@ void PackTos::pack(OutputFile *fo)
     t = i_text + i_data;
     fi->readx(ibuf,t);
     // skip symbols
+    if (i_sym && opt->exact)
+        throwCantPackExact();
     fi->seek(i_sym,SEEK_CUR);
     // read relocations + overlay
     overlay = file_size - (FH_SIZE + i_text + i_data + i_sym);
@@ -443,7 +454,6 @@ void PackTos::pack(OutputFile *fo)
 
     // Check relocs (see load_and_reloc() in freemint/sys/memory.c).
     // Must work around TOS bugs and lots of broken programs.
-    int r = 0;
     if (overlay < 4)
     {
         // Bug workaround: Whatever this is, silently keep it in
@@ -459,15 +469,17 @@ void PackTos::pack(OutputFile *fo)
     }
     else if (ih.fh_reloc != 0)
         relocsize = 0;
-    else
+    else {
-        r = check_relocs(ibuf+t, overlay, t, &nrelocs, &relocsize, &overlay);
+        int r = check_relocs(ibuf+t, overlay, t, &nrelocs, &relocsize, &overlay);
+        if (r != 0)
+            throwCantPack("bad relocation table");
+        symbols.need_reloc = true;
+    }
 
 #if 0 || defined(TESTING)
     printf("xx2: %d relocs: %d, overlay: %d, t: %d\n", nrelocs, relocsize, overlay, t);
 #endif
 
-    if (r != 0)
-        throwCantPack("bad relocation table");
     checkOverlay(overlay);
 
     // Append original fileheader.
@@ -485,8 +497,8 @@ void PackTos::pack(OutputFile *fo)
     // After compression this will become the first part of the
     // data segement. The second part will be the decompressor.
 
-    // alloc buffer (2048 is for decompressor and the various alignments)
+    // alloc buffer (4096 is for decompressor and the various alignments)
-    obuf.allocForCompression(t, 2048);
+    obuf.allocForCompression(t, 4096);
 
     // prepare packheader
     ph.u_len = t;
@@ -495,21 +507,33 @@ void PackTos::pack(OutputFile *fo)
     // compress (max_match = 65535)
     upx_compress_config_t cconf; cconf.reset();
     cconf.conf_ucl.max_match = 65535;
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28KB stack
     compressWithFilters(&ft, 512, 0, NULL, &cconf);
 
-    // get loader
+    //
-    const unsigned lsize = getLoaderSize();
+    // multipass buildLoader()
-    const unsigned e_len = getLoaderSectionStart("CUTPOINT");
+    //
-    const unsigned d_len = lsize - e_len;
-    const unsigned decomp_offset = linker->getSymbolOffset("decompr_start") - e_len;
-    assert(decomp_offset != 0xdeaddead);
-    assert((e_len & 3) == 0 && (d_len & 1) == 0);
 
+    // save initial loader
+    const unsigned initial_lsize = getLoaderSize();
+    unsigned last_lsize = initial_lsize;
+    MemBuffer last_loader(last_lsize);
+    memcpy(last_loader, getLoader(), last_lsize);
+
+    unsigned o_text, o_data, o_bss;
+    unsigned e_len, d_len, d_off;
+    for (;;)
+    {
         // The decompressed data will now get placed at this offset:
         unsigned offset = (ph.u_len + ph.overlap_overhead) - ph.c_len;
 
-    // compute addresses
+        // get loader
-    unsigned o_text, o_data, o_bss;
+        const unsigned lsize = getLoaderSize();
+        e_len = getLoaderSectionStart("CUTPOINT");
+        d_len = lsize - e_len;
+        assert((e_len & 3) == 0 && (d_len & 1) == 0);
+
+        // compute section sizes
         o_text = e_len;
         o_data = ph.c_len;
         o_bss = i_bss;
@@ -522,7 +546,8 @@ void PackTos::pack(OutputFile *fo)
         }
 
         // append decompressor (part 2 of loader)
-    const unsigned d_off = o_data;
+        d_off = o_data;
+        ////memcpy(obuf + d_off, getLoader() + e_len, d_len); // must be done after relocation
         o_data += d_len;
 
         // dword align the len of the final data segment
@@ -547,50 +572,98 @@ void PackTos::pack(OutputFile *fo)
         while (dirty_bss & (dirty_bss_align - 1))
             dirty_bss++;
         // adjust bss, assert room for some stack
-    if (dirty_bss + 512 > o_bss)
+        unsigned stack = 512 + getDecompressorWrkmemSize();
-        o_bss = dirty_bss + 512;
+        if (dirty_bss + stack > o_bss)
+            o_bss = dirty_bss + stack;
 
         // dword align the len of the final bss segment
         while (o_bss & 3)
             o_bss++;
 
-    //   patch "subq.l #1,d6" or "subq.w #1,d6" - see "up41" below
+        // update symbols for buildLoader()
-    const unsigned dirty_bss_d6 = dirty_bss / dirty_bss_align;
-        // FIXME patch_d_subq(loader, o_text, REG_D6, dirty_bss / dirty_bss_align, "u4");
-    linker->defineSymbol("up31", d_off + offset + decomp_offset);
         if (opt->small)
-        ; // patch_d_loop(loader, o_text, REG_D0, o_data/4, "up22", "u1");
+        {
+            symbols.loop1.init(o_data / 4);
+            symbols.loop2.init(0);
+        }
         else
         {
-        if (o_data <= 160)
+            symbols.loop1.init(o_data / 160);
-            throwNotCompressible();
+            symbols.loop2.init((o_data % 160) / 4);
-        unsigned loop1 = o_data / 160;
-        unsigned loop2 = o_data % 160;
-        if (loop2 == 0)
-        {
-            loop1--;
-            loop2 = 160;
         }
-        linker->defineSymbol("copy_remain", loop2 / 4 - 1);
+        symbols.loop3.init(dirty_bss / dirty_bss_align);
-        //patch_be16(loader, o_text, "u2", OP_MOVEQ(loop2/4-1, REG_D0)); // moveq.l #X,d0
+
-        //patch_d_loop(loader, o_text, REG_D0, loop1, "up22", "u1");
+        symbols.up21_d4 = o_data + offset;
+        symbols.up31_base_d4 = d_off + offset;
+        symbols.up21_a6 = symbols.up21_d4 - (i_text + i_data);
+        symbols.up31_base_a6 = symbols.up31_base_d4 - (i_text + i_data);
+        assert((int)symbols.up21_a6 > 0);
+        assert((int)symbols.up31_base_a6 > 0);
+
+        const unsigned c = linker->getSymbolOffset("code_on_stack");
+        unsigned d;
+        d = linker->getSymbolOffset("flush_cache_rts") - c;
+        symbols.flush_cache_rts_offset = d;
+        d = linker->getSymbolOffset("clear_dirty_stack_loop") - c;
+        symbols.clear_dirty_stack_len = (d + 3) / 4 + 32 - 1;
+        d = linker->getSymbolOffset("code_on_stack_end") - c;
+        symbols.copy_to_stack_len = d / 2 - 1;
+
+        // now re-build loader
+        buildLoader(&ft);
+        unsigned new_lsize = getLoaderSize();
+        //printf("buildLoader %d %d\n", new_lsize, initial_lsize);
+        assert(new_lsize <= initial_lsize);
+        if (new_lsize == last_lsize && memcmp(getLoader(), last_loader, last_lsize) == 0)
+            break;
+        last_lsize = new_lsize;
+        memcpy(last_loader, getLoader(), last_lsize);
     }
-    linker->defineSymbol("up22", opt->small ? o_data / 4 : (o_data - 1) / 160);
-    linker->defineSymbol("up21", o_data + offset);
-    linker->defineSymbol("up13", i_bss);                // p_blen
-    linker->defineSymbol("up12", i_data);               // p_dlen
-    linker->defineSymbol("up11", i_text);               // p_tlen
 
-    const unsigned clear_size = linker->getSymbolOffset("clear_bss_end") -
+    //
-                                linker->getSymbolOffset("clear_bss");
+    // define symbols and reloc
-    linker->defineSymbol("copy_to_stack_len", clear_size / 2 - 1);
+    //
-    linker->defineSymbol("clear_bss_size_p4", clear_size + 4);
 
-    // patch decompressor
+    defineDecompressorSymbols();
-    //upx_byte *p = obuf + d_off;
+
-    //   patch "moveq.l #1,d5" or "jmp (ASTACK)"
+    linker->defineSymbol("loop1_count", symbols.loop1.value);
-    //patch_be16(p, d_len, "u3", (nrelocs > 0) ? OP_MOVEQ(1, REG_D5) : OP_JMP(REG_A7));
+    linker->defineSymbol("loop2_count", symbols.loop2.value);
-    linker->defineSymbol("up41", dirty_bss_d6);
+    linker->defineSymbol("loop3_count", symbols.loop3.value);
+
+    linker->defineSymbol("orig_p_tlen", i_text);
+    linker->defineSymbol("orig_p_dlen", i_data);
+    linker->defineSymbol("orig_p_blen", i_bss);
+
+    if (symbols.up21_a6 <= 32767)
+        linker->defineSymbol("up21_a6", symbols.up21_a6);
+    else
+        linker->defineSymbol("up21_d4", symbols.up21_d4);
+
+    if (symbols.up31_a6 <= 32767)
+        linker->defineSymbol("up31_a6", symbols.up31_a6);
+    else if (symbols.up31_d4 <= 32767)
+        linker->defineSymbol("up31_d4", symbols.up31_d4);
+    else if (symbols.up31_a6 <= 65534)
+        linker->defineSymbol("up31_a6", symbols.up31_a6 - 32767);
+    else
+        linker->defineSymbol("up31_d4", symbols.up31_d4);
+#if 0
+    printf("relocsize = %d\n", relocsize);
+    printf("upx21(d4) = %d\n", symbols.up21_d4);
+    printf("upx21(a6) = %d\n", symbols.up21_a6);
+    printf("upx31(d4) = %d\n", symbols.up31_d4);
+    printf("upx31(a6) = %d\n", symbols.up31_a6);
+#endif
+
+    linker->defineSymbol("flush_cache_rts_offset", symbols.flush_cache_rts_offset);
+    linker->defineSymbol("copy_to_stack_len", symbols.copy_to_stack_len);
+    linker->defineSymbol("clear_dirty_stack_len", symbols.clear_dirty_stack_len);
+
+    relocateLoader();
+
+    //
+    // write
+    //
 
     // set new file_hdr
     memcpy(&oh, &ih, FH_SIZE);
@@ -616,16 +689,14 @@ void PackTos::pack(OutputFile *fo)
 #if 0 || defined(TESTING)
     printf("old text: %6d, data: %6d, bss: %6d, reloc: %d, overlay: %d\n",
            i_text, i_data, i_bss, relocsize, overlay);
-    printf("new text: %6d, data: %6d, bss: %6d, dirty_bss: %d, flag=0x%x\n",
+    printf("new text: %6d, data: %6d, bss: %6d, flag=0x%x\n",
-           o_text, o_data, o_bss, dirty_bss, (int)oh.fh_flag);
+           o_text, o_data, o_bss, (int)oh.fh_flag);
+    linker->dumpSymbols();
 #endif
 
-    linker->relocate();
     // prepare loader
     MemBuffer loader(o_text);
     memcpy(loader, getLoader(), o_text);
-    memcpy(obuf+d_off, getLoader() + e_len, d_len);
-
     patchPackHeader(loader, o_text);
 
     // write new file header, loader and compressed file
@@ -633,6 +704,7 @@ void PackTos::pack(OutputFile *fo)
     fo->write(loader, o_text);  // entry
     if (opt->debug.dump_stub_loader)
         OutputFile::dump(opt->debug.dump_stub_loader, loader, o_text);
+    memcpy(obuf + d_off, getLoader() + e_len, d_len); // copy decompressor
     fo->write(obuf, o_data);    // compressed + decompressor
 
     // write empty relocation fixup

src/p_tos.h

@@ -55,7 +55,8 @@ public:
 
 protected:
     virtual Linker* newLinker() const;
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
+    unsigned getDecomprOffset(int method, int small) const;
 
     virtual int readFileHeader();
     virtual bool checkFileHeader();
@@ -75,27 +76,34 @@ protected:
 
     tos_header_t ih, oh;
 
+    // symbols for buildLoader()
     struct LinkerSymbols
     {
-        enum { LOOP_UNKNOWN, LOOP_SUBQ_L, LOOP_SUBQ_W, LOOP_DBRA };
+        enum { LOOP_NONE, LOOP_SUBQ_L, LOOP_SUBQ_W, LOOP_DBRA };
-        // before linker->relocate()
+        struct LoopInfo {
-        unsigned loop1_count; int loop1_mode;
+            unsigned mode; unsigned count; unsigned value;
-        unsigned loop2_count; int loop2_mode;
+            void init(unsigned count, bool allow_dbra=true);
-        unsigned loop3_count; int loop3_mode;
+        };
-        // after linker->relocate()
+        // buildLoader() input
-        unsigned copy_to_stack_len;
+        bool need_reloc;
+        LoopInfo loop1;
+        LoopInfo loop2;
+        LoopInfo loop3;
+        unsigned up21_d4;
+        unsigned up21_a6;
+        unsigned up31_base_d4;
+        unsigned up31_base_a6;
+        // buildLoader() output
+        unsigned up31_d4;
+        unsigned up31_a6;
+        // currently not used by buildLoader()
         unsigned flush_cache_rts_offset;
-        unsigned clear_bss_size_p4;
         unsigned clear_dirty_stack_len;
-        // FIXME: up11 etc.
+        unsigned copy_to_stack_len;
 
         void reset() { memset(this, 0, sizeof(*this)); }
     };
     LinkerSymbols symbols;
-
-protected:
-    unsigned patch_d_subq(void *l, int llen, int, unsigned, const char*);
-    unsigned patch_d_loop(void *l, int llen, int, unsigned, const char*, const char*);
 };
 
 

src/p_unix.h

@@ -111,9 +111,9 @@ protected:
     }
     __attribute_packed;
     struct l_info { // 12-byte trailer in header for loader
-        unsigned l_checksum;
+        LE32 l_checksum;
-        unsigned l_magic;
+        LE32 l_magic;
-        unsigned short l_lsize;
+        LE16 l_lsize;
         unsigned char l_version;
         unsigned char l_format;
     }
@@ -141,7 +141,7 @@ class PackUnixBe32 : public PackUnix
 {
     typedef PackUnix super;
 protected:
-    PackUnixBe32(InputFile *f) : super(f) { }
+    PackUnixBe32(InputFile *f) : super(f) { bele = &N_BELE_RTP::be_policy; }
     virtual acc_uint64l_t get_native64(const void *b) const { return get_be64(b); }
     virtual unsigned get_native32(const void *b) const { return get_be32(b); }
     virtual unsigned get_native16(const void *b) const { return get_be16(b); }
@@ -182,7 +182,7 @@ class PackUnixLe32 : public PackUnix
 {
     typedef PackUnix super;
 protected:
-    PackUnixLe32(InputFile *f) : super(f) { }
+    PackUnixLe32(InputFile *f) : super(f) { bele = &N_BELE_RTP::le_policy; }
     virtual acc_uint64l_t get_native64(const void *b) const { return get_le64(b); }
     virtual unsigned get_native32(const void *b) const { return get_le32(b); }
     virtual unsigned get_native16(const void *b) const { return get_le16(b); }

src/p_vmlinx.cpp

@@ -46,12 +46,14 @@ static const
 **************************************************************************/
 
 PackVmlinuxI386::PackVmlinuxI386(InputFile *f) :
-    super(f), n_ptload(0), phdri(NULL), shdri(NULL)
+    super(f), n_ptload(0), phdri(NULL), shdri(NULL), shstrtab(NULL)
 {
+    bele = &N_BELE_RTP::le_policy;
 }
 
 PackVmlinuxI386::~PackVmlinuxI386()
 {
+    delete [] shstrtab;
     delete [] phdri;
     delete [] shdri;
 }
@@ -65,11 +67,50 @@ const int *PackVmlinuxI386::getCompressionMethods(int method, int level) const
 const int *PackVmlinuxI386::getFilters() const
 {
     static const int filters[] = {
-        0x49,
+        0x49, 0x46,
     -1 };
     return filters;
 }
 
+// copied from PackUnix 2006-10-13.
+int PackVmlinuxI386::getStrategy(Filter &/*ft*/)
+{
+    // Called just before reading and compressing each block.
+    // Might want to adjust blocksize, etc.
+
+    // If user specified the filter, then use it (-2==strategy).
+    // Else try the first two filters, and pick the better (2==strategy).
+    return (opt->no_filter ? -3 : ((opt->filter > 0) ? -2 : 2));
+}
+
+
+Elf_LE32_Shdr const *
+PackVmlinuxI386::getElfSections()
+{
+    Elf_LE32_Shdr const *p, *shstrsec=0;
+    shdri = new Elf_LE32_Shdr[(unsigned) ehdri.e_shnum];
+    fi->seek(ehdri.e_shoff, SEEK_SET);
+    fi->readx(shdri, ehdri.e_shnum * sizeof(*shdri));
+    int j;
+    for (p = shdri, j= ehdri.e_shnum; --j>=0; ++p) {
+        if (Elf32_Shdr::SHT_STRTAB==p->sh_type
+        &&  (p->sh_size + p->sh_offset) <= (unsigned) file_size
+        &&  (10+ p->sh_name) <= p->sh_size  // 1+ strlen(".shstrtab")
+        ) {
+            delete [] shstrtab;
+            shstrtab = new char[1+ p->sh_size];
+            fi->seek(p->sh_offset, SEEK_SET);
+            fi->readx(shstrtab, p->sh_size);
+            shstrtab[p->sh_size] = '\0';
+            if (0==strcmp(".shstrtab", shstrtab + p->sh_name)) {
+                shstrsec = p;
+                break;
+            }
+        }
+    }
+    return shstrsec;
+}
+
 static int __acc_cdecl_qsort
 compare_Phdr(void const *aa, void const *bb)
 {
@@ -102,6 +143,12 @@ compare_Phdr(void const *aa, void const *bb)
 //  LOAD           0x249000 0x02348000 0x02348000 0x81800 0xcb0fc RWE 0x1000
 //  STACK          0x000000 0x00000000 0x00000000 0x00000 0x00000 RWE 0x4
 //
+//----- kernel-2.6.18-1.2778 Fedora Core 6 test 3
+//Program Headers(3)
+//  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
+//  LOAD           0x001000 0xc0400000 0x00400000 0x279820 0x279820 R E 0x1000
+//  LOAD           0x27b000 0xc067a000 0x0067a000 0x10ee64 0x1b07e8 RWE 0x1000
+//  NOTE           0x000000 0x00000000 0x00000000 0x00000 0x00000 R   0x4
 
 bool PackVmlinuxI386::canPack()
 {
@@ -121,11 +168,28 @@ bool PackVmlinuxI386::canPack()
     ||  ehdri.e_phoff != sizeof(ehdri)  // Phdrs not contiguous with Ehdr
     ||  ehdri.e_phentsize!=sizeof(Elf32_Phdr)
     ||  ehdri.e_type!=Elf32_Ehdr::ET_EXEC
-    ||  0x00100000!=(0x001fffff & ehdri.e_entry) // entry not an odd 1MB
+    ||  0!=(0x000fffff & ehdri.e_entry) // entry not on whole 1MB
     ) {
         return false;
     }
 
+    // A Linux kernel must have a __ksymtab section. [??]
+    Elf_LE32_Shdr const *p, *const shstrsec = getElfSections();
+    if (0==shstrsec) {
+        return false;
+    }
+    {
+    int j;
+    for (p = shdri, j= ehdri.e_shnum; --j>=0; ++p) {
+        if (Elf32_Shdr::SHT_PROGBITS==p->sh_type
+        && 0==strcmp("__ksymtab", p->sh_name + shstrtab)) {
+            break;
+        }
+    }
+    if (j < 0)
+        return false;
+    }
+
     phdri = new Elf_LE32_Phdr[(unsigned) ehdri.e_phnum];
     fi->seek(ehdri.e_phoff, SEEK_SET);
     fi->readx(phdri, ehdri.e_phnum * sizeof(*phdri));
@@ -161,10 +225,10 @@ Linker* PackVmlinuxI386::newLinker() const
 }
 
 
-int PackVmlinuxI386::buildLoader(const Filter *ft)
+void PackVmlinuxI386::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader, sizeof(nrv_loader));
+    initLoader(stub_i386_linux_kernel_vmlinux, sizeof(stub_i386_linux_kernel_vmlinux));
     addLoader("LINUX000",
               (0x40==(0xf0 & ft->id)) ? "LXCKLLT1" : (ft->id ? "LXCALLT1" : ""),
               "LXMOVEUP",
@@ -183,15 +247,15 @@ int PackVmlinuxI386::buildLoader(const Filter *ft)
         addFilter32(ft->id);
     }
     addLoader("LINUX990,IDENTSTR,UPX1HEAD", NULL);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
 static bool defineFilterSymbols(Linker *linker, const Filter *ft)
 {
-    if (ft->id == 0)
+    if (ft->id == 0) {
+        linker->defineSymbol("filter_length", 0);
         return false;
+    }
     assert(ft->calls > 0);
 
     linker->defineSymbol("filter_cto", ft->cto);
@@ -201,6 +265,8 @@ static bool defineFilterSymbols(Linker *linker, const Filter *ft)
     return true;
 }
 
+static const
+#include "stub/i386-linux.kernel.vmlinux-head.h"
 
 void PackVmlinuxI386::pack(OutputFile *fo)
 {
@@ -213,8 +279,6 @@ void PackVmlinuxI386::pack(OutputFile *fo)
     // .shstrtab /* .symtab .strtab */
     Elf32_Shdr shdro[1+3+1/*+2*/];
     memset(shdro, 0, sizeof(shdro));
-    char const shstrtab[]= "\0.text\0.note\0.shstrtab\0.symtab\0.strtab";
-    char const *p = shstrtab;
 
     ibuf.alloc(file_size);
     obuf.allocForCompression(file_size);
@@ -245,7 +309,7 @@ void PackVmlinuxI386::pack(OutputFile *fo)
     upx_compress_config_t cconf; cconf.reset();
     // limit stack size needed for runtime decompression
     cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28KB stack
-    compressWithFilters(&ft, 512, 0, NULL, &cconf);
+    compressWithFilters(&ft, 512, getStrategy(ft), getFilters(), &cconf);
 
     const unsigned lsize = getLoaderSize();
 
@@ -254,23 +318,33 @@ void PackVmlinuxI386::pack(OutputFile *fo)
         linker->defineSymbol("filter_length", ph.u_len); // redefine
     }
     defineDecompressorSymbols();
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader, getLoader(), lsize);
     patchPackHeader(loader, lsize);
 
+#define shstrtab local_shstrtab // avoid -Wshadow warning
+    char const shstrtab[]= "\0.text\0.note\0.shstrtab\0.symtab\0.strtab";
+    char const *p = shstrtab;
     while (0!=*p++) ;
     shdro[1].sh_name = ptr_diff(p, shstrtab);
     shdro[1].sh_type = Elf32_Shdr::SHT_PROGBITS;
     shdro[1].sh_flags = Elf32_Shdr::SHF_ALLOC | Elf32_Shdr::SHF_EXECINSTR;
     shdro[1].sh_offset = fo_off;
-    shdro[1].sh_size = 1+ 4+ ph.c_len + lsize;
+    shdro[1].sh_size = sizeof(stub_i386_linux_kernel_vmlinux_head) + ph.c_len + lsize;
     shdro[1].sh_addralign = 1;
 
-    unsigned char const call = 0xE8;  // opcode for CALL d32
+    // ENTRY_POINT
-    fo->write(&call, 1); fo_off+=1;
+    fo->write(&stub_i386_linux_kernel_vmlinux_head[0], sizeof(stub_i386_linux_kernel_vmlinux_head)-2*(1+ 4) +1);
-    tmp_le32 = ph.c_len; fo->write(&tmp_le32, 4); fo_off += 4;
+    tmp_le32 = ehdri.e_entry; fo->write(&tmp_le32, 4);
+
+    // COMPRESSED_LENGTH
+    fo->write(&stub_i386_linux_kernel_vmlinux_head[sizeof(stub_i386_linux_kernel_vmlinux_head)-(1+ 4)], 1);
+    tmp_le32 = ph.c_len;      fo->write(&tmp_le32, 4);
+
+    fo_off += sizeof(stub_i386_linux_kernel_vmlinux_head);
+
     fo->write(obuf, ph.c_len); fo_off += ph.c_len;
     fo->write(loader, lsize); fo_off += lsize;
 
@@ -361,6 +435,7 @@ void PackVmlinuxI386::pack(OutputFile *fo)
 
     if (!checkFinalCompressionRatio(fo))
         throwNotCompressible();
+#undef shstrtab
 }
 
 
@@ -385,35 +460,18 @@ int PackVmlinuxI386::canUnpack()
         return false;
 
     // find the .shstrtab section
-    char shstrtab[40];
+    Elf_LE32_Shdr const *const shstrsec = getElfSections();
-    Elf_LE32_Shdr *p, *p_shstrtab=0;
+    if (0==shstrsec) {
-    shdri = new Elf_LE32_Shdr[(unsigned) ehdri.e_shnum];
-    fi->seek(ehdri.e_shoff, SEEK_SET);
-    fi->readx(shdri, ehdri.e_shnum * sizeof(*shdri));
-    int j;
-    for (p = shdri, j= ehdri.e_shnum; --j>=0; ++p) {
-        if (Elf32_Shdr::SHT_STRTAB==p->sh_type
-        &&  p->sh_size <= sizeof(shstrtab)
-        &&  (p->sh_size + p->sh_offset) <= (unsigned) file_size
-        &&  (10+ p->sh_name) <= p->sh_size  // 1+ strlen(".shstrtab")
-        ) {
-            fi->seek(p->sh_offset, SEEK_SET);
-            fi->readx(shstrtab, p->sh_size);
-            if (0==strcmp(".shstrtab", shstrtab + p->sh_name)) {
-                p_shstrtab = p;
-                break;
-            }
-        }
-    }
-    if (0==p_shstrtab) {
         return false;
     }
 
     // check for .text .note .note  and sane (.sh_size + .sh_offset)
     p_note0 = p_note1 = p_text = 0;
+    int j;
+    Elf_LE32_Shdr *p;
     for (p= shdri, j= ehdri.e_shnum; --j>=0; ++p) {
         if ((unsigned)file_size < (p->sh_size + p->sh_offset)
-        ||  p_shstrtab->sh_size < (5+ p->sh_name) ) {
+        ||  shstrsec->sh_size < (5+ p->sh_name) ) {
             continue;
         }
         if (0==strcmp(".text", shstrtab + p->sh_name)) {
@@ -460,7 +518,7 @@ void PackVmlinuxI386::unpack(OutputFile *fo)
     ibuf.dealloc();
 
     ph = ph_tmp;
-    fi->seek(p_text->sh_offset, SEEK_SET);
+    fi->seek(p_text->sh_offset + sizeof(stub_i386_linux_kernel_vmlinux_head) -5, SEEK_SET);
     fi->readx(&buf[0], 5);
     if (0xE8!=buf[0] ||  get_le32(&buf[1]) != ph.c_len)
     {
@@ -495,7 +553,7 @@ void PackVmlinuxI386::unpack(OutputFile *fo)
 }
 
 //
-// Example usage within build system of Linux kernel-2.6.7:
+// Example usage within build system of Linux kernel-2.6.18:
 //
 //----- arch/i386/boot/compressed/Makefile
 //#
@@ -507,7 +565,6 @@ void PackVmlinuxI386::unpack(OutputFile *fo)
 //targets := vmlinux upx-head.o upx-piggy.o
 //
 //LDFLAGS_vmlinux := -Ttext $(IMAGE_OFFSET) -e startup_32
-//EXTRA_AFLAGS += -DIMAGE_OFFSET=$(IMAGE_OFFSET)
 //
 //$(obj)/vmlinux: $(obj)/upx-head.o $(obj)/upx-piggy.o FORCE
 //	$(call if_changed,ld)
@@ -517,44 +574,42 @@ void PackVmlinuxI386::unpack(OutputFile *fo)
 //	rm -f $@
 //	upx --best -o $@ $<
 //	touch $@
+//
+//#
+//# The ORIGINAL build sequence using gzip is:
+//#                   vmlinux         Elf executable at top level in tree
+//#                                     (in same directory as MAINTAINERS)
+//#   In arch/i386:
+//#   boot/compressed/vmlinux.bin     by objcopy -O binary
+//#   boot/compressed/vmlinux.bin.gz  by gzip
+//#   boot/compressed/piggy.o         by ld --format binary --oformat elf32-i386
+//#
+//#                                   The 3 steps above create a linkable
+//#                                   compressed blob.
+//#   In arch/i386:
+//#   boot/compressed/vmlinux         by ld head.o misc.o piggy.o
+//#              boot/vmlinux.bin     by objcopy
+//#              boot/bzImage         by arch/i386/boot/tools/build with
+//#                                     bootsect and setup
+//#
+//#
+//# The MODIFIED build sequence using upx is:
+//#                   vmlinux         Elf executable at top level in tree
+//#                                     (in same directory as MAINTAINERS)
+//#   In arch/i386:
+//#   boot/compressed/upx-piggy.o     by upx format vmlinux/386
+//#
+//#   In arch/i386/boot:
+//#   boot/compressed/vmlinux         by ld upx-head.o upx-piggy.o
+//#              boot/vmlinux.bin     by objcopy
+//#              boot/bzImage         by arch/i386/boot/tools/build with
+//#                                     bootsect and setup
+//#
 //-----
 //
 //----- arch/i386/boot/compressed/upx-head.S
-//	.text
 //startup_32: .globl startup_32  # In: %esi=0x90000 setup data "real_mode pointer"
-//	#cli  # this must be true already
+//  /* All code is in stub/src/i386-linux.kernel.vmlinux-head.S */
-//
-//	/* The only facts about segments here, that are true for all kernels:
-//	 * %cs is a valid "flat" code segment; no other segment reg is valid;
-//	 * the next segment after %cs is a valid "flat" data segment, but
-//	 * no segment register designates it yet.
-//	 */
-//	movl %cs,%eax; addl $1<<3,%eax  # the next segment after %cs
-//	movl %eax,%ds
-//	movl %eax,%es
-//	leal 0x9000(%esi),%ecx  # 0x99000 typical
-//	movl %ecx,-8(%ecx)  # 32-bit offset for stack pointer
-//	movl %eax,-4(%ecx)  # segment for stack pointer
-//	lss -8(%ecx),%esp  # %ss:%esp= %ds:0x99000
-//	    /* Linux Documentation/i386/boot.txt "SAMPLE BOOT CONFIGURATION" says
-//		 0x8000-0x8FFF  Stack and heap  [inside the "real mode segment",
-//		 just below the command line at offset 0x9000].
-//
-//		 arch/i386/boot/compressed/head.S "Do the decompression ..." says
-//		 %esi contains the "real mode pointer" [as a 32-bit addr].
-//
-//		 In any case, avoid EBDA (Extended BIOS Data Area) below 0xA0000.
-//		 boot.txt says 0x9A000 is the limit.  LILO goes up to 0x9B000.
-//	    */
-//
-//	pushl $0; popf  # subsumes "cli; cld"; also clears NT for buggy BIOS
-//
-//#ifndef IMAGE_OFFSET  /*{*/
-//#define IMAGE_OFFSET 0x100000
-//#endif  /*}*/
-//	movl $ IMAGE_OFFSET,%eax  # destination of uncompression (and entry point)
-//	push %cs
-/* Fall into .text of upx-compressed vmlinux. */
 //-----
 
 // Approximate translation for Linux 2.4.x:

src/p_vmlinx.h

@@ -46,6 +46,7 @@ public:
     virtual const char *getName() const { return "vmlinux/386"; }
     virtual const int *getCompressionMethods(int method, int level) const;
     virtual const int *getFilters() const;
+    virtual int getStrategy(Filter &);
 
     virtual void pack(OutputFile *fo);
     virtual void unpack(OutputFile *fo);
@@ -54,7 +55,8 @@ public:
     virtual int canUnpack();
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual Elf_LE32_Shdr const *getElfSections();
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 //    virtual const upx_byte *getLoader() const;
 //    virtual int getLoaderSize() const;
@@ -63,6 +65,7 @@ protected:
     unsigned sz_ptload;
     Elf_LE32_Phdr *phdri; // from input file
     Elf_LE32_Shdr *shdri; // from input file
+    char *shstrtab; // from input file
     Elf_LE32_Shdr *p_text;
     Elf_LE32_Shdr *p_note0;
     Elf_LE32_Shdr *p_note1;

src/p_vmlinz.cpp

@@ -38,7 +38,6 @@
 static const
 #include "stub/i386-linux.kernel.vmlinuz.h"
 
-static const unsigned kernel_entry = 0x100000;
 static const unsigned stack_offset_during_uncompression = 0x9000;
 // add to "real mode pointer" in %esi; total 0x99000 is typical
 
@@ -52,8 +51,9 @@ static const unsigned bzimage_offset = 0x100000;
 **************************************************************************/
 
 PackVmlinuzI386::PackVmlinuzI386(InputFile *f) :
-    super(f)
+    super(f), physical_start(0x100000)
 {
+    bele = &N_BELE_RTP::le_policy;
     COMPILE_TIME_ASSERT(sizeof(boot_sect_t) == 0x218);
 }
 
@@ -133,6 +133,16 @@ int PackVmlinuzI386::decompressKernel()
     fi->seek(0, SEEK_SET);
     fi->readx(obuf, file_size);
 
+    // Find "ljmp $__BOOT_CS,$__PHYSICAL_START" if any.
+    // See startup_32: in linux/arch/i386/boot/compressed/head.S
+    char const *p = (char const *)&obuf[setup_size];
+    for (int j= 0; j < 0x200; ++j, ++p)
+    if (0==strncmp("\xEA\x00\x00", p, 3) && 0==(0xf & p[3]) && 0==p[4]) {
+        /* whole megabyte < 16MB */
+        physical_start = get_le32(1+ p);
+        break;
+    }
+
     checkAlreadyPacked(obuf + setup_size, UPX_MIN(file_size - setup_size, 1024));
 
     for (int gzoff = setup_size; gzoff < file_size; gzoff++)
@@ -209,6 +219,13 @@ int PackVmlinuzI386::decompressKernel()
         if (memcmp(ibuf, "\xFC\x0F\x01", 3) == 0) goto head_ok;
         // 2.6.x+grsecurity+strongswan+openwall+trustix: ljmp $0x10,...
         if (ibuf[0] == 0xEA && memcmp(ibuf+5, "\x10\x00", 2) == 0) goto head_ok;
+        // x86_64 2.6.x
+        if (0xB8==ibuf[0]  // mov $...,%eax
+        &&  0x8E==ibuf[5] && 0xD8==ibuf[6]  // mov %eax,%ds
+        &&  0x0F==ibuf[7] && 0x01==ibuf[8] && 020==(070 & ibuf[9]) // lgdtl
+        &&  0xB8==ibuf[14]  // mov $...,%eax
+        &&  0x0F==ibuf[19] && 0xA2==ibuf[20]  // cpuid
+        ) goto head_ok;
 
         throwCantPack("unrecognized kernel architecture; use option `-f' to force packing");
     head_ok:
@@ -253,10 +270,10 @@ Linker* PackVmlinuzI386::newLinker() const
 // vmlinuz specific
 **************************************************************************/
 
-int PackVmlinuzI386::buildLoader(const Filter *ft)
+void PackVmlinuzI386::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader, sizeof(nrv_loader));
+    initLoader(stub_i386_linux_kernel_vmlinuz, sizeof(stub_i386_linux_kernel_vmlinuz));
     addLoader("LINUZ000",
               ft->id ? "LZCALLT1" : "",
               "LZIMAGE0",
@@ -270,8 +287,6 @@ int PackVmlinuzI386::buildLoader(const Filter *ft)
         addFilter32(ft->id);
     }
     addLoader("LINUZ990,IDENTSTR,UPX1HEAD", NULL);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -295,7 +310,7 @@ void PackVmlinuzI386::pack(OutputFile *fo)
     // prepare filter
     Filter ft(ph.level);
     ft.buf_len = ph.u_len;
-    ft.addvalue = kernel_entry;  // saves 4 bytes in unfilter code
+    ft.addvalue = physical_start;  // saves 4 bytes in unfilter code
 
     // compress
     upx_compress_config_t cconf; cconf.reset();
@@ -308,9 +323,9 @@ void PackVmlinuzI386::pack(OutputFile *fo)
     defineFilterSymbols(linker, &ft);
     defineDecompressorSymbols();
     linker->defineSymbol("src_for_decompressor", zimage_offset + lsize);
-    linker->defineSymbol("original_entry", kernel_entry);
+    linker->defineSymbol("original_entry", physical_start);
     linker->defineSymbol("stack_offset", stack_offset_during_uncompression);
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader, getLoader(), lsize);
@@ -341,10 +356,10 @@ void PackVmlinuzI386::pack(OutputFile *fo)
 // bvmlinuz specific
 **************************************************************************/
 
-int PackBvmlinuzI386::buildLoader(const Filter *ft)
+void PackBvmlinuzI386::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader, sizeof(nrv_loader));
+    initLoader(stub_i386_linux_kernel_vmlinuz, sizeof(stub_i386_linux_kernel_vmlinuz));
     addLoader("LINUZ000",
               (0x40==(0xf0 & ft->id)) ? "LZCKLLT1" : (ft->id ? "LZCALLT1" : ""),
               "LBZIMAGE,IDENTSTR",
@@ -371,8 +386,6 @@ int PackBvmlinuzI386::buildLoader(const Filter *ft)
         addFilter32(ft->id);
     }
     addLoader("LINUZ990", NULL);
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -383,7 +396,7 @@ void PackBvmlinuzI386::pack(OutputFile *fo)
     // prepare filter
     Filter ft(ph.level);
     ft.buf_len = ph.u_len;
-    ft.addvalue = kernel_entry;  // saves 4 bytes in unfilter code
+    ft.addvalue = physical_start;  // saves 4 bytes in unfilter code
 
     upx_compress_config_t cconf; cconf.reset();
     // limit stack size needed for runtime decompression
@@ -399,10 +412,12 @@ void PackBvmlinuzI386::pack(OutputFile *fo)
 
     if (ph.method == M_LZMA) {
         const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
-        unsigned const properties = // lc, lp, pb, dummy
+        acc_uint32e_t properties = // lc, lp, pb, dummy
             (res->lit_context_bits << 0) |
             (res->lit_pos_bits << 8) |
             (res->pos_bits << 16);
+        if (linker->bele->isBE()) // big endian - bswap32
+            acc_swab32s(&properties);
         linker->defineSymbol("lzma_properties", properties);
         // -2 for properties
         linker->defineSymbol("lzma_c_len", ph.c_len - 2);
@@ -420,10 +435,10 @@ void PackBvmlinuzI386::pack(OutputFile *fo)
     const unsigned edi = decompr_pos + d_len4 - 4;          // copy to
     const unsigned esi = ALIGN_UP(c_len + lsize, 4) - 4;     // copy from
 
-    linker->defineSymbol("decompressor", decompr_pos);
+    linker->defineSymbol("decompressor", decompr_pos - bzimage_offset + physical_start);
-    linker->defineSymbol("src_for_decompressor", bzimage_offset + decompr_pos - c_len);
+    linker->defineSymbol("src_for_decompressor", physical_start + decompr_pos - c_len);
     linker->defineSymbol("words_to_copy", copy_size / 4);
-    linker->defineSymbol("copy_dest", bzimage_offset + edi);
+    linker->defineSymbol("copy_dest", physical_start + edi);
     linker->defineSymbol("copy_source", bzimage_offset + esi);
 
     defineFilterSymbols(linker, &ft);
@@ -431,9 +446,9 @@ void PackBvmlinuzI386::pack(OutputFile *fo)
         linker->defineSymbol("filter_length", ph.u_len); // redefine
     }
     defineDecompressorSymbols();
-    linker->defineSymbol("original_entry", kernel_entry);
+    linker->defineSymbol("original_entry", physical_start);
     linker->defineSymbol("stack_offset", stack_offset_during_uncompression);
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader, getLoader(), lsize);
@@ -493,7 +508,7 @@ void PackVmlinuzI386::unpack(OutputFile *fo)
 
     // unfilter
     Filter ft(ph.level);
-    ft.init(ph.filter, kernel_entry);
+    ft.init(ph.filter, physical_start);
     ft.cto = (unsigned char) ph.filter_cto;
     ft.unfilter(obuf, ph.u_len);
 

src/p_vmlinz.h

@@ -56,7 +56,7 @@ protected:
     virtual int decompressKernel();
     virtual void readKernel();
 
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
 //    virtual const upx_byte *getLoader() const;
@@ -86,6 +86,7 @@ protected:
 
     MemBuffer setup_buf;
     int setup_size;
+    unsigned physical_start;
 };
 
 
@@ -104,7 +105,7 @@ public:
     virtual void pack(OutputFile *fo);
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
 };
 
 
@@ -131,7 +132,7 @@ protected:
     virtual int decompressKernel();
     virtual void readKernel();
 
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
 };
 
 

src/p_vxd.h

@@ -39,7 +39,7 @@ class PackVxd : public PackWcle
     typedef PackWcle super;
 public:
     PackVxd(InputFile *f);
-    ~PackVxd();
+    virtual ~PackVxd();
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_VXD_LE; }
     virtual const char *getName() const { return "vxd/le"; }

src/p_w16ne.cpp

@@ -41,6 +41,7 @@
 PackW16Ne::PackW16Ne(InputFile *f) :
     super(f)
 {
+    bele = &N_BELE_RTP::le_policy;
 }
 
 
@@ -57,7 +58,7 @@ const int *PackW16Ne::getFilters() const
 }
 
 
-int PackW16Ne::buildLoader(const Filter *ft)
+void PackW16Ne::buildLoader(const Filter *ft)
 {
     // prepare loader
 //    initLoader(nrv_loader,sizeof(nrv_loader));
@@ -68,8 +69,6 @@ int PackW16Ne::buildLoader(const Filter *ft)
 //        addLoader("...");
     }
 //
-    freezeLoader();
-    return getLoaderSize();
 }
 
 

src/p_w16ne.h

@@ -54,7 +54,7 @@ public:
 protected:
     virtual int readFileHeader(void);
 
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 };
 

src/p_w32pe.cpp

@@ -120,6 +120,7 @@ PackW32Pe::PackW32Pe(InputFile *f) : super(f)
 {
     oloadconf = NULL;
     soloadconf = 0;
+    isrtm = false;
     use_dep_hack = true;
     use_clear_dirty_stack = true;
 }
@@ -535,7 +536,7 @@ bool PackW32Pe::canPack()
 }
 
 
-int PackW32Pe::buildLoader(const Filter *ft)
+void PackW32Pe::buildLoader(const Filter *ft)
 {
     // recompute tlsindex (see pack() below)
     unsigned tmp_tlsindex = tlsindex;
@@ -545,7 +546,7 @@ int PackW32Pe::buildLoader(const Filter *ft)
         tmp_tlsindex = 0;
 
     // prepare loader
-    initLoader(nrv_loader, sizeof(nrv_loader), 2);
+    initLoader(stub_i386_win32_pe, sizeof(stub_i386_win32_pe), 2);
     addLoader(isdll ? "PEISDLL1" : "",
               "PEMAIN01",
               icondir_count > 1 ? (icondir_count == 2 ? "PEICONS1" : "PEICONS2") : "",
@@ -598,8 +599,6 @@ int PackW32Pe::buildLoader(const Filter *ft)
               "IDENTSTR,UPX1HEAD",
               NULL
              );
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -866,13 +865,6 @@ void PackW32Pe::pack(OutputFile *fo)
 
         // rva of the most significant byte of member "flags" in section "UPX0"
         const unsigned swri = pe_offset + sizeof(oh) + sizeof(pe_section_t) - 1;
-#if 0
-        if (swri >= 0x1000)
-            throwCantPack("swri >= 0x1000! Send a bug report please!");
-        patch_le32(loader, codesize, "SWRI", swri);
-        patch_le32(loader, codesize, "IMGL", 0x1000);           // one page
-        patch_le32(loader, codesize, "IMGB", 0u - rvamin);
-#else
         // make sure we only touch the minimum number of pages
         const unsigned addr = 0u - rvamin + swri;
         linker->defineSymbol("swri", addr &  0xfff);    // page offset
@@ -881,7 +873,6 @@ void PackW32Pe::pack(OutputFile *fo)
         linker->defineSymbol("vp_size", ((addr & 0xfff) + 0x28 >= 0x1000) ?
                              0x2000 : 0x1000);          // 2 pages or 1 page
         linker->defineSymbol("vp_base", addr &~ 0xfff); // page mask
-#endif
         linker->defineSymbol("VirtualProtect", myimport + get_le32(oimpdlls + 16) + 8);
     }
     linker->defineSymbol("reloc_delt", 0u - (unsigned) ih.imagebase - rvamin);
@@ -892,10 +883,9 @@ void PackW32Pe::pack(OutputFile *fo)
     linker->defineSymbol("LoadLibraryA", myimport + get_le32(oimpdlls + 16));
     linker->defineSymbol("start_of_imports", myimport);
     linker->defineSymbol("compressed_imports", cimports);
-
 #if 0
-    patch_le32(loader, codesize, "VALL", myimport + get_le32(oimpdlls + 16) + 12);
+    linker->defineSymbol("VirtualAlloc", myimport + get_le32(oimpdlls + 16) + 12);
-    patch_le32(loader, codesize, "VFRE", myimport + get_le32(oimpdlls + 16) + 16);
+    linker->defineSymbol("VirtualFree", myimport + get_le32(oimpdlls + 16) + 16);
 #endif
 
     defineFilterSymbols(linker, &ft);
@@ -917,7 +907,7 @@ void PackW32Pe::pack(OutputFile *fo)
     linker->defineSymbol("start_of_compressed", esi0 + ih.imagebase);
 
     linker->defineSymbol(isdll ? "PEISDLL1" : "PEMAIN01", upxsection);
-    linker->relocate();
+    relocateLoader();
 
     const unsigned lsize = getLoaderSize();
     MemBuffer loader(lsize);

src/p_w32pe.h

@@ -39,7 +39,7 @@ class PackW32Pe : public PeFile
 
 public:
     PackW32Pe(InputFile *f);
-    ~PackW32Pe();
+    virtual ~PackW32Pe();
     virtual int getFormat() const { return UPX_F_WIN32_PE; }
     virtual const char *getName() const { return isrtm ? "rtm32/pe" : "win32/pe"; }
     virtual const int *getCompressionMethods(int method, int level) const;
@@ -53,11 +53,9 @@ public:
 protected:
     virtual int readFileHeader();
 
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
-    bool isrtm;
-
     virtual unsigned processImports();
     virtual void processImports(unsigned, unsigned);
     virtual void rebuildImports(upx_byte *&);
@@ -67,6 +65,7 @@ protected:
     upx_byte *oloadconf;
     unsigned soloadconf;
 
+    bool isrtm;
     bool use_dep_hack;
     bool use_clear_dirty_stack;
 };

src/p_wcle.cpp

@@ -88,10 +88,10 @@ Linker* PackWcle::newLinker() const
 }
 
 
-int PackWcle::buildLoader(const Filter *ft)
+void PackWcle::buildLoader(const Filter *ft)
 {
     // prepare loader
-    initLoader(nrv_loader,sizeof(nrv_loader));
+    initLoader(stub_i386_dos32_watcom_le, sizeof(stub_i386_dos32_watcom_le));
     addLoader("IDENTSTR,WCLEMAIN,UPX1HEAD,WCLECUTP", NULL);
 
     // fake alignment for the start of the decompressor
@@ -118,8 +118,6 @@ int PackWcle::buildLoader(const Filter *ft)
               "WCLEMAI4",
               NULL
              );
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -452,7 +450,9 @@ void PackWcle::encodeImage(const Filter *ft)
     buildLoader(ft);
 
     ibuf.dealloc();
-    soimage = (ph.c_len + 3) &~ 3;
+    soimage = ph.c_len;
+    while (soimage & 3)
+        oimage[RESERVED + soimage++] = 0;
 }
 
 
@@ -555,7 +555,7 @@ void PackWcle::pack(OutputFile *fo)
     linker->defineSymbol("copy_dest", ((ic + d_len + 3) &~ 3) - 4);
     linker->defineSymbol("copy_source", e_len + jpos * 4 - 4);
 
-    linker->relocate();
+    relocateLoader();
 
     MemBuffer loader(lsize);
     memcpy(loader, getLoader(), lsize);

src/p_wcle.h

@@ -38,7 +38,7 @@ class PackWcle : public Packer, public LeFile
 {
     typedef Packer super;
 public:
-    PackWcle(InputFile *f) : super(f), LeFile(f){};
+    PackWcle(InputFile *f) : super(f), LeFile(f) { bele = &N_BELE_RTP::le_policy; }
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_WATCOM_LE; }
     virtual const char *getName() const { return "watcom/le"; }
@@ -54,7 +54,7 @@ public:
 protected:
     virtual void handleStub(OutputFile *fo);
 
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
     virtual void readObjectTable();

src/packer.cpp

@@ -40,6 +40,7 @@
 **************************************************************************/
 
 Packer::Packer(InputFile *f) :
+    bele(NULL),
     fi(f), file_size(-1), ph_format(-1), ph_version(-1),
     uip(NULL), linker(NULL),
     last_patch(NULL), last_patch_len(0), last_patch_off(0)
@@ -57,6 +58,25 @@ Packer::~Packer()
 }
 
 
+// for PackMaster
+void Packer::assertPacker()
+{
+    assert(getFormat() > 0);
+    assert(getFormat() <= 255);
+    assert(getVersion() >= 11);
+    assert(getVersion() <= 14);
+    assert(strlen(getName()) <= 13);
+    if (bele == NULL) fprintf(stderr, "%s\n", getName());
+    assert(bele != NULL);
+#if 1
+    Linker *l = newLinker();
+    if (bele != l->bele) fprintf(stderr, "%s\n", getName());
+    assert(bele == l->bele);
+    delete l;
+#endif
+}
+
+
 /*************************************************************************
 // public entries called from class PackMaster
 **************************************************************************/
@@ -189,6 +209,20 @@ bool Packer::compress(upx_bytep in, upx_bytep out,
             step = 0;
 #endif
     }
+    if (M_IS_LZMA(ph.method))
+    {
+        oassign(cconf.conf_lzma.pos_bits, opt->crp.crp_lzma.pos_bits);
+        oassign(cconf.conf_lzma.lit_pos_bits, opt->crp.crp_lzma.lit_pos_bits);
+        oassign(cconf.conf_lzma.lit_context_bits, opt->crp.crp_lzma.lit_context_bits);
+        oassign(cconf.conf_lzma.dict_size, opt->crp.crp_lzma.dict_size);
+        oassign(cconf.conf_lzma.num_fast_bytes, opt->crp.crp_lzma.num_fast_bytes);
+    }
+    if (M_IS_DEFLATE(ph.method))
+    {
+        oassign(cconf.conf_zlib.mem_level, opt->crp.crp_zlib.mem_level);
+        oassign(cconf.conf_zlib.window_bits, opt->crp.crp_zlib.window_bits);
+        oassign(cconf.conf_zlib.strategy, opt->crp.crp_zlib.strategy);
+    }
     if (uip->ui_pass >= 0)
         uip->ui_pass++;
     uip->startCallback(ph.u_len, step, uip->ui_pass, uip->ui_total_passes);
@@ -211,7 +245,7 @@ bool Packer::compress(upx_bytep in, upx_bytep out,
 
     if (M_IS_NRV2B(ph.method) || M_IS_NRV2D(ph.method) || M_IS_NRV2E(ph.method))
     {
-        ucl_uint *res = ph.compress_result.result_ucl.result;
+        const ucl_uint *res = ph.compress_result.result_ucl.result;
         //ph.min_offset_found = res[0];
         ph.max_offset_found = res[1];
         //ph.min_match_found = res[2];
@@ -265,41 +299,38 @@ bool Packer::compress(upx_bytep in, upx_bytep out,
 #endif
 
 
-bool Packer::checkCompressionRatio(unsigned u_len, unsigned c_len) const
+bool Packer::checkDefaultCompressionRatio(unsigned u_len, unsigned c_len) const
 {
     assert((int)u_len > 0);
     assert((int)c_len > 0);
-
-#if 1
-    if (c_len + 512 >= u_len)           // min. 512 bytes gain
-        return false;
-    if (c_len >= u_len - u_len / 8)     // min. 12.5% gain
-        return false;
-#else
     if (c_len >= u_len)
         return false;
-#endif
+    unsigned gain = u_len - c_len;
+
+    if (gain < 512)             // need at least 512 bytes gain
+        return false;
+#if 1
+    if (gain >= 4096)           // ok if we have 4096 bytes gain
         return true;
+    if (gain >= u_len / 16)     // ok if we have 6.25% gain
+        return true;
+    return false;
+#else
+    return true;
+#endif
 }
 
 
+bool Packer::checkCompressionRatio(unsigned u_len, unsigned c_len) const
+{
+    return checkDefaultCompressionRatio(u_len, c_len);
+}
+
 bool Packer::checkFinalCompressionRatio(const OutputFile *fo) const
 {
     const unsigned u_len = file_size;
     const unsigned c_len = fo->getBytesWritten();
-
+    return checkDefaultCompressionRatio(u_len, c_len);
-    assert((int)u_len > 0);
-    assert((int)c_len > 0);
-
-    if (c_len + 4096 <= u_len)          // ok if we have 4096 bytes gain
-        return true;
-
-    if (c_len + 512 >= u_len)           // min. 512 bytes gain
-        return false;
-    if (c_len >= u_len - u_len / 8)     // min. 12.5% gain
-        return false;
-
-    return true;
 }
 
 
@@ -544,6 +575,8 @@ void Packer::copyOverlay(OutputFile *fo, unsigned overlay,
 // Create a pseudo-unique program id.
 unsigned Packer::getRandomId() const
 {
+    if (opt->debug.disable_random_id)
+        return 0x01020304;
     unsigned id = 0;
 #if 0 && defined(__unix__)
     // Don't consume precious bytes from /dev/urandom.
@@ -613,11 +646,15 @@ void Packer::updatePackHeader()
 }
 
 
+// FIXME: remove patchPackHeader() and fold into relocateLoader();
+//   then make linker->relocate() private (friend Packer)
 int Packer::patchPackHeader(void *b, int blen)
 {
-    const int size = ph.getPackHeaderSize();
     assert(isValidFilter(ph.filter));
 
+    const int size = ph.getPackHeaderSize();
+    if (linker->findSection("UPX1HEAD", false))
+        assert(size == linker->getSectionSize("UPX1HEAD"));
     int boff = find_le32(b, blen, UPX_MAGIC_LE32);
     checkPatch(b, blen, boff, size);
 
@@ -836,6 +873,9 @@ upx_byte *Packer::optimizeReloc32(upx_byte *in, unsigned relocnum,
                                   upx_byte *out, upx_byte *image,
                                   int bswap, int *big)
 {
+    if (opt->exact)
+        throwCantPackExact();
+
     *big = 0;
     if (relocnum == 0)
         return out;
@@ -871,7 +911,7 @@ upx_byte *Packer::optimizeReloc32(upx_byte *in, unsigned relocnum,
         }
         pc += oc;
         if (bswap)
-            set_be32(image+pc,get_le32(image+pc));
+            acc_ua_swab32s(image + pc);
     }
     *fix++ = 0;
     return fix;
@@ -912,7 +952,7 @@ unsigned Packer::unoptimizeReloc32(upx_byte **in, upx_byte *image,
         }
         *relocs++ = jc;
         if (bswap && image)
-            set_be32(image+jc,get_le32(image+jc));
+            acc_ua_swab32s(image + jc);
     }
     //fprintf(stderr,"relocnum=%x\n",relocn);
     *in = p+1;
@@ -921,37 +961,7 @@ unsigned Packer::unoptimizeReloc32(upx_byte **in, upx_byte *image,
 
 
 /*************************************************************************
-// loader util
+// loader util (interface to linker)
-**************************************************************************/
-
-void Packer::freezeLoader()
-{
-    linker->freeze();
-}
-
-
-upx_byte *Packer::getLoader() const
-{
-    int size = -1;
-    upx_byte *oloader = linker->getLoader(&size);
-    if (oloader == NULL || size <= 0)
-        throwBadLoader();
-    return oloader;
-}
-
-
-int Packer::getLoaderSize() const
-{
-    int size = -1;
-    upx_byte *oloader = linker->getLoader(&size);
-    if (oloader == NULL || size <= 0)
-        throwBadLoader();
-    return size;
-}
-
-
-/*************************************************************************
-// loader util
 **************************************************************************/
 
 static const char *getIdentstr(unsigned *size, int small)
@@ -1018,6 +1028,7 @@ void Packer::initLoader(const void *pdata, int plen, int small)
 {
     delete linker;
     linker = newLinker();
+    assert(bele == linker->bele);
     linker->init(pdata, plen);
 
     unsigned size;
@@ -1025,21 +1036,45 @@ void Packer::initLoader(const void *pdata, int plen, int small)
     linker->addSection("IDENTSTR", ident, size, 0);
 }
 
+void Packer::addLoader(const char *s)
+{
+    if (s)
+        linker->addLoader(s);
+}
 
-void __acc_cdecl_va Packer::addLoader(const char *s, ...)
+// provide specialization for [T = char]
+template <>
+void __acc_cdecl_va Packer::addLoader<char>(const char *s, ...)
 {
     va_list ap;
 
     va_start(ap, s);
     while (s != NULL)
     {
-        if (*s)
         linker->addLoader(s);
         s = va_arg(ap, const char *);
     }
     va_end(ap);
 }
 
+upx_byte *Packer::getLoader() const
+{
+    int size = -1;
+    upx_byte *oloader = linker->getLoader(&size);
+    if (oloader == NULL || size <= 0)
+        throwBadLoader();
+    return oloader;
+}
+
+int Packer::getLoaderSize() const
+{
+    int size = -1;
+    upx_byte *oloader = linker->getLoader(&size);
+    if (oloader == NULL || size <= 0)
+        throwBadLoader();
+    return size;
+}
+
 
 int Packer::getLoaderSection(const char *name, int *slen) const
 {
@@ -1052,7 +1087,6 @@ int Packer::getLoaderSection(const char *name, int *slen) const
     return ostart;
 }
 
-
 // same, but the size of the section may be == 0
 int Packer::getLoaderSectionStart(const char *name, int *slen) const
 {
@@ -1066,6 +1100,26 @@ int Packer::getLoaderSectionStart(const char *name, int *slen) const
 }
 
 
+void Packer::relocateLoader()
+{
+    linker->relocate();
+
+#if 0
+    // "relocate" packheader
+    if (linker->findSection("UPX1HEAD", false))
+    {
+        int lsize = -1;
+        int loff = getLoaderSectionStart("UPX1HEAD", &lsize);
+        assert(lsize == ph.getPackHeaderSize());
+        unsigned char *p = getLoader() + loff;
+        assert(get_le32(p) == UPX_MAGIC_LE32);
+        //patchPackHeader(p, lsize);
+        ph.putPackHeader(p);
+    }
+#endif
+}
+
+
 /*************************************************************************
 // Try compression with several methods and filters, choose the best
 /  or first working one. Needs buildLoader().
@@ -1306,7 +1360,8 @@ void Packer::compressWithFilters(Filter *parm_ft,
                 {
                     // get results
                     ph.overlap_overhead = findOverlapOverhead(*otemp, overlap_range);
-                    lsize = buildLoader(&ft);
+                    buildLoader(&ft);
+                    lsize = getLoaderSize();
                     assert(lsize > 0);
                 }
 #if 0

src/packer.h

@@ -119,6 +119,7 @@ protected:
     Packer(InputFile *f);
 public:
     virtual ~Packer();
+    virtual void assertPacker();
 
     virtual int getVersion() const = 0;
     // A unique integer ID for this executable format. See conf.h.
@@ -171,6 +172,7 @@ protected:
                           const upx_compress_config_t *cconf = NULL);
     virtual void decompress(const upx_bytep in, upx_bytep out,
                             bool verify_checksum = true, Filter *ft = NULL);
+    virtual bool checkDefaultCompressionRatio(unsigned u_len, unsigned c_len) const;
     virtual bool checkCompressionRatio(unsigned u_len, unsigned c_len) const;
     virtual bool checkFinalCompressionRatio(const OutputFile *fo) const;
 
@@ -203,17 +205,18 @@ protected:
     virtual void checkAlreadyPacked(const void *b, int blen);
 
     // loader core
-    virtual int buildLoader(const Filter *ft) = 0;
+    virtual void buildLoader(const Filter *ft) = 0;
     virtual Linker* newLinker() const = 0;
+    virtual void relocateLoader();
     // loader util for linker
-    virtual void freezeLoader();
     virtual upx_byte *getLoader() const;
     virtual int getLoaderSize() const;
     virtual void initLoader(const void *pdata, int plen, int small=-1);
+    void addLoader(const char *);
 #if 1 && (ACC_CC_GNUC >= 0x040100)
-    virtual void __acc_cdecl_va addLoader(const char *s, ...) __attribute__((__sentinel__));
+    template <class T> void __acc_cdecl_va addLoader(const T *, ...) __attribute__((__sentinel__));
 #else
-    virtual void __acc_cdecl_va addLoader(const char *s, ...);
+    template <class T> void __acc_cdecl_va addLoader(const T *, ...);
 #endif
     virtual int getLoaderSection(const char *name, int *slen=NULL) const;
     virtual int getLoaderSectionStart(const char *name, int *slen=NULL) const;
@@ -263,6 +266,7 @@ protected:
     static unsigned unoptimizeReloc32(upx_byte **in,upx_byte *image,MemBuffer *out,int bs);
 
 protected:
+    const N_BELE_RTP::AbstractPolicy *bele;
     InputFile *fi;
     off_t file_size;        // will get set by constructor
     PackHeader ph;          // must be filled by canUnpack()
@@ -292,6 +296,10 @@ private:
 };
 
 
+template <>
+void __acc_cdecl_va Packer::addLoader<char>(const char *s, ...);
+
+
 #endif /* already included */
 
 

src/packer_c.cpp

@@ -253,11 +253,12 @@ void Packer::defineDecompressorSymbols()
     {
         const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
         // FIXME - this is for i386 only
-        unsigned properties = // lc, lp, pb, dummy
+        acc_uint32e_t properties = // lc, lp, pb, dummy
             (res->lit_context_bits << 0) |
             (res->lit_pos_bits << 8) |
             (res->pos_bits << 16);
-
+        if (linker->bele->isBE()) // big endian - bswap32
+            acc_swab32s(&properties);
         linker->defineSymbol("lzma_properties", properties);
         // -2 for properties
         linker->defineSymbol("lzma_c_len", ph.c_len - 2);

src/packmast.cpp

@@ -69,6 +69,7 @@ PackMaster::PackMaster(InputFile *f, struct options_t *o) :
     if (o)
     {
         this->local_options = *o;       // struct copy
+        //memcpy(&this->local_options, o, sizeof(*o)); // struct copy
         opt = &this->local_options;
     }
 }
@@ -95,6 +96,7 @@ static Packer* try_pack(Packer *p, InputFile *f)
 {
     if (p == NULL)
         return NULL;
+    p->assertPacker();
     try {
         p->initPackHeader();
         f->seek(0,SEEK_SET);
@@ -119,6 +121,7 @@ static Packer* try_unpack(Packer *p, InputFile *f)
 {
     if (p == NULL)
         return NULL;
+    p->assertPacker();
     try {
         p->initPackHeader();
         f->seek(0,SEEK_SET);
@@ -278,16 +281,6 @@ static Packer *getUnpacker(InputFile *f)
 }
 
 
-static void assertPacker(const Packer *p)
-{
-    assert(p->getFormat() > 0);
-    assert(p->getFormat() <= 255);
-    assert(p->getVersion() >= 11);
-    assert(p->getVersion() <= 14);
-    assert(strlen(p->getName()) <= 13);
-}
-
-
 /*************************************************************************
 // delegation
 **************************************************************************/
@@ -295,7 +288,7 @@ static void assertPacker(const Packer *p)
 void PackMaster::pack(OutputFile *fo)
 {
     p = getPacker(fi);
-    assertPacker(p);
+    p->assertPacker();
     fi = NULL;
     p->doPack(fo);
 }
@@ -304,7 +297,7 @@ void PackMaster::pack(OutputFile *fo)
 void PackMaster::unpack(OutputFile *fo)
 {
     p = getUnpacker(fi);
-    assertPacker(p);
+    p->assertPacker();
     fi = NULL;
     p->doUnpack(fo);
 }
@@ -313,7 +306,7 @@ void PackMaster::unpack(OutputFile *fo)
 void PackMaster::test()
 {
     p = getUnpacker(fi);
-    assertPacker(p);
+    p->assertPacker();
     fi = NULL;
     p->doTest();
 }
@@ -322,7 +315,7 @@ void PackMaster::test()
 void PackMaster::list()
 {
     p = getUnpacker(fi);
-    assertPacker(p);
+    p->assertPacker();
     fi = NULL;
     p->doList();
 }
@@ -335,7 +328,7 @@ void PackMaster::fileInfo()
         p = try_packers(fi, try_pack);
     if (!p)
         throwUnknownExecutableFormat(NULL, 1);    // make a warning here
-    assertPacker(p);
+    p->assertPacker();
     fi = NULL;
     p->doFileInfo();
 }

src/pefile.cpp

@@ -109,6 +109,7 @@ static void xcheck(size_t poff, size_t plen, const void *b, size_t blen)
 
 PeFile::PeFile(InputFile *f) : super(f)
 {
+    bele = &N_BELE_RTP::le_policy;
     //printf("pe_header_t %d\n", (int) sizeof(pe_header_t));
     //printf("pe_section_t %d\n", (int) sizeof(pe_section_t));
     COMPILE_TIME_ASSERT(sizeof(pe_header_t) == 248);
@@ -1398,7 +1399,8 @@ void PeFile::processResources(Resource *res)
             if (res->itype() == RT_GROUP_ICON && iconsin1stdir == 0)
                 iconsin1stdir = get_le16(ibuf + res->offs() + 4);
 
-    bool compress_icon = false, compress_idir = false;
+    bool compress_icon = opt->win32_pe.compress_icons == 3;
+    bool compress_idir = false;
     unsigned iconcnt = 0;
 
     // some statistics
@@ -1629,7 +1631,7 @@ void PeFile::rebuildResources(upx_byte *& extrainfo)
     extrainfo += 2;
 
     const unsigned vaddr = IDADDR(PEDIR_RESOURCE);
-    const upx_byte *r = ibuf - isection[2].vaddr;
+    const upx_byte *r = ibuf - isection[ih.objects - 1].vaddr;
     Resource res(r + vaddr);
     while (res.next())
         if (res.offs() > vaddr)
@@ -1656,7 +1658,10 @@ void PeFile::unpack(OutputFile *fo)
 
     handleStub(fi,fo,pe_offset);
 
-    const unsigned overlay = file_size - ALIGN_UP(isection[2].rawdataptr + isection[2].size,ih.filealign);
+    const unsigned iobjs = ih.objects;
+    const unsigned overlay = file_size - ALIGN_UP(isection[iobjs - 1].rawdataptr
+                                                  + isection[iobjs - 1].size,
+                                                  ih.filealign);
     checkOverlay(overlay);
 
     ibuf.alloc(ph.c_len);
@@ -1697,6 +1702,16 @@ void PeFile::unpack(OutputFile *fo)
     rebuildRelocs(extrainfo);
     rebuildTls();
     rebuildExports();
+
+    if (iobjs == 4)
+    {
+        // read the resource section if present
+        ibuf.dealloc();
+        ibuf.alloc(isection[3].size);
+        fi->seek(isection[3].rawdataptr,SEEK_SET);
+        fi->readx(ibuf,isection[3].size);
+    }
+
     rebuildResources(extrainfo);
 
     //FIXME: this does bad things if the relocation section got removed

src/pefile.h

@@ -43,7 +43,7 @@ protected:
     class Export;
 
     PeFile(InputFile *f);
-    ~PeFile();
+    virtual ~PeFile();
     virtual int getVersion() const { return 13; }
 
     virtual void unpack(OutputFile *fo);

src/stub/Makefile

@@ -9,8 +9,8 @@
 MAKEFLAGS += -rR
 .SUFFIXES:
 .SECONDEXPANSION:
-export SHELL = /bin/sh
 export LC_ALL = C
+export SHELL = /bin/sh
 
 # internal make variables
 comma := ,
@@ -48,6 +48,8 @@ STUBS += amd64-linux.elf-entry.h
 STUBS += amd64-linux.elf-fold.h
 STUBS += arm-linux.elf-entry.h
 STUBS += arm-linux.elf-fold.h
+STUBS += armeb-linux.elf-entry.h
+STUBS += armeb-linux.elf-fold.h
 STUBS += arm.v4a-wince.pe.h
 STUBS += arm.v4t-wince.pe.h
 STUBS += i086-dos16.com.h
@@ -71,6 +73,7 @@ STUBS += i386-linux.elf.interp-fold.h
 STUBS += i386-linux.elf.shell-entry.h
 STUBS += i386-linux.elf.shell-fold.h
 STUBS += i386-linux.kernel.vmlinux.h
+STUBS += i386-linux.kernel.vmlinux-head.h
 STUBS += i386-linux.kernel.vmlinuz.h
 STUBS += i386-win32.pe.h
 STUBS += m68k-atari.tos.h
@@ -125,8 +128,10 @@ override T = $(basename $(notdir $@))
 
 # trim (strip) trailing whitespace
 RTRIM     := sed -e 's/[ $(tab)]*$$//'
-# squeeze duplicate blank lines, remove empty first & last line
+# squeeze duplicate blank lines, delete empty first & last line
-SQUEEZE := cat --squeeze-blank | sed -e '1{/^$$/d}' -e '$${/^$$/d}'
+BLSQUEEZE := $(RTRIM) | cat --squeeze-blank | sed -e '1{/^$$/d}' -e '$${/^$$/d}'
+# delete blank lines
+BLDEL     := $(RTRIM) | sed -e '/^$$/d'
 
 # clear some vars, just in case
 LABEL_PREFIX =
@@ -134,6 +139,7 @@ PP_FLAGS =
 tc_bfdarch =
 tc_bfdname =
 tc_list =
+tc_objdump_disasm_options =
 
 
 # /***********************************************************************
@@ -154,12 +160,15 @@ define tc
 endef
 
 # default tools
-tc.default.bin2h      = python $(top_srcdir)/src/stub/scripts/bin2h.py
+tc.default.bin2h      = python $(top_srcdir)/src/stub/scripts/bin2h.py --ident=auto-stub
+##tc.default.bin2h-c    = $(call tc,bin2h) --compress=14,15,0
+tc.default.bin2h-c    = $(call tc,bin2h) --compress=0
 tc.default.brandelf   = python $(top_srcdir)/src/stub/scripts/brandelf.py $(if $(tc_bfdname),--bfdname=$(tc_bfdname))
 tc.default.gpp_inc    = python $(top_srcdir)/src/stub/scripts/gpp_inc.py
 tc.default.gpp_mkdep  = python $(top_srcdir)/src/stub/scripts/gpp_inc.py -o /dev/null
 tc.default.pp-as      = i386-linux-gcc-3.4.6 -E -nostdinc -x assembler-with-cpp -Wall
 tc.default.sstrip     = sstrip
+tc.default.xstrip     = python $(top_srcdir)/src/stub/scripts/xstrip.py
 
 # default multiarch-binutils
 tc.default.m-ld       = multiarch-ld-2.17 $(if $(tc_bfdname),-b $(tc_bfdname))
@@ -181,8 +190,9 @@ define tc.default.f-embed_objinfo
 	$(call tc,objcopy) --strip-unneeded $1
 	$(call tc,objcopy) -R .text -R .data -R .bss $1
 	$(call tc,objcopy) -R .comment -R .note -R .note.GNU-stack -R .reginfo $1
-	$(call tc,objdump) -Dr $1 | $(RTRIM) > $1.disasm
+	$(call tc,objdump) -Dr $(tc_objdump_disasm_options) $1 | $(RTRIM) > $1.disasm
-	$(call tc,objdump) -htr -w $1 | $(RTRIM) | $(SQUEEZE) > $1.dump
+	$(call tc,objdump) -htr -w $1 | $(BLSQUEEZE) > $1.dump
+	$(call tc,xstrip) --dump=$1.dump $1
 	cat $1.dump >> $1
 endef
 define tc.default.f-objstrip
@@ -210,12 +220,13 @@ tc.amd64-linux.elf.gcc += -Wall -W -Wcast-align -Wcast-qual -Wwrite-strings -Wer
 amd64-linux.elf-entry.h: $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_elf64amd_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 amd64-linux.elf-fold.h : tmp/$$T.o tmp/amd64-linux.elf-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
+	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_elf64amd_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/amd64-linux.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o $@
@@ -224,6 +235,7 @@ tmp/amd64-linux.elf-fold.o : $(srcdir)/src/$$T.S
 tmp/amd64-linux.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c -Os $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -233,19 +245,20 @@ tmp/amd64-linux.elf-main.o : $(srcdir)/src/$$T.c
 arm-linux.elf%.h : tc_list = arm-linux.elf default
 arm-linux.elf%.h : tc_bfdname = elf32-littlearm
 
-tc.arm-linux.elf.gcc  = arm-linux-gcc-4.1.0 -mlittle-endian -march=armv4 -nostdinc -MMD -MT $@
+tc.arm-linux.elf.gcc  = arm-linux-gcc-4.1.0 -march=armv4 -nostdinc -MMD -MT $@
 tc.arm-linux.elf.gcc += -fno-exceptions -fno-asynchronous-unwind-tables
 tc.arm-linux.elf.gcc += -Wall -W -Wcast-align -Wcast-qual -Wwrite-strings -Werror
 
 arm-linux.elf-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -march=armv4 -c $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_elf32arm_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 arm-linux.elf-fold.h : tmp/$$T.o tmp/arm-linux.elf-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
+	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_elf32arm_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/arm-linux.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o $@
@@ -254,6 +267,37 @@ tmp/arm-linux.elf-fold.o : $(srcdir)/src/$$T.S
 tmp/arm-linux.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c -Os $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
+
+
+# /***********************************************************************
+# // armeb-linux.elf
+# ************************************************************************/
+
+armeb-linux.elf%.h : tc_list = armeb-linux.elf default
+armeb-linux.elf%.h : tc_bfdname = elf32-bigarm
+
+tc.armeb-linux.elf.gcc = $(tc.arm-linux.elf.gcc) -mbig-endian
+
+armeb-linux.elf-entry.h : $(srcdir)/src/$$T.S
+	$(call tc,gcc) -march=armv4 -c $< -o tmp/$T.bin
+	$(call tc,f-embed_objinfo,tmp/$T.bin)
+	$(call tc,bin2h) tmp/$T.bin $@
+
+armeb-linux.elf-fold.h : tmp/$$T.o tmp/armeb-linux.elf-main.o $(srcdir)/src/$$T.lds
+	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
+	$(call tc,f-objstrip,tmp/$T.bin)
+	$(call tc,sstrip) tmp/$T.bin
+	$(call tc,bin2h) tmp/$T.bin $@
+
+tmp/armeb-linux.elf-fold.o : $(srcdir)/src/$$T.S
+	$(call tc,gcc) -c $< -o $@
+	$(call tc,f-objstrip,$@)
+
+tmp/armeb-linux.elf-main.o : $(srcdir)/src/$$T.c
+	$(call tc,gcc) -c -Os $< -o $@
+	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -266,16 +310,17 @@ arm.v4a-wince.pe.h : tc_list = arm-linux.elf default
 arm.v4t-wince.pe.h : tc_list = arm-linux.elf default
 arm.v4a-wince.pe.h : tc_bfdname = elf32-littlearm
 arm.v4t-wince.pe.h : tc_bfdname = elf32-littlearm
+arm.v4t-wince.pe.h : tc_objdump_disasm_options = -M force-thumb
 
 arm.v4a-wince.pe.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -march=armv4 -c $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader_arm tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 arm.v4t-wince.pe.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -march=armv4t -c $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader_thumb tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -288,7 +333,7 @@ i086-dos16.com.h : tc_bfdarch = i8086
 i086-dos16.com.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv2b_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -301,7 +346,7 @@ i086-dos16.exe.h : tc_bfdarch = i8086
 i086-dos16.exe.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -314,7 +359,7 @@ i086-dos16.sys.h : tc_bfdarch = i8086
 i086-dos16.sys.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv2b_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -329,14 +374,14 @@ i386-bsd.elf%.h : tc_bfdname = elf32-i386
 i386-bsd.elf-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=bsd_i386elf_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 i386-bsd.elf-fold.h : tmp/$$T.o tmp/i386-bsd.elf-main.o tmp/i386-bsd.syscall.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=freebsd tmp/$T.bin
-	$(call tc,bin2h) --ident=bsd_i386elf_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-bsd.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -349,6 +394,7 @@ tmp/i386-bsd.syscall.o: $(srcdir)/src/$$T.S
 tmp/i386-bsd.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # info: we use the tc settings from i386-linux.elf
@@ -362,7 +408,7 @@ i386-openbsd.elf-fold.h : tmp/$$T.o tmp/i386-openbsd.elf-main.o tmp/i386-bsd.sys
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=openbsd tmp/$T.bin
-	$(call tc,bin2h) --ident=openbsd_i386elf_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-openbsd.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -371,6 +417,7 @@ tmp/i386-openbsd.elf-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-openbsd.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -382,7 +429,7 @@ tmp/i386-openbsd.elf-main.o : $(srcdir)/src/$$T.c
 i386-bsd.elf.execve-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=bsd_i386exec_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 # Note the re-use of i386-linux.elf.execve-fold.lds as input (no separate i386-bsd.elf.execve-fold.lds).
 i386-bsd.elf.execve-fold.h : tmp/$$T.o tmp/i386-bsd.elf.execve-main.o tmp/i386-bsd.syscall.o tmp/i386-linux.elf.execve-upx_itoa.o $(srcdir)/src/i386-linux.elf.execve-fold.lds
@@ -390,7 +437,7 @@ i386-bsd.elf.execve-fold.h : tmp/$$T.o tmp/i386-bsd.elf.execve-main.o tmp/i386-b
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=freebsd tmp/$T.bin
-	$(call tc,bin2h) --ident=bsd_i386exec_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-bsd.elf.execve-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -399,6 +446,7 @@ tmp/i386-bsd.elf.execve-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-bsd.elf.execve-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 tmp/i386-bsd.elf.execve-upx_itoa.o: $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o $@
@@ -414,12 +462,12 @@ i386-dos32.djgpp2% : tc_list = arch-i386 default
 i386-dos32.djgpp2.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 i386-dos32.djgpp2-stubify.h : $(srcdir)/src/$$T.asm
 	$(call tc,djasm) --outtype=exe --gmtime=1070220810 --inname=stub.asm --outname=stub.h $< tmp/$T.bin
 	$(call tc,objdump) -b binary -m i8086 -D --start-address=0x254 tmp/$T.bin | $(RTRIM) > tmp/$T.bin.disasm
-	$(call tc,bin2h) --ident=stubify_stub -q tmp/$T.bin $@
+	$(call tc,bin2h) -q tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -431,7 +479,7 @@ i386-dos32.tmt.h : tc_list = arch-i386 default
 i386-dos32.tmt.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -443,7 +491,7 @@ i386-dos32.watcom.le.h : tc_list = arch-i386 default
 i386-dos32.watcom.le.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -466,14 +514,14 @@ tc.i386-linux.elf.gcc     += -fweb
 i386-linux.elf-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_i386elf_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 i386-linux.elf-fold.h : tmp/$$T.o tmp/i386-linux.elf-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=linux tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_i386elf_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-linux.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -482,6 +530,7 @@ tmp/i386-linux.elf-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-linux.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -493,14 +542,14 @@ tmp/i386-linux.elf-main.o : $(srcdir)/src/$$T.c
 i386-linux.elf.execve-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_i386exec_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 i386-linux.elf.execve-fold.h : tmp/$$T.o tmp/i386-linux.elf.execve-main.o tmp/i386-linux.elf.execve-upx_itoa.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=linux tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_i386exec_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-linux.elf.execve-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -509,6 +558,7 @@ tmp/i386-linux.elf.execve-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-linux.elf.execve-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 tmp/i386-linux.elf.execve-upx_itoa.o: $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o $@
@@ -524,14 +574,14 @@ tmp/i386-linux.elf.execve-upx_itoa.o: $(srcdir)/src/$$T.S
 i386-linux.elf.interp-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_i386pti_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 i386-linux.elf.interp-fold.h : tmp/$$T.o tmp/i386-linux.elf.interp-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=linux tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_i386pti_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-linux.elf.interp-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -540,6 +590,7 @@ tmp/i386-linux.elf.interp-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-linux.elf.interp-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -551,14 +602,14 @@ tmp/i386-linux.elf.interp-main.o : $(srcdir)/src/$$T.c
 i386-linux.elf.shell-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_i386sh_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 i386-linux.elf.shell-fold.h : tmp/$$T.o tmp/i386-linux.elf.shell-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
 	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
 	$(call tc,brandelf) --elfosabi=linux tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_i386sh_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/i386-linux.elf.shell-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
@@ -567,11 +618,13 @@ tmp/i386-linux.elf.shell-fold.o : $(srcdir)/src/$$T.S
 tmp/i386-linux.elf.shell-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
 # // i386-linux.kernel.vmlinux
 # // i386-linux.kernel.vmlinuz
+# // i386-linux.kernel.vmlinux-head
 # ************************************************************************/
 
 i386-linux.kernel.vmlinu%.h : tc_list = arch-i386 default
@@ -579,7 +632,12 @@ i386-linux.kernel.vmlinu%.h : tc_list = arch-i386 default
 i386-linux.kernel.vmlinu%.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
+
+i386-linux.kernel.vmlinux-head.h : $(srcdir)/src/$$T.S
+	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.o
+	$(call tc,objcopy) --output-target binary --only-section .text tmp/$T.o tmp/$T.bin
+	$(call tc,bin2h) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -592,7 +650,7 @@ i386-win32.pe.h : tc_bfdname = elf32-i386
 i386-win32.pe.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c -x assembler-with-cpp $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -601,15 +659,16 @@ i386-win32.pe.h : $(srcdir)/src/$$T.S
 
 m68k-atari.tos.h : tc_list = m68k-atari.tos default
 m68k-atari.tos.h : tc_bfdname = elf32-m68k
+m68k-atari.tos.h : tc_objdump_disasm_options = -m m68k:68040
 
 tc.m68k-atari.tos.gcc  = m68k-linux-gcc-4.1.1 -m68000 -malign-int -nostdinc -MMD -MT $@
 tc.m68k-atari.tos.gcc += -fno-exceptions -fno-asynchronous-unwind-tables
 tc.m68k-atari.tos.gcc += -Wall -W -Wcast-align -Wcast-qual -Wwrite-strings -Werror
 
 m68k-atari.tos.h : $(srcdir)/src/$$T.S
-	$(call tc,gcc) -c -x assembler-with-cpp -Wa,-m68040,-l,--pcrel,--register-prefix-optional $< -o tmp/$T.bin
+	$(call tc,gcc) -c -x assembler-with-cpp -Wa,-m68000,-l,--pcrel,--register-prefix-optional $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -632,11 +691,11 @@ ifeq (1,1)
 	$(call tc,as) tmp/$T.i -o tmp/$T.bin
 	$(call tc,gpp_mkdep) --mode=c --MMD=$@ $< --MF=tmp/$T.d
 else
-	# info: as-2.16.1 does not work
+	# info: as-2.16.1 as used by gcc-4.1.1 does _not_ work
 	$(call tc,gcc) -c -DPS1 -Wa,-O,-mno-pdr $< -o tmp/$T.bin
 endif
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=nrv_loader tmp/$T.bin $@
+	$(call tc,bin2h-c) tmp/$T.bin $@
 
 
 # /***********************************************************************
@@ -650,11 +709,12 @@ powerpc-darwin.macho%.h : tc_bfdname = elf32-powerpc
 powerpc-darwin.macho-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=l_mac_ppc32_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 powerpc-darwin.macho-fold.h : tmp/$$T.o tmp/powerpc-darwin.macho-main.o
-	$(call tc,ld) --strip-all --oformat binary -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
+	$(call tc,ld) --no-warn-mismatch --strip-all --oformat binary -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
-	$(call tc,bin2h) --ident=fold_machppc32 tmp/$T.bin $@
+	chmod a-x tmp/$T.bin
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/powerpc-darwin.macho-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o $@
@@ -663,6 +723,7 @@ tmp/powerpc-darwin.macho-fold.o : $(srcdir)/src/$$T.S
 tmp/powerpc-darwin.macho-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c -Os $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -679,12 +740,13 @@ tc.powerpc-linux.elf.gcc += -Wall -W -Wcast-align -Wcast-qual -Wwrite-strings -W
 powerpc-linux.elf-entry.h : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o tmp/$T.bin
 	$(call tc,f-embed_objinfo,tmp/$T.bin)
-	$(call tc,bin2h) --ident=linux_elfppc32_loader tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 powerpc-linux.elf-fold.h : tmp/$$T.o tmp/powerpc-linux.elf-main.o $(srcdir)/src/$$T.lds
 	$(call tc,ld) --strip-all -T $(srcdir)/src/$T.lds -Map tmp/$T.map $(filter %.o,$^) -o tmp/$T.bin
+	$(call tc,f-objstrip,tmp/$T.bin)
 	$(call tc,sstrip) tmp/$T.bin
-	$(call tc,bin2h) --ident=linux_elfppc32_fold tmp/$T.bin $@
+	$(call tc,bin2h) tmp/$T.bin $@
 
 tmp/powerpc-linux.elf-fold.o : $(srcdir)/src/$$T.S
 	$(call tc,gcc) -c $< -o $@
@@ -693,6 +755,7 @@ tmp/powerpc-linux.elf-fold.o : $(srcdir)/src/$$T.S
 tmp/powerpc-linux.elf-main.o : $(srcdir)/src/$$T.c
 	$(call tc,gcc) -c -Os $< -o $@
 	$(call tc,f-objstrip,$@)
+	$(call tc,objdump) -dr $(tc_objdump_disasm_options) $@ | $(RTRIM) > $@.disasm
 
 
 # /***********************************************************************
@@ -702,9 +765,15 @@ tmp/powerpc-linux.elf-main.o : $(srcdir)/src/$$T.c
 ifneq ($(strip $(STUBS)),)
 # FIXME: we want a dependency-only prerequisite here
 $(STUBS): tmp/.tmp-stamp $(MAKEFILE_LIST)
+$(STUBS): $(top_srcdir)/src/stub/scripts/bin2h.py
+$(STUBS): $(top_srcdir)/src/stub/scripts/xstrip.py
 endif
 -include tmp/*.d
 
+ifneq ($(strip $(STUBS)),)
+.DELETE_ON_ERROR: $(STUBS)
+endif
+
 
 # /***********************************************************************
 # // extra-all

src/stub/amd64-linux.elf-entry.h

@@ -1,4 +1,5 @@
-/* amd64-linux.elf-entry.h -- created from amd64-linux.elf-entry.bin, 12687 (0x318f) bytes
+/* amd64-linux.elf-entry.h
+   created from amd64-linux.elf-entry.bin, 10083 (0x2763) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_ELF64AMD_LOADER_SIZE    12687
+#define STUB_AMD64_LINUX_ELF_ENTRY_SIZE    10083
-#define LINUX_ELF64AMD_LOADER_ADLER32 0xfad48a76
+#define STUB_AMD64_LINUX_ELF_ENTRY_ADLER32 0xade2081d
-#define LINUX_ELF64AMD_LOADER_CRC32   0x4e575312
+#define STUB_AMD64_LINUX_ELF_ENTRY_CRC32   0xfca80bc2
 
-unsigned char linux_elf64amd_loader[12687] = {
+unsigned char stub_amd64_linux_elf_entry[10083] = {
 127, 69, 76, 70,  2,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   1,  0, 62,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0,112, 24,  0,  0,  0,  0,  0,  0,   /* 0x  20 */
@@ -412,417 +413,255 @@ unsigned char linux_elf64amd_loader[12687] = {
   1,211, 68,137,249,193,233,  3,252,243, 72,165,151,137,222, 80,   /* 0x1790 */
 146,173, 80, 72,137,225,173,151,173, 68, 15,182,192,135,254,255,   /* 0x17a0 */
 213, 89,195, 93, 68,139,125,247, 65,129,239,200,  0,  0,  0,232,   /* 0x17b0 */
-133,255,255,255,  0, 46,115,121,109,116, 97, 98,  0, 46,115,116,   /* 0x17c0 */
+133,255,255,255,116,109,112, 47, 97,109,100, 54, 52, 45,108,105,   /* 0x17c0 */
-114,116, 97, 98,  0, 46,115,104,115,116,114,116, 97, 98,  0, 46,   /* 0x17d0 */
+110,117,120, 46,101,108,102, 45,101,110,116,114,121, 46, 98,105,   /* 0x17d0 */
-114,101,108, 97, 69, 76, 70, 77, 65, 73, 78, 88,  0, 78, 82, 86,   /* 0x17e0 */
+110, 58, 32, 32, 32, 32, 32,102,105,108,101, 32,102,111,114,109,   /* 0x17e0 */
- 95, 72, 69, 65, 68,  0, 46,114,101,108, 97, 78, 82, 86, 50, 69,   /* 0x17f0 */
+ 97,116, 32,101,108,102, 54, 52, 45,120, 56, 54, 45, 54, 52, 10,   /* 0x17f0 */
-  0, 46,114,101,108, 97, 78, 82, 86, 50, 68,  0, 46,114,101,108,   /* 0x1800 */
+ 10, 83,101, 99,116,105,111,110,115, 58, 10, 73,100,120, 32, 78,   /* 0x1800 */
- 97, 78, 82, 86, 50, 66,  0, 46,114,101,108, 97, 76, 90, 77, 65,   /* 0x1810 */
+ 97,109,101, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83,105,122,   /* 0x1810 */
- 95, 69, 76, 70, 48, 48,  0, 76, 90, 77, 65, 95, 68, 69, 67, 49,   /* 0x1820 */
+101, 32, 32, 32, 32, 32, 32, 86, 77, 65, 32, 32, 32, 32, 32, 32,   /* 0x1820 */
- 48,  0, 76, 90, 77, 65, 95, 68, 69, 67, 50, 48,  0, 76, 90, 77,   /* 0x1830 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 76, 77, 65, 32, 32, 32, 32,   /* 0x1830 */
- 65, 95, 68, 69, 67, 51, 48,  0, 78, 82, 86, 95, 84, 65, 73, 76,   /* 0x1840 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 70,105,108,101, 32,   /* 0x1840 */
-  0, 46,114,101,108, 97, 69, 76, 70, 77, 65, 73, 78, 89,  0, 46,   /* 0x1850 */
+111,102,102, 32, 32, 65,108,103,110, 32, 32, 70,108, 97,103,115,   /* 0x1850 */
-114,101,108, 97, 69, 76, 70, 77, 65, 73, 78, 90,  0,  0,  0,  0,   /* 0x1860 */
+ 10, 32, 32, 48, 32, 69, 76, 70, 77, 65, 73, 78, 88, 32, 32, 32,   /* 0x1860 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1870 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 48,100, 32, 32, 48, 48, 48,   /* 0x1870 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1880 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1880 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1890 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1890 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x18a0 */
+ 32, 48, 48, 48, 48, 48, 48, 52, 48, 32, 32, 50, 42, 42, 48, 32,   /* 0x18a0 */
- 32,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x18b0 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67,   /* 0x18b0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 64,  0,  0,  0,  0,  0,  0,  0,   /* 0x18c0 */
+ 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 49, 32, 78,   /* 0x18c0 */
- 13,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x18d0 */
+ 82, 86, 95, 72, 69, 65, 68, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x18d0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x18e0 */
+ 48, 48, 48, 54, 54, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x18e0 */
- 27,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x18f0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x18f0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 88, 32,  0,  0,  0,  0,  0,  0,   /* 0x1900 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1900 */
- 24,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0,  1,  0,  0,  0,   /* 0x1910 */
+ 48, 52,100, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x1910 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1920 */
+ 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32,   /* 0x1920 */
- 41,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1930 */
+ 50, 32, 78, 82, 86, 50, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1930 */
-  0,  0,  0,  0,  0,  0,  0,  0, 77,  0,  0,  0,  0,  0,  0,  0,   /* 0x1940 */
+ 48, 48, 48, 48, 48, 48, 98, 55, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x1940 */
-102,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1950 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x1950 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1960 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x1960 */
- 55,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1970 */
+ 48, 48, 48, 48, 98, 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x1970 */
-  0,  0,  0,  0,  0,  0,  0,  0,179,  0,  0,  0,  0,  0,  0,  0,   /* 0x1980 */
+ 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82,   /* 0x1980 */
-183,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1990 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 51, 32, 78, 82, 86, 50,   /* 0x1990 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x19a0 */
+ 68, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x19a0 */
- 50,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x19b0 */
+ 57,101, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x19b0 */
-  0,  0,  0,  0,  0,  0,  0,  0,112, 32,  0,  0,  0,  0,  0,  0,   /* 0x19c0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x19c0 */
- 48,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0,  4,  0,  0,  0,   /* 0x19d0 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 54, 97,   /* 0x19d0 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x19e0 */
+ 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x19e0 */
- 66,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x19f0 */
+ 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x19f0 */
-  0,  0,  0,  0,  0,  0,  0,  0,106,  1,  0,  0,  0,  0,  0,  0,   /* 0x1a00 */
+ 89, 10, 32, 32, 52, 32, 78, 82, 86, 50, 66, 32, 32, 32, 32, 32,   /* 0x1a00 */
-158,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a10 */
+ 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 57, 48, 32, 32, 48, 48,   /* 0x1a10 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a20 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x1a20 */
- 61,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a30 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1a30 */
-  0,  0,  0,  0,  0,  0,  0,  0,160, 32,  0,  0,  0,  0,  0,  0,   /* 0x1a40 */
+ 32, 32, 48, 48, 48, 48, 48, 50, 48, 56, 32, 32, 50, 42, 42, 48,   /* 0x1a40 */
- 48,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0,  6,  0,  0,  0,   /* 0x1a50 */
+ 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79,   /* 0x1a50 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a60 */
+ 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 53, 32,   /* 0x1a60 */
- 77,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a70 */
+ 76, 90, 77, 65, 95, 69, 76, 70, 48, 48, 32, 32, 32, 32, 48, 48,   /* 0x1a70 */
-  0,  0,  0,  0,  0,  0,  0,  0,  8,  2,  0,  0,  0,  0,  0,  0,   /* 0x1a80 */
+ 48, 48, 48, 48, 54, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1a80 */
-144,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1a90 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x1a90 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1aa0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x1aa0 */
- 72,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ab0 */
+ 48, 50, 57, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x1ab0 */
-  0,  0,  0,  0,  0,  0,  0,  0,208, 32,  0,  0,  0,  0,  0,  0,   /* 0x1ac0 */
+ 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65,   /* 0x1ac0 */
- 48,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0,  8,  0,  0,  0,   /* 0x1ad0 */
+ 68, 79, 78, 76, 89, 10, 32, 32, 54, 32, 76, 90, 77, 65, 95, 68,   /* 0x1ad0 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ae0 */
+ 69, 67, 49, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48, 57,102, 55,   /* 0x1ae0 */
- 88,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1af0 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1af0 */
-  0,  0,  0,  0,  0,  0,  0,  0,152,  2,  0,  0,  0,  0,  0,  0,   /* 0x1b00 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1b00 */
-100,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b10 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 50,102, 99, 32, 32,   /* 0x1b10 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b20 */
+ 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x1b20 */
- 83,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b30 */
+ 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 55, 32, 76, 90, 77,   /* 0x1b30 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0, 33,  0,  0,  0,  0,  0,  0,   /* 0x1b40 */
+ 65, 95, 68, 69, 67, 50, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x1b40 */
- 24,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0, 10,  0,  0,  0,   /* 0x1b50 */
+ 57,102, 55, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1b50 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b60 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1b60 */
- 99,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b70 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 99,102,   /* 0x1b70 */
-  0,  0,  0,  0,  0,  0,  0,  0,252,  2,  0,  0,  0,  0,  0,  0,   /* 0x1b80 */
+ 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x1b80 */
-247,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1b90 */
+ 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 56, 32,   /* 0x1b90 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ba0 */
+ 76, 90, 77, 65, 95, 68, 69, 67, 51, 48, 32, 32, 32, 32, 48, 48,   /* 0x1ba0 */
-110,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1bb0 */
+ 48, 48, 48, 48, 49, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1bb0 */
-  0,  0,  0,  0,  0,  0,  0,  0,243, 12,  0,  0,  0,  0,  0,  0,   /* 0x1bc0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x1bc0 */
-247,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1bd0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x1bd0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1be0 */
+ 49, 54,101, 97, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x1be0 */
-121,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1bf0 */
+ 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x1bf0 */
-  0,  0,  0,  0,  0,  0,  0,  0,234, 22,  0,  0,  0,  0,  0,  0,   /* 0x1c00 */
+ 32, 57, 32, 78, 82, 86, 95, 84, 65, 73, 76, 32, 32, 32, 32, 32,   /* 0x1c00 */
- 20,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c10 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1c10 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c20 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x1c20 */
-132,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c30 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1c30 */
-  0,  0,  0,  0,  0,  0,  0,  0,254, 22,  0,  0,  0,  0,  0,  0,   /* 0x1c40 */
+ 48, 48, 48, 49, 54,102,101, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1c40 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c50 */
+ 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x1c50 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c60 */
+ 89, 10, 32, 49, 48, 32, 69, 76, 70, 77, 65, 73, 78, 89, 32, 32,   /* 0x1c60 */
-146,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c70 */
+ 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 51, 97, 32, 32, 48, 48,   /* 0x1c70 */
-  0,  0,  0,  0,  0,  0,  0,  0,254, 22,  0,  0,  0,  0,  0,  0,   /* 0x1c80 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x1c80 */
- 58,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1c90 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1c90 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ca0 */
+ 32, 32, 48, 48, 48, 48, 49, 54,102,101, 32, 32, 50, 42, 42, 48,   /* 0x1ca0 */
-141,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1cb0 */
+ 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79,   /* 0x1cb0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 24, 33,  0,  0,  0,  0,  0,  0,   /* 0x1cc0 */
+ 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 49, 32,   /* 0x1cc0 */
- 24,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0, 16,  0,  0,  0,   /* 0x1cd0 */
+ 69, 76, 70, 77, 65, 73, 78, 90, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x1cd0 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ce0 */
+ 48, 48, 48, 48, 56, 99, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1ce0 */
-160,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1cf0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x1cf0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 56, 23,  0,  0,  0,  0,  0,  0,   /* 0x1d00 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x1d00 */
-140,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d10 */
+ 49, 55, 51, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x1d10 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d20 */
+ 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65,   /* 0x1d20 */
-155,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d30 */
+ 68, 79, 78, 76, 89, 10, 83, 89, 77, 66, 79, 76, 32, 84, 65, 66,   /* 0x1d30 */
-  0,  0,  0,  0,  0,  0,  0,  0, 48, 33,  0,  0,  0,  0,  0,  0,   /* 0x1d40 */
+ 76, 69, 58, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1d40 */
-192,  0,  0,  0,  0,  0,  0,  0, 21,  0,  0,  0, 18,  0,  0,  0,   /* 0x1d50 */
+ 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86,   /* 0x1d50 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d60 */
+ 95, 72, 69, 65, 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1d60 */
- 17,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d70 */
+ 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 95, 72, 69, 65, 68, 10,   /* 0x1d70 */
-  0,  0,  0,  0,  0,  0,  0,  0,196, 23,  0,  0,  0,  0,  0,  0,   /* 0x1d80 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1d80 */
-169,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1d90 */
+ 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90, 77, 65, 95, 68, 69,   /* 0x1d90 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1da0 */
+ 67, 51, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1da0 */
-  1,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1db0 */
+ 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 51, 48, 10,   /* 0x1db0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 48, 30,  0,  0,  0,  0,  0,  0,   /* 0x1dc0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1dc0 */
-248,  1,  0,  0,  0,  0,  0,  0, 22,  0,  0,  0, 13,  0,  0,  0,   /* 0x1dd0 */
+ 32,108, 32, 32, 32, 32,100, 32, 32, 69, 76, 70, 77, 65, 73, 78,   /* 0x1dd0 */
-  8,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x1de0 */
+ 89,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1de0 */
-  9,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1df0 */
+ 48, 48, 32, 69, 76, 70, 77, 65, 73, 78, 89, 10, 48, 48, 48, 48,   /* 0x1df0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 40, 32,  0,  0,  0,  0,  0,  0,   /* 0x1e00 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1e00 */
- 43,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e10 */
+ 32, 32,100, 32, 32, 69, 76, 70, 77, 65, 73, 78, 90,  9, 48, 48,   /* 0x1e10 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e20 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69,   /* 0x1e20 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e30 */
+ 76, 70, 77, 65, 73, 78, 90, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1e30 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0,  3,  0,   /* 0x1e40 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1e40 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e50 */
+ 32, 69, 76, 70, 77, 65, 73, 78, 88,  9, 48, 48, 48, 48, 48, 48,   /* 0x1e50 */
-  0,  0,  0,  0,  3,  0, 14,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e60 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69, 76, 70, 77, 65,   /* 0x1e60 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0, 16,  0,   /* 0x1e70 */
+ 73, 78, 88, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1e70 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e80 */
+ 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86,   /* 0x1e80 */
-  0,  0,  0,  0,  3,  0, 18,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1e90 */
+ 50, 69,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1e90 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0,  1,  0,   /* 0x1ea0 */
+ 48, 48, 48, 32, 78, 82, 86, 50, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x1ea0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1eb0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x1eb0 */
-  0,  0,  0,  0,  3,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ec0 */
+100, 32, 32, 78, 82, 86, 50, 68,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x1ec0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0,  6,  0,   /* 0x1ed0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 50, 68, 10,   /* 0x1ed0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ee0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1ee0 */
-  0,  0,  0,  0,  3,  0,  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1ef0 */
+ 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 50, 66,  9, 48,   /* 0x1ef0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0, 10,  0,   /* 0x1f00 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1f00 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f10 */
+ 78, 82, 86, 50, 66, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1f10 */
-  0,  0,  0,  0,  3,  0, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f20 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76,   /* 0x1f20 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  0, 13,  0,   /* 0x1f30 */
+ 90, 77, 65, 95, 69, 76, 70, 48, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1f30 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f40 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95,   /* 0x1f40 */
-  0,  0,  0,  0,  3,  0, 15,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f50 */
+ 69, 76, 70, 48, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1f50 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0, 16,  0,  1,  0,   /* 0x1f60 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76,   /* 0x1f60 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f70 */
+ 90, 77, 65, 95, 68, 69, 67, 49, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1f70 */
-  8,  0,  0,  0, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1f80 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95,   /* 0x1f80 */
-  0,  0,  0,  0,  0,  0,  0,  0, 13,  0,  0,  0, 16,  0,  0,  0,   /* 0x1f90 */
+ 68, 69, 67, 49, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1f90 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1fa0 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76,   /* 0x1fa0 */
- 18,  0,  0,  0, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1fb0 */
+ 90, 77, 65, 95, 68, 69, 67, 50, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1fb0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 23,  0,  0,  0, 16,  0,  0,  0,   /* 0x1fc0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95,   /* 0x1fc0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1fd0 */
+ 68, 69, 67, 50, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1fd0 */
- 28,  0,  0,  0, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1fe0 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78,   /* 0x1fe0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 33,  0,  0,  0, 16,  0,  0,  0,   /* 0x1ff0 */
+ 82, 86, 95, 84, 65, 73, 76,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1ff0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x2000 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 95, 84, 65, 73,   /* 0x2000 */
- 38,  0,  0,  0, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x2010 */
+ 76, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2010 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0, 95,115,116, 97,114,116,  0,   /* 0x2020 */
+ 48, 48, 32,103, 32, 32, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65,   /* 0x2020 */
- 65, 68, 82, 77,  0, 76, 69, 78, 77,  0, 74, 77, 80, 85,  0, 65,   /* 0x2030 */
+ 73, 78, 88,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2030 */
- 68, 82, 85,  0, 65, 68, 82, 67,  0, 76, 69, 78, 85,  0, 65, 68,   /* 0x2040 */
+ 48, 48, 48, 48, 32, 95,115,116, 97,114,116, 10, 48, 48, 48, 48,   /* 0x2040 */
- 82, 88,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x2050 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32,   /* 0x2050 */
-  2,  0,  0,  0,  4,  0,  0,  0,119,  0,  0,  0,  0,  0,  0,  0,   /* 0x2060 */
+ 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48,   /* 0x2060 */
-174,  0,  0,  0,  0,  0,  0,  0,  2,  0,  0,  0,  1,  0,  0,  0,   /* 0x2070 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 77,   /* 0x2070 */
- 33,  0,  0,  0,  0,  0,  0,  0, 91,  0,  0,  0,  0,  0,  0,  0,   /* 0x2080 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2080 */
-  2,  0,  0,  0,  3,  0,  0,  0,252,255,255,255,255,255,255,255,   /* 0x2090 */
+ 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x2090 */
-149,  0,  0,  0,  0,  0,  0,  0,  2,  0,  0,  0,  1,  0,  0,  0,   /* 0x20a0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x20a0 */
- 33,  0,  0,  0,  0,  0,  0,  0, 91,  0,  0,  0,  0,  0,  0,  0,   /* 0x20b0 */
+ 32, 76, 69, 78, 77, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x20b0 */
-  2,  0,  0,  0,  3,  0,  0,  0,252,255,255,255,255,255,255,255,   /* 0x20c0 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42,   /* 0x20c0 */
-138,  0,  0,  0,  0,  0,  0,  0,  2,  0,  0,  0,  1,  0,  0,  0,   /* 0x20d0 */
+ 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x20d0 */
- 33,  0,  0,  0,  0,  0,  0,  0, 82,  0,  0,  0,  0,  0,  0,  0,   /* 0x20e0 */
+ 48, 48, 48, 48, 48, 32, 74, 77, 80, 85, 10, 48, 48, 48, 48, 48,   /* 0x20e0 */
-  2,  0,  0,  0,  3,  0,  0,  0,252,255,255,255,255,255,255,255,   /* 0x20f0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32,   /* 0x20f0 */
-  6,  0,  0,  0,  0,  0,  0,  0,  2,  0,  0,  0,  2,  0,  0,  0,   /* 0x2100 */
+ 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48,   /* 0x2100 */
- 16,  0,  0,  0,  0,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x2110 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 85, 10,   /* 0x2110 */
-  2,  0,  0,  0,  4,  0,  0,  0,252,255,255,255,255,255,255,255,   /* 0x2120 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2120 */
- 19,  0,  0,  0,  0,  0,  0,  0, 10,  0,  0,  0, 14,  0,  0,  0,   /* 0x2130 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48,   /* 0x2130 */
-  0,  0,  0,  0,  0,  0,  0,  0, 27,  0,  0,  0,  0,  0,  0,  0,   /* 0x2140 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x2140 */
- 10,  0,  0,  0, 15,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x2150 */
+ 65, 68, 82, 67, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2150 */
- 52,  0,  0,  0,  0,  0,  0,  0, 10,  0,  0,  0, 16,  0,  0,  0,   /* 0x2160 */
+ 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x2160 */
-  0,  0,  0,  0,  0,  0,  0,  0, 57,  0,  0,  0,  0,  0,  0,  0,   /* 0x2170 */
+ 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2170 */
- 10,  0,  0,  0, 17,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x2180 */
+ 48, 48, 48, 48, 32, 76, 69, 78, 85, 10, 48, 48, 48, 48, 48, 48,   /* 0x2180 */
- 62,  0,  0,  0,  0,  0,  0,  0, 10,  0,  0,  0, 18,  0,  0,  0,   /* 0x2190 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32,   /* 0x2190 */
-  0,  0,  0,  0,  0,  0,  0,  0, 67,  0,  0,  0,  0,  0,  0,  0,   /* 0x21a0 */
+ 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x21a0 */
- 10,  0,  0,  0, 19,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x21b0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 88, 10, 10,   /* 0x21b0 */
- 72,  0,  0,  0,  0,  0,  0,  0, 10,  0,  0,  0, 20,  0,  0,  0,   /* 0x21c0 */
+ 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x21c0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 47,  0,  0,  0,  0,  0,  0,  0,   /* 0x21d0 */
+ 68, 83, 32, 70, 79, 82, 32, 91, 69, 76, 70, 77, 65, 73, 78, 88,   /* 0x21d0 */
-  2,  0,  0,  0,  3,  0,  0,  0, 13,  0,  0,  0,  0,  0,  0,  0,   /* 0x21e0 */
+ 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32,   /* 0x21e0 */
-116,109,112, 47, 97,109,100, 54, 52, 45,108,105,110,117,120, 46,   /* 0x21f0 */
+ 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x21f0 */
-101,108,102, 45,101,110,116,114,121, 46, 98,105,110, 58, 32, 32,   /* 0x2200 */
+ 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48,   /* 0x2200 */
- 32, 32, 32,102,105,108,101, 32,102,111,114,109, 97,116, 32,101,   /* 0x2210 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 88,   /* 0x2210 */
-108,102, 54, 52, 45,120, 56, 54, 45, 54, 52, 10, 10, 83,101, 99,   /* 0x2220 */
+ 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 69,   /* 0x2220 */
-116,105,111,110,115, 58, 10, 73,100,120, 32, 78, 97,109,101, 32,   /* 0x2230 */
+ 76, 70, 77, 65, 73, 78, 90, 43, 48,120, 48, 48, 48, 48, 48, 48,   /* 0x2230 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 83,105,122,101, 32, 32, 32,   /* 0x2240 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 55, 55, 10, 10, 82, 69, 76, 79,   /* 0x2240 */
- 32, 32, 32, 86, 77, 65, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2250 */
+ 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70,   /* 0x2250 */
- 32, 32, 32, 32, 32, 76, 77, 65, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2260 */
+ 79, 82, 32, 91, 78, 82, 86, 50, 69, 93, 58, 10, 79, 70, 70, 83,   /* 0x2260 */
- 32, 32, 32, 32, 32, 32, 32, 70,105,108,101, 32,111,102,102, 32,   /* 0x2270 */
+ 69, 84, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80,   /* 0x2270 */
- 32, 65,108,103,110, 32, 32, 70,108, 97,103,115, 10, 32, 32, 48,   /* 0x2280 */
+ 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86,   /* 0x2280 */
- 32, 69, 76, 70, 77, 65, 73, 78, 88, 32, 32, 32, 32, 32, 32, 48,   /* 0x2290 */
+ 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2290 */
- 48, 48, 48, 48, 48, 48,100, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x22a0 */
+ 48, 48, 48, 97,101, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80,   /* 0x22a0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x22b0 */
+ 67, 51, 50, 32, 32, 32, 32, 32, 78, 82, 86, 95, 72, 69, 65, 68,   /* 0x22b0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x22c0 */
+ 43, 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x22c0 */
- 48, 48, 48, 52, 48, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78,   /* 0x22d0 */
+ 48, 50, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x22d0 */
- 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69,   /* 0x22e0 */
+ 48, 48, 53, 98, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67,   /* 0x22e0 */
- 65, 68, 79, 78, 76, 89, 10, 32, 32, 49, 32, 78, 82, 86, 95, 72,   /* 0x22f0 */
+ 51, 50, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43,   /* 0x22f0 */
- 69, 65, 68, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 54,   /* 0x2300 */
+ 48,120,102,102,102,102,102,102,102,102,102,102,102,102,102,102,   /* 0x2300 */
- 54, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2310 */
+102, 99, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x2310 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2320 */
+ 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 50,   /* 0x2320 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 52,100, 32,   /* 0x2330 */
+ 68, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32,   /* 0x2330 */
- 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x2340 */
+ 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x2340 */
- 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 50, 32, 78, 82,   /* 0x2350 */
+ 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48,   /* 0x2350 */
- 86, 50, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48,   /* 0x2360 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 57, 53, 32, 82, 95,   /* 0x2360 */
- 48, 48, 98, 55, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2370 */
+ 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32,   /* 0x2370 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2380 */
+ 78, 82, 86, 95, 72, 69, 65, 68, 43, 48,120, 48, 48, 48, 48, 48,   /* 0x2380 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x2390 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 50, 49, 10, 48, 48, 48, 48,   /* 0x2390 */
- 98, 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78,   /* 0x23a0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 53, 98, 32, 82, 95, 88,   /* 0x23a0 */
- 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79,   /* 0x23b0 */
+ 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 69,   /* 0x23b0 */
- 78, 76, 89, 10, 32, 32, 51, 32, 78, 82, 86, 50, 68, 32, 32, 32,   /* 0x23c0 */
+ 76, 70, 77, 65, 73, 78, 89, 43, 48,120,102,102,102,102,102,102,   /* 0x23c0 */
- 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 57,101, 32, 32,   /* 0x23d0 */
+102,102,102,102,102,102,102,102,102, 99, 10, 10, 82, 69, 76, 79,   /* 0x23d0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x23e0 */
+ 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70,   /* 0x23e0 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x23f0 */
+ 79, 82, 32, 91, 78, 82, 86, 50, 66, 93, 58, 10, 79, 70, 70, 83,   /* 0x23f0 */
- 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 54, 97, 32, 32, 50, 42,   /* 0x2400 */
+ 69, 84, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80,   /* 0x2400 */
- 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x2410 */
+ 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86,   /* 0x2410 */
- 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32,   /* 0x2420 */
+ 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2420 */
- 52, 32, 78, 82, 86, 50, 66, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2430 */
+ 48, 48, 48, 56, 97, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80,   /* 0x2430 */
- 48, 48, 48, 48, 48, 48, 57, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x2440 */
+ 67, 51, 50, 32, 32, 32, 32, 32, 78, 82, 86, 95, 72, 69, 65, 68,   /* 0x2440 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x2450 */
+ 43, 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2450 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x2460 */
+ 48, 50, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2460 */
- 48, 48, 48, 50, 48, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x2470 */
+ 48, 48, 53, 50, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67,   /* 0x2470 */
- 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82,   /* 0x2480 */
+ 51, 50, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43,   /* 0x2480 */
- 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 53, 32, 76, 90, 77, 65,   /* 0x2490 */
+ 48,120,102,102,102,102,102,102,102,102,102,102,102,102,102,102,   /* 0x2490 */
- 95, 69, 76, 70, 48, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x24a0 */
+102, 99, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x24a0 */
- 54, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x24b0 */
+ 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 76, 90, 77, 65,   /* 0x24b0 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x24c0 */
+ 95, 69, 76, 70, 48, 48, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32,   /* 0x24c0 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 50, 57, 56,   /* 0x24d0 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32,   /* 0x24d0 */
- 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x24e0 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85,   /* 0x24e0 */
- 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x24f0 */
+ 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x24f0 */
- 89, 10, 32, 32, 54, 32, 76, 90, 77, 65, 95, 68, 69, 67, 49, 48,   /* 0x2500 */
+ 48, 54, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50,   /* 0x2500 */
- 32, 32, 32, 32, 48, 48, 48, 48, 48, 57,102, 55, 32, 32, 48, 48,   /* 0x2510 */
+ 32, 32, 32, 32, 32, 76, 90, 77, 65, 95, 68, 69, 67, 51, 48, 43,   /* 0x2510 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x2520 */
+ 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2520 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2530 */
+ 49, 48, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x2530 */
- 32, 32, 48, 48, 48, 48, 48, 50,102, 99, 32, 32, 50, 42, 42, 48,   /* 0x2540 */
+ 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 69, 76, 70, 77,   /* 0x2540 */
- 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68,   /* 0x2550 */
+ 65, 73, 78, 89, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32,   /* 0x2550 */
- 79, 78, 76, 89, 10, 32, 32, 55, 32, 76, 90, 77, 65, 95, 68, 69,   /* 0x2560 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32,   /* 0x2560 */
- 67, 50, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48, 57,102, 55, 32,   /* 0x2570 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10,   /* 0x2570 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2580 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 56,   /* 0x2580 */
- 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2590 */
+ 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32,   /* 0x2590 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 99,102, 51, 32, 32, 50,   /* 0x25a0 */
+ 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 90, 43, 48,120,102,102,   /* 0x25a0 */
- 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x25b0 */
+102,102,102,102,102,102,102,102,102,102,102,102,102, 99, 10, 10,   /* 0x25b0 */
- 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 56, 32, 76, 90, 77, 65,   /* 0x25c0 */
+ 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x25c0 */
- 95, 68, 69, 67, 51, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x25d0 */
+ 68, 83, 32, 70, 79, 82, 32, 91, 69, 76, 70, 77, 65, 73, 78, 90,   /* 0x25d0 */
- 49, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x25e0 */
+ 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32,   /* 0x25e0 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x25f0 */
+ 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x25f0 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 49, 54,101, 97,   /* 0x2600 */
+ 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48,   /* 0x2600 */
- 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x2610 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 51, 32, 82, 95, 88,   /* 0x2610 */
- 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 57, 32, 78,   /* 0x2620 */
+ 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65,   /* 0x2620 */
- 82, 86, 95, 84, 65, 73, 76, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x2630 */
+ 68, 82, 77, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2630 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2640 */
+ 48, 48, 49, 98, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50,   /* 0x2640 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x2650 */
+ 32, 32, 32, 32, 32, 32, 32, 76, 69, 78, 77, 10, 48, 48, 48, 48,   /* 0x2650 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 49,   /* 0x2660 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51, 52, 32, 82, 95, 88,   /* 0x2660 */
- 54,102,101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x2670 */
+ 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 74,   /* 0x2670 */
- 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49,   /* 0x2680 */
+ 77, 80, 85, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2680 */
- 48, 32, 69, 76, 70, 77, 65, 73, 78, 89, 32, 32, 32, 32, 32, 32,   /* 0x2690 */
+ 48, 48, 51, 57, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50,   /* 0x2690 */
- 48, 48, 48, 48, 48, 48, 51, 97, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x26a0 */
+ 32, 32, 32, 32, 32, 32, 32, 65, 68, 82, 85, 10, 48, 48, 48, 48,   /* 0x26a0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x26b0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51,101, 32, 82, 95, 88,   /* 0x26b0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x26c0 */
+ 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65,   /* 0x26c0 */
- 48, 48, 49, 54,102,101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x26d0 */
+ 68, 82, 67, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x26d0 */
- 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82,   /* 0x26e0 */
+ 48, 48, 52, 51, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50,   /* 0x26e0 */
- 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 49, 32, 69, 76, 70, 77,   /* 0x26f0 */
+ 32, 32, 32, 32, 32, 32, 32, 76, 69, 78, 85, 10, 48, 48, 48, 48,   /* 0x26f0 */
- 65, 73, 78, 90, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x2700 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 52, 56, 32, 82, 95, 88,   /* 0x2700 */
- 56, 99, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2710 */
+ 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65,   /* 0x2710 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2720 */
+ 68, 82, 88, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2720 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 49, 55, 51, 56,   /* 0x2730 */
+ 48, 48, 50,102, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67,   /* 0x2730 */
- 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x2740 */
+ 51, 50, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43,   /* 0x2740 */
- 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x2750 */
+ 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2750 */
- 89, 10, 83, 89, 77, 66, 79, 76, 32, 84, 65, 66, 76, 69, 58, 10,   /* 0x2760 */
+ 48,100, 10                                                        /* 0x2760 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2770 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 95, 72, 69, 65,   /* 0x2780 */
- 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2790 */
- 48, 48, 32, 78, 82, 86, 95, 72, 69, 65, 68, 10, 48, 48, 48, 48,   /* 0x27a0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x27b0 */
- 32, 32,100, 32, 32, 76, 90, 77, 65, 95, 68, 69, 67, 51, 48,  9,   /* 0x27c0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x27d0 */
- 32, 76, 90, 77, 65, 95, 68, 69, 67, 51, 48, 10, 48, 48, 48, 48,   /* 0x27e0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x27f0 */
- 32, 32,100, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89,  9, 48, 48,   /* 0x2800 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69,   /* 0x2810 */
- 76, 70, 77, 65, 73, 78, 89, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2820 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x2830 */
- 32, 69, 76, 70, 77, 65, 73, 78, 90,  9, 48, 48, 48, 48, 48, 48,   /* 0x2840 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69, 76, 70, 77, 65,   /* 0x2850 */
- 73, 78, 90, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2860 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 69, 76, 70,   /* 0x2870 */
- 77, 65, 73, 78, 88,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2880 */
- 48, 48, 48, 48, 48, 48, 32, 69, 76, 70, 77, 65, 73, 78, 88, 10,   /* 0x2890 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x28a0 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 50, 69,  9, 48,   /* 0x28b0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x28c0 */
- 78, 82, 86, 50, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x28d0 */
- 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78,   /* 0x28e0 */
- 82, 86, 50, 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x28f0 */
- 48, 48, 48, 48, 48, 32, 78, 82, 86, 50, 68, 10, 48, 48, 48, 48,   /* 0x2900 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x2910 */
- 32, 32,100, 32, 32, 78, 82, 86, 50, 66,  9, 48, 48, 48, 48, 48,   /* 0x2920 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 50,   /* 0x2930 */
- 66, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2940 */
- 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90, 77, 65, 95,   /* 0x2950 */
- 69, 76, 70, 48, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2960 */
- 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 69, 76, 70, 48,   /* 0x2970 */
- 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2980 */
- 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90, 77, 65, 95,   /* 0x2990 */
- 68, 69, 67, 49, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x29a0 */
- 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 49,   /* 0x29b0 */
- 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x29c0 */
- 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90, 77, 65, 95,   /* 0x29d0 */
- 68, 69, 67, 50, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x29e0 */
- 48, 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 50,   /* 0x29f0 */
- 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2a00 */
- 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 95, 84,   /* 0x2a10 */
- 65, 73, 76,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2a20 */
- 48, 48, 48, 48, 32, 78, 82, 86, 95, 84, 65, 73, 76, 10, 48, 48,   /* 0x2a30 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32,103,   /* 0x2a40 */
- 32, 32, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 88,  9,   /* 0x2a50 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2a60 */
- 32, 95,115,116, 97,114,116, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2a70 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2a80 */
- 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2a90 */
- 48, 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 77, 10, 48, 48, 48,   /* 0x2aa0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32,   /* 0x2ab0 */
- 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48,   /* 0x2ac0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 76, 69, 78,   /* 0x2ad0 */
- 77, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2ae0 */
- 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,   /* 0x2af0 */
-  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2b00 */
- 48, 32, 74, 77, 80, 85, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2b10 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2b20 */
- 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2b30 */
- 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 85, 10, 48, 48, 48, 48,   /* 0x2b40 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32,   /* 0x2b50 */
- 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48,   /* 0x2b60 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 32, 65, 68, 82, 67,   /* 0x2b70 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2b80 */
- 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x2b90 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2ba0 */
- 32, 76, 69, 78, 85, 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2bb0 */
- 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42,   /* 0x2bc0 */
- 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2bd0 */
- 48, 48, 48, 48, 48, 32, 65, 68, 82, 88, 10, 10, 82, 69, 76, 79,   /* 0x2be0 */
- 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70,   /* 0x2bf0 */
- 79, 82, 32, 91, 69, 76, 70, 77, 65, 73, 78, 88, 93, 58, 10, 79,   /* 0x2c00 */
- 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2c10 */
- 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2c20 */
- 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2c30 */
- 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x2c40 */
- 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65,   /* 0x2c50 */
- 73, 78, 90, 43, 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2c60 */
- 48, 48, 48, 48, 55, 55, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73,   /* 0x2c70 */
- 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91,   /* 0x2c80 */
- 78, 82, 86, 50, 69, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32,   /* 0x2c90 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x2ca0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x2cb0 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 97,   /* 0x2cc0 */
-101, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32,   /* 0x2cd0 */
- 32, 32, 32, 32, 78, 82, 86, 95, 72, 69, 65, 68, 43, 48,120, 48,   /* 0x2ce0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 50, 49, 10,   /* 0x2cf0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 53, 98,   /* 0x2d00 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32,   /* 0x2d10 */
- 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43, 48,120,102,102,   /* 0x2d20 */
-102,102,102,102,102,102,102,102,102,102,102,102,102, 99, 10, 10,   /* 0x2d30 */
- 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x2d40 */
- 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 50, 68, 93, 58, 10,   /* 0x2d50 */
- 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2d60 */
- 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2d70 */
- 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x2d80 */
- 48, 48, 48, 48, 48, 48, 48, 57, 53, 32, 82, 95, 88, 56, 54, 95,   /* 0x2d90 */
- 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 78, 82, 86, 95,   /* 0x2da0 */
- 72, 69, 65, 68, 43, 48,120, 48, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2db0 */
- 48, 48, 48, 48, 48, 50, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2dc0 */
- 48, 48, 48, 48, 48, 48, 53, 98, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x2dd0 */
- 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 69, 76, 70, 77, 65,   /* 0x2de0 */
- 73, 78, 89, 43, 48,120,102,102,102,102,102,102,102,102,102,102,   /* 0x2df0 */
-102,102,102,102,102, 99, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73,   /* 0x2e00 */
- 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91,   /* 0x2e10 */
- 78, 82, 86, 50, 66, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32,   /* 0x2e20 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x2e30 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x2e40 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 56,   /* 0x2e50 */
- 97, 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32,   /* 0x2e60 */
- 32, 32, 32, 32, 78, 82, 86, 95, 72, 69, 65, 68, 43, 48,120, 48,   /* 0x2e70 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 50, 49, 10,   /* 0x2e80 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 53, 50,   /* 0x2e90 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32,   /* 0x2ea0 */
- 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43, 48,120,102,102,   /* 0x2eb0 */
-102,102,102,102,102,102,102,102,102,102,102,102,102, 99, 10, 10,   /* 0x2ec0 */
- 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x2ed0 */
- 68, 83, 32, 70, 79, 82, 32, 91, 76, 90, 77, 65, 95, 69, 76, 70,   /* 0x2ee0 */
- 48, 48, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32,   /* 0x2ef0 */
- 32, 32, 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32,   /* 0x2f00 */
- 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48,   /* 0x2f10 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 54, 32, 82,   /* 0x2f20 */
- 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32,   /* 0x2f30 */
- 32, 76, 90, 77, 65, 95, 68, 69, 67, 51, 48, 43, 48,120, 48, 48,   /* 0x2f40 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 48, 10, 10,   /* 0x2f50 */
- 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x2f60 */
- 68, 83, 32, 70, 79, 82, 32, 91, 69, 76, 70, 77, 65, 73, 78, 89,   /* 0x2f70 */
- 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32,   /* 0x2f80 */
- 32, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2f90 */
- 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48,   /* 0x2fa0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 56, 32, 82, 95, 88,   /* 0x2fb0 */
- 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32, 32, 32, 32, 69,   /* 0x2fc0 */
- 76, 70, 77, 65, 73, 78, 90, 43, 48,120,102,102,102,102,102,102,   /* 0x2fd0 */
-102,102,102,102,102,102,102,102,102, 99, 10, 10, 82, 69, 76, 79,   /* 0x2fe0 */
- 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70,   /* 0x2ff0 */
- 79, 82, 32, 91, 69, 76, 70, 77, 65, 73, 78, 90, 93, 58, 10, 79,   /* 0x3000 */
- 70, 70, 83, 69, 84, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x3010 */
- 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x3020 */
- 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x3030 */
- 48, 48, 48, 48, 48, 48, 49, 51, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x3040 */
- 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65, 68, 82, 77, 10,   /* 0x3050 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 49, 98,   /* 0x3060 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32,   /* 0x3070 */
- 32, 32, 32, 76, 69, 78, 77, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x3080 */
- 48, 48, 48, 48, 48, 48, 51, 52, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x3090 */
- 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 74, 77, 80, 85, 10,   /* 0x30a0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51, 57,   /* 0x30b0 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32,   /* 0x30c0 */
- 32, 32, 32, 65, 68, 82, 85, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x30d0 */
- 48, 48, 48, 48, 48, 48, 51,101, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x30e0 */
- 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65, 68, 82, 67, 10,   /* 0x30f0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 52, 51,   /* 0x3100 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 51, 50, 32, 32, 32, 32,   /* 0x3110 */
- 32, 32, 32, 76, 69, 78, 85, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x3120 */
- 48, 48, 48, 48, 48, 48, 52, 56, 32, 82, 95, 88, 56, 54, 95, 54,   /* 0x3130 */
- 52, 95, 51, 50, 32, 32, 32, 32, 32, 32, 32, 65, 68, 82, 88, 10,   /* 0x3140 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 50,102,   /* 0x3150 */
- 32, 82, 95, 88, 56, 54, 95, 54, 52, 95, 80, 67, 51, 50, 32, 32,   /* 0x3160 */
- 32, 32, 32, 69, 76, 70, 77, 65, 73, 78, 89, 43, 48,120, 48, 48,   /* 0x3170 */
- 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,100, 10        /* 0x3180 */
 };

src/stub/amd64-linux.elf-fold.h

@@ -1,4 +1,5 @@
-/* amd64-linux.elf-fold.h -- created from amd64-linux.elf-fold.bin, 1775 (0x6ef) bytes
+/* amd64-linux.elf-fold.h
+   created from amd64-linux.elf-fold.bin, 1775 (0x6ef) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_ELF64AMD_FOLD_SIZE    1775
+#define STUB_AMD64_LINUX_ELF_FOLD_SIZE    1775
-#define LINUX_ELF64AMD_FOLD_ADLER32 0x8871a9cc
+#define STUB_AMD64_LINUX_ELF_FOLD_ADLER32 0x8871a9cc
-#define LINUX_ELF64AMD_FOLD_CRC32   0x5856b332
+#define STUB_AMD64_LINUX_ELF_FOLD_CRC32   0x5856b332
 
-unsigned char linux_elf64amd_fold[1775] = {
+unsigned char stub_amd64_linux_elf_fold[1775] = {
 127, 69, 76, 70,  2,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   2,  0, 62,  0,  1,  0,  0,  0,188,  0, 16,  0,  0,  0,  0,  0,   /* 0x  10 */
  64,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  20 */

src/stub/arm-linux.elf-fold.h

@@ -1,4 +1,5 @@
-/* arm-linux.elf-fold.h -- created from arm-linux.elf-fold.bin, 2108 (0x83c) bytes
+/* arm-linux.elf-fold.h
+   created from arm-linux.elf-fold.bin, 2108 (0x83c) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_ELF32ARM_FOLD_SIZE    2108
+#define STUB_ARM_LINUX_ELF_FOLD_SIZE    2108
-#define LINUX_ELF32ARM_FOLD_ADLER32 0x3e40608e
+#define STUB_ARM_LINUX_ELF_FOLD_ADLER32 0x3e40608e
-#define LINUX_ELF32ARM_FOLD_CRC32   0xb5be5c29
+#define STUB_ARM_LINUX_ELF_FOLD_CRC32   0xb5be5c29
 
-unsigned char linux_elf32arm_fold[2108] = {
+unsigned char stub_arm_linux_elf_fold[2108] = {
 127, 69, 76, 70,  1,  1,  1, 97,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   2,  0, 40,  0,  1,  0,  0,  0,128,128,  0,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  2,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/arm.v4t-wince.pe.h

@@ -1,4 +1,5 @@
-/* arm.v4t-wince.pe.h -- created from arm.v4t-wince.pe.bin, 9992 (0x2708) bytes
+/* arm.v4t-wince.pe.h
+   created from arm.v4t-wince.pe.bin, 7572 (0x1d94) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define NRV_LOADER_THUMB_SIZE    9992
+#define STUB_ARM_V4T_WINCE_PE_SIZE    7572
-#define NRV_LOADER_THUMB_ADLER32 0xfeadf935
+#define STUB_ARM_V4T_WINCE_PE_ADLER32 0x69a1fef0
-#define NRV_LOADER_THUMB_CRC32   0x7cc8eae9
+#define STUB_ARM_V4T_WINCE_PE_CRC32   0x0bf18823
 
-unsigned char nrv_loader_thumb[9992] = {
+unsigned char stub_arm_v4t_wince_pe[7572] = {
 127, 69, 76, 70,  1,  1,  1, 97,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   1,  0, 40,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  10 */
 132, 11,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,  0,  0, 40,  0,   /* 0x  20 */
@@ -202,459 +203,308 @@ unsigned char nrv_loader_thumb[9992] = {
 241,209,  7,146,  7,152, 37,154,144, 66,  0,210,175,228,  9, 75,   /* 0x a70 */
 153, 66,  3,216, 16,155,157, 66,  9,208,  1, 53,  4,152,  3,153,   /* 0x a80 */
  43, 26, 11, 96,  7,154, 38,155,  0, 32, 26, 96,  0,224,  1, 32,   /* 0x a90 */
- 31,176,240,189,255,255,255,  0,  0, 46,115,121,109,116, 97, 98,   /* 0x aa0 */
+ 31,176,240,189,255,255,255,  0,116,109,112, 47, 97,114,109, 46,   /* 0x aa0 */
-  0, 46,115,116,114,116, 97, 98,  0, 46,115,104,115,116,114,116,   /* 0x ab0 */
+118, 52,116, 45,119,105,110, 99,101, 46,112,101, 46, 98,105,110,   /* 0x ab0 */
- 97, 98,  0, 46,114,101,108, 68,108,108, 83,116, 97,114,116,  0,   /* 0x ac0 */
+ 58, 32, 32, 32, 32, 32,102,105,108,101, 32,102,111,114,109, 97,   /* 0x ac0 */
- 46,114,101,108, 69,120,101, 83,116, 97,114,116,  0, 46,114,101,   /* 0x ad0 */
+116, 32,101,108,102, 51, 50, 45,108,105,116,116,108,101, 97,114,   /* 0x ad0 */
-108, 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48,  0, 46,   /* 0x ae0 */
+109, 10, 10, 83,101, 99,116,105,111,110,115, 58, 10, 73,100,120,   /* 0x ae0 */
-114,101,108, 82,101,108,111, 99,115,  0, 46,114,101,108, 73,109,   /* 0x af0 */
+ 32, 78, 97,109,101, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 83,   /* 0x af0 */
-112,111,114,116,115,  0, 80,114,111, 99,101,115,115, 69,110,100,   /* 0x b00 */
+105,122,101, 32, 32, 32, 32, 32, 32, 86, 77, 65, 32, 32, 32, 32,   /* 0x b00 */
-  0, 85, 80, 88, 49, 72, 69, 65, 68,  0, 46,117, 99,108, 95,110,   /* 0x b10 */
+ 32, 32, 32, 76, 77, 65, 32, 32, 32, 32, 32, 32, 32, 70,105,108,   /* 0x b10 */
-114,118, 50, 98, 95,100,101, 99,111,109,112,114,101,115,115, 95,   /* 0x b20 */
+101, 32,111,102,102, 32, 32, 65,108,103,110, 32, 32, 70,108, 97,   /* 0x b20 */
- 56,  0, 46,114,101,108, 67, 97,108,108, 50, 66,  0, 46,117, 99,   /* 0x b30 */
+103,115, 10, 32, 32, 48, 32, 68,108,108, 83,116, 97,114,116, 32,   /* 0x b30 */
-108, 95,110,114,118, 50,101, 95,100,101, 99,111,109,112,114,101,   /* 0x b40 */
+ 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 56, 32, 32, 48,   /* 0x b40 */
-115,115, 95, 56,  0, 46,114,101,108, 67, 97,108,108, 50, 69,  0,   /* 0x b50 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x b50 */
- 46,114,101,108, 67, 97,108,108, 76, 90, 77, 65,  0, 76, 90, 77,   /* 0x b60 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 51, 52, 32, 32, 50, 42, 42,   /* 0x b60 */
- 65, 95, 68, 69, 67, 79, 68, 69,  0, 76, 90, 77, 65, 95, 68, 69,   /* 0x b70 */
+ 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76,   /* 0x b70 */
- 67, 49, 48,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b80 */
+ 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 49,   /* 0x b80 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b90 */
+ 32, 69,120,101, 83,116, 97,114,116, 32, 32, 32, 32, 32, 32, 48,   /* 0x b90 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 31,  0,  0,  0,   /* 0x ba0 */
+ 48, 48, 48, 48, 48, 54, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x ba0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,   /* 0x bb0 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x bb0 */
-  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x bc0 */
+ 48, 48, 48, 51, 99, 32, 32, 50, 42, 42, 49, 32, 32, 67, 79, 78,   /* 0x bc0 */
-  0,  0,  0,  0, 27,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x bd0 */
+ 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69,   /* 0x bd0 */
-  0,  0,  0,  0,100, 19,  0,  0,  8,  0,  0,  0, 24,  0,  0,  0,   /* 0x be0 */
+ 65, 68, 79, 78, 76, 89, 10, 32, 32, 50, 32, 85,110,102,105,108,   /* 0x be0 */
-  1,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0,   /* 0x bf0 */
+116,101,114, 95, 48,120, 53, 48, 32, 48, 48, 48, 48, 48, 48, 51,   /* 0x bf0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 60,  0,  0,  0,   /* 0x c00 */
+ 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x c00 */
-100,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  2,  0,  0,  0,   /* 0x c10 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 97, 48, 32,   /* 0x c10 */
-  0,  0,  0,  0, 40,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x c20 */
+ 32, 50, 42, 42, 50, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x c20 */
-  0,  0,  0,  0,108, 19,  0,  0, 48,  0,  0,  0, 24,  0,  0,  0,   /* 0x c30 */
+ 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x c30 */
-  3,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0, 57,  0,  0,  0,   /* 0x c40 */
+ 10, 32, 32, 51, 32, 82,101,108,111, 99,115, 32, 32, 32, 32, 32,   /* 0x c40 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,160,  0,  0,  0,   /* 0x c50 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 52, 48, 32, 32, 48, 48, 48,   /* 0x c50 */
- 56,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  0,  0,  0,   /* 0x c60 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x c60 */
-  0,  0,  0,  0, 53,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x c70 */
+ 32, 48, 48, 48, 48, 48, 48,100, 56, 32, 32, 50, 42, 42, 50, 32,   /* 0x c70 */
-  0,  0,  0,  0,156, 19,  0,  0, 16,  0,  0,  0, 24,  0,  0,  0,   /* 0x c80 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67,   /* 0x c80 */
-  5,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0, 75,  0,  0,  0,   /* 0x c90 */
+ 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 52, 32, 73,   /* 0x c90 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,216,  0,  0,  0,   /* 0x ca0 */
+109,112,111,114,116,115, 32, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x ca0 */
- 64,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  0,  0,  0,   /* 0x cb0 */
+ 48, 48, 48, 56, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x cb0 */
-  0,  0,  0,  0, 71,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x cc0 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x cc0 */
-  0,  0,  0,  0,172, 19,  0,  0,  8,  0,  0,  0, 24,  0,  0,  0,   /* 0x cd0 */
+ 49, 49, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x cd0 */
-  7,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0, 86,  0,  0,  0,   /* 0x ce0 */
+ 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68,   /* 0x ce0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,  1,  0,  0,   /* 0x cf0 */
+ 79, 78, 76, 89, 10, 32, 32, 53, 32, 80,114,111, 99,101,115,115,   /* 0x cf0 */
-130,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x d00 */
+ 69,110,100, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 56, 32,   /* 0x d00 */
-  0,  0,  0,  0, 82,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x d10 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x d10 */
-  0,  0,  0,  0,180, 19,  0,  0, 48,  0,  0,  0, 24,  0,  0,  0,   /* 0x d20 */
+ 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 57, 97, 32, 32, 50,   /* 0x d20 */
-  9,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0, 94,  0,  0,  0,   /* 0x d30 */
+ 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x d30 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,154,  1,  0,  0,   /* 0x d40 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 54, 32, 85, 80, 88, 49,   /* 0x d40 */
-  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x d50 */
+ 72, 69, 65, 68, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x d50 */
-  0,  0,  0,  0,105,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x d60 */
+ 50, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x d60 */
-  0,  0,  0,  0,162,  1,  0,  0, 32,  0,  0,  0,  0,  0,  0,  0,   /* 0x d70 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 97, 50,   /* 0x d70 */
-  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,114,  0,  0,  0,   /* 0x d80 */
+ 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x d80 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,194,  1,  0,  0,   /* 0x d90 */
+ 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 55, 32, 46,   /* 0x d90 */
-152,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x da0 */
+117, 99,108, 95,110,114,118, 50, 98, 95,100,101, 99,111,109,112,   /* 0x da0 */
-  0,  0,  0,  0,142,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x db0 */
+114,101,115,115, 95, 56, 32, 48, 48, 48, 48, 48, 48, 57, 56, 32,   /* 0x db0 */
-  0,  0,  0,  0, 90,  2,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0,   /* 0x dc0 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x dc0 */
-  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,138,  0,  0,  0,   /* 0x dd0 */
+ 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 99, 50, 32, 32, 50,   /* 0x dd0 */
-  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,228, 19,  0,  0,   /* 0x de0 */
+ 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x de0 */
-  8,  0,  0,  0, 24,  0,  0,  0, 14,  0,  0,  0,  4,  0,  0,  0,   /* 0x df0 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 56, 32, 67, 97,108,108,   /* 0x df0 */
-  8,  0,  0,  0,149,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x e00 */
+ 50, 66, 32, 32, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x e00 */
-  0,  0,  0,  0, 94,  2,  0,  0,178,  0,  0,  0,  0,  0,  0,  0,   /* 0x e10 */
+ 48, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x e10 */
-  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,177,  0,  0,  0,   /* 0x e20 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 50, 53, 97,   /* 0x e20 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16,  3,  0,  0,   /* 0x e30 */
+ 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x e30 */
-  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x e40 */
+ 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x e40 */
-  0,  0,  0,  0,173,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x e50 */
+ 89, 10, 32, 32, 57, 32, 46,117, 99,108, 95,110,114,118, 50,101,   /* 0x e50 */
-  0,  0,  0,  0,236, 19,  0,  0,  8,  0,  0,  0, 24,  0,  0,  0,   /* 0x e60 */
+ 95,100,101, 99,111,109,112,114,101,115,115, 95, 56, 32, 48, 48,   /* 0x e60 */
- 17,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,188,  0,  0,  0,   /* 0x e70 */
+ 48, 48, 48, 48, 98, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x e70 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 20,  3,  0,  0,   /* 0x e80 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x e80 */
- 52,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  4,  0,  0,  0,   /* 0x e90 */
+ 48, 50, 53,101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x e90 */
-  0,  0,  0,  0,184,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,   /* 0x ea0 */
+ 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x ea0 */
-  0,  0,  0,  0,244, 19,  0,  0, 40,  0,  0,  0, 24,  0,  0,  0,   /* 0x eb0 */
+ 49, 48, 32, 67, 97,108,108, 50, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x eb0 */
- 19,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,197,  0,  0,  0,   /* 0x ec0 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 52, 32, 32, 48, 48, 48, 48, 48,   /* 0x ec0 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 72,  3,  0,  0,   /* 0x ed0 */
+ 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x ed0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x ee0 */
+ 48, 48, 48, 48, 51, 49, 48, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x ee0 */
-  0,  0,  0,  0,209,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x ef0 */
+ 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32,   /* 0x ef0 */
-  0,  0,  0,  0, 72,  3,  0,  0, 96,  7,  0,  0,  0,  0,  0,  0,   /* 0x f00 */
+ 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 49, 32, 67, 97,108,   /* 0x f00 */
-  0,  0,  0,  0,  4,  0,  0,  0,  0,  0,  0,  0, 17,  0,  0,  0,   /* 0x f10 */
+108, 76, 90, 77, 65, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x f10 */
-  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,168, 10,  0,  0,   /* 0x f20 */
+ 48, 51, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x f20 */
-220,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x f30 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 51, 49,   /* 0x f30 */
-  0,  0,  0,  0,  1,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,   /* 0x f40 */
+ 52, 32, 32, 50, 42, 42, 50, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x f40 */
-  0,  0,  0,  0,148, 15,  0,  0,128,  2,  0,  0, 25,  0,  0,  0,   /* 0x f50 */
+ 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x f50 */
- 17,  0,  0,  0,  4,  0,  0,  0, 16,  0,  0,  0,  9,  0,  0,  0,   /* 0x f60 */
+ 76, 89, 10, 32, 49, 50, 32, 76, 90, 77, 65, 95, 68, 69, 67, 79,   /* 0x f60 */
-  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 20, 18,  0,  0,   /* 0x f70 */
+ 68, 69, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x f70 */
- 79,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,   /* 0x f80 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x f80 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x f90 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 51, 52, 56, 32, 32, 50, 42, 42,   /* 0x f90 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x fa0 */
+ 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65,   /* 0x fa0 */
-  3,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x fb0 */
+ 68, 79, 78, 76, 89, 10, 32, 49, 51, 32, 76, 90, 77, 65, 95, 68,   /* 0x fb0 */
- 15,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x fc0 */
+ 69, 67, 49, 48, 32, 32, 32, 32, 48, 48, 48, 48, 48, 55, 54, 48,   /* 0x fc0 */
-  3,  0, 13,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x fd0 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x fd0 */
-  3,  0, 16,  0, 23,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x fe0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 51, 52, 56, 32, 32,   /* 0x fe0 */
- 15,  0, 21,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x ff0 */
+ 50, 42, 42, 50, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x ff0 */
-  3,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1000 */
+ 82, 69, 65, 68, 79, 78, 76, 89, 10, 83, 89, 77, 66, 79, 76, 32,   /* 0x1000 */
-  3,  0,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1010 */
+ 84, 65, 66, 76, 69, 58, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1010 */
-  3,  0,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1020 */
+108, 32, 32, 32, 32,100, 32, 32, 69,120,101, 83,116, 97,114,116,   /* 0x1020 */
-  3,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1030 */
+  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69,120,101, 83,116, 97,   /* 0x1030 */
-  3,  0, 11,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1040 */
+114,116, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1040 */
-  3,  0, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1050 */
+ 32, 32, 32, 32, 73,109,112,111,114,116,115,  9, 48, 48, 48, 48,   /* 0x1050 */
-  3,  0, 14,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1060 */
+ 48, 48, 48, 48, 32, 46,114,101, 97,108, 95,115,116, 97,114,116,   /* 0x1060 */
-  3,  0, 17,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1070 */
+ 95,111,102, 73,109,112,111,114,116,115, 10, 48, 48, 48, 48, 48,   /* 0x1070 */
-  3,  0, 19,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1080 */
+ 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 46,117, 99,108,   /* 0x1080 */
-  3,  0, 21,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1090 */
+ 95,110,114,118, 50, 98, 95,100,101, 99,111,109,112,114,101,115,   /* 0x1090 */
-  3,  0, 22,  0, 49,  0,  0,  0, 56,  0,  0,  0,  0,  0,  0,  0,   /* 0x10a0 */
+115, 95, 56,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 46,117, 99,   /* 0x10a0 */
- 16,  0,  3,  0, 54,  0,  0,  0, 64,  0,  0,  0,  0,  0,  0,  0,   /* 0x10b0 */
+108, 95,110,114,118, 50, 98, 95,100,101, 99,111,109,112,114,101,   /* 0x10b0 */
- 16,  0,  3,  0, 59,  0,  0,  0, 72,  0,  0,  0,  0,  0,  0,  0,   /* 0x10c0 */
+115,115, 95, 56, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32,   /* 0x10c0 */
- 16,  0,  3,  0, 64,  0,  0,  0, 88,  0,  0,  0,  0,  0,  0,  0,   /* 0x10d0 */
+ 32, 32, 32,100, 32, 32, 46,117, 99,108, 95,110,114,118, 50,101,   /* 0x10d0 */
- 16,  0,  3,  0, 69,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x10e0 */
+ 95,100,101, 99,111,109,112,114,101,115,115, 95, 56,  9, 48, 48,   /* 0x10e0 */
- 16,  0,  0,  0, 89,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x10f0 */
+ 48, 48, 48, 48, 48, 48, 32, 46,117, 99,108, 95,110,114,118, 50,   /* 0x10f0 */
- 16,  0,  0,  0,107,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1100 */
+101, 95,100,101, 99,111,109,112,114,101,115,115, 95, 56, 10, 48,   /* 0x1100 */
- 16,  0,  0,  0,129,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1110 */
+ 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32, 32, 32, 32,   /* 0x1110 */
- 16,  0,  0,  0,149,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1120 */
+ 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69,  9, 48, 48, 48, 48,   /* 0x1120 */
- 16,  0,  0,  0,164,  0,  0,  0, 48,  0,  0,  0,  0,  0,  0,  0,   /* 0x1130 */
+ 48, 48, 48, 48, 32, 46,114,101, 97,108, 95,115,116, 97,114,116,   /* 0x1130 */
- 31,  0,  5,  0,169,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1140 */
+ 95,111,102, 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69, 10, 48,   /* 0x1140 */
- 16,  0,  0,  0,189,  0,  0,  0, 52,  0,  0,  0,  0,  0,  0,  0,   /* 0x1150 */
+ 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x1150 */
- 31,  0,  5,  0,194,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1160 */
+ 68,108,108, 83,116, 97,114,116,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x1160 */
- 16,  0,  0,  0,212,  0,  0,  0, 60,  0,  0,  0,  0,  0,  0,  0,   /* 0x1170 */
+ 48, 32, 68,108,108, 83,116, 97,114,116, 10, 48, 48, 48, 48, 48,   /* 0x1170 */
- 31,  0,  7,  0,217,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1180 */
+ 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 85,110,102,105,   /* 0x1180 */
- 16,  0,  0,  0,233,  0,  0,  0,120,  0,  0,  0,  0,  0,  0,  0,   /* 0x1190 */
+108,116,101,114, 95, 48,120, 53, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1190 */
- 31,  0,  9,  0,238,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x11a0 */
+ 48, 48, 32, 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48,   /* 0x11a0 */
- 16,  0,  0,  0,255,  0,  0,  0,124,  0,  0,  0,  0,  0,  0,  0,   /* 0x11b0 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100,   /* 0x11b0 */
- 31,  0,  9,  0,  4,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x11c0 */
+ 32, 32, 82,101,108,111, 99,115,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x11c0 */
- 16,  0,  0,  0, 23,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x11d0 */
+ 48, 32, 82,101,108,111, 99,115, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x11d0 */
- 16,  0,  0,  0, 34,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x11e0 */
+ 48, 32,108, 32, 32, 32, 32,100, 32, 32, 73,109,112,111,114,116,   /* 0x11e0 */
- 16,  0,  0,  0, 52,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x11f0 */
+115,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 73,109,112,111,114,   /* 0x11f0 */
- 16,  0,  0,  0, 63,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x1200 */
+116,115, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1200 */
- 16,  0,  0,  0,  0, 46,114,101, 97,108, 95,115,116, 97,114,116,   /* 0x1210 */
+ 32,100, 32, 32, 80,114,111, 99,101,115,115, 69,110,100,  9, 48,   /* 0x1210 */
- 95,111,102, 73,109,112,111,114,116,115,  0, 46,114,101, 97,108,   /* 0x1220 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 80,114,111, 99,101,115,115, 69,   /* 0x1220 */
- 95,115,116, 97,114,116, 95,111,102, 76, 90, 77, 65, 95, 68, 69,   /* 0x1230 */
+110,100, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1230 */
- 67, 79, 68, 69,  0, 83, 82, 67, 48,  0, 68, 83, 84, 48,  0, 73,   /* 0x1240 */
+ 32,100, 32, 32, 85, 80, 88, 49, 72, 69, 65, 68,  9, 48, 48, 48,   /* 0x1240 */
- 65, 84, 84,  0, 69, 78, 84, 82,  0,115,116, 97,114,116, 95,111,   /* 0x1250 */
+ 48, 48, 48, 48, 48, 32, 85, 80, 88, 49, 72, 69, 65, 68, 10, 48,   /* 0x1250 */
-102, 95, 99,111,109,112,114,101,115,115,101,100,  0, 99,111,109,   /* 0x1260 */
+ 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x1260 */
-112,114,101,115,115,101,100, 95,108,101,110,103,116,104,  0,115,   /* 0x1270 */
+ 67, 97,108,108, 50, 66,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1270 */
-116, 97,114,116, 95,111,102, 95,117,110, 99,111,109,112,114,101,   /* 0x1280 */
+ 67, 97,108,108, 50, 66, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1280 */
-115,115,101,100,  0,117,110, 99,111,109,112,114,101,115,115,101,   /* 0x1290 */
+108, 32, 32, 32, 32,100, 32, 32, 67, 97,108,108, 50, 69,  9, 48,   /* 0x1290 */
-100, 95,108,101,110,103,116,104,  0,111,114,105,103,105,110, 97,   /* 0x12a0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 67, 97,108,108, 50, 69, 10, 48,   /* 0x12a0 */
-108, 95,101,110,116,114,121,  0, 70, 73, 66, 83,  0,102,105,108,   /* 0x12b0 */
+ 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x12b0 */
-116,101,114, 95, 98,117,102,102,101,114, 95,115,116, 97,114,116,   /* 0x12c0 */
+ 67, 97,108,108, 76, 90, 77, 65,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x12c0 */
-  0, 70, 73, 66, 69,  0,102,105,108,116,101,114, 95, 98,117,102,   /* 0x12d0 */
+ 48, 32, 67, 97,108,108, 76, 90, 77, 65, 10, 48, 48, 48, 48, 48,   /* 0x12d0 */
-102,101,114, 95,101,110,100,  0, 66, 82, 69, 76,  0,115,116, 97,   /* 0x12e0 */
+ 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90, 77, 65,   /* 0x12e0 */
-114,116, 95,111,102, 95,114,101,108,111, 99,115,  0, 66, 73, 77,   /* 0x12f0 */
+ 95, 68, 69, 67, 79, 68, 69,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x12f0 */
- 80,  0,115,116, 97,114,116, 95,111,102, 95,105,109,112,111,114,   /* 0x1300 */
+ 32, 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69, 10, 48, 48, 48,   /* 0x1300 */
-116,115,  0, 79, 78, 65, 77,  0,115,116, 97,114,116, 95,111,102,   /* 0x1310 */
+ 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 76, 90,   /* 0x1310 */
- 95,100,108,108, 95,110, 97,109,101,115,  0,108,122,109, 97, 95,   /* 0x1320 */
+ 77, 65, 95, 68, 69, 67, 49, 48,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x1320 */
-117, 95,108,101,110,  0,108,122,109, 97, 95,115,116, 97, 99,107,   /* 0x1330 */
+ 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 49, 48, 10, 48, 48, 48,   /* 0x1330 */
- 95, 97,100,106,117,115,116,  0,108,122,109, 97, 95, 99, 95,108,   /* 0x1340 */
+ 48, 48, 48, 51, 56, 32,103, 32, 32, 32, 32, 32, 32, 32, 69,120,   /* 0x1340 */
-101,110,  0,108,122,109, 97, 95,112,114,111,112,101,114,116,105,   /* 0x1350 */
+101, 83,116, 97,114,116,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1350 */
-101,115,  0,  0,  4,  0,  0,  0,  1,  1,  0,  0, 28,  0,  0,  0,   /* 0x1360 */
+ 83, 82, 67, 48, 10, 48, 48, 48, 48, 48, 48, 52, 48, 32,103, 32,   /* 0x1360 */
-  1,  1,  0,  0, 56,  0,  0,  0,  2, 21,  0,  0, 60,  0,  0,  0,   /* 0x1370 */
+ 32, 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,114,116,  9, 48,   /* 0x1370 */
-  2, 22,  0,  0, 64,  0,  0,  0,  2, 23,  0,  0, 68,  0,  0,  0,   /* 0x1380 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 68, 83, 84, 48, 10, 48, 48, 48,   /* 0x1380 */
-  2, 24,  0,  0, 88,  0,  0,  0,  2, 25,  0,  0, 48,  0,  0,  0,   /* 0x1390 */
+ 48, 48, 48, 52, 56, 32,103, 32, 32, 32, 32, 32, 32, 32, 69,120,   /* 0x1390 */
-  2, 27,  0,  0, 52,  0,  0,  0,  2, 29,  0,  0, 60,  0,  0,  0,   /* 0x13a0 */
+101, 83,116, 97,114,116,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x13a0 */
-  2, 31,  0,  0, 14,  0,  0,  0, 10,  2,  0,  0, 40,  0,  0,  0,   /* 0x13b0 */
+ 73, 65, 84, 84, 10, 48, 48, 48, 48, 48, 48, 53, 56, 32,103, 32,   /* 0x13b0 */
- 10,  2,  0,  0, 48,  0,  0,  0, 10,  2,  0,  0, 92,  0,  0,  0,   /* 0x13c0 */
+ 32, 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,114,116,  9, 48,   /* 0x13c0 */
- 10,  2,  0,  0,120,  0,  0,  0,  2, 33,  0,  0,124,  0,  0,  0,   /* 0x13d0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 69, 78, 84, 82, 10, 48, 48, 48,   /* 0x13d0 */
-  2, 35,  0,  0,  0,  0,  0,  0, 10,  3,  0,  0,  0,  0,  0,  0,   /* 0x13e0 */
+ 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x13e0 */
- 10,  4,  0,  0, 28,  0,  0,  0, 10,  5,  0,  0, 36,  0,  0,  0,   /* 0x13f0 */
+ 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,115,116, 97,   /* 0x13f0 */
-  2, 36,  0,  0, 40,  0,  0,  0,  2, 37,  0,  0, 44,  0,  0,  0,   /* 0x1400 */
+114,116, 95,111,102, 95, 99,111,109,112,114,101,115,115,101,100,   /* 0x1400 */
-  2, 38,  0,  0, 48,  0,  0,  0,  2, 39,  0,  0,116,109,112, 47,   /* 0x1410 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32,   /* 0x1410 */
- 97,114,109, 46,118, 52,116, 45,119,105,110, 99,101, 46,112,101,   /* 0x1420 */
+ 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1420 */
- 46, 98,105,110, 58, 32, 32, 32, 32, 32,102,105,108,101, 32,102,   /* 0x1430 */
+ 32, 99,111,109,112,114,101,115,115,101,100, 95,108,101,110,103,   /* 0x1430 */
-111,114,109, 97,116, 32,101,108,102, 51, 50, 45,108,105,116,116,   /* 0x1440 */
+116,104, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32,   /* 0x1440 */
-108,101, 97,114,109, 10, 10, 83,101, 99,116,105,111,110,115, 58,   /* 0x1450 */
+ 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48,   /* 0x1450 */
- 10, 73,100,120, 32, 78, 97,109,101, 32, 32, 32, 32, 32, 32, 32,   /* 0x1460 */
+ 48, 48, 32,115,116, 97,114,116, 95,111,102, 95,117,110, 99,111,   /* 0x1460 */
- 32, 32, 32, 83,105,122,101, 32, 32, 32, 32, 32, 32, 86, 77, 65,   /* 0x1470 */
+109,112,114,101,115,115,101,100, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1470 */
- 32, 32, 32, 32, 32, 32, 32, 76, 77, 65, 32, 32, 32, 32, 32, 32,   /* 0x1480 */
+ 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x1480 */
- 32, 70,105,108,101, 32,111,102,102, 32, 32, 65,108,103,110, 32,   /* 0x1490 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32,117,110, 99,111,109,112,114,   /* 0x1490 */
- 32, 70,108, 97,103,115, 10, 32, 32, 48, 32, 68,108,108, 83,116,   /* 0x14a0 */
+101,115,115,101,100, 95,108,101,110,103,116,104, 10, 48, 48, 48,   /* 0x14a0 */
- 97,114,116, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x14b0 */
+ 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x14b0 */
- 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x14c0 */
+ 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,111,114,105,   /* 0x14c0 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 51, 52, 32,   /* 0x14d0 */
+103,105,110, 97,108, 95,101,110,116,114,121, 10, 48, 48, 48, 48,   /* 0x14d0 */
- 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x14e0 */
+ 48, 48, 51, 48, 32,103, 32, 32, 32, 32, 32, 32, 32, 85,110,102,   /* 0x14e0 */
- 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x14f0 */
+105,108,116,101,114, 95, 48,120, 53, 48,  9, 48, 48, 48, 48, 48,   /* 0x14f0 */
- 10, 32, 32, 49, 32, 69,120,101, 83,116, 97,114,116, 32, 32, 32,   /* 0x1500 */
+ 48, 48, 48, 32, 70, 73, 66, 83, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1500 */
- 32, 32, 32, 48, 48, 48, 48, 48, 48, 54, 52, 32, 32, 48, 48, 48,   /* 0x1510 */
+ 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x1510 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1520 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32,102,105,108,116,101,114, 95,   /* 0x1520 */
- 32, 48, 48, 48, 48, 48, 48, 51, 99, 32, 32, 50, 42, 42, 49, 32,   /* 0x1530 */
+ 98,117,102,102,101,114, 95,115,116, 97,114,116, 10, 48, 48, 48,   /* 0x1530 */
- 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67,   /* 0x1540 */
+ 48, 48, 48, 51, 52, 32,103, 32, 32, 32, 32, 32, 32, 32, 85,110,   /* 0x1540 */
- 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 50, 32, 85,   /* 0x1550 */
+102,105,108,116,101,114, 95, 48,120, 53, 48,  9, 48, 48, 48, 48,   /* 0x1550 */
-110,102,105,108,116,101,114, 95, 48,120, 53, 48, 32, 48, 48, 48,   /* 0x1560 */
+ 48, 48, 48, 48, 32, 70, 73, 66, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x1560 */
- 48, 48, 48, 51, 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1570 */
+ 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,   /* 0x1570 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1580 */
+  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,102,105,108,116,101,114,   /* 0x1580 */
- 48, 97, 48, 32, 32, 50, 42, 42, 50, 32, 32, 67, 79, 78, 84, 69,   /* 0x1590 */
+ 95, 98,117,102,102,101,114, 95,101,110,100, 10, 48, 48, 48, 48,   /* 0x1590 */
- 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68,   /* 0x15a0 */
+ 48, 48, 51, 99, 32,103, 32, 32, 32, 32, 32, 32, 32, 82,101,108,   /* 0x15a0 */
- 79, 78, 76, 89, 10, 32, 32, 51, 32, 82,101,108,111, 99,115, 32,   /* 0x15b0 */
+111, 99,115,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 66, 82, 69,   /* 0x15b0 */
- 32, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 52, 48, 32,   /* 0x15c0 */
+ 76, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32,   /* 0x15c0 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x15d0 */
+ 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x15d0 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,100, 56, 32, 32, 50,   /* 0x15e0 */
+ 48, 32,115,116, 97,114,116, 95,111,102, 95,114,101,108,111, 99,   /* 0x15e0 */
- 42, 42, 50, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x15f0 */
+115, 10, 48, 48, 48, 48, 48, 48, 55, 56, 32,103, 32, 32, 32, 32,   /* 0x15f0 */
- 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x1600 */
+ 32, 32, 32, 73,109,112,111,114,116,115,  9, 48, 48, 48, 48, 48,   /* 0x1600 */
- 32, 52, 32, 73,109,112,111,114,116,115, 32, 32, 32, 32, 32, 32,   /* 0x1610 */
+ 48, 48, 48, 32, 66, 73, 77, 80, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1610 */
- 32, 48, 48, 48, 48, 48, 48, 56, 50, 32, 32, 48, 48, 48, 48, 48,   /* 0x1620 */
+ 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x1620 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1630 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32,115,116, 97,114,116, 95,111,   /* 0x1630 */
- 48, 48, 48, 48, 49, 49, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1640 */
+102, 95,105,109,112,111,114,116,115, 10, 48, 48, 48, 48, 48, 48,   /* 0x1640 */
- 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32,   /* 0x1650 */
+ 55, 99, 32,103, 32, 32, 32, 32, 32, 32, 32, 73,109,112,111,114,   /* 0x1650 */
- 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 53, 32, 80,114,111,   /* 0x1660 */
+116,115,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 79, 78, 65, 77,   /* 0x1660 */
- 99,101,115,115, 69,110,100, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x1670 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32,   /* 0x1670 */
- 48, 48, 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1680 */
+ 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1680 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 57,   /* 0x1690 */
+ 32,115,116, 97,114,116, 95,111,102, 95,100,108,108, 95,110, 97,   /* 0x1690 */
- 97, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x16a0 */
+109,101,115, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32,   /* 0x16a0 */
- 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 54, 32,   /* 0x16b0 */
+ 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48,   /* 0x16b0 */
- 85, 80, 88, 49, 72, 69, 65, 68, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x16c0 */
+ 48, 48, 48, 32,108,122,109, 97, 95,117, 95,108,101,110, 10, 48,   /* 0x16c0 */
- 48, 48, 48, 48, 50, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x16d0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x16d0 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x16e0 */
+ 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x16e0 */
- 48, 49, 97, 50, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x16f0 */
+122,109, 97, 95,115,116, 97, 99,107, 95, 97,100,106,117,115,116,   /* 0x16f0 */
- 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x1700 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32,   /* 0x1700 */
- 32, 55, 32, 46,117, 99,108, 95,110,114,118, 50, 98, 95,100,101,   /* 0x1710 */
+ 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1710 */
- 99,111,109,112,114,101,115,115, 95, 56, 32, 48, 48, 48, 48, 48,   /* 0x1720 */
+ 32,108,122,109, 97, 95, 99, 95,108,101,110, 10, 48, 48, 48, 48,   /* 0x1720 */
- 48, 57, 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1730 */
+ 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78,   /* 0x1730 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 49, 99,   /* 0x1740 */
+ 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,122,109, 97,   /* 0x1740 */
- 50, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x1750 */
+ 95,112,114,111,112,101,114,116,105,101,115, 10, 10, 82, 69, 76,   /* 0x1750 */
- 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 56, 32,   /* 0x1760 */
+ 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32,   /* 0x1760 */
- 67, 97,108,108, 50, 66, 32, 32, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x1770 */
+ 70, 79, 82, 32, 91, 68,108,108, 83,116, 97,114,116, 93, 58, 10,   /* 0x1770 */
- 48, 48, 48, 48, 48, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1780 */
+ 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x1780 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x1790 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x1790 */
- 48, 50, 53, 97, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x17a0 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 52, 32, 82, 95, 65, 82, 77, 95,   /* 0x17a0 */
- 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65,   /* 0x17b0 */
+ 80, 67, 50, 52, 32, 32, 32, 32, 32, 32, 32, 32, 69,120,101, 83,   /* 0x17b0 */
- 68, 79, 78, 76, 89, 10, 32, 32, 57, 32, 46,117, 99,108, 95,110,   /* 0x17c0 */
+116, 97,114,116, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78,   /* 0x17c0 */
-114,118, 50,101, 95,100,101, 99,111,109,112,114,101,115,115, 95,   /* 0x17d0 */
+ 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 69,120,   /* 0x17d0 */
- 56, 32, 48, 48, 48, 48, 48, 48, 98, 50, 32, 32, 48, 48, 48, 48,   /* 0x17e0 */
+101, 83,116, 97,114,116, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32,   /* 0x17e0 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x17f0 */
+ 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x17f0 */
- 48, 48, 48, 48, 48, 50, 53,101, 32, 32, 50, 42, 42, 48, 32, 32,   /* 0x1800 */
+ 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x1800 */
- 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x1810 */
+ 49, 99, 32, 82, 95, 65, 82, 77, 95, 80, 67, 50, 52, 32, 32, 32,   /* 0x1810 */
- 76, 89, 10, 32, 49, 48, 32, 67, 97,108,108, 50, 69, 32, 32, 32,   /* 0x1820 */
+ 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,114,116, 10, 48, 48,   /* 0x1820 */
- 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 52, 32, 32, 48,   /* 0x1830 */
+ 48, 48, 48, 48, 51, 56, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83,   /* 0x1830 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x1840 */
+ 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116, 95,111,   /* 0x1840 */
- 48, 32, 32, 48, 48, 48, 48, 48, 51, 49, 48, 32, 32, 50, 42, 42,   /* 0x1850 */
+102, 95, 99,111,109,112,114,101,115,115,101,100, 10, 48, 48, 48,   /* 0x1850 */
- 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76,   /* 0x1860 */
+ 48, 48, 48, 51, 99, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51,   /* 0x1860 */
- 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 49,   /* 0x1870 */
+ 50, 32, 32, 32, 32, 32, 32, 32, 99,111,109,112,114,101,115,115,   /* 0x1870 */
- 32, 67, 97,108,108, 76, 90, 77, 65, 32, 32, 32, 32, 32, 32, 48,   /* 0x1880 */
+101,100, 95,108,101,110,103,116,104, 10, 48, 48, 48, 48, 48, 48,   /* 0x1880 */
- 48, 48, 48, 48, 48, 51, 52, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x1890 */
+ 52, 48, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32,   /* 0x1890 */
- 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x18a0 */
+ 32, 32, 32, 32, 32,115,116, 97,114,116, 95,111,102, 95,117,110,   /* 0x18a0 */
- 48, 48, 51, 49, 52, 32, 32, 50, 42, 42, 50, 32, 32, 67, 79, 78,   /* 0x18b0 */
+ 99,111,109,112,114,101,115,115,101,100, 10, 48, 48, 48, 48, 48,   /* 0x18b0 */
- 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69,   /* 0x18c0 */
+ 48, 52, 52, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32,   /* 0x18c0 */
- 65, 68, 79, 78, 76, 89, 10, 32, 49, 50, 32, 76, 90, 77, 65, 95,   /* 0x18d0 */
+ 32, 32, 32, 32, 32, 32,117,110, 99,111,109,112,114,101,115,115,   /* 0x18d0 */
- 68, 69, 67, 79, 68, 69, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x18e0 */
+101,100, 95,108,101,110,103,116,104, 10, 48, 48, 48, 48, 48, 48,   /* 0x18e0 */
- 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x18f0 */
+ 53, 56, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32,   /* 0x18f0 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 51, 52, 56, 32,   /* 0x1900 */
+ 32, 32, 32, 32, 32,111,114,105,103,105,110, 97,108, 95,101,110,   /* 0x1900 */
- 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x1910 */
+116,114,121, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32,   /* 0x1910 */
- 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 51, 32, 76, 90,   /* 0x1920 */
+ 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 85,110,102,   /* 0x1920 */
- 77, 65, 95, 68, 69, 67, 49, 48, 32, 32, 32, 32, 48, 48, 48, 48,   /* 0x1930 */
+105,108,116,101,114, 95, 48,120, 53, 48, 93, 58, 10, 79, 70, 70,   /* 0x1930 */
- 48, 55, 54, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x1940 */
+ 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32,   /* 0x1940 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 51,   /* 0x1950 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48,   /* 0x1950 */
- 52, 56, 32, 32, 50, 42, 42, 50, 32, 32, 67, 79, 78, 84, 69, 78,   /* 0x1960 */
+ 48, 48, 48, 48, 51, 48, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83,   /* 0x1960 */
- 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 83, 89, 77,   /* 0x1970 */
+ 51, 50, 32, 32, 32, 32, 32, 32, 32,102,105,108,116,101,114, 95,   /* 0x1970 */
- 66, 79, 76, 32, 84, 65, 66, 76, 69, 58, 10, 48, 48, 48, 48, 48,   /* 0x1980 */
+ 98,117,102,102,101,114, 95,115,116, 97,114,116, 10, 48, 48, 48,   /* 0x1980 */
- 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 69,120,101, 83,   /* 0x1990 */
+ 48, 48, 48, 51, 52, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51,   /* 0x1990 */
-116, 97,114,116,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69,120,   /* 0x19a0 */
+ 50, 32, 32, 32, 32, 32, 32, 32,102,105,108,116,101,114, 95, 98,   /* 0x19a0 */
-101, 83,116, 97,114,116, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x19b0 */
+117,102,102,101,114, 95,101,110,100, 10, 10, 82, 69, 76, 79, 67,   /* 0x19b0 */
-108, 32, 32, 32, 32, 32, 32, 32, 73,109,112,111,114,116,115,  9,   /* 0x19c0 */
+ 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79,   /* 0x19c0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 46,114,101, 97,108, 95,115,   /* 0x19d0 */
+ 82, 32, 91, 82,101,108,111, 99,115, 93, 58, 10, 79, 70, 70, 83,   /* 0x19d0 */
-116, 97,114,116, 95,111,102, 73,109,112,111,114,116,115, 10, 48,   /* 0x19e0 */
+ 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x19e0 */
- 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x19f0 */
+ 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48,   /* 0x19f0 */
- 46,117, 99,108, 95,110,114,118, 50, 98, 95,100,101, 99,111,109,   /* 0x1a00 */
+ 48, 48, 48, 51, 99, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51,   /* 0x1a00 */
-112,114,101,115,115, 95, 56,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1a10 */
+ 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116, 95,111,102,   /* 0x1a10 */
- 32, 46,117, 99,108, 95,110,114,118, 50, 98, 95,100,101, 99,111,   /* 0x1a20 */
+ 95,114,101,108,111, 99,115, 10, 10, 82, 69, 76, 79, 67, 65, 84,   /* 0x1a20 */
-109,112,114,101,115,115, 95, 56, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1a30 */
+ 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32,   /* 0x1a30 */
- 48, 32,108, 32, 32, 32, 32,100, 32, 32, 46,117, 99,108, 95,110,   /* 0x1a40 */
+ 91, 73,109,112,111,114,116,115, 93, 58, 10, 79, 70, 70, 83, 69,   /* 0x1a40 */
-114,118, 50,101, 95,100,101, 99,111,109,112,114,101,115,115, 95,   /* 0x1a50 */
+ 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1a50 */
- 56,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 46,117, 99,108, 95,   /* 0x1a60 */
+ 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48,   /* 0x1a60 */
-110,114,118, 50,101, 95,100,101, 99,111,109,112,114,101,115,115,   /* 0x1a70 */
+ 48, 48, 48,101, 32, 82, 95, 65, 82, 77, 95, 84, 72, 77, 95, 67,   /* 0x1a70 */
- 95, 56, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1a80 */
+ 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,115,116, 97,   /* 0x1a80 */
- 32, 32, 32, 32, 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69,  9,   /* 0x1a90 */
+114,116, 95,111,102, 73,109,112,111,114,116,115, 10, 48, 48, 48,   /* 0x1a90 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 46,114,101, 97,108, 95,115,   /* 0x1aa0 */
+ 48, 48, 48, 50, 56, 32, 82, 95, 65, 82, 77, 95, 84, 72, 77, 95,   /* 0x1aa0 */
-116, 97,114,116, 95,111,102, 76, 90, 77, 65, 95, 68, 69, 67, 79,   /* 0x1ab0 */
+ 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,115,116,   /* 0x1ab0 */
- 68, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1ac0 */
+ 97,114,116, 95,111,102, 73,109,112,111,114,116,115, 10, 48, 48,   /* 0x1ac0 */
- 32,100, 32, 32, 68,108,108, 83,116, 97,114,116,  9, 48, 48, 48,   /* 0x1ad0 */
+ 48, 48, 48, 48, 51, 48, 32, 82, 95, 65, 82, 77, 95, 84, 72, 77,   /* 0x1ad0 */
- 48, 48, 48, 48, 48, 32, 68,108,108, 83,116, 97,114,116, 10, 48,   /* 0x1ae0 */
+ 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,115,   /* 0x1ae0 */
- 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x1af0 */
+116, 97,114,116, 95,111,102, 73,109,112,111,114,116,115, 10, 48,   /* 0x1af0 */
- 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48,  9, 48, 48,   /* 0x1b00 */
+ 48, 48, 48, 48, 48, 53, 99, 32, 82, 95, 65, 82, 77, 95, 84, 72,   /* 0x1b00 */
- 48, 48, 48, 48, 48, 48, 32, 85,110,102,105,108,116,101,114, 95,   /* 0x1b10 */
+ 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,   /* 0x1b10 */
- 48,120, 53, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32,   /* 0x1b20 */
+115,116, 97,114,116, 95,111,102, 73,109,112,111,114,116,115, 10,   /* 0x1b20 */
- 32, 32, 32,100, 32, 32, 82,101,108,111, 99,115,  9, 48, 48, 48,   /* 0x1b30 */
+ 48, 48, 48, 48, 48, 48, 55, 56, 32, 82, 95, 65, 82, 77, 95, 65,   /* 0x1b30 */
- 48, 48, 48, 48, 48, 32, 82,101,108,111, 99,115, 10, 48, 48, 48,   /* 0x1b40 */
+ 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116,   /* 0x1b40 */
- 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 73,109,   /* 0x1b50 */
+ 95,111,102, 95,105,109,112,111,114,116,115, 10, 48, 48, 48, 48,   /* 0x1b50 */
-112,111,114,116,115,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 73,   /* 0x1b60 */
+ 48, 48, 55, 99, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50,   /* 0x1b60 */
-109,112,111,114,116,115, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1b70 */
+ 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116, 95,111,102, 95,   /* 0x1b70 */
-108, 32, 32, 32, 32,100, 32, 32, 80,114,111, 99,101,115,115, 69,   /* 0x1b80 */
+100,108,108, 95,110, 97,109,101,115, 10, 10, 82, 69, 76, 79, 67,   /* 0x1b80 */
-110,100,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 80,114,111, 99,   /* 0x1b90 */
+ 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79,   /* 0x1b90 */
-101,115,115, 69,110,100, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1ba0 */
+ 82, 32, 91, 67, 97,108,108, 50, 66, 93, 58, 10, 79, 70, 70, 83,   /* 0x1ba0 */
-108, 32, 32, 32, 32,100, 32, 32, 85, 80, 88, 49, 72, 69, 65, 68,   /* 0x1bb0 */
+ 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x1bb0 */
-  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 85, 80, 88, 49, 72, 69,   /* 0x1bc0 */
+ 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48,   /* 0x1bc0 */
- 65, 68, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1bd0 */
+ 48, 48, 48, 48, 48, 32, 82, 95, 65, 82, 77, 95, 84, 72, 77, 95,   /* 0x1bd0 */
- 32,100, 32, 32, 67, 97,108,108, 50, 66,  9, 48, 48, 48, 48, 48,   /* 0x1be0 */
+ 67, 65, 76, 76, 32, 32, 32, 32, 46,117, 99,108, 95,110,114,118,   /* 0x1be0 */
- 48, 48, 48, 32, 67, 97,108,108, 50, 66, 10, 48, 48, 48, 48, 48,   /* 0x1bf0 */
+ 50, 98, 95,100,101, 99,111,109,112,114,101,115,115, 95, 56, 10,   /* 0x1bf0 */
- 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 97,108,108,   /* 0x1c00 */
+ 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79,   /* 0x1c00 */
- 50, 69,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 97,108,108,   /* 0x1c10 */
+ 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 97,108,108, 50, 69, 93,   /* 0x1c10 */
- 50, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32,   /* 0x1c20 */
+ 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32,   /* 0x1c20 */
- 32,100, 32, 32, 67, 97,108,108, 76, 90, 77, 65,  9, 48, 48, 48,   /* 0x1c30 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76,   /* 0x1c30 */
- 48, 48, 48, 48, 48, 32, 67, 97,108,108, 76, 90, 77, 65, 10, 48,   /* 0x1c40 */
+ 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 82, 95, 65, 82,   /* 0x1c40 */
- 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32,   /* 0x1c50 */
+ 77, 95, 84, 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,117,   /* 0x1c50 */
- 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69,  9, 48, 48, 48, 48,   /* 0x1c60 */
+ 99,108, 95,110,114,118, 50,101, 95,100,101, 99,111,109,112,114,   /* 0x1c60 */
- 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69,   /* 0x1c70 */
+101,115,115, 95, 56, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79,   /* 0x1c70 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100,   /* 0x1c80 */
+ 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67,   /* 0x1c80 */
- 32, 32, 76, 90, 77, 65, 95, 68, 69, 67, 49, 48,  9, 48, 48, 48,   /* 0x1c90 */
+ 97,108,108, 76, 90, 77, 65, 93, 58, 10, 79, 70, 70, 83, 69, 84,   /* 0x1c90 */
- 48, 48, 48, 48, 48, 32, 76, 90, 77, 65, 95, 68, 69, 67, 49, 48,   /* 0x1ca0 */
+ 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1ca0 */
- 10, 48, 48, 48, 48, 48, 48, 51, 56, 32,103, 32, 32, 32, 32, 32,   /* 0x1cb0 */
+ 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48,   /* 0x1cb0 */
- 32, 32, 69,120,101, 83,116, 97,114,116,  9, 48, 48, 48, 48, 48,   /* 0x1cc0 */
+ 48, 49, 99, 32, 82, 95, 65, 82, 77, 95, 84, 72, 77, 95, 67, 65,   /* 0x1cc0 */
- 48, 48, 48, 32, 83, 82, 67, 48, 10, 48, 48, 48, 48, 48, 48, 52,   /* 0x1cd0 */
+ 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,115,116, 97,114,   /* 0x1cd0 */
- 48, 32,103, 32, 32, 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,   /* 0x1ce0 */
+116, 95,111,102, 76, 90, 77, 65, 95, 68, 69, 67, 79, 68, 69, 10,   /* 0x1ce0 */
-114,116,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 68, 83, 84, 48,   /* 0x1cf0 */
+ 48, 48, 48, 48, 48, 48, 50, 52, 32, 82, 95, 65, 82, 77, 95, 65,   /* 0x1cf0 */
- 10, 48, 48, 48, 48, 48, 48, 52, 56, 32,103, 32, 32, 32, 32, 32,   /* 0x1d00 */
+ 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,108,122,109, 97, 95,   /* 0x1d00 */
- 32, 32, 69,120,101, 83,116, 97,114,116,  9, 48, 48, 48, 48, 48,   /* 0x1d10 */
+117, 95,108,101,110, 10, 48, 48, 48, 48, 48, 48, 50, 56, 32, 82,   /* 0x1d10 */
- 48, 48, 48, 32, 73, 65, 84, 84, 10, 48, 48, 48, 48, 48, 48, 53,   /* 0x1d20 */
+ 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32,   /* 0x1d20 */
- 56, 32,103, 32, 32, 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,   /* 0x1d30 */
+ 32,108,122,109, 97, 95,115,116, 97, 99,107, 95, 97,100,106,117,   /* 0x1d30 */
-114,116,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 69, 78, 84, 82,   /* 0x1d40 */
+115,116, 10, 48, 48, 48, 48, 48, 48, 50, 99, 32, 82, 95, 65, 82,   /* 0x1d40 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32,   /* 0x1d50 */
+ 77, 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,108,122,   /* 0x1d50 */
- 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1d60 */
+109, 97, 95, 99, 95,108,101,110, 10, 48, 48, 48, 48, 48, 48, 51,   /* 0x1d60 */
- 32,115,116, 97,114,116, 95,111,102, 95, 99,111,109,112,114,101,   /* 0x1d70 */
+ 48, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32, 32,   /* 0x1d70 */
-115,115,101,100, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32,   /* 0x1d80 */
+ 32, 32, 32, 32,108,122,109, 97, 95,112,114,111,112,101,114,116,   /* 0x1d80 */
- 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48,   /* 0x1d90 */
+105,101,115, 10                                                    /* 0x1d90 */
- 48, 48, 48, 48, 32, 99,111,109,112,114,101,115,115,101,100, 95,   /* 0x1da0 */
-108,101,110,103,116,104, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1db0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48,   /* 0x1dc0 */
- 48, 48, 48, 48, 48, 48, 32,115,116, 97,114,116, 95,111,102, 95,   /* 0x1dd0 */
-117,110, 99,111,109,112,114,101,115,115,101,100, 10, 48, 48, 48,   /* 0x1de0 */
- 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x1df0 */
- 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,117,110, 99,   /* 0x1e00 */
-111,109,112,114,101,115,115,101,100, 95,108,101,110,103,116,104,   /* 0x1e10 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32,   /* 0x1e20 */
- 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1e30 */
- 32,111,114,105,103,105,110, 97,108, 95,101,110,116,114,121, 10,   /* 0x1e40 */
- 48, 48, 48, 48, 48, 48, 51, 48, 32,103, 32, 32, 32, 32, 32, 32,   /* 0x1e50 */
- 32, 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48,  9, 48,   /* 0x1e60 */
- 48, 48, 48, 48, 48, 48, 48, 32, 70, 73, 66, 83, 10, 48, 48, 48,   /* 0x1e70 */
- 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x1e80 */
- 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,102,105,108,   /* 0x1e90 */
-116,101,114, 95, 98,117,102,102,101,114, 95,115,116, 97,114,116,   /* 0x1ea0 */
- 10, 48, 48, 48, 48, 48, 48, 51, 52, 32,103, 32, 32, 32, 32, 32,   /* 0x1eb0 */
- 32, 32, 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48,  9,   /* 0x1ec0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 70, 73, 66, 69, 10, 48, 48,   /* 0x1ed0 */
- 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42,   /* 0x1ee0 */
- 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,102,105,   /* 0x1ef0 */
-108,116,101,114, 95, 98,117,102,102,101,114, 95,101,110,100, 10,   /* 0x1f00 */
- 48, 48, 48, 48, 48, 48, 51, 99, 32,103, 32, 32, 32, 32, 32, 32,   /* 0x1f10 */
- 32, 82,101,108,111, 99,115,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1f20 */
- 32, 66, 82, 69, 76, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x1f30 */
- 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48,   /* 0x1f40 */
- 48, 48, 48, 48, 48, 32,115,116, 97,114,116, 95,111,102, 95,114,   /* 0x1f50 */
-101,108,111, 99,115, 10, 48, 48, 48, 48, 48, 48, 55, 56, 32,103,   /* 0x1f60 */
- 32, 32, 32, 32, 32, 32, 32, 73,109,112,111,114,116,115,  9, 48,   /* 0x1f70 */
- 48, 48, 48, 48, 48, 48, 48, 32, 66, 73, 77, 80, 10, 48, 48, 48,   /* 0x1f80 */
- 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85,   /* 0x1f90 */
- 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,115,116, 97,   /* 0x1fa0 */
-114,116, 95,111,102, 95,105,109,112,111,114,116,115, 10, 48, 48,   /* 0x1fb0 */
- 48, 48, 48, 48, 55, 99, 32,103, 32, 32, 32, 32, 32, 32, 32, 73,   /* 0x1fc0 */
-109,112,111,114,116,115,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1fd0 */
- 79, 78, 65, 77, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32,   /* 0x1fe0 */
- 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48,   /* 0x1ff0 */
- 48, 48, 48, 48, 32,115,116, 97,114,116, 95,111,102, 95,100,108,   /* 0x2000 */
-108, 95,110, 97,109,101,115, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x2010 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48,   /* 0x2020 */
- 48, 48, 48, 48, 48, 48, 48, 32,108,122,109, 97, 95,117, 95,108,   /* 0x2030 */
-101,110, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32,   /* 0x2040 */
- 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48,   /* 0x2050 */
- 48, 48, 32,108,122,109, 97, 95,115,116, 97, 99,107, 95, 97,100,   /* 0x2060 */
-106,117,115,116, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32,   /* 0x2070 */
- 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48,   /* 0x2080 */
- 48, 48, 48, 48, 32,108,122,109, 97, 95, 99, 95,108,101,110, 10,   /* 0x2090 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x20a0 */
- 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x20b0 */
-108,122,109, 97, 95,112,114,111,112,101,114,116,105,101,115, 10,   /* 0x20c0 */
- 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79,   /* 0x20d0 */
- 82, 68, 83, 32, 70, 79, 82, 32, 91, 68,108,108, 83,116, 97,114,   /* 0x20e0 */
-116, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80,   /* 0x20f0 */
- 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86,   /* 0x2100 */
- 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 52, 32, 82, 95,   /* 0x2110 */
- 65, 82, 77, 95, 80, 67, 50, 52, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2120 */
- 69,120,101, 83,116, 97,114,116, 10, 10, 82, 69, 76, 79, 67, 65,   /* 0x2130 */
- 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82,   /* 0x2140 */
- 32, 91, 69,120,101, 83,116, 97,114,116, 93, 58, 10, 79, 70, 70,   /* 0x2150 */
- 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32,   /* 0x2160 */
- 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48,   /* 0x2170 */
- 48, 48, 48, 48, 49, 99, 32, 82, 95, 65, 82, 77, 95, 80, 67, 50,   /* 0x2180 */
- 52, 32, 32, 32, 32, 32, 32, 32, 32, 69,120,101, 83,116, 97,114,   /* 0x2190 */
-116, 10, 48, 48, 48, 48, 48, 48, 51, 56, 32, 82, 95, 65, 82, 77,   /* 0x21a0 */
- 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,   /* 0x21b0 */
-114,116, 95,111,102, 95, 99,111,109,112,114,101,115,115,101,100,   /* 0x21c0 */
- 10, 48, 48, 48, 48, 48, 48, 51, 99, 32, 82, 95, 65, 82, 77, 95,   /* 0x21d0 */
- 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32, 99,111,109,112,   /* 0x21e0 */
-114,101,115,115,101,100, 95,108,101,110,103,116,104, 10, 48, 48,   /* 0x21f0 */
- 48, 48, 48, 48, 52, 48, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83,   /* 0x2200 */
- 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116, 95,111,   /* 0x2210 */
-102, 95,117,110, 99,111,109,112,114,101,115,115,101,100, 10, 48,   /* 0x2220 */
- 48, 48, 48, 48, 48, 52, 52, 32, 82, 95, 65, 82, 77, 95, 65, 66,   /* 0x2230 */
- 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,117,110, 99,111,109,112,   /* 0x2240 */
-114,101,115,115,101,100, 95,108,101,110,103,116,104, 10, 48, 48,   /* 0x2250 */
- 48, 48, 48, 48, 53, 56, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83,   /* 0x2260 */
- 51, 50, 32, 32, 32, 32, 32, 32, 32,111,114,105,103,105,110, 97,   /* 0x2270 */
-108, 95,101,110,116,114,121, 10, 10, 82, 69, 76, 79, 67, 65, 84,   /* 0x2280 */
- 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32,   /* 0x2290 */
- 91, 85,110,102,105,108,116,101,114, 95, 48,120, 53, 48, 93, 58,   /* 0x22a0 */
- 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32,   /* 0x22b0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85,   /* 0x22c0 */
- 69, 10, 48, 48, 48, 48, 48, 48, 51, 48, 32, 82, 95, 65, 82, 77,   /* 0x22d0 */
- 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,102,105,108,   /* 0x22e0 */
-116,101,114, 95, 98,117,102,102,101,114, 95,115,116, 97,114,116,   /* 0x22f0 */
- 10, 48, 48, 48, 48, 48, 48, 51, 52, 32, 82, 95, 65, 82, 77, 95,   /* 0x2300 */
- 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,102,105,108,116,   /* 0x2310 */
-101,114, 95, 98,117,102,102,101,114, 95,101,110,100, 10, 10, 82,   /* 0x2320 */
- 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68,   /* 0x2330 */
- 83, 32, 70, 79, 82, 32, 91, 82,101,108,111, 99,115, 93, 58, 10,   /* 0x2340 */
- 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x2350 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x2360 */
- 10, 48, 48, 48, 48, 48, 48, 51, 99, 32, 82, 95, 65, 82, 77, 95,   /* 0x2370 */
- 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,   /* 0x2380 */
-116, 95,111,102, 95,114,101,108,111, 99,115, 10, 10, 82, 69, 76,   /* 0x2390 */
- 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32,   /* 0x23a0 */
- 70, 79, 82, 32, 91, 73,109,112,111,114,116,115, 93, 58, 10, 79,   /* 0x23b0 */
- 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32,   /* 0x23c0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10,   /* 0x23d0 */
- 48, 48, 48, 48, 48, 48, 48,101, 32, 82, 95, 65, 82, 77, 95, 84,   /* 0x23e0 */
- 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108,   /* 0x23f0 */
- 95,115,116, 97,114,116, 95,111,102, 73,109,112,111,114,116,115,   /* 0x2400 */
- 10, 48, 48, 48, 48, 48, 48, 50, 56, 32, 82, 95, 65, 82, 77, 95,   /* 0x2410 */
- 84, 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,   /* 0x2420 */
-108, 95,115,116, 97,114,116, 95,111,102, 73,109,112,111,114,116,   /* 0x2430 */
-115, 10, 48, 48, 48, 48, 48, 48, 51, 48, 32, 82, 95, 65, 82, 77,   /* 0x2440 */
- 95, 84, 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101,   /* 0x2450 */
- 97,108, 95,115,116, 97,114,116, 95,111,102, 73,109,112,111,114,   /* 0x2460 */
-116,115, 10, 48, 48, 48, 48, 48, 48, 53, 99, 32, 82, 95, 65, 82,   /* 0x2470 */
- 77, 95, 84, 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,   /* 0x2480 */
-101, 97,108, 95,115,116, 97,114,116, 95,111,102, 73,109,112,111,   /* 0x2490 */
-114,116,115, 10, 48, 48, 48, 48, 48, 48, 55, 56, 32, 82, 95, 65,   /* 0x24a0 */
- 82, 77, 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,115,   /* 0x24b0 */
-116, 97,114,116, 95,111,102, 95,105,109,112,111,114,116,115, 10,   /* 0x24c0 */
- 48, 48, 48, 48, 48, 48, 55, 99, 32, 82, 95, 65, 82, 77, 95, 65,   /* 0x24d0 */
- 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,115,116, 97,114,116,   /* 0x24e0 */
- 95,111,102, 95,100,108,108, 95,110, 97,109,101,115, 10, 10, 82,   /* 0x24f0 */
- 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68,   /* 0x2500 */
- 83, 32, 70, 79, 82, 32, 91, 67, 97,108,108, 50, 66, 93, 58, 10,   /* 0x2510 */
- 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x2520 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x2530 */
- 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 82, 95, 65, 82, 77, 95,   /* 0x2540 */
- 84, 72, 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,117, 99,108,   /* 0x2550 */
- 95,110,114,118, 50, 98, 95,100,101, 99,111,109,112,114,101,115,   /* 0x2560 */
-115, 95, 56, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32,   /* 0x2570 */
- 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 97,108,   /* 0x2580 */
-108, 50, 69, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84,   /* 0x2590 */
- 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x25a0 */
- 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x25b0 */
- 82, 95, 65, 82, 77, 95, 84, 72, 77, 95, 67, 65, 76, 76, 32, 32,   /* 0x25c0 */
- 32, 32, 46,117, 99,108, 95,110,114,118, 50,101, 95,100,101, 99,   /* 0x25d0 */
-111,109,112,114,101,115,115, 95, 56, 10, 10, 82, 69, 76, 79, 67,   /* 0x25e0 */
- 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79,   /* 0x25f0 */
- 82, 32, 91, 67, 97,108,108, 76, 90, 77, 65, 93, 58, 10, 79, 70,   /* 0x2600 */
- 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32,   /* 0x2610 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48,   /* 0x2620 */
- 48, 48, 48, 48, 48, 49, 99, 32, 82, 95, 65, 82, 77, 95, 84, 72,   /* 0x2630 */
- 77, 95, 67, 65, 76, 76, 32, 32, 32, 32, 46,114,101, 97,108, 95,   /* 0x2640 */
-115,116, 97,114,116, 95,111,102, 76, 90, 77, 65, 95, 68, 69, 67,   /* 0x2650 */
- 79, 68, 69, 10, 48, 48, 48, 48, 48, 48, 50, 52, 32, 82, 95, 65,   /* 0x2660 */
- 82, 77, 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32, 32, 32,108,   /* 0x2670 */
-122,109, 97, 95,117, 95,108,101,110, 10, 48, 48, 48, 48, 48, 48,   /* 0x2680 */
- 50, 56, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32,   /* 0x2690 */
- 32, 32, 32, 32, 32,108,122,109, 97, 95,115,116, 97, 99,107, 95,   /* 0x26a0 */
- 97,100,106,117,115,116, 10, 48, 48, 48, 48, 48, 48, 50, 99, 32,   /* 0x26b0 */
- 82, 95, 65, 82, 77, 95, 65, 66, 83, 51, 50, 32, 32, 32, 32, 32,   /* 0x26c0 */
- 32, 32,108,122,109, 97, 95, 99, 95,108,101,110, 10, 48, 48, 48,   /* 0x26d0 */
- 48, 48, 48, 51, 48, 32, 82, 95, 65, 82, 77, 95, 65, 66, 83, 51,   /* 0x26e0 */
- 50, 32, 32, 32, 32, 32, 32, 32,108,122,109, 97, 95,112,114,111,   /* 0x26f0 */
-112,101,114,116,105,101,115, 10                                    /* 0x2700 */
 };

src/stub/armeb-linux.elf-fold.h

@@ -0,0 +1,168 @@
+/* armeb-linux.elf-fold.h
+   created from armeb-linux.elf-fold.bin, 2108 (0x83c) bytes
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 2000-2006 John F. Reiser
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+ */
+
+
+#define STUB_ARMEB_LINUX_ELF_FOLD_SIZE    2108
+#define STUB_ARMEB_LINUX_ELF_FOLD_ADLER32 0x65a66090
+#define STUB_ARMEB_LINUX_ELF_FOLD_CRC32   0xdee2e92e
+
+unsigned char stub_armeb_linux_elf_fold[2108] = {
+127, 69, 76, 70,  1,  2,  1, 97,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
+  0,  2,  0, 40,  0,  0,  0,  1,  0,  0,128,128,  0,  0,  0, 52,   /* 0x  10 */
+  0,  0,  0,  0,  0,  0,  0,  2,  0, 52,  0, 32,  0,  2,  0,  0,   /* 0x  20 */
+  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,128,  0,   /* 0x  30 */
+  0,  0,128,  0,  0,  0,  8, 60,  0,  0,  8, 60,  0,  0,  0,  5,   /* 0x  40 */
+  0,  0,128,  0,  0,  0,  0,  1,  0,  0,  8, 60,  0,  0,  0,  0,   /* 0x  50 */
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  60 */
+  0,  0,128,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  70 */
+229,157, 48, 12,224,141, 49,  3,226,131, 48, 20,228,147,  0,  4,   /* 0x  80 */
+227, 80,  0,  0, 26,255,255,252,225,160, 32,  3,228,146,  0,  8,   /* 0x  90 */
+227, 80,  0,  0, 26,255,255,252,229,141, 32,  8,226, 77,220, 10,   /* 0x  a0 */
+225,160, 64,  9,229,154,144,  4,225,160,128, 13,229,154,112,  0,   /* 0x  b0 */
+226,143, 96, 36,226,137,144, 12,227,160,176,  0,233, 45, 15,248,   /* 0x  c0 */
+232,189,  0, 15,235,  0,  1,132,225,160,224,  0,226,141,208, 20,   /* 0x  d0 */
+226,141,220, 10,232,189,  0,  7,229, 18,240,  4,226,  3, 48,255,   /* 0x  e0 */
+227, 83,  0, 81, 17,160,240, 14,225,176, 17, 33, 19, 80,  0,  0,   /* 0x  f0 */
+  1,160,240, 14,226, 65, 16,  1,231,144, 33,  1,226,  2, 52, 15,   /* 0x 100 */
+227, 83,  4, 11, 26,  0,  0,  4,226,  2, 52,255,224, 66, 32,  1,   /* 0x 110 */
+227,194, 36,255,225,130, 32,  3,231,128, 33,  1,227, 81,  0,  0,   /* 0x 120 */
+ 26,255,255,243,225,160,240, 14,239,144,  0,  1,239,144,  0,  3,   /* 0x 130 */
+225,160,240, 14,239,144,  0,  4,225,160,240, 14,239,144,  0,  5,   /* 0x 140 */
+225,160,240, 14,239,144,  0,  6,225,160,240, 14,239,144,  0, 45,   /* 0x 150 */
+225,160,240, 14,239,144,  0, 91,225,160,240, 14,239,144,  0,125,   /* 0x 160 */
+225,160,240, 14,229, 45, 80,  4,229,157, 80,  8,229, 45, 64,  4,   /* 0x 170 */
+229,157, 64,  8,225,160, 86, 37,239,144,  0,192,228,157, 64,  4,   /* 0x 180 */
+228,157, 80,  4,225,160,240, 14,227, 80,  0,  0,  1,160,240, 14,   /* 0x 190 */
+229,144, 48,  0,225, 83,  0,  1, 10,  0,  0,  6,227, 83,  0,  1,   /* 0x 1a0 */
+ 19,160, 48,  0,  3,160, 48,  1,227, 81,  0,  0,  3,160, 48,  0,   /* 0x 1b0 */
+227, 83,  0,  0, 10,  0,  0,  1,232,128,  0,  6,225,160,240, 14,   /* 0x 1c0 */
+226,128,  0,  8,234,255,255,241,229,144, 48,  0,225, 83,  0,  2,   /* 0x 1d0 */
+229,144, 48,  4,229, 45,224,  4, 33,160,192,  3,225,160,224,  2,   /* 0x 1e0 */
+ 33,160, 32,  2, 42,  0,  0,  3,227,160,  0,127,235,255,255,205,   /* 0x 1f0 */
+229, 92, 48,  1,229, 65, 48,  1,226, 66, 32,  1,227,114,  0,  1,   /* 0x 200 */
+226,140,192,  1,226,129, 16,  1, 26,255,255,248,229,144, 32,  4,   /* 0x 210 */
+229,144, 48,  0,224,130, 32, 14,224,110, 48,  3,229,128, 48,  0,   /* 0x 220 */
+229,128, 32,  4,228,157,240,  4,233, 45, 64,240,225,160, 80,  0,   /* 0x 230 */
+226, 77,208, 20,225,160, 64,  1,225,160,112,  2,225,160, 96,  3,   /* 0x 240 */
+234,  0,  0, 68,226,141, 16,  4,225,160,  0,  5,227,160, 32, 12,   /* 0x 250 */
+235,255,255,220,229,157,192,  4,227, 92,  0,  0,229,157, 16,  8,   /* 0x 260 */
+ 26,  0,  0,  6,229,159, 49,  0,225, 81,  0,  3, 26,  0,  0,  5,   /* 0x 270 */
+229,149, 48,  0,227, 83,  0,  0, 26,  0,  0,  2,234,  0,  0, 56,   /* 0x 280 */
+227, 81,  0,  0, 26,  0,  0,  1,227,160,  0,127,235,255,255,165,   /* 0x 290 */
+225, 81,  0, 12,138,255,255,251,229,148, 48,  0,225, 92,  0,  3,   /* 0x 2a0 */
+138,255,255,248,225, 81,  0, 12, 42,  0,  0, 33,229,141,192, 16,   /* 0x 2b0 */
+229,157,192, 12,229,149,  0,  4,229,148, 32,  4,226,141, 48, 16,   /* 0x 2c0 */
+229,141,192,  0,225,160,224, 15,225,160,240,  7,227, 80,  0,  0,   /* 0x 2d0 */
+ 26,255,255,236,229,157, 16, 16,229,157, 48,  4,225, 81,  0,  3,   /* 0x 2e0 */
+ 26,255,255,232,229,221, 32, 13,227, 82,  0,  0, 19, 86,  0,  0,   /* 0x 2f0 */
+ 10,  0,  0,  9,227, 81, 12,  2,138,  0,  0,  2,229,148, 48,  0,   /* 0x 300 */
+225, 83,  0,  1, 26,  0,  0,  4,225,160, 48,  2,229,148,  0,  4,   /* 0x 310 */
+229,221, 32, 14,225,160,224, 15,225,160,240,  6,229,157, 48,  8,   /* 0x 320 */
+232,149,  0,  6,224,130, 32,  3,224, 99, 16,  1,232,133,  0,  6,   /* 0x 330 */
+234,  0,  0,  3,225,160, 32,  1,225,160,  0,  5,229,148, 16,  4,   /* 0x 340 */
+235,255,255,160,229,157, 48,  4,232,148,  0,  6,224,130, 32,  3,   /* 0x 350 */
+224, 99, 16,  1,232,132,  0,  6,229,148, 48,  0,227, 83,  0,  0,   /* 0x 360 */
+ 26,255,255,183,226,141,208, 20,232,189,128,240, 33, 88, 80, 85,   /* 0x 370 */
+233, 45, 79,240,225,160,160,  1,225,218,193,176,229,145, 16, 28,   /* 0x 380 */
+225,218,226,188,226, 77,208, 48,227, 92,  0,  2,224,138, 96,  1,   /* 0x 390 */
+229,141,  0, 16,  3,160,192, 16, 19,160,192,  0,226, 78,224,  1,   /* 0x 3a0 */
+225,160, 16,  6,227,224, 64,  0,227,160,  0,  0,229,141, 32, 12,   /* 0x 3b0 */
+229,141, 48,  8,234,  0,  0, 11,229,145, 48,  0,227, 83,  0,  1,   /* 0x 3c0 */
+ 26,  0,  0,  6,229,145, 32,  8,229,145, 48, 20,224,130, 48,  3,   /* 0x 3d0 */
+225, 80,  0,  3, 49,160,  0,  3,225, 84,  0,  2, 33,160, 64,  2,   /* 0x 3e0 */
+226,129, 16, 32,226, 78,224,  1,227, 94,  0,  0,170,255,255,241,   /* 0x 3f0 */
+227,196, 78,255,227,196, 64, 15,224,100, 48,  0,226,131, 62,255,   /* 0x 400 */
+226,131, 48, 15,227,195, 62,255,227,195, 48, 15,229,141, 48, 36,   /* 0x 410 */
+227,160, 80,  0,226,140, 48, 34,225,160,  0,  4,227,224,192,  0,   /* 0x 420 */
+229,157, 16, 36,225,160, 32,  5,229,141,192,  0,229,141, 80,  4,   /* 0x 430 */
+235,255,255, 75,227,160, 48, 52,224,100,176,  0,224,  3,  3,155,   /* 0x 440 */
+229,141,  0, 28,229,141, 48, 32,229,141, 80, 24,234,  0,  0,127,   /* 0x 450 */
+229,150, 48,  0,227, 83,  0,  6, 26,  0,  0,  5,229,150, 32,  8,   /* 0x 460 */
+229,157,  0,  8,224,139, 32,  2,227,160, 16,  3,235,255,255, 69,   /* 0x 470 */
+234,  0,  0,114,227, 83,  0,  1, 26,  0,  0,112,229,150, 48, 24,   /* 0x 480 */
+229,159, 34, 72,226,  3, 48,  7,225,160, 49,  3,225,160, 35, 50,   /* 0x 490 */
+229,150, 48,  8,229,157, 16, 12,224,139,144,  3,225,160, 10,  9,   /* 0x 4a0 */
+229,150, 48, 16,227, 81,  0,  0,225,160, 10, 32,229,150,192,  4,   /* 0x 4b0 */
+226,  2, 80,  7,229,150, 32, 20,224,131,128,  0,  5,157,224, 16,   /* 0x 4c0 */
+224, 96,112,  9,229,141, 48, 40,229,141, 32, 20, 19,224,224,  0,   /* 0x 4d0 */
+224, 96,192, 12,  1,160, 32,  5,  3,160, 48, 18, 19,133, 32,  2,   /* 0x 4e0 */
+ 19,160, 48, 50,225,160,  0,  7,225,160, 16,  8,229,141,144, 44,   /* 0x 4f0 */
+229,141,224,  0,229,141,192,  4,235,255,255, 25,225, 87,  0,  0,   /* 0x 500 */
+ 26,  0,  0, 59,229,157, 48, 12,227, 83,  0,  0, 10,  0,  0,  6,   /* 0x 510 */
+229,157, 16, 88,226, 21, 48,  4, 17,160, 48,  1,229,157,  0, 12,   /* 0x 520 */
+226,141, 16, 40,229,157, 32, 16,235,255,255, 62,226,104, 48,  0,   /* 0x 530 */
+225,160, 74,  3,227, 21,  0,  2,225,160, 74, 36, 10,  0,  0,  7,   /* 0x 540 */
+227, 84,  0,  0, 10,  0,  0,  5,224,135, 16,  8,225,160, 32,  4,   /* 0x 550 */
+227,160, 48,  0,226, 82, 32,  1,228,193, 48,  1, 26,255,255,251,   /* 0x 560 */
+229,157, 32, 12,227, 82,  0,  0, 10,  0,  0, 35,229,150, 48,  0,   /* 0x 570 */
+227, 83,  0,  1, 26,  0,  0, 24,229,150, 48, 24,227, 19,  0,  1,   /* 0x 580 */
+ 10,  0,  0, 21,229,150, 32, 20,229,150, 48, 16,225, 82,  0,  3,   /* 0x 590 */
+229,150, 16,  8, 26,  0,  0, 70,224,130, 48,  1,224,131, 32, 11,   /* 0x 5a0 */
+226, 98, 48,  0,225,160, 58,  3,225,160, 58, 35,227, 83,  0,  7,   /* 0x 5b0 */
+154,  0,  0, 63,229,159, 49, 24,229,130, 48,  0,229,159, 49, 20,   /* 0x 5c0 */
+229,130, 48,  4,234,  0,  0,  1,227, 82,  0,  0, 10,  0,  0,  2,   /* 0x 5d0 */
+229,157,  0,  8,227,160, 16,  0,235,255,254,234,225,160,  0,  7,   /* 0x 5e0 */
+225,160, 16,  8,225,160, 32,  5,235,255,254,219,227, 80,  0,  0,   /* 0x 5f0 */
+ 10,  0,  0,  1,227,160,  0,127,235,255,254,202,229,157, 32, 20,   /* 0x 600 */
+224,136, 48,  4,224,137, 16,  2,224,135, 64,  3,225, 84,  0,  1,   /* 0x 610 */
+ 42,  0,  0, 10,227,224,192,  0,229,141,192,  0,224,100, 16,  1,   /* 0x 620 */
+226,140,192,  1,225,160, 32,  5,225,160,  0,  4,227,160, 48, 50,   /* 0x 630 */
+229,141,192,  4,235,255,254,202,225, 84,  0,  0, 26,255,255,236,   /* 0x 640 */
+229,157, 48, 24,226,131, 48,  1,229,141, 48, 24,226,134, 96, 32,   /* 0x 650 */
+225,218, 50,188,229,157, 16, 24,225, 81,  0,  3,186,255,255,123,   /* 0x 660 */
+229,157, 32, 12,227, 82,  0,  0, 26,  0,  0,  4,229,157,  0, 16,   /* 0x 670 */
+235,255,254,179,227, 80,  0,  0, 26,255,255,221,234,  0,  0,  5,   /* 0x 680 */
+225,218, 49,176,227, 83,  0,  3, 21,157, 48, 28, 21,157, 16, 36,   /* 0x 690 */
+ 16,131,  0,  1, 27,255,254,172,229,157, 32, 84,227, 82,  0,  0,   /* 0x 6a0 */
+ 21,130,176,  0,229,154,  0, 24,224,139,  0,  0,226,141,208, 48,   /* 0x 6b0 */
+232,189,143,240,229,150, 48,  4,229,157, 32, 32,227, 83,  0,  0,   /* 0x 6c0 */
+224,129, 48,  2,226,131, 32,  8, 10,255,255,185,234,255,255,189,   /* 0x 6d0 */
+115, 81, 98, 64,239,144,  0, 91,225,160,240, 14,233, 45, 71,240,   /* 0x 6e0 */
+226, 77,208, 12,226,141,112, 52,225,160, 80,  0,225,160, 96,  1,   /* 0x 6f0 */
+225,160,160,  3,225,160,  0,  7,227,160, 48,  0,226,141, 16, 44,   /* 0x 700 */
+229,157,144, 48,225,160,128,  2,229,157, 64, 52,235,255,254,197,   /* 0x 710 */
+229,157, 48, 56,227,160, 16,  5,224,100, 48,  3,225,217, 34,188,   /* 0x 720 */
+225,160,  0,  5,229,141, 48, 56,229,141, 96, 52,235,255,254,149,   /* 0x 730 */
+225,160,  0,  5,227,160, 16,  4,225,217, 34,186,235,255,254,145,   /* 0x 740 */
+226,137, 96, 52,229,157, 32, 60,229,150, 48,  8,226,130, 32, 52,   /* 0x 750 */
+224,130, 32,  3,225,160,  0,  5,227,160, 16,  3,235,255,254,137,   /* 0x 760 */
+226,141,192,  8,225,160, 32,  7,225,160, 16,  9,225,160, 48,  5,   /* 0x 770 */
+225,160,  0,  8,229,141,192,  0,229,141,160,  4,235,255,254,251,   /* 0x 780 */
+225,160, 64,  0,227,160, 16,  9,225,160, 32,  4,225,160,  0,  5,   /* 0x 790 */
+235,255,254,124,225,217, 18,188,227,160, 32,  0,234,  0,  0, 29,   /* 0x 7a0 */
+229,150, 48,  0,227, 83,  0,  3, 26,  0,  0, 24,229,150, 48,  8,   /* 0x 7b0 */
+229,157,  0,  8,227,160, 16,  0,224,131,  0,  0,225,160, 32,  1,   /* 0x 7c0 */
+235,255,254, 93,226, 80, 64,  0,186,  0,  0,  4,225,160, 16,  9,   /* 0x 7d0 */
+227,160, 44,  2,235,255,254, 84,227, 80, 12,  2, 10,  0,  0,  1,   /* 0x 7e0 */
+227,160,  0,127,235,255,254, 79,227,160,192,  0,225,160,  0,  4,   /* 0x 7f0 */
+225,160, 32, 12,225,160, 16,  9,225,160, 48, 12,229,141,192,  0,   /* 0x 800 */
+229,141,192,  4,235,255,254,217,225,160, 64,  0,234,  0,  0,  3,   /* 0x 810 */
+226,134, 96, 32,226,130, 32,  1,225, 82,  0,  1,186,255,255,223,   /* 0x 820 */
+225,160,  0,  4,226,141,208, 12,232,189,135,240                    /* 0x 830 */
+};

src/stub/i086-dos16.com.h

@@ -1,4 +1,5 @@
-/* i086-dos16.com.h -- created from i086-dos16.com.bin, 9011 (0x2333) bytes
+/* i086-dos16.com.h
+   created from i086-dos16.com.bin, 6080 (0x17c0) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,16 +28,16 @@
  */
 
 
-#define NRV2B_LOADER_SIZE    9011
+#define STUB_I086_DOS16_COM_SIZE    6080
-#define NRV2B_LOADER_ADLER32 0x6fc3e6ea
+#define STUB_I086_DOS16_COM_ADLER32 0xa2eb419f
-#define NRV2B_LOADER_CRC32   0xadb67b7e
+#define STUB_I086_DOS16_COM_CRC32   0x4455eb6c
 
-unsigned char nrv2b_loader[9011] = {
+unsigned char stub_i086_dos16_com[6080] = {
 127, 69, 76, 70,  1,  1,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   1,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  10 */
  72,  2,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,  0,  0, 40,  0,   /* 0x  20 */
  46,  0, 43,  0,129,252,  0,  0,119,  2,205, 32,185,  0,  0,190,   /* 0x  30 */
-  0,  0,191,  0,  0,187,  0,128,253,243,164,252,135,247,131,198,   /* 0x  40 */
+  0,  0,191,  0,  0,187,  0,128,253,243,164,252,135,247,131,238,   /* 0x  40 */
   0, 25,237, 87, 87,233,255,255, 85, 80, 88, 33,161,216,208,213,   /* 0x  50 */
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 45,164,232,   /* 0x  60 */
  11,  0,114,250, 65,232,  6,  0,227, 21,227, 20,115,  6,131,233,   /* 0x  70 */
@@ -44,556 +45,372 @@ unsigned char nrv2b_loader[9011] = {
 117,  8, 65,232,  6,  0,115,251, 65, 65, 65,129,253,  0,243,131,   /* 0x  90 */
 209,  1,141,  3,150,243,164,150,235,  0,232,  2,  0, 17,201,  1,   /* 0x  a0 */
 219,117,  4,173, 17,192,147,195, 94,185,  0,  0,172, 44,232, 60,   /* 0x  b0 */
-  1,119,249,193,  4,  8, 41, 52,139, 28,134,251, 41,243,137, 28,   /* 0x  c0 */
+  1,119,249,193,  4,  8, 41, 52,139, 28,134,223, 41,243,137, 28,   /* 0x  c0 */
 173,226,  3,176,232,176,233, 95,185,  0,  0,242,174,117, 20,117,   /* 0x  d0 */
-  2,193,  5,  8, 41, 61,139, 29,134,251, 41,251,137, 29,175,235,   /* 0x  e0 */
+  2,193,  5,  8, 41, 61,139, 29,134,223, 41,251,137, 29,175,235,   /* 0x  e0 */
-  3,195,  0, 46,115,121,109,116, 97, 98,  0, 46,115,116,114,116,   /* 0x  f0 */
+  3,195,116,109,112, 47,105, 48, 56, 54, 45,100,111,115, 49, 54,   /* 0x  f0 */
- 97, 98,  0, 46,115,104,115,116,114,116, 97, 98,  0, 46,114,101,   /* 0x 100 */
+ 46, 99,111,109, 46, 98,105,110, 58, 32, 32, 32, 32, 32,102,105,   /* 0x 100 */
-108, 67, 79, 77, 77, 65, 73, 78, 49,  0, 67, 79, 77, 83, 66, 66,   /* 0x 110 */
+108,101, 32,102,111,114,109, 97,116, 32,101,108,102, 51, 50, 45,   /* 0x 110 */
- 66, 80,  0, 67, 79, 77, 80, 83, 72, 68, 73,  0, 67, 79, 77, 67,   /* 0x 120 */
+105, 51, 56, 54, 10, 10, 83,101, 99,116,105,111,110,115, 58, 10,   /* 0x 120 */
- 65, 76, 76, 84,  0, 46,114,101,108, 67, 79, 77, 77, 65, 73, 78,   /* 0x 130 */
+ 73,100,120, 32, 78, 97,109,101, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x 130 */
- 50,  0, 85, 80, 88, 49, 72, 69, 65, 68,  0, 67, 79, 77, 67, 85,   /* 0x 140 */
+ 32, 32, 83,105,122,101, 32, 32, 32, 32, 32, 32, 86, 77, 65, 32,   /* 0x 140 */
- 84, 80, 79,  0, 46,114,101,108, 78, 82, 86, 50, 66, 49, 54, 48,   /* 0x 150 */
+ 32, 32, 32, 32, 32, 32, 76, 77, 65, 32, 32, 32, 32, 32, 32, 32,   /* 0x 150 */
-  0, 46,114,101,108, 78, 82, 86, 68, 68, 79, 78, 69,  0, 46,114,   /* 0x 160 */
+ 70,105,108,101, 32,111,102,102, 32, 32, 65,108,103,110, 32, 32,   /* 0x 160 */
-101,108, 78, 82, 86, 68, 82, 69, 84, 85,  0, 46,114,101,108, 78,   /* 0x 170 */
+ 70,108, 97,103,115, 10, 32, 32, 48, 32, 67, 79, 77, 77, 65, 73,   /* 0x 170 */
- 82, 86, 68, 69, 67, 79, 49,  0, 78, 82, 86, 76, 69, 68, 48, 48,   /* 0x 180 */
+ 78, 49, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49,100,   /* 0x 180 */
-  0, 78, 82, 86, 71, 84, 68, 48, 48,  0, 46,114,101,108, 78, 82,   /* 0x 190 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x 190 */
- 86, 68, 69, 67, 79, 50,  0, 46,114,101,108, 67, 65, 76, 76, 84,   /* 0x 1a0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 51, 52, 32, 32,   /* 0x 1a0 */
- 82, 49, 54,  0, 67, 84, 49, 54, 73, 50, 56, 54,  0, 67, 84, 49,   /* 0x 1b0 */
+ 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x 1b0 */
- 54, 83, 85, 66, 48,  0, 67, 84, 49, 54, 73, 48, 56, 54,  0, 46,   /* 0x 1c0 */
+ 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10,   /* 0x 1c0 */
-114,101,108, 67, 65, 76, 76, 84, 82, 73, 50,  0, 67, 84, 49, 54,   /* 0x 1d0 */
+ 32, 32, 49, 32, 67, 79, 77, 83, 66, 66, 66, 80, 32, 32, 32, 32,   /* 0x 1d0 */
- 69, 56, 48, 48,  0, 67, 84, 49, 54, 69, 57, 48, 48,  0, 46,114,   /* 0x 1e0 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48,   /* 0x 1e0 */
-101,108, 67, 65, 76, 76, 84, 82, 73, 53,  0, 46,114,101,108, 67,   /* 0x 1f0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x 1f0 */
- 84, 49, 54, 74, 69, 78, 68,  0, 46,114,101,108, 67, 84, 49, 54,   /* 0x 200 */
+ 48, 48, 48, 48, 48, 48, 53, 49, 32, 32, 50, 42, 42, 48, 32, 32,   /* 0x 200 */
- 74, 85, 76, 50,  0, 67, 84, 49, 54, 73, 50, 56, 55,  0, 67, 84,   /* 0x 210 */
+ 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x 210 */
- 49, 54, 83, 85, 66, 49,  0, 67, 84, 49, 54, 73, 48, 56, 55,  0,   /* 0x 220 */
+ 76, 89, 10, 32, 32, 50, 32, 67, 79, 77, 80, 83, 72, 68, 73, 32,   /* 0x 220 */
- 46,114,101,108, 67, 65, 76, 76, 84, 82, 73, 54,  0, 67, 79, 82,   /* 0x 230 */
+ 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32, 48,   /* 0x 230 */
- 69, 84, 85, 82, 78,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 240 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x 240 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 250 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 53, 51, 32, 32, 50, 42, 42,   /* 0x 250 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 260 */
+ 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65,   /* 0x 260 */
- 31,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 270 */
+ 68, 79, 78, 76, 89, 10, 32, 32, 51, 32, 67, 79, 77, 67, 65, 76,   /* 0x 270 */
- 52,  0,  0,  0, 29,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 280 */
+ 76, 84, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49,   /* 0x 280 */
-  1,  0,  0,  0,  0,  0,  0,  0, 27,  0,  0,  0,  9,  0,  0,  0,   /* 0x 290 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x 290 */
-  0,  0,  0,  0,  0,  0,  0,  0,240, 11,  0,  0, 40,  0,  0,  0,   /* 0x 2a0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 53, 52, 32, 32,   /* 0x 2a0 */
- 44,  0,  0,  0,  1,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,   /* 0x 2b0 */
+ 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x 2b0 */
- 40,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 2c0 */
+ 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 52, 32, 67, 79, 77,   /* 0x 2c0 */
- 81,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 2d0 */
+ 77, 65, 73, 78, 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x 2d0 */
-  1,  0,  0,  0,  0,  0,  0,  0, 49,  0,  0,  0,  1,  0,  0,  0,   /* 0x 2e0 */
+ 48, 48, 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x 2e0 */
-  0,  0,  0,  0,  0,  0,  0,  0, 83,  0,  0,  0,  1,  0,  0,  0,   /* 0x 2f0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 53,   /* 0x 2f0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 300 */
+ 53, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x 300 */
- 58,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 310 */
+ 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x 310 */
- 84,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 320 */
+ 76, 89, 10, 32, 32, 53, 32, 85, 80, 88, 49, 72, 69, 65, 68, 32,   /* 0x 320 */
-  1,  0,  0,  0,  0,  0,  0,  0, 71,  0,  0,  0,  1,  0,  0,  0,   /* 0x 330 */
+ 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49, 54, 32, 32, 48,   /* 0x 330 */
-  0,  0,  0,  0,  0,  0,  0,  0, 85,  0,  0,  0,  3,  0,  0,  0,   /* 0x 340 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x 340 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 350 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 53, 56, 32, 32, 50, 42, 42,   /* 0x 350 */
- 67,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 360 */
+ 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65,   /* 0x 360 */
- 24, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0,  6,  0,  0,  0,   /* 0x 370 */
+ 68, 79, 78, 76, 89, 10, 32, 32, 54, 32, 67, 79, 77, 67, 85, 84,   /* 0x 370 */
-  4,  0,  0,  0,  8,  0,  0,  0, 80,  0,  0,  0,  1,  0,  0,  0,   /* 0x 380 */
+ 80, 79, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x 380 */
-  0,  0,  0,  0,  0,  0,  0,  0, 88,  0,  0,  0, 22,  0,  0,  0,   /* 0x 390 */
+ 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x 390 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 3a0 */
+ 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 54,101, 32, 32,   /* 0x 3a0 */
- 89,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 3b0 */
+ 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x 3b0 */
-110,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 3c0 */
+ 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 55, 32, 78, 82, 86,   /* 0x 3c0 */
-  1,  0,  0,  0,  0,  0,  0,  0,102,  0,  0,  0,  1,  0,  0,  0,   /* 0x 3d0 */
+ 50, 66, 49, 54, 48, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x 3d0 */
-  0,  0,  0,  0,  0,  0,  0,  0,110,  0,  0,  0, 10,  0,  0,  0,   /* 0x 3e0 */
+ 48, 48, 97, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x 3e0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 3f0 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 54,   /* 0x 3f0 */
- 98,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 400 */
+101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x 400 */
- 32, 12,  0,  0, 16,  0,  0,  0, 44,  0,  0,  0, 10,  0,  0,  0,   /* 0x 410 */
+ 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x 410 */
-  4,  0,  0,  0,  8,  0,  0,  0,115,  0,  0,  0,  1,  0,  0,  0,   /* 0x 420 */
+ 76, 89, 10, 32, 32, 56, 32, 78, 82, 86, 68, 68, 79, 78, 69, 32,   /* 0x 420 */
-  0,  0,  0,  0,  0,  0,  0,  0,120,  0,  0,  0,  2,  0,  0,  0,   /* 0x 430 */
+ 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48,   /* 0x 430 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 440 */
+ 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x 440 */
-111,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 450 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 55, 56, 32, 32, 50, 42, 42,   /* 0x 450 */
- 48, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0, 12,  0,  0,  0,   /* 0x 460 */
+ 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76,   /* 0x 460 */
-  4,  0,  0,  0,  8,  0,  0,  0,128,  0,  0,  0,  1,  0,  0,  0,   /* 0x 470 */
+ 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 57,   /* 0x 470 */
-  0,  0,  0,  0,  0,  0,  0,  0,122,  0,  0,  0,  2,  0,  0,  0,   /* 0x 480 */
+ 32, 78, 82, 86, 68, 82, 69, 84, 85, 32, 32, 32, 32, 32, 32, 48,   /* 0x 480 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 490 */
+ 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x 490 */
-124,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 4a0 */
+ 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x 4a0 */
- 56, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0, 14,  0,  0,  0,   /* 0x 4b0 */
+ 48, 48, 48, 55, 97, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78,   /* 0x 4b0 */
-  4,  0,  0,  0,  8,  0,  0,  0,141,  0,  0,  0,  1,  0,  0,  0,   /* 0x 4c0 */
+ 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69,   /* 0x 4c0 */
-  0,  0,  0,  0,  0,  0,  0,  0,124,  0,  0,  0, 30,  0,  0,  0,   /* 0x 4d0 */
+ 65, 68, 79, 78, 76, 89, 10, 32, 49, 48, 32, 78, 82, 86, 68, 69,   /* 0x 4d0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 4e0 */
+ 67, 79, 49, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49,   /* 0x 4e0 */
-137,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 4f0 */
+101, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x 4f0 */
- 64, 12,  0,  0, 24,  0,  0,  0, 44,  0,  0,  0, 16,  0,  0,  0,   /* 0x 500 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 55, 99, 32,   /* 0x 500 */
-  4,  0,  0,  0,  8,  0,  0,  0,150,  0,  0,  0,  1,  0,  0,  0,   /* 0x 510 */
+ 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x 510 */
-  0,  0,  0,  0,  0,  0,  0,  0,154,  0,  0,  0,  1,  0,  0,  0,   /* 0x 520 */
+ 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x 520 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 530 */
+ 10, 32, 49, 49, 32, 78, 82, 86, 76, 69, 68, 48, 48, 32, 32, 32,   /* 0x 530 */
-159,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 540 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32, 48, 48, 48,   /* 0x 540 */
-155,  0,  0,  0,  7,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 550 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x 550 */
-  1,  0,  0,  0,  0,  0,  0,  0,172,  0,  0,  0,  1,  0,  0,  0,   /* 0x 560 */
+ 32, 48, 48, 48, 48, 48, 48, 57, 97, 32, 32, 50, 42, 42, 48, 32,   /* 0x 560 */
-  0,  0,  0,  0,  0,  0,  0,  0,162,  0,  0,  0, 22,  0,  0,  0,   /* 0x 570 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79,   /* 0x 570 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 580 */
+ 78, 76, 89, 10, 32, 49, 50, 32, 78, 82, 86, 71, 84, 68, 48, 48,   /* 0x 580 */
-168,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 590 */
+ 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 55, 32, 32,   /* 0x 590 */
- 88, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0, 20,  0,  0,  0,   /* 0x 5a0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 5a0 */
-  4,  0,  0,  0,  8,  0,  0,  0,185,  0,  0,  0,  1,  0,  0,  0,   /* 0x 5b0 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 57, 98, 32, 32, 50, 42,   /* 0x 5b0 */
-  0,  0,  0,  0,  0,  0,  0,  0,184,  0,  0,  0, 11,  0,  0,  0,   /* 0x 5c0 */
+ 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x 5c0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 5d0 */
+ 65, 68, 79, 78, 76, 89, 10, 32, 49, 51, 32, 78, 82, 86, 68, 69,   /* 0x 5d0 */
-181,  0,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 5e0 */
+ 67, 79, 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49,   /* 0x 5e0 */
- 96, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0, 22,  0,  0,  0,   /* 0x 5f0 */
+ 54, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x 5f0 */
-  4,  0,  0,  0,  8,  0,  0,  0,194,  0,  0,  0,  1,  0,  0,  0,   /* 0x 600 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 97, 50, 32,   /* 0x 600 */
-  0,  0,  0,  0,  0,  0,  0,  0,195,  0,  0,  0,  3,  0,  0,  0,   /* 0x 610 */
+ 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x 610 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 620 */
+ 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x 620 */
-203,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 630 */
+ 10, 32, 49, 52, 32, 67, 65, 76, 76, 84, 82, 49, 54, 32, 32, 32,   /* 0x 630 */
-198,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 640 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 98, 32, 32, 48, 48, 48,   /* 0x 640 */
-  1,  0,  0,  0,  0,  0,  0,  0,212,  0,  0,  0,  1,  0,  0,  0,   /* 0x 650 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x 650 */
-  0,  0,  0,  0,  0,  0,  0,  0,200,  0,  0,  0,  8,  0,  0,  0,   /* 0x 660 */
+ 32, 48, 48, 48, 48, 48, 48, 98, 56, 32, 32, 50, 42, 42, 48, 32,   /* 0x 660 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 670 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67,   /* 0x 670 */
-225,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 680 */
+ 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 53, 32, 67,   /* 0x 680 */
-208,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 690 */
+ 84, 49, 54, 73, 50, 56, 54, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x 690 */
-  1,  0,  0,  0,  0,  0,  0,  0,221,  0,  0,  0,  9,  0,  0,  0,   /* 0x 6a0 */
+ 48, 48, 48, 48, 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x 6a0 */
-  0,  0,  0,  0,  0,  0,  0,  0,104, 12,  0,  0,  8,  0,  0,  0,   /* 0x 6b0 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x 6b0 */
- 44,  0,  0,  0, 27,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,   /* 0x 6c0 */
+ 48, 99, 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x 6c0 */
-234,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 6d0 */
+ 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49,   /* 0x 6d0 */
-211,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 6e0 */
+ 54, 32, 67, 84, 49, 54, 83, 85, 66, 48, 32, 32, 32, 32, 32, 32,   /* 0x 6e0 */
-  1,  0,  0,  0,  0,  0,  0,  0,243,  0,  0,  0,  1,  0,  0,  0,   /* 0x 6f0 */
+ 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 6f0 */
-  0,  0,  0,  0,  0,  0,  0,  0,213,  0,  0,  0,  2,  0,  0,  0,   /* 0x 700 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x 700 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 710 */
+ 48, 48, 48, 48, 99, 54, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x 710 */
-  0,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 720 */
+ 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x 720 */
-215,  0,  0,  0,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 730 */
+ 10, 32, 49, 55, 32, 67, 84, 49, 54, 73, 48, 56, 54, 32, 32, 32,   /* 0x 730 */
-  1,  0,  0,  0,  0,  0,  0,  0,252,  0,  0,  0,  9,  0,  0,  0,   /* 0x 740 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 56, 32, 32, 48, 48, 48,   /* 0x 740 */
-  0,  0,  0,  0,  0,  0,  0,  0,112, 12,  0,  0,  8,  0,  0,  0,   /* 0x 750 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x 750 */
- 44,  0,  0,  0, 31,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,   /* 0x 760 */
+ 32, 48, 48, 48, 48, 48, 48, 99, 56, 32, 32, 50, 42, 42, 48, 32,   /* 0x 760 */
- 13,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 770 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79,   /* 0x 770 */
-221,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 780 */
+ 78, 76, 89, 10, 32, 49, 56, 32, 67, 65, 76, 76, 84, 82, 73, 50,   /* 0x 780 */
-  1,  0,  0,  0,  0,  0,  0,  0,  9,  1,  0,  0,  9,  0,  0,  0,   /* 0x 790 */
+ 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 51, 32, 32,   /* 0x 790 */
-  0,  0,  0,  0,  0,  0,  0,  0,120, 12,  0,  0,  8,  0,  0,  0,   /* 0x 7a0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 7a0 */
- 44,  0,  0,  0, 33,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,   /* 0x 7b0 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,100, 48, 32, 32, 50, 42,   /* 0x 7b0 */
- 26,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 7c0 */
+ 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x 7c0 */
-223,  0,  0,  0,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 7d0 */
+ 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49,   /* 0x 7d0 */
-  1,  0,  0,  0,  0,  0,  0,  0, 22,  1,  0,  0,  9,  0,  0,  0,   /* 0x 7e0 */
+ 57, 32, 67, 84, 49, 54, 69, 56, 48, 48, 32, 32, 32, 32, 32, 32,   /* 0x 7e0 */
-  0,  0,  0,  0,  0,  0,  0,  0,128, 12,  0,  0,  8,  0,  0,  0,   /* 0x 7f0 */
+ 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 7f0 */
- 44,  0,  0,  0, 35,  0,  0,  0,  4,  0,  0,  0,  8,  0,  0,  0,   /* 0x 800 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x 800 */
- 35,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 810 */
+ 48, 48, 48, 48,100, 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x 810 */
-225,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 820 */
+ 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x 820 */
-  1,  0,  0,  0,  0,  0,  0,  0, 44,  1,  0,  0,  1,  0,  0,  0,   /* 0x 830 */
+ 10, 32, 50, 48, 32, 67, 84, 49, 54, 69, 57, 48, 48, 32, 32, 32,   /* 0x 830 */
-  0,  0,  0,  0,  0,  0,  0,  0,228,  0,  0,  0,  2,  0,  0,  0,   /* 0x 840 */
+ 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48,   /* 0x 840 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 850 */
+ 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x 850 */
- 53,  1,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 860 */
+ 32, 48, 48, 48, 48, 48, 48,100, 53, 32, 32, 50, 42, 42, 48, 32,   /* 0x 860 */
-230,  0,  0,  0,  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 870 */
+ 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79,   /* 0x 870 */
-  1,  0,  0,  0,  0,  0,  0,  0, 66,  1,  0,  0,  1,  0,  0,  0,   /* 0x 880 */
+ 78, 76, 89, 10, 32, 50, 49, 32, 67, 65, 76, 76, 84, 82, 73, 53,   /* 0x 880 */
-  0,  0,  0,  0,  0,  0,  0,  0,238,  0,  0,  0,  3,  0,  0,  0,   /* 0x 890 */
+ 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 54, 32, 32,   /* 0x 890 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 8a0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 8a0 */
- 62,  1,  0,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 8b0 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,100, 55, 32, 32, 50, 42,   /* 0x 8b0 */
-136, 12,  0,  0,  8,  0,  0,  0, 44,  0,  0,  0, 40,  0,  0,  0,   /* 0x 8c0 */
+ 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x 8c0 */
-  4,  0,  0,  0,  8,  0,  0,  0, 75,  1,  0,  0,  1,  0,  0,  0,   /* 0x 8d0 */
+ 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 50,   /* 0x 8d0 */
-  0,  0,  0,  0,  0,  0,  0,  0,241,  0,  0,  0,  1,  0,  0,  0,   /* 0x 8e0 */
+ 50, 32, 67, 84, 49, 54, 74, 69, 78, 68, 32, 32, 32, 32, 32, 32,   /* 0x 8e0 */
-  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x 8f0 */
+ 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 8f0 */
- 17,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 900 */
+ 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x 900 */
-242,  0,  0,  0, 84,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 910 */
+ 48, 48, 48, 48,100,100, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x 910 */
-  1,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  0,  2,  0,  0,  0,   /* 0x 920 */
+ 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82,   /* 0x 920 */
-  0,  0,  0,  0,  0,  0,  0,  0,120,  9,  0,  0, 48,  2,  0,  0,   /* 0x 930 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 32, 50, 51, 32, 67, 84, 49, 54,   /* 0x 930 */
- 45,  0,  0,  0, 30,  0,  0,  0,  4,  0,  0,  0, 16,  0,  0,  0,   /* 0x 940 */
+ 74, 85, 76, 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x 940 */
-  9,  0,  0,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 950 */
+ 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x 950 */
-168, 11,  0,  0, 69,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 960 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,100,102,   /* 0x 960 */
-  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 970 */
+ 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x 970 */
-  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 980 */
+ 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x 980 */
-  0,  0,  0,  0,  3,  0,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 990 */
+ 89, 10, 32, 50, 52, 32, 67, 84, 49, 54, 73, 50, 56, 55, 32, 32,   /* 0x 990 */
-  0,  0,  0,  0,  3,  0, 10,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9a0 */
+ 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 51, 32, 32, 48, 48,   /* 0x 9a0 */
-  0,  0,  0,  0,  3,  0, 20,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9b0 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x 9b0 */
-  0,  0,  0,  0,  3,  0, 22,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9c0 */
+ 32, 32, 48, 48, 48, 48, 48, 48,101, 49, 32, 32, 50, 42, 42, 48,   /* 0x 9c0 */
-  0,  0,  0,  0,  3,  0, 31,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9d0 */
+ 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68,   /* 0x 9d0 */
-  0,  0,  0,  0,  3,  0, 40,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9e0 */
+ 79, 78, 76, 89, 10, 32, 50, 53, 32, 67, 84, 49, 54, 83, 85, 66,   /* 0x 9e0 */
-  0,  0,  0,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x 9f0 */
+ 49, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32,   /* 0x 9f0 */
-  0,  0,  0,  0,  3,  0,  3,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a00 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x a00 */
-  0,  0,  0,  0,  3,  0,  4,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a10 */
+ 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,101, 52, 32, 32, 50,   /* 0x a10 */
-  0,  0,  0,  0,  3,  0,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a20 */
+ 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x a20 */
-  0,  0,  0,  0,  3,  0,  6,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a30 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 32, 50, 54, 32, 67, 84, 49, 54,   /* 0x a30 */
-  0,  0,  0,  0,  3,  0,  8,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a40 */
+ 73, 48, 56, 55, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x a40 */
-  0,  0,  0,  0,  3,  0, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a50 */
+ 48, 56, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x a50 */
-  0,  0,  0,  0,  3,  0, 14,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a60 */
+ 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,101, 54,   /* 0x a60 */
-  0,  0,  0,  0,  3,  0, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a70 */
+ 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83,   /* 0x a70 */
-  0,  0,  0,  0,  3,  0, 18,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a80 */
+ 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 50, 55, 32, 67,   /* 0x a80 */
-  0,  0,  0,  0,  3,  0, 19,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x a90 */
+ 65, 76, 76, 84, 82, 73, 54, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x a90 */
-  0,  0,  0,  0,  3,  0, 24,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x aa0 */
+ 48, 48, 48, 48, 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x aa0 */
-  0,  0,  0,  0,  3,  0, 25,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x ab0 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x ab0 */
-  0,  0,  0,  0,  3,  0, 26,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x ac0 */
+ 48,101,101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x ac0 */
-  0,  0,  0,  0,  3,  0, 27,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x ad0 */
+ 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68,   /* 0x ad0 */
-  0,  0,  0,  0,  3,  0, 29,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x ae0 */
+ 79, 78, 76, 89, 10, 32, 50, 56, 32, 67, 79, 82, 69, 84, 85, 82,   /* 0x ae0 */
-  0,  0,  0,  0,  3,  0, 30,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x af0 */
+ 78, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32,   /* 0x af0 */
-  0,  0,  0,  0,  3,  0, 33,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b00 */
+ 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x b00 */
-  0,  0,  0,  0,  3,  0, 35,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b10 */
+ 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,102, 49, 32, 32, 50,   /* 0x b10 */
-  0,  0,  0,  0,  3,  0, 37,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b20 */
+ 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x b20 */
-  0,  0,  0,  0,  3,  0, 38,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b30 */
+ 69, 65, 68, 79, 78, 76, 89, 10, 83, 89, 77, 66, 79, 76, 32, 84,   /* 0x b30 */
-  0,  0,  0,  0,  3,  0, 39,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x b40 */
+ 65, 66, 76, 69, 58, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x b40 */
-  0,  0,  0,  0,  3,  0, 42,  0,  1,  0,  0,  0,  0,  0,  0,  0,   /* 0x b50 */
+ 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 50, 66, 49, 54, 48,  9,   /* 0x b50 */
-  0,  0,  0,  0, 16,  0,  0,  0, 10,  0,  0,  0,  0,  0,  0,  0,   /* 0x b60 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 50, 66, 49, 54,   /* 0x b60 */
-  0,  0,  0,  0, 16,  0,  0,  0, 24,  0,  0,  0,  0,  0,  0,  0,   /* 0x b70 */
+ 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x b70 */
-  0,  0,  0,  0, 16,  0,  0,  0, 36,  0,  0,  0,  0,  0,  0,  0,   /* 0x b80 */
+100, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50,  9, 48, 48, 48, 48,   /* 0x b80 */
-  0,  0,  0,  0, 16,  0,  0,  0, 53,  0,  0,  0,  0,  0,  0,  0,   /* 0x b90 */
+ 48, 48, 48, 48, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48, 48,   /* 0x b90 */
-  0,  0,  0,  0, 16,  0,  0,  0,  0,115,112, 95,108,105,109,105,   /* 0x ba0 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67,   /* 0x ba0 */
-116,  0, 98,121,116,101,115, 95,116,111, 95, 99,111,112,121,  0,   /* 0x bb0 */
+ 65, 76, 76, 84, 82, 49, 54,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x bb0 */
- 99,111,112,121, 95,115,111,117,114, 99,101,  0, 99,111,112,121,   /* 0x bc0 */
+ 32, 67, 65, 76, 76, 84, 82, 49, 54, 10, 48, 48, 48, 48, 48, 48,   /* 0x bc0 */
- 95,100,101,115,116,105,110, 97,116,105,111,110,  0, 99, 97,108,   /* 0x bd0 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 65, 76, 76, 84,   /* 0x bd0 */
-108,116,114,105, 99,107, 95, 99, 97,108,108,115,  0,  0,  0,  0,   /* 0x be0 */
+ 82, 73, 53,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 65, 76,   /* 0x be0 */
-  2,  0,  0,  0, 20, 30,  0,  0,  9,  0,  0,  0, 20, 31,  0,  0,   /* 0x bf0 */
+ 76, 84, 82, 73, 53, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x bf0 */
- 12,  0,  0,  0, 20, 32,  0,  0, 15,  0,  0,  0, 20, 33,  0,  0,   /* 0x c00 */
+ 32, 32, 32, 32,100, 32, 32, 67, 65, 76, 76, 84, 82, 73, 54,  9,   /* 0x c00 */
- 28,  0,  0,  0, 22,  1,  0,  0,  1,  0,  0,  0, 21,  2,  0,  0,   /* 0x c10 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 65, 76, 76, 84, 82, 73,   /* 0x c10 */
-  2,  0,  0,  0, 21,  3,  0,  0,  8,  0,  0,  0, 21,  3,  0,  0,   /* 0x c20 */
+ 54, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x c20 */
-  1,  0,  0,  0, 23,  3,  0,  0,  1,  0,  0,  0, 23,  3,  0,  0,   /* 0x c30 */
+100, 32, 32, 67, 79, 77, 77, 65, 73, 78, 49,  9, 48, 48, 48, 48,   /* 0x c30 */
- 16,  0,  0,  0, 21,  3,  0,  0, 24,  0,  0,  0, 21,  3,  0,  0,   /* 0x c40 */
+ 48, 48, 48, 48, 32, 67, 79, 77, 77, 65, 73, 78, 49, 10, 48, 48,   /* 0x c40 */
-  1,  0,  0,  0, 23,  2,  0,  0,  7,  0,  0,  0, 23,  2,  0,  0,   /* 0x c50 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67,   /* 0x c50 */
-  2,  0,  0,  0, 20, 34,  0,  0,  2,  0,  0,  0, 23,  4,  0,  0,   /* 0x c60 */
+ 79, 77, 83, 66, 66, 66, 80,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x c60 */
-  2,  0,  0,  0, 20, 34,  0,  0,  1,  0,  0,  0, 23,  3,  0,  0,   /* 0x c70 */
+ 32, 67, 79, 77, 83, 66, 66, 66, 80, 10, 48, 48, 48, 48, 48, 48,   /* 0x c70 */
-  1,  0,  0,  0, 23,  6,  0,  0,  2,  0,  0,  0, 23,  5,  0,  0,   /* 0x c80 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 79, 77, 80, 83,   /* 0x c80 */
-116,109,112, 47,105, 48, 56, 54, 45,100,111,115, 49, 54, 46, 99,   /* 0x c90 */
+ 72, 68, 73,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 79, 77,   /* 0x c90 */
-111,109, 46, 98,105,110, 58, 32, 32, 32, 32, 32,102,105,108,101,   /* 0x ca0 */
+ 80, 83, 72, 68, 73, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x ca0 */
- 32,102,111,114,109, 97,116, 32,101,108,102, 51, 50, 45,105, 51,   /* 0x cb0 */
+ 32, 32, 32, 32,100, 32, 32, 67, 79, 77, 67, 65, 76, 76, 84,  9,   /* 0x cb0 */
- 56, 54, 10, 10, 83,101, 99,116,105,111,110,115, 58, 10, 73,100,   /* 0x cc0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 79, 77, 67, 65, 76, 76,   /* 0x cc0 */
-120, 32, 78, 97,109,101, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x cd0 */
+ 84, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x cd0 */
- 83,105,122,101, 32, 32, 32, 32, 32, 32, 86, 77, 65, 32, 32, 32,   /* 0x ce0 */
+100, 32, 32, 67, 79, 77, 77, 65, 73, 78, 50,  9, 48, 48, 48, 48,   /* 0x ce0 */
- 32, 32, 32, 32, 76, 77, 65, 32, 32, 32, 32, 32, 32, 32, 70,105,   /* 0x cf0 */
+ 48, 48, 48, 48, 32, 67, 79, 77, 77, 65, 73, 78, 50, 10, 48, 48,   /* 0x cf0 */
-108,101, 32,111,102,102, 32, 32, 65,108,103,110, 32, 32, 70,108,   /* 0x d00 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 85,   /* 0x d00 */
- 97,103,115, 10, 32, 32, 48, 32, 67, 79, 77, 77, 65, 73, 78, 49,   /* 0x d10 */
+ 80, 88, 49, 72, 69, 65, 68,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x d10 */
- 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49,100, 32, 32,   /* 0x d20 */
+ 32, 85, 80, 88, 49, 72, 69, 65, 68, 10, 48, 48, 48, 48, 48, 48,   /* 0x d20 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x d30 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 79, 77, 67, 85,   /* 0x d30 */
- 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 51, 52, 32, 32, 50, 42,   /* 0x d40 */
+ 84, 80, 79,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 79, 77,   /* 0x d40 */
- 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x d50 */
+ 67, 85, 84, 80, 79, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x d50 */
- 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32,   /* 0x d60 */
+ 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 68, 68, 79, 78, 69,  9,   /* 0x d60 */
- 49, 32, 67, 79, 77, 83, 66, 66, 66, 80, 32, 32, 32, 32, 32, 32,   /* 0x d70 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 68, 68, 79, 78,   /* 0x d70 */
- 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x d80 */
+ 69, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x d80 */
- 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48,   /* 0x d90 */
+100, 32, 32, 78, 82, 86, 68, 82, 69, 84, 85,  9, 48, 48, 48, 48,   /* 0x d90 */
- 48, 48, 48, 48, 53, 49, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79,   /* 0x da0 */
+ 48, 48, 48, 48, 32, 78, 82, 86, 68, 82, 69, 84, 85, 10, 48, 48,   /* 0x da0 */
- 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x db0 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78,   /* 0x db0 */
- 10, 32, 32, 50, 32, 67, 79, 77, 80, 83, 72, 68, 73, 32, 32, 32,   /* 0x dc0 */
+ 82, 86, 68, 69, 67, 79, 49,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x dc0 */
- 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32, 48, 48, 48,   /* 0x dd0 */
+ 32, 78, 82, 86, 68, 69, 67, 79, 49, 10, 48, 48, 48, 48, 48, 48,   /* 0x dd0 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x de0 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 76, 69,   /* 0x de0 */
- 32, 48, 48, 48, 48, 48, 48, 53, 51, 32, 32, 50, 42, 42, 48, 32,   /* 0x df0 */
+ 68, 48, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86,   /* 0x df0 */
- 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79,   /* 0x e00 */
+ 76, 69, 68, 48, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x e00 */
- 78, 76, 89, 10, 32, 32, 51, 32, 67, 79, 77, 67, 65, 76, 76, 84,   /* 0x e10 */
+ 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 71, 84, 68, 48, 48,  9,   /* 0x e10 */
- 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32,   /* 0x e20 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 71, 84, 68, 48,   /* 0x e20 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x e30 */
+ 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x e30 */
- 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 53, 52, 32, 32, 50, 42,   /* 0x e40 */
+100, 32, 32, 67, 84, 49, 54, 73, 50, 56, 54,  9, 48, 48, 48, 48,   /* 0x e40 */
- 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x e50 */
+ 48, 48, 48, 48, 32, 67, 84, 49, 54, 73, 50, 56, 54, 10, 48, 48,   /* 0x e50 */
- 65, 68, 79, 78, 76, 89, 10, 32, 32, 52, 32, 67, 79, 77, 77, 65,   /* 0x e60 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67,   /* 0x e60 */
- 73, 78, 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x e70 */
+ 84, 49, 54, 83, 85, 66, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x e70 */
- 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x e80 */
+ 32, 67, 84, 49, 54, 83, 85, 66, 48, 10, 48, 48, 48, 48, 48, 48,   /* 0x e80 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 53, 53, 32,   /* 0x e90 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 73,   /* 0x e90 */
- 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x ea0 */
+ 48, 56, 54,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49,   /* 0x ea0 */
- 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x eb0 */
+ 54, 73, 48, 56, 54, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x eb0 */
- 10, 32, 32, 53, 32, 85, 80, 88, 49, 72, 69, 65, 68, 32, 32, 32,   /* 0x ec0 */
+ 32, 32, 32, 32,100, 32, 32, 67, 65, 76, 76, 84, 82, 73, 50,  9,   /* 0x ec0 */
- 32, 32, 32, 48, 48, 48, 48, 48, 48, 49, 54, 32, 32, 48, 48, 48,   /* 0x ed0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 65, 76, 76, 84, 82, 73,   /* 0x ed0 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x ee0 */
+ 50, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x ee0 */
- 32, 48, 48, 48, 48, 48, 48, 53, 56, 32, 32, 50, 42, 42, 48, 32,   /* 0x ef0 */
+100, 32, 32, 67, 84, 49, 54, 69, 56, 48, 48,  9, 48, 48, 48, 48,   /* 0x ef0 */
- 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79,   /* 0x f00 */
+ 48, 48, 48, 48, 32, 67, 84, 49, 54, 69, 56, 48, 48, 10, 48, 48,   /* 0x f00 */
- 78, 76, 89, 10, 32, 32, 54, 32, 67, 79, 77, 67, 85, 84, 80, 79,   /* 0x f10 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67,   /* 0x f10 */
- 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x f20 */
+ 84, 49, 54, 69, 57, 48, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x f20 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,   /* 0x f30 */
+ 32, 67, 84, 49, 54, 69, 57, 48, 48, 10, 48, 48, 48, 48, 48, 48,   /* 0x f30 */
- 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 54,101, 32, 32, 50, 42,   /* 0x f40 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 74,   /* 0x f40 */
- 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69,   /* 0x f50 */
+ 69, 78, 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49,   /* 0x f50 */
- 65, 68, 79, 78, 76, 89, 10, 32, 32, 55, 32, 78, 82, 86, 50, 66,   /* 0x f60 */
+ 54, 74, 69, 78, 68, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x f60 */
- 49, 54, 48, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x f70 */
+ 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 74, 85, 76, 50,  9,   /* 0x f70 */
- 97, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48,   /* 0x f80 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49, 54, 74, 85, 76,   /* 0x f80 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 54,101, 32,   /* 0x f90 */
+ 50, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,   /* 0x f90 */
- 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44,   /* 0x fa0 */
+100, 32, 32, 67, 84, 49, 54, 73, 50, 56, 55,  9, 48, 48, 48, 48,   /* 0x fa0 */
- 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89,   /* 0x fb0 */
+ 48, 48, 48, 48, 32, 67, 84, 49, 54, 73, 50, 56, 55, 10, 48, 48,   /* 0x fb0 */
- 10, 32, 32, 56, 32, 78, 82, 86, 68, 68, 79, 78, 69, 32, 32, 32,   /* 0x fc0 */
+ 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67,   /* 0x fc0 */
- 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48,   /* 0x fd0 */
+ 84, 49, 54, 83, 85, 66, 49,  9, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x fd0 */
- 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x fe0 */
+ 32, 67, 84, 49, 54, 83, 85, 66, 49, 10, 48, 48, 48, 48, 48, 48,   /* 0x fe0 */
- 32, 48, 48, 48, 48, 48, 48, 55, 56, 32, 32, 50, 42, 42, 48, 32,   /* 0x ff0 */
+ 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 73,   /* 0x ff0 */
- 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67,   /* 0x1000 */
+ 48, 56, 55,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49,   /* 0x1000 */
- 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 32, 57, 32, 78,   /* 0x1010 */
+ 54, 73, 48, 56, 55, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108,   /* 0x1010 */
- 82, 86, 68, 82, 69, 84, 85, 32, 32, 32, 32, 32, 32, 48, 48, 48,   /* 0x1020 */
+ 32, 32, 32, 32,100, 32, 32, 67, 79, 82, 69, 84, 85, 82, 78,  9,   /* 0x1020 */
- 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1030 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 79, 82, 69, 84, 85, 82,   /* 0x1030 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1040 */
+ 78, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32,   /* 0x1040 */
- 48, 55, 97, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69,   /* 0x1050 */
+ 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48,   /* 0x1050 */
- 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68,   /* 0x1060 */
+ 48, 32,115,112, 95,108,105,109,105,116, 10, 48, 48, 48, 48, 48,   /* 0x1060 */
- 79, 78, 76, 89, 10, 32, 49, 48, 32, 78, 82, 86, 68, 69, 67, 79,   /* 0x1070 */
+ 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68,   /* 0x1070 */
- 49, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49,101, 32,   /* 0x1080 */
+ 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 98,121,116,101,115,   /* 0x1080 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1090 */
+ 95,116,111, 95, 99,111,112,121, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1090 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 55, 99, 32, 32, 50,   /* 0x10a0 */
+ 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x10a0 */
- 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x10b0 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 99,111,112,121, 95,115,111,   /* 0x10b0 */
- 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x10c0 */
+117,114, 99,101, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32,   /* 0x10c0 */
- 49, 49, 32, 78, 82, 86, 76, 69, 68, 48, 48, 32, 32, 32, 32, 32,   /* 0x10d0 */
+ 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48,   /* 0x10d0 */
- 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32, 48, 48, 48, 48, 48,   /* 0x10e0 */
+ 48, 48, 48, 48, 32, 99,111,112,121, 95,100,101,115,116,105,110,   /* 0x10e0 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x10f0 */
+ 97,116,105,111,110, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x10f0 */
- 48, 48, 48, 48, 48, 57, 97, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1100 */
+ 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48,   /* 0x1100 */
- 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x1110 */
+ 48, 48, 48, 48, 48, 32,110,101,103, 95,101, 95,108,101,110, 10,   /* 0x1110 */
- 89, 10, 32, 49, 50, 32, 78, 82, 86, 71, 84, 68, 48, 48, 32, 32,   /* 0x1120 */
+ 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1120 */
- 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 55, 32, 32, 48, 48,   /* 0x1130 */
+ 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1130 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1140 */
+ 99, 97,108,108,116,114,105, 99,107, 95, 99, 97,108,108,115, 10,   /* 0x1140 */
- 32, 32, 48, 48, 48, 48, 48, 48, 57, 98, 32, 32, 50, 42, 42, 48,   /* 0x1150 */
+ 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79,   /* 0x1150 */
- 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68,   /* 0x1160 */
+ 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 79, 77, 77, 65, 73, 78,   /* 0x1160 */
- 79, 78, 76, 89, 10, 32, 49, 51, 32, 78, 82, 86, 68, 69, 67, 79,   /* 0x1170 */
+ 49, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80,   /* 0x1170 */
- 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 49, 54, 32,   /* 0x1180 */
+ 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86,   /* 0x1180 */
- 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48,   /* 0x1190 */
+ 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 50, 32, 82, 95,   /* 0x1190 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 97, 50, 32, 32, 50,   /* 0x11a0 */
+ 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x11a0 */
- 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82,   /* 0x11b0 */
+115,112, 95,108,105,109,105,116, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x11b0 */
- 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x11c0 */
+ 57, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32,   /* 0x11c0 */
- 49, 52, 32, 67, 65, 76, 76, 84, 82, 49, 54, 32, 32, 32, 32, 32,   /* 0x11d0 */
+ 32, 32, 32, 32, 98,121,116,101,115, 95,116,111, 95, 99,111,112,   /* 0x11d0 */
- 32, 48, 48, 48, 48, 48, 48, 48, 98, 32, 32, 48, 48, 48, 48, 48,   /* 0x11e0 */
+121, 10, 48, 48, 48, 48, 48, 48, 48, 99, 32, 82, 95, 51, 56, 54,   /* 0x11e0 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x11f0 */
+ 95, 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 99,111,112,   /* 0x11f0 */
- 48, 48, 48, 48, 48, 98, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1200 */
+121, 95,115,111,117,114, 99,101, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1200 */
- 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32,   /* 0x1210 */
+102, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32,   /* 0x1210 */
- 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 53, 32, 67, 84, 49,   /* 0x1220 */
+ 32, 32, 32, 32, 99,111,112,121, 95,100,101,115,116,105,110, 97,   /* 0x1220 */
- 54, 73, 50, 56, 54, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x1230 */
+116,105,111,110, 10, 48, 48, 48, 48, 48, 48, 49, 99, 32, 82, 95,   /* 0x1230 */
- 48, 48, 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1240 */
+ 51, 56, 54, 95, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1240 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 99,   /* 0x1250 */
+110,101,103, 95,101, 95,108,101,110, 10, 10, 82, 69, 76, 79, 67,   /* 0x1250 */
- 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x1260 */
+ 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79,   /* 0x1260 */
- 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 54, 32,   /* 0x1270 */
+ 82, 32, 91, 67, 79, 77, 77, 65, 73, 78, 50, 93, 58, 10, 79, 70,   /* 0x1270 */
- 67, 84, 49, 54, 83, 85, 66, 48, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x1280 */
+ 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32,   /* 0x1280 */
- 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1290 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48,   /* 0x1290 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x12a0 */
+ 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54, 95, 80, 67,   /* 0x12a0 */
- 48, 48, 99, 54, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x12b0 */
+ 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 50, 66, 49,   /* 0x12b0 */
- 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x12c0 */
+ 54, 48, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x12c0 */
- 49, 55, 32, 67, 84, 49, 54, 73, 48, 56, 54, 32, 32, 32, 32, 32,   /* 0x12d0 */
+ 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 50,   /* 0x12d0 */
- 32, 48, 48, 48, 48, 48, 48, 48, 56, 32, 32, 48, 48, 48, 48, 48,   /* 0x12e0 */
+ 66, 49, 54, 48, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32,   /* 0x12e0 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x12f0 */
+ 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x12f0 */
- 48, 48, 48, 48, 48, 99, 56, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1300 */
+ 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 50,   /* 0x1300 */
- 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x1310 */
+ 32, 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32, 32, 32, 32, 32,   /* 0x1310 */
- 89, 10, 32, 49, 56, 32, 67, 65, 76, 76, 84, 82, 73, 50, 32, 32,   /* 0x1320 */
+ 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48, 48, 48, 48,   /* 0x1320 */
- 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 51, 32, 32, 48, 48,   /* 0x1330 */
+ 48, 48, 48, 56, 32, 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32,   /* 0x1330 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1340 */
+ 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10,   /* 0x1340 */
- 32, 32, 48, 48, 48, 48, 48, 48,100, 48, 32, 32, 50, 42, 42, 48,   /* 0x1350 */
+ 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79,   /* 0x1350 */
- 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79,   /* 0x1360 */
+ 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 68, 68, 79, 78,   /* 0x1360 */
- 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 49, 57, 32,   /* 0x1370 */
+ 69, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80,   /* 0x1370 */
- 67, 84, 49, 54, 69, 56, 48, 48, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x1380 */
+ 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86,   /* 0x1380 */
- 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1390 */
+ 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95,   /* 0x1390 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x13a0 */
+ 51, 56, 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x13a0 */
- 48, 48,100, 51, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x13b0 */
+ 78, 82, 86, 68, 69, 67, 79, 50, 10, 10, 82, 69, 76, 79, 67, 65,   /* 0x13b0 */
- 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32,   /* 0x13c0 */
+ 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82,   /* 0x13c0 */
- 50, 48, 32, 67, 84, 49, 54, 69, 57, 48, 48, 32, 32, 32, 32, 32,   /* 0x13d0 */
+ 32, 91, 78, 82, 86, 68, 82, 69, 84, 85, 93, 58, 10, 79, 70, 70,   /* 0x13d0 */
- 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48,   /* 0x13e0 */
+ 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32,   /* 0x13e0 */
- 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x13f0 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48,   /* 0x13f0 */
- 48, 48, 48, 48, 48,100, 53, 32, 32, 50, 42, 42, 48, 32, 32, 67,   /* 0x1400 */
+ 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54, 95, 80, 67, 56,   /* 0x1400 */
- 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78, 76,   /* 0x1410 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79,   /* 0x1410 */
- 89, 10, 32, 50, 49, 32, 67, 65, 76, 76, 84, 82, 73, 53, 32, 32,   /* 0x1420 */
+ 50, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69,   /* 0x1420 */
- 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 54, 32, 32, 48, 48,   /* 0x1430 */
+ 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 68, 69,   /* 0x1430 */
- 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1440 */
+ 67, 79, 49, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84,   /* 0x1440 */
- 32, 32, 48, 48, 48, 48, 48, 48,100, 55, 32, 32, 50, 42, 42, 48,   /* 0x1450 */
+ 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1450 */
- 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 76, 79,   /* 0x1460 */
+ 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 49, 48, 32,   /* 0x1460 */
- 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 50, 50, 32,   /* 0x1470 */
+ 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32, 32, 32, 32, 32, 32,   /* 0x1470 */
- 67, 84, 49, 54, 74, 69, 78, 68, 32, 32, 32, 32, 32, 32, 48, 48,   /* 0x1480 */
+ 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48, 48, 48, 48, 48,   /* 0x1480 */
- 48, 48, 48, 48, 48, 50, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1490 */
+ 48, 49, 56, 32, 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32, 32,   /* 0x1490 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x14a0 */
+ 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48,   /* 0x14a0 */
- 48, 48,100,100, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84,   /* 0x14b0 */
+ 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54, 95, 80, 67,   /* 0x14b0 */
- 69, 78, 84, 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65,   /* 0x14c0 */
+ 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 50, 66, 49,   /* 0x14c0 */
- 68, 79, 78, 76, 89, 10, 32, 50, 51, 32, 67, 84, 49, 54, 74, 85,   /* 0x14d0 */
+ 54, 48, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x14d0 */
- 76, 50, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50,   /* 0x14e0 */
+ 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 68,   /* 0x14e0 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x14f0 */
+ 69, 67, 79, 50, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32,   /* 0x14f0 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,100,102, 32, 32,   /* 0x1500 */
+ 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1500 */
- 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x1510 */
+ 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 55,   /* 0x1510 */
- 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78, 76, 89, 10,   /* 0x1520 */
+ 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32,   /* 0x1520 */
- 32, 50, 52, 32, 67, 84, 49, 54, 73, 50, 56, 55, 32, 32, 32, 32,   /* 0x1530 */
+ 32, 32, 32, 78, 82, 86, 50, 66, 49, 54, 48, 10, 10, 82, 69, 76,   /* 0x1530 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 51, 32, 32, 48, 48, 48, 48,   /* 0x1540 */
+ 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32,   /* 0x1540 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32,   /* 0x1550 */
+ 70, 79, 82, 32, 91, 67, 65, 76, 76, 84, 82, 49, 54, 93, 58, 10,   /* 0x1550 */
- 48, 48, 48, 48, 48, 48,101, 49, 32, 32, 50, 42, 42, 48, 32, 32,   /* 0x1560 */
+ 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x1560 */
- 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x1570 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x1570 */
- 76, 89, 10, 32, 50, 53, 32, 67, 84, 49, 54, 83, 85, 66, 49, 32,   /* 0x1580 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 50, 32, 82, 95, 51, 56, 54, 95,   /* 0x1580 */
- 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 50, 32, 32, 48,   /* 0x1590 */
+ 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 99, 97,108,108,   /* 0x1590 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x15a0 */
+116,114,105, 99,107, 95, 99, 97,108,108,115, 10, 10, 82, 69, 76,   /* 0x15a0 */
- 48, 32, 32, 48, 48, 48, 48, 48, 48,101, 52, 32, 32, 50, 42, 42,   /* 0x15b0 */
+ 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32,   /* 0x15b0 */
- 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65,   /* 0x15c0 */
+ 70, 79, 82, 32, 91, 67, 65, 76, 76, 84, 82, 73, 50, 93, 58, 10,   /* 0x15c0 */
- 68, 79, 78, 76, 89, 10, 32, 50, 54, 32, 67, 84, 49, 54, 73, 48,   /* 0x15d0 */
+ 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x15d0 */
- 56, 55, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 56,   /* 0x15e0 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x15e0 */
- 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48,   /* 0x15f0 */
+ 10, 48, 48, 48, 48, 48, 48, 48, 50, 32, 82, 95, 51, 56, 54, 95,   /* 0x15f0 */
- 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,101, 54, 32, 32,   /* 0x1600 */
+ 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 76, 76,   /* 0x1600 */
- 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32,   /* 0x1610 */
+ 84, 82, 49, 54, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78,   /* 0x1610 */
- 82, 69, 65, 68, 79, 78, 76, 89, 10, 32, 50, 55, 32, 67, 65, 76,   /* 0x1620 */
+ 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 65,   /* 0x1620 */
- 76, 84, 82, 73, 54, 32, 32, 32, 32, 32, 32, 48, 48, 48, 48, 48,   /* 0x1630 */
+ 76, 76, 84, 82, 73, 53, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32,   /* 0x1630 */
- 48, 48, 51, 32, 32, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 48,   /* 0x1640 */
+ 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1640 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48,101,   /* 0x1650 */
+ 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x1650 */
-101, 32, 32, 50, 42, 42, 48, 32, 32, 67, 79, 78, 84, 69, 78, 84,   /* 0x1660 */
+ 48, 50, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32,   /* 0x1660 */
- 83, 44, 32, 82, 69, 76, 79, 67, 44, 32, 82, 69, 65, 68, 79, 78,   /* 0x1670 */
+ 32, 32, 32, 32, 32, 99, 97,108,108,116,114,105, 99,107, 95, 99,   /* 0x1670 */
- 76, 89, 10, 32, 50, 56, 32, 67, 79, 82, 69, 84, 85, 82, 78, 32,   /* 0x1680 */
+ 97,108,108,115, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78,   /* 0x1680 */
- 32, 32, 32, 32, 32, 48, 48, 48, 48, 48, 48, 48, 49, 32, 32, 48,   /* 0x1690 */
+ 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 84,   /* 0x1690 */
- 48, 48, 48, 48, 48, 48, 48, 32, 32, 48, 48, 48, 48, 48, 48, 48,   /* 0x16a0 */
+ 49, 54, 74, 69, 78, 68, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32,   /* 0x16a0 */
- 48, 32, 32, 48, 48, 48, 48, 48, 48,102, 49, 32, 32, 50, 42, 42,   /* 0x16b0 */
+ 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x16b0 */
- 48, 32, 32, 67, 79, 78, 84, 69, 78, 84, 83, 44, 32, 82, 69, 65,   /* 0x16c0 */
+ 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x16c0 */
- 68, 79, 78, 76, 89, 10, 83, 89, 77, 66, 79, 76, 32, 84, 65, 66,   /* 0x16d0 */
+ 48, 49, 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32, 32, 32, 32,   /* 0x16d0 */
- 76, 69, 58, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x16e0 */
+ 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 10, 82,   /* 0x16e0 */
- 32, 32,100, 32, 32, 67, 79, 77, 67, 85, 84, 80, 79,  9, 48, 48,   /* 0x16f0 */
+ 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68,   /* 0x16f0 */
- 48, 48, 48, 48, 48, 48, 32, 67, 79, 77, 67, 85, 84, 80, 79, 10,   /* 0x1700 */
+ 83, 32, 70, 79, 82, 32, 91, 67, 84, 49, 54, 74, 85, 76, 50, 93,   /* 0x1700 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1710 */
+ 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32,   /* 0x1710 */
- 32, 78, 82, 86, 50, 66, 49, 54, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1720 */
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76,   /* 0x1720 */
- 48, 48, 32, 78, 82, 86, 50, 66, 49, 54, 48, 10, 48, 48, 48, 48,   /* 0x1730 */
+ 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56,   /* 0x1730 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86,   /* 0x1740 */
+ 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65,   /* 0x1740 */
- 68, 69, 67, 79, 50,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78,   /* 0x1750 */
+ 76, 76, 84, 82, 73, 54, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73,   /* 0x1750 */
- 82, 86, 68, 69, 67, 79, 50, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1760 */
+ 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91,   /* 0x1760 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 67, 65, 76, 76, 84, 82, 49,   /* 0x1770 */
+ 67, 65, 76, 76, 84, 82, 73, 54, 93, 58, 10, 79, 70, 70, 83, 69,   /* 0x1770 */
- 54,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 65, 76, 76, 84,   /* 0x1780 */
+ 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1780 */
- 82, 49, 54, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1790 */
+ 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48,   /* 0x1790 */
- 32, 32,100, 32, 32, 67, 65, 76, 76, 84, 82, 73, 53,  9, 48, 48,   /* 0x17a0 */
+ 48, 48, 48, 50, 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32, 32,   /* 0x17a0 */
- 48, 48, 48, 48, 48, 48, 32, 67, 65, 76, 76, 84, 82, 73, 53, 10,   /* 0x17b0 */
+ 32, 32, 32, 32, 32, 32, 32, 67, 65, 76, 76, 84, 82, 73, 53, 10    /* 0x17b0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x17c0 */
- 32, 67, 65, 76, 76, 84, 82, 73, 54,  9, 48, 48, 48, 48, 48, 48,   /* 0x17d0 */
- 48, 48, 32, 67, 65, 76, 76, 84, 82, 73, 54, 10, 48, 48, 48, 48,   /* 0x17e0 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 79, 77,   /* 0x17f0 */
- 77, 65, 73, 78, 49,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67,   /* 0x1800 */
- 79, 77, 77, 65, 73, 78, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1810 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 67, 79, 77, 83, 66, 66, 66,   /* 0x1820 */
- 80,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 79, 77, 83, 66,   /* 0x1830 */
- 66, 66, 80, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1840 */
- 32, 32,100, 32, 32, 67, 79, 77, 80, 83, 72, 68, 73,  9, 48, 48,   /* 0x1850 */
- 48, 48, 48, 48, 48, 48, 32, 67, 79, 77, 80, 83, 72, 68, 73, 10,   /* 0x1860 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1870 */
- 32, 67, 79, 77, 67, 65, 76, 76, 84,  9, 48, 48, 48, 48, 48, 48,   /* 0x1880 */
- 48, 48, 32, 67, 79, 77, 67, 65, 76, 76, 84, 10, 48, 48, 48, 48,   /* 0x1890 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 79, 77,   /* 0x18a0 */
- 77, 65, 73, 78, 50,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67,   /* 0x18b0 */
- 79, 77, 77, 65, 73, 78, 50, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x18c0 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 85, 80, 88, 49, 72, 69, 65,   /* 0x18d0 */
- 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 85, 80, 88, 49, 72,   /* 0x18e0 */
- 69, 65, 68, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x18f0 */
- 32, 32,100, 32, 32, 78, 82, 86, 68, 68, 79, 78, 69,  9, 48, 48,   /* 0x1900 */
- 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 68, 68, 79, 78, 69, 10,   /* 0x1910 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1920 */
- 32, 78, 82, 86, 68, 82, 69, 84, 85,  9, 48, 48, 48, 48, 48, 48,   /* 0x1930 */
- 48, 48, 32, 78, 82, 86, 68, 82, 69, 84, 85, 10, 48, 48, 48, 48,   /* 0x1940 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86,   /* 0x1950 */
- 68, 69, 67, 79, 49,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78,   /* 0x1960 */
- 82, 86, 68, 69, 67, 79, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1970 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 78, 82, 86, 76, 69, 68, 48,   /* 0x1980 */
- 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 76, 69,   /* 0x1990 */
- 68, 48, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x19a0 */
- 32, 32,100, 32, 32, 78, 82, 86, 71, 84, 68, 48, 48,  9, 48, 48,   /* 0x19b0 */
- 48, 48, 48, 48, 48, 48, 32, 78, 82, 86, 71, 84, 68, 48, 48, 10,   /* 0x19c0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x19d0 */
- 32, 67, 84, 49, 54, 73, 50, 56, 54,  9, 48, 48, 48, 48, 48, 48,   /* 0x19e0 */
- 48, 48, 32, 67, 84, 49, 54, 73, 50, 56, 54, 10, 48, 48, 48, 48,   /* 0x19f0 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49,   /* 0x1a00 */
- 54, 83, 85, 66, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67,   /* 0x1a10 */
- 84, 49, 54, 83, 85, 66, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1a20 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 73, 48, 56,   /* 0x1a30 */
- 54,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49, 54, 73,   /* 0x1a40 */
- 48, 56, 54, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1a50 */
- 32, 32,100, 32, 32, 67, 65, 76, 76, 84, 82, 73, 50,  9, 48, 48,   /* 0x1a60 */
- 48, 48, 48, 48, 48, 48, 32, 67, 65, 76, 76, 84, 82, 73, 50, 10,   /* 0x1a70 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1a80 */
- 32, 67, 84, 49, 54, 69, 56, 48, 48,  9, 48, 48, 48, 48, 48, 48,   /* 0x1a90 */
- 48, 48, 32, 67, 84, 49, 54, 69, 56, 48, 48, 10, 48, 48, 48, 48,   /* 0x1aa0 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49,   /* 0x1ab0 */
- 54, 69, 57, 48, 48,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67,   /* 0x1ac0 */
- 84, 49, 54, 69, 57, 48, 48, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1ad0 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 74, 69, 78,   /* 0x1ae0 */
- 68,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49, 54, 74,   /* 0x1af0 */
- 69, 78, 68, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1b00 */
- 32, 32,100, 32, 32, 67, 84, 49, 54, 74, 85, 76, 50,  9, 48, 48,   /* 0x1b10 */
- 48, 48, 48, 48, 48, 48, 32, 67, 84, 49, 54, 74, 85, 76, 50, 10,   /* 0x1b20 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32,   /* 0x1b30 */
- 32, 67, 84, 49, 54, 73, 50, 56, 55,  9, 48, 48, 48, 48, 48, 48,   /* 0x1b40 */
- 48, 48, 32, 67, 84, 49, 54, 73, 50, 56, 55, 10, 48, 48, 48, 48,   /* 0x1b50 */
- 48, 48, 48, 48, 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49,   /* 0x1b60 */
- 54, 83, 85, 66, 49,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67,   /* 0x1b70 */
- 84, 49, 54, 83, 85, 66, 49, 10, 48, 48, 48, 48, 48, 48, 48, 48,   /* 0x1b80 */
- 32,108, 32, 32, 32, 32,100, 32, 32, 67, 84, 49, 54, 73, 48, 56,   /* 0x1b90 */
- 55,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32, 67, 84, 49, 54, 73,   /* 0x1ba0 */
- 48, 56, 55, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,108, 32, 32,   /* 0x1bb0 */
- 32, 32,100, 32, 32, 67, 79, 82, 69, 84, 85, 82, 78,  9, 48, 48,   /* 0x1bc0 */
- 48, 48, 48, 48, 48, 48, 32, 67, 79, 82, 69, 84, 85, 82, 78, 10,   /* 0x1bd0 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1be0 */
- 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1bf0 */
-115,112, 95,108,105,109,105,116, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1c00 */
- 48, 32, 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9,   /* 0x1c10 */
- 48, 48, 48, 48, 48, 48, 48, 48, 32, 98,121,116,101,115, 95,116,   /* 0x1c20 */
-111, 95, 99,111,112,121, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32,   /* 0x1c30 */
- 32, 32, 32, 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48,   /* 0x1c40 */
- 48, 48, 48, 48, 48, 48, 32, 99,111,112,121, 95,115,111,117,114,   /* 0x1c50 */
- 99,101, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32, 32,   /* 0x1c60 */
- 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48, 48,   /* 0x1c70 */
- 48, 48, 32, 99,111,112,121, 95,100,101,115,116,105,110, 97,116,   /* 0x1c80 */
-105,111,110, 10, 48, 48, 48, 48, 48, 48, 48, 48, 32, 32, 32, 32,   /* 0x1c90 */
- 32, 32, 32, 32, 32, 42, 85, 78, 68, 42,  9, 48, 48, 48, 48, 48,   /* 0x1ca0 */
- 48, 48, 48, 32, 99, 97,108,108,116,114,105, 99,107, 95, 99, 97,   /* 0x1cb0 */
-108,108,115, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32,   /* 0x1cc0 */
- 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 79, 77,   /* 0x1cd0 */
- 77, 65, 73, 78, 49, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32,   /* 0x1ce0 */
- 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1cf0 */
- 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48,   /* 0x1d00 */
- 50, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32,   /* 0x1d10 */
- 32, 32, 32, 32,115,112, 95,108,105,109,105,116, 10, 48, 48, 48,   /* 0x1d20 */
- 48, 48, 48, 48, 57, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32,   /* 0x1d30 */
- 32, 32, 32, 32, 32, 32, 32, 32, 98,121,116,101,115, 95,116,111,   /* 0x1d40 */
- 95, 99,111,112,121, 10, 48, 48, 48, 48, 48, 48, 48, 99, 32, 82,   /* 0x1d50 */
- 95, 51, 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1d60 */
- 32, 99,111,112,121, 95,115,111,117,114, 99,101, 10, 48, 48, 48,   /* 0x1d70 */
- 48, 48, 48, 48,102, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32,   /* 0x1d80 */
- 32, 32, 32, 32, 32, 32, 32, 32, 99,111,112,121, 95,100,101,115,   /* 0x1d90 */
-116,105,110, 97,116,105,111,110, 10, 48, 48, 48, 48, 48, 48, 49,   /* 0x1da0 */
- 99, 32, 82, 95, 51, 56, 54, 95, 56, 32, 32, 32, 32, 32, 32, 32,   /* 0x1db0 */
- 32, 32, 32, 32, 67, 79, 77, 67, 85, 84, 80, 79, 10, 10, 82, 69,   /* 0x1dc0 */
- 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83,   /* 0x1dd0 */
- 32, 70, 79, 82, 32, 91, 67, 79, 77, 77, 65, 73, 78, 50, 93, 58,   /* 0x1de0 */
- 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32,   /* 0x1df0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85,   /* 0x1e00 */
- 69, 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54,   /* 0x1e10 */
- 95, 80, 67, 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86,   /* 0x1e20 */
- 50, 66, 49, 54, 48, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79,   /* 0x1e30 */
- 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78,   /* 0x1e40 */
- 82, 86, 50, 66, 49, 54, 48, 93, 58, 10, 79, 70, 70, 83, 69, 84,   /* 0x1e50 */
- 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1e60 */
- 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48,   /* 0x1e70 */
- 48, 48, 50, 32, 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32, 32,   /* 0x1e80 */
- 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48,   /* 0x1e90 */
- 48, 48, 48, 48, 48, 48, 56, 32, 82, 95, 51, 56, 54, 95, 80, 67,   /* 0x1ea0 */
- 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67,   /* 0x1eb0 */
- 79, 50, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82,   /* 0x1ec0 */
- 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82, 86, 68,   /* 0x1ed0 */
- 68, 79, 78, 69, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32,   /* 0x1ee0 */
- 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1ef0 */
- 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 49,   /* 0x1f00 */
- 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32,   /* 0x1f10 */
- 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 10, 82, 69, 76,   /* 0x1f20 */
- 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32,   /* 0x1f30 */
- 70, 79, 82, 32, 91, 78, 82, 86, 68, 82, 69, 84, 85, 93, 58, 10,   /* 0x1f40 */
- 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32,   /* 0x1f50 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69,   /* 0x1f60 */
- 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54, 95,   /* 0x1f70 */
- 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68,   /* 0x1f80 */
- 69, 67, 79, 50, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78,   /* 0x1f90 */
- 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78, 82,   /* 0x1fa0 */
- 86, 68, 69, 67, 79, 49, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32,   /* 0x1fb0 */
- 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x1fc0 */
- 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48,   /* 0x1fd0 */
- 49, 48, 32, 82, 95, 51, 56, 54, 95, 80, 67, 49, 54, 32, 32, 32,   /* 0x1fe0 */
- 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50, 10, 48, 48,   /* 0x1ff0 */
- 48, 48, 48, 48, 49, 56, 32, 82, 95, 51, 56, 54, 95, 80, 67, 49,   /* 0x2000 */
- 54, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79,   /* 0x2010 */
- 50, 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54,   /* 0x2020 */
- 95, 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86,   /* 0x2030 */
- 50, 66, 49, 54, 48, 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79,   /* 0x2040 */
- 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 78,   /* 0x2050 */
- 82, 86, 68, 69, 67, 79, 50, 93, 58, 10, 79, 70, 70, 83, 69, 84,   /* 0x2060 */
- 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2070 */
- 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48,   /* 0x2080 */
- 48, 48, 55, 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32, 32, 32,   /* 0x2090 */
- 32, 32, 32, 32, 32, 32, 78, 82, 86, 50, 66, 49, 54, 48, 10, 10,   /* 0x20a0 */
- 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x20b0 */
- 68, 83, 32, 70, 79, 82, 32, 91, 67, 65, 76, 76, 84, 82, 49, 54,   /* 0x20c0 */
- 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69,   /* 0x20d0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65,   /* 0x20e0 */
- 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 50, 32, 82, 95, 51,   /* 0x20f0 */
- 56, 54, 95, 49, 54, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 99,   /* 0x2100 */
- 97,108,108,116,114,105, 99,107, 95, 99, 97,108,108,115, 10, 10,   /* 0x2110 */
- 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82,   /* 0x2120 */
- 68, 83, 32, 70, 79, 82, 32, 91, 67, 65, 76, 76, 84, 82, 73, 50,   /* 0x2130 */
- 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69,   /* 0x2140 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65,   /* 0x2150 */
- 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 50, 32, 82, 95, 51,   /* 0x2160 */
- 56, 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 67,   /* 0x2170 */
- 65, 76, 76, 84, 82, 49, 54, 10, 10, 82, 69, 76, 79, 67, 65, 84,   /* 0x2180 */
- 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32,   /* 0x2190 */
- 91, 67, 65, 76, 76, 84, 82, 73, 53, 93, 58, 10, 79, 70, 70, 83,   /* 0x21a0 */
- 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x21b0 */
- 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48,   /* 0x21c0 */
- 48, 48, 48, 48, 50, 32, 82, 95, 51, 56, 54, 95, 49, 54, 32, 32,   /* 0x21d0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 99, 97,108,108,116,114,105, 99,   /* 0x21e0 */
-107, 95, 99, 97,108,108,115, 10, 10, 82, 69, 76, 79, 67, 65, 84,   /* 0x21f0 */
- 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79, 82, 32,   /* 0x2200 */
- 91, 67, 84, 49, 54, 74, 69, 78, 68, 93, 58, 10, 79, 70, 70, 83,   /* 0x2210 */
- 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32, 32, 32,   /* 0x2220 */
- 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48, 48, 48,   /* 0x2230 */
- 48, 48, 48, 48, 49, 32, 82, 95, 51, 56, 54, 95, 80, 67, 56, 32,   /* 0x2240 */
- 32, 32, 32, 32, 32, 32, 32, 32, 78, 82, 86, 68, 69, 67, 79, 50,   /* 0x2250 */
- 10, 10, 82, 69, 76, 79, 67, 65, 84, 73, 79, 78, 32, 82, 69, 67,   /* 0x2260 */
- 79, 82, 68, 83, 32, 70, 79, 82, 32, 91, 67, 84, 49, 54, 74, 85,   /* 0x2270 */
- 76, 50, 93, 58, 10, 79, 70, 70, 83, 69, 84, 32, 32, 32, 84, 89,   /* 0x2280 */
- 80, 69, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x2290 */
- 86, 65, 76, 85, 69, 10, 48, 48, 48, 48, 48, 48, 48, 49, 32, 82,   /* 0x22a0 */
- 95, 51, 56, 54, 95, 80, 67, 56, 32, 32, 32, 32, 32, 32, 32, 32,   /* 0x22b0 */
- 32, 67, 65, 76, 76, 84, 82, 73, 54, 10, 10, 82, 69, 76, 79, 67,   /* 0x22c0 */
- 65, 84, 73, 79, 78, 32, 82, 69, 67, 79, 82, 68, 83, 32, 70, 79,   /* 0x22d0 */
- 82, 32, 91, 67, 65, 76, 76, 84, 82, 73, 54, 93, 58, 10, 79, 70,   /* 0x22e0 */
- 70, 83, 69, 84, 32, 32, 32, 84, 89, 80, 69, 32, 32, 32, 32, 32,   /* 0x22f0 */
- 32, 32, 32, 32, 32, 32, 32, 32, 32, 86, 65, 76, 85, 69, 10, 48,   /* 0x2300 */
- 48, 48, 48, 48, 48, 48, 50, 32, 82, 95, 51, 56, 54, 95, 80, 67,   /* 0x2310 */
- 56, 32, 32, 32, 32, 32, 32, 32, 32, 32, 67, 65, 76, 76, 84, 82,   /* 0x2320 */
- 73, 53, 10                                                        /* 0x2330 */
 };

src/stub/i386-bsd.elf-fold.h

@@ -1,4 +1,5 @@
-/* i386-bsd.elf-fold.h -- created from i386-bsd.elf-fold.bin, 1789 (0x6fd) bytes
+/* i386-bsd.elf-fold.h
+   created from i386-bsd.elf-fold.bin, 1789 (0x6fd) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define BSD_I386ELF_FOLD_SIZE    1789
+#define STUB_I386_BSD_ELF_FOLD_SIZE    1789
-#define BSD_I386ELF_FOLD_ADLER32 0x627bfe0b
+#define STUB_I386_BSD_ELF_FOLD_ADLER32 0x627bfe0b
-#define BSD_I386ELF_FOLD_CRC32   0x9ea4486f
+#define STUB_I386_BSD_ELF_FOLD_CRC32   0x9ea4486f
 
-unsigned char bsd_i386elf_fold[1789] = {
+unsigned char stub_i386_bsd_elf_fold[1789] = {
 127, 69, 76, 70,  1,  1,  1,  9,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,128, 16,192,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-bsd.elf.execve-fold.h

@@ -1,4 +1,5 @@
-/* i386-bsd.elf.execve-fold.h -- created from i386-bsd.elf.execve-fold.bin, 1031 (0x407) bytes
+/* i386-bsd.elf.execve-fold.h
+   created from i386-bsd.elf.execve-fold.bin, 1031 (0x407) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define BSD_I386EXEC_FOLD_SIZE    1031
+#define STUB_I386_BSD_ELF_EXECVE_FOLD_SIZE    1031
-#define BSD_I386EXEC_FOLD_ADLER32 0x73c799a0
+#define STUB_I386_BSD_ELF_EXECVE_FOLD_ADLER32 0x73c799a0
-#define BSD_I386EXEC_FOLD_CRC32   0xef2fbdb2
+#define STUB_I386_BSD_ELF_EXECVE_FOLD_CRC32   0xef2fbdb2
 
-unsigned char bsd_i386exec_fold[1031] = {
+unsigned char stub_i386_bsd_elf_execve_fold[1031] = {
 127, 69, 76, 70,  1,  1,  1,  9,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-dos32.djgpp2-stubify.h

@@ -1,8 +1,8 @@
-#define STUBIFY_STUB_SIZE    2048
+#define STUB_I386_DOS32_DJGPP2_STUBIFY_SIZE    2048
-#define STUBIFY_STUB_ADLER32 0xbf689ba8
+#define STUB_I386_DOS32_DJGPP2_STUBIFY_ADLER32 0xbf689ba8
-#define STUBIFY_STUB_CRC32   0x2ae982b2
+#define STUB_I386_DOS32_DJGPP2_STUBIFY_CRC32   0x2ae982b2
 
-unsigned char stubify_stub[2048] = {
+unsigned char stub_i386_dos32_djgpp2_stubify[2048] = {
  77, 90,  0,  0,  4,  0,  0,  0, 32,  0, 39,  0,255,255,  0,  0,   /* 0x   0 */
  96,  7,  0,  0, 84,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x  20 */

src/stub/i386-linux.elf-fold.h

@@ -1,4 +1,5 @@
-/* i386-linux.elf-fold.h -- created from i386-linux.elf-fold.bin, 1691 (0x69b) bytes
+/* i386-linux.elf-fold.h
+   created from i386-linux.elf-fold.bin, 1691 (0x69b) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_I386ELF_FOLD_SIZE    1691
+#define STUB_I386_LINUX_ELF_FOLD_SIZE    1691
-#define LINUX_I386ELF_FOLD_ADLER32 0xe27fd53e
+#define STUB_I386_LINUX_ELF_FOLD_ADLER32 0xe27fd53e
-#define LINUX_I386ELF_FOLD_CRC32   0x75829ac3
+#define STUB_I386_LINUX_ELF_FOLD_CRC32   0x75829ac3
 
-unsigned char linux_i386elf_fold[1691] = {
+unsigned char stub_i386_linux_elf_fold[1691] = {
 127, 69, 76, 70,  1,  1,  1,  0, 76,105,110,117,120,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,128, 16,192,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-linux.elf.execve-fold.h

@@ -1,4 +1,5 @@
-/* i386-linux.elf.execve-fold.h -- created from i386-linux.elf.execve-fold.bin, 931 (0x3a3) bytes
+/* i386-linux.elf.execve-fold.h
+   created from i386-linux.elf.execve-fold.bin, 931 (0x3a3) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_I386EXEC_FOLD_SIZE    931
+#define STUB_I386_LINUX_ELF_EXECVE_FOLD_SIZE    931
-#define LINUX_I386EXEC_FOLD_ADLER32 0x488877dc
+#define STUB_I386_LINUX_ELF_EXECVE_FOLD_ADLER32 0x488877dc
-#define LINUX_I386EXEC_FOLD_CRC32   0x399780ea
+#define STUB_I386_LINUX_ELF_EXECVE_FOLD_CRC32   0x399780ea
 
-unsigned char linux_i386exec_fold[931] = {
+unsigned char stub_i386_linux_elf_execve_fold[931] = {
 127, 69, 76, 70,  1,  1,  1,  0, 76,105,110,117,120,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-linux.elf.interp-fold.h

@@ -1,4 +1,5 @@
-/* i386-linux.elf.interp-fold.h -- created from i386-linux.elf.interp-fold.bin, 1519 (0x5ef) bytes
+/* i386-linux.elf.interp-fold.h
+   created from i386-linux.elf.interp-fold.bin, 1519 (0x5ef) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_I386PTI_FOLD_SIZE    1519
+#define STUB_I386_LINUX_ELF_INTERP_FOLD_SIZE    1519
-#define LINUX_I386PTI_FOLD_ADLER32 0xe82498de
+#define STUB_I386_LINUX_ELF_INTERP_FOLD_ADLER32 0xe82498de
-#define LINUX_I386PTI_FOLD_CRC32   0xd7e223de
+#define STUB_I386_LINUX_ELF_INTERP_FOLD_CRC32   0xd7e223de
 
-unsigned char linux_i386pti_fold[1519] = {
+unsigned char stub_i386_linux_elf_interp_fold[1519] = {
 127, 69, 76, 70,  1,  1,  1,  0, 76,105,110,117,120,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,116,  0,  1,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-linux.elf.shell-fold.h

@@ -1,4 +1,5 @@
-/* i386-linux.elf.shell-fold.h -- created from i386-linux.elf.shell-fold.bin, 1194 (0x4aa) bytes
+/* i386-linux.elf.shell-fold.h
+   created from i386-linux.elf.shell-fold.bin, 1194 (0x4aa) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define LINUX_I386SH_FOLD_SIZE    1194
+#define STUB_I386_LINUX_ELF_SHELL_FOLD_SIZE    1194
-#define LINUX_I386SH_FOLD_ADLER32 0x63b3f90a
+#define STUB_I386_LINUX_ELF_SHELL_FOLD_ADLER32 0x63b3f90a
-#define LINUX_I386SH_FOLD_CRC32   0xe2bc019d
+#define STUB_I386_LINUX_ELF_SHELL_FOLD_CRC32   0xe2bc019d
 
-unsigned char linux_i386sh_fold[1194] = {
+unsigned char stub_i386_linux_elf_shell_fold[1194] = {
 127, 69, 76, 70,  1,  1,  1,  0, 76,105,110,117,120,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,  0,  0,  0,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */

src/stub/i386-linux.kernel.vmlinux-head.h

@@ -0,0 +1,39 @@
+/* i386-linux.kernel.vmlinux-head.h
+   created from i386-linux.kernel.vmlinux-head.bin, 39 (0x27) bytes
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 2000-2006 John F. Reiser
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+ */
+
+
+#define STUB_I386_LINUX_KERNEL_VMLINUX_HEAD_SIZE    39
+#define STUB_I386_LINUX_KERNEL_VMLINUX_HEAD_ADLER32 0x7a591357
+#define STUB_I386_LINUX_KERNEL_VMLINUX_HEAD_CRC32   0xf4f6740a
+
+unsigned char stub_i386_linux_kernel_vmlinux_head[39] = {
+140,200,131,192,  8,142,216,142,192,141,142,  0,144,  0,  0,137,   /* 0x   0 */
+ 73,248,137, 65,252, 15,178, 97,248,106,  0,157, 14,184,  0,  0,   /* 0x  10 */
+  0,  0,232,252,255,255,255                                        /* 0x  20 */
+};

src/stub/i386-openbsd.elf-fold.h

@@ -1,4 +1,5 @@
-/* i386-openbsd.elf-fold.h -- created from i386-openbsd.elf-fold.bin, 2025 (0x7e9) bytes
+/* i386-openbsd.elf-fold.h
+   created from i386-openbsd.elf-fold.bin, 2025 (0x7e9) bytes
 
    This file is part of the UPX executable compressor.
 
@@ -27,11 +28,11 @@
  */
 
 
-#define OPENBSD_I386ELF_FOLD_SIZE    2025
+#define STUB_I386_OPENBSD_ELF_FOLD_SIZE    2025
-#define OPENBSD_I386ELF_FOLD_ADLER32 0x4b605db7
+#define STUB_I386_OPENBSD_ELF_FOLD_ADLER32 0x4b605db7
-#define OPENBSD_I386ELF_FOLD_CRC32   0x59c73b6b
+#define STUB_I386_OPENBSD_ELF_FOLD_CRC32   0x59c73b6b
 
-unsigned char openbsd_i386elf_fold[2025] = {
+unsigned char stub_i386_openbsd_elf_fold[2025] = {
 127, 69, 76, 70,  1,  1,  1, 12,  0,  0,  0,  0,  0,  0,  0,  0,   /* 0x   0 */
   2,  0,  3,  0,  1,  0,  0,  0,128, 16,192,  0, 52,  0,  0,  0,   /* 0x  10 */
   0,  0,  0,  0,  0,  0,  0,  0, 52,  0, 32,  0,  2,  0,  0,  0,   /* 0x  20 */