Menu
▾
▴
[Oorexx-svn] SF.net SVN: oorexx-code-0:[8551] sandbox/mark/ooSQLite.encrypted/src
|
From: <mie...@us...> - 2012-11-01 02:16:57
|
Revision: 8551
http://sourceforge.net/p/oorexx/code-0/8551
Author: miesfeld
Date: 2012-11-01 02:16:54 +0000 (Thu, 01 Nov 2012)
Log Message:
-----------
Add OO_CLASSIC_STEM implementation to my sandbox
Modified Paths:
--------------
sandbox/mark/ooSQLite.encrypted/src/ooSQLite.cpp
sandbox/mark/ooSQLite.encrypted/src/ooSQLite.hpp
sandbox/mark/ooSQLite.encrypted/src/rexx/ooSQLite.cls
Removed Paths:
-------------
sandbox/mark/ooSQLite.encrypted/src/botan/NOTICE
sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_amd64.cpp
sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_amd64.h
sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_x86.cpp
sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_x86.h
Deleted: sandbox/mark/ooSQLite.encrypted/src/botan/NOTICE
===================================================================
--- sandbox/mark/ooSQLite.encrypted/src/botan/NOTICE 2012-11-01 02:07:57 UTC (rev 8550)
+++ sandbox/mark/ooSQLite.encrypted/src/botan/NOTICE 2012-11-01 02:16:54 UTC (rev 8551)
@@ -1,47 +0,0 @@
-The files in this directroy are from the Botan Cryptographic Library. They
-are generated from the Botan source files and each one is configured for
-a specific type of build.
-
-Botan (http://botan.randombit.net/) is distributed under these terms:
-
-Copyright (C) 1999-2012 Jack Lloyd
- 2001 Peter J Jones
- 2004-2007 Justin Karneges
- 2004 Vaclav Ovsik
- 2005 Matthew Gregan
- 2005-2006 Matt Johnston
- 2006 Luca Piccarreta
- 2007 Yves Jerschow
- 2007-2008 FlexSecure GmbH
- 2007-2008 Technische Universitat Darmstadt
- 2007-2008 Falko Strenzke
- 2007-2008 Martin Doering
- 2007 Manuel Hartl
- 2007 Christoph Ludwig
- 2007 Patrick Sona
- 2010 Olivier de Gaalon
- 2012 Vojtech Kral
- 2012 Markus Wanner
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,
- this list of conditions, and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions, and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
Deleted: sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_amd64.cpp
===================================================================
--- sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_amd64.cpp 2012-11-01 02:07:57 UTC (rev 8550)
+++ sandbox/mark/ooSQLite.encrypted/src/botan/botan_all_amd64.cpp 2012-11-01 02:16:54 UTC (rev 8551)
@@ -1,46054 +0,0 @@
-/*
-* Botan 1.10.3 Amalgamation
-* (C) 1999-2011 Jack Lloyd and others
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include "botan_all.h"
-#include <map>
-#include <vector>
-#include <string>
-#include <deque>
-#include <utility>
-
-
-namespace Botan {
-
-/**
-* Win32 Entropy Source
-*/
-class Win32_EntropySource : public EntropySource
- {
- public:
- std::string name() const { return "Win32 Statistics"; }
- void poll(Entropy_Accumulator& accum);
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Represents a DLL or shared object
-*/
-class Dynamically_Loaded_Library
- {
- public:
- /**
- * Load a DLL (or fail with an exception)
- * @param lib_name name or path to a library
- *
- * If you don't use a full path, the search order will be defined
- * by whatever the system linker does by default. Always using fully
- * qualified pathnames can help prevent code injection attacks (eg
- * via manipulation of LD_LIBRARY_PATH on Linux)
- */
- Dynamically_Loaded_Library(const std::string& lib_name);
-
- /**
- * Unload the DLL
- * @warning Any pointers returned by resolve()/resolve_symbol()
- * should not be used after this destructor runs.
- */
- ~Dynamically_Loaded_Library();
-
- /**
- * Load a symbol (or fail with an exception)
- * @param symbol names the symbol to load
- * @return address of the loaded symbol
- */
- void* resolve_symbol(const std::string& symbol);
-
- /**
- * Convenience function for casting symbol to the right type
- * @param symbol names the symbol to load
- * @return address of the loaded symbol
- */
- template<typename T>
- T resolve(const std::string& symbol)
- {
-#if defined(__GNUC__) && __GNUC__ < 4
- return (T)(resolve_symbol(symbol));
-#else
- return reinterpret_cast<T>(resolve_symbol(symbol));
-#endif
- }
-
- private:
- Dynamically_Loaded_Library(const Dynamically_Loaded_Library&);
- Dynamically_Loaded_Library& operator=(const Dynamically_Loaded_Library&);
-
- std::string lib_name;
- void* lib;
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* XOR arrays. Postcondition out[i] = in[i] ^ out[i] forall i = 0...length
-* @param out the input/output buffer
-* @param in the read-only input buffer
-* @param length the length of the buffers
-*/
-inline void xor_buf(byte out[], const byte in[], size_t length)
- {
- while(length >= 8)
- {
-#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
- *reinterpret_cast<u64bit*>(out) ^= *reinterpret_cast<const u64bit*>(in);
-#else
- out[0] ^= in[0]; out[1] ^= in[1];
- out[2] ^= in[2]; out[3] ^= in[3];
- out[4] ^= in[4]; out[5] ^= in[5];
- out[6] ^= in[6]; out[7] ^= in[7];
-#endif
-
- out += 8; in += 8; length -= 8;
- }
-
- for(size_t i = 0; i != length; ++i)
- out[i] ^= in[i];
- }
-
-/**
-* XOR arrays. Postcondition out[i] = in[i] ^ in2[i] forall i = 0...length
-* @param out the output buffer
-* @param in the first input buffer
-* @param in2 the second output buffer
-* @param length the length of the three buffers
-*/
-inline void xor_buf(byte out[],
- const byte in[],
- const byte in2[],
- size_t length)
- {
- while(length >= 8)
- {
-#if BOTAN_TARGET_UNALIGNED_MEMORY_ACCESS_OK
- *reinterpret_cast<u64bit*>(out) =
- *reinterpret_cast<const u64bit*>(in) ^
- *reinterpret_cast<const u64bit*>(in2);
-#else
- out[0] = in[0] ^ in2[0]; out[1] = in[1] ^ in2[1];
- out[2] = in[2] ^ in2[2]; out[3] = in[3] ^ in2[3];
- out[4] = in[4] ^ in2[4]; out[5] = in[5] ^ in2[5];
- out[6] = in[6] ^ in2[6]; out[7] = in[7] ^ in2[7];
-#endif
-
- in += 8; in2 += 8; out += 8; length -= 8;
- }
-
- for(size_t i = 0; i != length; ++i)
- out[i] = in[i] ^ in2[i];
- }
-
-}
-
-
-namespace Botan {
-
-/**
-* Mutex Base Class
-*/
-class Mutex
- {
- public:
- /**
- * Lock the mutex
- */
- virtual void lock() = 0;
-
- /**
- * Unlock the mutex
- */
- virtual void unlock() = 0;
- virtual ~Mutex() {}
- };
-
-/**
-* Mutex Factory
-*/
-class Mutex_Factory
- {
- public:
- /**
- * @return newly allocated mutex
- */
- virtual Mutex* make() = 0;
-
- virtual ~Mutex_Factory() {}
- };
-
-/**
-* Mutex Holding Class for RAII
-*/
-class Mutex_Holder
- {
- public:
- /**
- * Hold onto a mutex until we leave scope
- * @param m the mutex to lock
- */
- Mutex_Holder(Mutex* m) : mux(m)
- {
- if(!mux)
- throw Invalid_Argument("Mutex_Holder: Argument was NULL");
- mux->lock();
- }
-
- ~Mutex_Holder() { mux->unlock(); }
- private:
- Mutex* mux;
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Copy-on-Predicate Algorithm
-* @param current the first iterator value
-* @param end the final iterator value
-* @param dest an output iterator
-* @param copy_p the predicate
-*/
-template<typename InputIterator, typename OutputIterator, typename Predicate>
-OutputIterator copy_if(InputIterator current, InputIterator end,
- OutputIterator dest, Predicate copy_p)
- {
- while(current != end)
- {
- if(copy_p(*current))
- *dest++ = *current;
- ++current;
- }
- return dest;
- }
-
-/**
-* Searching through a std::map
-* @param mapping the map to search
-* @param key is what to look for
-* @param null_result is the value to return if key is not in mapping
-* @return mapping[key] or null_result
-*/
-template<typename K, typename V>
-inline V search_map(const std::map<K, V>& mapping,
- const K& key,
- const V& null_result = V())
- {
- typename std::map<K, V>::const_iterator i = mapping.find(key);
- if(i == mapping.end())
- return null_result;
- return i->second;
- }
-
-/**
-* Function adaptor for delete operation
-*/
-template<class T>
-class del_fun : public std::unary_function<T, void>
- {
- public:
- void operator()(T* ptr) { delete ptr; }
- };
-
-/**
-* Delete the second half of a pair of objects
-*/
-template<typename Pair>
-void delete2nd(Pair& pair)
- {
- delete pair.second;
- }
-
-/**
-* Insert a key/value pair into a multimap
-*/
-template<typename K, typename V>
-void multimap_insert(std::multimap<K, V>& multimap,
- const K& key, const V& value)
- {
-#if defined(BOTAN_BUILD_COMPILER_IS_SUN_STUDIO)
- // Work around a strange bug in Sun Studio
- multimap.insert(std::make_pair<const K, V>(key, value));
-#else
- multimap.insert(std::make_pair(key, value));
-#endif
- }
-
-}
-
-
-namespace Botan {
-
-/**
-* @param prov_name a provider name
-* @return weight for this provider
-*/
-size_t static_provider_weight(const std::string& prov_name);
-
-/**
-* Algorithm_Cache (used by Algorithm_Factory)
-*/
-template<typename T>
-class Algorithm_Cache
- {
- public:
- /**
- * @param algo_spec names the requested algorithm
- * @param pref_provider suggests a preferred provider
- * @return prototype object, or NULL
- */
- const T* get(const std::string& algo_spec,
- const std::string& pref_provider);
-
- /**
- * Add a new algorithm implementation to the cache
- * @param algo the algorithm prototype object
- * @param requested_name how this name will be requested
- * @param provider_name is the name of the provider of this prototype
- */
- void add(T* algo,
- const std::string& requested_name,
- const std::string& provider_name);
-
- /**
- * Set the preferred provider
- * @param algo_spec names the algorithm
- * @param provider names the preferred provider
- */
- void set_preferred_provider(const std::string& algo_spec,
- const std::string& provider);
-
- /**
- * Return the list of providers of this algorithm
- * @param algo_name names the algorithm
- * @return list of providers of this algorithm
- */
- std::vector<std::string> providers_of(const std::string& algo_name);
-
- /**
- * Clear the cache
- */
- void clear_cache();
-
- /**
- * Constructor
- * @param m a mutex to serialize internal access
- */
- Algorithm_Cache(Mutex* m) : mutex(m) {}
- ~Algorithm_Cache() { clear_cache(); delete mutex; }
- private:
- typedef typename std::map<std::string, std::map<std::string, T*> >::iterator
- algorithms_iterator;
-
- typedef typename std::map<std::string, T*>::iterator provider_iterator;
-
- algorithms_iterator find_algorithm(const std::string& algo_spec);
-
- Mutex* mutex;
- std::map<std::string, std::string> aliases;
- std::map<std::string, std::string> pref_providers;
- std::map<std::string, std::map<std::string, T*> > algorithms;
- };
-
-/*
-* Look for an algorithm implementation in the cache, also checking aliases
-* Assumes object lock is held
-*/
-template<typename T>
-typename Algorithm_Cache<T>::algorithms_iterator
-Algorithm_Cache<T>::find_algorithm(const std::string& algo_spec)
- {
- algorithms_iterator algo = algorithms.find(algo_spec);
-
- // Not found? Check if a known alias
- if(algo == algorithms.end())
- {
- std::map<std::string, std::string>::const_iterator alias =
- aliases.find(algo_spec);
-
- if(alias != aliases.end())
- algo = algorithms.find(alias->second);
- }
-
- return algo;
- }
-
-/*
-* Look for an algorithm implementation by a particular provider
-*/
-template<typename T>
-const T* Algorithm_Cache<T>::get(const std::string& algo_spec,
- const std::string& requested_provider)
- {
- Mutex_Holder lock(mutex);
-
- algorithms_iterator algo = find_algorithm(algo_spec);
- if(algo == algorithms.end()) // algo not found at all (no providers)
- return 0;
-
- // If a provider is requested specifically, return it or fail entirely
- if(requested_provider != "")
- {
- provider_iterator prov = algo->second.find(requested_provider);
- if(prov != algo->second.end())
- return prov->second;
- return 0;
- }
-
- const T* prototype = 0;
- std::string prototype_provider;
- size_t prototype_prov_weight = 0;
-
- const std::string pref_provider = search_map(pref_providers, algo_spec);
-
- for(provider_iterator i = algo->second.begin(); i != algo->second.end(); ++i)
- {
- const std::string prov_name = i->first;
- const size_t prov_weight = static_provider_weight(prov_name);
-
- // preferred prov exists, return immediately
- if(prov_name == pref_provider)
- return i->second;
-
- if(prototype == 0 || prov_weight > prototype_prov_weight)
- {
- prototype = i->second;
- prototype_provider = i->first;
- prototype_prov_weight = prov_weight;
- }
- }
-
- return prototype;
- }
-
-/*
-* Add an implementation to the cache
-*/
-template<typename T>
-void Algorithm_Cache<T>::add(T* algo,
- const std::string& requested_name,
- const std::string& provider)
- {
- if(!algo)
- return;
-
- Mutex_Holder lock(mutex);
-
- if(algo->name() != requested_name &&
- aliases.find(requested_name) == aliases.end())
- {
- aliases[requested_name] = algo->name();
- }
-
- if(!algorithms[algo->name()][provider])
- algorithms[algo->name()][provider] = algo;
- else
- delete algo;
- }
-
-/*
-* Find the providers of this algo (if any)
-*/
-template<typename T> std::vector<std::string>
-Algorithm_Cache<T>::providers_of(const std::string& algo_name)
- {
- Mutex_Holder lock(mutex);
-
- std::vector<std::string> providers;
-
- algorithms_iterator algo = find_algorithm(algo_name);
-
- if(algo != algorithms.end())
- {
- provider_iterator provider = algo->second.begin();
-
- while(provider != algo->second.end())
- {
- providers.push_back(provider->first);
- ++provider;
- }
- }
-
- return providers;
- }
-
-/*
-* Set the preferred provider for an algorithm
-*/
-template<typename T>
-void Algorithm_Cache<T>::set_preferred_provider(const std::string& algo_spec,
- const std::string& provider)
- {
- Mutex_Holder lock(mutex);
-
- pref_providers[algo_spec] = provider;
- }
-
-/*
-* Clear out the cache
-*/
-template<typename T>
-void Algorithm_Cache<T>::clear_cache()
- {
- algorithms_iterator algo = algorithms.begin();
-
- while(algo != algorithms.end())
- {
- provider_iterator provider = algo->second.begin();
-
- while(provider != algo->second.end())
- {
- delete provider->second;
- ++provider;
- }
-
- ++algo;
- }
-
- algorithms.clear();
- }
-
-}
-
-
-namespace Botan {
-
-/**
-* Round up
-* @param n an integer
-* @param align_to the alignment boundary
-* @return n rounded up to a multiple of align_to
-*/
-template<typename T>
-inline T round_up(T n, T align_to)
- {
- if(n % align_to || n == 0)
- n += align_to - (n % align_to);
- return n;
- }
-
-/**
-* Round down
-* @param n an integer
-* @param align_to the alignment boundary
-* @return n rounded down to a multiple of align_to
-*/
-template<typename T>
-inline T round_down(T n, T align_to)
- {
- return (n - (n % align_to));
- }
-
-}
-
-#if defined(BOTAN_TARGET_CPU_HAS_SSE2)
-
-#include <emmintrin.h>
-
-namespace Botan {
-
-class SIMD_SSE2
- {
- public:
- static bool enabled() { return CPUID::has_sse2(); }
-
- SIMD_SSE2(const u32bit B[4])
- {
- reg = _mm_loadu_si128(reinterpret_cast<const __m128i*>(B));
- }
-
- SIMD_SSE2(u32bit B0, u32bit B1, u32bit B2, u32bit B3)
- {
- reg = _mm_set_epi32(B0, B1, B2, B3);
- }
-
- SIMD_SSE2(u32bit B)
- {
- reg = _mm_set1_epi32(B);
- }
-
- static SIMD_SSE2 load_le(const void* in)
- {
- return _mm_loadu_si128(reinterpret_cast<const __m128i*>(in));
- }
-
- static SIMD_SSE2 load_be(const void* in)
- {
- return load_le(in).bswap();
- }
-
- void store_le(byte out[]) const
- {
- _mm_storeu_si128(reinterpret_cast<__m128i*>(out), reg);
- }
-
- void store_be(byte out[]) const
- {
- bswap().store_le(out);
- }
-
- void rotate_left(size_t rot)
- {
- reg = _mm_or_si128(_mm_slli_epi32(reg, static_cast<int>(rot)),
- _mm_srli_epi32(reg, static_cast<int>(32-rot)));
- }
-
- void rotate_right(size_t rot)
- {
- rotate_left(32 - rot);
- }
-
- void operator+=(const SIMD_SSE2& other)
- {
- reg = _mm_add_epi32(reg, other.reg);
- }
-
- SIMD_SSE2 operator+(const SIMD_SSE2& other) const
- {
- return _mm_add_epi32(reg, other.reg);
- }
-
- void operator-=(const SIMD_SSE2& other)
- {
- reg = _mm_sub_epi32(reg, other.reg);
- }
-
- SIMD_SSE2 operator-(const SIMD_SSE2& other) const
- {
- return _mm_sub_epi32(reg, other.reg);
- }
-
- void operator^=(const SIMD_SSE2& other)
- {
- reg = _mm_xor_si128(reg, other.reg);
- }
-
- SIMD_SSE2 operator^(const SIMD_SSE2& other) const
- {
- return _mm_xor_si128(reg, other.reg);
- }
-
- void operator|=(const SIMD_SSE2& other)
- {
- reg = _mm_or_si128(reg, other.reg);
- }
-
- SIMD_SSE2 operator&(const SIMD_SSE2& other)
- {
- return _mm_and_si128(reg, other.reg);
- }
-
- void operator&=(const SIMD_SSE2& other)
- {
- reg = _mm_and_si128(reg, other.reg);
- }
-
- SIMD_SSE2 operator<<(size_t shift) const
- {
- return _mm_slli_epi32(reg, static_cast<int>(shift));
- }
-
- SIMD_SSE2 operator>>(size_t shift) const
- {
- return _mm_srli_epi32(reg, static_cast<int>(shift));
- }
-
- SIMD_SSE2 operator~() const
- {
- return _mm_xor_si128(reg, _mm_set1_epi32(0xFFFFFFFF));
- }
-
- // (~reg) & other
- SIMD_SSE2 andc(const SIMD_SSE2& other)
- {
- return _mm_andnot_si128(reg, other.reg);
- }
-
- SIMD_SSE2 bswap() const
- {
- __m128i T = reg;
-
- T = _mm_shufflehi_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
- T = _mm_shufflelo_epi16(T, _MM_SHUFFLE(2, 3, 0, 1));
-
- return _mm_or_si128(_mm_srli_epi16(T, 8),
- _mm_slli_epi16(T, 8));
- }
-
- static void transpose(SIMD_SSE2& B0, SIMD_SSE2& B1,
- SIMD_SSE2& B2, SIMD_SSE2& B3)
- {
- __m128i T0 = _mm_unpacklo_epi32(B0.reg, B1.reg);
- __m128i T1 = _mm_unpacklo_epi32(B2.reg, B3.reg);
- __m128i T2 = _mm_unpackhi_epi32(B0.reg, B1.reg);
- __m128i T3 = _mm_unpackhi_epi32(B2.reg, B3.reg);
- B0.reg = _mm_unpacklo_epi64(T0, T1);
- B1.reg = _mm_unpackhi_epi64(T0, T1);
- B2.reg = _mm_unpacklo_epi64(T2, T3);
- B3.reg = _mm_unpackhi_epi64(T2, T3);
- }
-
- private:
- SIMD_SSE2(__m128i in) { reg = in; }
-
- __m128i reg;
- };
-
-}
-
-#endif
-
-
-namespace Botan {
-
-/**
-* Entropy source using high resolution timers
-*
-* @note Any results from timers are marked as not contributing entropy
-* to the poll, as a local attacker could observe them directly.
-*/
-class High_Resolution_Timestamp : public EntropySource
- {
- public:
- std::string name() const { return "High Resolution Timestamp"; }
- void poll(Entropy_Accumulator& accum);
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Win32 Mutex Factory
-*/
-class Win32_Mutex_Factory : public Mutex_Factory
- {
- public:
- Mutex* make();
- };
-}
-
-
-namespace Botan {
-
-/**
-* Power of 2 test. T should be an unsigned integer type
-* @param arg an integer value
-* @return true iff arg is 2^n for some n > 0
-*/
-template<typename T>
-inline bool power_of_2(T arg)
- {
- return ((arg != 0 && arg != 1) && ((arg & (arg-1)) == 0));
- }
-
-/**
-* Return the index of the highest set bit
-* T is an unsigned integer type
-* @param n an integer value
-* @return index of the highest set bit in n
-*/
-template<typename T>
-inline size_t high_bit(T n)
- {
- for(size_t i = 8*sizeof(T); i > 0; --i)
- if((n >> (i - 1)) & 0x01)
- return i;
- return 0;
- }
-
-/**
-* Return the index of the lowest set bit
-* T is an unsigned integer type
-* @param n an integer value
-* @return index of the lowest set bit in n
-*/
-template<typename T>
-inline size_t low_bit(T n)
- {
- for(size_t i = 0; i != 8*sizeof(T); ++i)
- if((n >> i) & 0x01)
- return (i + 1);
- return 0;
- }
-
-/**
-* Return the number of significant bytes in n
-* @param n an integer value
-* @return number of significant bytes in n
-*/
-template<typename T>
-inline size_t significant_bytes(T n)
- {
- for(size_t i = 0; i != sizeof(T); ++i)
- if(get_byte(i, n))
- return sizeof(T)-i;
- return 0;
- }
-
-/**
-* Compute Hamming weights
-* @param n an integer value
-* @return number of bits in n set to 1
-*/
-template<typename T>
-inline size_t hamming_weight(T n)
- {
- const byte NIBBLE_WEIGHTS[] = {
- 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
-
- size_t weight = 0;
- for(size_t i = 0; i != 2*sizeof(T); ++i)
- weight += NIBBLE_WEIGHTS[(n >> (4*i)) & 0x0F];
- return weight;
- }
-
-/**
-* Count the trailing zero bits in n
-* @param n an integer value
-* @return maximum x st 2^x divides n
-*/
-template<typename T>
-inline size_t ctz(T n)
- {
- for(size_t i = 0; i != 8*sizeof(T); ++i)
- if((n >> i) & 0x01)
- return i;
- return 8*sizeof(T);
- }
-
-}
-
-
-namespace Botan {
-
-/**
-* Estimate work factor for discrete logarithm
-* @param prime_group_size size of the group in bits
-* @return estimated security level for this group
-*/
-size_t dl_work_factor(size_t prime_group_size);
-
-}
-
-
-namespace Botan {
-
-/**
-* No-Op Mutex Factory
-*/
-class Noop_Mutex_Factory : public Mutex_Factory
- {
- public:
- Mutex* make();
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Pooling Allocator
-*/
-class Pooling_Allocator : public Allocator
- {
- public:
- void* allocate(size_t);
- void deallocate(void*, size_t);
-
- void destroy();
-
- /**
- * @param mutex used for internal locking
- */
- Pooling_Allocator(Mutex* mutex);
- ~Pooling_Allocator();
- private:
- void get_more_core(size_t);
- byte* allocate_blocks(size_t);
-
- virtual void* alloc_block(size_t) = 0;
- virtual void dealloc_block(void*, size_t) = 0;
-
- class Memory_Block
- {
- public:
- Memory_Block(void*);
-
- static size_t bitmap_size() { return BITMAP_SIZE; }
- static size_t block_size() { return BLOCK_SIZE; }
-
- bool contains(void*, size_t) const;
- byte* alloc(size_t);
- void free(void*, size_t);
-
- bool operator<(const Memory_Block& other) const
- {
- if(buffer < other.buffer && other.buffer < buffer_end)
- return false;
- return (buffer < other.buffer);
- }
- private:
- typedef u64bit bitmap_type;
- static const size_t BITMAP_SIZE = 8 * sizeof(bitmap_type);
- static const size_t BLOCK_SIZE = 64;
-
- bitmap_type bitmap;
- byte* buffer, *buffer_end;
- };
-
- std::vector<Memory_Block> blocks;
- std::vector<Memory_Block>::iterator last_used;
- std::vector<std::pair<void*, size_t> > allocated;
- Mutex* mutex;
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Allocator using malloc
-*/
-class Malloc_Allocator : public Allocator
- {
- public:
- void* allocate(size_t);
- void deallocate(void*, size_t);
-
- std::string type() const { return "malloc"; }
- };
-
-/**
-* Allocator using malloc plus locking
-*/
-class Locking_Allocator : public Pooling_Allocator
- {
- public:
- /**
- * @param mutex used for internal locking
- */
- Locking_Allocator(Mutex* mutex) : Pooling_Allocator(mutex) {}
-
- std::string type() const { return "locking"; }
- private:
- void* alloc_block(size_t);
- void dealloc_block(void*, size_t);
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Check if we can at least potentially lock memory
-*/
-bool has_mlock();
-
-/**
-* Lock memory into RAM if possible
-* @param addr the start of the memory block
-* @param length the length of the memory block in bytes
-* @returns true if successful, false otherwise
-*/
-bool lock_mem(void* addr, size_t length);
-
-/**
-* Unlock memory locked with lock_mem()
-* @param addr the start of the memory block
-* @param length the length of the memory block in bytes
-*/
-void unlock_mem(void* addr, size_t length);
-
-}
-
-#include <intrin.h>
-
-#if (BOTAN_MP_WORD_BITS != 64)
- #error The mp_msvc64 module requires that BOTAN_MP_WORD_BITS == 64
-#endif
-
-#pragma intrinsic(_umul128)
-
-namespace Botan {
-
-extern "C" {
-
-/*
-* Word Multiply
-*/
-inline word word_madd2(word a, word b, word* c)
- {
- word hi, lo;
- lo = _umul128(a, b, &hi);
-
- lo += *c;
- hi += (lo < *c); // carry?
-
- *c = hi;
- return lo;
- }
-
-/*
-* Word Multiply/Add
-*/
-inline word word_madd3(word a, word b, word c, word* d)
- {
- word hi, lo;
- lo = _umul128(a, b, &hi);
-
- lo += c;
- hi += (lo < c); // carry?
-
- lo += *d;
- hi += (lo < *d); // carry?
-
- *d = hi;
- return lo;
- }
-
-}
-
-}
-
-
-#if defined(BOTAN_HAS_SIMD_SSE2)
- namespace Botan { typedef SIMD_SSE2 SIMD_32; }
-
-#elif defined(BOTAN_HAS_SIMD_ALTIVEC)
- namespace Botan { typedef SIMD_Altivec SIMD_32; }
-
-#elif defined(BOTAN_HAS_SIMD_SCALAR)
- namespace Botan { typedef SIMD_Scalar SIMD_32; }
-
-#else
- #error "No SIMD module defined"
-
-#endif
-
-
-namespace Botan {
-
-/**
-* Engine for implementations that use some kind of SIMD
-*/
-class SIMD_Engine : public Engine
- {
- public:
- std::string provider_name() const { return "simd"; }
-
- BlockCipher* find_block_cipher(const SCAN_Name&,
- Algorithm_Factory&) const;
-
- HashFunction* find_hash(const SCAN_Name& request,
- Algorithm_Factory&) const;
- };
-
-}
-
-
-namespace Botan {
-
-Public_Key* make_public_key(const AlgorithmIdentifier& alg_id,
- const MemoryRegion<byte>& key_bits);
-
-Private_Key* make_private_key(const AlgorithmIdentifier& alg_id,
- const MemoryRegion<byte>& key_bits,
- RandomNumberGenerator& rng);
-
-}
-
-
-namespace Botan {
-
-/*
-* The size of the word type, in bits
-*/
-const size_t MP_WORD_BITS = BOTAN_MP_WORD_BITS;
-
-extern "C" {
-
-/*
-* Addition/Subtraction Operations
-*/
-void bigint_add2(word x[], size_t x_size,
- const word y[], size_t y_size);
-
-void bigint_add3(word z[],
- const word x[], size_t x_size,
- const word y[], size_t y_size);
-
-word bigint_add2_nc(word x[], size_t x_size, const word y[], size_t y_size);
-
-word bigint_add3_nc(word z[],
- const word x[], size_t x_size,
- const word y[], size_t y_size);
-
-word bigint_sub2(word x[], size_t x_size,
- const word y[], size_t y_size);
-
-/**
-* x = y - x; assumes y >= x
-*/
-void bigint_sub2_rev(word x[], const word y[], size_t y_size);
-
-word bigint_sub3(word z[],
- const word x[], size_t x_size,
- const word y[], size_t y_size);
-
-/*
-* Shift Operations
-*/
-void bigint_shl1(word x[], size_t x_size,
- size_t word_shift, size_t bit_shift);
-
-void bigint_shr1(word x[], size_t x_size,
- size_t word_shift, size_t bit_shift);
-
-void bigint_shl2(word y[], const word x[], size_t x_size,
- size_t word_shift, size_t bit_shift);
-
-void bigint_shr2(word y[], const word x[], size_t x_size,
- size_t word_shift, size_t bit_shift);
-
-/*
-* Simple O(N^2) Multiplication and Squaring
-*/
-void bigint_simple_mul(word z[],
- const word x[], size_t x_size,
- const word y[], size_t y_size);
-
-void bigint_simple_sqr(word z[], const word x[], size_t x_size);
-
-/*
-* Linear Multiply
-*/
-void bigint_linmul2(word x[], size_t x_size, word y);
-void bigint_linmul3(word z[], const word x[], size_t x_size, word y);
-
-/**
-* Montgomery Reduction
-* @param z integer to reduce (also output in first p_size+1 words)
-* @param z_size size of z (should be >= 2*p_size+1)
-* @param p modulus
-* @param p_size size of p
-* @param p_dash Montgomery value
-* @param workspace array of at least 2*(p_size+1) words
-*/
-void bigint_monty_redc(word z[], size_t z_size,
- const word p[], size_t p_size, word p_dash,
- word workspace[]);
-
-/*
-* Montgomery Multiplication
-*/
-void bigint_monty_mul(word z[], size_t z_size,
- const word x[], size_t x_size, size_t x_sw,
- const word y[], size_t y_size, size_t y_sw,
- const word p[], size_t p_size, word p_dash,
- word workspace[]);
-
-/*
-* Montgomery Squaring
-*/
-void bigint_monty_sqr(word z[], size_t z_size,
- const word x[], size_t x_size, size_t x_sw,
- const word p[], size_t p_size, word p_dash,
- word workspace[]);
-
-/*
-* Division operation
-*/
-size_t bigint_divcore(word q, word y2, word y1,
- word x3, word x2, word x1);
-
-/**
-* Compare x and y
-*/
-s32bit bigint_cmp(const word x[], size_t x_size,
- const word y[], size_t y_size);
-
-/**
-* Compute ((n1<<bits) + n0) / d
-*/
-word bigint_divop(word n1, word n0, word d);
-
-/**
-* Compute ((n1<<bits) + n0) % d
-*/
-word bigint_modop(word n1, word n0, word d);
-
-/*
-* Comba Multiplication / Squaring
-*/
-void bigint_comba_mul4(word z[8], const word x[4], const word y[4]);
-void bigint_comba_mul6(word z[12], const word x[6], const word y[6]);
-void bigint_comba_mul8(word z[16], const word x[8], const word y[8]);
-void bigint_comba_mul16(word z[32], const word x[16], const word y[16]);
-
-void bigint_comba_sqr4(word out[8], const word in[4]);
-void bigint_comba_sqr6(word out[12], const word in[6]);
-void bigint_comba_sqr8(word out[16], const word in[8]);
-void bigint_comba_sqr16(word out[32], const word in[16]);
-
-}
-
-/*
-* High Level Multiplication/Squaring Interfaces
-*/
-void bigint_mul(word z[], size_t z_size, word workspace[],
- const word x[], size_t x_size, size_t x_sw,
- const word y[], size_t y_size, size_t y_sw);
-
-void bigint_sqr(word z[], size_t z_size, word workspace[],
- const word x[], size_t x_size, size_t x_sw);
-
-}
-
-
-namespace Botan {
-
-/**
-* Fixed Window Exponentiator
-*/
-class Fixed_Window_Exponentiator : public Modular_Exponentiator
- {
- public:
- void set_exponent(const BigInt&);
- void set_base(const BigInt&);
- BigInt execute() const;
-
- Modular_Exponentiator* copy() const
- { return new Fixed_Window_Exponentiator(*this); }
-
- Fixed_Window_Exponentiator(const BigInt&, Power_Mod::Usage_Hints);
- private:
- Modular_Reducer reducer;
- BigInt exp;
- size_t window_bits;
- std::vector<BigInt> g;
- Power_Mod::Usage_Hints hints;
- };
-
-/**
-* Montgomery Exponentiator
-*/
-class Montgomery_Exponentiator : public Modular_Exponentiator
- {
- public:
- void set_exponent(const BigInt&);
- void set_base(const BigInt&);
- BigInt execute() const;
-
- Modular_Exponentiator* copy() const
- { return new Montgomery_Exponentiator(*this); }
-
- Montgomery_Exponentiator(const BigInt&, Power_Mod::Usage_Hints);
- private:
- BigInt exp, modulus;
- BigInt R2, R_mod;
- std::vector<BigInt> g;
- word mod_prime;
- size_t mod_words, exp_bits, window_bits;
- Power_Mod::Usage_Hints hints;
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Core Engine
-*/
-class Core_Engine : public Engine
- {
- public:
- std::string provider_name() const { return "core"; }
-
- PK_Ops::Key_Agreement*
- get_key_agreement_op(const Private_Key& key) const;
-
- PK_Ops::Signature*
- get_signature_op(const Private_Key& key) const;
-
- PK_Ops::Verification* get_verify_op(const Public_Key& key) const;
-
- PK_Ops::Encryption* get_encryption_op(const Public_Key& key) const;
-
- PK_Ops::Decryption* get_decryption_op(const Private_Key& key) const;
-
- Modular_Exponentiator* mod_exp(const BigInt& n,
- Power_Mod::Usage_Hints) const;
-
- Keyed_Filter* get_cipher(const std::string&, Cipher_Dir,
- Algorithm_Factory&);
-
- BlockCipher* find_block_cipher(const SCAN_Name&,
- Algorithm_Factory&) const;
-
- StreamCipher* find_stream_cipher(const SCAN_Name&,
- Algorithm_Factory&) const;
-
- HashFunction* find_hash(const SCAN_Name& request,
- Algorithm_Factory&) const;
-
- MessageAuthenticationCode* find_mac(const SCAN_Name& request,
- Algorithm_Factory&) const;
-
- PBKDF* find_pbkdf(const SCAN_Name& algo_spec,
- Algorithm_Factory& af) const;
- };
-
-/**
-* Create a cipher mode filter object
-* @param block_cipher a block cipher object
-* @param direction are we encrypting or decrypting?
-* @param mode the name of the cipher mode to use
-* @param padding the mode padding to use (only used for ECB, CBC)
-*/
-Keyed_Filter* get_cipher_mode(const BlockCipher* block_cipher,
- Cipher_Dir direction,
- const std::string& mode,
- const std::string& padding);
-
-}
-
-namespace Botan {
-
-void assertion_failure(const char* expr_str,
- const char* msg,
- const char* func,
- const char* file,
- int line);
-
-#define BOTAN_ASSERT(expr, msg) \
- do { \
- if(!(expr)) \
- Botan::assertion_failure(#expr, \
- msg, \
- BOTAN_ASSERT_FUNCTION, \
- __FILE__, \
- __LINE__); \
- } while(0)
-
-#define BOTAN_ASSERT_EQUAL(value1, value2, msg) \
- do { \
- if(value1 != value2) \
- Botan::assertion_failure(#value1 " == " #value2, \
- msg, \
- BOTAN_ASSERT_FUNCTION, \
- __FILE__, \
- __LINE__); \
- } while(0)
-
-/*
-* Unfortunately getting the function name from the preprocessor
-* isn't standard in C++98 (C++0x uses C99's __func__)
-*/
-#if defined(BOTAN_BUILD_COMPILER_IS_GCC) || \
- defined(BOTAN_BUILD_COMPILER_IS_CLANG) || \
- defined(BOTAN_BUILD_COMPILER_IS_INTEL)
-
- #define BOTAN_ASSERT_FUNCTION __PRETTY_FUNCTION__
-
-#elif defined(BOTAN_BUILD_COMPILER_IS_MSVC)
-
- #define BOTAN_ASSERT_FUNCTION __FUNCTION__
-
-#else
- #define BOTAN_ASSERT_FUNCTION ((const char*)0)
-#endif
-
-}
-
-
-namespace Botan {
-
-/**
-* Container of output buffers for Pipe
-*/
-class Output_Buffers
- {
- public:
- size_t read(byte[], size_t, Pipe::message_id);
- size_t peek(byte[], size_t, size_t, Pipe::message_id) const;
- size_t remaining(Pipe::message_id) const;
-
- void add(class SecureQueue*);
- void retire();
-
- Pipe::message_id message_count() const;
-
- Output_Buffers();
- ~Output_Buffers();
- private:
- class SecureQueue* get(Pipe::message_id) const;
-
- std::deque<SecureQueue*> buffers;
- Pipe::message_id offset;
- };
-
-}
-
-
-namespace Botan {
-
-/**
-* Win32 CAPI Entropy Source
-*/
-class Win32_CAPI_EntropySource : public EntropySource
- {
- public:
- std::string name() const { return "Win32 CryptoGenRandom"; }
-
- void poll(Entropy_Accumulator& accum);
-
- /**
- * Win32_Capi_Entropysource Constructor
- * @param provs list of providers, separated by ':'
- */
- Win32_CAPI_EntropySource(const std::string& provs = "");
- private:
- std::vector<u64bit> prov_types;
- };
-
-}
-
-
-namespace Botan {
-
-template<typename T>
-inline void prefetch_readonly(const T* addr, size_t length)
- {
-#if defined(__GNUG__)
- const size_t Ts_per_cache_line = CPUID::cache_line_size() / sizeof(T);
-
- for(size_t i = 0; i <= length; i += Ts_per_cache_line)
- __builtin_prefetch(addr + i, 0);
-#endif
- }
-
-template<typename T>
-inline void prefetch_readwrite(const T* addr, size_t length)
- {
-#if defined(__GNUG__)
- const size_t Ts_per_cache_line = CPUID::cache_line_size() / sizeof(T);
-
- for(size_t i = 0; i <= length; i += Ts_per_cache_line)
- __builtin_prefetch(addr + i, 1);
-#endif
- }
-
-}
-
-
-namespace Botan {
-
-const u64bit Camellia_SBOX1[256] = {
-0x7070700070000070, 0x8282820082000082, 0x2C2C2C002C00002C, 0xECECEC00EC0000EC,
-0xB3B3B300B30000B3, 0x2727270027000027, 0xC0C0C000C00000C0, 0xE5E5E500E50000E5,
-0xE4E4E400E40000E4, 0x8585850085000085, 0x5757570057000057, 0x3535350035000035,
-0xEAEAEA00EA0000EA, 0x0C0C0C000C00000C, 0xAEAEAE00AE0000AE, 0x4141410041000041,
-0x2323230023000023, 0xEFEFEF00EF0000EF, 0x6B6B6B006B00006B, 0x9393930093000093,
-0x4545450045000045, 0x1919190019000019, 0xA5A5A500A50000A5, 0x2121210021000021,
-0xEDEDED00ED0000ED, 0x0E0E0E000E00000E, 0x4F4F4F004F00004F, 0x4E4E4E004E00004E,
-0x1D1D1D001D00001D, 0x6565650065000065, 0x9292920092000092, 0xBDBDBD00BD0000BD,
-0x8686860086000086, 0xB8B8B800B80000B8, 0xAFAFAF00AF0000AF, 0x8F8F8F008F00008F,
-0x7C7C7C007C00007C, 0xEBEBEB00EB0000EB, 0x1F1F1F001F00001F, 0xCECECE00CE0000CE,
-0x3E3E3E003E00003E, 0x3030300030000030, 0xDCDCDC00DC0000DC, 0x5F5F5F005F00005F,
-0x5E5E5E005E00005E, 0xC5C5C500C50000C5, 0x0B0B0B000B00000B, 0x1A1A1A001A00001A,
-0xA6A6A600A60000A6, 0xE1E1E100E10000E1, 0x3939390039000039, 0xCACACA00CA0000CA,
-0xD5D5D500D50000D5, 0x4747470047000047, 0x5D5D5D005D00005D, 0x3D3D3D003D00003D,
-0xD9D9D900D90000D9, 0x0101010001000001, 0x5A5A5A005A00005A, 0xD6D6D600D60000D6,
-0x5151510051000051, 0x5656560056000056, 0x6C6C6C006C00006C, 0x4D4D4D004D00004D,
-0x8B8B8B008B00008B, 0x0D0D0D000D00000D, 0x9A9A9A009A00009A, 0x6666660066000066,
-0xFBFBFB00FB0000FB, 0xCCCCCC00CC0000CC, 0xB0B0B000B00000B0, 0x2D2D2D002D00002D,
-0x7474740074000074, 0x1212120012000012, 0x2B2B2B002B00002B, 0x2020200020000020,
-0xF0F0F000F00000F0, 0xB1B1B100B10000B1, 0x8484840084000084, 0x9999990099000099,
-0xDFDFDF00DF0000DF, 0x4C4C4C004C00004C, 0xCBCBCB00CB0000CB, 0xC2C2C200C20000C2,
-0x3434340034000034, 0x7E7E7E007E00007E, 0x7676760076000076, 0x0505050005000005,
-0x6D6D6D006D00006D, 0xB7B7B700B70000B7, 0xA9A9A900A90000A9, 0x3131310031000031,
-0xD1D1D100D10000D1, 0x1717170017000017, 0x0404040004000004, 0xD7D7D700D70000D7,
-0x1414140014000014, 0x5858580058000058, 0x3A3A3A003A00003A, 0x6161610061000061,
-0xDEDEDE00DE0000DE, 0x1B1B1B001B00001B, 0x1111110011000011, 0x1C1C1C001C00001C,
-0x3232320032000032, 0x0F0F0F000F00000F, 0x9C9C9C009C00009C, 0x1616160016000016,
-0x5353530053000053, 0x1818180018000018, 0xF2F2F200F20000F2, 0x2222220022000022,
-0xFEFEFE00FE0000FE, 0x4444440044000044, 0xCFCFCF00CF0000CF, 0xB2B2B200B20000B2,
-0xC3C3C300C30000C3, 0xB5B5B500B50000B5, 0x7A7A7A007A00007A, 0x9191910091000091,
-0x2424240024000024, 0x0808080008000008, 0xE8E8E800E80000E8, 0xA8A8A800A80000A8,
-0x6060600060000060, 0xFCFCFC00FC0000FC, 0x6969690069000069, 0x5050500050000050,
-0xAAAAAA00AA0000AA, 0xD0D0D000D00000D0, 0xA0A0A000A00000A0, 0x7D7D7D007D00007D,
-0xA1A1A100A10000A1, 0x8989890089000089, 0x6262620062000062, 0x9797970097000097,
-0x5454540054000054, 0x5B5B5B005B00005B, 0x1E1E1E001E00001E, 0x9595950095000095,
-0xE0E0E000E00000E0, 0xFFFFFF00FF0000FF, 0x6464640064000064, 0xD2D2D200D20000D2,
-0x1010100010000010, 0xC4C4C400C40000C4, 0x0000000000000000, 0x4848480048000048,
-0xA3A3A300A30000A3, 0xF7F7F700F70000F7, 0x7575750075000075, 0xDBDBDB00DB0000DB,
-0x8A8A8A008A00008A, 0x0303030003000003, 0xE6E6E600E60000E6, 0xDADADA00DA0000DA,
-0x0909090009000009, 0x3F3F3F003F00003F, 0xDDDDDD00DD0000DD, 0x9494940094000094,
-0x8787870087000087, 0x5C5C5C005C00005C, 0x8383830083000083, 0x0202020002000002,
-0xCDCDCD00CD0000CD, 0x4A4A4A004A00004A, 0x9090900090000090, 0x3333330033000033,
-0x7373730073000073, 0x6767670067000067, 0xF6F6F600F60000F6, 0xF3F3F300F30000F3,
-0x9D9D9D009D00009D, 0x7F7F7F007F00007F, 0xBFBFBF00BF0000BF, 0xE2E2E200E20000E2,
-0x5252520052000052, 0x9B9B9B009B00009B, 0xD8D8D800D80000D8, 0x2626260026000026,
-0xC8C8C800C80000C8, 0x3737370037000037, 0xC6C6C600C60000C6, 0x3B3B3B003B00003B,
-0x8181810081000081, 0x9696960096000096, 0x6F6F6F006F00006F, 0x4B4B4B004B00004B,
-0x1313130013000013, 0xBEBEBE00BE0000BE, 0x6363630063000063, 0x2E2E2E002E00002E,
-0xE9E9E900E90000E9, 0x7979790079000079, 0xA7A7A700A70000A7, 0x8C8C8C008C00008C,
-0x9F9F9F009F00009F, 0x6E6E6E006E00006E, 0xBCBCBC00BC0000BC, 0x8E8E8E008E00008E,
-0x2929290029000029, 0xF5F5F500F50000F5, 0xF9F9F900F90000F9, 0xB6B6B600B60000B6,
-0x2F2F2F002F00002F, 0xFDFDFD00FD0000FD, 0xB4B4B400B40000B4, 0x5959590059000059,
-0x7878780078000078, 0x9898980098000098, 0x0606060006000006, 0x6A6A6A006A00006A,
-0xE7E7E700E70000E7, 0x4646460046000046, 0x7171710071000071, 0xBABABA00BA0000BA,
-0xD4D4D400D40000D4, 0x2525250025000025, 0xABABAB00AB0000AB, 0x4242420042000042,
-0x8888880088000088, 0xA2A2A200A20000A2, 0x8D8D8D008D00008D, 0xFAFAFA00FA0000FA,
-0x7272720072000072, 0x0707070007000007, 0xB9B9B900B90000B9, 0x5555550055000055,
-0xF8F8F800F80000F8, 0xEEEEEE00EE0000EE, 0xACACAC00AC0000AC, 0x0A0A0A000A00000A,
-0x3636360036000036, 0x4949490049000049, 0x2A2A2A002A00002A, 0x6868680068000068,
-0x3C3C3C003C00003C, 0x3838380038000038, 0xF1F1F100F10000F1, 0xA4A4A400A40000A4,
-0x4040400040000040, 0x2828280028000028, 0xD3D3D300D30000D3, 0x7B7B7B007B00007B,
-0xBBBBBB00BB0000BB, 0xC9C9C900C90000C9, 0x4343430043000043, 0xC1C1C100C10000C1,
-0x1515150015000015, 0xE3E3E300E30000E3, 0xADADAD00AD0000AD, 0xF4F4F400F40000F4,
-0x7777770077000077, 0xC7C7C700C70000C7, 0x8080800080000080, 0x9E9E9E009E00009E };
-
-const u64bit Camellia_SBOX2[256] = {
-0x00E0E0E0E0E00000, 0x0005050505050000, 0x0058585858580000, 0x00D9D9D9D9D90000,
-0x0067676767670000, 0x004E4E4E4E4E0000, 0x0081818181810000, 0x00CBCBCBCBCB0000,
-0x00C9C9C9C9C90000, 0x000B0B0B0B0B0000, 0x00AEAEAEAEAE0000, 0x006A6A6A6A6A0000,
-0x00D5D5D5D5D50000, 0x0018181818180000, 0x005D5D5D5D5D0000, 0x0082828282820000,
-0x0046464646460000, 0x00DFDFDFDFDF0000, 0x00D6D6D6D6D60000, 0x0027272727270000,
-0x008A8A8A8A8A0000, 0x0032323232320000, 0x004B4B4B4B4B0000, 0x0042424242420000,
-0x00DBDBDBDBDB0000, 0x001C1C1C1C1C0000, 0x009E9E9E9E9E0000, 0x009C9C9C9C9C0000,
-0x003A3A3A3A3A0000, 0x00CACACACACA0000, 0x0025252525250000, 0x007B7B7B7B7B0000,
-0x000D0D0D0D0D0000, 0x0071717171710000, 0x005F5F5F5F5F0000, 0x001F1F1F1F1F0000,
-0x00F8F8F8F8F80000, 0x00D7D7D7D7D70000, 0x003E3E3E3E3E0000, 0x009D9D9D9D9D0000,
-0x007C7C7C7C7C0000, 0x0060606060600000, 0x00B9B9B9B9B90000, 0x00BEBEBEBEBE0000,
-0x00BCBCBCBCBC0000, 0x008B8B8B8B8B0000, 0x0016161616160000, 0x0034343434340000,
-0x004D4D4D4D4D0000, 0x00C3C3C3C3C30000, 0x0072727272720000, 0x0095959595950000,
-0x00ABABABABAB0000, 0x008E8E8E8E8E0000, 0x00BABABABABA0000, 0x007A7A7A7A7A0000,
-0x00B3B3B3B3B30000, 0x0002020202020000, 0x00B4B4B4B4B40000, 0x00ADADADADAD0000,
-0x00A2A2A2A2A20000, 0x00ACACACACAC0000, 0x00D8D8D8D8D80000, 0x009A9A9A9A9A0000,
-0x0017171717170000, 0x001A1A1A1A1A0000, 0x0035353535350000, 0x00CCCCCCCCCC0000,
-0x00F7F7F7F7F70000, 0x0099999999990000, 0x0061616161610000, 0x005A5A5A5A5A0000,
-0x00E8E8E8E8E80000, 0x0024242424240000, 0x0056565656560000, 0x0040404040400000,
-0x00E1E1E1E1E10000, 0x0063636363630000, 0x0009090909090000, 0x0033333333330000,
-0x00BFBFBFBFBF0000, 0x0098989898980000, 0x0097979797970000, 0x0085858585850000,
-0x0068686868680000, 0x00FCFCFCFCFC0000, 0x00ECECECECEC0000, 0x000A0A0A0A0A0000,
-0x00DADADADADA0000, 0x006F6F6F6F6F0000, 0x0053535353530000, 0x0062626262620000,
-0x00A3A3A3A3A30000, 0x002E2E2E2E2E0000, 0x0008080808080000, 0x00AFAFAFAFAF0000,
-0x0028282828280000, 0x00B0B0B0B0B00000, 0x0074747474740000, 0x00C2C2C2C2C20000,
-0x00BDBDBDBDBD0000, 0x0036363636360000, 0x0022222222220000, 0x0038383838380000,
-0x0064646464640000, 0x001E1E1E1E1E0000, 0x0039393939390000, 0x002C2C2C2C2C0000,
-0x00A6A6A6A6A60000, 0x0030303030300000, 0x00E5E5E5E5E50000, 0x0044444444440000,
-0x00FDFDFDFDFD0000, 0x0088888888880000, 0x009F9F9F9F9F0000, 0x0065656565650000,
-0x0087878787870000, 0x006B6B6B6B6B0000, 0x00F4F4F4F4F40000, 0x0023232323230000,
-0x0048484848480000, 0x0010101010100000, 0x00D1D1D1D1D10000, 0x0051515151510000,
-0x00C0C0C0C0C00000, 0x00F9F9F9F9F90000, 0x00D2D2D2D2D20000, 0x00A0A0A0A0A00000,
-0x0055555555550000, 0x00A1A1A1A1A10000, 0x0041414141410000, 0x00FAFAFAFAFA0000,
-0x0043434343430000, 0x0013131313130000, 0x00C4C4C4C4C40000, 0x002F2F2F2F2F0000,
-0x00A8A8A8A8A80000, 0x00B6B6B6B6B60000, 0x003C3C3C3C3C0000, 0x002B2B2B2B2B0000,
-0x00C1C1C1C1C10000, 0x00FFFFFFFFFF0000, 0x00C8C8C8C8C80000, 0x00A5A5A5A5A50000,
-0x0020202020200000, 0x0089898989890000, 0x0000000000000000, 0x0090909090900000,
-0x0047474747470000, 0x00EFEFEFEFEF0000, 0x00EAEAEAEAEA0000, 0x00B7B7B7B7B70000,
-0x0015151515150000, 0x0006060606060000, 0x00CDCDCDCDCD0000, 0x00B5B5B5B5B50000,
-0x0012121212120000, 0x007E7E7E7E7E0000, 0x00BBBBBBBBBB0000, 0x0029292929290000,
-0x000F0F0F0F0F0000, 0x00B8B8B8B8B80000, 0x0007070707070000, 0x0004040404040000,
-0x009B9B9B9B9B0000, 0x0094949494940000, 0x0021212121210000, 0x0066666666660000,
-0x00E6E6E6E6E60000, 0x00CECECECECE0000, 0x00EDEDEDEDED0000, 0x00E7E7E7E7E70000,
-0x003B3B3B3B3B0000, 0x00FEFEFEFEFE0000, 0x007F7F7F7F7F0000, 0x00C5C5C5C5C50000,
-0x00A4A4A4A4A40000, 0x0037373737370000, 0x00B1B1B1B1B10000, 0x004C4C4C4C4C0000,
-0x0091919191910000, 0x006E6E6E6E6E0000, 0x008D8D8D8D8D0000, 0x0076767676760000,
-0x0003030303030000, 0x002D2D2D2D2D0000, 0x00DEDEDEDEDE0000, 0x0096969696960000,
-0x0026262626260000, 0x007D7D7D7D7D0000, 0x00C6C6C6C6C60000, 0x005C5C5C5C5C0000,
-0x00D3D3D3D3D30000, 0x00F2F2F2F2F20000, 0x004F4F4F4F4F0000, 0x0019191919190000,
-0x003F3F3F3F3F0000, 0x00DCDCDCDCDC0000, 0x0079797979790000, 0x001D1D1D1D1D0000,
-0x0052525252520000, 0x00EBEBEBEBEB0000, 0x00F3F3F3F3F30000, 0x006D6D6D6D6D0000,
-0x005E5E5E5E5E0000, 0x00FBFBFBFBFB0000, 0x0069696969690000, 0x00B2B2B2B2B20000,
-0x00F0F0F0F0F00000, 0x0031313131310000, 0x000C0C0C0C0C0000, 0x00D4D4D4D4D40000,
-0x00CFCFCFCFCF0000, 0x008C8C8C8C8C0000, 0x00E2E2E2E2E20000, 0x0075757575750000,
-0x00A9A9A9A9A90000, 0x004A4A4A4A4A0000, 0x0057575757570000, 0x0084848484840000,
-0x0011111111110000, 0x0045454545450000, 0x001B1B1B1B1B0000, 0x00F5F5F5F5F50000,
-0x00E4E4E4E4E40000, 0x000E0E0E0E0E0000, 0x0073737373730000, 0x00AAAAAAAAAA0000,
-0x00F1F1F1F1F10000, 0x00DDDDDDDDDD0000, 0x0059595959590000, 0x0014141414140000,
-0x006C6C6C6C6C0000, 0x0092929292920000, 0x0054545454540000, 0x00D0D0D0D0D00000,
-0x0078787878780000, 0x0070707070700000, 0x00E3E3E3E3E30000, 0x0049494949490000,
-0x0080808080800000, 0x0050505050500000, 0x00A7A7A7A7A70000, 0x00F6F6F6F6F60000,
-0x0077777777770000, 0x0093939393930000, 0x0086868686860000, 0x0083838383830000,
-0x002A2A2A2A2A0000, 0x00C7C7C7C7C70000, 0x005B5B5B5B5B0000, 0x00E9E9E9E9E90000,
-0x00EEEEEEEEEE0000, 0x008F8F8F8F8F0000, 0x0001010101010000, 0x003D3D3D3D3D0000 };
-
-const u64bit Camellia_SBOX3[256] = {
-0x3800383800383800, 0x4100414100414100, 0x1600161600161600, 0x7600767600767600,
-0xD900D9D900D9D900, 0x9300939300939300, 0x6000606000606000, 0xF200F2F200F2F200,
-0x7200727200727200, 0xC200C2C200C2C200, 0xAB00ABAB00ABAB00, 0x9A009A9A009A9A00,
-0x7500757500757500, 0x0600060600060600, 0x5700575700575700, 0xA000A0A000A0A000,
-0x9100919100919100, 0xF700F7F700F7F700, 0xB500B5B500B5B500, 0xC900C9C900C9C900,
-0xA200A2A200A2A200, 0x8C008C8C008C8C00, 0xD200D2D200D2D200, 0x9000909000909000,
-0xF600F6F600F6F600, 0x0700070700070700, 0xA700A7A700A7A700, 0x2700272700272700,
-0x8E008E8E008E8E00, 0xB200B2B200B2B200, 0x4900494900494900, 0xDE00DEDE00DEDE00,
-0x4300434300434300, 0x5C005C5C005C5C00, 0xD700D7D700D7D700, 0xC700C7C700C7C700,
-0x3E003E3E003E3E00, 0xF500F5F500F5F500, 0x8F008F8F008F8F00, 0x6700676700676700,
-0x1F001F1F001F1F00, 0x1800181800181800, 0x6E006E6E006E6E00, 0xAF00AFAF00AFAF00,
-0x2F002F2F002F2F00, 0xE200E2E200E2E200, 0x8500858500858500, 0x0D000D0D000D0D00,
-0x5300535300535300, 0xF000F0F000F0F000, 0x9C009C9C009C9C00, 0x6500656500656500,
-0xEA00EAEA00EAEA00, 0xA300A3A300A3A300, 0xAE00AEAE00AEAE00, 0x9E009E9E009E9E00,
-0xEC00ECEC00ECEC00, 0x8000808000808000, 0x2D002D2D002D2D00, 0x6B006B6B006B6B00,
-0xA800A8A800A8A800, 0x2B002B2B002B2B00, 0x3600363600363600, 0xA600A6A600A6A600,
-0xC500C5C500C5C500, 0x8600868600868600, 0x4D004D4D004D4D00, 0x3300333300333300,
-0xFD00FDFD00FDFD00, 0x6600666600666600, 0x5800585800585800, 0x9600969600969600,
-0x3A003A3A003A3A00, 0x0900090900090900, 0x9500959500959500, 0x1000101000101000,
-0x7800787800787800, 0xD800D8D800D8D800, 0x4200424200424200, 0xCC00CCCC00CCCC00,
-0xEF00EFEF00EFEF00, 0x2600262600262600, 0xE500E5E500E5E500, 0x6100616100616100,
-0x1A001A1A001A1A00, 0x3F003F3F003F3F00, 0x3B003B3B003B3B00, 0x8200828200828200,
-0xB600B6B600B6B600, 0xDB00DBDB00DBDB00, 0xD400D4D400D4D400, 0x9800989800989800,
-0xE800E8E800E8E800, 0x8B008B8B008B8B00, 0x0200020200020200, 0xEB00EBEB00EBEB00,
-0x0A000A0A000A0A00, 0x2C002C2C002C2C00, 0x1D001D1D001D1D00, 0xB000B0B000B0B000,
-0x6F006F6F006F6F00, 0x8D008D8D008D8D00, 0x8800888800888800, 0x0E000E0E000E0E00,
-0x1900191900191900, 0x8700878700878700, 0x4E004E4E004E4E00, 0x0B000B0B000B0B00,
-0xA900A9A900A9A900, 0x0C000C0C000C0C00, 0x7900797900797900, 0x1100111100111100,
-0x7F007F7F007F7F00, 0x2200222200222200, 0xE700E7E700E7E700, 0x5900595900595900,
-0xE100E1E100E1E100, 0xDA00DADA00DADA00, 0x3D003D3D003D3D00, 0xC800C8C800C8C800,
-0x1200121200121200, 0x0400040400040400, 0x7400747400747400, 0x5400545400545400,
-0x3000303000303000, 0x7E007E7E007E7E00, 0xB400B4B400B4B400, 0x2800282800282800,
-0x5500555500555500, 0x6800686800686800, 0x5000505000505000, 0xBE00BEBE00BEBE00,
-0xD000D0D000D0D000, 0xC400C4C400C4C400, 0x3100313100313100, 0xCB00CBCB00CBCB00,
-0x2A002A2A002A2A00, 0xAD00ADAD00ADAD00, 0x0F000F0F000F0F00, 0xCA00CACA00CACA00,
-0x7000707000707000, 0xFF00FFFF00FFFF00, 0x3200323200323200, 0x6900696900696900,
-0x0800080800080800, 0x6200626200626200, 0x0000000000000000, 0x2400242400242400,
-0xD100D1D100D1D100, 0xFB00FBFB00FBFB00, 0xBA00BABA00BABA00, 0xED00EDED00EDED00,
-0x4500454500454500, 0x8100818100818100, 0x7300737300737300, 0x6D006D6D006D6D00,
-0x8400848400848400, 0x9F009F9F009F9F00, 0xEE00EEEE00EEEE00, 0x4A004A4A004A4A00,
-0xC300C3C300C3C300, 0x2E002E2E002E2E00, 0xC100C1C100C1C100, 0x0100010100010100,
-0xE600E6E600E6E600, 0x2500252500252500, 0x4800484800484800, 0x9900999900999900,
-0xB900B9B900B9B900, 0xB300B3B300B3B300, 0x7B007B7B007B7B00, 0xF900F9F900F9F900,
-0xCE00CECE00CECE00, 0xBF00BFBF00BFBF00, 0xDF00DFDF00DFDF00, 0x7100717100717100,
-0x2900292900292900, 0xCD00CDCD00CDCD00, 0x6C006C6C006C6C00, 0x1300131300131300,
-0x6400646400646400, 0x9B009B9B009B9B00, 0x6300636300636300, 0x9D009D9D009D9D00,
-0xC000C0C000C0C000, 0x4B004B4B004B4B00, 0xB700B7B700B7B700, 0xA500A5A500A5A500,
-0x8900898900898900, 0x5F005F5F005F5F00, 0xB100B1B100B1B100, 0x1700171700171700,
-0xF400F4F400F4F400, 0xBC00BCBC00BCBC00, 0xD300D3D300D3D300, 0x4600464600464600,
-0xCF00CFCF00CFCF00, 0x3700373700373700, 0x5E005E5E005E5E00, 0x4700474700474700,
-0x9400949400949400, 0xFA00FAFA00FAFA00, 0xFC00FCFC00FCFC00, 0x5B005B5B005B5B00,
-0x9700979700979700, 0xFE00FEFE00FEFE00, 0x5A005A5A005A5A00, 0xAC00ACAC00ACAC00,
-0x3C003C3C003C3C00, 0x4C004C4C004C4C00, 0x0300030300030300, 0x3500353500353500,
-0xF300F3F300F3F300, 0x2300232300232300, 0xB800B8B800B8B800, 0x5D005D5D005D5D00,
-0x6A006A6A006A6A00, 0x9200929200929200, 0xD500D5D500D5D500, 0x2100212100212100,
-0x4400444400444400, 0x5100515100515100, 0xC600C6C600C6C600, 0x7D007D7D007D7D00,
-0x3900393900393900, 0x8300838300838300, 0xDC00DCDC00DCDC00, 0xAA00AAAA00AAAA00,
-0x7C007C7C007C7C00, 0x7700777700777700, 0x5600565600565600, 0x0500050500050500,
-0x1B001B1B001B1B00, 0xA400A4A400A4A400, 0x1500151500151500, 0x3400343400343400,
-0x1E001E1E001E1E00, 0x1C001C1C001C1C00, 0xF800F8F800F8F800, 0x5200525200525200,
-0x2000202000202000, 0x1400141400141400, 0xE900E9E900E9E900, 0xBD00BDBD00BDBD00,
-0xDD00DDDD00DDDD00, 0xE400E4E400E4E400, 0xA100A1A100A1A100, 0xE000E0E000E0E000,
-0x8A008A8A008A8A00, 0xF100F1F100F1F100, 0xD600D6D600D6D600, 0x7A007A7A007A7A00,
-0xBB00BBBB00BBBB00, 0xE300E3E300E3E300, 0x4000404000404000, 0x4F004F4F004F4F00 };
-
-const u64bit Camellia_SBOX4[256] = {
-0x7070007000007070, 0x2C2C002C00002C2C, 0xB3B300B30000B3B3, 0xC0C000C00000C0C0,
-0xE4E400E40000E4E4, 0x5757005700005757, 0xEAEA00EA0000EAEA, 0xAEAE00AE0000AEAE,
-0x2323002300002323, 0x6B6B006B00006B6B, 0x4545004500004545, 0xA5A500A50000A5A5,
-0xEDED00ED0000EDED, 0x4F4F004F00004F4F, 0x1D1D001D00001D1D, 0x9292009200009292,
-0x8686008600008686, 0xAFAF00AF0000AFAF, 0x7C7C007C00007C7C, 0x1F1F001F00001F1F,
-0x3E3E003E00003E3E, 0xDCDC00DC0000DCDC, 0x5E5E005E00005E5E, 0x0B0B000B00000B0B,
-0xA6A600A60000A6A6, 0x3939003900003939, 0xD5D500D50000D5D5, 0x5D5D005D00005D5D,
-0xD9D900D90000D9D9, 0x5A5A005A00005A5A, 0x5151005100005151, 0x6C6C006C00006C6C,
-0x8B8B008B00008B8B, 0x9A9A009A00009A9A, 0xFBFB00FB0000FBFB, 0xB0B000B00000B0B0,
-0x7474007400007474, 0x2B2B002B00002B2B, 0xF0F000F00000F0F0, 0x8484008400008484,
-0xDFDF00DF0000DFDF, 0xCBCB00CB0000CBCB, 0x3434003400003434, 0x7676007600007676,
-0x6D6D006D00006D6D, 0xA9A900A90000A9A9, 0xD1D100D10000D1D1, 0x0404000400000404,
-0x1414001400001414, 0x3A3A003A00003A3A, 0xDEDE00DE0000DEDE, 0x1111001100001111,
-0x3232003200003232, 0x9C9C009C00009C9C, 0x5353005300005353, 0xF2F200F20000F2F2,
-0xFEFE00FE0000FEFE, 0xCFCF00CF0000CFCF, 0xC3C300C30000C3C3, 0x7A7A007A00007A7A,
-0x2424002400002424, 0xE8E800E80000E8E8, 0x6060006000006060, 0x6969006900006969,
-0xAAAA00AA0000AAAA, 0xA0A000A00000A0A0, 0xA1A100A10000A1A1, 0x6262006200006262,
-0x5454005400005454, 0x1E1E001E00001E1E, 0xE0E000E00000E0E0, 0x6464006400006464,
-0x1010001000001010, 0x0000000000000000, 0xA3A300A30000A3A3, 0x7575007500007575,
-0x8A8A008A00008A8A, 0xE6E600E60000E6E6, 0x0909000900000909, 0xDDDD00DD0000DDDD,
-0x8787008700008787, 0x8383008300008383, 0xCDCD00CD0000CDCD, 0x9090009000009090,
-0x7373007300007373, 0xF6F600F60000F6F6, 0x9D9D009D00009D9D, 0xBFBF00BF0000BFBF,
-0x5252005200005252, 0xD8D800D80000D8D8, 0xC8C800C80000C8C8, 0xC6C600C60000C6C6,
-0x8181008100008181, 0x6F6F006F00006F6F, 0x1313001300001313, 0x6363006300006363,
-0xE9E900E90000E9E9, 0xA7A700A70000A7A7, 0x9F9F009F00009F9F, 0xBCBC00BC0000BCBC,
-0x2929002900002929, 0xF9F900F90000F9F9, 0x2F2F002F00002F2F, 0xB4B400B40000B4B4,
-0x7878007800007878, 0x0606000600000606, 0xE7E700E70000E7E7, 0x7171007100007171,
-0xD4D400D40000D4D4, 0xABAB00AB0000ABAB, 0x8888008800008888, 0x8D8D008D00008D8D,
-0x7272007200007272, 0xB9B900B90000B9B9, 0xF8F800F80000F8F8, 0xACAC00AC0000ACAC,
-0x3636003600003636, 0x2A2A002A00002A2A, 0x3C3C003C00003C3C, 0xF1F100F10000F1F1,
-0x4040004000004040, 0xD3D300D30000D3D3, 0xBBBB00BB0000BBBB, 0x4343004300004343,
-0x1515001500001515, 0xADAD00AD0000ADAD, 0x7777007700007777, 0x8080008000008080,
-0x8282008200008282, 0xECEC00EC0000ECEC, 0x2727002700002727, 0xE5E500E50000E5E5,
-0x8585008500008585, 0x3535003500003535, 0x0C0C000C00000C0C, 0x4141004100004141,
-0xEFEF00EF0000EFEF, 0x9393009300009393, 0x1919001900001919, 0x2121002100002121,
-0x0E0E000E00000E0E, 0x4E4E004E00004E4E, 0x6565006500006565, 0xBDBD00BD0000BDBD,
-0xB8B800B80000B8B8, 0x8F8F008F00008F8F, 0xEBEB00EB0000EBEB, 0xCECE00CE0000CECE,
-0x3030003000003030, 0x5F5F005F00005F5F, 0xC5C500C50000C5C5, 0x1A1A001A00001A1A,
-0xE1E100E10000E1E1, 0xCACA00CA0000CACA, 0x4747004700004747, 0x3D3D003D00003D3D,
-0x0101000100000101, 0xD6D600D60000D6D6, 0x5656005600005656, 0x4D4D004D00004D4D,
-0x0D0D000D00000D0D, 0x6666006600006666, 0xCCCC00CC0000CCCC, 0x2D2D002D00002D2D,
-0x1212001200001212, 0x2020002000002020, 0xB1B100B10000B1B1, 0x9999009900009999,
-0x4C4C004C00004C4C, 0xC2C200C20000C2C2, 0x7E7E007E00007E7E, 0x0505000500000505,
-0xB7B700B70000B7B7, 0x3131003100003131, 0x1717001700001717, 0xD7D700D70000D7D7,
-0x5858005800005858, 0x6161006100006161, 0x1B1B001B00001B1B, 0x1C1C001C00001C1C,
-0x0F0F000F00000F0F, 0x1616001600001616, 0x1818001800001818, 0x2222002200002222,
-0x4444004400004444, 0xB2B200B20000B2B2, 0xB5B500B50000B5B5, 0x9191009100009191,
-0x0808000800000808, 0xA8A800A80000A8A8, 0xFCFC00FC0000FCFC, 0x5050005000005050,
-0xD0D000D00000D0D0, 0x7D7D007D00007D7D, 0x8989008900008989, 0x9797009700009797,
-0x5B5B005B00005B5B, 0x9595009500009595, 0xFFFF00FF0000FFFF, 0xD2D200D20000D2D2,
-0xC4C400C40000C4C4, 0x4848004800004848, 0xF7F700F70000F7F7, 0xDBDB00DB0000DBDB,
-0x0303000300000303, 0xDADA00DA0000DADA, 0x3F3F003F00003F3F, 0x9494009400009494,
-0x5C5C005C00005C5C, 0x0202000200000202, 0x4A4A004A00004A4A, 0x3333003300003333,
-0x6767006700006767, 0xF3F300F30000F3F3, 0x7F7F007F00007F7F, 0xE2E200E20000E2E2,
-0x9B9B009B00009B9B, 0x2626002600002626, 0x3737003700003737, 0x3B3B003B00003B3B,
-0x9696009600009696, 0x4B4B004B00004B4B, 0xBEBE00BE0000BEBE, 0x2E2E002E00002E2E,
-0x7979007900007979, 0x8C8C008C00008C8C, 0x6E6E006E00006E6E, 0x8E8E008E00008E8E,
-0xF5F500F50000F5F5, 0xB6B600B60000B6B6, 0xFDFD00FD0000FDFD, 0x5959005900005959,
-0x9898009800009898, 0x6A6A006A00006A6A, 0x4646004600004646, 0xBABA00BA0000BABA,
-0x2525002500002525, 0x4242004200004242, 0xA2A200A20000A2A2, 0xFAFA00FA0000FAFA,
-0x0707000700000707, 0x5555005500005555, 0xEEEE00EE0000EEEE, 0x0A0A000A00000A0A,
-0x4949004900004949, 0x6868006800006868, 0x3838003800003838, 0xA4A400A40000A4A4,
-0x2828002800002828, 0x7B7B007B00007B7B, 0xC9C900C90000C9C9, 0xC1C100C10000C1C1,
-0xE3E300E30000E3E3, 0xF4F400F40000F4F4, 0xC7C700C70000C7...
[truncated message content] |