ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_burl.c

@@ -0,0 +1,228 @@
+/*
+ * <pre>
+ * BFASTURL.c High performance URL encoder/decoder
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2006-2016  Nick Galbreath
+ * All rights reserved.
+ * Released under MIT license. See LICENSE for details.
+ * </PRE>
+ */
+
+#include "modp_stdint.h"
+
+#include "modp_burl.h"
+#include "modp_burl_data.h"
+
+size_t modp_burl_encode(char* dest, const char* src, size_t len)
+{
+
+    const char* deststart = dest;
+    const uint8_t* s = (const uint8_t*)src;
+    const uint8_t* srcend = s + len;
+    char c;
+    uint8_t x;
+
+    if (len == 0) {
+        *dest = '\0';
+        return (size_t)0;
+    }
+
+    while (s < srcend) {
+        x = *s++;
+        c = (char)gsUrlEncodeMap[x];
+        if (c) {
+            *dest++ = c;
+        } else {
+            *dest++ = '%';
+            *dest++ = (char)gsHexEncodeMap1[x];
+            *dest++ = (char)gsHexEncodeMap2[x];
+            /*
+              is the equiv of this
+              static const char sHexChars[] = "0123456789ABCDEF";
+              *dest++ = (char)sHexChars[x >> 4];
+              *dest++ = (char)sHexChars[x & 0x0F];
+              */
+        }
+    }
+    *dest = '\0';
+    return (size_t)(dest - deststart); /* compute "strlen" of dest. */
+}
+
+/**
+ * The implementation is identical except it uses a
+ * different array
+ */
+size_t modp_burl_min_encode(char* dest, const char* src, size_t len)
+{
+
+    const char* deststart = dest;
+    const uint8_t* s = (const uint8_t*)src;
+    const uint8_t* srcend = s + len;
+    char c;
+    uint8_t x;
+
+    if (len == 0) {
+        *dest = '\0';
+        return (size_t)0;
+    }
+
+    while (s < srcend) {
+        x = *s++;
+        c = (char)(gsUrlEncodeMinMap[x]); /** CHANGE HERE **/
+        if (c) {
+            *dest++ = c;
+        } else {
+            *dest++ = '%';
+            *dest++ = (char)gsHexEncodeMap1[x];
+            *dest++ = (char)(gsHexEncodeMap2[x]);
+            /*
+              is the equiv of this
+              static const char sHexChars[] = "0123456789ABCDEF";
+              *dest++ = sHexChars[x >> 4];
+              *dest++ = sHexChars[x & 0x0F];
+              */
+        }
+    }
+    *dest = '\0';
+    return (size_t)(dest - deststart); /* compute "strlen" of dest. */
+}
+
+/**
+ * Give exact size of encoded output string
+ * without doing the encoding
+ */
+size_t modp_burl_encode_strlen(const char* src, const size_t len)
+{
+    size_t count = 0;
+    const char* srcend = src + len;
+
+    if (len == 0) {
+        return (size_t)0;
+    }
+
+    while (src < srcend) {
+        if (gsUrlEncodeMap[(uint8_t)*src++]) {
+            count++;
+        } else {
+            count += 3;
+        }
+    }
+    return count;
+}
+
+/**
+ * Give exact size of encoded output string
+ * without doing the encoding
+ */
+size_t modp_burl_min_encode_strlen(const char* src, const size_t len)
+{
+    size_t count = 0;
+    const char* srcend = src + len;
+
+    if (len == 0) {
+        return (size_t)0;
+    }
+
+    while (src < srcend) {
+        if (gsUrlEncodeMinMap[(uint8_t)*src++]) {
+            count++;
+        } else {
+            count += 3;
+        }
+    }
+    return count;
+}
+
+size_t modp_burl_decode(char* dest, const char* s, size_t len)
+{
+    uint32_t d = 0; /* used for decoding %XX */
+    const uint8_t* src = (const uint8_t*)s;
+    const char* deststart = dest;
+    const uint8_t* srcend = (const uint8_t*)(src + len);
+    const uint8_t* srcendloop = (const uint8_t*)(srcend - 2);
+
+    if (len == 0) {
+        *dest = '\0';
+        return (size_t)0;
+    }
+
+    while (src < srcendloop) {
+        switch (*src) {
+        case '+':
+            *dest++ = ' ';
+            src++;
+            break;
+        case '%':
+            d = (gsHexDecodeMap[(uint32_t)(*(src + 1))] << 4) | gsHexDecodeMap[(uint32_t)(*(src + 2))];
+            if (d < 256) { /* if one of the hex chars is bad,  d >= 256 */
+                *dest = (char)d;
+                dest++;
+                src += 3;
+            } else {
+                *dest++ = '%';
+                src++;
+            }
+            break;
+        default:
+            *dest++ = (char)*src++;
+        }
+    }
+
+    /* handle last two chars
+     * dont decode "%XX"
+     */
+    while (src < srcend) {
+        switch (*src) {
+        case '+':
+            *dest++ = ' ';
+            src++;
+            break;
+        default:
+            *dest++ = (char)(*src++);
+        }
+    }
+
+    *dest = '\0';
+    return (size_t)(dest - deststart); /* compute "strlen" of dest. */
+}
+
+size_t modp_burl_decode_raw(char* dest, const char* s, size_t len)
+{
+    uint32_t d = 0; /* used for decoding %XX */
+    const uint8_t* src = (const uint8_t*)s;
+    const char* deststart = dest;
+    const uint8_t* srcend = (const uint8_t*)(src + len);
+    const uint8_t* srcendloop = (const uint8_t*)(srcend - 2);
+
+    if (len == 0) {
+        *dest = '\0';
+        return (size_t)0;
+    }
+
+    while (src < srcendloop) {
+        if (*src == '%') {
+            d = (gsHexDecodeMap[(uint32_t)(*(src + 1))] << 4) | gsHexDecodeMap[(uint32_t)(*(src + 2))];
+            if (d < 256) { /* if one of the hex chars is bad,  d >= 256 */
+                *dest = (char)d;
+                dest++;
+                src += 3;
+            } else {
+                *dest++ = '%';
+                src++;
+            }
+        } else {
+            *dest++ = (char)*src++;
+        }
+    }
+
+    /* handle last two chars
+     * dont decode "%XX"
+     */
+    while (src < srcend) {
+        *dest++ = (char)(*src++);
+    }
+
+    *dest = '\0';
+    return (size_t)(dest - deststart); /* compute "strlen" of dest. */
+}

