stormlib 0.1.0 → 1.0.1

data/ext/stormlib/StormLib/src/pklib/pklib.h

@@ -0,0 +1,160 @@
+/*****************************************************************************/
+/* pklib.h                                Copyright (c) Ladislav Zezula 2003 */
+/*---------------------------------------------------------------------------*/
+/* Header file for PKWARE Data Compression Library                           */
+/*---------------------------------------------------------------------------*/
+/*   Date    Ver   Who  Comment                                              */
+/* --------  ----  ---  -------                                              */
+/* 31.03.03  1.00  Lad  Created                                              */
+/*****************************************************************************/
+
+#ifndef __PKLIB_H__
+#define __PKLIB_H__
+
+#pragma once
+
+//-----------------------------------------------------------------------------
+// Defines
+
+#define CMP_BINARY             0            // Binary compression
+#define CMP_ASCII              1            // Ascii compression
+
+#define CMP_NO_ERROR           0
+#define CMP_INVALID_DICTSIZE   1
+#define CMP_INVALID_MODE       2
+#define CMP_BAD_DATA           3
+#define CMP_ABORT              4
+
+#define CMP_IMPLODE_DICT_SIZE1   1024       // Dictionary size of 1024
+#define CMP_IMPLODE_DICT_SIZE2   2048       // Dictionary size of 2048
+#define CMP_IMPLODE_DICT_SIZE3   4096       // Dictionary size of 4096
+
+//-----------------------------------------------------------------------------
+// Define calling convention
+
+#ifndef PKEXPORT
+#ifdef WIN32
+#define PKEXPORT  __cdecl                   // Use for normal __cdecl calling
+#else
+#define PKEXPORT
+#endif
+#endif
+
+//-----------------------------------------------------------------------------
+// Internal structures
+
+// Compression structure
+typedef struct
+{
+    unsigned int   distance;                // 0000: Backward distance of the currently found repetition, decreased by 1
+    unsigned int   out_bytes;               // 0004: # bytes available in out_buff
+    unsigned int   out_bits;                // 0008: # of bits available in the last out byte
+    unsigned int   dsize_bits;              // 000C: Number of bits needed for dictionary size. 4 = 0x400, 5 = 0x800, 6 = 0x1000
+    unsigned int   dsize_mask;              // 0010: Bit mask for dictionary. 0x0F = 0x400, 0x1F = 0x800, 0x3F = 0x1000
+    unsigned int   ctype;                   // 0014: Compression type (CMP_ASCII or CMP_BINARY)
+    unsigned int   dsize_bytes;             // 0018: Dictionary size in bytes
+    unsigned char  dist_bits[0x40];         // 001C: Distance bits
+    unsigned char  dist_codes[0x40];        // 005C: Distance codes
+    unsigned char  nChBits[0x306];          // 009C: Table of literal bit lengths to be put to the output stream
+    unsigned short nChCodes[0x306];         // 03A2: Table of literal codes to be put to the output stream
+    unsigned short offs09AE;                // 09AE:
+
+    void         * param;                   // 09B0: User parameter
+    unsigned int (*read_buf)(char *buf, unsigned int *size, void *param);  // 9B4
+    void         (*write_buf)(char *buf, unsigned int *size, void *param); // 9B8
+
+    unsigned short offs09BC[0x204];         // 09BC:
+    unsigned long  offs0DC4;                // 0DC4:
+    unsigned short phash_to_index[0x900];   // 0DC8: Array of indexes (one for each PAIR_HASH) to the "pair_hash_offsets" table
+    unsigned short phash_to_index_end;      // 1FC8: End marker for "phash_to_index" table
+    char           out_buff[0x802];         // 1FCA: Compressed data
+    unsigned char  work_buff[0x2204];       // 27CC: Work buffer
+                                            //  + DICT_OFFSET  => Dictionary
+                                            //  + UNCMP_OFFSET => Uncompressed data
+    unsigned short phash_offs[0x2204];      // 49D0: Table of offsets for each PAIR_HASH
+} TCmpStruct;
+
+#define CMP_BUFFER_SIZE  sizeof(TCmpStruct) // Size of compression structure.
+                                            // Defined as 36312 in pkware header file
+
+
+// Decompression structure
+typedef struct
+{
+    unsigned long offs0000;                 // 0000
+    unsigned long ctype;                    // 0004: Compression type (CMP_BINARY or CMP_ASCII)
+    unsigned long outputPos;                // 0008: Position in output buffer
+    unsigned long dsize_bits;               // 000C: Dict size (4, 5, 6 for 0x400, 0x800, 0x1000)
+    unsigned long dsize_mask;               // 0010: Dict size bitmask (0x0F, 0x1F, 0x3F for 0x400, 0x800, 0x1000)
+    unsigned long bit_buff;                 // 0014: 16-bit buffer for processing input data
+    unsigned long extra_bits;               // 0018: Number of extra (above 8) bits in bit buffer
+    unsigned int  in_pos;                   // 001C: Position in in_buff
+    unsigned long in_bytes;                 // 0020: Number of bytes in input buffer
+    void        * param;                    // 0024: Custom parameter
+    unsigned int (*read_buf)(char *buf, unsigned int *size, void *param); // Pointer to function that reads data from the input stream
+    void         (*write_buf)(char *buf, unsigned int *size, void *param);// Pointer to function that writes data to the output stream
+
+    unsigned char out_buff[0x2204];         // 0030: Output circle buffer.
+                                            //       0x0000 - 0x0FFF: Previous uncompressed data, kept for repetitions
+                                            //       0x1000 - 0x1FFF: Currently decompressed data
+                                            //       0x2000 - 0x2203: Reserve space for the longest possible repetition
+    unsigned char in_buff[0x800];           // 2234: Buffer for data to be decompressed
+    unsigned char DistPosCodes[0x100];      // 2A34: Table of distance position codes
+    unsigned char LengthCodes[0x100];       // 2B34: Table of length codes
+    unsigned char offs2C34[0x100];          // 2C34: Buffer for
+    unsigned char offs2D34[0x100];          // 2D34: Buffer for
+    unsigned char offs2E34[0x80];           // 2E34: Buffer for
+    unsigned char offs2EB4[0x100];          // 2EB4: Buffer for
+    unsigned char ChBitsAsc[0x100];         // 2FB4: Buffer for
+    unsigned char DistBits[0x40];           // 30B4: Numbers of bytes to skip copied block length
+    unsigned char LenBits[0x10];            // 30F4: Numbers of bits for skip copied block length
+    unsigned char ExLenBits[0x10];          // 3104: Number of valid bits for copied block
+    unsigned short LenBase[0x10];           // 3114: Buffer for
+} TDcmpStruct;
+
+#define EXP_BUFFER_SIZE sizeof(TDcmpStruct) // Size of decompression structure
+                                            // Defined as 12596 in pkware headers
+
+//-----------------------------------------------------------------------------
+// Tables (in explode.c)
+
+extern const unsigned char DistBits[0x40];
+extern const unsigned char DistCode[0x40];
+extern const unsigned char ExLenBits[0x10];
+extern const unsigned short LenBase[0x10];
+extern const unsigned char LenBits[0x10];
+extern const unsigned char LenCode[0x10];
+extern const unsigned char ChBitsAsc[0x100];
+extern const unsigned short ChCodeAsc[0x100];
+
+//-----------------------------------------------------------------------------
+// Public functions
+
+#ifdef __cplusplus
+   extern "C" {
+#endif
+
+unsigned int PKEXPORT implode(
+   unsigned int (*read_buf)(char *buf, unsigned int *size, void *param),
+   void         (*write_buf)(char *buf, unsigned int *size, void *param),
+   char         *work_buf,
+   void         *param,
+   unsigned int *type,
+   unsigned int *dsize);
+
+
+unsigned int PKEXPORT explode(
+   unsigned int (*read_buf)(char *buf, unsigned  int *size, void *param),
+   void         (*write_buf)(char *buf, unsigned  int *size, void *param),
+   char         *work_buf,
+   void         *param);
+
+// The original name "crc32" was changed to "crc32_pklib" due
+// to compatibility with zlib
+unsigned long PKEXPORT crc32_pklib(char *buffer, unsigned int *size, unsigned long *old_crc);
+
+#ifdef __cplusplus
+   }                         // End of 'extern "C"' declaration
+#endif
+
+#endif // __PKLIB_H__

data/ext/stormlib/StormLib/src/resource.h

@@ -0,0 +1,15 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by DllMain.rc
+//
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1000
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif

data/ext/stormlib/StormLib/src/sparse/sparse.cpp

@@ -0,0 +1,287 @@
+/*****************************************************************************/
+/* huffman.cpp                       Copyright (c) Ladislav Zezula 1998-2003 */
+/*---------------------------------------------------------------------------*/
+/* This module contains Huffmann (de)compression methods                     */
+/*                                                                           */
+/* Authors : Ladislav Zezula (ladik.zezula.net)                              */
+/*           ShadowFlare     (BlakFlare@hotmail.com)                         */
+/*                                                                           */
+/*---------------------------------------------------------------------------*/
+/*   Date    Ver   Who  Comment                                              */
+/* --------  ----  ---  -------                                              */
+/* xx.xx.xx  1.00  Lad  The first version of dcmp.cpp                        */
+/* 03.05.03  1.00  Lad  Added compression methods                            */
+/* 19.11.03  1.01  Dan  Big endian handling                                  */
+/* 08.12.03  2.01  Dan  High-memory handling (> 0x80000000)                  */
+/*****************************************************************************/
+
+#include <assert.h>
+#include <string.h>
+
+#include "sparse.h"
+
+//-----------------------------------------------------------------------------
+// Public functions
+
+void CompressSparse(void * pvOutBuffer, int * pcbOutBuffer, void * pvInBuffer, int cbInBuffer)
+{
+    unsigned char * pbOutBufferEnd = (unsigned char *)pvOutBuffer + *pcbOutBuffer;
+    unsigned char * pbInBufferEnd = (unsigned char *)pvInBuffer + cbInBuffer;
+    unsigned char * pbLastNonZero = (unsigned char *)pvInBuffer;
+    unsigned char * pbOutBuffer0 = (unsigned char *)pvOutBuffer;
+    unsigned char * pbInBuffPtr = (unsigned char *)pvInBuffer;
+    unsigned char * pbOutBuffer = (unsigned char *)pvOutBuffer;
+    unsigned char * pbInBuffer = (unsigned char *)pvInBuffer;
+    size_t NumberOfNonZeros;
+    size_t NumberOfZeros;
+
+    // There must be at least 4 bytes of free space in the output buffer now
+    if((pbInBuffer + 4) >= pbInBufferEnd)
+        return;
+
+    // Put the original data length (in little endian)
+    *pbOutBuffer++ = (unsigned char)(cbInBuffer >> 0x18);
+    *pbOutBuffer++ = (unsigned char)(cbInBuffer >> 0x10);
+    *pbOutBuffer++ = (unsigned char)(cbInBuffer >> 0x08);
+    *pbOutBuffer++ = (unsigned char)(cbInBuffer >> 0x00);
+
+    // If there is at least 3 bytes in the input buffer, do this loop
+    while(pbInBuffer < (pbInBufferEnd - 3))
+    {
+        // Reset the zero count and frontal pointer
+        pbLastNonZero = pbInBuffer;
+        pbInBuffPtr   = pbInBuffer;
+        NumberOfZeros = 0;
+
+        if(pbInBuffPtr < pbInBufferEnd)
+        {
+            do
+            {
+                // Count number of zeros
+                if(*pbInBuffPtr == 0)
+                {
+                    NumberOfZeros++;
+                }
+                else
+                {
+                    // Were there at least 3 zeros before? If yes, we need to flush the data
+                    if(NumberOfZeros >= 3)
+                        break;
+                    pbLastNonZero = pbInBuffPtr + 1;
+                    NumberOfZeros = 0;
+                }
+            }
+            while(++pbInBuffPtr < pbInBufferEnd);
+        }
+
+        // Get number of nonzeros that we found so far and flush them
+        NumberOfNonZeros = pbLastNonZero - pbInBuffer;
+        if(NumberOfNonZeros != 0)
+        {
+            // Process blocks that are longer than 0x81 nonzero bytes
+            while(NumberOfNonZeros > 0x81)
+            {
+                // Verify if we still have enough space in output buffer
+                if((pbOutBuffer + 0x81) >= pbOutBufferEnd)
+                    return;
+
+                // Put marker that means "0x80 of nonzeros"
+                *pbOutBuffer++ = 0xFF;
+                memcpy(pbOutBuffer, pbInBuffer, 0x80);
+
+                // Adjust counter of nonzeros and both pointers
+                NumberOfNonZeros -= 0x80;
+                pbOutBuffer += 0x80;
+                pbInBuffer += 0x80;
+            }
+
+            // BUGBUG: The following code will be triggered if the NumberOfNonZeros
+            // was 0x81 before. It will copy just one byte. This seems like a bug to me,
+            // but since I want StormLib to be exact like Blizzard code is, I will keep
+            // it that way here
+            if(NumberOfNonZeros > 0x80)
+            {
+                // Verify if we still have enough space in output buffer
+                if((pbOutBuffer + 2) >= pbOutBufferEnd)
+                    return;
+
+                // Put marker that means "1 nonzero byte"
+                *pbOutBuffer++ = 0x80;
+                memcpy(pbOutBuffer, pbInBuffer, 1);
+
+                // Adjust counter of nonzeros and both pointers
+                NumberOfNonZeros--;
+                pbOutBuffer++;
+                pbInBuffer++;
+            }
+
+            // If there is 1 nonzero or more, put the block
+            if(NumberOfNonZeros >= 0x01)
+            {
+                // Verify if we still have enough space in output buffer
+                if((pbOutBuffer + NumberOfNonZeros + 1) >= pbOutBufferEnd)
+                    return;
+
+                // Put marker that means "Several nonzero bytes"
+                *pbOutBuffer++ = (unsigned char)(0x80 | (NumberOfNonZeros - 1));
+                memcpy(pbOutBuffer, pbInBuffer, NumberOfNonZeros);
+
+                // Adjust pointers
+                pbOutBuffer += NumberOfNonZeros;
+                pbInBuffer += NumberOfNonZeros;
+            }
+        }
+
+        // Now flush all zero bytes
+        while(NumberOfZeros > 0x85)
+        {
+            // Do we have at least 2 bytes in the output buffer ?
+            if((pbOutBuffer + 1) >= pbOutBufferEnd)
+                return;
+
+            // Put marker that means "0x82 zeros"
+            *pbOutBuffer++ = 0x7F;
+
+            // Adjust zero counter and input pointer
+            NumberOfZeros -= 0x82;
+            pbInBuffer += 0x82;
+        }
+
+        // If we got more than 0x82 zeros, flush 3 of them now
+        if(NumberOfZeros > 0x82)
+        {
+            // Do we have at least 2 bytes in the output buffer ?
+            if((pbOutBuffer + 1) >= pbOutBufferEnd)
+                return;
+
+            // Put marker that means "0x03 zeros"
+            *pbOutBuffer++ = 0;
+
+            // Adjust zero counter and input pointer
+            NumberOfZeros -= 0x03;
+            pbInBuffer += 0x03;
+        }
+
+        // Is there at least three zeros ?
+        if(NumberOfZeros >= 3)
+        {
+            // Do we have at least 2 bytes in the output buffer ?
+            if((pbOutBuffer + 1) >= pbOutBufferEnd)
+                return;
+
+            // Put marker that means "Several zeros"
+            *pbOutBuffer++ = (unsigned char)(NumberOfZeros - 3);
+
+            // Adjust pointer
+            pbInBuffer += NumberOfZeros;
+        }
+    }
+
+    // Flush last three bytes
+    if(pbInBuffer < pbInBufferEnd)
+    {
+        pbInBuffPtr = pbInBuffer;
+
+        for(;;)
+        {
+            if(*pbInBuffPtr++ != 0)
+            {
+                // Get number of bytes remaining
+                NumberOfNonZeros = (pbInBufferEnd - pbInBuffer);
+
+                // Not enough space in the output buffer ==> exit
+                if((pbOutBuffer + NumberOfNonZeros + 1) >= pbOutBufferEnd)
+                    return;
+
+                // Terminate with a marker that means "0x80 of nonzeros"
+                *pbOutBuffer++ = 0xFF;
+                memcpy(pbOutBuffer, pbInBuffer, NumberOfNonZeros);
+
+                // Adjust pointer
+                pbOutBuffer += NumberOfNonZeros;
+                break;
+            }
+            else
+            {
+                // Is there are more chars in the input buffer
+                if(pbInBuffPtr < pbInBufferEnd)
+                    continue;
+
+                // If the compression will not compress it by even 1 byte, do nothing
+                if((pbOutBuffer + 1) >= pbOutBufferEnd)
+                    return;
+
+                // Terminate with a chunk that means "0x82 of zeros"
+                *pbOutBuffer++ = 0x7F;
+                break;
+            }
+        }
+    }
+
+    // Out the length of the output buffer
+    *pcbOutBuffer = (int)(pbOutBuffer - pbOutBuffer0);
+}
+
+int DecompressSparse(void * pvOutBuffer, int * pcbOutBuffer, void * pvInBuffer, int cbInBuffer)
+{
+    unsigned char * pbInBufferEnd = (unsigned char *)pvInBuffer + cbInBuffer;
+    unsigned char * pbOutBuffer = (unsigned char *)pvOutBuffer;
+    unsigned char * pbInBuffer = (unsigned char *)pvInBuffer;
+    unsigned int cbChunkSize;
+    unsigned int cbOutBuffer = 0;
+    unsigned int OneByte;
+
+    // Don't decompress anything that is shorter than 5 bytes
+    if(cbInBuffer < 5)
+        return 0;
+
+    // Get the 32-bits from the input stream
+    OneByte = *pbInBuffer++;
+    cbOutBuffer |= (OneByte << 0x18);
+    OneByte = *pbInBuffer++;
+    cbOutBuffer |= (OneByte << 0x10);
+    OneByte = *pbInBuffer++;
+    cbOutBuffer |= (OneByte << 0x08);
+    OneByte = *pbInBuffer++;
+    cbOutBuffer |= (OneByte << 0x00);
+
+    // Verify the size of the stream against the output buffer size
+    if(cbOutBuffer > (unsigned int)*pcbOutBuffer)
+        return 0;
+
+    // Put the output size to the buffer
+    *pcbOutBuffer = cbOutBuffer;
+
+    // Process the input buffer
+    while(pbInBuffer < pbInBufferEnd)
+    {
+        // Get (next) byte from the stream
+        OneByte = *pbInBuffer++;
+
+        // If highest bit, it means that that normal data follow
+        if(OneByte & 0x80)
+        {
+            // Check the length of one chunk. Check for overflows
+            cbChunkSize = (OneByte & 0x7F) + 1;
+            if((pbInBuffer + cbChunkSize) > pbInBufferEnd)
+                return 0;
+
+            // Copy the chunk. Make sure that the buffer won't overflow
+            cbChunkSize = (cbChunkSize < cbOutBuffer) ? cbChunkSize : cbOutBuffer;
+            memcpy(pbOutBuffer, pbInBuffer, cbChunkSize);
+            pbInBuffer += cbChunkSize;
+        }
+        else
+        {
+            cbChunkSize = (OneByte & 0x7F) + 3;
+            cbChunkSize = (cbChunkSize < cbOutBuffer) ? cbChunkSize : cbOutBuffer;
+            memset(pbOutBuffer, 0, cbChunkSize);
+        }
+
+        // Increment output buffer pointer
+        pbOutBuffer += cbChunkSize;
+        cbOutBuffer -= cbChunkSize;
+    }
+
+    return 1;
+}