data/vendor/stringencoders/src/modp_burl.h

@@ -0,0 +1,259 @@
+/**
+ * \file modp_burl.h
+ * \brief high performance URL encoding and decoding
+ *
+ */
+
+/*
+ * <PRE>
+ * High Performance URL Encoder/Decoder
+ *
+ * Copyright &copy; 2006-2016  Nick Galbreath
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders
+ *
+ * Released under MIT license. See LICENSE for details.
+ * </PRE>
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_BURL
+#define COM_MODP_STRINGENCODERS_BURL
+
+/* size_t declaration */
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+#ifndef MODP_C_BEGIN_DECLS
+#define MODP_C_BEGIN_DECLS extern "C" {
+#define MODP_C_END_DECLS }
+#endif
+#else
+#define MODP_C_BEGIN_DECLS
+#define MODP_C_END_DECLS
+#endif
+
+MODP_C_BEGIN_DECLS
+
+/**
+ * Url encode a string.  This uses a very strict definition of url
+ * encoding.  The only characters NOT encoded are A-Z, a-z, 0-9, "-",
+ * "_", ".", along with the space char getting mapped to "+".
+ * Everything else is escaped using "%HEXHEX" format.  This is
+ * identical to the implementation of php's urlencode and nearly
+ * identical to Java's UrlEncoder class (they do not escape '*' for
+ * some reason).
+ *
+ * \param[out] dest output string.  Must
+ * \param[in] str The input string
+ * \param[in] len  The length of the input string, excluding any
+ *   final null byte.
+ */
+size_t modp_burl_encode(char* dest, const char* str, size_t len);
+
+/**
+ * Url encode a string.  This uses a minimal definition of url
+ * encoding.  This works similar to the previous function except '~',
+ * '!', '$', '\'', '(', ')', '*', ',', ';', ':', '@', '/', '?' are NOT
+ * escaped.  This will allow decoding by standard url-decoders and
+ * make the encoded urls more readable.
+ *
+ * \param[out] dest output string.  Must
+ * \param[in] str The input string
+ * \param[in] len  The length of the input string, excluding any
+ *   final null byte.
+ */
+size_t modp_burl_min_encode(char* dest, const char* str, size_t len);
+
+/** \brief get size of output string w/o doing actual encoding
+ *
+ * \param[in] src input string, not null
+ * \param[in] len length of input string
+ * \return length of output string NOT including any final null byte
+ */
+size_t modp_burl_min_encode_strlen(const char* src, const size_t len);
+
+/**
+ * Provides the maximum size for output string given
+ * and input size of A bytes.
+ */
+#define modp_burl_encode_len(A) (3 * A + 1)
+
+/**
+ * Given the exact size of output string.
+ *
+ * Can be used to allocate the right amount of memory for
+ * modp_burl_encode.  Be sure to add 1 byte for final null.
+ *
+ * This is somewhat expensive since it examines every character
+ *  in the input string
+ *
+ * \param[in] str  The input string
+ * \param[in] len  THe length of the input string, excluding any
+ *   final null byte (i.e. strlen(str))
+ * \return the size of the output string, excluding the final
+ *   null byte.
+ */
+size_t modp_burl_encode_strlen(const char* str, const size_t len);
+
+/**
+ * URL Decode a string
+ *
+ * \param[out] dest  The output string.  Must be at least (len + 1)
+ *  bytes allocated.  This may be the same as the input buffer.
+ * \param[in] str The input string that is URL encoded.
+ * \param[in] len The length of the input string (excluding final
+ *   null byte)
+ * \return the strlen of the output string.
+ */
+size_t modp_burl_decode(char* dest, const char* str, size_t len);
+
+/**
+ * URL Decode a string, '+' is preserved
+ *
+ * \param[out] dest  The output string.  Must be at least (len + 1)
+ *  bytes allocated.  This may be the same as the input buffer.
+ * \param[in] str The input string that is URL encoded.
+ * \param[in] len The length of the input string (excluding final
+ *   null byte)
+ * \return the strlen of the output string.
+ */
+size_t modp_burl_decode_raw(char* dest, const char* str, size_t len);
+
+/**
+ * Returns memory required to decoded a url-encoded
+ * string of length A.
+ *
+ */
+#define modp_burl_decode_len(A) (A + 1)
+
+MODP_C_END_DECLS
+
+#ifdef __cplusplus
+#include <cstring>
+#include <string>
+
+namespace modp {
+
+inline std::string url_encode(const char* s, size_t len)
+{
+    std::string x(modp_burl_encode_len(len), '\0');
+    size_t d = modp_burl_encode(const_cast<char*>(x.data()), s, len);
+    x.erase(d, std::string::npos);
+    return x;
+}
+
+inline std::string url_encode(const char* s)
+{
+    return url_encode(s, strlen(s));
+}
+
+inline std::string url_encode(const std::string& s)
+{
+    return url_encode(s.data(), s.size());
+}
+
+/**
+     * Standard (maximal) url encoding.
+     *
+     * \param[in,out] s the string to be encoded
+     * \return a reference to the input string
+     */
+inline std::string& url_encode(std::string& s)
+{
+    std::string x(url_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+/**
+     * Minimal Url Encoding
+     *
+     * \param[in,out] s the string to be encoded
+     * \return a reference to the input string
+     */
+inline std::string& url_min_encode(std::string& s)
+{
+    std::string x(modp_burl_encode_len(s.size()), '\0');
+    size_t d = modp_burl_min_encode(const_cast<char*>(x.data()), s.data(), s.size());
+    x.erase(d, std::string::npos);
+    s.swap(x);
+    return s;
+}
+
+inline std::string url_min_encode(const std::string& s)
+{
+    std::string x(modp_burl_encode_len(s.size()), '\0');
+    size_t d = modp_burl_min_encode(const_cast<char*>(x.data()), s.data(), s.size());
+    x.erase(d, std::string::npos);
+    return x;
+}
+
+/**
+     * Url decode a string.
+     * This function does not allocate memory.
+     *
+     * \param[in,out] s the string to be decoded
+     * \return a reference to the input string.
+     *      There is no error case, bad characters are passed through
+     */
+inline std::string& url_decode(std::string& s)
+{
+    size_t d = modp_burl_decode(const_cast<char*>(s.data()), s.data(), s.size());
+    s.erase(d, std::string::npos);
+    return s;
+}
+
+inline std::string& url_decode_raw(std::string& s)
+{
+    size_t d = modp_burl_decode_raw(const_cast<char*>(s.data()), s.data(), s.size());
+    s.erase(d, std::string::npos);
+    return s;
+}
+
+inline std::string url_decode(const char* str)
+{
+    std::string s(str);
+    url_decode(s);
+    return s;
+}
+
+inline std::string url_decode_raw(const char* str)
+{
+    std::string s(str);
+    url_decode_raw(s);
+    return s;
+}
+
+inline std::string url_decode(const char* str, size_t len)
+{
+    std::string s(str, len);
+    url_decode(s);
+    return s;
+}
+
+inline std::string url_decode_raw(const char* str, size_t len)
+{
+    std::string s(str, len);
+    url_decode_raw(s);
+    return s;
+}
+
+inline std::string url_decode(const std::string& s)
+{
+    std::string x(s);
+    url_decode(x);
+    return x;
+}
+
+inline std::string url_decode_raw(const std::string& s)
+{
+    std::string x(s);
+    url_decode_raw(x);
+    return x;
+}
+}
+#endif
+
+#endif

data/vendor/stringencoders/src/modp_burl_data.h

@@ -0,0 +1,136 @@
+static const uint8_t gsUrlEncodeMap[256] = {
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '+', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '-', '.', '\0', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', 'A', 'B', 'C', 'D', 'E',
+    'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+    'Z', '\0', '\0', '\0', '\0', '_', '\0', 'a', 'b', 'c',
+    'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+    'x', 'y', 'z', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0'
+};
+static const uint8_t gsUrlEncodeMinMap[256] = {
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '+', '!', '\0', '\0', '$', '\0', '\0', '\0',
+    '(', ')', '*', '\0', ',', '-', '.', '/', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
+    '\0', '\0', '\0', '?', '@', 'A', 'B', 'C', 'D', 'E',
+    'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+    'Z', '\0', '\0', '\0', '\0', '_', '\0', 'a', 'b', 'c',
+    'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+    'x', 'y', 'z', '\0', '\0', '\0', '~', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0'
+};
+static const uint32_t gsHexDecodeMap[256] = {
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 256, 256,
+    256, 256, 256, 256, 256, 10, 11, 12, 13, 14, 15, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 10, 11, 12, 13, 14, 15, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256
+};
+static const uint8_t gsHexEncodeMap1[256] = {
+    '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
+    '0', '0', '0', '0', '0', '0', '1', '1', '1', '1',
+    '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
+    '1', '1', '2', '2', '2', '2', '2', '2', '2', '2',
+    '2', '2', '2', '2', '2', '2', '2', '2', '3', '3',
+    '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
+    '3', '3', '3', '3', '4', '4', '4', '4', '4', '4',
+    '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
+    '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
+    '5', '5', '5', '5', '5', '5', '6', '6', '6', '6',
+    '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
+    '6', '6', '7', '7', '7', '7', '7', '7', '7', '7',
+    '7', '7', '7', '7', '7', '7', '7', '7', '8', '8',
+    '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
+    '8', '8', '8', '8', '9', '9', '9', '9', '9', '9',
+    '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B',
+    'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B',
+    'B', 'B', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C',
+    'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'D', 'D',
+    'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D',
+    'D', 'D', 'D', 'D', 'E', 'E', 'E', 'E', 'E', 'E',
+    'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E',
+    'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F',
+    'F', 'F', 'F', 'F', 'F', 'F'
+};
+static const uint8_t gsHexEncodeMap2[256] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F'
+};