data/ext/stormlib/StormLib/src/sparse/sparse.h

@@ -0,0 +1,17 @@
+/*****************************************************************************/
+/* sparse.h                               Copyright (c) Ladislav Zezula 2010 */
+/*---------------------------------------------------------------------------*/
+/* implementation of Sparse compression, used in Starcraft II                */
+/*---------------------------------------------------------------------------*/
+/*   Date    Ver   Who  Comment                                              */
+/* --------  ----  ---  -------                                              */
+/* 05.03.10  1.00  Lad  The first version of sparse.h                        */
+/*****************************************************************************/
+
+#ifndef __SPARSE_H__
+#define __SPARSE_H__
+
+void CompressSparse(void * pvOutBuffer, int * pcbOutBuffer, void * pvInBuffer, int cbInBuffer);
+int  DecompressSparse(void * pvOutBuffer, int * pcbOutBuffer, void * pvInBuffer, int cbInBuffer);
+
+#endif // __SPARSE_H__

data/ext/stormlib/StormLib/src/wdk/sources-cpp.cpp

@@ -0,0 +1,26 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#include "src\adpcm\adpcm.cpp"
+#include "src\huffman\huff.cpp"
+#include "src\sparse\sparse.cpp"
+
+#include "src\FileStream.cpp"
+#include "src\SBaseCommon.cpp"
+#include "src\SBaseDumpData.cpp"
+#include "src\SBaseFileTable.cpp"
+#include "src\SBaseSubTypes.cpp"
+#include "src\SCompression.cpp"
+#include "src\SFileAddFile.cpp"
+#include "src\SFileAttributes.cpp"
+#include "src\SFileCompactArchive.cpp"
+#include "src\SFileCreateArchive.cpp"
+#include "src\SFileExtractFile.cpp"
+#include "src\SFileFindFile.cpp"
+#include "src\SFileGetFileInfo.cpp"
+#include "src\SFileListFile.cpp"
+#include "src\SFileOpenArchive.cpp"
+#include "src\SFileOpenFileEx.cpp"
+#include "src\SFilePatchArchives.cpp"
+#include "src\SFileReadFile.cpp"
+#include "src\SFileVerify.cpp"

data/ext/stormlib/StormLib/src/wdk/sources-wdk-bzip2.c

@@ -0,0 +1,13 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#pragma warning(disable: 4242)                      // '=' : conversion from 'Int32' to 'UChar', possible loss of data
+#pragma warning(disable: 4244)                      // '=' : conversion from '__int64' to 'Int32', possible loss of data
+
+#include "src\bzip2\blocksort.c"
+#include "src\bzip2\bzlib.c"
+#include "src\bzip2\compress.c"
+#include "src\bzip2\crctable.c"
+#include "src\bzip2\decompress.c"
+#include "src\bzip2\huffman.c"
+#include "src\bzip2\randtable.c"

data/ext/stormlib/StormLib/src/wdk/sources-wdk-ltc.c

@@ -0,0 +1,4 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#include "src\libtomcrypt\src\math\ltm_desc.c"

data/ext/stormlib/StormLib/src/wdk/sources-wdk-lzma.c

@@ -0,0 +1,8 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#include "src\lzma\C\LzFind.c"
+#include "src\lzma\C\LzFindMt.c"
+#include "src\lzma\C\LzmaDec.c"
+#include "src\lzma\C\LzmaEnc.c"
+#include "src\lzma\C\Threads.c"

data/ext/stormlib/StormLib/src/wdk/sources-wdk-misc.c

@@ -0,0 +1,6 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#include "src\jenkins\lookup3.c"
+#include "src\pklib\explode.c"
+#include "src\pklib\implode.c"

data/ext/stormlib/StormLib/src/wdk/sources-wdk-tomcrypt.c

@@ -0,0 +1,82 @@
+// This is a source file for WDK build of StormLib
+// It is copied to the root folder during the build process
+
+#pragma warning(disable:4242)            // der_decode_ia5_string.c(84) : warning C4242: '=' : conversion from 'int' to 'unsigned char', possible loss of data
+
+#include "src\libtomcrypt\src\hashes\hash_memory.c"
+#include "src\libtomcrypt\src\hashes\md5.c"
+#include "src\libtomcrypt\src\hashes\sha1.c"
+#include "src\libtomcrypt\src\math\multi.c"
+#include "src\libtomcrypt\src\math\rand_prime.c"
+#include "src\libtomcrypt\src\misc\base64_decode.c"
+#include "src\libtomcrypt\src\misc\crypt_argchk.c"
+#include "src\libtomcrypt\src\misc\crypt_find_hash.c"
+#include "src\libtomcrypt\src\misc\crypt_find_prng.c"
+#include "src\libtomcrypt\src\misc\crypt_hash_descriptor.c"
+#include "src\libtomcrypt\src\misc\crypt_hash_is_valid.c"
+#include "src\libtomcrypt\src\misc\crypt_libc.c"
+#include "src\libtomcrypt\src\misc\crypt_ltc_mp_descriptor.c"
+#include "src\libtomcrypt\src\misc\crypt_prng_descriptor.c"
+#include "src\libtomcrypt\src\misc\crypt_prng_is_valid.c"
+#include "src\libtomcrypt\src\misc\crypt_register_hash.c"
+#include "src\libtomcrypt\src\misc\crypt_register_prng.c"
+#include "src\libtomcrypt\src\misc\zeromem.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_bit_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_boolean.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_choice.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_ia5_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_object_identifier.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_octet_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_printable_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_sequence_ex.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_sequence_flexi.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_sequence_multi.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_short_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_utctime.c"
+#include "src\libtomcrypt\src\pk\asn1\der_decode_utf8_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_bit_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_boolean.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_ia5_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_object_identifier.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_octet_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_printable_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_sequence_ex.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_sequence_multi.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_set.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_setof.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_short_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_utctime.c"
+#include "src\libtomcrypt\src\pk\asn1\der_encode_utf8_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_bit_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_boolean.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_ia5_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_object_identifier.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_octet_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_printable_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_sequence.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_short_integer.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_utctime.c"
+#include "src\libtomcrypt\src\pk\asn1\der_length_utf8_string.c"
+#include "src\libtomcrypt\src\pk\asn1\der_sequence_free.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_map.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_mul2add.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_mulmod.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_points.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_projective_add_point.c"
+#include "src\libtomcrypt\src\pk\ecc\ltc_ecc_projective_dbl_point.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_mgf1.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_oaep_decode.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_pss_decode.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_pss_encode.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_v1_5_decode.c"
+#include "src\libtomcrypt\src\pk\pkcs1\pkcs_1_v1_5_encode.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_exptmod.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_free.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_import.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_make_key.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_sign_hash.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_verify_hash.c"
+#include "src\libtomcrypt\src\pk\rsa\rsa_verify_simple.c"