Merged v4.0.0-beta

src/backend/backend.cmake

@@ -1,13 +1,16 @@
 include (src/backend/cpu/cpu.cmake)
+include (src/backend/opencl/opencl.cmake)
 include (src/backend/common/common.cmake)
 
 
 set(HEADERS_BACKEND
     "${HEADERS_BACKEND_COMMON}"
     "${HEADERS_BACKEND_CPU}"
+    "${HEADERS_BACKEND_OPENCL}"
    )
 
 set(SOURCES_BACKEND
     "${SOURCES_BACKEND_COMMON}"
     "${SOURCES_BACKEND_CPU}"
+    "${SOURCES_BACKEND_OPENCL}"
    )

src/backend/common/Tags.h

@@ -0,0 +1,44 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_TAGS_H
+#define XMRIG_TAGS_H
+
+
+namespace xmrig {
+
+
+const char *cpu_tag();
+
+
+#ifdef XMRIG_FEATURE_OPENCL
+const char *ocl_tag();
+#endif
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_TAGS_H */

src/backend/common/Thread.h

@@ -42,18 +42,18 @@ template<class T>
 class Thread
 {
 public:
-    inline Thread(IBackend *backend, size_t index, const T &config) : m_index(index), m_config(config), m_backend(backend) {}
+    inline Thread(IBackend *backend, size_t id, const T &config) : m_id(id), m_config(config), m_backend(backend) {}
     inline ~Thread() { m_thread.join(); delete m_worker; }
 
     inline const T &config() const                  { return m_config; }
     inline IBackend *backend() const                { return m_backend; }
     inline IWorker *worker() const                  { return m_worker; }
-    inline size_t index() const                     { return m_index; }
+    inline size_t id() const                        { return m_id; }
     inline void setWorker(IWorker *worker)          { m_worker = worker; }
     inline void start(void (*callback) (void *))    { m_thread = std::thread(callback, this); }
 
 private:
-    const size_t m_index    = 0;
+    const size_t m_id    = 0;
     const T m_config;
     IBackend *m_backend;
     IWorker *m_worker       = nullptr;

src/backend/common/Threads.cpp

@@ -25,13 +25,20 @@
 
 #include "backend/common/Threads.h"
 #include "backend/cpu/CpuThreads.h"
+#include "crypto/cn/CnAlgo.h"
 #include "rapidjson/document.h"
 
 
+#ifdef XMRIG_FEATURE_OPENCL
+#   include "backend/opencl/OclThreads.h"
+#endif
+
+
 namespace xmrig {
 
 
 static const char *kAsterisk = "*";
+static const char *kCn2      = "cn/2";
 
 
 } // namespace xmrig
@@ -113,6 +120,10 @@ xmrig::String xmrig::Threads<T>::profileName(const Algorithm &algorithm, bool st
         return String();
     }
 
+    if (algorithm.family() == Algorithm::CN && CnAlgo<>::base(algorithm) == Algorithm::CN_2 && has(kCn2)) {
+        return kCn2;
+    }
+
     if (name.contains("/")) {
         const String base = name.split('/').at(0);
         if (has(base)) {
@@ -152,4 +163,8 @@ namespace xmrig {
 
 template class Threads<CpuThreads>;
 
+#ifdef XMRIG_FEATURE_OPENCL
+template class Threads<OclThreads>;
+#endif
+
 } // namespace xmrig

src/backend/common/Threads.h

@@ -47,7 +47,13 @@ public:
     inline bool isExist(const Algorithm &algo) const                                   { return isDisabled(algo) || m_aliases.count(algo) > 0 || has(algo.shortName()); }
     inline const T &get(const Algorithm &algo, bool strict = false) const              { return get(profileName(algo, strict)); }
     inline void disable(const Algorithm &algo)                                         { m_disabled.insert(algo); }
-    inline void move(const char *profile, T &&threads)                                 { m_profiles.insert({ profile, threads }); }
+
+    inline void move(const char *profile, T &&threads)
+    {
+        if (!threads.isEmpty()) {
+            m_profiles.insert({ profile, std::move(threads) });
+        }
+    }
 
     const T &get(const String &profileName) const;
     size_t read(const rapidjson::Value &value);

src/backend/common/Worker.h

@@ -28,7 +28,7 @@
 
 
 #include <atomic>
-#include <stdint.h>
+#include <cstdint>
 
 
 #include "backend/common/interfaces/IWorker.h"

src/backend/common/WorkerJob.h

@@ -64,18 +64,18 @@ public:
     }
 
 
-    inline void nextRound(uint32_t reserveCount)
+    inline void nextRound(uint32_t rounds, uint32_t roundSize)
     {
         m_rounds[index()]++;
 
-        if ((m_rounds[index()] % reserveCount) == 0) {
+        if ((m_rounds[index()] % rounds) == 0) {
             for (size_t i = 0; i < N; ++i) {
-                *nonce(i) = Nonce::next(index(), *nonce(i), reserveCount, currentJob().isNicehash());
+                *nonce(i) = Nonce::next(index(), *nonce(i), rounds * roundSize, currentJob().isNicehash());
             }
         }
         else {
             for (size_t i = 0; i < N; ++i) {
-                *nonce(i) += 1;
+                *nonce(i) += roundSize;
             }
         }
     }
@@ -112,15 +112,15 @@ inline uint32_t *xmrig::WorkerJob<1>::nonce(size_t)
 
 
 template<>
-inline void xmrig::WorkerJob<1>::nextRound(uint32_t reserveCount)
+inline void xmrig::WorkerJob<1>::nextRound(uint32_t rounds, uint32_t roundSize)
 {
     m_rounds[index()]++;
 
-    if ((m_rounds[index()] % reserveCount) == 0) {
-        *nonce() = Nonce::next(index(), *nonce(), reserveCount, currentJob().isNicehash());
+    if ((m_rounds[index()] % rounds) == 0) {
+        *nonce() = Nonce::next(index(), *nonce(), rounds * roundSize, currentJob().isNicehash());
     }
     else {
-        *nonce() += 1;
+        *nonce() += roundSize;
     }
 }
 

src/backend/common/Workers.cpp

@@ -31,6 +31,11 @@
 #include "base/io/log/Log.h"
 
 
+#ifdef XMRIG_FEATURE_OPENCL
+#   include "backend/opencl/OclWorker.h"
+#endif
+
+
 namespace xmrig {
 
 
@@ -129,7 +134,7 @@ void xmrig::Workers<T>::tick(uint64_t)
             return;
         }
 
-        d_ptr->hashrate->add(handle->index(), handle->worker()->hashCount(), handle->worker()->timestamp());
+        d_ptr->hashrate->add(handle->id(), handle->worker()->hashCount(), handle->worker()->timestamp());
     }
 
     d_ptr->hashrate->updateHighest();
@@ -137,7 +142,7 @@ void xmrig::Workers<T>::tick(uint64_t)
 
 
 template<class T>
-xmrig::IWorker *xmrig::Workers<T>::create(Thread<CpuLaunchData> *)
+xmrig::IWorker *xmrig::Workers<T>::create(Thread<T> *)
 {
     return nullptr;
 }
@@ -146,15 +151,18 @@ xmrig::IWorker *xmrig::Workers<T>::create(Thread<CpuLaunchData> *)
 template<class T>
 void xmrig::Workers<T>::onReady(void *arg)
 {
-    Thread<T> *handle = static_cast<Thread<T>* >(arg);
+    auto handle = static_cast<Thread<T>* >(arg);
 
     IWorker *worker = create(handle);
     if (!worker || !worker->selfTest()) {
         LOG_ERR("thread %zu error: \"hash self-test failed\".", worker->id());
 
+        delete worker;
         return;
     }
 
+    assert(handle->backend() != nullptr);
+
     handle->setWorker(worker);
     handle->backend()->start(worker);
 }
@@ -168,19 +176,19 @@ xmrig::IWorker *xmrig::Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *han
 {
     switch (handle->config().intensity) {
     case 1:
-        return new CpuWorker<1>(handle->index(), handle->config());
+        return new CpuWorker<1>(handle->id(), handle->config());
 
     case 2:
-        return new CpuWorker<2>(handle->index(), handle->config());
+        return new CpuWorker<2>(handle->id(), handle->config());
 
     case 3:
-        return new CpuWorker<3>(handle->index(), handle->config());
+        return new CpuWorker<3>(handle->id(), handle->config());
 
     case 4:
-        return new CpuWorker<4>(handle->index(), handle->config());
+        return new CpuWorker<4>(handle->id(), handle->config());
 
     case 5:
-        return new CpuWorker<5>(handle->index(), handle->config());
+        return new CpuWorker<5>(handle->id(), handle->config());
     }
 
     return nullptr;
@@ -190,4 +198,16 @@ xmrig::IWorker *xmrig::Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *han
 template class Workers<CpuLaunchData>;
 
 
+#ifdef XMRIG_FEATURE_OPENCL
+template<>
+xmrig::IWorker *xmrig::Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle)
+{
+    return new OclWorker(handle->id(), handle->config());
+}
+
+
+template class Workers<OclLaunchData>;
+#endif
+
+
 } // namespace xmrig

src/backend/common/Workers.h

@@ -31,6 +31,11 @@
 #include "backend/cpu/CpuLaunchData.h"
 
 
+#ifdef XMRIG_FEATURE_OPENCL
+#   include "backend/opencl/OclLaunchData.h"
+#endif
+
+
 namespace xmrig {
 
 
@@ -52,7 +57,7 @@ public:
     void tick(uint64_t ticks);
 
 private:
-    static IWorker *create(Thread<CpuLaunchData> *handle);
+    static IWorker *create(Thread<T> *handle);
     static void onReady(void *arg);
 
     std::vector<Thread<T> *> m_workers;
@@ -62,11 +67,16 @@ private:
 
 template<>
 IWorker *Workers<CpuLaunchData>::create(Thread<CpuLaunchData> *handle);
-
-
 extern template class Workers<CpuLaunchData>;
 
 
+#ifdef XMRIG_FEATURE_OPENCL
+template<>
+IWorker *Workers<OclLaunchData>::create(Thread<OclLaunchData> *handle);
+extern template class Workers<OclLaunchData>;
+#endif
+
+
 } // namespace xmrig
 
 

src/backend/common/common.cmake

@@ -1,13 +1,16 @@
 set(HEADERS_BACKEND_COMMON
+    src/backend/common/Hashrate.h
+    src/backend/common/Tags.h
     src/backend/common/interfaces/IBackend.h
+    src/backend/common/interfaces/IRxListener.h
     src/backend/common/interfaces/IThread.h
     src/backend/common/interfaces/IWorker.h
-    src/backend/common/Hashrate.h
+    src/backend/common/misc/PciTopology.h
     src/backend/common/Thread.h
     src/backend/common/Threads.h
     src/backend/common/Worker.h
-    src/backend/common/Workers.h
     src/backend/common/WorkerJob.h
+    src/backend/common/Workers.h
    )
 
 set(SOURCES_BACKEND_COMMON

src/backend/common/interfaces/IBackend.h

@@ -37,6 +37,7 @@ namespace xmrig {
 
 class Algorithm;
 class Hashrate;
+class IApiRequest;
 class IWorker;
 class Job;
 class String;
@@ -61,6 +62,7 @@ public:
 
 #   ifdef XMRIG_FEATURE_API
     virtual rapidjson::Value toJSON(rapidjson::Document &doc) const     = 0;
+    virtual void handleRequest(IApiRequest &request)                    = 0;
 #   endif
 };
 

src/backend/common/interfaces/IRxListener.h

@@ -0,0 +1,44 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2016-2018 XMRig       <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_IRXLISTENER_H
+#define XMRIG_IRXLISTENER_H
+
+
+namespace xmrig {
+
+
+class IRxListener
+{
+public:
+    virtual ~IRxListener() = default;
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    virtual void onDatasetReady() = 0;
+#   endif
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_IRXLISTENER_H

src/backend/common/misc/PciTopology.h

@@ -0,0 +1,62 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_PCITOPOLOGY_H
+#define XMRIG_PCITOPOLOGY_H
+
+
+#include <stdio.h>
+
+
+#include "base/tools/String.h"
+
+
+namespace xmrig {
+
+
+class PciTopology
+{
+public:
+    PciTopology() = default;
+    PciTopology(uint32_t bus, uint32_t device, uint32_t function) : bus(bus), device(device), function(function) {}
+
+    uint32_t bus        = 0;
+    uint32_t device     = 0;
+    uint32_t function   = 0;
+
+    String toString() const
+    {
+        char *buf = new char[8]();
+        snprintf(buf, 8, "%02x:%02x.%01x", bus, device, function);
+
+        return buf;
+    }
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_PCITOPOLOGY_H */

src/backend/cpu/CpuBackend.cpp

@@ -28,6 +28,7 @@
 
 #include "backend/common/Hashrate.h"
 #include "backend/common/interfaces/IWorker.h"
+#include "backend/common/Tags.h"
 #include "backend/common/Workers.h"
 #include "backend/cpu/Cpu.h"
 #include "backend/cpu/CpuBackend.h"
@@ -43,6 +44,11 @@
 #include "rapidjson/document.h"
 
 
+#ifdef XMRIG_FEATURE_API
+#   include "base/api/interfaces/IApiRequest.h"
+#endif
+
+
 #ifdef XMRIG_ALGO_ARGON2
 #   include "crypto/argon2/Impl.h"
 #endif
@@ -56,29 +62,63 @@ extern template class Threads<CpuThreads>;
 
 static const char *tag      = CYAN_BG_BOLD(" cpu ");
 static const String kType   = "cpu";
+static std::mutex mutex;
 
 
-struct LaunchStatus
+struct CpuLaunchStatus
 {
 public:
-    inline void reset()
+    inline size_t hugePages() const     { return m_hugePages; }
+    inline size_t memory() const        { return m_ways * m_memory; }
+    inline size_t pages() const         { return m_pages; }
+    inline size_t threads() const       { return m_threads; }
+    inline size_t ways() const          { return m_ways; }
+
+    inline void start(const std::vector<CpuLaunchData> &threads, size_t memory)
     {
-        hugePages = 0;
-        memory    = 0;
-        pages     = 0;
-        started   = 0;
-        threads   = 0;
-        ways      = 0;
-        ts        = Chrono::steadyMSecs();
+        m_hugePages = 0;
+        m_memory    = memory;
+        m_pages     = 0;
+        m_started   = 0;
+        m_threads   = threads.size();
+        m_ways      = 0;
+        m_ts        = Chrono::steadyMSecs();
+
+        for (const CpuLaunchData &data : threads) {
+            m_ways += data.intensity;
+        }
     }
 
-    size_t hugePages    = 0;
-    size_t memory       = 0;
-    size_t pages        = 0;
-    size_t started      = 0;
-    size_t threads      = 0;
-    size_t ways         = 0;
-    uint64_t ts         = 0;
+    inline bool started(const std::pair<size_t, size_t> &hugePages)
+    {
+        m_started++;
+        m_hugePages += hugePages.first;
+        m_pages     += hugePages.second;
+
+        return m_started == m_threads;
+    }
+
+    inline void print() const
+    {
+        LOG_INFO("%s" GREEN_BOLD(" READY") " threads " CYAN_BOLD("%zu(%zu)") " huge pages %s%zu/%zu %1.0f%%\x1B[0m memory " CYAN_BOLD("%zu KB") BLACK_BOLD(" (%" PRIu64 " ms)"),
+                 tag,
+                 m_threads, m_ways,
+                 (m_hugePages == m_pages ? GREEN_BOLD_S : (m_hugePages == 0 ? RED_BOLD_S : YELLOW_BOLD_S)),
+                 m_hugePages, m_pages,
+                 m_hugePages == 0 ? 0.0 : static_cast<double>(m_hugePages) / m_pages * 100.0,
+                 m_ways * m_memory / 1024,
+                 Chrono::steadyMSecs() - m_ts
+                 );
+    }
+
+private:
+    size_t m_hugePages    = 0;
+    size_t m_memory       = 0;
+    size_t m_pages        = 0;
+    size_t m_started      = 0;
+    size_t m_threads      = 0;
+    size_t m_ways         = 0;
+    uint64_t m_ts         = 0;
 };
 
 
@@ -100,16 +140,7 @@ public:
                  algo.l3() / 1024
                  );
 
-        workers.stop();
-
-        status.reset();
-        status.memory   = algo.l3();
-        status.threads  = threads.size();
-
-        for (const CpuLaunchData &data : threads) {
-            status.ways += static_cast<size_t>(data.intensity);
-        }
-
+        status.start(threads, algo.l3());
         workers.start(threads);
     }
 
@@ -118,14 +149,45 @@ public:
     {
         std::lock_guard<std::mutex> lock(mutex);
 
-        return status.ways;
+        return status.ways();
+    }
+
+
+    rapidjson::Value hugePages(int version, rapidjson::Document &doc)
+    {
+        std::pair<unsigned, unsigned> pages(0, 0);
+
+    #   ifdef XMRIG_ALGO_RANDOMX
+        if (algo.family() == Algorithm::RANDOM_X) {
+            pages = Rx::hugePages();
+        }
+    #   endif
+
+        mutex.lock();
+
+        pages.first  += status.hugePages();
+        pages.second += status.pages();
+
+        mutex.unlock();
+
+        rapidjson::Value hugepages;
+
+        if (version > 1) {
+            hugepages.SetArray();
+            hugepages.PushBack(pages.first, doc.GetAllocator());
+            hugepages.PushBack(pages.second, doc.GetAllocator());
+        }
+        else {
+            hugepages = pages.first == pages.second;
+        }
+
+        return hugepages;
     }
 
 
     Algorithm algo;
     Controller *controller;
-    LaunchStatus status;
-    std::mutex mutex;
+    CpuLaunchStatus status;
     std::vector<CpuLaunchData> threads;
     String profileName;
     Workers<CpuLaunchData> workers;
@@ -135,6 +197,12 @@ public:
 } // namespace xmrig
 
 
+const char *xmrig::cpu_tag()
+{
+    return tag;
+}
+
+
 xmrig::CpuBackend::CpuBackend(Controller *controller) :
     d_ptr(new CpuBackendPrivate(controller))
 {
@@ -148,25 +216,6 @@ xmrig::CpuBackend::~CpuBackend()
 }
 
 
-std::pair<unsigned, unsigned> xmrig::CpuBackend::hugePages() const
-{
-    std::pair<unsigned, unsigned> pages(0, 0);
-
-#   ifdef XMRIG_ALGO_RANDOMX
-    if (d_ptr->algo.family() == Algorithm::RANDOM_X) {
-        pages = Rx::hugePages();
-    }
-#   endif
-
-    std::lock_guard<std::mutex> lock(d_ptr->mutex);
-
-    pages.first  += d_ptr->status.hugePages;
-    pages.second += d_ptr->status.pages;
-
-    return pages;
-}
-
-
 bool xmrig::CpuBackend::isEnabled() const
 {
     return d_ptr->controller->config()->cpu().isEnabled();
@@ -219,11 +268,11 @@ void xmrig::CpuBackend::printHashrate(bool details)
 
     char num[8 * 3] = { 0 };
 
-    Log::print(WHITE_BOLD_S "|    CPU THREAD | AFFINITY | 10s H/s | 60s H/s | 15m H/s |");
+    Log::print(WHITE_BOLD_S "|    CPU # | AFFINITY | 10s H/s | 60s H/s | 15m H/s |");
 
     size_t i = 0;
     for (const CpuLaunchData &data : d_ptr->threads) {
-         Log::print("| %13zu | %8" PRId64 " | %7s | %7s | %7s |",
+         Log::print("| %8zu | %8" PRId64 " | %7s | %7s | %7s |",
                     i,
                     data.affinity,
                     Hashrate::format(hashrate()->calc(i, Hashrate::ShortInterval),  num,         sizeof num / 3),
@@ -233,6 +282,14 @@ void xmrig::CpuBackend::printHashrate(bool details)
 
          i++;
     }
+
+#   ifdef XMRIG_FEATURE_OPENCL
+    Log::print(WHITE_BOLD_S "|        - |        - | %7s | %7s | %7s |",
+               Hashrate::format(hashrate()->calc(Hashrate::ShortInterval),  num,         sizeof num / 3),
+               Hashrate::format(hashrate()->calc(Hashrate::MediumInterval), num + 8,     sizeof num / 3),
+               Hashrate::format(hashrate()->calc(Hashrate::LargeInterval),  num + 8 * 2, sizeof num / 3)
+               );
+#   endif
 }
 
 
@@ -245,7 +302,7 @@ void xmrig::CpuBackend::setJob(const Job &job)
     const CpuConfig &cpu = d_ptr->controller->config()->cpu();
 
     std::vector<CpuLaunchData> threads = cpu.get(d_ptr->controller->miner(), job.algorithm());
-    if (d_ptr->threads.size() == threads.size() && std::equal(d_ptr->threads.begin(), d_ptr->threads.end(), threads.begin())) {
+    if (!d_ptr->threads.empty() && d_ptr->threads.size() == threads.size() && std::equal(d_ptr->threads.begin(), d_ptr->threads.end(), threads.begin())) {
         return;
     }
 
@@ -253,13 +310,13 @@ void xmrig::CpuBackend::setJob(const Job &job)
     d_ptr->profileName  = cpu.threads().profileName(job.algorithm());
 
     if (d_ptr->profileName.isNull() || threads.empty()) {
-        d_ptr->workers.stop();
+        LOG_WARN("%s " RED_BOLD("disabled") YELLOW(" (no suitable configuration found)"), tag);
 
-        LOG_WARN(YELLOW_BOLD_S "CPU disabled, no suitable configuration for algo %s", job.algorithm().shortName());
-
-        return;
+        return stop();
     }
 
+    stop();
+
     d_ptr->threads = std::move(threads);
     d_ptr->start();
 }
@@ -267,28 +324,13 @@ void xmrig::CpuBackend::setJob(const Job &job)
 
 void xmrig::CpuBackend::start(IWorker *worker)
 {
-    d_ptr->mutex.lock();
+    mutex.lock();
 
-    const auto pages = worker->memory()->hugePages();
-
-    d_ptr->status.started++;
-    d_ptr->status.hugePages += pages.first;
-    d_ptr->status.pages     += pages.second;
-
-    if (d_ptr->status.started == d_ptr->status.threads) {
-        const double percent = d_ptr->status.hugePages == 0 ? 0.0 : static_cast<double>(d_ptr->status.hugePages) / d_ptr->status.pages * 100.0;
-        const size_t memory  = d_ptr->status.ways * d_ptr->status.memory / 1024;
-
-        LOG_INFO("%s" GREEN_BOLD(" READY") " threads " CYAN_BOLD("%zu(%zu)") " huge pages %s%zu/%zu %1.0f%%\x1B[0m memory " CYAN_BOLD("%zu KB") BLACK_BOLD(" (%" PRIu64 " ms)"),
-                 tag,
-                 d_ptr->status.threads, d_ptr->status.ways,
-                 (d_ptr->status.hugePages == d_ptr->status.pages ? GREEN_BOLD_S : (d_ptr->status.hugePages == 0 ? RED_BOLD_S : YELLOW_BOLD_S)),
-                 d_ptr->status.hugePages, d_ptr->status.pages, percent, memory,
-                 Chrono::steadyMSecs() - d_ptr->status.ts
-                 );
+    if (d_ptr->status.started(worker->memory()->hugePages())) {
+        d_ptr->status.print();
     }
 
-    d_ptr->mutex.unlock();
+    mutex.unlock();
 
     worker->start();
 }
@@ -296,6 +338,10 @@ void xmrig::CpuBackend::start(IWorker *worker)
 
 void xmrig::CpuBackend::stop()
 {
+    if (d_ptr->threads.empty()) {
+        return;
+    }
+
     const uint64_t ts = Chrono::steadyMSecs();
 
     d_ptr->workers.stop();
@@ -337,13 +383,7 @@ rapidjson::Value xmrig::CpuBackend::toJSON(rapidjson::Document &doc) const
     out.AddMember("argon2-impl", argon2::Impl::name().toJSON(), allocator);
 #   endif
 
-    const auto pages = hugePages();
-
-    rapidjson::Value hugepages(rapidjson::kArrayType);
-    hugepages.PushBack(pages.first, allocator);
-    hugepages.PushBack(pages.second, allocator);
-
-    out.AddMember("hugepages", hugepages, allocator);
+    out.AddMember("hugepages", d_ptr->hugePages(2, doc), allocator);
     out.AddMember("memory",    static_cast<uint64_t>(d_ptr->algo.isValid() ? (d_ptr->ways() * d_ptr->algo.l3()) : 0), allocator);
 
     if (d_ptr->threads.empty() || !hashrate()) {
@@ -375,4 +415,12 @@ rapidjson::Value xmrig::CpuBackend::toJSON(rapidjson::Document &doc) const
 
     return out;
 }
+
+
+void xmrig::CpuBackend::handleRequest(IApiRequest &request)
+{
+    if (request.type() == IApiRequest::REQ_SUMMARY) {
+        request.reply().AddMember("hugepages", d_ptr->hugePages(request.version(), request.doc()), request.doc().GetAllocator());
+    }
+}
 #endif

src/backend/cpu/CpuBackend.h

@@ -46,8 +46,6 @@ public:
     CpuBackend(Controller *controller);
     ~CpuBackend() override;
 
-    std::pair<unsigned, unsigned> hugePages() const;
-
 protected:
     bool isEnabled() const override;
     bool isEnabled(const Algorithm &algorithm) const override;
@@ -63,6 +61,7 @@ protected:
 
 #   ifdef XMRIG_FEATURE_API
     rapidjson::Value toJSON(rapidjson::Document &doc) const override;
+    void handleRequest(IApiRequest &request) override;
 #   endif
 
 private:

src/backend/cpu/CpuConfig.cpp

@@ -122,7 +122,7 @@ std::vector<xmrig::CpuLaunchData> xmrig::CpuConfig::get(const Miner *miner, cons
     out.reserve(threads.count());
 
     for (const CpuThread &thread : threads.data()) {
-        out.push_back(CpuLaunchData(miner, algorithm, *this, thread));
+        out.emplace_back(miner, algorithm, *this, thread);
     }
 
     return out;

src/backend/cpu/CpuThread.h

@@ -35,7 +35,7 @@ namespace xmrig {
 class CpuThread
 {
 public:
-    inline constexpr CpuThread() {}
+    inline constexpr CpuThread() = default;
     inline constexpr CpuThread(int64_t affinity, uint32_t intensity) : m_affinity(affinity), m_intensity(intensity) {}
 
     CpuThread(const rapidjson::Value &value);

src/backend/cpu/CpuWorker.cpp

@@ -24,7 +24,7 @@
  */
 
 
-#include <assert.h>
+#include <cassert>
 #include <thread>
 
 
@@ -47,15 +47,15 @@
 
 namespace xmrig {
 
-static constexpr uint32_t kReserveCount = 4096;
+static constexpr uint32_t kReserveCount = 32768;
 
 } // namespace xmrig
 
 
 
 template<size_t N>
-xmrig::CpuWorker<N>::CpuWorker(size_t index, const CpuLaunchData &data) :
-    Worker(index, data.affinity, data.priority),
+xmrig::CpuWorker<N>::CpuWorker(size_t id, const CpuLaunchData &data) :
+    Worker(id, data.affinity, data.priority),
     m_algorithm(data.algorithm),
     m_assembly(data.assembly),
     m_hwAES(data.hwAES),
@@ -121,7 +121,6 @@ bool xmrig::CpuWorker<N>::selfTest()
                         verify(Algorithm::CN_XAO,    test_output_xao)  &&
                         verify(Algorithm::CN_RTO,    test_output_rto)  &&
                         verify(Algorithm::CN_HALF,   test_output_half) &&
-                        verify2(Algorithm::CN_WOW,   test_output_wow)  &&
                         verify2(Algorithm::CN_R,     test_output_r)    &&
                         verify(Algorithm::CN_RWZ,    test_output_rwz)  &&
                         verify(Algorithm::CN_ZLS,    test_output_zls)  &&
@@ -214,11 +213,11 @@ void xmrig::CpuWorker<N>::start()
 
             for (size_t i = 0; i < N; ++i) {
                 if (*reinterpret_cast<uint64_t*>(m_hash + (i * 32) + 24) < job.target()) {
-                    JobResults::submit(JobResult(job, *m_job.nonce(i), m_hash + (i * 32)));
+                    JobResults::submit(job, *m_job.nonce(i), m_hash + (i * 32));
                 }
             }
 
-            m_job.nextRound(kReserveCount);
+            m_job.nextRound(kReserveCount, 1);
             m_count += N;
 
             std::this_thread::yield();
@@ -305,6 +304,10 @@ void xmrig::CpuWorker<N>::allocateCnCtx()
 template<size_t N>
 void xmrig::CpuWorker<N>::consumeJob()
 {
+    if (Nonce::sequence(Nonce::CPU) == 0) {
+        return;
+    }
+
     m_job.add(m_miner->job(), Nonce::sequence(Nonce::CPU), kReserveCount);
 
 #   ifdef XMRIG_ALGO_RANDOMX

src/backend/cpu/CpuWorker.h

@@ -30,7 +30,7 @@
 #include "backend/common/Worker.h"
 #include "backend/common/WorkerJob.h"
 #include "backend/cpu/CpuLaunchData.h"
-#include "base/net/stratum/Job.h"
+#include "base/tools/Object.h"
 #include "net/JobResult.h"
 
 
@@ -44,7 +44,9 @@ template<size_t N>
 class CpuWorker : public Worker
 {
 public:
-    CpuWorker(size_t index, const CpuLaunchData &data);
+    XMRIG_DISABLE_COPY_MOVE_DEFAULT(CpuWorker)
+
+    CpuWorker(size_t id, const CpuLaunchData &data);
     ~CpuWorker() override;
 
 protected:
@@ -71,7 +73,7 @@ private:
     const CnHash::AlgoVariant m_av;
     const Miner *m_miner;
     cryptonight_ctx *m_ctx[N];
-    uint8_t m_hash[N * 32];
+    uint8_t m_hash[N * 32]{ 0 };
     VirtualMemory *m_memory = nullptr;
     WorkerJob<N> m_job;
 

src/backend/opencl/OclBackend.cpp

@@ -0,0 +1,404 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <mutex>
+#include <string>
+
+
+#include "backend/common/Hashrate.h"
+#include "backend/common/interfaces/IWorker.h"
+#include "backend/common/Tags.h"
+#include "backend/common/Workers.h"
+#include "backend/opencl/OclBackend.h"
+#include "backend/opencl/OclConfig.h"
+#include "backend/opencl/OclLaunchData.h"
+#include "backend/opencl/OclWorker.h"
+#include "backend/opencl/wrappers/OclContext.h"
+#include "backend/opencl/wrappers/OclLib.h"
+#include "base/io/log/Log.h"
+#include "base/net/stratum/Job.h"
+#include "base/tools/Chrono.h"
+#include "base/tools/String.h"
+#include "core/config/Config.h"
+#include "core/Controller.h"
+#include "rapidjson/document.h"
+
+
+#ifdef XMRIG_FEATURE_API
+#   include "base/api/interfaces/IApiRequest.h"
+#endif
+
+
+namespace xmrig {
+
+
+extern template class Threads<OclThreads>;
+
+
+constexpr const size_t oneMiB   = 1024u * 1024u;
+static const char *tag          = MAGENTA_BG_BOLD(WHITE_BOLD_S " ocl ");
+static const String kType       = "opencl";
+static std::mutex mutex;
+
+
+static void printDisabled(const char *reason)
+{
+    Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") RED_BOLD("disabled") "%s", "OPENCL", reason);
+}
+
+
+struct OclLaunchStatus
+{
+public:
+    inline bool started()               { m_started++; return m_started == m_threads; }
+    inline size_t threads() const       { return m_threads; }
+
+    inline void start(size_t threads)
+    {
+        m_started        = 0;
+        m_threads        = threads;
+        m_ts             = Chrono::steadyMSecs();
+        OclWorker::ready = false;
+    }
+
+    inline void print() const
+    {
+        LOG_INFO("%s" GREEN_BOLD(" READY") " threads " CYAN_BOLD("%zu") BLACK_BOLD(" (%" PRIu64 " ms)"),
+                 tag,
+                 m_threads,
+                 Chrono::steadyMSecs() - m_ts
+                 );
+    }
+
+private:
+    size_t m_started    = 0;
+    size_t m_threads    = 0;
+    uint64_t m_ts       = 0;
+};
+
+
+class OclBackendPrivate
+{
+public:
+    inline OclBackendPrivate(Controller *controller) :
+        controller(controller)
+    {
+        init(controller->config()->cl());
+    }
+
+
+    void init(const OclConfig &cl)
+    {
+        if (!cl.isEnabled()) {
+            return printDisabled("");
+        }
+
+        if (!OclLib::init(cl.loader())) {
+            return printDisabled(RED_S " (failed to load OpenCL runtime)");
+        }
+
+        platform = cl.platform();
+        if (!platform.isValid()) {
+            return printDisabled(RED_S " (selected OpenCL platform NOT found)");
+        }
+
+        devices = platform.devices();
+        if (devices.empty()) {
+            return printDisabled(RED_S " (no devices)");
+        }
+
+        Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu ") WHITE_BOLD("%s") "/" WHITE_BOLD("%s"), "OPENCL", platform.index(), platform.name().data(), platform.version().data());
+
+        for (const OclDevice &device : devices) {
+            Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-13s") CYAN_BOLD("#%zu") YELLOW(" %s") " %s " WHITE_BOLD("%uMHz") " cu:" WHITE_BOLD("%u") " mem:" CYAN("%zu/%zu") " MB", "OPENCL GPU",
+                       device.index(),
+                       device.hasTopology() ? device.topology().toString().data() : "n/a",
+                       device.printableName().data(),
+                       device.clock(),
+                       device.computeUnits(),
+                       device.freeMemSize() / oneMiB,
+                       device.globalMemSize() / oneMiB);
+        }
+    }
+
+
+    inline void start()
+    {
+        LOG_INFO("%s use profile " BLUE_BG(WHITE_BOLD_S " %s ") WHITE_BOLD_S " (" CYAN_BOLD("%zu") WHITE_BOLD(" threads)") " scratchpad " CYAN_BOLD("%zu KB"),
+                 tag,
+                 profileName.data(),
+                 threads.size(),
+                 algo.l3() / 1024
+                 );
+
+        Log::print(WHITE_BOLD("|  # | GPU |  BUS ID |    I |  W | SI | MC |  U |  MEM | NAME"));
+
+        size_t i = 0;
+        for (const auto &data : threads) {
+            Log::print("|" CYAN_BOLD("%3zu") " |" CYAN_BOLD("%4u") " |" YELLOW(" %7s") " |" CYAN_BOLD("%5u") " |" CYAN_BOLD("%3u") " |"
+                       CYAN_BOLD("%3u") " |" CYAN_BOLD("%3s") " |" CYAN_BOLD("%3u") " |" CYAN("%5zu") " | %s",
+                       i,
+                       data.thread.index(),
+                       data.device.hasTopology() ? data.device.topology().toString().data() : "n/a",
+                       data.thread.intensity(),
+                       data.thread.worksize(),
+                       data.thread.stridedIndex(),
+                       data.thread.stridedIndex() == 2 ? std::to_string(data.thread.memChunk()).c_str() : "-",
+                       data.thread.unrollFactor(),
+                       data.thread.intensity() * algo.l3() / oneMiB,
+                       data.device.printableName().data()
+                       );
+
+                    i++;
+        }
+
+        status.start(threads.size());
+        workers.start(threads);
+    }
+
+
+    Algorithm algo;
+    Controller *controller;
+    OclContext context;
+    OclLaunchStatus status;
+    OclPlatform platform;
+    std::vector<OclDevice> devices;
+    std::vector<OclLaunchData> threads;
+    String profileName;
+    Workers<OclLaunchData> workers;
+};
+
+
+} // namespace xmrig
+
+
+const char *xmrig::ocl_tag()
+{
+    return tag;
+}
+
+
+xmrig::OclBackend::OclBackend(Controller *controller) :
+    d_ptr(new OclBackendPrivate(controller))
+{
+    d_ptr->workers.setBackend(this);
+}
+
+
+xmrig::OclBackend::~OclBackend()
+{
+    delete d_ptr;
+
+    OclLib::close();
+}
+
+
+bool xmrig::OclBackend::isEnabled() const
+{
+    return d_ptr->controller->config()->cl().isEnabled() && OclLib::isInitialized() && d_ptr->platform.isValid() && !d_ptr->devices.empty();
+}
+
+
+bool xmrig::OclBackend::isEnabled(const Algorithm &algorithm) const
+{
+    return !d_ptr->controller->config()->cl().threads().get(algorithm).isEmpty();
+}
+
+
+const xmrig::Hashrate *xmrig::OclBackend::hashrate() const
+{
+    return d_ptr->workers.hashrate();
+}
+
+
+const xmrig::String &xmrig::OclBackend::profileName() const
+{
+    return d_ptr->profileName;
+}
+
+
+const xmrig::String &xmrig::OclBackend::type() const
+{
+    return kType;
+}
+
+
+void xmrig::OclBackend::prepare(const Job &)
+{
+}
+
+
+void xmrig::OclBackend::printHashrate(bool details)
+{
+    if (!details || !hashrate()) {
+        return;
+    }
+
+    char num[8 * 3] = { 0 };
+
+    Log::print(WHITE_BOLD_S "| OPENCL # | AFFINITY | 10s H/s | 60s H/s | 15m H/s |");
+
+    size_t i = 0;
+    for (const OclLaunchData &data : d_ptr->threads) {
+         Log::print("| %8zu | %8" PRId64 " | %7s | %7s | %7s |" CYAN_BOLD(" #%u") YELLOW(" %s") " %s",
+                    i,
+                    data.affinity,
+                    Hashrate::format(hashrate()->calc(i, Hashrate::ShortInterval),  num,         sizeof num / 3),
+                    Hashrate::format(hashrate()->calc(i, Hashrate::MediumInterval), num + 8,     sizeof num / 3),
+                    Hashrate::format(hashrate()->calc(i, Hashrate::LargeInterval),  num + 8 * 2, sizeof num / 3),
+                    data.device.index(),
+                    data.device.hasTopology() ? data.device.topology().toString().data() : "n/a",
+                    data.device.printableName().data()
+                    );
+
+         i++;
+    }
+
+    Log::print(WHITE_BOLD_S "|        - |        - | %7s | %7s | %7s |",
+               Hashrate::format(hashrate()->calc(Hashrate::ShortInterval),  num,         sizeof num / 3),
+               Hashrate::format(hashrate()->calc(Hashrate::MediumInterval), num + 8,     sizeof num / 3),
+               Hashrate::format(hashrate()->calc(Hashrate::LargeInterval),  num + 8 * 2, sizeof num / 3)
+               );
+}
+
+
+void xmrig::OclBackend::setJob(const Job &job)
+{
+    if (!isEnabled()) {
+        return stop();
+    }
+
+    const OclConfig &cl = d_ptr->controller->config()->cl();
+
+    std::vector<OclLaunchData> threads = cl.get(d_ptr->controller->miner(), job.algorithm(), d_ptr->platform, d_ptr->devices, tag);
+    if (!d_ptr->threads.empty() && d_ptr->threads.size() == threads.size() && std::equal(d_ptr->threads.begin(), d_ptr->threads.end(), threads.begin())) {
+        return;
+    }
+
+    d_ptr->algo         = job.algorithm();
+    d_ptr->profileName  = cl.threads().profileName(job.algorithm());
+
+    if (d_ptr->profileName.isNull() || threads.empty()) {
+        LOG_WARN("%s " RED_BOLD("disabled") YELLOW(" (no suitable configuration found)"), tag);
+
+        return stop();
+    }
+
+    if (!d_ptr->context.init(d_ptr->devices, threads, job)) {
+        LOG_WARN("%s " RED_BOLD("disabled") YELLOW(" (OpenCL context unavailable)"), tag);
+
+        return stop();
+    }
+
+    stop();
+
+    d_ptr->threads = std::move(threads);
+    d_ptr->start();
+}
+
+
+void xmrig::OclBackend::start(IWorker *worker)
+{
+    mutex.lock();
+
+    if (d_ptr->status.started()) {
+        d_ptr->status.print();
+
+        OclWorker::ready = true;
+    }
+
+    mutex.unlock();
+
+    worker->start();
+}
+
+
+void xmrig::OclBackend::stop()
+{
+    if (d_ptr->threads.empty()) {
+        return;
+    }
+
+    const uint64_t ts = Chrono::steadyMSecs();
+
+    d_ptr->workers.stop();
+    d_ptr->threads.clear();
+
+    LOG_INFO("%s" YELLOW(" stopped") BLACK_BOLD(" (%" PRIu64 " ms)"), tag, Chrono::steadyMSecs() - ts);
+}
+
+
+void xmrig::OclBackend::tick(uint64_t ticks)
+{
+    d_ptr->workers.tick(ticks);
+}
+
+
+#ifdef XMRIG_FEATURE_API
+rapidjson::Value xmrig::OclBackend::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value out(kObjectType);
+    out.AddMember("type",       type().toJSON(), allocator);
+    out.AddMember("enabled",    isEnabled(), allocator);
+    out.AddMember("algo",       d_ptr->algo.toJSON(), allocator);
+    out.AddMember("profile",    profileName().toJSON(), allocator);
+    out.AddMember("platform",   d_ptr->platform.toJSON(doc), allocator);
+
+    if (d_ptr->threads.empty() || !hashrate()) {
+        return out;
+    }
+
+    Value threads(kArrayType);
+    const Hashrate *hr = hashrate();
+
+    size_t i = 0;
+    for (const OclLaunchData &data : d_ptr->threads) {
+        Value thread = data.thread.toJSON(doc);
+        thread.AddMember("affinity", data.affinity, allocator);
+
+        Value hashrate(kArrayType);
+        hashrate.PushBack(Hashrate::normalize(hr->calc(i, Hashrate::ShortInterval)),  allocator);
+        hashrate.PushBack(Hashrate::normalize(hr->calc(i, Hashrate::MediumInterval)), allocator);
+        hashrate.PushBack(Hashrate::normalize(hr->calc(i, Hashrate::LargeInterval)),  allocator);
+
+        i++;
+
+        thread.AddMember("hashrate", hashrate, allocator);
+        threads.PushBack(thread, allocator);
+    }
+
+    out.AddMember("threads", threads, allocator);
+
+    return out;
+}
+
+
+void xmrig::OclBackend::handleRequest(IApiRequest &)
+{
+}
+#endif

src/backend/opencl/OclBackend.h

@@ -0,0 +1,82 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLBACKEND_H
+#define XMRIG_OCLBACKEND_H
+
+
+#include <utility>
+
+
+#include "backend/common/interfaces/IBackend.h"
+
+
+namespace xmrig {
+
+
+class Controller;
+class OclBackendPrivate;
+class Miner;
+
+
+class OclBackend : public IBackend
+{
+public:
+    OclBackend()                        = delete;
+    OclBackend(const OclBackend &other) = delete;
+    OclBackend(Controller *controller);
+    OclBackend(OclBackend &&other)      = delete;
+
+    ~OclBackend() override;
+
+    OclBackend &operator=(const OclBackend &other) = delete;
+    OclBackend &operator=(OclBackend &&other)      = delete;
+
+protected:
+    bool isEnabled() const override;
+    bool isEnabled(const Algorithm &algorithm) const override;
+    const Hashrate *hashrate() const override;
+    const String &profileName() const override;
+    const String &type() const override;
+    void prepare(const Job &nextJob) override;
+    void printHashrate(bool details) override;
+    void setJob(const Job &job) override;
+    void start(IWorker *worker) override;
+    void stop() override;
+    void tick(uint64_t ticks) override;
+
+#   ifdef XMRIG_FEATURE_API
+    rapidjson::Value toJSON(rapidjson::Document &doc) const override;
+    void handleRequest(IApiRequest &request) override;
+#   endif
+
+private:
+    OclBackendPrivate *d_ptr;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_OCLBACKEND_H */

src/backend/opencl/OclCache.cpp

@@ -0,0 +1,184 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <fstream>
+#include <map>
+#include <mutex>
+#include <sstream>
+
+
+#include "3rdparty/base32/base32.h"
+#include "backend/common/Tags.h"
+#include "backend/opencl/interfaces/IOclRunner.h"
+#include "backend/opencl/OclCache.h"
+#include "backend/opencl/OclLaunchData.h"
+#include "backend/opencl/wrappers/OclLib.h"
+#include "base/io/log/Log.h"
+#include "base/tools/Chrono.h"
+#include "crypto/common/keccak.h"
+
+
+namespace xmrig {
+
+
+static std::mutex mutex;
+
+
+static cl_program createFromSource(const IOclRunner *runner)
+{
+    LOG_INFO("%s GPU " WHITE_BOLD("#%zu") " " YELLOW_BOLD("compiling..."), ocl_tag(), runner->data().device.index());
+
+    cl_int ret;
+    cl_device_id device = runner->data().device.id();
+    const char *source  = runner->source();
+    const uint64_t ts   = Chrono::steadyMSecs();
+
+    cl_program program = OclLib::createProgramWithSource(runner->ctx(), 1, &source, nullptr, &ret);
+    if (ret != CL_SUCCESS) {
+        return nullptr;
+    }
+
+    if (OclLib::buildProgram(program, 1, &device, runner->buildOptions()) != CL_SUCCESS) {
+        printf("BUILD LOG:\n%s\n", OclLib::getProgramBuildLog(program, device).data());
+
+        OclLib::release(program);
+        return nullptr;
+    }
+
+    LOG_INFO("%s GPU " WHITE_BOLD("#%zu") " " GREEN_BOLD("compilation completed") BLACK_BOLD(" (%" PRIu64 " ms)"),
+             ocl_tag(), runner->data().device.index(), Chrono::steadyMSecs() - ts);
+
+    return program;
+}
+
+
+static cl_program createFromBinary(const IOclRunner *runner, const std::string &fileName)
+{
+    std::ifstream file(fileName, std::ofstream::in | std::ofstream::binary);
+    if (!file.good()) {
+        return nullptr;
+    }
+
+    std::ostringstream ss;
+    ss << file.rdbuf();
+
+    const std::string s     = ss.str();
+    const size_t bin_size   = s.size();
+    auto data_ptr           = s.data();
+    cl_device_id device     = runner->data().device.id();
+
+    cl_int clStatus;
+    cl_int ret;
+    cl_program program = OclLib::createProgramWithBinary(runner->ctx(), 1, &device, &bin_size, reinterpret_cast<const unsigned char **>(&data_ptr), &clStatus, &ret);
+    if (ret != CL_SUCCESS) {
+        return nullptr;
+    }
+
+    if (OclLib::buildProgram(program, 1, &device) != CL_SUCCESS) {
+        OclLib::release(program);
+        return nullptr;
+    }
+
+    return program;
+}
+
+
+} // namespace xmrig
+
+
+cl_program xmrig::OclCache::build(const IOclRunner *runner)
+{
+    std::lock_guard<std::mutex> lock(mutex);
+
+    if (Nonce::sequence(Nonce::OPENCL) == 0) {
+        return nullptr;
+    }
+
+    std::string fileName;
+    if (runner->data().cache) {
+#       ifdef _WIN32
+        fileName = prefix() + "\\xmrig\\.cache\\" + cacheKey(runner) + ".bin";
+#       else
+        fileName = prefix() + "/.cache/" + cacheKey(runner) + ".bin";
+#       endif
+
+        cl_program program = createFromBinary(runner, fileName);
+        if (program) {
+            return program;
+        }
+    }
+
+    cl_program program = createFromSource(runner);
+    if (runner->data().cache && program) {
+        save(program, fileName);
+    }
+
+    return program;
+}
+
+
+std::string xmrig::OclCache::cacheKey(const char *deviceKey, const char *options, const char *source)
+{
+    std::string in(source);
+    in += options;
+    in += deviceKey;
+
+    uint8_t hash[200];
+    keccak(in.c_str(), in.size(), hash);
+
+    uint8_t result[32] = { 0 };
+    base32_encode(hash, 12, result, sizeof(result));
+
+    return reinterpret_cast<char *>(result);
+}
+
+
+std::string xmrig::OclCache::cacheKey(const IOclRunner *runner)
+{
+    return cacheKey(runner->deviceKey(), runner->buildOptions(), runner->source());
+}
+
+
+void xmrig::OclCache::save(cl_program program, const std::string &fileName)
+{
+    size_t size = 0;
+    if (OclLib::getProgramInfo(program, CL_PROGRAM_BINARY_SIZES, sizeof(size), &size) != CL_SUCCESS) {
+        return;
+    }
+
+    std::vector<char> binary(size);
+
+    char *data = binary.data();
+    if (OclLib::getProgramInfo(program, CL_PROGRAM_BINARIES, sizeof(char *), &data) != CL_SUCCESS) {
+        return;
+    }
+
+    createDirectory();
+
+    std::ofstream file_stream;
+    file_stream.open(fileName, std::ofstream::out | std::ofstream::binary);
+    file_stream.write(binary.data(), static_cast<int64_t>(binary.size()));
+    file_stream.close();
+}

src/backend/opencl/OclCache.h

@@ -0,0 +1,58 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLCACHE_H
+#define XMRIG_OCLCACHE_H
+
+
+#include <string>
+
+
+using cl_program = struct _cl_program *;
+
+
+namespace xmrig {
+
+
+class IOclRunner;
+
+
+class OclCache
+{
+public:
+    static cl_program build(const IOclRunner *runner);
+    static std::string cacheKey(const char *deviceKey, const char *options, const char *source);
+    static std::string cacheKey(const IOclRunner *runner);
+
+private:
+    static std::string prefix();
+    static void createDirectory();
+    static void save(cl_program program, const std::string &fileName);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_OCLCACHE_H */

src/backend/opencl/OclCache_unix.cpp

@@ -0,0 +1,42 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <sys/stat.h>
+#include <unistd.h>
+
+
+#include "backend/opencl/OclCache.h"
+
+
+void xmrig::OclCache::createDirectory()
+{
+    std::string path = prefix() + "/.cache";
+    mkdir(path.c_str(), 0744);
+}
+
+
+std::string xmrig::OclCache::prefix()
+{
+    return ".";
+}

src/backend/opencl/OclCache_win.cpp

@@ -0,0 +1,52 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <direct.h>
+#include <Shlobj.h>
+#include <windows.h>
+
+
+#include "backend/opencl/OclCache.h"
+
+
+void xmrig::OclCache::createDirectory()
+{
+    std::string path = prefix() + "/xmrig";
+    _mkdir(path.c_str());
+
+    path += "/.cache";
+    _mkdir(path.c_str());
+}
+
+
+std::string xmrig::OclCache::prefix()
+{
+    char path[MAX_PATH + 1];
+    if (SHGetSpecialFolderPathA(HWND_DESKTOP, path, CSIDL_LOCAL_APPDATA, FALSE)) {
+        return path;
+    }
+
+    return ".";
+}

src/backend/opencl/OclConfig.cpp

@@ -0,0 +1,293 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclConfig.h"
+#include "backend/opencl/wrappers/OclLib.h"
+#include "base/io/json/Json.h"
+#include "base/io/log/Log.h"
+#include "rapidjson/document.h"
+
+
+namespace xmrig {
+
+static const char *kAMD         = "AMD";
+static const char *kCache       = "cache";
+static const char *kCn          = "cn";
+static const char *kCn2         = "cn/2";
+static const char *kEnabled     = "enabled";
+static const char *kINTEL       = "INTEL";
+static const char *kLoader      = "loader";
+static const char *kNVIDIA      = "NVIDIA";
+static const char *kPlatform    = "platform";
+
+
+#ifdef XMRIG_ALGO_CN_GPU
+static const char *kCnGPU = "cn/gpu";
+#endif
+
+#ifdef XMRIG_ALGO_CN_LITE
+static const char *kCnLite = "cn-lite";
+#endif
+
+#ifdef XMRIG_ALGO_CN_HEAVY
+static const char *kCnHeavy = "cn-heavy";
+#endif
+
+#ifdef XMRIG_ALGO_CN_PICO
+static const char *kCnPico = "cn-pico";
+#endif
+
+#ifdef XMRIG_ALGO_RANDOMX
+static const char *kRx    = "rx";
+static const char *kRxWOW = "rx/wow";
+#endif
+
+#ifdef XMRIG_ALGO_ARGON2
+//static const char *kArgon2     = "argon2";
+#endif
+
+
+extern template class Threads<OclThreads>;
+
+
+static size_t generate(const char *key, Threads<OclThreads> &threads, const Algorithm &algorithm, const std::vector<OclDevice> &devices)
+{
+    if (threads.has(key) || threads.isExist(algorithm)) {
+        return 0;
+    }
+
+    OclThreads profile;
+    for (const OclDevice &device : devices) {
+        device.generate(algorithm, profile);
+    }
+
+    const size_t count = profile.count();
+    threads.move(key, std::move(profile));
+
+    return count;
+}
+
+
+}
+
+
+xmrig::OclConfig::OclConfig() :
+    m_platformVendor(kAMD)
+{
+}
+
+
+xmrig::OclPlatform xmrig::OclConfig::platform() const
+{
+    const auto platforms = OclPlatform::get();
+    if (platforms.empty()) {
+        return {};
+    }
+
+    if (!m_platformVendor.isEmpty()) {
+        String search;
+        String vendor = m_platformVendor;
+        vendor.toUpper();
+
+        if (vendor == kAMD) {
+            search = "Advanced Micro Devices";
+        }
+        else if (vendor == kNVIDIA) {
+            search = kNVIDIA;
+        }
+        else if (vendor == kINTEL) {
+            search = "Intel";
+        }
+        else {
+            search = m_platformVendor;
+        }
+
+        for (const auto &platform : platforms) {
+            if (platform.vendor().contains(search)) {
+                return platform;
+            }
+        }
+    }
+    else if (m_platformIndex < platforms.size()) {
+        return platforms[m_platformIndex];
+    }
+
+    return {};
+}
+
+
+rapidjson::Value xmrig::OclConfig::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value obj(kObjectType);
+
+    obj.AddMember(StringRef(kEnabled),  m_enabled, allocator);
+    obj.AddMember(StringRef(kCache),    m_cache, allocator);
+    obj.AddMember(StringRef(kLoader),   m_loader.toJSON(), allocator);
+    obj.AddMember(StringRef(kPlatform), m_platformVendor.isEmpty() ? Value(m_platformIndex) : m_platformVendor.toJSON(), allocator);
+
+    m_threads.toJSON(obj, doc);
+
+    return obj;
+}
+
+
+std::vector<xmrig::OclLaunchData> xmrig::OclConfig::get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector<OclDevice> &devices, const char *tag) const
+{
+    std::vector<OclLaunchData> out;
+    const OclThreads &threads = m_threads.get(algorithm);
+
+    if (threads.isEmpty()) {
+        return out;
+    }
+
+    out.reserve(threads.count() * 2);
+
+    for (const OclThread &thread : threads.data()) {
+        if (thread.index() >= devices.size()) {
+            LOG_INFO("%s" YELLOW(" skip non-existing device with index ") YELLOW_BOLD("%u"), tag, thread.index());
+            continue;
+        }
+
+#       ifdef XMRIG_ALGO_RANDOMX
+        auto dataset = algorithm.family() == Algorithm::RANDOM_X ? std::make_shared<OclRxDataset>() : nullptr;
+#       endif
+
+        if (thread.threads().size() > 1) {
+            auto interleave = std::make_shared<OclInterleave>(thread.threads().size());
+
+            for (int64_t affinity : thread.threads()) {
+                OclLaunchData data(miner, algorithm, *this, platform, thread, devices[thread.index()], affinity);
+                data.interleave = interleave;
+
+#               ifdef XMRIG_ALGO_RANDOMX
+                data.dataset = dataset;
+#               endif
+
+                out.emplace_back(std::move(data));
+            }
+        }
+        else {
+            OclLaunchData data(miner, algorithm, *this, platform, thread, devices[thread.index()], thread.threads().front());
+
+#           ifdef XMRIG_ALGO_RANDOMX
+            data.dataset = dataset;
+#           endif
+
+            out.emplace_back(std::move(data));
+        }
+    }
+
+    return out;
+}
+
+
+void xmrig::OclConfig::read(const rapidjson::Value &value)
+{
+    if (value.IsObject()) {
+        m_enabled   = Json::getBool(value, kEnabled, m_enabled);
+        m_cache     = Json::getBool(value, kCache, m_cache);
+        m_loader    = Json::getString(value, kLoader);
+
+        setPlatform(Json::getValue(value, kPlatform));
+
+        if (isEnabled()) {
+            m_threads.read(value);
+
+            generate();
+        }
+    }
+    else if (value.IsBool() && value.IsFalse()) {
+        m_enabled = false;
+    }
+    else {
+        generate();
+    }
+}
+
+
+void xmrig::OclConfig::generate()
+{
+    if (!OclLib::init(loader())) {
+        return;
+    }
+
+    const auto devices = platform().devices();
+    if (devices.empty()) {
+        return;
+    }
+
+    size_t count = 0;
+
+    count += xmrig::generate(kCn, m_threads, Algorithm::CN_0, devices);
+    count += xmrig::generate(kCn2, m_threads, Algorithm::CN_2, devices);
+
+    if (!m_threads.isExist(Algorithm::CN_0)) {
+        m_threads.disable(Algorithm::CN_0);
+        count++;
+    }
+
+#   ifdef XMRIG_ALGO_CN_GPU
+    count += xmrig::generate(kCnGPU, m_threads, Algorithm::CN_GPU, devices);
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_LITE
+    count += xmrig::generate(kCnLite, m_threads, Algorithm::CN_LITE_1, devices);
+
+    if (!m_threads.isExist(Algorithm::CN_LITE_0)) {
+        m_threads.disable(Algorithm::CN_LITE_0);
+        count++;
+    }
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_HEAVY
+    count += xmrig::generate(kCnHeavy, m_threads, Algorithm::CN_HEAVY_0, devices);
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_PICO
+    count += xmrig::generate(kCnPico, m_threads, Algorithm::CN_PICO_0, devices);
+#   endif
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    count += xmrig::generate(kRx, m_threads, Algorithm::RX_0, devices);
+    count += xmrig::generate(kRxWOW, m_threads, Algorithm::RX_WOW, devices);
+#   endif
+
+    m_shouldSave = count > 0;
+}
+
+
+void xmrig::OclConfig::setPlatform(const rapidjson::Value &platform)
+{
+    if (platform.IsString()) {
+        m_platformVendor = platform.GetString();
+    }
+    else if (platform.IsUint()) {
+        m_platformVendor = nullptr;
+        m_platformIndex  = platform.GetUint();
+    }
+}

src/backend/opencl/OclConfig.h

@@ -0,0 +1,71 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLCONFIG_H
+#define XMRIG_OCLCONFIG_H
+
+
+#include "backend/common/Threads.h"
+#include "backend/opencl/OclLaunchData.h"
+#include "backend/opencl/OclThreads.h"
+#include "backend/opencl/wrappers/OclPlatform.h"
+
+
+namespace xmrig {
+
+
+class OclConfig
+{
+public:
+    OclConfig();
+
+    OclPlatform platform() const;
+    rapidjson::Value toJSON(rapidjson::Document &doc) const;
+    std::vector<OclLaunchData> get(const Miner *miner, const Algorithm &algorithm, const OclPlatform &platform, const std::vector<OclDevice> &devices, const char *tag) const;
+    void read(const rapidjson::Value &value);
+
+    inline bool isCacheEnabled() const                  { return m_cache; }
+    inline bool isEnabled() const                       { return m_enabled; }
+    inline bool isShouldSave() const                    { return m_shouldSave; }
+    inline const String &loader() const                 { return m_loader; }
+    inline const Threads<OclThreads> &threads() const   { return m_threads; }
+
+private:
+    void generate();
+    void setPlatform(const rapidjson::Value &platform);
+
+    bool m_cache         = true;
+    bool m_enabled       = true;
+    bool m_shouldSave    = false;
+    String m_loader;
+    String m_platformVendor;
+    Threads<OclThreads> m_threads;
+    uint32_t m_platformIndex = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_OCLCONFIG_H */

src/backend/opencl/OclGenerator.h

@@ -0,0 +1,43 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLGENERATOR_H
+#define XMRIG_OCLGENERATOR_H
+
+
+namespace xmrig {
+
+
+class Algorithm;
+class OclDevice;
+class OclThreads;
+
+
+using ocl_gen_config_fun = bool (*)(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads);
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_OCLGENERATOR_H */

src/backend/opencl/OclInterleave.cpp

@@ -0,0 +1,118 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclInterleave.h"
+#include "base/io/log/Log.h"
+#include "base/tools/Chrono.h"
+
+
+#include <cinttypes>
+#include <thread>
+
+
+uint64_t xmrig::OclInterleave::adjustDelay(size_t id)
+{
+    const uint64_t t0 = Chrono::steadyMSecs();
+    uint64_t delay    = 0;
+
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+
+        const uint64_t dt = t0 - m_timestamp;
+        m_timestamp = t0;
+
+        // The perfect interleaving is when N threads on the same GPU start with T/N interval between each other
+        // If a thread starts earlier than 0.75*T/N ms after the previous thread, delay it to restore perfect interleaving
+        if ((dt > 0) && (dt < m_threshold * (m_averageRunTime / m_threads))) {
+            delay = static_cast<uint64_t>(m_averageRunTime / m_threads - dt);
+            m_threshold = 0.75;
+        }
+    }
+
+    if (delay == 0) {
+        return 0;
+    }
+
+    if (delay >= 400) {
+        delay = 200;
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+
+#   ifdef XMRIG_INTERLEAVE_DEBUG
+    LOG_WARN("Thread #%zu was paused for %" PRIu64 " ms to adjust interleaving", id, delay);
+#   endif
+
+    return delay;
+}
+
+
+uint64_t xmrig::OclInterleave::resumeDelay(size_t id)
+{
+    uint64_t delay = 0;
+
+    {
+        constexpr const double firstThreadSpeedupCoeff = 1.25;
+
+        std::lock_guard<std::mutex> lock(m_mutex);
+        delay = static_cast<uint64_t>(m_resumeCounter * m_averageRunTime / m_threads / firstThreadSpeedupCoeff);
+        ++m_resumeCounter;
+    }
+
+    if (delay == 0) {
+        return 0;
+    }
+
+    if (delay > 1000) {
+        delay = 1000;
+    }
+
+#   ifdef XMRIG_INTERLEAVE_DEBUG
+    LOG_WARN("Thread #%zu will be paused for %" PRIu64 " ms to before resuming", id, delay);
+#   endif
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+
+    return delay;
+}
+
+
+void xmrig::OclInterleave::setResumeCounter(uint32_t value)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_resumeCounter = value;
+}
+
+
+void xmrig::OclInterleave::setRunTime(uint64_t time)
+{
+    // averagingBias = 1.0 - only the last delta time is taken into account
+    // averagingBias = 0.5 - the last delta time has the same weight as all the previous ones combined
+    // averagingBias = 0.1 - the last delta time has 10% weight of all the previous ones combined
+    constexpr double averagingBias = 0.1;
+
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_averageRunTime = m_averageRunTime * (1.0 - averagingBias) + time * averagingBias;
+}

src/backend/opencl/OclInterleave.h

@@ -0,0 +1,63 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLINTERLEAVE_H
+#define XMRIG_OCLINTERLEAVE_H
+
+
+#include <memory>
+#include <mutex>
+
+
+namespace xmrig {
+
+
+class OclInterleave
+{
+public:
+    OclInterleave() = delete;
+    inline OclInterleave(size_t threads) : m_threads(threads) {}
+
+    uint64_t adjustDelay(size_t id);
+    uint64_t resumeDelay(size_t id);
+    void setResumeCounter(uint32_t value);
+    void setRunTime(uint64_t time);
+
+private:
+    const size_t m_threads;
+    double m_averageRunTime   = 0.0;
+    double m_threshold        = 0.95;
+    std::mutex m_mutex;
+    uint32_t m_resumeCounter  = 0;
+    uint64_t m_timestamp      = 0;
+};
+
+
+using OclInterleavePtr = std::shared_ptr<OclInterleave>;
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_OCLINTERLEAVE_H */

src/backend/opencl/OclLaunchData.cpp

@@ -0,0 +1,47 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclLaunchData.h"
+#include "backend/opencl/OclConfig.h"
+
+
+xmrig::OclLaunchData::OclLaunchData(const Miner *miner, const Algorithm &algorithm, const OclConfig &config, const OclPlatform &platform, const OclThread &thread, const OclDevice &device, int64_t affinity) :
+    algorithm(algorithm),
+    cache(config.isCacheEnabled()),
+    affinity(affinity),
+    miner(miner),
+    device(device),
+    platform(platform),
+    thread(thread)
+{
+}
+
+
+bool xmrig::OclLaunchData::isEqual(const OclLaunchData &other) const
+{
+    return (other.algorithm == algorithm &&
+            other.thread    == thread);
+}

src/backend/opencl/OclLaunchData.h

@@ -0,0 +1,84 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLLAUNCHDATA_H
+#define XMRIG_OCLLAUNCHDATA_H
+
+
+#include "backend/opencl/OclInterleave.h"
+#include "backend/opencl/OclThread.h"
+#include "backend/opencl/wrappers/OclDevice.h"
+#include "backend/opencl/wrappers/OclPlatform.h"
+#include "crypto/common/Algorithm.h"
+#include "crypto/common/Nonce.h"
+
+
+#ifdef XMRIG_ALGO_RANDOMX
+#   include "backend/opencl/runners/tools/OclRxDataset.h"
+#endif
+
+
+using cl_context = struct _cl_context *;
+
+
+namespace xmrig {
+
+
+class OclConfig;
+class Miner;
+
+
+class OclLaunchData
+{
+public:
+    OclLaunchData(const Miner *miner, const Algorithm &algorithm, const OclConfig &config, const OclPlatform &platform, const OclThread &thread, const OclDevice &device, int64_t affinity);
+
+    bool isEqual(const OclLaunchData &other) const;
+
+    inline constexpr static Nonce::Backend backend() { return Nonce::OPENCL; }
+
+    inline bool operator!=(const OclLaunchData &other) const    { return !isEqual(other); }
+    inline bool operator==(const OclLaunchData &other) const    { return isEqual(other); }
+
+    cl_context ctx = nullptr;
+    const Algorithm algorithm;
+    const bool cache;
+    const int64_t affinity;
+    const Miner *miner;
+    const OclDevice device;
+    const OclPlatform platform;
+    const OclThread thread;
+    OclInterleavePtr interleave;
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    OclRxDatasetPtr dataset;
+#   endif
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_OCLLAUNCHDATA_H */

src/backend/opencl/OclThread.cpp

@@ -0,0 +1,154 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclThread.h"
+
+#include "base/io/json/Json.h"
+#include "rapidjson/document.h"
+
+
+#include <algorithm>
+
+
+namespace xmrig {
+
+static const char *kIndex        = "index";
+static const char *kIntensity    = "intensity";
+static const char *kStridedIndex = "strided_index";
+static const char *kThreads      = "threads";
+static const char *kUnroll       = "unroll";
+static const char *kWorksize     = "worksize";
+
+#ifdef XMRIG_ALGO_RANDOMX
+static const char *kBFactor      = "bfactor";
+static const char *kGCNAsm       = "gcn_asm";
+static const char* kDatasetHost  = "dataset_host";
+#endif
+
+} // namespace xmrig
+
+
+xmrig::OclThread::OclThread(const rapidjson::Value &value)
+{
+    m_index         = Json::getUint(value, kIndex);
+    m_worksize      = std::max(std::min(Json::getUint(value, kWorksize), 128u), 1u);
+    m_unrollFactor  = std::max(std::min(Json::getUint(value, kUnroll, m_unrollFactor), 128u), 1u);
+
+    setIntensity(Json::getUint(value, kIntensity));
+
+    const auto &si = Json::getArray(value, kStridedIndex);
+    if (si.IsArray() && si.Size() >= 2) {
+        m_stridedIndex = std::min(si[0].GetUint(), 2u);
+        m_memChunk     = std::min(si[1].GetUint(), 18u);
+    }
+    else {
+        m_stridedIndex = 0;
+        m_memChunk     = 0;
+        m_fields.set(STRIDED_INDEX_FIELD, false);
+    }
+
+    const auto &threads = Json::getArray(value, kThreads);
+    if (threads.IsArray()) {
+        m_threads.reserve(threads.Size());
+
+        for (const auto &affinity : threads.GetArray()) {
+            m_threads.emplace_back(affinity.GetInt64());
+        }
+    }
+
+    if (m_threads.empty()) {
+        m_threads.emplace_back(-1);
+    }
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    const auto &gcnAsm = Json::getValue(value, kGCNAsm);
+    if (gcnAsm.IsBool()) {
+        m_fields.set(RANDOMX_FIELDS, true);
+
+        m_gcnAsm      = gcnAsm.GetBool();
+        m_bfactor     = Json::getUint(value, kBFactor, m_bfactor);
+        m_datasetHost = Json::getBool(value, kDatasetHost, m_datasetHost);
+    }
+#   endif
+}
+
+
+bool xmrig::OclThread::isEqual(const OclThread &other) const
+{
+    return other.m_threads.size() == m_threads.size() &&
+           std::equal(m_threads.begin(), m_threads.end(), other.m_threads.begin()) &&
+           other.m_bfactor      == m_bfactor &&
+           other.m_datasetHost  == m_datasetHost &&
+           other.m_gcnAsm       == m_gcnAsm &&
+           other.m_index        == m_index &&
+           other.m_intensity    == m_intensity &&
+           other.m_memChunk     == m_memChunk &&
+           other.m_stridedIndex == m_stridedIndex &&
+           other.m_unrollFactor == m_unrollFactor &&
+           other.m_worksize     == m_worksize;
+}
+
+
+rapidjson::Value xmrig::OclThread::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value out(kObjectType);
+
+    out.AddMember(StringRef(kIndex),        index(), allocator);
+    out.AddMember(StringRef(kIntensity),    intensity(), allocator);
+    out.AddMember(StringRef(kWorksize),     worksize(), allocator);
+
+    if (m_fields.test(STRIDED_INDEX_FIELD)) {
+        Value si(kArrayType);
+        si.Reserve(2, allocator);
+        si.PushBack(stridedIndex(), allocator);
+        si.PushBack(memChunk(), allocator);
+        out.AddMember(StringRef(kStridedIndex), si, allocator);
+    }
+
+    Value threads(kArrayType);
+    threads.Reserve(m_threads.size(), allocator);
+
+    for (auto thread : m_threads) {
+        threads.PushBack(thread, allocator);
+    }
+
+    out.AddMember(StringRef(kThreads), threads, allocator);
+
+    if (m_fields.test(RANDOMX_FIELDS)) {
+#       ifdef XMRIG_ALGO_RANDOMX
+        out.AddMember(StringRef(kBFactor),      bfactor(), allocator);
+        out.AddMember(StringRef(kGCNAsm),       isAsm(), allocator);
+        out.AddMember(StringRef(kDatasetHost),  isDatasetHost(), allocator);
+#       endif
+    }
+    else {
+        out.AddMember(StringRef(kUnroll), unrollFactor(), allocator);
+    }
+
+    return out;
+}

src/backend/opencl/OclThread.h

@@ -0,0 +1,131 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLTHREAD_H
+#define XMRIG_OCLTHREAD_H
+
+
+#include "crypto/common/Algorithm.h"
+#include "rapidjson/fwd.h"
+
+
+#include <bitset>
+#include <vector>
+
+
+namespace xmrig {
+
+
+class OclThread
+{
+public:
+    OclThread() = delete;
+    OclThread(uint32_t index, uint32_t intensity, uint32_t worksize, uint32_t stridedIndex, uint32_t memChunk, uint32_t threads, uint32_t unrollFactor) :
+        m_threads(threads, -1),
+        m_index(index),
+        m_memChunk(memChunk),
+        m_stridedIndex(stridedIndex),
+        m_unrollFactor(unrollFactor),
+        m_worksize(worksize)
+    {
+        setIntensity(intensity);
+    }
+
+#   ifdef XMRIG_ALGO_CN_GPU
+    OclThread(uint32_t index, uint32_t intensity, uint32_t worksize, uint32_t threads, uint32_t unrollFactor) :
+        m_fields(0),
+        m_threads(threads, -1),
+        m_index(index),
+        m_memChunk(0),
+        m_stridedIndex(0),
+        m_unrollFactor(unrollFactor),
+        m_worksize(worksize)
+    {
+        setIntensity(intensity);
+    }
+#   endif
+
+#   ifdef XMRIG_ALGO_RANDOMX
+    OclThread(uint32_t index, uint32_t intensity, uint32_t worksize, uint32_t threads, bool gcnAsm, bool datasetHost, uint32_t bfactor) :
+        m_datasetHost(datasetHost),
+        m_gcnAsm(gcnAsm),
+        m_fields(2),
+        m_threads(threads, -1),
+        m_bfactor(bfactor),
+        m_index(index),
+        m_memChunk(0),
+        m_stridedIndex(0),
+        m_worksize(worksize)
+    {
+        setIntensity(intensity);
+    }
+#   endif
+
+    OclThread(const rapidjson::Value &value);
+
+    inline bool isAsm() const                               { return m_gcnAsm; }
+    inline bool isDatasetHost() const                       { return m_datasetHost; }
+    inline bool isValid() const                             { return m_intensity > 0; }
+    inline const std::vector<int64_t> &threads() const      { return m_threads; }
+    inline uint32_t bfactor() const                         { return m_bfactor; }
+    inline uint32_t index() const                           { return m_index; }
+    inline uint32_t intensity() const                       { return m_intensity; }
+    inline uint32_t memChunk() const                        { return m_memChunk; }
+    inline uint32_t stridedIndex() const                    { return m_stridedIndex; }
+    inline uint32_t unrollFactor() const                    { return m_unrollFactor; }
+    inline uint32_t worksize() const                        { return m_worksize; }
+
+    inline bool operator!=(const OclThread &other) const    { return !isEqual(other); }
+    inline bool operator==(const OclThread &other) const    { return isEqual(other); }
+
+    bool isEqual(const OclThread &other) const;
+    rapidjson::Value toJSON(rapidjson::Document &doc) const;
+
+private:
+    enum Fields {
+        STRIDED_INDEX_FIELD,
+        RANDOMX_FIELDS,
+        FIELD_MAX
+    };
+
+    inline void setIntensity(uint32_t intensity)            { m_intensity = intensity / m_worksize * m_worksize; }
+
+    bool m_datasetHost              = false;
+    bool m_gcnAsm                   = true;
+    std::bitset<FIELD_MAX> m_fields = 1;
+    std::vector<int64_t> m_threads;
+    uint32_t m_bfactor              = 6;
+    uint32_t m_index                = 0;
+    uint32_t m_intensity            = 0;
+    uint32_t m_memChunk             = 2;
+    uint32_t m_stridedIndex         = 2;
+    uint32_t m_unrollFactor         = 8;
+    uint32_t m_worksize             = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_OCLTHREAD_H */

src/backend/opencl/OclThreads.cpp

@@ -0,0 +1,61 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <algorithm>
+
+
+#include "backend/opencl/OclThreads.h"
+#include "base/io/json/Json.h"
+#include "rapidjson/document.h"
+
+
+xmrig::OclThreads::OclThreads(const rapidjson::Value &value)
+{
+    if (value.IsArray()) {
+        for (auto &v : value.GetArray()) {
+            OclThread thread(v);
+            if (thread.isValid()) {
+                add(std::move(thread));
+            }
+        }
+    }
+}
+
+
+rapidjson::Value xmrig::OclThreads::toJSON(rapidjson::Document &doc) const
+{
+    using namespace rapidjson;
+    auto &allocator = doc.GetAllocator();
+
+    Value out(kArrayType);
+
+    out.SetArray();
+
+    for (const OclThread &thread : m_data) {
+        out.PushBack(thread.toJSON(doc), allocator);
+    }
+
+    return out;
+}

src/backend/opencl/OclThreads.h

@@ -0,0 +1,60 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLTHREADS_H
+#define XMRIG_OCLTHREADS_H
+
+
+#include <vector>
+
+
+#include "backend/opencl/OclThread.h"
+
+
+namespace xmrig {
+
+
+class OclThreads
+{
+public:
+    OclThreads() = default;
+    OclThreads(const rapidjson::Value &value);
+
+    inline bool isEmpty() const                             { return m_data.empty(); }
+    inline const std::vector<OclThread> &data() const       { return m_data; }
+    inline size_t count() const                             { return m_data.size(); }
+    inline void add(OclThread &&thread)                     { m_data.push_back(thread); }
+    inline void reserve(size_t capacity)                    { m_data.reserve(capacity); }
+
+    rapidjson::Value toJSON(rapidjson::Document &doc) const;
+
+private:
+    std::vector<OclThread> m_data;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif /* XMRIG_OCLTHREADS_H */

src/backend/opencl/OclWorker.cpp

@@ -0,0 +1,235 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclWorker.h"
+
+#include "backend/common/Tags.h"
+#include "backend/opencl/runners/OclCnRunner.h"
+#include "base/io/log/Log.h"
+#include "base/tools/Chrono.h"
+#include "core/Miner.h"
+#include "crypto/common/Nonce.h"
+#include "net/JobResults.h"
+
+
+#ifdef XMRIG_ALGO_RANDOMX
+#   include "backend/opencl/runners/OclRxJitRunner.h"
+#   include "backend/opencl/runners/OclRxVmRunner.h"
+#endif
+
+#ifdef XMRIG_ALGO_CN_GPU
+#   include "backend/opencl/runners/OclRyoRunner.h"
+#endif
+
+
+#include <cassert>
+#include <thread>
+
+
+namespace xmrig {
+
+
+static constexpr uint32_t kReserveCount = 32768;
+std::atomic<bool> OclWorker::ready;
+
+
+static inline bool isReady()                         { return !Nonce::isPaused() && OclWorker::ready; }
+static inline uint32_t roundSize(uint32_t intensity) { return kReserveCount / intensity + 1; }
+
+
+static inline void printError(size_t id, const char *error)
+{
+    LOG_ERR("%s" RED_S " thread " RED_BOLD("#%zu") RED_S " failed with error " RED_BOLD("%s"), ocl_tag(), id, error);
+}
+
+
+} // namespace xmrig
+
+
+
+xmrig::OclWorker::OclWorker(size_t id, const OclLaunchData &data) :
+    Worker(id, data.affinity, -1),
+    m_algorithm(data.algorithm),
+    m_miner(data.miner),
+    m_intensity(data.thread.intensity()),
+    m_interleave(data.interleave)
+{
+    switch (m_algorithm.family()) {
+    case Algorithm::RANDOM_X:
+#       ifdef XMRIG_ALGO_RANDOMX
+        if (data.thread.isAsm() && data.device.vendorId() == OCL_VENDOR_AMD) {
+            m_runner = new OclRxJitRunner(id, data);
+        }
+        else {
+            m_runner = new OclRxVmRunner(id, data);
+        }
+#       endif
+        break;
+
+    case Algorithm::ARGON2:
+#       ifdef XMRIG_ALGO_ARGON2
+        m_runner = nullptr; // TODO OclArgon2Runner
+#       endif
+        break;
+
+    default:
+#       ifdef XMRIG_ALGO_CN_GPU
+        if (m_algorithm == Algorithm::CN_GPU) {
+            m_runner = new OclRyoRunner(id, data);
+        }
+        else
+#       endif
+        {
+            m_runner = new OclCnRunner(id, data);
+        }
+        break;
+    }
+
+    if (!m_runner) {
+        return;
+    }
+
+    try {
+        m_runner->init();
+        m_runner->build();
+    }
+    catch (std::exception &ex) {
+        printError(id, ex.what());
+
+        delete m_runner;
+        m_runner = nullptr;
+    }
+}
+
+
+xmrig::OclWorker::~OclWorker()
+{
+    delete m_runner;
+}
+
+
+bool xmrig::OclWorker::selfTest()
+{
+    return m_runner != nullptr;
+}
+
+
+void xmrig::OclWorker::start()
+{
+    cl_uint results[0x100];
+
+    while (Nonce::sequence(Nonce::OPENCL) > 0) {
+        if (!isReady()) {
+            if (m_interleave) {
+                m_interleave->setResumeCounter(0);
+            }
+
+            do {
+                std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            }
+            while (!isReady() && Nonce::sequence(Nonce::OPENCL) > 0);
+
+            if (Nonce::sequence(Nonce::OPENCL) == 0) {
+                break;
+            }
+
+            if (m_interleave) {
+                m_interleave->resumeDelay(m_id);
+            }
+
+            if (!consumeJob()) {
+                return;
+            }
+        }
+
+        while (!Nonce::isOutdated(Nonce::OPENCL, m_job.sequence())) {
+            if (m_interleave) {
+                m_interleave->adjustDelay(m_id);
+            }
+
+            const uint64_t t = Chrono::steadyMSecs();
+
+            try {
+                m_runner->run(*m_job.nonce(), results);
+            }
+            catch (std::exception &ex) {
+                printError(id(), ex.what());
+
+                return;
+            }
+
+            if (results[0xFF] > 0) {
+                JobResults::submit(m_job.currentJob(), results, results[0xFF]);
+            }
+
+            m_job.nextRound(roundSize(m_intensity), m_intensity);
+
+            storeStats(t);
+            std::this_thread::yield();
+        }
+
+        if (!consumeJob()) {
+            return;
+        }
+    }
+}
+
+
+bool xmrig::OclWorker::consumeJob()
+{
+    if (Nonce::sequence(Nonce::OPENCL) == 0) {
+        return false;
+    }
+
+    m_job.add(m_miner->job(), Nonce::sequence(Nonce::OPENCL), roundSize(m_intensity) * m_intensity);
+
+    try {
+        m_runner->set(m_job.currentJob(), m_job.blob());
+    }
+    catch (std::exception &ex) {
+        printError(id(), ex.what());
+
+        return false;
+    }
+
+    return true;
+}
+
+
+void xmrig::OclWorker::storeStats(uint64_t t)
+{
+    if (!isReady()) {
+        return;
+    }
+
+    m_count += m_intensity;
+
+    if (m_interleave) {
+        m_interleave->setRunTime(Chrono::steadyMSecs() - t);
+    }
+
+    Worker::storeStats();
+}

src/backend/opencl/OclWorker.h

@@ -0,0 +1,77 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLWORKER_H
+#define XMRIG_OCLWORKER_H
+
+
+#include "backend/common/Worker.h"
+#include "backend/common/WorkerJob.h"
+#include "backend/opencl/OclLaunchData.h"
+#include "net/JobResult.h"
+
+
+namespace xmrig {
+
+
+class IOclRunner;
+
+
+class OclWorker : public Worker
+{
+public:
+    OclWorker()                       = delete;
+    OclWorker(const OclWorker &other) = delete;
+    OclWorker(OclWorker &&other)      = delete;
+    OclWorker(size_t id, const OclLaunchData &data);
+
+    ~OclWorker() override;
+
+    OclWorker &operator=(const OclWorker &other) = delete;
+    OclWorker &operator=(OclWorker &&other)      = delete;
+
+    static std::atomic<bool> ready;
+
+protected:
+    bool selfTest() override;
+    void start() override;
+
+private:
+    bool consumeJob();
+    void storeStats(uint64_t ts);
+
+    const Algorithm m_algorithm;
+    const Miner *m_miner;
+    const uint32_t m_intensity;
+    IOclRunner *m_runner = nullptr;
+    OclInterleavePtr m_interleave;
+    WorkerJob<1> m_job;
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_OCLWORKER_H */

src/backend/opencl/cl/OclSource.cpp

@@ -0,0 +1,56 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/cl/OclSource.h"
+
+#include "backend/opencl/cl/cn/cryptonight_cl.h"
+#include "crypto/common/Algorithm.h"
+
+
+#ifdef XMRIG_ALGO_CN_GPU
+#   include "backend/opencl/cl/cn/cryptonight_gpu_cl.h"
+#endif
+
+#ifdef XMRIG_ALGO_RANDOMX
+#   include "backend/opencl/cl/rx/randomx_cl.h"
+#endif
+
+
+const char *xmrig::OclSource::get(const Algorithm &algorithm)
+{
+#   ifdef XMRIG_ALGO_RANDOMX
+    if (algorithm.family() == Algorithm::RANDOM_X) {
+        return randomx_cl;
+    }
+#   endif
+
+#   ifdef XMRIG_ALGO_CN_GPU
+    if (algorithm == Algorithm::CN_GPU) {
+        return cryptonight_gpu_cl;
+    }
+#   endif
+
+    return cryptonight_cl;
+}

src/backend/opencl/cl/OclSource.h

@@ -0,0 +1,46 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_OCLSOURCE_H
+#define XMRIG_OCLSOURCE_H
+
+
+namespace xmrig {
+
+
+class Algorithm;
+
+
+class OclSource
+{
+public:
+    static const char *get(const Algorithm &algorithm);
+    static void init();
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_OCLSOURCE_H */

src/backend/opencl/cl/cn/algorithm.cl

@@ -0,0 +1,31 @@
+#define ALGO_CN_0           0
+#define ALGO_CN_1           1
+#define ALGO_CN_2           2
+#define ALGO_CN_R           3
+#define ALGO_CN_FAST        4
+#define ALGO_CN_HALF        5
+#define ALGO_CN_XAO         6
+#define ALGO_CN_RTO         7
+#define ALGO_CN_RWZ         8
+#define ALGO_CN_ZLS         9
+#define ALGO_CN_DOUBLE      10
+#define ALGO_CN_GPU         11
+#define ALGO_CN_LITE_0      12
+#define ALGO_CN_LITE_1      13
+#define ALGO_CN_HEAVY_0     14
+#define ALGO_CN_HEAVY_TUBE  15
+#define ALGO_CN_HEAVY_XHV   16
+#define ALGO_CN_PICO_0      17
+#define ALGO_RX_0           18
+#define ALGO_RX_WOW         19
+#define ALGO_RX_LOKI        20
+#define ALGO_AR2_CHUKWA     21
+#define ALGO_AR2_WRKZ       22
+
+#define FAMILY_UNKNOWN      0
+#define FAMILY_CN           1
+#define FAMILY_CN_LITE      2
+#define FAMILY_CN_HEAVY     3
+#define FAMILY_CN_PICO      4
+#define FAMILY_RANDOM_X     5
+#define FAMILY_ARGON2       6

src/backend/opencl/cl/cn/blake256.cl

@@ -0,0 +1,91 @@
+/*
+* blake256 kernel implementation.
+*
+* ==========================(LICENSE BEGIN)============================
+* Copyright (c) 2014 djm34
+* Copyright (c) 2014 tpruvot
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*
+* ===========================(LICENSE END)=============================
+*
+* @author   djm34
+*/
+__constant static const int sigma[16][16] = {
+		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
+		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
+		{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
+		{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
+		{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
+		{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
+		{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
+		{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
+		{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
+		{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0 },
+		{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
+		{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
+		{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
+		{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
+		{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
+		{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 }
+};
+
+
+__constant static const sph_u32  c_IV256[8] = {
+	0x6A09E667, 0xBB67AE85,
+	0x3C6EF372, 0xA54FF53A,
+	0x510E527F, 0x9B05688C,
+	0x1F83D9AB, 0x5BE0CD19
+};
+
+/* Second part (64-80) msg never change, store it */
+__constant static const sph_u32  c_Padding[16] = {
+	0, 0, 0, 0,
+	0x80000000, 0, 0, 0,
+	0, 0, 0, 0,
+	0, 1, 0, 640,
+};
+__constant static const sph_u32  c_u256[16] = {
+	0x243F6A88, 0x85A308D3,
+	0x13198A2E, 0x03707344,
+	0xA4093822, 0x299F31D0,
+	0x082EFA98, 0xEC4E6C89,
+	0x452821E6, 0x38D01377,
+	0xBE5466CF, 0x34E90C6C,
+	0xC0AC29B7, 0xC97C50DD,
+	0x3F84D5B5, 0xB5470917
+};
+
+#define GS(a,b,c,d,x) { \
+	const sph_u32 idx1 = sigma[r][x]; \
+	const sph_u32 idx2 = sigma[r][x+1]; \
+	v[a] += (m[idx1] ^ c_u256[idx2]) + v[b]; \
+	v[d] ^= v[a]; \
+    v[d] = rotate(v[d], 16U); \
+	v[c] += v[d]; \
+    v[b] ^= v[c]; \
+	v[b] = rotate(v[b], 20U); \
+\
+	v[a] += (m[idx2] ^ c_u256[idx1]) + v[b]; \
+    v[d] ^= v[a]; \
+	v[d] = rotate(v[d], 24U); \
+	v[c] += v[d]; \
+    v[b] ^= v[c]; \
+	v[b] = rotate(v[b], 25U); \
+}

src/backend/opencl/cl/cn/cryptonight_gpu.cl

@@ -0,0 +1,520 @@
+#include "wolf-aes.cl"
+#include "keccak.cl"
+
+
+inline uint getIdx()
+{
+    return get_global_id(0) - get_global_offset(0);
+}
+
+
+#define IDX(x) (x)
+
+
+inline float4 _mm_add_ps(float4 a, float4 b)
+{
+    return a + b;
+}
+
+
+inline float4 _mm_sub_ps(float4 a, float4 b)
+{
+    return a - b;
+}
+
+
+inline float4 _mm_mul_ps(float4 a, float4 b)
+{
+    return a * b;
+}
+
+
+inline float4 _mm_div_ps(float4 a, float4 b)
+{
+    return a / b;
+}
+
+
+inline float4 _mm_and_ps(float4 a, int b)
+{
+    return as_float4(as_int4(a) & (int4)(b));
+}
+
+
+inline float4 _mm_or_ps(float4 a, int b)
+{
+    return as_float4(as_int4(a) | (int4)(b));
+}
+
+
+inline float4 _mm_fmod_ps(float4 v, float dc)
+{
+    float4 d = (float4)(dc);
+    float4 c = _mm_div_ps(v, d);
+    c = trunc(c);
+    c = _mm_mul_ps(c, d);
+    return _mm_sub_ps(v, c);
+}
+
+
+inline int4 _mm_xor_si128(int4 a, int4 b)
+{
+    return a ^ b;
+}
+
+
+inline float4 _mm_xor_ps(float4 a, int b)
+{
+    return as_float4(as_int4(a) ^ (int4)(b));
+}
+
+
+inline int4 _mm_alignr_epi8(int4 a, const uint rot)
+{
+    const uint right = 8 * rot;
+    const uint left = (32 - 8 * rot);
+    return (int4)(
+        ((uint)a.x >> right) | ( a.y << left ),
+        ((uint)a.y >> right) | ( a.z << left ),
+        ((uint)a.z >> right) | ( a.w << left ),
+        ((uint)a.w >> right) | ( a.x << left )
+    );
+}
+
+
+inline global int4* scratchpad_ptr(uint idx, uint n, __global int *lpad) { return (__global int4*)((__global char*)lpad + (idx & MASK) + n * 16); }
+
+
+inline float4 fma_break(float4 x)
+{
+    // Break the dependency chain by setitng the exp to ?????01
+    x = _mm_and_ps(x, 0xFEFFFFFF);
+    return _mm_or_ps(x, 0x00800000);
+}
+
+
+inline void sub_round(float4 n0, float4 n1, float4 n2, float4 n3, float4 rnd_c, float4* n, float4* d, float4* c)
+{
+    n1 = _mm_add_ps(n1, *c);
+    float4 nn = _mm_mul_ps(n0, *c);
+    nn = _mm_mul_ps(n1, _mm_mul_ps(nn,nn));
+    nn = fma_break(nn);
+    *n = _mm_add_ps(*n, nn);
+
+    n3 = _mm_sub_ps(n3, *c);
+    float4 dd = _mm_mul_ps(n2, *c);
+    dd = _mm_mul_ps(n3, _mm_mul_ps(dd,dd));
+    dd = fma_break(dd);
+    *d = _mm_add_ps(*d, dd);
+
+    //Constant feedback
+    *c = _mm_add_ps(*c, rnd_c);
+    *c = _mm_add_ps(*c, (float4)(0.734375f));
+    float4 r = _mm_add_ps(nn, dd);
+    r = _mm_and_ps(r, 0x807FFFFF);
+    r = _mm_or_ps(r, 0x40000000);
+    *c = _mm_add_ps(*c, r);
+
+}
+
+
+// 9*8 + 2 = 74
+inline void round_compute(float4 n0, float4 n1, float4 n2, float4 n3, float4 rnd_c, float4* c, float4* r)
+{
+    float4 n = (float4)(0.0f);
+    float4 d = (float4)(0.0f);
+
+    sub_round(n0, n1, n2, n3, rnd_c, &n, &d, c);
+    sub_round(n1, n2, n3, n0, rnd_c, &n, &d, c);
+    sub_round(n2, n3, n0, n1, rnd_c, &n, &d, c);
+    sub_round(n3, n0, n1, n2, rnd_c, &n, &d, c);
+    sub_round(n3, n2, n1, n0, rnd_c, &n, &d, c);
+    sub_round(n2, n1, n0, n3, rnd_c, &n, &d, c);
+    sub_round(n1, n0, n3, n2, rnd_c, &n, &d, c);
+    sub_round(n0, n3, n2, n1, rnd_c, &n, &d, c);
+
+    // Make sure abs(d) > 2.0 - this prevents division by zero and accidental overflows by division by < 1.0
+    d = _mm_and_ps(d, 0xFF7FFFFF);
+    d = _mm_or_ps(d, 0x40000000);
+    *r =_mm_add_ps(*r, _mm_div_ps(n,d));
+}
+
+
+inline int4 single_comupte(float4 n0, float4 n1, float4 n2, float4 n3, float cnt, float4 rnd_c, __local float4* sum)
+{
+    float4 c= (float4)(cnt);
+    // 35 maths calls follow (140 FLOPS)
+    float4 r = (float4)(0.0f);
+
+    for (int i = 0; i < 4; ++i) {
+        round_compute(n0, n1, n2, n3, rnd_c, &c, &r);
+    }
+
+    // do a quick fmod by setting exp to 2
+    r = _mm_and_ps(r, 0x807FFFFF);
+    r = _mm_or_ps(r, 0x40000000);
+    *sum = r; // 34
+    float4 x = (float4)(536870880.0f);
+    r = _mm_mul_ps(r, x); // 35
+    return convert_int4_rte(r);
+}
+
+
+inline void single_comupte_wrap(const uint rot, int4 v0, int4 v1, int4 v2, int4 v3, float cnt, float4 rnd_c, __local float4* sum, __local int4* out)
+{
+    float4 n0 = convert_float4_rte(v0);
+    float4 n1 = convert_float4_rte(v1);
+    float4 n2 = convert_float4_rte(v2);
+    float4 n3 = convert_float4_rte(v3);
+
+    int4 r = single_comupte(n0, n1, n2, n3, cnt, rnd_c, sum);
+    *out = rot == 0 ? r : _mm_alignr_epi8(r, rot);
+}
+
+
+static const __constant uint look[16][4] = {
+    {0, 1, 2, 3},
+    {0, 2, 3, 1},
+    {0, 3, 1, 2},
+    {0, 3, 2, 1},
+
+    {1, 0, 2, 3},
+    {1, 2, 3, 0},
+    {1, 3, 0, 2},
+    {1, 3, 2, 0},
+
+    {2, 1, 0, 3},
+    {2, 0, 3, 1},
+    {2, 3, 1, 0},
+    {2, 3, 0, 1},
+
+    {3, 1, 2, 0},
+    {3, 2, 0, 1},
+    {3, 0, 1, 2},
+    {3, 0, 2, 1}
+};
+
+
+static const __constant float ccnt[16] = {
+    1.34375f,
+    1.28125f,
+    1.359375f,
+    1.3671875f,
+
+    1.4296875f,
+    1.3984375f,
+    1.3828125f,
+    1.3046875f,
+
+    1.4140625f,
+    1.2734375f,
+    1.2578125f,
+    1.2890625f,
+
+    1.3203125f,
+    1.3515625f,
+    1.3359375f,
+    1.4609375f
+};
+
+
+struct SharedMemChunk
+{
+    int4 out[16];
+    float4 va[16];
+};
+
+
+__attribute__((reqd_work_group_size(WORKSIZE * 16, 1, 1)))
+__kernel void cn1(__global int *lpad_in, __global int *spad, uint numThreads)
+{
+    const uint gIdx = getIdx();
+    uint chunk = get_local_id(0) / 16;
+
+    __global int* lpad = (__global int*)((__global char*)lpad_in + MEMORY * (gIdx/16));
+
+    __local struct SharedMemChunk smem_in[WORKSIZE];
+    __local struct SharedMemChunk* smem = smem_in + chunk;
+
+    uint tid = get_local_id(0) % 16;
+
+    uint idxHash = gIdx/16;
+    uint s = ((__global uint*)spad)[idxHash * 50] >> 8;
+    float4 vs = (float4)(0);
+
+    // tid divided
+    const uint tidd = tid / 4;
+    // tid modulo
+    const uint tidm = tid % 4;
+    const uint block = tidd * 16 + tidm;
+
+    #pragma unroll CN_UNROLL
+    for (uint i = 0; i < ITERATIONS; i++)   {
+        mem_fence(CLK_LOCAL_MEM_FENCE);
+        int tmp = ((__global int*)scratchpad_ptr(s, tidd, lpad))[tidm];
+        ((__local int*)(smem->out))[tid] = tmp;
+        mem_fence(CLK_LOCAL_MEM_FENCE);
+
+        {
+            single_comupte_wrap(
+                tidm,
+                *(smem->out + look[tid][0]),
+                *(smem->out + look[tid][1]),
+                *(smem->out + look[tid][2]),
+                *(smem->out + look[tid][3]),
+                ccnt[tid], vs, smem->va + tid,
+                smem->out + tid
+            );
+        }
+        mem_fence(CLK_LOCAL_MEM_FENCE);
+
+        int outXor = ((__local int*)smem->out)[block];
+        for (uint dd = block + 4; dd < (tidd + 1) * 16; dd += 4) {
+            outXor ^= ((__local int*)smem->out)[dd];
+        }
+
+        ((__global int*)scratchpad_ptr(s, tidd, lpad))[tidm] = outXor ^ tmp;
+        ((__local int*)smem->out)[tid] = outXor;
+
+        float va_tmp1 = ((__local float*)smem->va)[block] + ((__local float*)smem->va)[block + 4];
+        float va_tmp2 = ((__local float*)smem->va)[block+ 8] + ((__local float*)smem->va)[block + 12];
+        ((__local float*)smem->va)[tid] = va_tmp1 + va_tmp2;
+
+        mem_fence(CLK_LOCAL_MEM_FENCE);
+
+        int out2 = ((__local int*)smem->out)[tid] ^ ((__local int*)smem->out)[tid + 4 ] ^ ((__local int*)smem->out)[tid + 8] ^ ((__local int*)smem->out)[tid + 12];
+        va_tmp1 = ((__local float*)smem->va)[block] + ((__local float*)smem->va)[block + 4];
+        va_tmp2 = ((__local float*)smem->va)[block + 8] + ((__local float*)smem->va)[block + 12];
+        va_tmp1 = va_tmp1 + va_tmp2;
+        va_tmp1 = fabs(va_tmp1);
+
+        float xx = va_tmp1 * 16777216.0f;
+        int xx_int = (int)xx;
+        ((__local int*)smem->out)[tid] = out2 ^ xx_int;
+        ((__local float*)smem->va)[tid] = va_tmp1 / 64.0f;
+
+        mem_fence(CLK_LOCAL_MEM_FENCE);
+
+        vs = smem->va[0];
+        s = smem->out[0].x ^ smem->out[0].y ^ smem->out[0].z ^ smem->out[0].w;
+    }
+}
+
+
+static const __constant uint skip[3] = {
+    20,22,22
+};
+
+
+inline void generate_512(uint idx, __local ulong* in, __global ulong* out)
+{
+    ulong hash[25];
+
+    hash[0] = in[0] ^ idx;
+    for (int i = 1; i < 25; ++i) {
+        hash[i] = in[i];
+    }
+
+    for (int a = 0; a < 3; ++a) {
+        keccakf1600_1(hash);
+        for (int i = 0; i < skip[a]; ++i) {
+            out[i] = hash[i];
+        }
+
+        out += skip[a];
+    }
+}
+
+
+__attribute__((reqd_work_group_size(8, 8, 1)))
+__kernel void cn0(__global ulong *input, __global int *Scratchpad, __global ulong *states, uint Threads)
+{
+    const uint gIdx = getIdx();
+    __local ulong State_buf[8 * 25];
+    __local ulong* State = State_buf + get_local_id(0) * 25;
+
+    {
+        states += 25 * gIdx;
+
+        Scratchpad = (__global int*)((__global char*)Scratchpad + MEMORY * gIdx);
+
+        if (get_local_id(1) == 0) {
+
+#           ifdef __NV_CL_C_VERSION
+            for(uint i = 0; i < 8; ++i)
+                State[i] = input[i];
+#           else
+            ((__local ulong8 *)State)[0] = vload8(0, input);
+#           endif
+
+            State[8]  = input[8];
+            State[9]  = input[9];
+            State[10] = input[10];
+
+            ((__local uint *)State)[9]  &= 0x00FFFFFFU;
+            ((__local uint *)State)[9]  |= (((uint)get_global_id(0)) & 0xFF) << 24;
+            ((__local uint *)State)[10] &= 0xFF000000U;
+            /* explicit cast to `uint` is required because some OpenCL implementations (e.g. NVIDIA)
+             * handle get_global_id and get_global_offset as signed long long int and add
+             * 0xFFFFFFFF... to `get_global_id` if we set on host side a 32bit offset where the first bit is `1`
+             * (even if it is correct casted to unsigned on the host)
+             */
+            ((__local uint *)State)[10] |= (((uint)get_global_id(0) >> 8));
+
+            for (int i = 11; i < 25; ++i) {
+                State[i] = 0x00UL;
+            }
+
+            // Last bit of padding
+            State[16] = 0x8000000000000000UL;
+
+            keccakf1600_2(State);
+
+            #pragma unroll
+            for (int i = 0; i < 25; ++i) {
+                states[i] = State[i];
+            }
+        }
+    }
+}
+
+
+__attribute__((reqd_work_group_size(64, 1, 1)))
+__kernel void cn00(__global int *Scratchpad, __global ulong *states)
+{
+    const uint gIdx = getIdx() / 64;
+    __local ulong State[25];
+
+    states += 25 * gIdx;
+
+    Scratchpad = (__global int*)((__global char*)Scratchpad + MEMORY * gIdx);
+
+    for (int i = get_local_id(0); i < 25; i += get_local_size(0)) {
+        State[i] = states[i];
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    for (uint i = get_local_id(0); i < MEMORY / 512; i += get_local_size(0)) {
+        generate_512(i, State, (__global ulong*)((__global uchar*)Scratchpad + i * 512));
+    }
+}
+
+
+__attribute__((reqd_work_group_size(8, 8, 1)))
+__kernel void cn2(__global uint4 *Scratchpad, __global ulong *states, __global uint *output, ulong Target, uint Threads)
+{
+    __local uint AES0[256], AES1[256], AES2[256], AES3[256];
+    uint ExpandedKey2[40];
+    uint4 text;
+
+    const uint gIdx = getIdx();
+
+    for (int i = get_local_id(1) * 8 + get_local_id(0); i < 256; i += 8 * 8) {
+        const uint tmp = AES0_C[i];
+        AES0[i] = tmp;
+        AES1[i] = rotate(tmp, 8U);
+        AES2[i] = rotate(tmp, 16U);
+        AES3[i] = rotate(tmp, 24U);
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local uint4 xin1[8][8];
+    __local uint4 xin2[8][8];
+
+    {
+        states += 25 * gIdx;
+        Scratchpad += gIdx * (MEMORY >> 4);
+
+        #if defined(__Tahiti__) || defined(__Pitcairn__)
+        for(int i = 0; i < 4; ++i) ((ulong *)ExpandedKey2)[i] = states[i + 4];
+        text = vload4(get_local_id(1) + 4, (__global uint *)states);
+        #else
+        text = vload4(get_local_id(1) + 4, (__global uint *)states);
+        ((uint8 *)ExpandedKey2)[0] = vload8(1, (__global uint *)states);
+        #endif
+
+        AESExpandKey256(ExpandedKey2);
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    __local uint4* xin1_store = &xin1[get_local_id(1)][get_local_id(0)];
+    __local uint4* xin1_load = &xin1[(get_local_id(1) + 1) % 8][get_local_id(0)];
+    __local uint4* xin2_store = &xin2[get_local_id(1)][get_local_id(0)];
+    __local uint4* xin2_load = &xin2[(get_local_id(1) + 1) % 8][get_local_id(0)];
+    *xin2_store = (uint4)(0, 0, 0, 0);
+
+    {
+
+        #pragma unroll 2
+        for (int i = 0, i1 = get_local_id(1); i < (MEMORY >> 7); ++i, i1 = (i1 + 16) % (MEMORY >> 4)) {
+            text ^= Scratchpad[(uint)i1];
+            barrier(CLK_LOCAL_MEM_FENCE);
+            text ^= *xin2_load;
+
+            #pragma unroll 10
+            for(int j = 0; j < 10; ++j)
+                text = AES_Round(AES0, AES1, AES2, AES3, text, ((uint4 *)ExpandedKey2)[j]);
+
+            *xin1_store = text;
+
+            text ^= Scratchpad[(uint)i1 + 8u];
+            barrier(CLK_LOCAL_MEM_FENCE);
+            text ^= *xin1_load;
+
+            #pragma unroll 10
+            for(int j = 0; j < 10; ++j)
+                text = AES_Round(AES0, AES1, AES2, AES3, text, ((uint4 *)ExpandedKey2)[j]);
+
+            *xin2_store = text;
+        }
+
+        barrier(CLK_LOCAL_MEM_FENCE);
+        text ^= *xin2_load;
+    }
+
+    /* Also left over threads performe this loop.
+     * The left over thread results will be ignored
+     */
+    #pragma unroll 16
+    for(size_t i = 0; i < 16; i++)
+    {
+        #pragma unroll 10
+        for (int j = 0; j < 10; ++j) {
+            text = AES_Round(AES0, AES1, AES2, AES3, text, ((uint4 *)ExpandedKey2)[j]);
+        }
+
+        barrier(CLK_LOCAL_MEM_FENCE);
+        *xin1_store = text;
+        barrier(CLK_LOCAL_MEM_FENCE);
+        text ^= *xin1_load;
+    }
+
+    __local ulong State_buf[8 * 25];
+    {
+        vstore2(as_ulong2(text), get_local_id(1) + 4, states);
+    }
+
+    barrier(CLK_GLOBAL_MEM_FENCE);
+
+    {
+        if(!get_local_id(1))
+        {
+            __local ulong* State = State_buf + get_local_id(0) * 25;
+
+            for(int i = 0; i < 25; ++i) State[i] = states[i];
+
+            keccakf1600_2(State);
+
+            if(State[3] <= Target)
+            {
+                ulong outIdx = atomic_inc(output + 0xFF);
+                if(outIdx < 0xFF)
+                    output[outIdx] = get_global_id(0);
+            }
+        }
+    }
+    mem_fence(CLK_GLOBAL_MEM_FENCE);
+}

src/backend/opencl/cl/cn/cryptonight_gpu_cl.h

@@ -0,0 +1,639 @@
+#pragma once
+
+namespace xmrig {
+
+static char cryptonight_gpu_cl[20166] = {
+    0x23,0x69,0x66,0x6e,0x64,0x65,0x66,0x20,0x57,0x4f,0x4c,0x46,0x5f,0x41,0x45,0x53,0x5f,0x43,0x4c,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x57,0x4f,0x4c,0x46,
+    0x5f,0x41,0x45,0x53,0x5f,0x43,0x4c,0x0a,0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x63,0x6c,0x5f,0x61,0x6d,0x64,0x5f,0x6d,0x65,0x64,0x69,0x61,0x5f,0x6f,0x70,0x73,0x32,
+    0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x4f,0x50,0x45,0x4e,0x43,0x4c,0x20,0x45,0x58,0x54,0x45,0x4e,0x53,0x49,0x4f,0x4e,0x20,0x63,0x6c,0x5f,0x61,0x6d,0x64,
+    0x5f,0x6d,0x65,0x64,0x69,0x61,0x5f,0x6f,0x70,0x73,0x32,0x20,0x3a,0x20,0x65,0x6e,0x61,0x62,0x6c,0x65,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x78,0x6d,0x72,
+    0x69,0x67,0x5f,0x61,0x6d,0x64,0x5f,0x62,0x66,0x65,0x28,0x73,0x72,0x63,0x30,0x2c,0x20,0x73,0x72,0x63,0x31,0x2c,0x20,0x73,0x72,0x63,0x32,0x29,0x20,0x61,0x6d,0x64,
+    0x5f,0x62,0x66,0x65,0x28,0x73,0x72,0x63,0x30,0x2c,0x20,0x73,0x72,0x63,0x31,0x2c,0x20,0x73,0x72,0x63,0x32,0x29,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x69,0x6e,0x6c,
+    0x69,0x6e,0x65,0x20,0x69,0x6e,0x74,0x20,0x78,0x6d,0x72,0x69,0x67,0x5f,0x61,0x6d,0x64,0x5f,0x62,0x66,0x65,0x28,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,
+    0x20,0x73,0x72,0x63,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6f,0x66,0x66,0x73,0x65,0x74,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,
+    0x6e,0x74,0x20,0x77,0x69,0x64,0x74,0x68,0x29,0x0a,0x7b,0x0a,0x69,0x66,0x28,0x28,0x6f,0x66,0x66,0x73,0x65,0x74,0x2b,0x77,0x69,0x64,0x74,0x68,0x29,0x3c,0x33,0x32,
+    0x75,0x29,0x20,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x73,0x72,0x63,0x30,0x3c,0x3c,0x28,0x33,0x32,0x75,0x2d,0x6f,0x66,0x66,0x73,0x65,0x74,0x2d,0x77,
+    0x69,0x64,0x74,0x68,0x29,0x29,0x3e,0x3e,0x28,0x33,0x32,0x75,0x2d,0x77,0x69,0x64,0x74,0x68,0x29,0x3b,0x0a,0x7d,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x73,0x72,
+    0x63,0x30,0x3e,0x3e,0x6f,0x66,0x66,0x73,0x65,0x74,0x3b,0x0a,0x7d,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x41,0x45,0x53,0x30,0x5f,0x43,0x5b,0x32,0x35,0x36,0x5d,0x20,0x3d,0x0a,
+    0x7b,0x0a,0x30,0x78,0x41,0x35,0x36,0x33,0x36,0x33,0x43,0x36,0x55,0x2c,0x30,0x78,0x38,0x34,0x37,0x43,0x37,0x43,0x46,0x38,0x55,0x2c,0x30,0x78,0x39,0x39,0x37,0x37,
+    0x37,0x37,0x45,0x45,0x55,0x2c,0x30,0x78,0x38,0x44,0x37,0x42,0x37,0x42,0x46,0x36,0x55,0x2c,0x0a,0x30,0x78,0x30,0x44,0x46,0x32,0x46,0x32,0x46,0x46,0x55,0x2c,0x30,
+    0x78,0x42,0x44,0x36,0x42,0x36,0x42,0x44,0x36,0x55,0x2c,0x30,0x78,0x42,0x31,0x36,0x46,0x36,0x46,0x44,0x45,0x55,0x2c,0x30,0x78,0x35,0x34,0x43,0x35,0x43,0x35,0x39,
+    0x31,0x55,0x2c,0x0a,0x30,0x78,0x35,0x30,0x33,0x30,0x33,0x30,0x36,0x30,0x55,0x2c,0x30,0x78,0x30,0x33,0x30,0x31,0x30,0x31,0x30,0x32,0x55,0x2c,0x30,0x78,0x41,0x39,
+    0x36,0x37,0x36,0x37,0x43,0x45,0x55,0x2c,0x30,0x78,0x37,0x44,0x32,0x42,0x32,0x42,0x35,0x36,0x55,0x2c,0x0a,0x30,0x78,0x31,0x39,0x46,0x45,0x46,0x45,0x45,0x37,0x55,
+    0x2c,0x30,0x78,0x36,0x32,0x44,0x37,0x44,0x37,0x42,0x35,0x55,0x2c,0x30,0x78,0x45,0x36,0x41,0x42,0x41,0x42,0x34,0x44,0x55,0x2c,0x30,0x78,0x39,0x41,0x37,0x36,0x37,
+    0x36,0x45,0x43,0x55,0x2c,0x0a,0x30,0x78,0x34,0x35,0x43,0x41,0x43,0x41,0x38,0x46,0x55,0x2c,0x30,0x78,0x39,0x44,0x38,0x32,0x38,0x32,0x31,0x46,0x55,0x2c,0x30,0x78,
+    0x34,0x30,0x43,0x39,0x43,0x39,0x38,0x39,0x55,0x2c,0x30,0x78,0x38,0x37,0x37,0x44,0x37,0x44,0x46,0x41,0x55,0x2c,0x0a,0x30,0x78,0x31,0x35,0x46,0x41,0x46,0x41,0x45,
+    0x46,0x55,0x2c,0x30,0x78,0x45,0x42,0x35,0x39,0x35,0x39,0x42,0x32,0x55,0x2c,0x30,0x78,0x43,0x39,0x34,0x37,0x34,0x37,0x38,0x45,0x55,0x2c,0x30,0x78,0x30,0x42,0x46,
+    0x30,0x46,0x30,0x46,0x42,0x55,0x2c,0x0a,0x30,0x78,0x45,0x43,0x41,0x44,0x41,0x44,0x34,0x31,0x55,0x2c,0x30,0x78,0x36,0x37,0x44,0x34,0x44,0x34,0x42,0x33,0x55,0x2c,
+    0x30,0x78,0x46,0x44,0x41,0x32,0x41,0x32,0x35,0x46,0x55,0x2c,0x30,0x78,0x45,0x41,0x41,0x46,0x41,0x46,0x34,0x35,0x55,0x2c,0x0a,0x30,0x78,0x42,0x46,0x39,0x43,0x39,
+    0x43,0x32,0x33,0x55,0x2c,0x30,0x78,0x46,0x37,0x41,0x34,0x41,0x34,0x35,0x33,0x55,0x2c,0x30,0x78,0x39,0x36,0x37,0x32,0x37,0x32,0x45,0x34,0x55,0x2c,0x30,0x78,0x35,
+    0x42,0x43,0x30,0x43,0x30,0x39,0x42,0x55,0x2c,0x0a,0x30,0x78,0x43,0x32,0x42,0x37,0x42,0x37,0x37,0x35,0x55,0x2c,0x30,0x78,0x31,0x43,0x46,0x44,0x46,0x44,0x45,0x31,
+    0x55,0x2c,0x30,0x78,0x41,0x45,0x39,0x33,0x39,0x33,0x33,0x44,0x55,0x2c,0x30,0x78,0x36,0x41,0x32,0x36,0x32,0x36,0x34,0x43,0x55,0x2c,0x0a,0x30,0x78,0x35,0x41,0x33,
+    0x36,0x33,0x36,0x36,0x43,0x55,0x2c,0x30,0x78,0x34,0x31,0x33,0x46,0x33,0x46,0x37,0x45,0x55,0x2c,0x30,0x78,0x30,0x32,0x46,0x37,0x46,0x37,0x46,0x35,0x55,0x2c,0x30,
+    0x78,0x34,0x46,0x43,0x43,0x43,0x43,0x38,0x33,0x55,0x2c,0x0a,0x30,0x78,0x35,0x43,0x33,0x34,0x33,0x34,0x36,0x38,0x55,0x2c,0x30,0x78,0x46,0x34,0x41,0x35,0x41,0x35,
+    0x35,0x31,0x55,0x2c,0x30,0x78,0x33,0x34,0x45,0x35,0x45,0x35,0x44,0x31,0x55,0x2c,0x30,0x78,0x30,0x38,0x46,0x31,0x46,0x31,0x46,0x39,0x55,0x2c,0x0a,0x30,0x78,0x39,
+    0x33,0x37,0x31,0x37,0x31,0x45,0x32,0x55,0x2c,0x30,0x78,0x37,0x33,0x44,0x38,0x44,0x38,0x41,0x42,0x55,0x2c,0x30,0x78,0x35,0x33,0x33,0x31,0x33,0x31,0x36,0x32,0x55,
+    0x2c,0x30,0x78,0x33,0x46,0x31,0x35,0x31,0x35,0x32,0x41,0x55,0x2c,0x0a,0x30,0x78,0x30,0x43,0x30,0x34,0x30,0x34,0x30,0x38,0x55,0x2c,0x30,0x78,0x35,0x32,0x43,0x37,
+    0x43,0x37,0x39,0x35,0x55,0x2c,0x30,0x78,0x36,0x35,0x32,0x33,0x32,0x33,0x34,0x36,0x55,0x2c,0x30,0x78,0x35,0x45,0x43,0x33,0x43,0x33,0x39,0x44,0x55,0x2c,0x0a,0x30,
+    0x78,0x32,0x38,0x31,0x38,0x31,0x38,0x33,0x30,0x55,0x2c,0x30,0x78,0x41,0x31,0x39,0x36,0x39,0x36,0x33,0x37,0x55,0x2c,0x30,0x78,0x30,0x46,0x30,0x35,0x30,0x35,0x30,
+    0x41,0x55,0x2c,0x30,0x78,0x42,0x35,0x39,0x41,0x39,0x41,0x32,0x46,0x55,0x2c,0x0a,0x30,0x78,0x30,0x39,0x30,0x37,0x30,0x37,0x30,0x45,0x55,0x2c,0x30,0x78,0x33,0x36,
+    0x31,0x32,0x31,0x32,0x32,0x34,0x55,0x2c,0x30,0x78,0x39,0x42,0x38,0x30,0x38,0x30,0x31,0x42,0x55,0x2c,0x30,0x78,0x33,0x44,0x45,0x32,0x45,0x32,0x44,0x46,0x55,0x2c,
+    0x0a,0x30,0x78,0x32,0x36,0x45,0x42,0x45,0x42,0x43,0x44,0x55,0x2c,0x30,0x78,0x36,0x39,0x32,0x37,0x32,0x37,0x34,0x45,0x55,0x2c,0x30,0x78,0x43,0x44,0x42,0x32,0x42,
+    0x32,0x37,0x46,0x55,0x2c,0x30,0x78,0x39,0x46,0x37,0x35,0x37,0x35,0x45,0x41,0x55,0x2c,0x0a,0x30,0x78,0x31,0x42,0x30,0x39,0x30,0x39,0x31,0x32,0x55,0x2c,0x30,0x78,
+    0x39,0x45,0x38,0x33,0x38,0x33,0x31,0x44,0x55,0x2c,0x30,0x78,0x37,0x34,0x32,0x43,0x32,0x43,0x35,0x38,0x55,0x2c,0x30,0x78,0x32,0x45,0x31,0x41,0x31,0x41,0x33,0x34,
+    0x55,0x2c,0x0a,0x30,0x78,0x32,0x44,0x31,0x42,0x31,0x42,0x33,0x36,0x55,0x2c,0x30,0x78,0x42,0x32,0x36,0x45,0x36,0x45,0x44,0x43,0x55,0x2c,0x30,0x78,0x45,0x45,0x35,
+    0x41,0x35,0x41,0x42,0x34,0x55,0x2c,0x30,0x78,0x46,0x42,0x41,0x30,0x41,0x30,0x35,0x42,0x55,0x2c,0x0a,0x30,0x78,0x46,0x36,0x35,0x32,0x35,0x32,0x41,0x34,0x55,0x2c,
+    0x30,0x78,0x34,0x44,0x33,0x42,0x33,0x42,0x37,0x36,0x55,0x2c,0x30,0x78,0x36,0x31,0x44,0x36,0x44,0x36,0x42,0x37,0x55,0x2c,0x30,0x78,0x43,0x45,0x42,0x33,0x42,0x33,
+    0x37,0x44,0x55,0x2c,0x0a,0x30,0x78,0x37,0x42,0x32,0x39,0x32,0x39,0x35,0x32,0x55,0x2c,0x30,0x78,0x33,0x45,0x45,0x33,0x45,0x33,0x44,0x44,0x55,0x2c,0x30,0x78,0x37,
+    0x31,0x32,0x46,0x32,0x46,0x35,0x45,0x55,0x2c,0x30,0x78,0x39,0x37,0x38,0x34,0x38,0x34,0x31,0x33,0x55,0x2c,0x0a,0x30,0x78,0x46,0x35,0x35,0x33,0x35,0x33,0x41,0x36,
+    0x55,0x2c,0x30,0x78,0x36,0x38,0x44,0x31,0x44,0x31,0x42,0x39,0x55,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x55,0x2c,0x30,0x78,0x32,0x43,0x45,0x44,
+    0x45,0x44,0x43,0x31,0x55,0x2c,0x0a,0x30,0x78,0x36,0x30,0x32,0x30,0x32,0x30,0x34,0x30,0x55,0x2c,0x30,0x78,0x31,0x46,0x46,0x43,0x46,0x43,0x45,0x33,0x55,0x2c,0x30,
+    0x78,0x43,0x38,0x42,0x31,0x42,0x31,0x37,0x39,0x55,0x2c,0x30,0x78,0x45,0x44,0x35,0x42,0x35,0x42,0x42,0x36,0x55,0x2c,0x0a,0x30,0x78,0x42,0x45,0x36,0x41,0x36,0x41,
+    0x44,0x34,0x55,0x2c,0x30,0x78,0x34,0x36,0x43,0x42,0x43,0x42,0x38,0x44,0x55,0x2c,0x30,0x78,0x44,0x39,0x42,0x45,0x42,0x45,0x36,0x37,0x55,0x2c,0x30,0x78,0x34,0x42,
+    0x33,0x39,0x33,0x39,0x37,0x32,0x55,0x2c,0x0a,0x30,0x78,0x44,0x45,0x34,0x41,0x34,0x41,0x39,0x34,0x55,0x2c,0x30,0x78,0x44,0x34,0x34,0x43,0x34,0x43,0x39,0x38,0x55,
+    0x2c,0x30,0x78,0x45,0x38,0x35,0x38,0x35,0x38,0x42,0x30,0x55,0x2c,0x30,0x78,0x34,0x41,0x43,0x46,0x43,0x46,0x38,0x35,0x55,0x2c,0x0a,0x30,0x78,0x36,0x42,0x44,0x30,
+    0x44,0x30,0x42,0x42,0x55,0x2c,0x30,0x78,0x32,0x41,0x45,0x46,0x45,0x46,0x43,0x35,0x55,0x2c,0x30,0x78,0x45,0x35,0x41,0x41,0x41,0x41,0x34,0x46,0x55,0x2c,0x30,0x78,
+    0x31,0x36,0x46,0x42,0x46,0x42,0x45,0x44,0x55,0x2c,0x0a,0x30,0x78,0x43,0x35,0x34,0x33,0x34,0x33,0x38,0x36,0x55,0x2c,0x30,0x78,0x44,0x37,0x34,0x44,0x34,0x44,0x39,
+    0x41,0x55,0x2c,0x30,0x78,0x35,0x35,0x33,0x33,0x33,0x33,0x36,0x36,0x55,0x2c,0x30,0x78,0x39,0x34,0x38,0x35,0x38,0x35,0x31,0x31,0x55,0x2c,0x0a,0x30,0x78,0x43,0x46,
+    0x34,0x35,0x34,0x35,0x38,0x41,0x55,0x2c,0x30,0x78,0x31,0x30,0x46,0x39,0x46,0x39,0x45,0x39,0x55,0x2c,0x30,0x78,0x30,0x36,0x30,0x32,0x30,0x32,0x30,0x34,0x55,0x2c,
+    0x30,0x78,0x38,0x31,0x37,0x46,0x37,0x46,0x46,0x45,0x55,0x2c,0x0a,0x30,0x78,0x46,0x30,0x35,0x30,0x35,0x30,0x41,0x30,0x55,0x2c,0x30,0x78,0x34,0x34,0x33,0x43,0x33,
+    0x43,0x37,0x38,0x55,0x2c,0x30,0x78,0x42,0x41,0x39,0x46,0x39,0x46,0x32,0x35,0x55,0x2c,0x30,0x78,0x45,0x33,0x41,0x38,0x41,0x38,0x34,0x42,0x55,0x2c,0x0a,0x30,0x78,
+    0x46,0x33,0x35,0x31,0x35,0x31,0x41,0x32,0x55,0x2c,0x30,0x78,0x46,0x45,0x41,0x33,0x41,0x33,0x35,0x44,0x55,0x2c,0x30,0x78,0x43,0x30,0x34,0x30,0x34,0x30,0x38,0x30,
+    0x55,0x2c,0x30,0x78,0x38,0x41,0x38,0x46,0x38,0x46,0x30,0x35,0x55,0x2c,0x0a,0x30,0x78,0x41,0x44,0x39,0x32,0x39,0x32,0x33,0x46,0x55,0x2c,0x30,0x78,0x42,0x43,0x39,
+    0x44,0x39,0x44,0x32,0x31,0x55,0x2c,0x30,0x78,0x34,0x38,0x33,0x38,0x33,0x38,0x37,0x30,0x55,0x2c,0x30,0x78,0x30,0x34,0x46,0x35,0x46,0x35,0x46,0x31,0x55,0x2c,0x0a,
+    0x30,0x78,0x44,0x46,0x42,0x43,0x42,0x43,0x36,0x33,0x55,0x2c,0x30,0x78,0x43,0x31,0x42,0x36,0x42,0x36,0x37,0x37,0x55,0x2c,0x30,0x78,0x37,0x35,0x44,0x41,0x44,0x41,
+    0x41,0x46,0x55,0x2c,0x30,0x78,0x36,0x33,0x32,0x31,0x32,0x31,0x34,0x32,0x55,0x2c,0x0a,0x30,0x78,0x33,0x30,0x31,0x30,0x31,0x30,0x32,0x30,0x55,0x2c,0x30,0x78,0x31,
+    0x41,0x46,0x46,0x46,0x46,0x45,0x35,0x55,0x2c,0x30,0x78,0x30,0x45,0x46,0x33,0x46,0x33,0x46,0x44,0x55,0x2c,0x30,0x78,0x36,0x44,0x44,0x32,0x44,0x32,0x42,0x46,0x55,
+    0x2c,0x0a,0x30,0x78,0x34,0x43,0x43,0x44,0x43,0x44,0x38,0x31,0x55,0x2c,0x30,0x78,0x31,0x34,0x30,0x43,0x30,0x43,0x31,0x38,0x55,0x2c,0x30,0x78,0x33,0x35,0x31,0x33,
+    0x31,0x33,0x32,0x36,0x55,0x2c,0x30,0x78,0x32,0x46,0x45,0x43,0x45,0x43,0x43,0x33,0x55,0x2c,0x0a,0x30,0x78,0x45,0x31,0x35,0x46,0x35,0x46,0x42,0x45,0x55,0x2c,0x30,
+    0x78,0x41,0x32,0x39,0x37,0x39,0x37,0x33,0x35,0x55,0x2c,0x30,0x78,0x43,0x43,0x34,0x34,0x34,0x34,0x38,0x38,0x55,0x2c,0x30,0x78,0x33,0x39,0x31,0x37,0x31,0x37,0x32,
+    0x45,0x55,0x2c,0x0a,0x30,0x78,0x35,0x37,0x43,0x34,0x43,0x34,0x39,0x33,0x55,0x2c,0x30,0x78,0x46,0x32,0x41,0x37,0x41,0x37,0x35,0x35,0x55,0x2c,0x30,0x78,0x38,0x32,
+    0x37,0x45,0x37,0x45,0x46,0x43,0x55,0x2c,0x30,0x78,0x34,0x37,0x33,0x44,0x33,0x44,0x37,0x41,0x55,0x2c,0x0a,0x30,0x78,0x41,0x43,0x36,0x34,0x36,0x34,0x43,0x38,0x55,
+    0x2c,0x30,0x78,0x45,0x37,0x35,0x44,0x35,0x44,0x42,0x41,0x55,0x2c,0x30,0x78,0x32,0x42,0x31,0x39,0x31,0x39,0x33,0x32,0x55,0x2c,0x30,0x78,0x39,0x35,0x37,0x33,0x37,
+    0x33,0x45,0x36,0x55,0x2c,0x0a,0x30,0x78,0x41,0x30,0x36,0x30,0x36,0x30,0x43,0x30,0x55,0x2c,0x30,0x78,0x39,0x38,0x38,0x31,0x38,0x31,0x31,0x39,0x55,0x2c,0x30,0x78,
+    0x44,0x31,0x34,0x46,0x34,0x46,0x39,0x45,0x55,0x2c,0x30,0x78,0x37,0x46,0x44,0x43,0x44,0x43,0x41,0x33,0x55,0x2c,0x0a,0x30,0x78,0x36,0x36,0x32,0x32,0x32,0x32,0x34,
+    0x34,0x55,0x2c,0x30,0x78,0x37,0x45,0x32,0x41,0x32,0x41,0x35,0x34,0x55,0x2c,0x30,0x78,0x41,0x42,0x39,0x30,0x39,0x30,0x33,0x42,0x55,0x2c,0x30,0x78,0x38,0x33,0x38,
+    0x38,0x38,0x38,0x30,0x42,0x55,0x2c,0x0a,0x30,0x78,0x43,0x41,0x34,0x36,0x34,0x36,0x38,0x43,0x55,0x2c,0x30,0x78,0x32,0x39,0x45,0x45,0x45,0x45,0x43,0x37,0x55,0x2c,
+    0x30,0x78,0x44,0x33,0x42,0x38,0x42,0x38,0x36,0x42,0x55,0x2c,0x30,0x78,0x33,0x43,0x31,0x34,0x31,0x34,0x32,0x38,0x55,0x2c,0x0a,0x30,0x78,0x37,0x39,0x44,0x45,0x44,
+    0x45,0x41,0x37,0x55,0x2c,0x30,0x78,0x45,0x32,0x35,0x45,0x35,0x45,0x42,0x43,0x55,0x2c,0x30,0x78,0x31,0x44,0x30,0x42,0x30,0x42,0x31,0x36,0x55,0x2c,0x30,0x78,0x37,
+    0x36,0x44,0x42,0x44,0x42,0x41,0x44,0x55,0x2c,0x0a,0x30,0x78,0x33,0x42,0x45,0x30,0x45,0x30,0x44,0x42,0x55,0x2c,0x30,0x78,0x35,0x36,0x33,0x32,0x33,0x32,0x36,0x34,
+    0x55,0x2c,0x30,0x78,0x34,0x45,0x33,0x41,0x33,0x41,0x37,0x34,0x55,0x2c,0x30,0x78,0x31,0x45,0x30,0x41,0x30,0x41,0x31,0x34,0x55,0x2c,0x0a,0x30,0x78,0x44,0x42,0x34,
+    0x39,0x34,0x39,0x39,0x32,0x55,0x2c,0x30,0x78,0x30,0x41,0x30,0x36,0x30,0x36,0x30,0x43,0x55,0x2c,0x30,0x78,0x36,0x43,0x32,0x34,0x32,0x34,0x34,0x38,0x55,0x2c,0x30,
+    0x78,0x45,0x34,0x35,0x43,0x35,0x43,0x42,0x38,0x55,0x2c,0x0a,0x30,0x78,0x35,0x44,0x43,0x32,0x43,0x32,0x39,0x46,0x55,0x2c,0x30,0x78,0x36,0x45,0x44,0x33,0x44,0x33,
+    0x42,0x44,0x55,0x2c,0x30,0x78,0x45,0x46,0x41,0x43,0x41,0x43,0x34,0x33,0x55,0x2c,0x30,0x78,0x41,0x36,0x36,0x32,0x36,0x32,0x43,0x34,0x55,0x2c,0x0a,0x30,0x78,0x41,
+    0x38,0x39,0x31,0x39,0x31,0x33,0x39,0x55,0x2c,0x30,0x78,0x41,0x34,0x39,0x35,0x39,0x35,0x33,0x31,0x55,0x2c,0x30,0x78,0x33,0x37,0x45,0x34,0x45,0x34,0x44,0x33,0x55,
+    0x2c,0x30,0x78,0x38,0x42,0x37,0x39,0x37,0x39,0x46,0x32,0x55,0x2c,0x0a,0x30,0x78,0x33,0x32,0x45,0x37,0x45,0x37,0x44,0x35,0x55,0x2c,0x30,0x78,0x34,0x33,0x43,0x38,
+    0x43,0x38,0x38,0x42,0x55,0x2c,0x30,0x78,0x35,0x39,0x33,0x37,0x33,0x37,0x36,0x45,0x55,0x2c,0x30,0x78,0x42,0x37,0x36,0x44,0x36,0x44,0x44,0x41,0x55,0x2c,0x0a,0x30,
+    0x78,0x38,0x43,0x38,0x44,0x38,0x44,0x30,0x31,0x55,0x2c,0x30,0x78,0x36,0x34,0x44,0x35,0x44,0x35,0x42,0x31,0x55,0x2c,0x30,0x78,0x44,0x32,0x34,0x45,0x34,0x45,0x39,
+    0x43,0x55,0x2c,0x30,0x78,0x45,0x30,0x41,0x39,0x41,0x39,0x34,0x39,0x55,0x2c,0x0a,0x30,0x78,0x42,0x34,0x36,0x43,0x36,0x43,0x44,0x38,0x55,0x2c,0x30,0x78,0x46,0x41,
+    0x35,0x36,0x35,0x36,0x41,0x43,0x55,0x2c,0x30,0x78,0x30,0x37,0x46,0x34,0x46,0x34,0x46,0x33,0x55,0x2c,0x30,0x78,0x32,0x35,0x45,0x41,0x45,0x41,0x43,0x46,0x55,0x2c,
+    0x0a,0x30,0x78,0x41,0x46,0x36,0x35,0x36,0x35,0x43,0x41,0x55,0x2c,0x30,0x78,0x38,0x45,0x37,0x41,0x37,0x41,0x46,0x34,0x55,0x2c,0x30,0x78,0x45,0x39,0x41,0x45,0x41,
+    0x45,0x34,0x37,0x55,0x2c,0x30,0x78,0x31,0x38,0x30,0x38,0x30,0x38,0x31,0x30,0x55,0x2c,0x0a,0x30,0x78,0x44,0x35,0x42,0x41,0x42,0x41,0x36,0x46,0x55,0x2c,0x30,0x78,
+    0x38,0x38,0x37,0x38,0x37,0x38,0x46,0x30,0x55,0x2c,0x30,0x78,0x36,0x46,0x32,0x35,0x32,0x35,0x34,0x41,0x55,0x2c,0x30,0x78,0x37,0x32,0x32,0x45,0x32,0x45,0x35,0x43,
+    0x55,0x2c,0x0a,0x30,0x78,0x32,0x34,0x31,0x43,0x31,0x43,0x33,0x38,0x55,0x2c,0x30,0x78,0x46,0x31,0x41,0x36,0x41,0x36,0x35,0x37,0x55,0x2c,0x30,0x78,0x43,0x37,0x42,
+    0x34,0x42,0x34,0x37,0x33,0x55,0x2c,0x30,0x78,0x35,0x31,0x43,0x36,0x43,0x36,0x39,0x37,0x55,0x2c,0x0a,0x30,0x78,0x32,0x33,0x45,0x38,0x45,0x38,0x43,0x42,0x55,0x2c,
+    0x30,0x78,0x37,0x43,0x44,0x44,0x44,0x44,0x41,0x31,0x55,0x2c,0x30,0x78,0x39,0x43,0x37,0x34,0x37,0x34,0x45,0x38,0x55,0x2c,0x30,0x78,0x32,0x31,0x31,0x46,0x31,0x46,
+    0x33,0x45,0x55,0x2c,0x0a,0x30,0x78,0x44,0x44,0x34,0x42,0x34,0x42,0x39,0x36,0x55,0x2c,0x30,0x78,0x44,0x43,0x42,0x44,0x42,0x44,0x36,0x31,0x55,0x2c,0x30,0x78,0x38,
+    0x36,0x38,0x42,0x38,0x42,0x30,0x44,0x55,0x2c,0x30,0x78,0x38,0x35,0x38,0x41,0x38,0x41,0x30,0x46,0x55,0x2c,0x0a,0x30,0x78,0x39,0x30,0x37,0x30,0x37,0x30,0x45,0x30,
+    0x55,0x2c,0x30,0x78,0x34,0x32,0x33,0x45,0x33,0x45,0x37,0x43,0x55,0x2c,0x30,0x78,0x43,0x34,0x42,0x35,0x42,0x35,0x37,0x31,0x55,0x2c,0x30,0x78,0x41,0x41,0x36,0x36,
+    0x36,0x36,0x43,0x43,0x55,0x2c,0x0a,0x30,0x78,0x44,0x38,0x34,0x38,0x34,0x38,0x39,0x30,0x55,0x2c,0x30,0x78,0x30,0x35,0x30,0x33,0x30,0x33,0x30,0x36,0x55,0x2c,0x30,
+    0x78,0x30,0x31,0x46,0x36,0x46,0x36,0x46,0x37,0x55,0x2c,0x30,0x78,0x31,0x32,0x30,0x45,0x30,0x45,0x31,0x43,0x55,0x2c,0x0a,0x30,0x78,0x41,0x33,0x36,0x31,0x36,0x31,
+    0x43,0x32,0x55,0x2c,0x30,0x78,0x35,0x46,0x33,0x35,0x33,0x35,0x36,0x41,0x55,0x2c,0x30,0x78,0x46,0x39,0x35,0x37,0x35,0x37,0x41,0x45,0x55,0x2c,0x30,0x78,0x44,0x30,
+    0x42,0x39,0x42,0x39,0x36,0x39,0x55,0x2c,0x0a,0x30,0x78,0x39,0x31,0x38,0x36,0x38,0x36,0x31,0x37,0x55,0x2c,0x30,0x78,0x35,0x38,0x43,0x31,0x43,0x31,0x39,0x39,0x55,
+    0x2c,0x30,0x78,0x32,0x37,0x31,0x44,0x31,0x44,0x33,0x41,0x55,0x2c,0x30,0x78,0x42,0x39,0x39,0x45,0x39,0x45,0x32,0x37,0x55,0x2c,0x0a,0x30,0x78,0x33,0x38,0x45,0x31,
+    0x45,0x31,0x44,0x39,0x55,0x2c,0x30,0x78,0x31,0x33,0x46,0x38,0x46,0x38,0x45,0x42,0x55,0x2c,0x30,0x78,0x42,0x33,0x39,0x38,0x39,0x38,0x32,0x42,0x55,0x2c,0x30,0x78,
+    0x33,0x33,0x31,0x31,0x31,0x31,0x32,0x32,0x55,0x2c,0x0a,0x30,0x78,0x42,0x42,0x36,0x39,0x36,0x39,0x44,0x32,0x55,0x2c,0x30,0x78,0x37,0x30,0x44,0x39,0x44,0x39,0x41,
+    0x39,0x55,0x2c,0x30,0x78,0x38,0x39,0x38,0x45,0x38,0x45,0x30,0x37,0x55,0x2c,0x30,0x78,0x41,0x37,0x39,0x34,0x39,0x34,0x33,0x33,0x55,0x2c,0x0a,0x30,0x78,0x42,0x36,
+    0x39,0x42,0x39,0x42,0x32,0x44,0x55,0x2c,0x30,0x78,0x32,0x32,0x31,0x45,0x31,0x45,0x33,0x43,0x55,0x2c,0x30,0x78,0x39,0x32,0x38,0x37,0x38,0x37,0x31,0x35,0x55,0x2c,
+    0x30,0x78,0x32,0x30,0x45,0x39,0x45,0x39,0x43,0x39,0x55,0x2c,0x0a,0x30,0x78,0x34,0x39,0x43,0x45,0x43,0x45,0x38,0x37,0x55,0x2c,0x30,0x78,0x46,0x46,0x35,0x35,0x35,
+    0x35,0x41,0x41,0x55,0x2c,0x30,0x78,0x37,0x38,0x32,0x38,0x32,0x38,0x35,0x30,0x55,0x2c,0x30,0x78,0x37,0x41,0x44,0x46,0x44,0x46,0x41,0x35,0x55,0x2c,0x0a,0x30,0x78,
+    0x38,0x46,0x38,0x43,0x38,0x43,0x30,0x33,0x55,0x2c,0x30,0x78,0x46,0x38,0x41,0x31,0x41,0x31,0x35,0x39,0x55,0x2c,0x30,0x78,0x38,0x30,0x38,0x39,0x38,0x39,0x30,0x39,
+    0x55,0x2c,0x30,0x78,0x31,0x37,0x30,0x44,0x30,0x44,0x31,0x41,0x55,0x2c,0x0a,0x30,0x78,0x44,0x41,0x42,0x46,0x42,0x46,0x36,0x35,0x55,0x2c,0x30,0x78,0x33,0x31,0x45,
+    0x36,0x45,0x36,0x44,0x37,0x55,0x2c,0x30,0x78,0x43,0x36,0x34,0x32,0x34,0x32,0x38,0x34,0x55,0x2c,0x30,0x78,0x42,0x38,0x36,0x38,0x36,0x38,0x44,0x30,0x55,0x2c,0x0a,
+    0x30,0x78,0x43,0x33,0x34,0x31,0x34,0x31,0x38,0x32,0x55,0x2c,0x30,0x78,0x42,0x30,0x39,0x39,0x39,0x39,0x32,0x39,0x55,0x2c,0x30,0x78,0x37,0x37,0x32,0x44,0x32,0x44,
+    0x35,0x41,0x55,0x2c,0x30,0x78,0x31,0x31,0x30,0x46,0x30,0x46,0x31,0x45,0x55,0x2c,0x0a,0x30,0x78,0x43,0x42,0x42,0x30,0x42,0x30,0x37,0x42,0x55,0x2c,0x30,0x78,0x46,
+    0x43,0x35,0x34,0x35,0x34,0x41,0x38,0x55,0x2c,0x30,0x78,0x44,0x36,0x42,0x42,0x42,0x42,0x36,0x44,0x55,0x2c,0x30,0x78,0x33,0x41,0x31,0x36,0x31,0x36,0x32,0x43,0x55,
+    0x0a,0x7d,0x3b,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x42,0x59,0x54,0x45,0x28,0x78,0x2c,0x20,0x79,0x29,0x20,0x28,0x78,0x6d,0x72,0x69,0x67,0x5f,0x61,0x6d,
+    0x64,0x5f,0x62,0x66,0x65,0x28,0x28,0x78,0x29,0x2c,0x20,0x28,0x79,0x29,0x20,0x3c,0x3c,0x20,0x33,0x55,0x2c,0x20,0x38,0x55,0x29,0x29,0x0a,0x23,0x69,0x66,0x20,0x28,
+    0x41,0x4c,0x47,0x4f,0x20,0x3d,0x3d,0x20,0x41,0x4c,0x47,0x4f,0x5f,0x43,0x4e,0x5f,0x48,0x45,0x41,0x56,0x59,0x5f,0x54,0x55,0x42,0x45,0x29,0x0a,0x69,0x6e,0x6c,0x69,
+    0x6e,0x65,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x5f,0x62,0x69,0x74,0x74,0x75,0x62,0x65,0x32,0x28,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x78,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x6b,0x29,0x0a,0x7b,
+    0x0a,0x78,0x3d,0x7e,0x78,0x3b,0x0a,0x6b,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x30,0x29,
+    0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x33,0x29,
+    0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x6b,0x2e,0x73,0x30,0x3b,0x0a,0x6b,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,
+    0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,
+    0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,
+    0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x6b,
+    0x2e,0x73,0x31,0x3b,0x0a,0x6b,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x30,0x29,0x5d,0x5e,
+    0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,
+    0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x2c,
+    0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x6b,0x2e,0x73,0x32,0x3b,0x0a,0x6b,0x2e,0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x31,0x29,
+    0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x3b,0x0a,0x7d,
+    0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x28,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,
+    0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,
+    0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,
+    0x53,0x32,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x33,0x2c,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x58,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x6b,0x65,0x79,0x29,0x0a,0x7b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x30,0x20,0x5e,0x3d,
+    0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,
+    0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,
+    0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,
+    0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,
+    0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,
+    0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x30,0x29,
+    0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,
+    0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,
+    0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,
+    0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x65,0x79,0x3b,0x0a,0x7d,
+    0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x5f,0x54,0x77,0x6f,0x5f,0x54,0x61,0x62,0x6c,0x65,0x73,0x28,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x58,0x2c,0x75,0x69,0x6e,0x74,
+    0x34,0x20,0x6b,0x65,0x79,0x29,0x0a,0x7b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,
+    0x30,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,
+    0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,
+    0x33,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,
+    0x58,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,
+    0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,
+    0x58,0x2e,0x73,0x30,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x72,
+    0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x31,0x29,
+    0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x65,0x79,0x3b,
+    0x0a,0x7d,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x63,0x68,0x61,0x72,
+    0x20,0x72,0x63,0x6f,0x6e,0x5b,0x38,0x5d,0x3d,0x7b,0x20,0x30,0x78,0x38,0x64,0x2c,0x30,0x78,0x30,0x31,0x2c,0x30,0x78,0x30,0x32,0x2c,0x30,0x78,0x30,0x34,0x2c,0x30,
+    0x78,0x30,0x38,0x2c,0x30,0x78,0x31,0x30,0x2c,0x30,0x78,0x32,0x30,0x2c,0x30,0x78,0x34,0x30,0x20,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,
+    0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x63,0x68,0x61,0x72,0x20,0x73,0x62,0x6f,0x78,0x5b,0x32,0x35,0x36,0x5d,0x20,0x3d,0x0a,
+    0x7b,0x0a,0x30,0x78,0x36,0x33,0x2c,0x30,0x78,0x37,0x43,0x2c,0x30,0x78,0x37,0x37,0x2c,0x30,0x78,0x37,0x42,0x2c,0x30,0x78,0x46,0x32,0x2c,0x30,0x78,0x36,0x42,0x2c,
+    0x30,0x78,0x36,0x46,0x2c,0x30,0x78,0x43,0x35,0x2c,0x30,0x78,0x33,0x30,0x2c,0x30,0x78,0x30,0x31,0x2c,0x30,0x78,0x36,0x37,0x2c,0x30,0x78,0x32,0x42,0x2c,0x30,0x78,
+    0x46,0x45,0x2c,0x30,0x78,0x44,0x37,0x2c,0x30,0x78,0x41,0x42,0x2c,0x30,0x78,0x37,0x36,0x2c,0x0a,0x30,0x78,0x43,0x41,0x2c,0x30,0x78,0x38,0x32,0x2c,0x30,0x78,0x43,
+    0x39,0x2c,0x30,0x78,0x37,0x44,0x2c,0x30,0x78,0x46,0x41,0x2c,0x30,0x78,0x35,0x39,0x2c,0x30,0x78,0x34,0x37,0x2c,0x30,0x78,0x46,0x30,0x2c,0x30,0x78,0x41,0x44,0x2c,
+    0x30,0x78,0x44,0x34,0x2c,0x30,0x78,0x41,0x32,0x2c,0x30,0x78,0x41,0x46,0x2c,0x30,0x78,0x39,0x43,0x2c,0x30,0x78,0x41,0x34,0x2c,0x30,0x78,0x37,0x32,0x2c,0x30,0x78,
+    0x43,0x30,0x2c,0x0a,0x30,0x78,0x42,0x37,0x2c,0x30,0x78,0x46,0x44,0x2c,0x30,0x78,0x39,0x33,0x2c,0x30,0x78,0x32,0x36,0x2c,0x30,0x78,0x33,0x36,0x2c,0x30,0x78,0x33,
+    0x46,0x2c,0x30,0x78,0x46,0x37,0x2c,0x30,0x78,0x43,0x43,0x2c,0x30,0x78,0x33,0x34,0x2c,0x30,0x78,0x41,0x35,0x2c,0x30,0x78,0x45,0x35,0x2c,0x30,0x78,0x46,0x31,0x2c,
+    0x30,0x78,0x37,0x31,0x2c,0x30,0x78,0x44,0x38,0x2c,0x30,0x78,0x33,0x31,0x2c,0x30,0x78,0x31,0x35,0x2c,0x0a,0x30,0x78,0x30,0x34,0x2c,0x30,0x78,0x43,0x37,0x2c,0x30,
+    0x78,0x32,0x33,0x2c,0x30,0x78,0x43,0x33,0x2c,0x30,0x78,0x31,0x38,0x2c,0x30,0x78,0x39,0x36,0x2c,0x30,0x78,0x30,0x35,0x2c,0x30,0x78,0x39,0x41,0x2c,0x30,0x78,0x30,
+    0x37,0x2c,0x30,0x78,0x31,0x32,0x2c,0x30,0x78,0x38,0x30,0x2c,0x30,0x78,0x45,0x32,0x2c,0x30,0x78,0x45,0x42,0x2c,0x30,0x78,0x32,0x37,0x2c,0x30,0x78,0x42,0x32,0x2c,
+    0x30,0x78,0x37,0x35,0x2c,0x0a,0x30,0x78,0x30,0x39,0x2c,0x30,0x78,0x38,0x33,0x2c,0x30,0x78,0x32,0x43,0x2c,0x30,0x78,0x31,0x41,0x2c,0x30,0x78,0x31,0x42,0x2c,0x30,
+    0x78,0x36,0x45,0x2c,0x30,0x78,0x35,0x41,0x2c,0x30,0x78,0x41,0x30,0x2c,0x30,0x78,0x35,0x32,0x2c,0x30,0x78,0x33,0x42,0x2c,0x30,0x78,0x44,0x36,0x2c,0x30,0x78,0x42,
+    0x33,0x2c,0x30,0x78,0x32,0x39,0x2c,0x30,0x78,0x45,0x33,0x2c,0x30,0x78,0x32,0x46,0x2c,0x30,0x78,0x38,0x34,0x2c,0x0a,0x30,0x78,0x35,0x33,0x2c,0x30,0x78,0x44,0x31,
+    0x2c,0x30,0x78,0x30,0x30,0x2c,0x30,0x78,0x45,0x44,0x2c,0x30,0x78,0x32,0x30,0x2c,0x30,0x78,0x46,0x43,0x2c,0x30,0x78,0x42,0x31,0x2c,0x30,0x78,0x35,0x42,0x2c,0x30,
+    0x78,0x36,0x41,0x2c,0x30,0x78,0x43,0x42,0x2c,0x30,0x78,0x42,0x45,0x2c,0x30,0x78,0x33,0x39,0x2c,0x30,0x78,0x34,0x41,0x2c,0x30,0x78,0x34,0x43,0x2c,0x30,0x78,0x35,
+    0x38,0x2c,0x30,0x78,0x43,0x46,0x2c,0x0a,0x30,0x78,0x44,0x30,0x2c,0x30,0x78,0x45,0x46,0x2c,0x30,0x78,0x41,0x41,0x2c,0x30,0x78,0x46,0x42,0x2c,0x30,0x78,0x34,0x33,
+    0x2c,0x30,0x78,0x34,0x44,0x2c,0x30,0x78,0x33,0x33,0x2c,0x30,0x78,0x38,0x35,0x2c,0x30,0x78,0x34,0x35,0x2c,0x30,0x78,0x46,0x39,0x2c,0x30,0x78,0x30,0x32,0x2c,0x30,
+    0x78,0x37,0x46,0x2c,0x30,0x78,0x35,0x30,0x2c,0x30,0x78,0x33,0x43,0x2c,0x30,0x78,0x39,0x46,0x2c,0x30,0x78,0x41,0x38,0x2c,0x0a,0x30,0x78,0x35,0x31,0x2c,0x30,0x78,
+    0x41,0x33,0x2c,0x30,0x78,0x34,0x30,0x2c,0x30,0x78,0x38,0x46,0x2c,0x30,0x78,0x39,0x32,0x2c,0x30,0x78,0x39,0x44,0x2c,0x30,0x78,0x33,0x38,0x2c,0x30,0x78,0x46,0x35,
+    0x2c,0x30,0x78,0x42,0x43,0x2c,0x30,0x78,0x42,0x36,0x2c,0x30,0x78,0x44,0x41,0x2c,0x30,0x78,0x32,0x31,0x2c,0x30,0x78,0x31,0x30,0x2c,0x30,0x78,0x46,0x46,0x2c,0x30,
+    0x78,0x46,0x33,0x2c,0x30,0x78,0x44,0x32,0x2c,0x0a,0x30,0x78,0x43,0x44,0x2c,0x30,0x78,0x30,0x43,0x2c,0x30,0x78,0x31,0x33,0x2c,0x30,0x78,0x45,0x43,0x2c,0x30,0x78,
+    0x35,0x46,0x2c,0x30,0x78,0x39,0x37,0x2c,0x30,0x78,0x34,0x34,0x2c,0x30,0x78,0x31,0x37,0x2c,0x30,0x78,0x43,0x34,0x2c,0x30,0x78,0x41,0x37,0x2c,0x30,0x78,0x37,0x45,
+    0x2c,0x30,0x78,0x33,0x44,0x2c,0x30,0x78,0x36,0x34,0x2c,0x30,0x78,0x35,0x44,0x2c,0x30,0x78,0x31,0x39,0x2c,0x30,0x78,0x37,0x33,0x2c,0x0a,0x30,0x78,0x36,0x30,0x2c,
+    0x30,0x78,0x38,0x31,0x2c,0x30,0x78,0x34,0x46,0x2c,0x30,0x78,0x44,0x43,0x2c,0x30,0x78,0x32,0x32,0x2c,0x30,0x78,0x32,0x41,0x2c,0x30,0x78,0x39,0x30,0x2c,0x30,0x78,
+    0x38,0x38,0x2c,0x30,0x78,0x34,0x36,0x2c,0x30,0x78,0x45,0x45,0x2c,0x30,0x78,0x42,0x38,0x2c,0x30,0x78,0x31,0x34,0x2c,0x30,0x78,0x44,0x45,0x2c,0x30,0x78,0x35,0x45,
+    0x2c,0x30,0x78,0x30,0x42,0x2c,0x30,0x78,0x44,0x42,0x2c,0x0a,0x30,0x78,0x45,0x30,0x2c,0x30,0x78,0x33,0x32,0x2c,0x30,0x78,0x33,0x41,0x2c,0x30,0x78,0x30,0x41,0x2c,
+    0x30,0x78,0x34,0x39,0x2c,0x30,0x78,0x30,0x36,0x2c,0x30,0x78,0x32,0x34,0x2c,0x30,0x78,0x35,0x43,0x2c,0x30,0x78,0x43,0x32,0x2c,0x30,0x78,0x44,0x33,0x2c,0x30,0x78,
+    0x41,0x43,0x2c,0x30,0x78,0x36,0x32,0x2c,0x30,0x78,0x39,0x31,0x2c,0x30,0x78,0x39,0x35,0x2c,0x30,0x78,0x45,0x34,0x2c,0x30,0x78,0x37,0x39,0x2c,0x0a,0x30,0x78,0x45,
+    0x37,0x2c,0x30,0x78,0x43,0x38,0x2c,0x30,0x78,0x33,0x37,0x2c,0x30,0x78,0x36,0x44,0x2c,0x30,0x78,0x38,0x44,0x2c,0x30,0x78,0x44,0x35,0x2c,0x30,0x78,0x34,0x45,0x2c,
+    0x30,0x78,0x41,0x39,0x2c,0x30,0x78,0x36,0x43,0x2c,0x30,0x78,0x35,0x36,0x2c,0x30,0x78,0x46,0x34,0x2c,0x30,0x78,0x45,0x41,0x2c,0x30,0x78,0x36,0x35,0x2c,0x30,0x78,
+    0x37,0x41,0x2c,0x30,0x78,0x41,0x45,0x2c,0x30,0x78,0x30,0x38,0x2c,0x0a,0x30,0x78,0x42,0x41,0x2c,0x30,0x78,0x37,0x38,0x2c,0x30,0x78,0x32,0x35,0x2c,0x30,0x78,0x32,
+    0x45,0x2c,0x30,0x78,0x31,0x43,0x2c,0x30,0x78,0x41,0x36,0x2c,0x30,0x78,0x42,0x34,0x2c,0x30,0x78,0x43,0x36,0x2c,0x30,0x78,0x45,0x38,0x2c,0x30,0x78,0x44,0x44,0x2c,
+    0x30,0x78,0x37,0x34,0x2c,0x30,0x78,0x31,0x46,0x2c,0x30,0x78,0x34,0x42,0x2c,0x30,0x78,0x42,0x44,0x2c,0x30,0x78,0x38,0x42,0x2c,0x30,0x78,0x38,0x41,0x2c,0x0a,0x30,
+    0x78,0x37,0x30,0x2c,0x30,0x78,0x33,0x45,0x2c,0x30,0x78,0x42,0x35,0x2c,0x30,0x78,0x36,0x36,0x2c,0x30,0x78,0x34,0x38,0x2c,0x30,0x78,0x30,0x33,0x2c,0x30,0x78,0x46,
+    0x36,0x2c,0x30,0x78,0x30,0x45,0x2c,0x30,0x78,0x36,0x31,0x2c,0x30,0x78,0x33,0x35,0x2c,0x30,0x78,0x35,0x37,0x2c,0x30,0x78,0x42,0x39,0x2c,0x30,0x78,0x38,0x36,0x2c,
+    0x30,0x78,0x43,0x31,0x2c,0x30,0x78,0x31,0x44,0x2c,0x30,0x78,0x39,0x45,0x2c,0x0a,0x30,0x78,0x45,0x31,0x2c,0x30,0x78,0x46,0x38,0x2c,0x30,0x78,0x39,0x38,0x2c,0x30,
+    0x78,0x31,0x31,0x2c,0x30,0x78,0x36,0x39,0x2c,0x30,0x78,0x44,0x39,0x2c,0x30,0x78,0x38,0x45,0x2c,0x30,0x78,0x39,0x34,0x2c,0x30,0x78,0x39,0x42,0x2c,0x30,0x78,0x31,
+    0x45,0x2c,0x30,0x78,0x38,0x37,0x2c,0x30,0x78,0x45,0x39,0x2c,0x30,0x78,0x43,0x45,0x2c,0x30,0x78,0x35,0x35,0x2c,0x30,0x78,0x32,0x38,0x2c,0x30,0x78,0x44,0x46,0x2c,
+    0x0a,0x30,0x78,0x38,0x43,0x2c,0x30,0x78,0x41,0x31,0x2c,0x30,0x78,0x38,0x39,0x2c,0x30,0x78,0x30,0x44,0x2c,0x30,0x78,0x42,0x46,0x2c,0x30,0x78,0x45,0x36,0x2c,0x30,
+    0x78,0x34,0x32,0x2c,0x30,0x78,0x36,0x38,0x2c,0x30,0x78,0x34,0x31,0x2c,0x30,0x78,0x39,0x39,0x2c,0x30,0x78,0x32,0x44,0x2c,0x30,0x78,0x30,0x46,0x2c,0x30,0x78,0x42,
+    0x30,0x2c,0x30,0x78,0x35,0x34,0x2c,0x30,0x78,0x42,0x42,0x2c,0x30,0x78,0x31,0x36,0x0a,0x7d,0x3b,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x53,0x75,0x62,0x57,
+    0x6f,0x72,0x64,0x28,0x69,0x6e,0x77,0x29,0x20,0x28,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x33,0x29,0x5d,0x20,0x3c,0x3c,
+    0x20,0x32,0x34,0x29,0x20,0x7c,0x20,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x32,0x29,0x5d,0x20,0x3c,0x3c,0x20,0x31,0x36,
+    0x29,0x20,0x7c,0x20,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x31,0x29,0x5d,0x20,0x3c,0x3c,0x20,0x38,0x29,0x20,0x7c,0x20,
+    0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x30,0x29,0x5d,0x29,0x0a,0x76,0x6f,0x69,0x64,0x20,0x41,0x45,0x53,0x45,0x78,0x70,0x61,
+    0x6e,0x64,0x4b,0x65,0x79,0x32,0x35,0x36,0x28,0x75,0x69,0x6e,0x74,0x20,0x2a,0x6b,0x65,0x79,0x62,0x75,0x66,0x29,0x0a,0x7b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,
+    0x6e,0x74,0x20,0x63,0x3d,0x38,0x2c,0x69,0x3d,0x31,0x3b,0x20,0x63,0x3c,0x34,0x30,0x3b,0x20,0x2b,0x2b,0x63,0x29,0x20,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x74,0x3d,
+    0x28,0x28,0x21,0x28,0x63,0x26,0x37,0x29,0x29,0x7c,0x7c,0x28,0x28,0x63,0x26,0x37,0x29,0x3d,0x3d,0x34,0x29,0x29,0x3f,0x53,0x75,0x62,0x57,0x6f,0x72,0x64,0x28,0x6b,
+    0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x31,0x5d,0x29,0x3a,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x31,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,
+    0x63,0x5d,0x3d,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x38,0x5d,0x5e,0x28,0x28,0x21,0x28,0x63,0x26,0x37,0x29,0x29,0x3f,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,
+    0x74,0x2c,0x32,0x34,0x55,0x29,0x5e,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x28,0x28,0x75,0x63,0x68,0x61,0x72,0x34,0x29,0x28,0x72,0x63,0x6f,0x6e,0x5b,0x69,0x2b,0x2b,
+    0x5d,0x2c,0x30,0x55,0x2c,0x30,0x55,0x2c,0x30,0x55,0x29,0x29,0x3a,0x74,0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x23,0x69,0x66,0x6e,
+    0x64,0x65,0x66,0x20,0x58,0x4d,0x52,0x49,0x47,0x5f,0x4b,0x45,0x43,0x43,0x41,0x4b,0x5f,0x43,0x4c,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x58,0x4d,0x52,0x49,
+    0x47,0x5f,0x4b,0x45,0x43,0x43,0x41,0x4b,0x5f,0x43,0x4c,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,
+    0x61,0x6e,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,0x6e,0x64,0x63,0x5b,0x32,0x34,0x5d,0x20,0x3d,0x0a,0x7b,0x0a,0x30,
+    0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x31,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+    0x38,0x30,0x38,0x32,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x38,0x61,0x2c,0x0a,0x30,0x78,0x38,0x30,0x30,0x30,0x30,
+    0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x38,0x62,0x2c,0x30,
+    0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x31,0x2c,0x0a,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,
+    0x30,0x38,0x30,0x38,0x31,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x39,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x61,0x2c,0x0a,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x38,0x2c,
+    0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x30,0x39,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x61,0x2c,0x0a,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x38,0x62,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x62,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x38,0x39,0x2c,
+    0x0a,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x33,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+    0x30,0x30,0x38,0x30,0x30,0x32,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x2c,0x0a,0x30,0x78,0x30,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x61,0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x61,
+    0x2c,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x38,0x31,0x2c,0x0a,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,
+    0x30,0x30,0x30,0x38,0x30,0x38,0x30,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x31,0x2c,0x30,0x78,0x38,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x30,0x38,0x30,0x30,0x30,0x38,0x30,0x30,0x38,0x0a,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,
+    0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,0x6f,0x74,0x63,0x5b,0x32,0x34,0x5d,0x20,0x3d,
+    0x0a,0x7b,0x0a,0x31,0x2c,0x33,0x2c,0x36,0x2c,0x31,0x30,0x2c,0x31,0x35,0x2c,0x32,0x31,0x2c,0x32,0x38,0x2c,0x33,0x36,0x2c,0x34,0x35,0x2c,0x35,0x35,0x2c,0x32,0x2c,
+    0x31,0x34,0x2c,0x0a,0x32,0x37,0x2c,0x34,0x31,0x2c,0x35,0x36,0x2c,0x38,0x2c,0x32,0x35,0x2c,0x34,0x33,0x2c,0x36,0x32,0x2c,0x31,0x38,0x2c,0x33,0x39,0x2c,0x36,0x31,
+    0x2c,0x32,0x30,0x2c,0x34,0x34,0x0a,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,
+    0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x70,0x69,0x6c,0x6e,0x5b,0x32,0x34,0x5d,0x20,0x3d,0x0a,0x7b,0x0a,0x31,0x30,0x2c,0x37,
+    0x2c,0x31,0x31,0x2c,0x31,0x37,0x2c,0x31,0x38,0x2c,0x33,0x2c,0x35,0x2c,0x31,0x36,0x2c,0x38,0x2c,0x32,0x31,0x2c,0x32,0x34,0x2c,0x34,0x2c,0x0a,0x31,0x35,0x2c,0x32,
+    0x33,0x2c,0x31,0x39,0x2c,0x31,0x33,0x2c,0x31,0x32,0x2c,0x32,0x2c,0x32,0x30,0x2c,0x31,0x34,0x2c,0x32,0x32,0x2c,0x39,0x2c,0x36,0x2c,0x31,0x0a,0x7d,0x3b,0x0a,0x76,
+    0x6f,0x69,0x64,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x31,0x36,0x30,0x30,0x5f,0x31,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x73,0x74,0x29,0x0a,0x7b,0x0a,0x69,
+    0x6e,0x74,0x20,0x69,0x2c,0x72,0x6f,0x75,0x6e,0x64,0x3b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x2c,0x62,0x63,0x5b,0x35,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,
+    0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x72,0x6f,0x75,0x6e,0x64,0x3d,0x30,0x3b,0x20,0x72,0x6f,0x75,0x6e,0x64,0x3c,
+    0x32,0x34,0x3b,0x20,0x2b,0x2b,0x72,0x6f,0x75,0x6e,0x64,0x29,0x20,0x7b,0x0a,0x62,0x63,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x5b,0x30,0x5d,0x5e,0x73,0x74,0x5b,0x35,0x5d,
+    0x5e,0x73,0x74,0x5b,0x31,0x30,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x35,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x30,0x5d,0x3b,0x0a,0x62,0x63,0x5b,0x31,0x5d,0x3d,0x73,0x74,0x5b,
+    0x31,0x5d,0x5e,0x73,0x74,0x5b,0x36,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x31,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x36,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x31,0x5d,0x3b,0x0a,0x62,
+    0x63,0x5b,0x32,0x5d,0x3d,0x73,0x74,0x5b,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x37,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x37,0x5d,0x5e,0x73,
+    0x74,0x5b,0x32,0x32,0x5d,0x3b,0x0a,0x62,0x63,0x5b,0x33,0x5d,0x3d,0x73,0x74,0x5b,0x33,0x5d,0x5e,0x73,0x74,0x5b,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x33,0x5d,0x5e,
+    0x73,0x74,0x5b,0x31,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x33,0x5d,0x3b,0x0a,0x62,0x63,0x5b,0x34,0x5d,0x3d,0x73,0x74,0x5b,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x39,0x5d,
+    0x5e,0x73,0x74,0x5b,0x31,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x39,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x34,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,
+    0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x35,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x74,0x3d,
+    0x62,0x63,0x5b,0x28,0x69,0x2b,0x34,0x29,0x20,0x25,0x20,0x35,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x62,0x63,0x5b,0x28,0x69,0x2b,0x31,0x29,0x20,0x25,0x20,
+    0x35,0x5d,0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x20,0x5d,0x20,0x5e,0x3d,0x20,0x74,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x35,0x5d,0x20,0x5e,0x3d,
+    0x20,0x74,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x31,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x74,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x31,0x35,0x5d,0x20,0x5e,0x3d,0x20,0x74,
+    0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x32,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x74,0x3b,0x0a,0x7d,0x0a,0x74,0x3d,0x73,0x74,0x5b,0x31,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,
+    0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x32,0x34,0x3b,0x20,0x2b,0x2b,0x69,
+    0x29,0x20,0x7b,0x0a,0x62,0x63,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x5b,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x70,0x69,0x6c,0x6e,0x5b,0x69,0x5d,0x5d,0x3b,0x0a,0x73,
+    0x74,0x5b,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x70,0x69,0x6c,0x6e,0x5b,0x69,0x5d,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x2c,0x28,0x75,0x6c,0x6f,
+    0x6e,0x67,0x29,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,0x6f,0x74,0x63,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x74,0x3d,0x62,0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x7d,0x0a,
+    0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,
+    0x3c,0x32,0x35,0x3b,0x20,0x69,0x2b,0x3d,0x35,0x29,0x20,0x7b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x6d,0x70,0x5b,0x35,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,
+    0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x78,0x3d,0x30,0x3b,0x20,0x78,0x3c,0x35,0x3b,0x20,0x2b,
+    0x2b,0x78,0x29,0x20,0x7b,0x0a,0x74,0x6d,0x70,0x5b,0x78,0x5d,0x3d,0x62,0x69,0x74,0x73,0x65,0x6c,0x65,0x63,0x74,0x28,0x73,0x74,0x5b,0x69,0x2b,0x78,0x5d,0x5e,0x73,
+    0x74,0x5b,0x69,0x2b,0x28,0x28,0x78,0x2b,0x32,0x29,0x20,0x25,0x20,0x35,0x29,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x78,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x28,0x28,
+    0x78,0x2b,0x31,0x29,0x20,0x25,0x20,0x35,0x29,0x5d,0x29,0x3b,0x0a,0x7d,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,
+    0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x78,0x3d,0x30,0x3b,0x20,0x78,0x3c,0x35,0x3b,0x20,0x2b,0x2b,0x78,0x29,0x20,0x7b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x78,
+    0x5d,0x3d,0x74,0x6d,0x70,0x5b,0x78,0x5d,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x73,0x74,0x5b,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,
+    0x6e,0x64,0x63,0x5b,0x72,0x6f,0x75,0x6e,0x64,0x5d,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x76,0x6f,0x69,0x64,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x31,0x36,0x30,0x30,
+    0x5f,0x32,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x73,0x74,0x29,0x0a,0x7b,0x0a,0x69,0x6e,0x74,0x20,0x69,0x2c,0x72,0x6f,
+    0x75,0x6e,0x64,0x3b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x2c,0x62,0x63,0x5b,0x35,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,
+    0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x72,0x6f,0x75,0x6e,0x64,0x3d,0x30,0x3b,0x20,0x72,0x6f,0x75,0x6e,0x64,0x3c,0x32,0x34,0x3b,0x20,0x2b,0x2b,0x72,
+    0x6f,0x75,0x6e,0x64,0x29,0x20,0x7b,0x0a,0x62,0x63,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x5b,0x30,0x5d,0x5e,0x73,0x74,0x5b,0x35,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x30,0x5d,
+    0x5e,0x73,0x74,0x5b,0x31,0x35,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x30,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x73,0x74,0x5b,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x37,
+    0x5d,0x5e,0x73,0x74,0x5b,0x31,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x37,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x32,0x5d,0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x62,0x63,0x5b,
+    0x31,0x5d,0x3d,0x73,0x74,0x5b,0x31,0x5d,0x5e,0x73,0x74,0x5b,0x36,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x31,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x36,0x5d,0x5e,0x73,0x74,0x5b,
+    0x32,0x31,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x73,0x74,0x5b,0x33,0x5d,0x5e,0x73,0x74,0x5b,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x33,0x5d,0x5e,0x73,0x74,
+    0x5b,0x31,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x33,0x5d,0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x62,0x63,0x5b,0x32,0x5d,0x3d,0x73,0x74,0x5b,0x32,0x5d,0x5e,0x73,0x74,
+    0x5b,0x37,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x37,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x32,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,
+    0x73,0x74,0x5b,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x39,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x39,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x34,0x5d,
+    0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x62,0x63,0x5b,0x33,0x5d,0x3d,0x73,0x74,0x5b,0x33,0x5d,0x5e,0x73,0x74,0x5b,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x33,0x5d,0x5e,
+    0x73,0x74,0x5b,0x31,0x38,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x33,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x73,0x74,0x5b,0x30,0x5d,0x5e,0x73,0x74,0x5b,0x35,0x5d,
+    0x5e,0x73,0x74,0x5b,0x31,0x30,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x35,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x30,0x5d,0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x62,0x63,0x5b,0x34,
+    0x5d,0x3d,0x73,0x74,0x5b,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x39,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x34,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x39,0x5d,0x5e,0x73,0x74,0x5b,0x32,
+    0x34,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x73,0x74,0x5b,0x31,0x5d,0x5e,0x73,0x74,0x5b,0x36,0x5d,0x5e,0x73,0x74,0x5b,0x31,0x31,0x5d,0x5e,0x73,0x74,0x5b,
+    0x31,0x36,0x5d,0x5e,0x73,0x74,0x5b,0x32,0x31,0x5d,0x2c,0x31,0x55,0x4c,0x29,0x3b,0x0a,0x73,0x74,0x5b,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x34,0x5d,0x3b,
+    0x0a,0x73,0x74,0x5b,0x35,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x34,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x34,0x5d,
+    0x3b,0x0a,0x73,0x74,0x5b,0x31,0x35,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x34,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x32,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,
+    0x34,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x36,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,
+    0x30,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x31,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x36,0x5d,0x20,0x5e,0x3d,0x20,0x62,
+    0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x32,0x31,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x32,0x5d,0x20,0x5e,0x3d,0x20,
+    0x62,0x63,0x5b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x37,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x32,0x5d,0x20,0x5e,0x3d,
+    0x20,0x62,0x63,0x5b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x37,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x32,0x32,0x5d,0x20,
+    0x5e,0x3d,0x20,0x62,0x63,0x5b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x33,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x32,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x38,0x5d,0x20,
+    0x5e,0x3d,0x20,0x62,0x63,0x5b,0x32,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x33,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x32,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x38,
+    0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x32,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x32,0x33,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x32,0x5d,0x3b,0x0a,0x73,0x74,0x5b,
+    0x34,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x33,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x39,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x33,0x5d,0x3b,0x0a,0x73,0x74,0x5b,
+    0x31,0x34,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x33,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x31,0x39,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x33,0x5d,0x3b,0x0a,0x73,
+    0x74,0x5b,0x32,0x34,0x5d,0x20,0x5e,0x3d,0x20,0x62,0x63,0x5b,0x33,0x5d,0x3b,0x0a,0x74,0x3d,0x73,0x74,0x5b,0x31,0x5d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,
+    0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x32,0x34,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,
+    0x0a,0x62,0x63,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x5b,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x70,0x69,0x6c,0x6e,0x5b,0x69,0x5d,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x6b,
+    0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x70,0x69,0x6c,0x6e,0x5b,0x69,0x5d,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x2c,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x29,
+    0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,0x6f,0x74,0x63,0x5b,0x69,0x5d,0x29,0x3b,0x0a,0x74,0x3d,0x62,0x63,0x5b,0x30,0x5d,0x3b,0x0a,0x7d,0x0a,0x23,0x70,0x72,
+    0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x32,0x35,
+    0x3b,0x20,0x69,0x2b,0x3d,0x35,0x29,0x20,0x7b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x74,0x6d,0x70,0x31,0x3d,0x73,0x74,0x5b,0x69,0x5d,0x2c,0x74,0x6d,0x70,0x32,0x3d,
+    0x73,0x74,0x5b,0x69,0x2b,0x31,0x5d,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x5d,0x3d,0x62,0x69,0x74,0x73,0x65,0x6c,0x65,0x63,0x74,0x28,0x73,0x74,0x5b,0x69,0x5d,0x5e,0x73,
+    0x74,0x5b,0x69,0x2b,0x32,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x31,0x5d,0x29,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x31,0x5d,0x3d,0x62,
+    0x69,0x74,0x73,0x65,0x6c,0x65,0x63,0x74,0x28,0x73,0x74,0x5b,0x69,0x2b,0x31,0x5d,0x5e,0x73,0x74,0x5b,0x69,0x2b,0x33,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x31,0x5d,
+    0x2c,0x73,0x74,0x5b,0x69,0x2b,0x32,0x5d,0x29,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x32,0x5d,0x3d,0x62,0x69,0x74,0x73,0x65,0x6c,0x65,0x63,0x74,0x28,0x73,0x74,0x5b,
+    0x69,0x2b,0x32,0x5d,0x5e,0x73,0x74,0x5b,0x69,0x2b,0x34,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x32,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x33,0x5d,0x29,0x3b,0x0a,0x73,
+    0x74,0x5b,0x69,0x2b,0x33,0x5d,0x3d,0x62,0x69,0x74,0x73,0x65,0x6c,0x65,0x63,0x74,0x28,0x73,0x74,0x5b,0x69,0x2b,0x33,0x5d,0x5e,0x74,0x6d,0x70,0x31,0x2c,0x73,0x74,
+    0x5b,0x69,0x2b,0x33,0x5d,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x34,0x5d,0x29,0x3b,0x0a,0x73,0x74,0x5b,0x69,0x2b,0x34,0x5d,0x3d,0x62,0x69,0x74,0x73,0x65,0x6c,0x65,0x63,
+    0x74,0x28,0x73,0x74,0x5b,0x69,0x2b,0x34,0x5d,0x5e,0x74,0x6d,0x70,0x32,0x2c,0x73,0x74,0x5b,0x69,0x2b,0x34,0x5d,0x2c,0x74,0x6d,0x70,0x31,0x29,0x3b,0x0a,0x7d,0x0a,
+    0x73,0x74,0x5b,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x5f,0x72,0x6e,0x64,0x63,0x5b,0x72,0x6f,0x75,0x6e,0x64,0x5d,0x3b,0x0a,0x7d,0x0a,
+    0x7d,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x75,0x69,0x6e,0x74,0x20,0x67,0x65,0x74,0x49,0x64,0x78,0x28,0x29,0x0a,0x7b,0x0a,
+    0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x2d,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,
+    0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,0x28,0x30,0x29,0x3b,0x0a,0x7d,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x49,0x44,0x58,0x28,0x78,0x29,0x20,0x28,
+    0x78,0x29,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,
+    0x74,0x34,0x20,0x61,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x2b,0x62,0x3b,0x0a,0x7d,0x0a,0x69,
+    0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x73,0x75,0x62,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,
+    0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x2d,0x62,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,
+    0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,0x2c,0x66,0x6c,0x6f,
+    0x61,0x74,0x34,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x2a,0x62,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,
+    0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x64,0x69,0x76,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,
+    0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x2f,0x62,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,
+    0x20,0x5f,0x6d,0x6d,0x5f,0x61,0x6e,0x64,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,0x2c,0x69,0x6e,0x74,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,
+    0x74,0x75,0x72,0x6e,0x20,0x61,0x73,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x28,0x61,0x73,0x5f,0x69,0x6e,0x74,0x34,0x28,0x61,0x29,0x26,0x28,0x69,0x6e,0x74,0x34,0x29,
+    0x28,0x62,0x29,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x6f,0x72,0x5f,0x70,0x73,0x28,
+    0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,0x2c,0x69,0x6e,0x74,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x73,0x5f,0x66,0x6c,0x6f,0x61,
+    0x74,0x34,0x28,0x61,0x73,0x5f,0x69,0x6e,0x74,0x34,0x28,0x61,0x29,0x7c,0x28,0x69,0x6e,0x74,0x34,0x29,0x28,0x62,0x29,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,
+    0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x66,0x6d,0x6f,0x64,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x76,0x2c,0x66,
+    0x6c,0x6f,0x61,0x74,0x20,0x64,0x63,0x29,0x0a,0x7b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x64,0x3d,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x64,0x63,0x29,
+    0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x3d,0x5f,0x6d,0x6d,0x5f,0x64,0x69,0x76,0x5f,0x70,0x73,0x28,0x76,0x2c,0x64,0x29,0x3b,0x0a,0x63,0x3d,0x74,0x72,
+    0x75,0x6e,0x63,0x28,0x63,0x29,0x3b,0x0a,0x63,0x3d,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x63,0x2c,0x64,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,
+    0x6e,0x20,0x5f,0x6d,0x6d,0x5f,0x73,0x75,0x62,0x5f,0x70,0x73,0x28,0x76,0x2c,0x63,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x69,0x6e,0x74,0x34,
+    0x20,0x5f,0x6d,0x6d,0x5f,0x78,0x6f,0x72,0x5f,0x73,0x69,0x31,0x32,0x38,0x28,0x69,0x6e,0x74,0x34,0x20,0x61,0x2c,0x69,0x6e,0x74,0x34,0x20,0x62,0x29,0x0a,0x7b,0x0a,
+    0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x61,0x5e,0x62,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,
+    0x78,0x6f,0x72,0x5f,0x70,0x73,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x61,0x2c,0x69,0x6e,0x74,0x20,0x62,0x29,0x0a,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,
+    0x61,0x73,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x28,0x61,0x73,0x5f,0x69,0x6e,0x74,0x34,0x28,0x61,0x29,0x5e,0x28,0x69,0x6e,0x74,0x34,0x29,0x28,0x62,0x29,0x29,0x3b,
+    0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x69,0x6e,0x74,0x34,0x20,0x5f,0x6d,0x6d,0x5f,0x61,0x6c,0x69,0x67,0x6e,0x72,0x5f,0x65,0x70,0x69,0x38,0x28,0x69,
+    0x6e,0x74,0x34,0x20,0x61,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x6f,0x74,0x29,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,
+    0x6e,0x74,0x20,0x72,0x69,0x67,0x68,0x74,0x3d,0x38,0x2a,0x72,0x6f,0x74,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6c,0x65,0x66,0x74,0x3d,
+    0x28,0x33,0x32,0x2d,0x38,0x2a,0x72,0x6f,0x74,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x69,0x6e,0x74,0x34,0x29,0x28,0x0a,0x28,0x28,0x75,0x69,0x6e,
+    0x74,0x29,0x61,0x2e,0x78,0x3e,0x3e,0x72,0x69,0x67,0x68,0x74,0x29,0x7c,0x28,0x20,0x61,0x2e,0x79,0x3c,0x3c,0x6c,0x65,0x66,0x74,0x20,0x29,0x2c,0x0a,0x28,0x28,0x75,
+    0x69,0x6e,0x74,0x29,0x61,0x2e,0x79,0x3e,0x3e,0x72,0x69,0x67,0x68,0x74,0x29,0x7c,0x28,0x20,0x61,0x2e,0x7a,0x3c,0x3c,0x6c,0x65,0x66,0x74,0x20,0x29,0x2c,0x0a,0x28,
+    0x28,0x75,0x69,0x6e,0x74,0x29,0x61,0x2e,0x7a,0x3e,0x3e,0x72,0x69,0x67,0x68,0x74,0x29,0x7c,0x28,0x20,0x61,0x2e,0x77,0x3c,0x3c,0x6c,0x65,0x66,0x74,0x20,0x29,0x2c,
+    0x0a,0x28,0x28,0x75,0x69,0x6e,0x74,0x29,0x61,0x2e,0x77,0x3e,0x3e,0x72,0x69,0x67,0x68,0x74,0x29,0x7c,0x28,0x20,0x61,0x2e,0x78,0x3c,0x3c,0x6c,0x65,0x66,0x74,0x20,
+    0x29,0x0a,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x34,0x2a,0x20,0x73,0x63,0x72,0x61,0x74,
+    0x63,0x68,0x70,0x61,0x64,0x5f,0x70,0x74,0x72,0x28,0x75,0x69,0x6e,0x74,0x20,0x69,0x64,0x78,0x2c,0x75,0x69,0x6e,0x74,0x20,0x6e,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,
+    0x61,0x6c,0x20,0x69,0x6e,0x74,0x20,0x2a,0x6c,0x70,0x61,0x64,0x29,0x20,0x7b,0x20,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,
+    0x20,0x69,0x6e,0x74,0x34,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x63,0x68,0x61,0x72,0x2a,0x29,0x6c,0x70,0x61,0x64,0x2b,0x28,0x69,0x64,
+    0x78,0x26,0x4d,0x41,0x53,0x4b,0x29,0x2b,0x6e,0x2a,0x31,0x36,0x29,0x3b,0x20,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x66,
+    0x6d,0x61,0x5f,0x62,0x72,0x65,0x61,0x6b,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x78,0x29,0x0a,0x7b,0x0a,0x78,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x6e,0x64,0x5f,0x70,
+    0x73,0x28,0x78,0x2c,0x30,0x78,0x46,0x45,0x46,0x46,0x46,0x46,0x46,0x46,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x5f,0x6d,0x6d,0x5f,0x6f,0x72,0x5f,0x70,
+    0x73,0x28,0x78,0x2c,0x30,0x78,0x30,0x30,0x38,0x30,0x30,0x30,0x30,0x30,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x76,0x6f,0x69,0x64,0x20,0x73,
+    0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x30,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x31,0x2c,0x66,0x6c,0x6f,
+    0x61,0x74,0x34,0x20,0x6e,0x32,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x33,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x66,0x6c,
+    0x6f,0x61,0x74,0x34,0x2a,0x20,0x6e,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,0x64,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,0x63,0x29,0x0a,0x7b,0x0a,0x6e,
+    0x31,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x6e,0x31,0x2c,0x2a,0x63,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x6e,0x3d,0x5f,
+    0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x6e,0x30,0x2c,0x2a,0x63,0x29,0x3b,0x0a,0x6e,0x6e,0x3d,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,
+    0x6e,0x31,0x2c,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x6e,0x6e,0x2c,0x6e,0x6e,0x29,0x29,0x3b,0x0a,0x6e,0x6e,0x3d,0x66,0x6d,0x61,0x5f,0x62,0x72,
+    0x65,0x61,0x6b,0x28,0x6e,0x6e,0x29,0x3b,0x0a,0x2a,0x6e,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x2a,0x6e,0x2c,0x6e,0x6e,0x29,0x3b,0x0a,0x6e,
+    0x33,0x3d,0x5f,0x6d,0x6d,0x5f,0x73,0x75,0x62,0x5f,0x70,0x73,0x28,0x6e,0x33,0x2c,0x2a,0x63,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x64,0x64,0x3d,0x5f,
+    0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x6e,0x32,0x2c,0x2a,0x63,0x29,0x3b,0x0a,0x64,0x64,0x3d,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,
+    0x6e,0x33,0x2c,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,0x70,0x73,0x28,0x64,0x64,0x2c,0x64,0x64,0x29,0x29,0x3b,0x0a,0x64,0x64,0x3d,0x66,0x6d,0x61,0x5f,0x62,0x72,
+    0x65,0x61,0x6b,0x28,0x64,0x64,0x29,0x3b,0x0a,0x2a,0x64,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x2a,0x64,0x2c,0x64,0x64,0x29,0x3b,0x0a,0x2a,
+    0x63,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x2a,0x63,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x29,0x3b,0x0a,0x2a,0x63,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,
+    0x64,0x64,0x5f,0x70,0x73,0x28,0x2a,0x63,0x2c,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x30,0x2e,0x37,0x33,0x34,0x33,0x37,0x35,0x66,0x29,0x29,0x3b,0x0a,0x66,
+    0x6c,0x6f,0x61,0x74,0x34,0x20,0x72,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x6e,0x6e,0x2c,0x64,0x64,0x29,0x3b,0x0a,0x72,0x3d,0x5f,0x6d,0x6d,
+    0x5f,0x61,0x6e,0x64,0x5f,0x70,0x73,0x28,0x72,0x2c,0x30,0x78,0x38,0x30,0x37,0x46,0x46,0x46,0x46,0x46,0x29,0x3b,0x0a,0x72,0x3d,0x5f,0x6d,0x6d,0x5f,0x6f,0x72,0x5f,
+    0x70,0x73,0x28,0x72,0x2c,0x30,0x78,0x34,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x29,0x3b,0x0a,0x2a,0x63,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,
+    0x2a,0x63,0x2c,0x72,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x76,0x6f,0x69,0x64,0x20,0x72,0x6f,0x75,0x6e,0x64,0x5f,0x63,0x6f,0x6d,0x70,0x75,
+    0x74,0x65,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x30,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x31,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x32,
+    0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x33,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,
+    0x63,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,0x72,0x29,0x0a,0x7b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x3d,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,
+    0x28,0x30,0x2e,0x30,0x66,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x64,0x3d,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x30,0x2e,0x30,0x66,0x29,0x3b,
+    0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x30,0x2c,0x6e,0x31,0x2c,0x6e,0x32,0x2c,0x6e,0x33,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,
+    0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x31,0x2c,0x6e,0x32,0x2c,0x6e,0x33,0x2c,0x6e,0x30,0x2c,0x72,0x6e,0x64,
+    0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x32,0x2c,0x6e,0x33,0x2c,0x6e,0x30,0x2c,
+    0x6e,0x31,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x33,0x2c,
+    0x6e,0x30,0x2c,0x6e,0x31,0x2c,0x6e,0x32,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,
+    0x6e,0x64,0x28,0x6e,0x33,0x2c,0x6e,0x32,0x2c,0x6e,0x31,0x2c,0x6e,0x30,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,
+    0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x32,0x2c,0x6e,0x31,0x2c,0x6e,0x30,0x2c,0x6e,0x33,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,
+    0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x31,0x2c,0x6e,0x30,0x2c,0x6e,0x33,0x2c,0x6e,0x32,0x2c,0x72,0x6e,0x64,0x5f,0x63,
+    0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x73,0x75,0x62,0x5f,0x72,0x6f,0x75,0x6e,0x64,0x28,0x6e,0x30,0x2c,0x6e,0x33,0x2c,0x6e,0x32,0x2c,0x6e,0x31,
+    0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x6e,0x2c,0x26,0x64,0x2c,0x63,0x29,0x3b,0x0a,0x64,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x6e,0x64,0x5f,0x70,0x73,0x28,0x64,0x2c,
+    0x30,0x78,0x46,0x46,0x37,0x46,0x46,0x46,0x46,0x46,0x29,0x3b,0x0a,0x64,0x3d,0x5f,0x6d,0x6d,0x5f,0x6f,0x72,0x5f,0x70,0x73,0x28,0x64,0x2c,0x30,0x78,0x34,0x30,0x30,
+    0x30,0x30,0x30,0x30,0x30,0x29,0x3b,0x0a,0x2a,0x72,0x20,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x64,0x64,0x5f,0x70,0x73,0x28,0x2a,0x72,0x2c,0x5f,0x6d,0x6d,0x5f,0x64,0x69,
+    0x76,0x5f,0x70,0x73,0x28,0x6e,0x2c,0x64,0x29,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x69,0x6e,0x74,0x34,0x20,0x73,0x69,0x6e,0x67,0x6c,0x65,
+    0x5f,0x63,0x6f,0x6d,0x75,0x70,0x74,0x65,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x30,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x31,0x2c,0x66,0x6c,0x6f,
+    0x61,0x74,0x34,0x20,0x6e,0x32,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x33,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x20,0x63,0x6e,0x74,0x2c,0x66,0x6c,0x6f,0x61,0x74,
+    0x34,0x20,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,0x73,0x75,0x6d,0x29,0x0a,0x7b,0x0a,0x66,
+    0x6c,0x6f,0x61,0x74,0x34,0x20,0x63,0x3d,0x20,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x63,0x6e,0x74,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x72,
+    0x3d,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x30,0x2e,0x30,0x66,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,
+    0x3c,0x34,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x72,0x6f,0x75,0x6e,0x64,0x5f,0x63,0x6f,0x6d,0x70,0x75,0x74,0x65,0x28,0x6e,0x30,0x2c,0x6e,0x31,0x2c,0x6e,
+    0x32,0x2c,0x6e,0x33,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x26,0x63,0x2c,0x26,0x72,0x29,0x3b,0x0a,0x7d,0x0a,0x72,0x3d,0x5f,0x6d,0x6d,0x5f,0x61,0x6e,0x64,0x5f,0x70,
+    0x73,0x28,0x72,0x2c,0x30,0x78,0x38,0x30,0x37,0x46,0x46,0x46,0x46,0x46,0x29,0x3b,0x0a,0x72,0x3d,0x5f,0x6d,0x6d,0x5f,0x6f,0x72,0x5f,0x70,0x73,0x28,0x72,0x2c,0x30,
+    0x78,0x34,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x29,0x3b,0x0a,0x2a,0x73,0x75,0x6d,0x3d,0x72,0x3b,0x20,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x78,0x3d,0x28,0x66,
+    0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x35,0x33,0x36,0x38,0x37,0x30,0x38,0x38,0x30,0x2e,0x30,0x66,0x29,0x3b,0x0a,0x72,0x3d,0x5f,0x6d,0x6d,0x5f,0x6d,0x75,0x6c,0x5f,
+    0x70,0x73,0x28,0x72,0x2c,0x78,0x29,0x3b,0x20,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x63,0x6f,0x6e,0x76,0x65,0x72,0x74,0x5f,0x69,0x6e,0x74,0x34,0x5f,0x72,0x74,
+    0x65,0x28,0x72,0x29,0x3b,0x0a,0x7d,0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x76,0x6f,0x69,0x64,0x20,0x73,0x69,0x6e,0x67,0x6c,0x65,0x5f,0x63,0x6f,0x6d,0x75,0x70,
+    0x74,0x65,0x5f,0x77,0x72,0x61,0x70,0x28,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x6f,0x74,0x2c,0x69,0x6e,0x74,0x34,0x20,0x76,0x30,0x2c,0x69,
+    0x6e,0x74,0x34,0x20,0x76,0x31,0x2c,0x69,0x6e,0x74,0x34,0x20,0x76,0x32,0x2c,0x69,0x6e,0x74,0x34,0x20,0x76,0x33,0x2c,0x66,0x6c,0x6f,0x61,0x74,0x20,0x63,0x6e,0x74,
+    0x2c,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x34,0x2a,0x20,0x73,0x75,
+    0x6d,0x2c,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x34,0x2a,0x20,0x6f,0x75,0x74,0x29,0x0a,0x7b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x6e,0x30,
+    0x3d,0x63,0x6f,0x6e,0x76,0x65,0x72,0x74,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x5f,0x72,0x74,0x65,0x28,0x76,0x30,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,
+    0x6e,0x31,0x3d,0x63,0x6f,0x6e,0x76,0x65,0x72,0x74,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x5f,0x72,0x74,0x65,0x28,0x76,0x31,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,
+    0x34,0x20,0x6e,0x32,0x3d,0x63,0x6f,0x6e,0x76,0x65,0x72,0x74,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x5f,0x72,0x74,0x65,0x28,0x76,0x32,0x29,0x3b,0x0a,0x66,0x6c,0x6f,
+    0x61,0x74,0x34,0x20,0x6e,0x33,0x3d,0x63,0x6f,0x6e,0x76,0x65,0x72,0x74,0x5f,0x66,0x6c,0x6f,0x61,0x74,0x34,0x5f,0x72,0x74,0x65,0x28,0x76,0x33,0x29,0x3b,0x0a,0x69,
+    0x6e,0x74,0x34,0x20,0x72,0x3d,0x73,0x69,0x6e,0x67,0x6c,0x65,0x5f,0x63,0x6f,0x6d,0x75,0x70,0x74,0x65,0x28,0x6e,0x30,0x2c,0x6e,0x31,0x2c,0x6e,0x32,0x2c,0x6e,0x33,
+    0x2c,0x63,0x6e,0x74,0x2c,0x72,0x6e,0x64,0x5f,0x63,0x2c,0x73,0x75,0x6d,0x29,0x3b,0x0a,0x2a,0x6f,0x75,0x74,0x3d,0x72,0x6f,0x74,0x3d,0x3d,0x30,0x3f,0x72,0x3a,0x5f,
+    0x6d,0x6d,0x5f,0x61,0x6c,0x69,0x67,0x6e,0x72,0x5f,0x65,0x70,0x69,0x38,0x28,0x72,0x2c,0x72,0x6f,0x74,0x29,0x3b,0x0a,0x7d,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,
+    0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6c,0x6f,0x6f,0x6b,0x5b,0x31,0x36,0x5d,0x5b,0x34,
+    0x5d,0x3d,0x7b,0x0a,0x7b,0x30,0x2c,0x31,0x2c,0x32,0x2c,0x33,0x7d,0x2c,0x0a,0x7b,0x30,0x2c,0x32,0x2c,0x33,0x2c,0x31,0x7d,0x2c,0x0a,0x7b,0x30,0x2c,0x33,0x2c,0x31,
+    0x2c,0x32,0x7d,0x2c,0x0a,0x7b,0x30,0x2c,0x33,0x2c,0x32,0x2c,0x31,0x7d,0x2c,0x0a,0x7b,0x31,0x2c,0x30,0x2c,0x32,0x2c,0x33,0x7d,0x2c,0x0a,0x7b,0x31,0x2c,0x32,0x2c,
+    0x33,0x2c,0x30,0x7d,0x2c,0x0a,0x7b,0x31,0x2c,0x33,0x2c,0x30,0x2c,0x32,0x7d,0x2c,0x0a,0x7b,0x31,0x2c,0x33,0x2c,0x32,0x2c,0x30,0x7d,0x2c,0x0a,0x7b,0x32,0x2c,0x31,
+    0x2c,0x30,0x2c,0x33,0x7d,0x2c,0x0a,0x7b,0x32,0x2c,0x30,0x2c,0x33,0x2c,0x31,0x7d,0x2c,0x0a,0x7b,0x32,0x2c,0x33,0x2c,0x31,0x2c,0x30,0x7d,0x2c,0x0a,0x7b,0x32,0x2c,
+    0x33,0x2c,0x30,0x2c,0x31,0x7d,0x2c,0x0a,0x7b,0x33,0x2c,0x31,0x2c,0x32,0x2c,0x30,0x7d,0x2c,0x0a,0x7b,0x33,0x2c,0x32,0x2c,0x30,0x2c,0x31,0x7d,0x2c,0x0a,0x7b,0x33,
+    0x2c,0x30,0x2c,0x31,0x2c,0x32,0x7d,0x2c,0x0a,0x7b,0x33,0x2c,0x30,0x2c,0x32,0x2c,0x31,0x7d,0x0a,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,
+    0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x66,0x6c,0x6f,0x61,0x74,0x20,0x63,0x63,0x6e,0x74,0x5b,0x31,0x36,0x5d,0x3d,0x7b,0x0a,0x31,
+    0x2e,0x33,0x34,0x33,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x32,0x38,0x31,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x33,0x35,0x39,0x33,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,
+    0x33,0x36,0x37,0x31,0x38,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x34,0x32,0x39,0x36,0x38,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x33,0x39,0x38,0x34,0x33,0x37,0x35,0x66,
+    0x2c,0x0a,0x31,0x2e,0x33,0x38,0x32,0x38,0x31,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x33,0x30,0x34,0x36,0x38,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x34,0x31,0x34,0x30,
+    0x36,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x32,0x37,0x33,0x34,0x33,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x32,0x35,0x37,0x38,0x31,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,
+    0x32,0x38,0x39,0x30,0x36,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x33,0x32,0x30,0x33,0x31,0x32,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x33,0x35,0x31,0x35,0x36,0x32,0x35,0x66,
+    0x2c,0x0a,0x31,0x2e,0x33,0x33,0x35,0x39,0x33,0x37,0x35,0x66,0x2c,0x0a,0x31,0x2e,0x34,0x36,0x30,0x39,0x33,0x37,0x35,0x66,0x0a,0x7d,0x3b,0x0a,0x73,0x74,0x72,0x75,
+    0x63,0x74,0x20,0x53,0x68,0x61,0x72,0x65,0x64,0x4d,0x65,0x6d,0x43,0x68,0x75,0x6e,0x6b,0x0a,0x7b,0x0a,0x69,0x6e,0x74,0x34,0x20,0x6f,0x75,0x74,0x5b,0x31,0x36,0x5d,
+    0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x76,0x61,0x5b,0x31,0x36,0x5d,0x3b,0x0a,0x7d,0x3b,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x5f,
+    0x5f,0x28,0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,
+    0x2a,0x31,0x36,0x2c,0x31,0x2c,0x31,0x29,0x29,0x29,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,0x63,0x6e,0x31,0x28,0x5f,0x5f,0x67,
+    0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x20,0x2a,0x6c,0x70,0x61,0x64,0x5f,0x69,0x6e,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x20,
+    0x2a,0x73,0x70,0x61,0x64,0x2c,0x75,0x69,0x6e,0x74,0x20,0x6e,0x75,0x6d,0x54,0x68,0x72,0x65,0x61,0x64,0x73,0x29,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,
+    0x69,0x6e,0x74,0x20,0x67,0x49,0x64,0x78,0x3d,0x67,0x65,0x74,0x49,0x64,0x78,0x28,0x29,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x63,0x68,0x75,0x6e,0x6b,0x3d,0x67,0x65,
+    0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x2f,0x31,0x36,0x3b,0x0a,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x20,
+    0x6c,0x70,0x61,0x64,0x3d,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x63,
+    0x68,0x61,0x72,0x2a,0x29,0x6c,0x70,0x61,0x64,0x5f,0x69,0x6e,0x2b,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x2a,0x28,0x67,0x49,0x64,0x78,0x2f,0x31,0x36,0x29,0x29,0x3b,0x0a,
+    0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x20,0x53,0x68,0x61,0x72,0x65,0x64,0x4d,0x65,0x6d,0x43,0x68,0x75,0x6e,0x6b,0x20,0x73,0x6d,
+    0x65,0x6d,0x5f,0x69,0x6e,0x5b,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x73,0x74,0x72,0x75,0x63,0x74,0x20,
+    0x53,0x68,0x61,0x72,0x65,0x64,0x4d,0x65,0x6d,0x43,0x68,0x75,0x6e,0x6b,0x2a,0x20,0x73,0x6d,0x65,0x6d,0x3d,0x73,0x6d,0x65,0x6d,0x5f,0x69,0x6e,0x2b,0x63,0x68,0x75,
+    0x6e,0x6b,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x74,0x69,0x64,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x20,0x25,0x20,0x31,
+    0x36,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x69,0x64,0x78,0x48,0x61,0x73,0x68,0x3d,0x67,0x49,0x64,0x78,0x2f,0x31,0x36,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x73,0x3d,
+    0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x2a,0x29,0x73,0x70,0x61,0x64,0x29,0x5b,0x69,0x64,0x78,0x48,0x61,0x73,0x68,0x2a,0x35,
+    0x30,0x5d,0x3e,0x3e,0x38,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x34,0x20,0x76,0x73,0x3d,0x28,0x66,0x6c,0x6f,0x61,0x74,0x34,0x29,0x28,0x30,0x29,0x3b,0x0a,0x63,0x6f,
+    0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x74,0x69,0x64,0x64,0x3d,0x74,0x69,0x64,0x2f,0x34,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,
+    0x74,0x69,0x64,0x6d,0x3d,0x74,0x69,0x64,0x20,0x25,0x20,0x34,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x62,0x6c,0x6f,0x63,0x6b,0x3d,0x74,
+    0x69,0x64,0x64,0x2a,0x31,0x36,0x2b,0x74,0x69,0x64,0x6d,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x43,0x4e,0x5f,0x55,
+    0x4e,0x52,0x4f,0x4c,0x4c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x49,0x54,0x45,0x52,0x41,0x54,0x49,0x4f,0x4e,
+    0x53,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x20,0x7b,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,
+    0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x69,0x6e,0x74,0x20,0x74,0x6d,0x70,0x3d,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,
+    0x2a,0x29,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x70,0x74,0x72,0x28,0x73,0x2c,0x74,0x69,0x64,0x64,0x2c,0x6c,0x70,0x61,0x64,0x29,0x29,0x5b,0x74,
+    0x69,0x64,0x6d,0x5d,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x28,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,
+    0x29,0x5b,0x74,0x69,0x64,0x5d,0x3d,0x74,0x6d,0x70,0x3b,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,
+    0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x7b,0x0a,0x73,0x69,0x6e,0x67,0x6c,0x65,0x5f,0x63,0x6f,0x6d,0x75,0x70,0x74,0x65,0x5f,0x77,0x72,0x61,
+    0x70,0x28,0x0a,0x74,0x69,0x64,0x6d,0x2c,0x0a,0x2a,0x28,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x2b,0x6c,0x6f,0x6f,0x6b,0x5b,0x74,0x69,0x64,0x5d,0x5b,0x30,
+    0x5d,0x29,0x2c,0x0a,0x2a,0x28,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x2b,0x6c,0x6f,0x6f,0x6b,0x5b,0x74,0x69,0x64,0x5d,0x5b,0x31,0x5d,0x29,0x2c,0x0a,0x2a,
+    0x28,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x2b,0x6c,0x6f,0x6f,0x6b,0x5b,0x74,0x69,0x64,0x5d,0x5b,0x32,0x5d,0x29,0x2c,0x0a,0x2a,0x28,0x73,0x6d,0x65,0x6d,
+    0x2d,0x3e,0x6f,0x75,0x74,0x2b,0x6c,0x6f,0x6f,0x6b,0x5b,0x74,0x69,0x64,0x5d,0x5b,0x33,0x5d,0x29,0x2c,0x0a,0x63,0x63,0x6e,0x74,0x5b,0x74,0x69,0x64,0x5d,0x2c,0x76,
+    0x73,0x2c,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x2b,0x74,0x69,0x64,0x2c,0x0a,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x2b,0x74,0x69,0x64,0x0a,0x29,0x3b,
+    0x0a,0x7d,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,
+    0x29,0x3b,0x0a,0x69,0x6e,0x74,0x20,0x6f,0x75,0x74,0x58,0x6f,0x72,0x3d,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,
+    0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x5d,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x20,0x64,0x64,0x3d,0x62,0x6c,0x6f,
+    0x63,0x6b,0x2b,0x34,0x3b,0x20,0x64,0x64,0x3c,0x28,0x74,0x69,0x64,0x64,0x2b,0x31,0x29,0x2a,0x31,0x36,0x3b,0x20,0x64,0x64,0x2b,0x3d,0x34,0x29,0x20,0x7b,0x0a,0x6f,
+    0x75,0x74,0x58,0x6f,0x72,0x20,0x5e,0x3d,0x20,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,
+    0x74,0x29,0x5b,0x64,0x64,0x5d,0x3b,0x0a,0x7d,0x0a,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x63,0x72,0x61,0x74,0x63,
+    0x68,0x70,0x61,0x64,0x5f,0x70,0x74,0x72,0x28,0x73,0x2c,0x74,0x69,0x64,0x64,0x2c,0x6c,0x70,0x61,0x64,0x29,0x29,0x5b,0x74,0x69,0x64,0x6d,0x5d,0x3d,0x6f,0x75,0x74,
+    0x58,0x6f,0x72,0x5e,0x74,0x6d,0x70,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,
+    0x74,0x29,0x5b,0x74,0x69,0x64,0x5d,0x3d,0x6f,0x75,0x74,0x58,0x6f,0x72,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x20,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x3d,0x28,0x28,
+    0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x5d,0x2b,
+    0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,
+    0x2b,0x34,0x5d,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x20,0x76,0x61,0x5f,0x74,0x6d,0x70,0x32,0x3d,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,
+    0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x2b,0x20,0x38,0x5d,0x2b,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,
+    0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x2b,0x31,0x32,0x5d,0x3b,0x0a,0x28,0x28,
+    0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x74,0x69,0x64,0x5d,0x3d,0x76,0x61,
+    0x5f,0x74,0x6d,0x70,0x31,0x2b,0x76,0x61,0x5f,0x74,0x6d,0x70,0x32,0x3b,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,
+    0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x69,0x6e,0x74,0x20,0x6f,0x75,0x74,0x32,0x3d,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,
+    0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x74,0x69,0x64,0x5d,0x5e,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,
+    0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x74,0x69,0x64,0x2b,0x34,0x20,0x5d,0x5e,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x74,0x69,0x64,0x2b,0x38,0x5d,0x5e,0x28,0x28,0x5f,0x5f,0x6c,0x6f,
+    0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x74,0x69,0x64,0x2b,0x31,0x32,0x5d,0x3b,0x0a,0x76,0x61,0x5f,
+    0x74,0x6d,0x70,0x31,0x3d,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,
+    0x62,0x6c,0x6f,0x63,0x6b,0x5d,0x2b,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,
+    0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x2b,0x34,0x5d,0x3b,0x0a,0x76,0x61,0x5f,0x74,0x6d,0x70,0x32,0x3d,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,
+    0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x2b,0x38,0x5d,0x2b,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,
+    0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x62,0x6c,0x6f,0x63,0x6b,0x2b,0x31,0x32,0x5d,0x3b,0x0a,0x76,0x61,
+    0x5f,0x74,0x6d,0x70,0x31,0x3d,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x2b,0x76,0x61,0x5f,0x74,0x6d,0x70,0x32,0x3b,0x0a,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x3d,0x66,
+    0x61,0x62,0x73,0x28,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x29,0x3b,0x0a,0x66,0x6c,0x6f,0x61,0x74,0x20,0x78,0x78,0x3d,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x2a,0x31,
+    0x36,0x37,0x37,0x37,0x32,0x31,0x36,0x2e,0x30,0x66,0x3b,0x0a,0x69,0x6e,0x74,0x20,0x78,0x78,0x5f,0x69,0x6e,0x74,0x3d,0x28,0x69,0x6e,0x74,0x29,0x78,0x78,0x3b,0x0a,
+    0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x29,0x5b,0x74,0x69,0x64,0x5d,0x3d,0x6f,
+    0x75,0x74,0x32,0x5e,0x78,0x78,0x5f,0x69,0x6e,0x74,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x66,0x6c,0x6f,0x61,0x74,0x2a,0x29,0x73,0x6d,0x65,
+    0x6d,0x2d,0x3e,0x76,0x61,0x29,0x5b,0x74,0x69,0x64,0x5d,0x3d,0x76,0x61,0x5f,0x74,0x6d,0x70,0x31,0x2f,0x36,0x34,0x2e,0x30,0x66,0x3b,0x0a,0x6d,0x65,0x6d,0x5f,0x66,
+    0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x76,0x73,0x3d,0x73,0x6d,
+    0x65,0x6d,0x2d,0x3e,0x76,0x61,0x5b,0x30,0x5d,0x3b,0x0a,0x73,0x3d,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x5b,0x30,0x5d,0x2e,0x78,0x5e,0x73,0x6d,0x65,0x6d,
+    0x2d,0x3e,0x6f,0x75,0x74,0x5b,0x30,0x5d,0x2e,0x79,0x5e,0x73,0x6d,0x65,0x6d,0x2d,0x3e,0x6f,0x75,0x74,0x5b,0x30,0x5d,0x2e,0x7a,0x5e,0x73,0x6d,0x65,0x6d,0x2d,0x3e,
+    0x6f,0x75,0x74,0x5b,0x30,0x5d,0x2e,0x77,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,
+    0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x73,0x6b,0x69,0x70,0x5b,0x33,0x5d,0x3d,0x7b,0x0a,0x32,0x30,0x2c,0x32,0x32,0x2c,0x32,0x32,0x0a,0x7d,0x3b,
+    0x0a,0x69,0x6e,0x6c,0x69,0x6e,0x65,0x20,0x76,0x6f,0x69,0x64,0x20,0x67,0x65,0x6e,0x65,0x72,0x61,0x74,0x65,0x5f,0x35,0x31,0x32,0x28,0x75,0x69,0x6e,0x74,0x20,0x69,
+    0x64,0x78,0x2c,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x20,0x69,0x6e,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,
+    0x6f,0x6e,0x67,0x2a,0x20,0x6f,0x75,0x74,0x29,0x0a,0x7b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x68,0x61,0x73,0x68,0x5b,0x32,0x35,0x5d,0x3b,0x0a,0x68,0x61,0x73,0x68,
+    0x5b,0x30,0x5d,0x3d,0x69,0x6e,0x5b,0x30,0x5d,0x5e,0x69,0x64,0x78,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x3b,0x20,0x69,0x3c,0x32,
+    0x35,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x68,0x61,0x73,0x68,0x5b,0x69,0x5d,0x3d,0x69,0x6e,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x66,0x6f,0x72,0x20,0x28,
+    0x69,0x6e,0x74,0x20,0x61,0x3d,0x30,0x3b,0x20,0x61,0x3c,0x33,0x3b,0x20,0x2b,0x2b,0x61,0x29,0x20,0x7b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x31,0x36,0x30,0x30,
+    0x5f,0x31,0x28,0x68,0x61,0x73,0x68,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x73,0x6b,0x69,0x70,0x5b,0x61,
+    0x5d,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x6f,0x75,0x74,0x5b,0x69,0x5d,0x3d,0x68,0x61,0x73,0x68,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x6f,0x75,0x74,0x2b,
+    0x3d,0x73,0x6b,0x69,0x70,0x5b,0x61,0x5d,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x5f,0x5f,0x28,0x28,0x72,0x65,0x71,
+    0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x38,0x2c,0x38,0x2c,0x31,0x29,0x29,0x29,0x0a,0x5f,0x5f,0x6b,0x65,0x72,
+    0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,0x63,0x6e,0x30,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x69,0x6e,0x70,
+    0x75,0x74,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x20,0x2a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2c,0x5f,0x5f,0x67,0x6c,
+    0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x73,0x74,0x61,0x74,0x65,0x73,0x2c,0x75,0x69,0x6e,0x74,0x20,0x54,0x68,0x72,0x65,0x61,0x64,0x73,0x29,
+    0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x67,0x49,0x64,0x78,0x3d,0x67,0x65,0x74,0x49,0x64,0x78,0x28,0x29,0x3b,0x0a,0x5f,0x5f,0x6c,
+    0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x53,0x74,0x61,0x74,0x65,0x5f,0x62,0x75,0x66,0x5b,0x38,0x2a,0x32,0x35,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,
+    0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x20,0x53,0x74,0x61,0x74,0x65,0x3d,0x53,0x74,0x61,0x74,0x65,0x5f,0x62,0x75,0x66,0x2b,0x67,0x65,0x74,0x5f,0x6c,
+    0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x2a,0x32,0x35,0x3b,0x0a,0x7b,0x0a,0x73,0x74,0x61,0x74,0x65,0x73,0x2b,0x3d,0x32,0x35,0x2a,0x67,0x49,0x64,0x78,
+    0x3b,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x3d,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x28,0x28,0x5f,0x5f,
+    0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x63,0x68,0x61,0x72,0x2a,0x29,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x2a,0x67,
+    0x49,0x64,0x78,0x29,0x3b,0x0a,0x69,0x66,0x28,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x3d,0x3d,0x30,0x29,0x20,0x7b,0x0a,0x23,
+    0x69,0x66,0x64,0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x0a,0x66,0x6f,0x72,0x28,0x75,0x69,0x6e,0x74,
+    0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x38,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x0a,0x53,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x69,0x6e,0x70,0x75,0x74,0x5b,0x69,
+    0x5d,0x3b,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x38,0x20,0x2a,0x29,0x53,0x74,0x61,0x74,
+    0x65,0x29,0x5b,0x30,0x5d,0x3d,0x76,0x6c,0x6f,0x61,0x64,0x38,0x28,0x30,0x2c,0x69,0x6e,0x70,0x75,0x74,0x29,0x3b,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x53,0x74,
+    0x61,0x74,0x65,0x5b,0x38,0x5d,0x3d,0x69,0x6e,0x70,0x75,0x74,0x5b,0x38,0x5d,0x3b,0x0a,0x53,0x74,0x61,0x74,0x65,0x5b,0x39,0x5d,0x3d,0x69,0x6e,0x70,0x75,0x74,0x5b,
+    0x39,0x5d,0x3b,0x0a,0x53,0x74,0x61,0x74,0x65,0x5b,0x31,0x30,0x5d,0x3d,0x69,0x6e,0x70,0x75,0x74,0x5b,0x31,0x30,0x5d,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x29,0x53,0x74,0x61,0x74,0x65,0x29,0x5b,0x39,0x5d,0x20,0x26,0x3d,0x20,0x30,0x78,0x30,0x30,0x46,0x46,0x46,0x46,0x46,
+    0x46,0x55,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x29,0x53,0x74,0x61,0x74,0x65,0x29,0x5b,0x39,0x5d,0x7c,0x3d,
+    0x28,0x28,0x28,0x75,0x69,0x6e,0x74,0x29,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x29,0x26,0x30,0x78,0x46,0x46,0x29,0x3c,
+    0x3c,0x32,0x34,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x29,0x53,0x74,0x61,0x74,0x65,0x29,0x5b,0x31,0x30,0x5d,
+    0x20,0x26,0x3d,0x20,0x30,0x78,0x46,0x46,0x30,0x30,0x30,0x30,0x30,0x30,0x55,0x3b,0x0a,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,
+    0x2a,0x29,0x53,0x74,0x61,0x74,0x65,0x29,0x5b,0x31,0x30,0x5d,0x7c,0x3d,0x28,0x28,0x28,0x75,0x69,0x6e,0x74,0x29,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,
+    0x5f,0x69,0x64,0x28,0x30,0x29,0x3e,0x3e,0x38,0x29,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x31,0x31,0x3b,0x20,0x69,0x3c,0x32,0x35,
+    0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x53,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x30,0x78,0x30,0x30,0x55,0x4c,0x3b,0x0a,0x7d,0x0a,0x53,0x74,0x61,0x74,
+    0x65,0x5b,0x31,0x36,0x5d,0x3d,0x30,0x78,0x38,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x55,0x4c,0x3b,0x0a,0x6b,0x65,0x63,0x63,
+    0x61,0x6b,0x66,0x31,0x36,0x30,0x30,0x5f,0x32,0x28,0x53,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,
+    0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x73,0x74,0x61,0x74,
+    0x65,0x73,0x5b,0x69,0x5d,0x3d,0x53,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x7d,0x0a,0x7d,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,
+    0x75,0x74,0x65,0x5f,0x5f,0x28,0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x36,0x34,0x2c,0x31,
+    0x2c,0x31,0x29,0x29,0x29,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,0x63,0x6e,0x30,0x30,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,
+    0x6c,0x20,0x69,0x6e,0x74,0x20,0x2a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,
+    0x20,0x2a,0x73,0x74,0x61,0x74,0x65,0x73,0x29,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x67,0x49,0x64,0x78,0x3d,0x67,0x65,0x74,0x49,
+    0x64,0x78,0x28,0x29,0x2f,0x36,0x34,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x53,0x74,0x61,0x74,0x65,0x5b,0x32,0x35,0x5d,
+    0x3b,0x0a,0x73,0x74,0x61,0x74,0x65,0x73,0x2b,0x3d,0x32,0x35,0x2a,0x67,0x49,0x64,0x78,0x3b,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x3d,0x28,0x5f,
+    0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x69,0x6e,0x74,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x63,0x68,0x61,0x72,0x2a,0x29,0x53,0x63,
+    0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x2a,0x67,0x49,0x64,0x78,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,
+    0x69,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x69,0x2b,0x3d,0x67,0x65,0x74,0x5f,
+    0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x73,0x69,0x7a,0x65,0x28,0x30,0x29,0x29,0x20,0x7b,0x0a,0x53,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,
+    0x5b,0x69,0x5d,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,
+    0x43,0x45,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,0x6e,0x74,0x20,0x69,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,
+    0x3b,0x20,0x69,0x3c,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x2f,0x35,0x31,0x32,0x3b,0x20,0x69,0x2b,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x73,0x69,0x7a,
+    0x65,0x28,0x30,0x29,0x29,0x20,0x7b,0x0a,0x67,0x65,0x6e,0x65,0x72,0x61,0x74,0x65,0x5f,0x35,0x31,0x32,0x28,0x69,0x2c,0x53,0x74,0x61,0x74,0x65,0x2c,0x28,0x5f,0x5f,
+    0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,
+    0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x69,0x2a,0x35,0x31,0x32,0x29,0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,
+    0x75,0x74,0x65,0x5f,0x5f,0x28,0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,0x69,0x7a,0x65,0x28,0x38,0x2c,0x38,0x2c,
+    0x31,0x29,0x29,0x29,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,0x64,0x20,0x63,0x6e,0x32,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,
+    0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,
+    0x20,0x2a,0x73,0x74,0x61,0x74,0x65,0x73,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x6f,0x75,0x74,0x70,0x75,0x74,0x2c,0x75,
+    0x6c,0x6f,0x6e,0x67,0x20,0x54,0x61,0x72,0x67,0x65,0x74,0x2c,0x75,0x69,0x6e,0x74,0x20,0x54,0x68,0x72,0x65,0x61,0x64,0x73,0x29,0x0a,0x7b,0x0a,0x5f,0x5f,0x6c,0x6f,
+    0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x41,0x45,0x53,0x30,0x5b,0x32,0x35,0x36,0x5d,0x2c,0x41,0x45,0x53,0x31,0x5b,0x32,0x35,0x36,0x5d,0x2c,0x41,0x45,0x53,
+    0x32,0x5b,0x32,0x35,0x36,0x5d,0x2c,0x41,0x45,0x53,0x33,0x5b,0x32,0x35,0x36,0x5d,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,
+    0x65,0x79,0x32,0x5b,0x34,0x30,0x5d,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x74,0x65,0x78,0x74,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,
+    0x67,0x49,0x64,0x78,0x3d,0x67,0x65,0x74,0x49,0x64,0x78,0x28,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,
+    0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x2a,0x38,0x2b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x20,0x69,0x3c,0x32,
+    0x35,0x36,0x3b,0x20,0x69,0x2b,0x3d,0x38,0x2a,0x38,0x29,0x20,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x74,0x6d,0x70,0x3d,0x41,0x45,0x53,
+    0x30,0x5f,0x43,0x5b,0x69,0x5d,0x3b,0x0a,0x41,0x45,0x53,0x30,0x5b,0x69,0x5d,0x3d,0x74,0x6d,0x70,0x3b,0x0a,0x41,0x45,0x53,0x31,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,
+    0x61,0x74,0x65,0x28,0x74,0x6d,0x70,0x2c,0x38,0x55,0x29,0x3b,0x0a,0x41,0x45,0x53,0x32,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x6d,0x70,0x2c,
+    0x31,0x36,0x55,0x29,0x3b,0x0a,0x41,0x45,0x53,0x33,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x6d,0x70,0x2c,0x32,0x34,0x55,0x29,0x3b,0x0a,0x7d,
+    0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x5f,
+    0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x78,0x69,0x6e,0x31,0x5b,0x38,0x5d,0x5b,0x38,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,
+    0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x78,0x69,0x6e,0x32,0x5b,0x38,0x5d,0x5b,0x38,0x5d,0x3b,0x0a,0x7b,0x0a,0x73,0x74,0x61,0x74,0x65,0x73,0x2b,0x3d,0x32,0x35,0x2a,
+    0x67,0x49,0x64,0x78,0x3b,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x3d,0x67,0x49,0x64,0x78,0x2a,0x28,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x3e,0x3e,
+    0x34,0x29,0x3b,0x0a,0x23,0x69,0x66,0x20,0x64,0x65,0x66,0x69,0x6e,0x65,0x64,0x28,0x5f,0x5f,0x54,0x61,0x68,0x69,0x74,0x69,0x5f,0x5f,0x29,0x20,0x7c,0x7c,0x20,0x64,
+    0x65,0x66,0x69,0x6e,0x65,0x64,0x28,0x5f,0x5f,0x50,0x69,0x74,0x63,0x61,0x69,0x72,0x6e,0x5f,0x5f,0x29,0x0a,0x66,0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,
+    0x3b,0x20,0x69,0x3c,0x34,0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x28,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x29,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,
+    0x79,0x32,0x29,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x69,0x2b,0x34,0x5d,0x3b,0x0a,0x74,0x65,0x78,0x74,0x3d,0x76,0x6c,0x6f,0x61,0x64,0x34,0x28,
+    0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x2b,0x34,0x2c,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,
+    0x20,0x2a,0x29,0x73,0x74,0x61,0x74,0x65,0x73,0x29,0x3b,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x74,0x65,0x78,0x74,0x3d,0x76,0x6c,0x6f,0x61,0x64,0x34,0x28,0x67,0x65,
+    0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x2b,0x34,0x2c,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,
+    0x29,0x73,0x74,0x61,0x74,0x65,0x73,0x29,0x3b,0x0a,0x28,0x28,0x75,0x69,0x6e,0x74,0x38,0x20,0x2a,0x29,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,0x79,0x32,
+    0x29,0x5b,0x30,0x5d,0x3d,0x76,0x6c,0x6f,0x61,0x64,0x38,0x28,0x31,0x2c,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x29,0x73,
+    0x74,0x61,0x74,0x65,0x73,0x29,0x3b,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x41,0x45,0x53,0x45,0x78,0x70,0x61,0x6e,0x64,0x4b,0x65,0x79,0x32,0x35,0x36,0x28,0x45,
+    0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,0x79,0x32,0x29,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,
+    0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x20,0x78,0x69,0x6e,
+    0x31,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x26,0x78,0x69,0x6e,0x31,0x5b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x5d,0x5b,0x67,
+    0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x20,
+    0x78,0x69,0x6e,0x31,0x5f,0x6c,0x6f,0x61,0x64,0x3d,0x26,0x78,0x69,0x6e,0x31,0x5b,0x28,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,
+    0x2b,0x31,0x29,0x20,0x25,0x20,0x38,0x5d,0x5b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x20,0x78,0x69,0x6e,0x32,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x26,0x78,0x69,0x6e,0x32,0x5b,0x67,0x65,0x74,0x5f,0x6c,
+    0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x5d,0x5b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x5d,0x3b,0x0a,0x5f,0x5f,
+    0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x20,0x78,0x69,0x6e,0x32,0x5f,0x6c,0x6f,0x61,0x64,0x3d,0x26,0x78,0x69,0x6e,0x32,0x5b,0x28,0x67,0x65,
+    0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x2b,0x31,0x29,0x20,0x25,0x20,0x38,0x5d,0x5b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,
+    0x69,0x64,0x28,0x30,0x29,0x5d,0x3b,0x0a,0x2a,0x78,0x69,0x6e,0x32,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x28,0x75,0x69,0x6e,0x74,0x34,0x29,0x28,0x30,0x2c,0x30,0x2c,
+    0x30,0x2c,0x30,0x29,0x3b,0x0a,0x7b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x32,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,
+    0x74,0x20,0x69,0x3d,0x30,0x2c,0x69,0x31,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x3b,0x20,0x69,0x3c,0x28,0x4d,0x45,0x4d,
+    0x4f,0x52,0x59,0x3e,0x3e,0x37,0x29,0x3b,0x20,0x2b,0x2b,0x69,0x2c,0x69,0x31,0x3d,0x28,0x69,0x31,0x2b,0x31,0x36,0x29,0x20,0x25,0x20,0x28,0x4d,0x45,0x4d,0x4f,0x52,
+    0x59,0x3e,0x3e,0x34,0x29,0x29,0x20,0x7b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,0x3d,0x20,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5b,0x28,0x75,0x69,0x6e,
+    0x74,0x29,0x69,0x31,0x5d,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,
+    0x43,0x45,0x29,0x3b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,0x3d,0x20,0x2a,0x78,0x69,0x6e,0x32,0x5f,0x6c,0x6f,0x61,0x64,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,
+    0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x30,0x0a,0x66,0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x6a,0x3d,0x30,0x3b,0x20,0x6a,0x3c,0x31,0x30,0x3b,0x20,0x2b,0x2b,
+    0x6a,0x29,0x0a,0x74,0x65,0x78,0x74,0x3d,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x28,0x41,0x45,0x53,0x30,0x2c,0x41,0x45,0x53,0x31,0x2c,0x41,0x45,0x53,0x32,
+    0x2c,0x41,0x45,0x53,0x33,0x2c,0x74,0x65,0x78,0x74,0x2c,0x28,0x28,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x29,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,0x79,
+    0x32,0x29,0x5b,0x6a,0x5d,0x29,0x3b,0x0a,0x2a,0x78,0x69,0x6e,0x31,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x74,0x65,0x78,0x74,0x3b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,
+    0x3d,0x20,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5b,0x28,0x75,0x69,0x6e,0x74,0x29,0x69,0x31,0x2b,0x38,0x75,0x5d,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,
+    0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,0x3d,
+    0x20,0x2a,0x78,0x69,0x6e,0x31,0x5f,0x6c,0x6f,0x61,0x64,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x30,0x0a,0x66,
+    0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x6a,0x3d,0x30,0x3b,0x20,0x6a,0x3c,0x31,0x30,0x3b,0x20,0x2b,0x2b,0x6a,0x29,0x0a,0x74,0x65,0x78,0x74,0x3d,0x41,0x45,0x53,0x5f,
+    0x52,0x6f,0x75,0x6e,0x64,0x28,0x41,0x45,0x53,0x30,0x2c,0x41,0x45,0x53,0x31,0x2c,0x41,0x45,0x53,0x32,0x2c,0x41,0x45,0x53,0x33,0x2c,0x74,0x65,0x78,0x74,0x2c,0x28,
+    0x28,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x29,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,0x79,0x32,0x29,0x5b,0x6a,0x5d,0x29,0x3b,0x0a,0x2a,0x78,0x69,0x6e,
+    0x32,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x74,0x65,0x78,0x74,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,
+    0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,0x3d,0x20,0x2a,0x78,0x69,0x6e,0x32,0x5f,0x6c,0x6f,0x61,0x64,
+    0x3b,0x0a,0x7d,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x31,0x36,0x0a,0x66,0x6f,0x72,0x28,0x73,0x69,0x7a,0x65,0x5f,0x74,
+    0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x31,0x36,0x3b,0x20,0x69,0x2b,0x2b,0x29,0x0a,0x7b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,
+    0x6c,0x20,0x31,0x30,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x6a,0x3d,0x30,0x3b,0x20,0x6a,0x3c,0x31,0x30,0x3b,0x20,0x2b,0x2b,0x6a,0x29,0x20,0x7b,0x0a,
+    0x74,0x65,0x78,0x74,0x3d,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x28,0x41,0x45,0x53,0x30,0x2c,0x41,0x45,0x53,0x31,0x2c,0x41,0x45,0x53,0x32,0x2c,0x41,0x45,
+    0x53,0x33,0x2c,0x74,0x65,0x78,0x74,0x2c,0x28,0x28,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x29,0x45,0x78,0x70,0x61,0x6e,0x64,0x65,0x64,0x4b,0x65,0x79,0x32,0x29,0x5b,
+    0x6a,0x5d,0x29,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,
+    0x43,0x45,0x29,0x3b,0x0a,0x2a,0x78,0x69,0x6e,0x31,0x5f,0x73,0x74,0x6f,0x72,0x65,0x3d,0x74,0x65,0x78,0x74,0x3b,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,
+    0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x74,0x65,0x78,0x74,0x20,0x5e,0x3d,0x20,0x2a,0x78,0x69,
+    0x6e,0x31,0x5f,0x6c,0x6f,0x61,0x64,0x3b,0x0a,0x7d,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x53,0x74,0x61,0x74,0x65,0x5f,0x62,
+    0x75,0x66,0x5b,0x38,0x2a,0x32,0x35,0x5d,0x3b,0x0a,0x7b,0x0a,0x76,0x73,0x74,0x6f,0x72,0x65,0x32,0x28,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x74,0x65,
+    0x78,0x74,0x29,0x2c,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x2b,0x34,0x2c,0x73,0x74,0x61,0x74,0x65,0x73,0x29,0x3b,0x0a,0x7d,
+    0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x47,0x4c,0x4f,0x42,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,
+    0x7b,0x0a,0x69,0x66,0x28,0x21,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x31,0x29,0x29,0x0a,0x7b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,
+    0x20,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x20,0x53,0x74,0x61,0x74,0x65,0x3d,0x53,0x74,0x61,0x74,0x65,0x5f,0x62,0x75,0x66,0x2b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,
+    0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x2a,0x32,0x35,0x3b,0x0a,0x66,0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x32,0x35,0x3b,0x20,0x2b,
+    0x2b,0x69,0x29,0x20,0x53,0x74,0x61,0x74,0x65,0x5b,0x69,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x69,0x5d,0x3b,0x0a,0x6b,0x65,0x63,0x63,0x61,0x6b,0x66,0x31,
+    0x36,0x30,0x30,0x5f,0x32,0x28,0x53,0x74,0x61,0x74,0x65,0x29,0x3b,0x0a,0x69,0x66,0x28,0x53,0x74,0x61,0x74,0x65,0x5b,0x33,0x5d,0x3c,0x3d,0x54,0x61,0x72,0x67,0x65,
+    0x74,0x29,0x0a,0x7b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x6f,0x75,0x74,0x49,0x64,0x78,0x3d,0x61,0x74,0x6f,0x6d,0x69,0x63,0x5f,0x69,0x6e,0x63,0x28,0x6f,0x75,0x74,
+    0x70,0x75,0x74,0x2b,0x30,0x78,0x46,0x46,0x29,0x3b,0x0a,0x69,0x66,0x28,0x6f,0x75,0x74,0x49,0x64,0x78,0x3c,0x30,0x78,0x46,0x46,0x29,0x0a,0x6f,0x75,0x74,0x70,0x75,
+    0x74,0x5b,0x6f,0x75,0x74,0x49,0x64,0x78,0x5d,0x3d,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,
+    0x7d,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x47,0x4c,0x4f,0x42,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,
+    0x29,0x3b,0x0a,0x7d,0x0a,0x00
+};
+
+} // namespace xmrig

src/backend/opencl/cl/cn/cryptonight_r.cl

@@ -0,0 +1,144 @@
+__attribute__((reqd_work_group_size(WORKSIZE, 1, 1)))
+__kernel void KERNEL_NAME(__global ulong *input, __global uint4 *Scratchpad, __global ulong *states, uint Threads)
+{
+    ulong a[2], b[4];
+    __local uint AES0[256], AES1[256], AES2[256], AES3[256];
+
+    const ulong gIdx = get_global_id(0) - get_global_offset(0);
+
+    for(int i = get_local_id(0); i < 256; i += WORKSIZE) {
+        const uint tmp = AES0_C[i];
+        AES0[i] = tmp;
+        AES1[i] = rotate(tmp, 8U);
+        AES2[i] = rotate(tmp, 16U);
+        AES3[i] = rotate(tmp, 24U);
+    }
+
+    barrier(CLK_LOCAL_MEM_FENCE);
+
+    {
+        states += 25 * gIdx;
+
+#       if defined(__NV_CL_C_VERSION)
+            Scratchpad += gIdx * (ITERATIONS >> 2);
+#       else
+#           if (STRIDED_INDEX == 0)
+                Scratchpad += gIdx * (MEMORY >> 4);
+#           elif (STRIDED_INDEX == 1)
+                Scratchpad += gIdx;
+#           elif (STRIDED_INDEX == 2)
+                Scratchpad += get_group_id(0) * (MEMORY >> 4) * WORKSIZE + MEM_CHUNK * get_local_id(0);
+#           endif
+#       endif
+
+        a[0] = states[0] ^ states[4];
+        a[1] = states[1] ^ states[5];
+
+        b[0] = states[2] ^ states[6];
+        b[1] = states[3] ^ states[7];
+        b[2] = states[8] ^ states[10];
+        b[3] = states[9] ^ states[11];
+    }
+
+    ulong2 bx0 = ((ulong2 *)b)[0];
+    ulong2 bx1 = ((ulong2 *)b)[1];
+
+    mem_fence(CLK_LOCAL_MEM_FENCE);
+
+#   ifdef __NV_CL_C_VERSION
+    __local uint16 scratchpad_line_buf[WORKSIZE];
+    __local uint16* scratchpad_line = scratchpad_line_buf + get_local_id(0);
+#   endif
+
+    {
+        uint r0 = as_uint2(states[12]).s0;
+        uint r1 = as_uint2(states[12]).s1;
+        uint r2 = as_uint2(states[13]).s0;
+        uint r3 = as_uint2(states[13]).s1;
+
+        #pragma unroll CN_UNROLL
+        for (int i = 0; i < ITERATIONS; ++i) {
+#           ifdef __NV_CL_C_VERSION
+                uint idx  = a[0] & 0x1FFFC0;
+                uint idx1 = a[0] & 0x30;
+
+                *scratchpad_line = *(__global uint16*)((__global uchar*)(Scratchpad) + idx);
+#           else
+                uint idx = a[0] & MASK;
+#           endif
+
+            uint4 c = SCRATCHPAD_CHUNK(0);
+            c = AES_Round(AES0, AES1, AES2, AES3, c, ((uint4 *)a)[0]);
+
+            {
+                const ulong2 chunk1 = as_ulong2(SCRATCHPAD_CHUNK(1));
+                const ulong2 chunk2 = as_ulong2(SCRATCHPAD_CHUNK(2));
+                const ulong2 chunk3 = as_ulong2(SCRATCHPAD_CHUNK(3));
+
+                c ^= as_uint4(chunk1) ^ as_uint4(chunk2) ^ as_uint4(chunk3);
+
+                SCRATCHPAD_CHUNK(1) = as_uint4(chunk3 + bx1);
+                SCRATCHPAD_CHUNK(2) = as_uint4(chunk1 + bx0);
+                SCRATCHPAD_CHUNK(3) = as_uint4(chunk2 + ((ulong2 *)a)[0]);
+            }
+
+            SCRATCHPAD_CHUNK(0) = as_uint4(bx0) ^ c;
+
+#           ifdef __NV_CL_C_VERSION
+                *(__global uint16*)((__global uchar*)(Scratchpad) + idx) = *scratchpad_line;
+
+                idx = as_ulong2(c).s0 & 0x1FFFC0;
+                idx1 = as_ulong2(c).s0 & 0x30;
+
+                *scratchpad_line = *(__global uint16*)((__global uchar*)(Scratchpad) + idx);
+#           else
+                idx = as_ulong2(c).s0 & MASK;
+#           endif
+
+            uint4 tmp = SCRATCHPAD_CHUNK(0);
+
+            tmp.s0 ^= r0 + r1;
+            tmp.s1 ^= r2 + r3;
+            const uint r4 = as_uint2(a[0]).s0;
+            const uint r5 = as_uint2(a[1]).s0;
+            const uint r6 = as_uint4(bx0).s0;
+            const uint r7 = as_uint4(bx1).s0;
+            const uint r8 = as_uint4(bx1).s2;
+
+XMRIG_INCLUDE_RANDOM_MATH
+
+            const uint2 al = (uint2)(as_uint2(a[0]).s0 ^ r2, as_uint2(a[0]).s1 ^ r3);
+            const uint2 ah = (uint2)(as_uint2(a[1]).s0 ^ r0, as_uint2(a[1]).s1 ^ r1);
+
+            ulong2 t;
+            t.s0 = mul_hi(as_ulong2(c).s0, as_ulong2(tmp).s0);
+            t.s1 = as_ulong2(c).s0 * as_ulong2(tmp).s0;
+            {
+                const ulong2 chunk1 = as_ulong2(SCRATCHPAD_CHUNK(1));
+                const ulong2 chunk2 = as_ulong2(SCRATCHPAD_CHUNK(2));
+                const ulong2 chunk3 = as_ulong2(SCRATCHPAD_CHUNK(3));
+
+                c ^= as_uint4(chunk1) ^ as_uint4(chunk2) ^ as_uint4(chunk3);
+
+                SCRATCHPAD_CHUNK(1) = as_uint4(chunk3 + bx1);
+                SCRATCHPAD_CHUNK(2) = as_uint4(chunk1 + bx0);
+                SCRATCHPAD_CHUNK(3) = as_uint4(chunk2 + ((ulong2 *)a)[0]);
+            }
+
+            a[1] = as_ulong(ah) + t.s1;
+            a[0] = as_ulong(al) + t.s0;
+
+            SCRATCHPAD_CHUNK(0) = ((uint4 *)a)[0];
+
+#           ifdef __NV_CL_C_VERSION
+                *(__global uint16*)((__global uchar*)(Scratchpad) + idx) = *scratchpad_line;
+#          endif
+
+            ((uint4 *)a)[0] ^= tmp;
+            bx1 = bx0;
+            bx0 = as_ulong2(c);
+        }
+    }
+
+    mem_fence(CLK_GLOBAL_MEM_FENCE);
+}

src/backend/opencl/cl/cn/cryptonight_r_cl.h

@@ -0,0 +1,359 @@
+#pragma once
+
+namespace xmrig {
+
+static char cryptonight_r_defines_cl[7709] = {
+    0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,
+    0x20,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x4e,0x29,0x20,0x28,0x2a,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,
+    0x75,0x69,0x6e,0x74,0x34,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,0x28,0x73,0x63,0x72,0x61,0x74,0x63,0x68,
+    0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x29,0x20,0x2b,0x20,0x28,0x69,0x64,0x78,0x31,0x20,0x5e,0x20,0x28,0x4e,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x29,0x29,0x0a,
+    0x23,0x65,0x6c,0x73,0x65,0x0a,0x23,0x69,0x66,0x20,0x28,0x53,0x54,0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x30,0x29,0x0a,0x23,
+    0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x4e,0x29,0x20,0x28,0x2a,0x28,0x5f,0x5f,
+    0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,
+    0x28,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x20,0x2b,0x20,0x28,0x69,0x64,0x78,0x20,0x5e,0x20,0x28,0x4e,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x29,
+    0x29,0x0a,0x23,0x65,0x6c,0x69,0x66,0x20,0x28,0x53,0x54,0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x31,0x29,0x0a,0x23,0x64,0x65,
+    0x66,0x69,0x6e,0x65,0x20,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x4e,0x29,0x20,0x28,0x2a,0x28,0x5f,0x5f,0x67,0x6c,
+    0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,0x28,0x53,
+    0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x20,0x2b,0x20,0x6d,0x75,0x6c,0x32,0x34,0x28,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x28,0x69,0x64,0x78,0x20,0x5e,
+    0x20,0x28,0x4e,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x2c,0x20,0x54,0x68,0x72,0x65,0x61,0x64,0x73,0x29,0x29,0x29,0x0a,0x23,0x65,0x6c,0x69,0x66,0x20,0x28,0x53,0x54,
+    0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x32,0x29,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x53,0x43,0x52,0x41,0x54,0x43,
+    0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x4e,0x29,0x20,0x28,0x2a,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x2a,
+    0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,0x28,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x20,
+    0x2b,0x20,0x28,0x28,0x28,0x69,0x64,0x78,0x20,0x5e,0x20,0x28,0x4e,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x20,0x25,0x20,0x28,0x4d,0x45,0x4d,0x5f,0x43,0x48,0x55,0x4e,
+    0x4b,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x20,0x2b,0x20,0x28,0x28,0x69,0x64,0x78,0x20,0x5e,0x20,0x28,0x4e,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x20,0x2f,0x20,0x28,
+    0x4d,0x45,0x4d,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x20,0x2a,0x20,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x20,0x2a,0x20,0x28,0x4d,
+    0x45,0x4d,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x20,0x3c,0x3c,0x20,0x34,0x29,0x29,0x29,0x29,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,
+    0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x52,0x4f,0x54,0x5f,0x42,0x49,0x54,0x53,0x20,0x33,0x32,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x4d,0x45,0x4d,0x5f,
+    0x43,0x48,0x55,0x4e,0x4b,0x20,0x28,0x31,0x20,0x3c,0x3c,0x20,0x4d,0x45,0x4d,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x5f,0x45,0x58,0x50,0x4f,0x4e,0x45,0x4e,0x54,0x29,0x0a,
+    0x23,0x69,0x66,0x6e,0x64,0x65,0x66,0x20,0x57,0x4f,0x4c,0x46,0x5f,0x41,0x45,0x53,0x5f,0x43,0x4c,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x57,0x4f,0x4c,0x46,
+    0x5f,0x41,0x45,0x53,0x5f,0x43,0x4c,0x0a,0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x63,0x6c,0x5f,0x61,0x6d,0x64,0x5f,0x6d,0x65,0x64,0x69,0x61,0x5f,0x6f,0x70,0x73,0x32,
+    0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x4f,0x50,0x45,0x4e,0x43,0x4c,0x20,0x45,0x58,0x54,0x45,0x4e,0x53,0x49,0x4f,0x4e,0x20,0x63,0x6c,0x5f,0x61,0x6d,0x64,
+    0x5f,0x6d,0x65,0x64,0x69,0x61,0x5f,0x6f,0x70,0x73,0x32,0x20,0x3a,0x20,0x65,0x6e,0x61,0x62,0x6c,0x65,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x78,0x6d,0x72,
+    0x69,0x67,0x5f,0x61,0x6d,0x64,0x5f,0x62,0x66,0x65,0x28,0x73,0x72,0x63,0x30,0x2c,0x20,0x73,0x72,0x63,0x31,0x2c,0x20,0x73,0x72,0x63,0x32,0x29,0x20,0x61,0x6d,0x64,
+    0x5f,0x62,0x66,0x65,0x28,0x73,0x72,0x63,0x30,0x2c,0x20,0x73,0x72,0x63,0x31,0x2c,0x20,0x73,0x72,0x63,0x32,0x29,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x69,0x6e,0x6c,
+    0x69,0x6e,0x65,0x20,0x69,0x6e,0x74,0x20,0x78,0x6d,0x72,0x69,0x67,0x5f,0x61,0x6d,0x64,0x5f,0x62,0x66,0x65,0x28,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,
+    0x20,0x73,0x72,0x63,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x6f,0x66,0x66,0x73,0x65,0x74,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,
+    0x6e,0x74,0x20,0x77,0x69,0x64,0x74,0x68,0x29,0x0a,0x7b,0x0a,0x69,0x66,0x28,0x28,0x6f,0x66,0x66,0x73,0x65,0x74,0x2b,0x77,0x69,0x64,0x74,0x68,0x29,0x3c,0x33,0x32,
+    0x75,0x29,0x20,0x7b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x28,0x73,0x72,0x63,0x30,0x3c,0x3c,0x28,0x33,0x32,0x75,0x2d,0x6f,0x66,0x66,0x73,0x65,0x74,0x2d,0x77,
+    0x69,0x64,0x74,0x68,0x29,0x29,0x3e,0x3e,0x28,0x33,0x32,0x75,0x2d,0x77,0x69,0x64,0x74,0x68,0x29,0x3b,0x0a,0x7d,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x73,0x72,
+    0x63,0x30,0x3e,0x3e,0x6f,0x66,0x66,0x73,0x65,0x74,0x3b,0x0a,0x7d,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x41,0x45,0x53,0x30,0x5f,0x43,0x5b,0x32,0x35,0x36,0x5d,0x20,0x3d,0x0a,
+    0x7b,0x0a,0x30,0x78,0x41,0x35,0x36,0x33,0x36,0x33,0x43,0x36,0x55,0x2c,0x30,0x78,0x38,0x34,0x37,0x43,0x37,0x43,0x46,0x38,0x55,0x2c,0x30,0x78,0x39,0x39,0x37,0x37,
+    0x37,0x37,0x45,0x45,0x55,0x2c,0x30,0x78,0x38,0x44,0x37,0x42,0x37,0x42,0x46,0x36,0x55,0x2c,0x0a,0x30,0x78,0x30,0x44,0x46,0x32,0x46,0x32,0x46,0x46,0x55,0x2c,0x30,
+    0x78,0x42,0x44,0x36,0x42,0x36,0x42,0x44,0x36,0x55,0x2c,0x30,0x78,0x42,0x31,0x36,0x46,0x36,0x46,0x44,0x45,0x55,0x2c,0x30,0x78,0x35,0x34,0x43,0x35,0x43,0x35,0x39,
+    0x31,0x55,0x2c,0x0a,0x30,0x78,0x35,0x30,0x33,0x30,0x33,0x30,0x36,0x30,0x55,0x2c,0x30,0x78,0x30,0x33,0x30,0x31,0x30,0x31,0x30,0x32,0x55,0x2c,0x30,0x78,0x41,0x39,
+    0x36,0x37,0x36,0x37,0x43,0x45,0x55,0x2c,0x30,0x78,0x37,0x44,0x32,0x42,0x32,0x42,0x35,0x36,0x55,0x2c,0x0a,0x30,0x78,0x31,0x39,0x46,0x45,0x46,0x45,0x45,0x37,0x55,
+    0x2c,0x30,0x78,0x36,0x32,0x44,0x37,0x44,0x37,0x42,0x35,0x55,0x2c,0x30,0x78,0x45,0x36,0x41,0x42,0x41,0x42,0x34,0x44,0x55,0x2c,0x30,0x78,0x39,0x41,0x37,0x36,0x37,
+    0x36,0x45,0x43,0x55,0x2c,0x0a,0x30,0x78,0x34,0x35,0x43,0x41,0x43,0x41,0x38,0x46,0x55,0x2c,0x30,0x78,0x39,0x44,0x38,0x32,0x38,0x32,0x31,0x46,0x55,0x2c,0x30,0x78,
+    0x34,0x30,0x43,0x39,0x43,0x39,0x38,0x39,0x55,0x2c,0x30,0x78,0x38,0x37,0x37,0x44,0x37,0x44,0x46,0x41,0x55,0x2c,0x0a,0x30,0x78,0x31,0x35,0x46,0x41,0x46,0x41,0x45,
+    0x46,0x55,0x2c,0x30,0x78,0x45,0x42,0x35,0x39,0x35,0x39,0x42,0x32,0x55,0x2c,0x30,0x78,0x43,0x39,0x34,0x37,0x34,0x37,0x38,0x45,0x55,0x2c,0x30,0x78,0x30,0x42,0x46,
+    0x30,0x46,0x30,0x46,0x42,0x55,0x2c,0x0a,0x30,0x78,0x45,0x43,0x41,0x44,0x41,0x44,0x34,0x31,0x55,0x2c,0x30,0x78,0x36,0x37,0x44,0x34,0x44,0x34,0x42,0x33,0x55,0x2c,
+    0x30,0x78,0x46,0x44,0x41,0x32,0x41,0x32,0x35,0x46,0x55,0x2c,0x30,0x78,0x45,0x41,0x41,0x46,0x41,0x46,0x34,0x35,0x55,0x2c,0x0a,0x30,0x78,0x42,0x46,0x39,0x43,0x39,
+    0x43,0x32,0x33,0x55,0x2c,0x30,0x78,0x46,0x37,0x41,0x34,0x41,0x34,0x35,0x33,0x55,0x2c,0x30,0x78,0x39,0x36,0x37,0x32,0x37,0x32,0x45,0x34,0x55,0x2c,0x30,0x78,0x35,
+    0x42,0x43,0x30,0x43,0x30,0x39,0x42,0x55,0x2c,0x0a,0x30,0x78,0x43,0x32,0x42,0x37,0x42,0x37,0x37,0x35,0x55,0x2c,0x30,0x78,0x31,0x43,0x46,0x44,0x46,0x44,0x45,0x31,
+    0x55,0x2c,0x30,0x78,0x41,0x45,0x39,0x33,0x39,0x33,0x33,0x44,0x55,0x2c,0x30,0x78,0x36,0x41,0x32,0x36,0x32,0x36,0x34,0x43,0x55,0x2c,0x0a,0x30,0x78,0x35,0x41,0x33,
+    0x36,0x33,0x36,0x36,0x43,0x55,0x2c,0x30,0x78,0x34,0x31,0x33,0x46,0x33,0x46,0x37,0x45,0x55,0x2c,0x30,0x78,0x30,0x32,0x46,0x37,0x46,0x37,0x46,0x35,0x55,0x2c,0x30,
+    0x78,0x34,0x46,0x43,0x43,0x43,0x43,0x38,0x33,0x55,0x2c,0x0a,0x30,0x78,0x35,0x43,0x33,0x34,0x33,0x34,0x36,0x38,0x55,0x2c,0x30,0x78,0x46,0x34,0x41,0x35,0x41,0x35,
+    0x35,0x31,0x55,0x2c,0x30,0x78,0x33,0x34,0x45,0x35,0x45,0x35,0x44,0x31,0x55,0x2c,0x30,0x78,0x30,0x38,0x46,0x31,0x46,0x31,0x46,0x39,0x55,0x2c,0x0a,0x30,0x78,0x39,
+    0x33,0x37,0x31,0x37,0x31,0x45,0x32,0x55,0x2c,0x30,0x78,0x37,0x33,0x44,0x38,0x44,0x38,0x41,0x42,0x55,0x2c,0x30,0x78,0x35,0x33,0x33,0x31,0x33,0x31,0x36,0x32,0x55,
+    0x2c,0x30,0x78,0x33,0x46,0x31,0x35,0x31,0x35,0x32,0x41,0x55,0x2c,0x0a,0x30,0x78,0x30,0x43,0x30,0x34,0x30,0x34,0x30,0x38,0x55,0x2c,0x30,0x78,0x35,0x32,0x43,0x37,
+    0x43,0x37,0x39,0x35,0x55,0x2c,0x30,0x78,0x36,0x35,0x32,0x33,0x32,0x33,0x34,0x36,0x55,0x2c,0x30,0x78,0x35,0x45,0x43,0x33,0x43,0x33,0x39,0x44,0x55,0x2c,0x0a,0x30,
+    0x78,0x32,0x38,0x31,0x38,0x31,0x38,0x33,0x30,0x55,0x2c,0x30,0x78,0x41,0x31,0x39,0x36,0x39,0x36,0x33,0x37,0x55,0x2c,0x30,0x78,0x30,0x46,0x30,0x35,0x30,0x35,0x30,
+    0x41,0x55,0x2c,0x30,0x78,0x42,0x35,0x39,0x41,0x39,0x41,0x32,0x46,0x55,0x2c,0x0a,0x30,0x78,0x30,0x39,0x30,0x37,0x30,0x37,0x30,0x45,0x55,0x2c,0x30,0x78,0x33,0x36,
+    0x31,0x32,0x31,0x32,0x32,0x34,0x55,0x2c,0x30,0x78,0x39,0x42,0x38,0x30,0x38,0x30,0x31,0x42,0x55,0x2c,0x30,0x78,0x33,0x44,0x45,0x32,0x45,0x32,0x44,0x46,0x55,0x2c,
+    0x0a,0x30,0x78,0x32,0x36,0x45,0x42,0x45,0x42,0x43,0x44,0x55,0x2c,0x30,0x78,0x36,0x39,0x32,0x37,0x32,0x37,0x34,0x45,0x55,0x2c,0x30,0x78,0x43,0x44,0x42,0x32,0x42,
+    0x32,0x37,0x46,0x55,0x2c,0x30,0x78,0x39,0x46,0x37,0x35,0x37,0x35,0x45,0x41,0x55,0x2c,0x0a,0x30,0x78,0x31,0x42,0x30,0x39,0x30,0x39,0x31,0x32,0x55,0x2c,0x30,0x78,
+    0x39,0x45,0x38,0x33,0x38,0x33,0x31,0x44,0x55,0x2c,0x30,0x78,0x37,0x34,0x32,0x43,0x32,0x43,0x35,0x38,0x55,0x2c,0x30,0x78,0x32,0x45,0x31,0x41,0x31,0x41,0x33,0x34,
+    0x55,0x2c,0x0a,0x30,0x78,0x32,0x44,0x31,0x42,0x31,0x42,0x33,0x36,0x55,0x2c,0x30,0x78,0x42,0x32,0x36,0x45,0x36,0x45,0x44,0x43,0x55,0x2c,0x30,0x78,0x45,0x45,0x35,
+    0x41,0x35,0x41,0x42,0x34,0x55,0x2c,0x30,0x78,0x46,0x42,0x41,0x30,0x41,0x30,0x35,0x42,0x55,0x2c,0x0a,0x30,0x78,0x46,0x36,0x35,0x32,0x35,0x32,0x41,0x34,0x55,0x2c,
+    0x30,0x78,0x34,0x44,0x33,0x42,0x33,0x42,0x37,0x36,0x55,0x2c,0x30,0x78,0x36,0x31,0x44,0x36,0x44,0x36,0x42,0x37,0x55,0x2c,0x30,0x78,0x43,0x45,0x42,0x33,0x42,0x33,
+    0x37,0x44,0x55,0x2c,0x0a,0x30,0x78,0x37,0x42,0x32,0x39,0x32,0x39,0x35,0x32,0x55,0x2c,0x30,0x78,0x33,0x45,0x45,0x33,0x45,0x33,0x44,0x44,0x55,0x2c,0x30,0x78,0x37,
+    0x31,0x32,0x46,0x32,0x46,0x35,0x45,0x55,0x2c,0x30,0x78,0x39,0x37,0x38,0x34,0x38,0x34,0x31,0x33,0x55,0x2c,0x0a,0x30,0x78,0x46,0x35,0x35,0x33,0x35,0x33,0x41,0x36,
+    0x55,0x2c,0x30,0x78,0x36,0x38,0x44,0x31,0x44,0x31,0x42,0x39,0x55,0x2c,0x30,0x78,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x55,0x2c,0x30,0x78,0x32,0x43,0x45,0x44,
+    0x45,0x44,0x43,0x31,0x55,0x2c,0x0a,0x30,0x78,0x36,0x30,0x32,0x30,0x32,0x30,0x34,0x30,0x55,0x2c,0x30,0x78,0x31,0x46,0x46,0x43,0x46,0x43,0x45,0x33,0x55,0x2c,0x30,
+    0x78,0x43,0x38,0x42,0x31,0x42,0x31,0x37,0x39,0x55,0x2c,0x30,0x78,0x45,0x44,0x35,0x42,0x35,0x42,0x42,0x36,0x55,0x2c,0x0a,0x30,0x78,0x42,0x45,0x36,0x41,0x36,0x41,
+    0x44,0x34,0x55,0x2c,0x30,0x78,0x34,0x36,0x43,0x42,0x43,0x42,0x38,0x44,0x55,0x2c,0x30,0x78,0x44,0x39,0x42,0x45,0x42,0x45,0x36,0x37,0x55,0x2c,0x30,0x78,0x34,0x42,
+    0x33,0x39,0x33,0x39,0x37,0x32,0x55,0x2c,0x0a,0x30,0x78,0x44,0x45,0x34,0x41,0x34,0x41,0x39,0x34,0x55,0x2c,0x30,0x78,0x44,0x34,0x34,0x43,0x34,0x43,0x39,0x38,0x55,
+    0x2c,0x30,0x78,0x45,0x38,0x35,0x38,0x35,0x38,0x42,0x30,0x55,0x2c,0x30,0x78,0x34,0x41,0x43,0x46,0x43,0x46,0x38,0x35,0x55,0x2c,0x0a,0x30,0x78,0x36,0x42,0x44,0x30,
+    0x44,0x30,0x42,0x42,0x55,0x2c,0x30,0x78,0x32,0x41,0x45,0x46,0x45,0x46,0x43,0x35,0x55,0x2c,0x30,0x78,0x45,0x35,0x41,0x41,0x41,0x41,0x34,0x46,0x55,0x2c,0x30,0x78,
+    0x31,0x36,0x46,0x42,0x46,0x42,0x45,0x44,0x55,0x2c,0x0a,0x30,0x78,0x43,0x35,0x34,0x33,0x34,0x33,0x38,0x36,0x55,0x2c,0x30,0x78,0x44,0x37,0x34,0x44,0x34,0x44,0x39,
+    0x41,0x55,0x2c,0x30,0x78,0x35,0x35,0x33,0x33,0x33,0x33,0x36,0x36,0x55,0x2c,0x30,0x78,0x39,0x34,0x38,0x35,0x38,0x35,0x31,0x31,0x55,0x2c,0x0a,0x30,0x78,0x43,0x46,
+    0x34,0x35,0x34,0x35,0x38,0x41,0x55,0x2c,0x30,0x78,0x31,0x30,0x46,0x39,0x46,0x39,0x45,0x39,0x55,0x2c,0x30,0x78,0x30,0x36,0x30,0x32,0x30,0x32,0x30,0x34,0x55,0x2c,
+    0x30,0x78,0x38,0x31,0x37,0x46,0x37,0x46,0x46,0x45,0x55,0x2c,0x0a,0x30,0x78,0x46,0x30,0x35,0x30,0x35,0x30,0x41,0x30,0x55,0x2c,0x30,0x78,0x34,0x34,0x33,0x43,0x33,
+    0x43,0x37,0x38,0x55,0x2c,0x30,0x78,0x42,0x41,0x39,0x46,0x39,0x46,0x32,0x35,0x55,0x2c,0x30,0x78,0x45,0x33,0x41,0x38,0x41,0x38,0x34,0x42,0x55,0x2c,0x0a,0x30,0x78,
+    0x46,0x33,0x35,0x31,0x35,0x31,0x41,0x32,0x55,0x2c,0x30,0x78,0x46,0x45,0x41,0x33,0x41,0x33,0x35,0x44,0x55,0x2c,0x30,0x78,0x43,0x30,0x34,0x30,0x34,0x30,0x38,0x30,
+    0x55,0x2c,0x30,0x78,0x38,0x41,0x38,0x46,0x38,0x46,0x30,0x35,0x55,0x2c,0x0a,0x30,0x78,0x41,0x44,0x39,0x32,0x39,0x32,0x33,0x46,0x55,0x2c,0x30,0x78,0x42,0x43,0x39,
+    0x44,0x39,0x44,0x32,0x31,0x55,0x2c,0x30,0x78,0x34,0x38,0x33,0x38,0x33,0x38,0x37,0x30,0x55,0x2c,0x30,0x78,0x30,0x34,0x46,0x35,0x46,0x35,0x46,0x31,0x55,0x2c,0x0a,
+    0x30,0x78,0x44,0x46,0x42,0x43,0x42,0x43,0x36,0x33,0x55,0x2c,0x30,0x78,0x43,0x31,0x42,0x36,0x42,0x36,0x37,0x37,0x55,0x2c,0x30,0x78,0x37,0x35,0x44,0x41,0x44,0x41,
+    0x41,0x46,0x55,0x2c,0x30,0x78,0x36,0x33,0x32,0x31,0x32,0x31,0x34,0x32,0x55,0x2c,0x0a,0x30,0x78,0x33,0x30,0x31,0x30,0x31,0x30,0x32,0x30,0x55,0x2c,0x30,0x78,0x31,
+    0x41,0x46,0x46,0x46,0x46,0x45,0x35,0x55,0x2c,0x30,0x78,0x30,0x45,0x46,0x33,0x46,0x33,0x46,0x44,0x55,0x2c,0x30,0x78,0x36,0x44,0x44,0x32,0x44,0x32,0x42,0x46,0x55,
+    0x2c,0x0a,0x30,0x78,0x34,0x43,0x43,0x44,0x43,0x44,0x38,0x31,0x55,0x2c,0x30,0x78,0x31,0x34,0x30,0x43,0x30,0x43,0x31,0x38,0x55,0x2c,0x30,0x78,0x33,0x35,0x31,0x33,
+    0x31,0x33,0x32,0x36,0x55,0x2c,0x30,0x78,0x32,0x46,0x45,0x43,0x45,0x43,0x43,0x33,0x55,0x2c,0x0a,0x30,0x78,0x45,0x31,0x35,0x46,0x35,0x46,0x42,0x45,0x55,0x2c,0x30,
+    0x78,0x41,0x32,0x39,0x37,0x39,0x37,0x33,0x35,0x55,0x2c,0x30,0x78,0x43,0x43,0x34,0x34,0x34,0x34,0x38,0x38,0x55,0x2c,0x30,0x78,0x33,0x39,0x31,0x37,0x31,0x37,0x32,
+    0x45,0x55,0x2c,0x0a,0x30,0x78,0x35,0x37,0x43,0x34,0x43,0x34,0x39,0x33,0x55,0x2c,0x30,0x78,0x46,0x32,0x41,0x37,0x41,0x37,0x35,0x35,0x55,0x2c,0x30,0x78,0x38,0x32,
+    0x37,0x45,0x37,0x45,0x46,0x43,0x55,0x2c,0x30,0x78,0x34,0x37,0x33,0x44,0x33,0x44,0x37,0x41,0x55,0x2c,0x0a,0x30,0x78,0x41,0x43,0x36,0x34,0x36,0x34,0x43,0x38,0x55,
+    0x2c,0x30,0x78,0x45,0x37,0x35,0x44,0x35,0x44,0x42,0x41,0x55,0x2c,0x30,0x78,0x32,0x42,0x31,0x39,0x31,0x39,0x33,0x32,0x55,0x2c,0x30,0x78,0x39,0x35,0x37,0x33,0x37,
+    0x33,0x45,0x36,0x55,0x2c,0x0a,0x30,0x78,0x41,0x30,0x36,0x30,0x36,0x30,0x43,0x30,0x55,0x2c,0x30,0x78,0x39,0x38,0x38,0x31,0x38,0x31,0x31,0x39,0x55,0x2c,0x30,0x78,
+    0x44,0x31,0x34,0x46,0x34,0x46,0x39,0x45,0x55,0x2c,0x30,0x78,0x37,0x46,0x44,0x43,0x44,0x43,0x41,0x33,0x55,0x2c,0x0a,0x30,0x78,0x36,0x36,0x32,0x32,0x32,0x32,0x34,
+    0x34,0x55,0x2c,0x30,0x78,0x37,0x45,0x32,0x41,0x32,0x41,0x35,0x34,0x55,0x2c,0x30,0x78,0x41,0x42,0x39,0x30,0x39,0x30,0x33,0x42,0x55,0x2c,0x30,0x78,0x38,0x33,0x38,
+    0x38,0x38,0x38,0x30,0x42,0x55,0x2c,0x0a,0x30,0x78,0x43,0x41,0x34,0x36,0x34,0x36,0x38,0x43,0x55,0x2c,0x30,0x78,0x32,0x39,0x45,0x45,0x45,0x45,0x43,0x37,0x55,0x2c,
+    0x30,0x78,0x44,0x33,0x42,0x38,0x42,0x38,0x36,0x42,0x55,0x2c,0x30,0x78,0x33,0x43,0x31,0x34,0x31,0x34,0x32,0x38,0x55,0x2c,0x0a,0x30,0x78,0x37,0x39,0x44,0x45,0x44,
+    0x45,0x41,0x37,0x55,0x2c,0x30,0x78,0x45,0x32,0x35,0x45,0x35,0x45,0x42,0x43,0x55,0x2c,0x30,0x78,0x31,0x44,0x30,0x42,0x30,0x42,0x31,0x36,0x55,0x2c,0x30,0x78,0x37,
+    0x36,0x44,0x42,0x44,0x42,0x41,0x44,0x55,0x2c,0x0a,0x30,0x78,0x33,0x42,0x45,0x30,0x45,0x30,0x44,0x42,0x55,0x2c,0x30,0x78,0x35,0x36,0x33,0x32,0x33,0x32,0x36,0x34,
+    0x55,0x2c,0x30,0x78,0x34,0x45,0x33,0x41,0x33,0x41,0x37,0x34,0x55,0x2c,0x30,0x78,0x31,0x45,0x30,0x41,0x30,0x41,0x31,0x34,0x55,0x2c,0x0a,0x30,0x78,0x44,0x42,0x34,
+    0x39,0x34,0x39,0x39,0x32,0x55,0x2c,0x30,0x78,0x30,0x41,0x30,0x36,0x30,0x36,0x30,0x43,0x55,0x2c,0x30,0x78,0x36,0x43,0x32,0x34,0x32,0x34,0x34,0x38,0x55,0x2c,0x30,
+    0x78,0x45,0x34,0x35,0x43,0x35,0x43,0x42,0x38,0x55,0x2c,0x0a,0x30,0x78,0x35,0x44,0x43,0x32,0x43,0x32,0x39,0x46,0x55,0x2c,0x30,0x78,0x36,0x45,0x44,0x33,0x44,0x33,
+    0x42,0x44,0x55,0x2c,0x30,0x78,0x45,0x46,0x41,0x43,0x41,0x43,0x34,0x33,0x55,0x2c,0x30,0x78,0x41,0x36,0x36,0x32,0x36,0x32,0x43,0x34,0x55,0x2c,0x0a,0x30,0x78,0x41,
+    0x38,0x39,0x31,0x39,0x31,0x33,0x39,0x55,0x2c,0x30,0x78,0x41,0x34,0x39,0x35,0x39,0x35,0x33,0x31,0x55,0x2c,0x30,0x78,0x33,0x37,0x45,0x34,0x45,0x34,0x44,0x33,0x55,
+    0x2c,0x30,0x78,0x38,0x42,0x37,0x39,0x37,0x39,0x46,0x32,0x55,0x2c,0x0a,0x30,0x78,0x33,0x32,0x45,0x37,0x45,0x37,0x44,0x35,0x55,0x2c,0x30,0x78,0x34,0x33,0x43,0x38,
+    0x43,0x38,0x38,0x42,0x55,0x2c,0x30,0x78,0x35,0x39,0x33,0x37,0x33,0x37,0x36,0x45,0x55,0x2c,0x30,0x78,0x42,0x37,0x36,0x44,0x36,0x44,0x44,0x41,0x55,0x2c,0x0a,0x30,
+    0x78,0x38,0x43,0x38,0x44,0x38,0x44,0x30,0x31,0x55,0x2c,0x30,0x78,0x36,0x34,0x44,0x35,0x44,0x35,0x42,0x31,0x55,0x2c,0x30,0x78,0x44,0x32,0x34,0x45,0x34,0x45,0x39,
+    0x43,0x55,0x2c,0x30,0x78,0x45,0x30,0x41,0x39,0x41,0x39,0x34,0x39,0x55,0x2c,0x0a,0x30,0x78,0x42,0x34,0x36,0x43,0x36,0x43,0x44,0x38,0x55,0x2c,0x30,0x78,0x46,0x41,
+    0x35,0x36,0x35,0x36,0x41,0x43,0x55,0x2c,0x30,0x78,0x30,0x37,0x46,0x34,0x46,0x34,0x46,0x33,0x55,0x2c,0x30,0x78,0x32,0x35,0x45,0x41,0x45,0x41,0x43,0x46,0x55,0x2c,
+    0x0a,0x30,0x78,0x41,0x46,0x36,0x35,0x36,0x35,0x43,0x41,0x55,0x2c,0x30,0x78,0x38,0x45,0x37,0x41,0x37,0x41,0x46,0x34,0x55,0x2c,0x30,0x78,0x45,0x39,0x41,0x45,0x41,
+    0x45,0x34,0x37,0x55,0x2c,0x30,0x78,0x31,0x38,0x30,0x38,0x30,0x38,0x31,0x30,0x55,0x2c,0x0a,0x30,0x78,0x44,0x35,0x42,0x41,0x42,0x41,0x36,0x46,0x55,0x2c,0x30,0x78,
+    0x38,0x38,0x37,0x38,0x37,0x38,0x46,0x30,0x55,0x2c,0x30,0x78,0x36,0x46,0x32,0x35,0x32,0x35,0x34,0x41,0x55,0x2c,0x30,0x78,0x37,0x32,0x32,0x45,0x32,0x45,0x35,0x43,
+    0x55,0x2c,0x0a,0x30,0x78,0x32,0x34,0x31,0x43,0x31,0x43,0x33,0x38,0x55,0x2c,0x30,0x78,0x46,0x31,0x41,0x36,0x41,0x36,0x35,0x37,0x55,0x2c,0x30,0x78,0x43,0x37,0x42,
+    0x34,0x42,0x34,0x37,0x33,0x55,0x2c,0x30,0x78,0x35,0x31,0x43,0x36,0x43,0x36,0x39,0x37,0x55,0x2c,0x0a,0x30,0x78,0x32,0x33,0x45,0x38,0x45,0x38,0x43,0x42,0x55,0x2c,
+    0x30,0x78,0x37,0x43,0x44,0x44,0x44,0x44,0x41,0x31,0x55,0x2c,0x30,0x78,0x39,0x43,0x37,0x34,0x37,0x34,0x45,0x38,0x55,0x2c,0x30,0x78,0x32,0x31,0x31,0x46,0x31,0x46,
+    0x33,0x45,0x55,0x2c,0x0a,0x30,0x78,0x44,0x44,0x34,0x42,0x34,0x42,0x39,0x36,0x55,0x2c,0x30,0x78,0x44,0x43,0x42,0x44,0x42,0x44,0x36,0x31,0x55,0x2c,0x30,0x78,0x38,
+    0x36,0x38,0x42,0x38,0x42,0x30,0x44,0x55,0x2c,0x30,0x78,0x38,0x35,0x38,0x41,0x38,0x41,0x30,0x46,0x55,0x2c,0x0a,0x30,0x78,0x39,0x30,0x37,0x30,0x37,0x30,0x45,0x30,
+    0x55,0x2c,0x30,0x78,0x34,0x32,0x33,0x45,0x33,0x45,0x37,0x43,0x55,0x2c,0x30,0x78,0x43,0x34,0x42,0x35,0x42,0x35,0x37,0x31,0x55,0x2c,0x30,0x78,0x41,0x41,0x36,0x36,
+    0x36,0x36,0x43,0x43,0x55,0x2c,0x0a,0x30,0x78,0x44,0x38,0x34,0x38,0x34,0x38,0x39,0x30,0x55,0x2c,0x30,0x78,0x30,0x35,0x30,0x33,0x30,0x33,0x30,0x36,0x55,0x2c,0x30,
+    0x78,0x30,0x31,0x46,0x36,0x46,0x36,0x46,0x37,0x55,0x2c,0x30,0x78,0x31,0x32,0x30,0x45,0x30,0x45,0x31,0x43,0x55,0x2c,0x0a,0x30,0x78,0x41,0x33,0x36,0x31,0x36,0x31,
+    0x43,0x32,0x55,0x2c,0x30,0x78,0x35,0x46,0x33,0x35,0x33,0x35,0x36,0x41,0x55,0x2c,0x30,0x78,0x46,0x39,0x35,0x37,0x35,0x37,0x41,0x45,0x55,0x2c,0x30,0x78,0x44,0x30,
+    0x42,0x39,0x42,0x39,0x36,0x39,0x55,0x2c,0x0a,0x30,0x78,0x39,0x31,0x38,0x36,0x38,0x36,0x31,0x37,0x55,0x2c,0x30,0x78,0x35,0x38,0x43,0x31,0x43,0x31,0x39,0x39,0x55,
+    0x2c,0x30,0x78,0x32,0x37,0x31,0x44,0x31,0x44,0x33,0x41,0x55,0x2c,0x30,0x78,0x42,0x39,0x39,0x45,0x39,0x45,0x32,0x37,0x55,0x2c,0x0a,0x30,0x78,0x33,0x38,0x45,0x31,
+    0x45,0x31,0x44,0x39,0x55,0x2c,0x30,0x78,0x31,0x33,0x46,0x38,0x46,0x38,0x45,0x42,0x55,0x2c,0x30,0x78,0x42,0x33,0x39,0x38,0x39,0x38,0x32,0x42,0x55,0x2c,0x30,0x78,
+    0x33,0x33,0x31,0x31,0x31,0x31,0x32,0x32,0x55,0x2c,0x0a,0x30,0x78,0x42,0x42,0x36,0x39,0x36,0x39,0x44,0x32,0x55,0x2c,0x30,0x78,0x37,0x30,0x44,0x39,0x44,0x39,0x41,
+    0x39,0x55,0x2c,0x30,0x78,0x38,0x39,0x38,0x45,0x38,0x45,0x30,0x37,0x55,0x2c,0x30,0x78,0x41,0x37,0x39,0x34,0x39,0x34,0x33,0x33,0x55,0x2c,0x0a,0x30,0x78,0x42,0x36,
+    0x39,0x42,0x39,0x42,0x32,0x44,0x55,0x2c,0x30,0x78,0x32,0x32,0x31,0x45,0x31,0x45,0x33,0x43,0x55,0x2c,0x30,0x78,0x39,0x32,0x38,0x37,0x38,0x37,0x31,0x35,0x55,0x2c,
+    0x30,0x78,0x32,0x30,0x45,0x39,0x45,0x39,0x43,0x39,0x55,0x2c,0x0a,0x30,0x78,0x34,0x39,0x43,0x45,0x43,0x45,0x38,0x37,0x55,0x2c,0x30,0x78,0x46,0x46,0x35,0x35,0x35,
+    0x35,0x41,0x41,0x55,0x2c,0x30,0x78,0x37,0x38,0x32,0x38,0x32,0x38,0x35,0x30,0x55,0x2c,0x30,0x78,0x37,0x41,0x44,0x46,0x44,0x46,0x41,0x35,0x55,0x2c,0x0a,0x30,0x78,
+    0x38,0x46,0x38,0x43,0x38,0x43,0x30,0x33,0x55,0x2c,0x30,0x78,0x46,0x38,0x41,0x31,0x41,0x31,0x35,0x39,0x55,0x2c,0x30,0x78,0x38,0x30,0x38,0x39,0x38,0x39,0x30,0x39,
+    0x55,0x2c,0x30,0x78,0x31,0x37,0x30,0x44,0x30,0x44,0x31,0x41,0x55,0x2c,0x0a,0x30,0x78,0x44,0x41,0x42,0x46,0x42,0x46,0x36,0x35,0x55,0x2c,0x30,0x78,0x33,0x31,0x45,
+    0x36,0x45,0x36,0x44,0x37,0x55,0x2c,0x30,0x78,0x43,0x36,0x34,0x32,0x34,0x32,0x38,0x34,0x55,0x2c,0x30,0x78,0x42,0x38,0x36,0x38,0x36,0x38,0x44,0x30,0x55,0x2c,0x0a,
+    0x30,0x78,0x43,0x33,0x34,0x31,0x34,0x31,0x38,0x32,0x55,0x2c,0x30,0x78,0x42,0x30,0x39,0x39,0x39,0x39,0x32,0x39,0x55,0x2c,0x30,0x78,0x37,0x37,0x32,0x44,0x32,0x44,
+    0x35,0x41,0x55,0x2c,0x30,0x78,0x31,0x31,0x30,0x46,0x30,0x46,0x31,0x45,0x55,0x2c,0x0a,0x30,0x78,0x43,0x42,0x42,0x30,0x42,0x30,0x37,0x42,0x55,0x2c,0x30,0x78,0x46,
+    0x43,0x35,0x34,0x35,0x34,0x41,0x38,0x55,0x2c,0x30,0x78,0x44,0x36,0x42,0x42,0x42,0x42,0x36,0x44,0x55,0x2c,0x30,0x78,0x33,0x41,0x31,0x36,0x31,0x36,0x32,0x43,0x55,
+    0x0a,0x7d,0x3b,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x42,0x59,0x54,0x45,0x28,0x78,0x2c,0x20,0x79,0x29,0x20,0x28,0x78,0x6d,0x72,0x69,0x67,0x5f,0x61,0x6d,
+    0x64,0x5f,0x62,0x66,0x65,0x28,0x28,0x78,0x29,0x2c,0x20,0x28,0x79,0x29,0x20,0x3c,0x3c,0x20,0x33,0x55,0x2c,0x20,0x38,0x55,0x29,0x29,0x0a,0x23,0x69,0x66,0x20,0x28,
+    0x41,0x4c,0x47,0x4f,0x20,0x3d,0x3d,0x20,0x41,0x4c,0x47,0x4f,0x5f,0x43,0x4e,0x5f,0x48,0x45,0x41,0x56,0x59,0x5f,0x54,0x55,0x42,0x45,0x29,0x0a,0x69,0x6e,0x6c,0x69,
+    0x6e,0x65,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x5f,0x62,0x69,0x74,0x74,0x75,0x62,0x65,0x32,0x28,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x78,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x6b,0x29,0x0a,0x7b,
+    0x0a,0x78,0x3d,0x7e,0x78,0x3b,0x0a,0x6b,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x30,0x29,
+    0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x33,0x29,
+    0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x6b,0x2e,0x73,0x30,0x3b,0x0a,0x6b,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,
+    0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,
+    0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,
+    0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x6b,
+    0x2e,0x73,0x31,0x3b,0x0a,0x6b,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x30,0x29,0x5d,0x5e,
+    0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,
+    0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x2c,
+    0x31,0x36,0x55,0x29,0x3b,0x0a,0x78,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x6b,0x2e,0x73,0x32,0x3b,0x0a,0x6b,0x2e,0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x30,0x2c,0x31,0x29,
+    0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x78,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x3b,0x0a,0x7d,
+    0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x28,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,
+    0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,
+    0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,
+    0x53,0x32,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x33,0x2c,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x58,0x2c,0x75,0x69,0x6e,0x74,0x34,0x20,0x6b,0x65,0x79,0x29,0x0a,0x7b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x30,0x20,0x5e,0x3d,
+    0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,
+    0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,
+    0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,
+    0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,
+    0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,
+    0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x30,0x29,
+    0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,
+    0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x2e,
+    0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x31,0x29,0x5d,0x5e,0x41,0x45,0x53,0x32,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,
+    0x45,0x53,0x33,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x65,0x79,0x3b,0x0a,0x7d,
+    0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,0x64,0x5f,0x54,0x77,0x6f,0x5f,0x54,0x61,0x62,0x6c,0x65,0x73,0x28,0x63,0x6f,0x6e,0x73,
+    0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x30,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x20,0x2a,0x41,0x45,0x53,0x31,0x2c,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x58,0x2c,0x75,0x69,0x6e,0x74,
+    0x34,0x20,0x6b,0x65,0x79,0x29,0x0a,0x7b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,
+    0x30,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,
+    0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,
+    0x33,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,
+    0x58,0x2e,0x73,0x31,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x31,0x29,0x5d,0x5e,0x72,0x6f,0x74,0x61,
+    0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,
+    0x58,0x2e,0x73,0x30,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x32,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x31,0x29,0x5d,0x5e,0x72,
+    0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,
+    0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x6b,0x65,0x79,0x2e,0x73,0x33,0x20,0x5e,0x3d,0x20,0x41,0x45,0x53,0x30,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x33,0x2c,0x30,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x30,0x2c,0x31,0x29,
+    0x5d,0x5e,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x41,0x45,0x53,0x30,0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x31,0x2c,0x32,0x29,0x5d,0x5e,0x41,0x45,0x53,0x31,
+    0x5b,0x42,0x59,0x54,0x45,0x28,0x58,0x2e,0x73,0x32,0x2c,0x33,0x29,0x5d,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x72,0x65,0x74,0x75,0x72,0x6e,0x20,0x6b,0x65,0x79,0x3b,
+    0x0a,0x7d,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x63,0x68,0x61,0x72,
+    0x20,0x72,0x63,0x6f,0x6e,0x5b,0x38,0x5d,0x3d,0x7b,0x20,0x30,0x78,0x38,0x64,0x2c,0x30,0x78,0x30,0x31,0x2c,0x30,0x78,0x30,0x32,0x2c,0x30,0x78,0x30,0x34,0x2c,0x30,
+    0x78,0x30,0x38,0x2c,0x30,0x78,0x31,0x30,0x2c,0x30,0x78,0x32,0x30,0x2c,0x30,0x78,0x34,0x30,0x20,0x7d,0x3b,0x0a,0x73,0x74,0x61,0x74,0x69,0x63,0x20,0x63,0x6f,0x6e,
+    0x73,0x74,0x20,0x5f,0x5f,0x63,0x6f,0x6e,0x73,0x74,0x61,0x6e,0x74,0x20,0x75,0x63,0x68,0x61,0x72,0x20,0x73,0x62,0x6f,0x78,0x5b,0x32,0x35,0x36,0x5d,0x20,0x3d,0x0a,
+    0x7b,0x0a,0x30,0x78,0x36,0x33,0x2c,0x30,0x78,0x37,0x43,0x2c,0x30,0x78,0x37,0x37,0x2c,0x30,0x78,0x37,0x42,0x2c,0x30,0x78,0x46,0x32,0x2c,0x30,0x78,0x36,0x42,0x2c,
+    0x30,0x78,0x36,0x46,0x2c,0x30,0x78,0x43,0x35,0x2c,0x30,0x78,0x33,0x30,0x2c,0x30,0x78,0x30,0x31,0x2c,0x30,0x78,0x36,0x37,0x2c,0x30,0x78,0x32,0x42,0x2c,0x30,0x78,
+    0x46,0x45,0x2c,0x30,0x78,0x44,0x37,0x2c,0x30,0x78,0x41,0x42,0x2c,0x30,0x78,0x37,0x36,0x2c,0x0a,0x30,0x78,0x43,0x41,0x2c,0x30,0x78,0x38,0x32,0x2c,0x30,0x78,0x43,
+    0x39,0x2c,0x30,0x78,0x37,0x44,0x2c,0x30,0x78,0x46,0x41,0x2c,0x30,0x78,0x35,0x39,0x2c,0x30,0x78,0x34,0x37,0x2c,0x30,0x78,0x46,0x30,0x2c,0x30,0x78,0x41,0x44,0x2c,
+    0x30,0x78,0x44,0x34,0x2c,0x30,0x78,0x41,0x32,0x2c,0x30,0x78,0x41,0x46,0x2c,0x30,0x78,0x39,0x43,0x2c,0x30,0x78,0x41,0x34,0x2c,0x30,0x78,0x37,0x32,0x2c,0x30,0x78,
+    0x43,0x30,0x2c,0x0a,0x30,0x78,0x42,0x37,0x2c,0x30,0x78,0x46,0x44,0x2c,0x30,0x78,0x39,0x33,0x2c,0x30,0x78,0x32,0x36,0x2c,0x30,0x78,0x33,0x36,0x2c,0x30,0x78,0x33,
+    0x46,0x2c,0x30,0x78,0x46,0x37,0x2c,0x30,0x78,0x43,0x43,0x2c,0x30,0x78,0x33,0x34,0x2c,0x30,0x78,0x41,0x35,0x2c,0x30,0x78,0x45,0x35,0x2c,0x30,0x78,0x46,0x31,0x2c,
+    0x30,0x78,0x37,0x31,0x2c,0x30,0x78,0x44,0x38,0x2c,0x30,0x78,0x33,0x31,0x2c,0x30,0x78,0x31,0x35,0x2c,0x0a,0x30,0x78,0x30,0x34,0x2c,0x30,0x78,0x43,0x37,0x2c,0x30,
+    0x78,0x32,0x33,0x2c,0x30,0x78,0x43,0x33,0x2c,0x30,0x78,0x31,0x38,0x2c,0x30,0x78,0x39,0x36,0x2c,0x30,0x78,0x30,0x35,0x2c,0x30,0x78,0x39,0x41,0x2c,0x30,0x78,0x30,
+    0x37,0x2c,0x30,0x78,0x31,0x32,0x2c,0x30,0x78,0x38,0x30,0x2c,0x30,0x78,0x45,0x32,0x2c,0x30,0x78,0x45,0x42,0x2c,0x30,0x78,0x32,0x37,0x2c,0x30,0x78,0x42,0x32,0x2c,
+    0x30,0x78,0x37,0x35,0x2c,0x0a,0x30,0x78,0x30,0x39,0x2c,0x30,0x78,0x38,0x33,0x2c,0x30,0x78,0x32,0x43,0x2c,0x30,0x78,0x31,0x41,0x2c,0x30,0x78,0x31,0x42,0x2c,0x30,
+    0x78,0x36,0x45,0x2c,0x30,0x78,0x35,0x41,0x2c,0x30,0x78,0x41,0x30,0x2c,0x30,0x78,0x35,0x32,0x2c,0x30,0x78,0x33,0x42,0x2c,0x30,0x78,0x44,0x36,0x2c,0x30,0x78,0x42,
+    0x33,0x2c,0x30,0x78,0x32,0x39,0x2c,0x30,0x78,0x45,0x33,0x2c,0x30,0x78,0x32,0x46,0x2c,0x30,0x78,0x38,0x34,0x2c,0x0a,0x30,0x78,0x35,0x33,0x2c,0x30,0x78,0x44,0x31,
+    0x2c,0x30,0x78,0x30,0x30,0x2c,0x30,0x78,0x45,0x44,0x2c,0x30,0x78,0x32,0x30,0x2c,0x30,0x78,0x46,0x43,0x2c,0x30,0x78,0x42,0x31,0x2c,0x30,0x78,0x35,0x42,0x2c,0x30,
+    0x78,0x36,0x41,0x2c,0x30,0x78,0x43,0x42,0x2c,0x30,0x78,0x42,0x45,0x2c,0x30,0x78,0x33,0x39,0x2c,0x30,0x78,0x34,0x41,0x2c,0x30,0x78,0x34,0x43,0x2c,0x30,0x78,0x35,
+    0x38,0x2c,0x30,0x78,0x43,0x46,0x2c,0x0a,0x30,0x78,0x44,0x30,0x2c,0x30,0x78,0x45,0x46,0x2c,0x30,0x78,0x41,0x41,0x2c,0x30,0x78,0x46,0x42,0x2c,0x30,0x78,0x34,0x33,
+    0x2c,0x30,0x78,0x34,0x44,0x2c,0x30,0x78,0x33,0x33,0x2c,0x30,0x78,0x38,0x35,0x2c,0x30,0x78,0x34,0x35,0x2c,0x30,0x78,0x46,0x39,0x2c,0x30,0x78,0x30,0x32,0x2c,0x30,
+    0x78,0x37,0x46,0x2c,0x30,0x78,0x35,0x30,0x2c,0x30,0x78,0x33,0x43,0x2c,0x30,0x78,0x39,0x46,0x2c,0x30,0x78,0x41,0x38,0x2c,0x0a,0x30,0x78,0x35,0x31,0x2c,0x30,0x78,
+    0x41,0x33,0x2c,0x30,0x78,0x34,0x30,0x2c,0x30,0x78,0x38,0x46,0x2c,0x30,0x78,0x39,0x32,0x2c,0x30,0x78,0x39,0x44,0x2c,0x30,0x78,0x33,0x38,0x2c,0x30,0x78,0x46,0x35,
+    0x2c,0x30,0x78,0x42,0x43,0x2c,0x30,0x78,0x42,0x36,0x2c,0x30,0x78,0x44,0x41,0x2c,0x30,0x78,0x32,0x31,0x2c,0x30,0x78,0x31,0x30,0x2c,0x30,0x78,0x46,0x46,0x2c,0x30,
+    0x78,0x46,0x33,0x2c,0x30,0x78,0x44,0x32,0x2c,0x0a,0x30,0x78,0x43,0x44,0x2c,0x30,0x78,0x30,0x43,0x2c,0x30,0x78,0x31,0x33,0x2c,0x30,0x78,0x45,0x43,0x2c,0x30,0x78,
+    0x35,0x46,0x2c,0x30,0x78,0x39,0x37,0x2c,0x30,0x78,0x34,0x34,0x2c,0x30,0x78,0x31,0x37,0x2c,0x30,0x78,0x43,0x34,0x2c,0x30,0x78,0x41,0x37,0x2c,0x30,0x78,0x37,0x45,
+    0x2c,0x30,0x78,0x33,0x44,0x2c,0x30,0x78,0x36,0x34,0x2c,0x30,0x78,0x35,0x44,0x2c,0x30,0x78,0x31,0x39,0x2c,0x30,0x78,0x37,0x33,0x2c,0x0a,0x30,0x78,0x36,0x30,0x2c,
+    0x30,0x78,0x38,0x31,0x2c,0x30,0x78,0x34,0x46,0x2c,0x30,0x78,0x44,0x43,0x2c,0x30,0x78,0x32,0x32,0x2c,0x30,0x78,0x32,0x41,0x2c,0x30,0x78,0x39,0x30,0x2c,0x30,0x78,
+    0x38,0x38,0x2c,0x30,0x78,0x34,0x36,0x2c,0x30,0x78,0x45,0x45,0x2c,0x30,0x78,0x42,0x38,0x2c,0x30,0x78,0x31,0x34,0x2c,0x30,0x78,0x44,0x45,0x2c,0x30,0x78,0x35,0x45,
+    0x2c,0x30,0x78,0x30,0x42,0x2c,0x30,0x78,0x44,0x42,0x2c,0x0a,0x30,0x78,0x45,0x30,0x2c,0x30,0x78,0x33,0x32,0x2c,0x30,0x78,0x33,0x41,0x2c,0x30,0x78,0x30,0x41,0x2c,
+    0x30,0x78,0x34,0x39,0x2c,0x30,0x78,0x30,0x36,0x2c,0x30,0x78,0x32,0x34,0x2c,0x30,0x78,0x35,0x43,0x2c,0x30,0x78,0x43,0x32,0x2c,0x30,0x78,0x44,0x33,0x2c,0x30,0x78,
+    0x41,0x43,0x2c,0x30,0x78,0x36,0x32,0x2c,0x30,0x78,0x39,0x31,0x2c,0x30,0x78,0x39,0x35,0x2c,0x30,0x78,0x45,0x34,0x2c,0x30,0x78,0x37,0x39,0x2c,0x0a,0x30,0x78,0x45,
+    0x37,0x2c,0x30,0x78,0x43,0x38,0x2c,0x30,0x78,0x33,0x37,0x2c,0x30,0x78,0x36,0x44,0x2c,0x30,0x78,0x38,0x44,0x2c,0x30,0x78,0x44,0x35,0x2c,0x30,0x78,0x34,0x45,0x2c,
+    0x30,0x78,0x41,0x39,0x2c,0x30,0x78,0x36,0x43,0x2c,0x30,0x78,0x35,0x36,0x2c,0x30,0x78,0x46,0x34,0x2c,0x30,0x78,0x45,0x41,0x2c,0x30,0x78,0x36,0x35,0x2c,0x30,0x78,
+    0x37,0x41,0x2c,0x30,0x78,0x41,0x45,0x2c,0x30,0x78,0x30,0x38,0x2c,0x0a,0x30,0x78,0x42,0x41,0x2c,0x30,0x78,0x37,0x38,0x2c,0x30,0x78,0x32,0x35,0x2c,0x30,0x78,0x32,
+    0x45,0x2c,0x30,0x78,0x31,0x43,0x2c,0x30,0x78,0x41,0x36,0x2c,0x30,0x78,0x42,0x34,0x2c,0x30,0x78,0x43,0x36,0x2c,0x30,0x78,0x45,0x38,0x2c,0x30,0x78,0x44,0x44,0x2c,
+    0x30,0x78,0x37,0x34,0x2c,0x30,0x78,0x31,0x46,0x2c,0x30,0x78,0x34,0x42,0x2c,0x30,0x78,0x42,0x44,0x2c,0x30,0x78,0x38,0x42,0x2c,0x30,0x78,0x38,0x41,0x2c,0x0a,0x30,
+    0x78,0x37,0x30,0x2c,0x30,0x78,0x33,0x45,0x2c,0x30,0x78,0x42,0x35,0x2c,0x30,0x78,0x36,0x36,0x2c,0x30,0x78,0x34,0x38,0x2c,0x30,0x78,0x30,0x33,0x2c,0x30,0x78,0x46,
+    0x36,0x2c,0x30,0x78,0x30,0x45,0x2c,0x30,0x78,0x36,0x31,0x2c,0x30,0x78,0x33,0x35,0x2c,0x30,0x78,0x35,0x37,0x2c,0x30,0x78,0x42,0x39,0x2c,0x30,0x78,0x38,0x36,0x2c,
+    0x30,0x78,0x43,0x31,0x2c,0x30,0x78,0x31,0x44,0x2c,0x30,0x78,0x39,0x45,0x2c,0x0a,0x30,0x78,0x45,0x31,0x2c,0x30,0x78,0x46,0x38,0x2c,0x30,0x78,0x39,0x38,0x2c,0x30,
+    0x78,0x31,0x31,0x2c,0x30,0x78,0x36,0x39,0x2c,0x30,0x78,0x44,0x39,0x2c,0x30,0x78,0x38,0x45,0x2c,0x30,0x78,0x39,0x34,0x2c,0x30,0x78,0x39,0x42,0x2c,0x30,0x78,0x31,
+    0x45,0x2c,0x30,0x78,0x38,0x37,0x2c,0x30,0x78,0x45,0x39,0x2c,0x30,0x78,0x43,0x45,0x2c,0x30,0x78,0x35,0x35,0x2c,0x30,0x78,0x32,0x38,0x2c,0x30,0x78,0x44,0x46,0x2c,
+    0x0a,0x30,0x78,0x38,0x43,0x2c,0x30,0x78,0x41,0x31,0x2c,0x30,0x78,0x38,0x39,0x2c,0x30,0x78,0x30,0x44,0x2c,0x30,0x78,0x42,0x46,0x2c,0x30,0x78,0x45,0x36,0x2c,0x30,
+    0x78,0x34,0x32,0x2c,0x30,0x78,0x36,0x38,0x2c,0x30,0x78,0x34,0x31,0x2c,0x30,0x78,0x39,0x39,0x2c,0x30,0x78,0x32,0x44,0x2c,0x30,0x78,0x30,0x46,0x2c,0x30,0x78,0x42,
+    0x30,0x2c,0x30,0x78,0x35,0x34,0x2c,0x30,0x78,0x42,0x42,0x2c,0x30,0x78,0x31,0x36,0x0a,0x7d,0x3b,0x0a,0x23,0x64,0x65,0x66,0x69,0x6e,0x65,0x20,0x53,0x75,0x62,0x57,
+    0x6f,0x72,0x64,0x28,0x69,0x6e,0x77,0x29,0x20,0x28,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x33,0x29,0x5d,0x20,0x3c,0x3c,
+    0x20,0x32,0x34,0x29,0x20,0x7c,0x20,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x32,0x29,0x5d,0x20,0x3c,0x3c,0x20,0x31,0x36,
+    0x29,0x20,0x7c,0x20,0x28,0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x31,0x29,0x5d,0x20,0x3c,0x3c,0x20,0x38,0x29,0x20,0x7c,0x20,
+    0x73,0x62,0x6f,0x78,0x5b,0x42,0x59,0x54,0x45,0x28,0x69,0x6e,0x77,0x2c,0x20,0x30,0x29,0x5d,0x29,0x0a,0x76,0x6f,0x69,0x64,0x20,0x41,0x45,0x53,0x45,0x78,0x70,0x61,
+    0x6e,0x64,0x4b,0x65,0x79,0x32,0x35,0x36,0x28,0x75,0x69,0x6e,0x74,0x20,0x2a,0x6b,0x65,0x79,0x62,0x75,0x66,0x29,0x0a,0x7b,0x0a,0x66,0x6f,0x72,0x20,0x28,0x75,0x69,
+    0x6e,0x74,0x20,0x63,0x3d,0x38,0x2c,0x69,0x3d,0x31,0x3b,0x20,0x63,0x3c,0x34,0x30,0x3b,0x20,0x2b,0x2b,0x63,0x29,0x20,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x74,0x3d,
+    0x28,0x28,0x21,0x28,0x63,0x26,0x37,0x29,0x29,0x7c,0x7c,0x28,0x28,0x63,0x26,0x37,0x29,0x3d,0x3d,0x34,0x29,0x29,0x3f,0x53,0x75,0x62,0x57,0x6f,0x72,0x64,0x28,0x6b,
+    0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x31,0x5d,0x29,0x3a,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x31,0x5d,0x3b,0x0a,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,
+    0x63,0x5d,0x3d,0x6b,0x65,0x79,0x62,0x75,0x66,0x5b,0x63,0x2d,0x38,0x5d,0x5e,0x28,0x28,0x21,0x28,0x63,0x26,0x37,0x29,0x29,0x3f,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,
+    0x74,0x2c,0x32,0x34,0x55,0x29,0x5e,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x28,0x28,0x75,0x63,0x68,0x61,0x72,0x34,0x29,0x28,0x72,0x63,0x6f,0x6e,0x5b,0x69,0x2b,0x2b,
+    0x5d,0x2c,0x30,0x55,0x2c,0x30,0x55,0x2c,0x30,0x55,0x29,0x29,0x3a,0x74,0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x00
+};
+
+static char cryptonight_r_cl[3424] = {
+    0x5f,0x5f,0x61,0x74,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x5f,0x5f,0x28,0x28,0x72,0x65,0x71,0x64,0x5f,0x77,0x6f,0x72,0x6b,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x73,
+    0x69,0x7a,0x65,0x28,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x2c,0x31,0x2c,0x31,0x29,0x29,0x29,0x0a,0x5f,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x20,0x76,0x6f,0x69,
+    0x64,0x20,0x4b,0x45,0x52,0x4e,0x45,0x4c,0x5f,0x4e,0x41,0x4d,0x45,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x69,0x6e,
+    0x70,0x75,0x74,0x2c,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2c,0x5f,
+    0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x2a,0x73,0x74,0x61,0x74,0x65,0x73,0x2c,0x75,0x69,0x6e,0x74,0x20,0x54,0x68,0x72,0x65,0x61,
+    0x64,0x73,0x29,0x0a,0x7b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x61,0x5b,0x32,0x5d,0x2c,0x62,0x5b,0x34,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,
+    0x69,0x6e,0x74,0x20,0x41,0x45,0x53,0x30,0x5b,0x32,0x35,0x36,0x5d,0x2c,0x41,0x45,0x53,0x31,0x5b,0x32,0x35,0x36,0x5d,0x2c,0x41,0x45,0x53,0x32,0x5b,0x32,0x35,0x36,
+    0x5d,0x2c,0x41,0x45,0x53,0x33,0x5b,0x32,0x35,0x36,0x5d,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x20,0x67,0x49,0x64,0x78,0x3d,0x67,0x65,
+    0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x2d,0x67,0x65,0x74,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,
+    0x28,0x30,0x29,0x3b,0x0a,0x66,0x6f,0x72,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x20,
+    0x69,0x3c,0x32,0x35,0x36,0x3b,0x20,0x69,0x2b,0x3d,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x29,0x20,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,
+    0x20,0x74,0x6d,0x70,0x3d,0x41,0x45,0x53,0x30,0x5f,0x43,0x5b,0x69,0x5d,0x3b,0x0a,0x41,0x45,0x53,0x30,0x5b,0x69,0x5d,0x3d,0x74,0x6d,0x70,0x3b,0x0a,0x41,0x45,0x53,
+    0x31,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x6d,0x70,0x2c,0x38,0x55,0x29,0x3b,0x0a,0x41,0x45,0x53,0x32,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,
+    0x61,0x74,0x65,0x28,0x74,0x6d,0x70,0x2c,0x31,0x36,0x55,0x29,0x3b,0x0a,0x41,0x45,0x53,0x33,0x5b,0x69,0x5d,0x3d,0x72,0x6f,0x74,0x61,0x74,0x65,0x28,0x74,0x6d,0x70,
+    0x2c,0x32,0x34,0x55,0x29,0x3b,0x0a,0x7d,0x0a,0x62,0x61,0x72,0x72,0x69,0x65,0x72,0x28,0x43,0x4c,0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,
+    0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x7b,0x0a,0x73,0x74,0x61,0x74,0x65,0x73,0x2b,0x3d,0x32,0x35,0x2a,0x67,0x49,0x64,0x78,0x3b,0x0a,0x23,0x69,0x66,0x20,0x64,0x65,
+    0x66,0x69,0x6e,0x65,0x64,0x28,0x5f,0x5f,0x4e,0x56,0x5f,0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x29,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,
+    0x70,0x61,0x64,0x2b,0x3d,0x67,0x49,0x64,0x78,0x2a,0x28,0x49,0x54,0x45,0x52,0x41,0x54,0x49,0x4f,0x4e,0x53,0x3e,0x3e,0x32,0x29,0x3b,0x0a,0x23,0x65,0x6c,0x73,0x65,
+    0x0a,0x23,0x69,0x66,0x20,0x28,0x53,0x54,0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x30,0x29,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,
+    0x68,0x70,0x61,0x64,0x2b,0x3d,0x67,0x49,0x64,0x78,0x2a,0x28,0x4d,0x45,0x4d,0x4f,0x52,0x59,0x3e,0x3e,0x34,0x29,0x3b,0x0a,0x23,0x65,0x6c,0x69,0x66,0x20,0x28,0x53,
+    0x54,0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x31,0x29,0x0a,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x3d,0x67,
+    0x49,0x64,0x78,0x3b,0x0a,0x23,0x65,0x6c,0x69,0x66,0x20,0x28,0x53,0x54,0x52,0x49,0x44,0x45,0x44,0x5f,0x49,0x4e,0x44,0x45,0x58,0x20,0x3d,0x3d,0x20,0x32,0x29,0x0a,
+    0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x2b,0x3d,0x67,0x65,0x74,0x5f,0x67,0x72,0x6f,0x75,0x70,0x5f,0x69,0x64,0x28,0x30,0x29,0x2a,0x28,0x4d,0x45,0x4d,
+    0x4f,0x52,0x59,0x3e,0x3e,0x34,0x29,0x2a,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x2b,0x4d,0x45,0x4d,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x2a,0x67,0x65,0x74,0x5f,0x6c,
+    0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x61,0x5b,0x30,0x5d,0x3d,0x73,
+    0x74,0x61,0x74,0x65,0x73,0x5b,0x30,0x5d,0x5e,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x34,0x5d,0x3b,0x0a,0x61,0x5b,0x31,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,
+    0x31,0x5d,0x5e,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x35,0x5d,0x3b,0x0a,0x62,0x5b,0x30,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x32,0x5d,0x5e,0x73,0x74,0x61,
+    0x74,0x65,0x73,0x5b,0x36,0x5d,0x3b,0x0a,0x62,0x5b,0x31,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x33,0x5d,0x5e,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x37,0x5d,
+    0x3b,0x0a,0x62,0x5b,0x32,0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x38,0x5d,0x5e,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x31,0x30,0x5d,0x3b,0x0a,0x62,0x5b,0x33,
+    0x5d,0x3d,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x39,0x5d,0x5e,0x73,0x74,0x61,0x74,0x65,0x73,0x5b,0x31,0x31,0x5d,0x3b,0x0a,0x7d,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x32,
+    0x20,0x62,0x78,0x30,0x3d,0x28,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x2a,0x29,0x62,0x29,0x5b,0x30,0x5d,0x3b,0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x62,0x78,
+    0x31,0x3d,0x28,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x2a,0x29,0x62,0x29,0x5b,0x31,0x5d,0x3b,0x0a,0x6d,0x65,0x6d,0x5f,0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,
+    0x4b,0x5f,0x4c,0x4f,0x43,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,
+    0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x31,0x36,0x20,0x73,0x63,0x72,0x61,
+    0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x5f,0x62,0x75,0x66,0x5b,0x57,0x4f,0x52,0x4b,0x53,0x49,0x5a,0x45,0x5d,0x3b,0x0a,0x5f,0x5f,0x6c,0x6f,0x63,
+    0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x31,0x36,0x2a,0x20,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x3d,0x73,0x63,0x72,0x61,0x74,
+    0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x5f,0x62,0x75,0x66,0x2b,0x67,0x65,0x74,0x5f,0x6c,0x6f,0x63,0x61,0x6c,0x5f,0x69,0x64,0x28,0x30,0x29,0x3b,0x0a,
+    0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x7b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x72,0x30,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x73,0x74,0x61,0x74,0x65,0x73,
+    0x5b,0x31,0x32,0x5d,0x29,0x2e,0x73,0x30,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x72,0x31,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x73,0x74,0x61,0x74,0x65,
+    0x73,0x5b,0x31,0x32,0x5d,0x29,0x2e,0x73,0x31,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x72,0x32,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x73,0x74,0x61,0x74,
+    0x65,0x73,0x5b,0x31,0x33,0x5d,0x29,0x2e,0x73,0x30,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x72,0x33,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x73,0x74,0x61,
+    0x74,0x65,0x73,0x5b,0x31,0x33,0x5d,0x29,0x2e,0x73,0x31,0x3b,0x0a,0x23,0x70,0x72,0x61,0x67,0x6d,0x61,0x20,0x75,0x6e,0x72,0x6f,0x6c,0x6c,0x20,0x43,0x4e,0x5f,0x55,
+    0x4e,0x52,0x4f,0x4c,0x4c,0x0a,0x66,0x6f,0x72,0x20,0x28,0x69,0x6e,0x74,0x20,0x69,0x3d,0x30,0x3b,0x20,0x69,0x3c,0x49,0x54,0x45,0x52,0x41,0x54,0x49,0x4f,0x4e,0x53,
+    0x3b,0x20,0x2b,0x2b,0x69,0x29,0x20,0x7b,0x0a,0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,
+    0x4e,0x0a,0x75,0x69,0x6e,0x74,0x20,0x69,0x64,0x78,0x3d,0x61,0x5b,0x30,0x5d,0x26,0x30,0x78,0x31,0x46,0x46,0x46,0x43,0x30,0x3b,0x0a,0x75,0x69,0x6e,0x74,0x20,0x69,
+    0x64,0x78,0x31,0x3d,0x61,0x5b,0x30,0x5d,0x26,0x30,0x78,0x33,0x30,0x3b,0x0a,0x2a,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x3d,
+    0x2a,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x31,0x36,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,
+    0x68,0x61,0x72,0x2a,0x29,0x28,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x2b,0x69,0x64,0x78,0x29,0x3b,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x75,0x69,
+    0x6e,0x74,0x20,0x69,0x64,0x78,0x3d,0x61,0x5b,0x30,0x5d,0x26,0x4d,0x41,0x53,0x4b,0x3b,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x75,0x69,0x6e,0x74,0x34,0x20,0x63,
+    0x3d,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x30,0x29,0x3b,0x0a,0x63,0x3d,0x41,0x45,0x53,0x5f,0x52,0x6f,0x75,0x6e,
+    0x64,0x28,0x41,0x45,0x53,0x30,0x2c,0x41,0x45,0x53,0x31,0x2c,0x41,0x45,0x53,0x32,0x2c,0x41,0x45,0x53,0x33,0x2c,0x63,0x2c,0x28,0x28,0x75,0x69,0x6e,0x74,0x34,0x20,
+    0x2a,0x29,0x61,0x29,0x5b,0x30,0x5d,0x29,0x3b,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x63,0x68,0x75,0x6e,0x6b,0x31,0x3d,
+    0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x31,0x29,0x29,0x3b,0x0a,
+    0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x63,0x68,0x75,0x6e,0x6b,0x32,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x53,0x43,
+    0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x32,0x29,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x32,
+    0x20,0x63,0x68,0x75,0x6e,0x6b,0x33,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,
+    0x4e,0x4b,0x28,0x33,0x29,0x29,0x3b,0x0a,0x63,0x20,0x5e,0x3d,0x20,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x31,0x29,0x5e,0x61,0x73,
+    0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x32,0x29,0x5e,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x33,0x29,0x3b,
+    0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x31,0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,
+    0x75,0x6e,0x6b,0x33,0x2b,0x62,0x78,0x31,0x29,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x32,0x29,0x3d,0x61,
+    0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x31,0x2b,0x62,0x78,0x30,0x29,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,
+    0x43,0x48,0x55,0x4e,0x4b,0x28,0x33,0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x32,0x2b,0x28,0x28,0x75,0x6c,0x6f,0x6e,0x67,
+    0x32,0x20,0x2a,0x29,0x61,0x29,0x5b,0x30,0x5d,0x29,0x3b,0x0a,0x7d,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x30,
+    0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x62,0x78,0x30,0x29,0x5e,0x63,0x3b,0x0a,0x23,0x69,0x66,0x64,0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,0x43,
+    0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x0a,0x2a,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x31,0x36,0x2a,0x29,0x28,
+    0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,0x28,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x2b,0x69,0x64,
+    0x78,0x29,0x3d,0x2a,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x3b,0x0a,0x69,0x64,0x78,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,
+    0x67,0x32,0x28,0x63,0x29,0x2e,0x73,0x30,0x26,0x30,0x78,0x31,0x46,0x46,0x46,0x43,0x30,0x3b,0x0a,0x69,0x64,0x78,0x31,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,
+    0x32,0x28,0x63,0x29,0x2e,0x73,0x30,0x26,0x30,0x78,0x33,0x30,0x3b,0x0a,0x2a,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x3d,0x2a,
+    0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x69,0x6e,0x74,0x31,0x36,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,
+    0x61,0x72,0x2a,0x29,0x28,0x53,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x29,0x2b,0x69,0x64,0x78,0x29,0x3b,0x0a,0x23,0x65,0x6c,0x73,0x65,0x0a,0x69,0x64,0x78,
+    0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x63,0x29,0x2e,0x73,0x30,0x26,0x4d,0x41,0x53,0x4b,0x3b,0x0a,0x23,0x65,0x6e,0x64,0x69,0x66,0x0a,0x75,0x69,
+    0x6e,0x74,0x34,0x20,0x74,0x6d,0x70,0x3d,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x30,0x29,0x3b,0x0a,0x74,0x6d,0x70,
+    0x2e,0x73,0x30,0x20,0x5e,0x3d,0x20,0x72,0x30,0x2b,0x72,0x31,0x3b,0x0a,0x74,0x6d,0x70,0x2e,0x73,0x31,0x20,0x5e,0x3d,0x20,0x72,0x32,0x2b,0x72,0x33,0x3b,0x0a,0x63,
+    0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x34,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,0x30,0x5d,0x29,0x2e,0x73,0x30,0x3b,0x0a,
+    0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x35,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,0x31,0x5d,0x29,0x2e,0x73,0x30,0x3b,
+    0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x36,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x62,0x78,0x30,0x29,0x2e,0x73,0x30,0x3b,
+    0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x37,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x62,0x78,0x31,0x29,0x2e,0x73,0x30,0x3b,
+    0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x20,0x72,0x38,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x62,0x78,0x31,0x29,0x2e,0x73,0x32,0x3b,
+    0x0a,0x58,0x4d,0x52,0x49,0x47,0x5f,0x49,0x4e,0x43,0x4c,0x55,0x44,0x45,0x5f,0x52,0x41,0x4e,0x44,0x4f,0x4d,0x5f,0x4d,0x41,0x54,0x48,0x0a,0x63,0x6f,0x6e,0x73,0x74,
+    0x20,0x75,0x69,0x6e,0x74,0x32,0x20,0x61,0x6c,0x3d,0x28,0x75,0x69,0x6e,0x74,0x32,0x29,0x28,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,0x30,0x5d,0x29,
+    0x2e,0x73,0x30,0x5e,0x72,0x32,0x2c,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,0x30,0x5d,0x29,0x2e,0x73,0x31,0x5e,0x72,0x33,0x29,0x3b,0x0a,0x63,0x6f,
+    0x6e,0x73,0x74,0x20,0x75,0x69,0x6e,0x74,0x32,0x20,0x61,0x68,0x3d,0x28,0x75,0x69,0x6e,0x74,0x32,0x29,0x28,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,
+    0x31,0x5d,0x29,0x2e,0x73,0x30,0x5e,0x72,0x30,0x2c,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x32,0x28,0x61,0x5b,0x31,0x5d,0x29,0x2e,0x73,0x31,0x5e,0x72,0x31,0x29,0x3b,
+    0x0a,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x74,0x3b,0x0a,0x74,0x2e,0x73,0x30,0x3d,0x6d,0x75,0x6c,0x5f,0x68,0x69,0x28,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,
+    0x28,0x63,0x29,0x2e,0x73,0x30,0x2c,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x74,0x6d,0x70,0x29,0x2e,0x73,0x30,0x29,0x3b,0x0a,0x74,0x2e,0x73,0x31,0x3d,
+    0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x63,0x29,0x2e,0x73,0x30,0x2a,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x74,0x6d,0x70,0x29,0x2e,0x73,
+    0x30,0x3b,0x0a,0x7b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x63,0x68,0x75,0x6e,0x6b,0x31,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,
+    0x67,0x32,0x28,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x31,0x29,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,
+    0x6c,0x6f,0x6e,0x67,0x32,0x20,0x63,0x68,0x75,0x6e,0x6b,0x32,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,
+    0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x32,0x29,0x29,0x3b,0x0a,0x63,0x6f,0x6e,0x73,0x74,0x20,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x63,0x68,0x75,0x6e,0x6b,0x33,
+    0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x33,0x29,0x29,0x3b,
+    0x0a,0x63,0x20,0x5e,0x3d,0x20,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x31,0x29,0x5e,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,
+    0x63,0x68,0x75,0x6e,0x6b,0x32,0x29,0x5e,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x33,0x29,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,
+    0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x31,0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x33,0x2b,0x62,0x78,
+    0x31,0x29,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x32,0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,
+    0x28,0x63,0x68,0x75,0x6e,0x6b,0x31,0x2b,0x62,0x78,0x30,0x29,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x33,
+    0x29,0x3d,0x61,0x73,0x5f,0x75,0x69,0x6e,0x74,0x34,0x28,0x63,0x68,0x75,0x6e,0x6b,0x32,0x2b,0x28,0x28,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x20,0x2a,0x29,0x61,0x29,0x5b,
+    0x30,0x5d,0x29,0x3b,0x0a,0x7d,0x0a,0x61,0x5b,0x31,0x5d,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x28,0x61,0x68,0x29,0x2b,0x74,0x2e,0x73,0x31,0x3b,0x0a,0x61,
+    0x5b,0x30,0x5d,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x28,0x61,0x6c,0x29,0x2b,0x74,0x2e,0x73,0x30,0x3b,0x0a,0x53,0x43,0x52,0x41,0x54,0x43,0x48,0x50,0x41,
+    0x44,0x5f,0x43,0x48,0x55,0x4e,0x4b,0x28,0x30,0x29,0x3d,0x28,0x28,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x29,0x61,0x29,0x5b,0x30,0x5d,0x3b,0x0a,0x23,0x69,0x66,0x64,
+    0x65,0x66,0x20,0x5f,0x5f,0x4e,0x56,0x5f,0x43,0x4c,0x5f,0x43,0x5f,0x56,0x45,0x52,0x53,0x49,0x4f,0x4e,0x0a,0x2a,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,
+    0x75,0x69,0x6e,0x74,0x31,0x36,0x2a,0x29,0x28,0x28,0x5f,0x5f,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x20,0x75,0x63,0x68,0x61,0x72,0x2a,0x29,0x28,0x53,0x63,0x72,0x61,0x74,
+    0x63,0x68,0x70,0x61,0x64,0x29,0x2b,0x69,0x64,0x78,0x29,0x3d,0x2a,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x5f,0x6c,0x69,0x6e,0x65,0x3b,0x0a,0x23,0x65,
+    0x6e,0x64,0x69,0x66,0x0a,0x28,0x28,0x75,0x69,0x6e,0x74,0x34,0x20,0x2a,0x29,0x61,0x29,0x5b,0x30,0x5d,0x20,0x5e,0x3d,0x20,0x74,0x6d,0x70,0x3b,0x0a,0x62,0x78,0x31,
+    0x3d,0x62,0x78,0x30,0x3b,0x0a,0x62,0x78,0x30,0x3d,0x61,0x73,0x5f,0x75,0x6c,0x6f,0x6e,0x67,0x32,0x28,0x63,0x29,0x3b,0x0a,0x7d,0x0a,0x7d,0x0a,0x6d,0x65,0x6d,0x5f,
+    0x66,0x65,0x6e,0x63,0x65,0x28,0x43,0x4c,0x4b,0x5f,0x47,0x4c,0x4f,0x42,0x41,0x4c,0x5f,0x4d,0x45,0x4d,0x5f,0x46,0x45,0x4e,0x43,0x45,0x29,0x3b,0x0a,0x7d,0x0a,0x00
+};
+
+} // namespace xmrig

src/backend/opencl/cl/cn/cryptonight_r_defines.cl

@@ -0,0 +1,16 @@
+#ifdef __NV_CL_C_VERSION
+#	define SCRATCHPAD_CHUNK(N) (*(__local uint4*)((__local uchar*)(scratchpad_line) + (idx1 ^ (N << 4))))
+#else
+#	if (STRIDED_INDEX == 0)
+#		define SCRATCHPAD_CHUNK(N) (*(__global uint4*)((__global uchar*)(Scratchpad) + (idx ^ (N << 4))))
+#	elif (STRIDED_INDEX == 1)
+#		define SCRATCHPAD_CHUNK(N) (*(__global uint4*)((__global uchar*)(Scratchpad) + mul24(as_uint(idx ^ (N << 4)), Threads)))
+#	elif (STRIDED_INDEX == 2)
+#		define SCRATCHPAD_CHUNK(N) (*(__global uint4*)((__global uchar*)(Scratchpad) + (((idx ^ (N << 4)) % (MEM_CHUNK << 4)) + ((idx ^ (N << 4)) / (MEM_CHUNK << 4)) * WORKSIZE * (MEM_CHUNK << 4))))
+#	endif
+#endif
+
+#define ROT_BITS 32
+#define MEM_CHUNK (1 << MEM_CHUNK_EXPONENT)
+
+#include "wolf-aes.cl"

src/backend/opencl/cl/cn/fast_div_heavy.cl

@@ -0,0 +1,31 @@
+#ifndef FAST_DIV_HEAVY_CL
+#define FAST_DIV_HEAVY_CL
+
+#if (ALGO_FAMILY == FAMILY_CN_HEAVY)
+
+inline long fast_div_heavy(long _a, int _b)
+{
+	long a = abs(_a);
+	int b = abs(_b);
+
+	float rcp = native_recip(convert_float_rte(b));
+	float rcp2 = as_float(as_uint(rcp) + (32U << 23));
+
+	ulong q1 = convert_ulong(convert_float_rte(as_int2(a).s1) * rcp2);
+	a -= q1 * as_uint(b);
+
+	float q2f = convert_float_rte(as_int2(a >> 12).s0) * rcp;
+	q2f = as_float(as_uint(q2f) + (12U << 23));
+	long q2 = convert_long_rte(q2f);
+	int a2 = as_int2(a).s0 - as_int2(q2).s0 * b;
+
+	int q3 = convert_int_rte(convert_float_rte(a2) * rcp);
+	q3 += (a2 - q3 * b) >> 31;
+
+	const long q = q1 + q2 + q3;
+	return ((as_int2(_a).s1 ^ _b) < 0) ? -q : q;
+}
+
+#endif
+
+#endif

src/backend/opencl/cl/cn/fast_int_math_v2.cl

@@ -0,0 +1,56 @@
+/*
+ * @author SChernykh
+ */
+
+#if (ALGO_BASE == ALGO_CN_2)
+inline uint get_reciprocal(uint a)
+{
+    const float a_hi = as_float((a >> 8) + ((126U + 31U) << 23));
+    const float a_lo = convert_float_rte(a & 0xFF);
+
+    const float r = native_recip(a_hi);
+    const float r_scaled = as_float(as_uint(r) + (64U << 23));
+
+    const float h = fma(a_lo, r, fma(a_hi, r, -1.0f));
+    return (as_uint(r) << 9) - convert_int_rte(h * r_scaled);
+}
+
+inline uint2 fast_div_v2(ulong a, uint b)
+{
+    const uint r = get_reciprocal(b);
+    const ulong k = mul_hi(as_uint2(a).s0, r) + ((ulong)(r) * as_uint2(a).s1) + a;
+
+    const uint q = as_uint2(k).s1;
+    long tmp = a - ((ulong)(q) * b);
+    ((int*)&tmp)[1] -= (as_uint2(k).s1 < as_uint2(a).s1) ? b : 0;
+
+    const int overshoot = ((int*)&tmp)[1] >> 31;
+    const int undershoot = as_int2(as_uint(b - 1) - tmp).s1 >> 31;
+    return (uint2)(q + overshoot - undershoot, as_uint2(tmp).s0 + (as_uint(overshoot) & b) - (as_uint(undershoot) & b));
+}
+
+inline uint fast_sqrt_v2(const ulong n1)
+{
+    float x = as_float((as_uint2(n1).s1 >> 9) + ((64U + 127U) << 23));
+
+    float x1 = native_rsqrt(x);
+    x = native_sqrt(x);
+
+    // The following line does x1 *= 4294967296.0f;
+    x1 = as_float(as_uint(x1) + (32U << 23));
+
+    const uint x0 = as_uint(x) - (158U << 23);
+    const long delta0 = n1 - (as_ulong((uint2)(mul24(x0, x0), mul_hi(x0, x0))) << 18);
+    const float delta = convert_float_rte(as_int2(delta0).s1) * x1;
+
+    uint result = (x0 << 10) + convert_int_rte(delta);
+    const uint s = result >> 1;
+    const uint b = result & 1;
+
+    const ulong x2 = (ulong)(s) * (s + b) + ((ulong)(result) << 32) - n1;
+    if ((long)(x2 + as_int(b - 1)) >= 0) --result;
+    if ((long)(x2 + 0x100000000UL + s) < 0) ++result;
+
+    return result;
+}
+#endif

src/backend/opencl/cl/cn/groestl256.cl

@@ -0,0 +1,289 @@
+/* $Id: groestl.c 260 2011-07-21 01:02:38Z tp $ */
+/*
+ * Groestl256
+ *
+ * ==========================(LICENSE BEGIN)============================
+ * Copyright (c) 2014 djm34
+ * Copyright (c) 2007-2010  Projet RNRT SAPHIR
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ===========================(LICENSE END)=============================
+ *
+ * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
+ */
+
+#define SPH_C64(x)	x
+#define SPH_ROTL64(x, y)	rotate((x), (ulong)(y))
+
+
+#define C64e(x)     ((SPH_C64(x) >> 56) \
+                    | ((SPH_C64(x) >> 40) & SPH_C64(0x000000000000FF00)) \
+                    | ((SPH_C64(x) >> 24) & SPH_C64(0x0000000000FF0000)) \
+                    | ((SPH_C64(x) >>  8) & SPH_C64(0x00000000FF000000)) \
+                    | ((SPH_C64(x) <<  8) & SPH_C64(0x000000FF00000000)) \
+                    | ((SPH_C64(x) << 24) & SPH_C64(0x0000FF0000000000)) \
+                    | ((SPH_C64(x) << 40) & SPH_C64(0x00FF000000000000)) \
+                    | ((SPH_C64(x) << 56) & SPH_C64(0xFF00000000000000)))
+
+#define B64_0(x)    ((x) & 0xFF)
+#define B64_1(x)    (((x) >> 8) & 0xFF)
+#define B64_2(x)    (((x) >> 16) & 0xFF)
+#define B64_3(x)    (((x) >> 24) & 0xFF)
+#define B64_4(x)    (((x) >> 32) & 0xFF)
+#define B64_5(x)    (((x) >> 40) & 0xFF)
+#define B64_6(x)    (((x) >> 48) & 0xFF)
+#define B64_7(x)    ((x) >> 56)
+#define R64         SPH_ROTL64
+#define PC64(j, r)  ((sph_u64)((j) + (r)))
+#define QC64(j, r)  (((sph_u64)(r) << 56) ^ (~((sph_u64)(j) << 56)))
+
+static const __constant ulong T0_G[] =
+{
+	0xc6a597f4a5f432c6UL, 0xf884eb9784976ff8UL, 0xee99c7b099b05eeeUL, 0xf68df78c8d8c7af6UL, 
+	0xff0de5170d17e8ffUL, 0xd6bdb7dcbddc0ad6UL, 0xdeb1a7c8b1c816deUL, 0x915439fc54fc6d91UL, 
+	0x6050c0f050f09060UL, 0x0203040503050702UL, 0xcea987e0a9e02eceUL, 0x567dac877d87d156UL, 
+	0xe719d52b192bcce7UL, 0xb56271a662a613b5UL, 0x4de69a31e6317c4dUL, 0xec9ac3b59ab559ecUL, 
+	0x8f4505cf45cf408fUL, 0x1f9d3ebc9dbca31fUL, 0x894009c040c04989UL, 0xfa87ef92879268faUL, 
+	0xef15c53f153fd0efUL, 0xb2eb7f26eb2694b2UL, 0x8ec90740c940ce8eUL, 0xfb0bed1d0b1de6fbUL, 
+	0x41ec822fec2f6e41UL, 0xb3677da967a91ab3UL, 0x5ffdbe1cfd1c435fUL, 0x45ea8a25ea256045UL, 
+	0x23bf46dabfdaf923UL, 0x53f7a602f7025153UL, 0xe496d3a196a145e4UL, 0x9b5b2ded5bed769bUL, 
+	0x75c2ea5dc25d2875UL, 0xe11cd9241c24c5e1UL, 0x3dae7ae9aee9d43dUL, 0x4c6a98be6abef24cUL, 
+	0x6c5ad8ee5aee826cUL, 0x7e41fcc341c3bd7eUL, 0xf502f1060206f3f5UL, 0x834f1dd14fd15283UL, 
+	0x685cd0e45ce48c68UL, 0x51f4a207f4075651UL, 0xd134b95c345c8dd1UL, 0xf908e9180818e1f9UL, 
+	0xe293dfae93ae4ce2UL, 0xab734d9573953eabUL, 0x6253c4f553f59762UL, 0x2a3f54413f416b2aUL, 
+	0x080c10140c141c08UL, 0x955231f652f66395UL, 0x46658caf65afe946UL, 0x9d5e21e25ee27f9dUL, 
+	0x3028607828784830UL, 0x37a16ef8a1f8cf37UL, 0x0a0f14110f111b0aUL, 0x2fb55ec4b5c4eb2fUL, 
+	0x0e091c1b091b150eUL, 0x2436485a365a7e24UL, 0x1b9b36b69bb6ad1bUL, 0xdf3da5473d4798dfUL, 
+	0xcd26816a266aa7cdUL, 0x4e699cbb69bbf54eUL, 0x7fcdfe4ccd4c337fUL, 0xea9fcfba9fba50eaUL, 
+	0x121b242d1b2d3f12UL, 0x1d9e3ab99eb9a41dUL, 0x5874b09c749cc458UL, 0x342e68722e724634UL, 
+	0x362d6c772d774136UL, 0xdcb2a3cdb2cd11dcUL, 0xb4ee7329ee299db4UL, 0x5bfbb616fb164d5bUL, 
+	0xa4f65301f601a5a4UL, 0x764decd74dd7a176UL, 0xb76175a361a314b7UL, 0x7dcefa49ce49347dUL, 
+	0x527ba48d7b8ddf52UL, 0xdd3ea1423e429fddUL, 0x5e71bc937193cd5eUL, 0x139726a297a2b113UL, 
+	0xa6f55704f504a2a6UL, 0xb96869b868b801b9UL, 0x0000000000000000UL, 0xc12c99742c74b5c1UL, 
+	0x406080a060a0e040UL, 0xe31fdd211f21c2e3UL, 0x79c8f243c8433a79UL, 0xb6ed772ced2c9ab6UL, 
+	0xd4beb3d9bed90dd4UL, 0x8d4601ca46ca478dUL, 0x67d9ce70d9701767UL, 0x724be4dd4bddaf72UL, 
+	0x94de3379de79ed94UL, 0x98d42b67d467ff98UL, 0xb0e87b23e82393b0UL, 0x854a11de4ade5b85UL, 
+	0xbb6b6dbd6bbd06bbUL, 0xc52a917e2a7ebbc5UL, 0x4fe59e34e5347b4fUL, 0xed16c13a163ad7edUL, 
+	0x86c51754c554d286UL, 0x9ad72f62d762f89aUL, 0x6655ccff55ff9966UL, 0x119422a794a7b611UL, 
+	0x8acf0f4acf4ac08aUL, 0xe910c9301030d9e9UL, 0x0406080a060a0e04UL, 0xfe81e798819866feUL, 
+	0xa0f05b0bf00baba0UL, 0x7844f0cc44ccb478UL, 0x25ba4ad5bad5f025UL, 0x4be3963ee33e754bUL, 
+	0xa2f35f0ef30eaca2UL, 0x5dfeba19fe19445dUL, 0x80c01b5bc05bdb80UL, 0x058a0a858a858005UL, 
+	0x3fad7eecadecd33fUL, 0x21bc42dfbcdffe21UL, 0x7048e0d848d8a870UL, 0xf104f90c040cfdf1UL, 
+	0x63dfc67adf7a1963UL, 0x77c1ee58c1582f77UL, 0xaf75459f759f30afUL, 0x426384a563a5e742UL, 
+	0x2030405030507020UL, 0xe51ad12e1a2ecbe5UL, 0xfd0ee1120e12effdUL, 0xbf6d65b76db708bfUL, 
+	0x814c19d44cd45581UL, 0x1814303c143c2418UL, 0x26354c5f355f7926UL, 0xc32f9d712f71b2c3UL, 
+	0xbee16738e13886beUL, 0x35a26afda2fdc835UL, 0x88cc0b4fcc4fc788UL, 0x2e395c4b394b652eUL, 
+	0x93573df957f96a93UL, 0x55f2aa0df20d5855UL, 0xfc82e39d829d61fcUL, 0x7a47f4c947c9b37aUL, 
+	0xc8ac8befacef27c8UL, 0xbae76f32e73288baUL, 0x322b647d2b7d4f32UL, 0xe695d7a495a442e6UL, 
+	0xc0a09bfba0fb3bc0UL, 0x199832b398b3aa19UL, 0x9ed12768d168f69eUL, 0xa37f5d817f8122a3UL, 
+	0x446688aa66aaee44UL, 0x547ea8827e82d654UL, 0x3bab76e6abe6dd3bUL, 0x0b83169e839e950bUL, 
+	0x8cca0345ca45c98cUL, 0xc729957b297bbcc7UL, 0x6bd3d66ed36e056bUL, 0x283c50443c446c28UL, 
+	0xa779558b798b2ca7UL, 0xbce2633de23d81bcUL, 0x161d2c271d273116UL, 0xad76419a769a37adUL, 
+	0xdb3bad4d3b4d96dbUL, 0x6456c8fa56fa9e64UL, 0x744ee8d24ed2a674UL, 0x141e28221e223614UL, 
+	0x92db3f76db76e492UL, 0x0c0a181e0a1e120cUL, 0x486c90b46cb4fc48UL, 0xb8e46b37e4378fb8UL, 
+	0x9f5d25e75de7789fUL, 0xbd6e61b26eb20fbdUL, 0x43ef862aef2a6943UL, 0xc4a693f1a6f135c4UL, 
+	0x39a872e3a8e3da39UL, 0x31a462f7a4f7c631UL, 0xd337bd5937598ad3UL, 0xf28bff868b8674f2UL, 
+	0xd532b156325683d5UL, 0x8b430dc543c54e8bUL, 0x6e59dceb59eb856eUL, 0xdab7afc2b7c218daUL, 
+	0x018c028f8c8f8e01UL, 0xb16479ac64ac1db1UL, 0x9cd2236dd26df19cUL, 0x49e0923be03b7249UL, 
+	0xd8b4abc7b4c71fd8UL, 0xacfa4315fa15b9acUL, 0xf307fd090709faf3UL, 0xcf25856f256fa0cfUL, 
+	0xcaaf8feaafea20caUL, 0xf48ef3898e897df4UL, 0x47e98e20e9206747UL, 0x1018202818283810UL, 
+	0x6fd5de64d5640b6fUL, 0xf088fb83888373f0UL, 0x4a6f94b16fb1fb4aUL, 0x5c72b8967296ca5cUL, 
+	0x3824706c246c5438UL, 0x57f1ae08f1085f57UL, 0x73c7e652c7522173UL, 0x975135f351f36497UL, 
+	0xcb238d652365aecbUL, 0xa17c59847c8425a1UL, 0xe89ccbbf9cbf57e8UL, 0x3e217c6321635d3eUL, 
+	0x96dd377cdd7cea96UL, 0x61dcc27fdc7f1e61UL, 0x0d861a9186919c0dUL, 0x0f851e9485949b0fUL, 
+	0xe090dbab90ab4be0UL, 0x7c42f8c642c6ba7cUL, 0x71c4e257c4572671UL, 0xccaa83e5aae529ccUL, 
+	0x90d83b73d873e390UL, 0x06050c0f050f0906UL, 0xf701f5030103f4f7UL, 0x1c12383612362a1cUL, 
+	0xc2a39ffea3fe3cc2UL, 0x6a5fd4e15fe18b6aUL, 0xaef94710f910beaeUL, 0x69d0d26bd06b0269UL, 
+	0x17912ea891a8bf17UL, 0x995829e858e87199UL, 0x3a2774692769533aUL, 0x27b94ed0b9d0f727UL, 
+	0xd938a948384891d9UL, 0xeb13cd351335deebUL, 0x2bb356ceb3cee52bUL, 0x2233445533557722UL, 
+	0xd2bbbfd6bbd604d2UL, 0xa9704990709039a9UL, 0x07890e8089808707UL, 0x33a766f2a7f2c133UL, 
+	0x2db65ac1b6c1ec2dUL, 0x3c22786622665a3cUL, 0x15922aad92adb815UL, 0xc92089602060a9c9UL, 
+	0x874915db49db5c87UL, 0xaaff4f1aff1ab0aaUL, 0x5078a0887888d850UL, 0xa57a518e7a8e2ba5UL, 
+	0x038f068a8f8a8903UL, 0x59f8b213f8134a59UL, 0x0980129b809b9209UL, 0x1a1734391739231aUL, 
+	0x65daca75da751065UL, 0xd731b553315384d7UL, 0x84c61351c651d584UL, 0xd0b8bbd3b8d303d0UL, 
+	0x82c31f5ec35edc82UL, 0x29b052cbb0cbe229UL, 0x5a77b4997799c35aUL, 0x1e113c3311332d1eUL, 
+	0x7bcbf646cb463d7bUL, 0xa8fc4b1ffc1fb7a8UL, 0x6dd6da61d6610c6dUL, 0x2c3a584e3a4e622cUL
+};
+
+static const __constant ulong T4_G[] =
+{
+	0xA5F432C6C6A597F4UL, 0x84976FF8F884EB97UL, 0x99B05EEEEE99C7B0UL, 0x8D8C7AF6F68DF78CUL, 
+	0x0D17E8FFFF0DE517UL, 0xBDDC0AD6D6BDB7DCUL, 0xB1C816DEDEB1A7C8UL, 0x54FC6D91915439FCUL, 
+	0x50F090606050C0F0UL, 0x0305070202030405UL, 0xA9E02ECECEA987E0UL, 0x7D87D156567DAC87UL, 
+	0x192BCCE7E719D52BUL, 0x62A613B5B56271A6UL, 0xE6317C4D4DE69A31UL, 0x9AB559ECEC9AC3B5UL, 
+	0x45CF408F8F4505CFUL, 0x9DBCA31F1F9D3EBCUL, 0x40C04989894009C0UL, 0x879268FAFA87EF92UL, 
+	0x153FD0EFEF15C53FUL, 0xEB2694B2B2EB7F26UL, 0xC940CE8E8EC90740UL, 0x0B1DE6FBFB0BED1DUL, 
+	0xEC2F6E4141EC822FUL, 0x67A91AB3B3677DA9UL, 0xFD1C435F5FFDBE1CUL, 0xEA25604545EA8A25UL, 
+	0xBFDAF92323BF46DAUL, 0xF702515353F7A602UL, 0x96A145E4E496D3A1UL, 0x5BED769B9B5B2DEDUL, 
+	0xC25D287575C2EA5DUL, 0x1C24C5E1E11CD924UL, 0xAEE9D43D3DAE7AE9UL, 0x6ABEF24C4C6A98BEUL, 
+	0x5AEE826C6C5AD8EEUL, 0x41C3BD7E7E41FCC3UL, 0x0206F3F5F502F106UL, 0x4FD15283834F1DD1UL, 
+	0x5CE48C68685CD0E4UL, 0xF407565151F4A207UL, 0x345C8DD1D134B95CUL, 0x0818E1F9F908E918UL, 
+	0x93AE4CE2E293DFAEUL, 0x73953EABAB734D95UL, 0x53F597626253C4F5UL, 0x3F416B2A2A3F5441UL, 
+	0x0C141C08080C1014UL, 0x52F66395955231F6UL, 0x65AFE94646658CAFUL, 0x5EE27F9D9D5E21E2UL, 
+	0x2878483030286078UL, 0xA1F8CF3737A16EF8UL, 0x0F111B0A0A0F1411UL, 0xB5C4EB2F2FB55EC4UL, 
+	0x091B150E0E091C1BUL, 0x365A7E242436485AUL, 0x9BB6AD1B1B9B36B6UL, 0x3D4798DFDF3DA547UL, 
+	0x266AA7CDCD26816AUL, 0x69BBF54E4E699CBBUL, 0xCD4C337F7FCDFE4CUL, 0x9FBA50EAEA9FCFBAUL, 
+	0x1B2D3F12121B242DUL, 0x9EB9A41D1D9E3AB9UL, 0x749CC4585874B09CUL, 0x2E724634342E6872UL, 
+	0x2D774136362D6C77UL, 0xB2CD11DCDCB2A3CDUL, 0xEE299DB4B4EE7329UL, 0xFB164D5B5BFBB616UL, 
+	0xF601A5A4A4F65301UL, 0x4DD7A176764DECD7UL, 0x61A314B7B76175A3UL, 0xCE49347D7DCEFA49UL, 
+	0x7B8DDF52527BA48DUL, 0x3E429FDDDD3EA142UL, 0x7193CD5E5E71BC93UL, 0x97A2B113139726A2UL, 
+	0xF504A2A6A6F55704UL, 0x68B801B9B96869B8UL, 0x0000000000000000UL, 0x2C74B5C1C12C9974UL, 
+	0x60A0E040406080A0UL, 0x1F21C2E3E31FDD21UL, 0xC8433A7979C8F243UL, 0xED2C9AB6B6ED772CUL, 
+	0xBED90DD4D4BEB3D9UL, 0x46CA478D8D4601CAUL, 0xD970176767D9CE70UL, 0x4BDDAF72724BE4DDUL, 
+	0xDE79ED9494DE3379UL, 0xD467FF9898D42B67UL, 0xE82393B0B0E87B23UL, 0x4ADE5B85854A11DEUL, 
+	0x6BBD06BBBB6B6DBDUL, 0x2A7EBBC5C52A917EUL, 0xE5347B4F4FE59E34UL, 0x163AD7EDED16C13AUL, 
+	0xC554D28686C51754UL, 0xD762F89A9AD72F62UL, 0x55FF99666655CCFFUL, 0x94A7B611119422A7UL, 
+	0xCF4AC08A8ACF0F4AUL, 0x1030D9E9E910C930UL, 0x060A0E040406080AUL, 0x819866FEFE81E798UL, 
+	0xF00BABA0A0F05B0BUL, 0x44CCB4787844F0CCUL, 0xBAD5F02525BA4AD5UL, 0xE33E754B4BE3963EUL, 
+	0xF30EACA2A2F35F0EUL, 0xFE19445D5DFEBA19UL, 0xC05BDB8080C01B5BUL, 0x8A858005058A0A85UL, 
+	0xADECD33F3FAD7EECUL, 0xBCDFFE2121BC42DFUL, 0x48D8A8707048E0D8UL, 0x040CFDF1F104F90CUL, 
+	0xDF7A196363DFC67AUL, 0xC1582F7777C1EE58UL, 0x759F30AFAF75459FUL, 0x63A5E742426384A5UL, 
+	0x3050702020304050UL, 0x1A2ECBE5E51AD12EUL, 0x0E12EFFDFD0EE112UL, 0x6DB708BFBF6D65B7UL, 
+	0x4CD45581814C19D4UL, 0x143C24181814303CUL, 0x355F792626354C5FUL, 0x2F71B2C3C32F9D71UL, 
+	0xE13886BEBEE16738UL, 0xA2FDC83535A26AFDUL, 0xCC4FC78888CC0B4FUL, 0x394B652E2E395C4BUL, 
+	0x57F96A9393573DF9UL, 0xF20D585555F2AA0DUL, 0x829D61FCFC82E39DUL, 0x47C9B37A7A47F4C9UL, 
+	0xACEF27C8C8AC8BEFUL, 0xE73288BABAE76F32UL, 0x2B7D4F32322B647DUL, 0x95A442E6E695D7A4UL, 
+	0xA0FB3BC0C0A09BFBUL, 0x98B3AA19199832B3UL, 0xD168F69E9ED12768UL, 0x7F8122A3A37F5D81UL, 
+	0x66AAEE44446688AAUL, 0x7E82D654547EA882UL, 0xABE6DD3B3BAB76E6UL, 0x839E950B0B83169EUL, 
+	0xCA45C98C8CCA0345UL, 0x297BBCC7C729957BUL, 0xD36E056B6BD3D66EUL, 0x3C446C28283C5044UL, 
+	0x798B2CA7A779558BUL, 0xE23D81BCBCE2633DUL, 0x1D273116161D2C27UL, 0x769A37ADAD76419AUL, 
+	0x3B4D96DBDB3BAD4DUL, 0x56FA9E646456C8FAUL, 0x4ED2A674744EE8D2UL, 0x1E223614141E2822UL, 
+	0xDB76E49292DB3F76UL, 0x0A1E120C0C0A181EUL, 0x6CB4FC48486C90B4UL, 0xE4378FB8B8E46B37UL, 
+	0x5DE7789F9F5D25E7UL, 0x6EB20FBDBD6E61B2UL, 0xEF2A694343EF862AUL, 0xA6F135C4C4A693F1UL, 
+	0xA8E3DA3939A872E3UL, 0xA4F7C63131A462F7UL, 0x37598AD3D337BD59UL, 0x8B8674F2F28BFF86UL, 
+	0x325683D5D532B156UL, 0x43C54E8B8B430DC5UL, 0x59EB856E6E59DCEBUL, 0xB7C218DADAB7AFC2UL, 
+	0x8C8F8E01018C028FUL, 0x64AC1DB1B16479ACUL, 0xD26DF19C9CD2236DUL, 0xE03B724949E0923BUL, 
+	0xB4C71FD8D8B4ABC7UL, 0xFA15B9ACACFA4315UL, 0x0709FAF3F307FD09UL, 0x256FA0CFCF25856FUL, 
+	0xAFEA20CACAAF8FEAUL, 0x8E897DF4F48EF389UL, 0xE920674747E98E20UL, 0x1828381010182028UL, 
+	0xD5640B6F6FD5DE64UL, 0x888373F0F088FB83UL, 0x6FB1FB4A4A6F94B1UL, 0x7296CA5C5C72B896UL, 
+	0x246C54383824706CUL, 0xF1085F5757F1AE08UL, 0xC752217373C7E652UL, 0x51F36497975135F3UL, 
+	0x2365AECBCB238D65UL, 0x7C8425A1A17C5984UL, 0x9CBF57E8E89CCBBFUL, 0x21635D3E3E217C63UL, 
+	0xDD7CEA9696DD377CUL, 0xDC7F1E6161DCC27FUL, 0x86919C0D0D861A91UL, 0x85949B0F0F851E94UL, 
+	0x90AB4BE0E090DBABUL, 0x42C6BA7C7C42F8C6UL, 0xC457267171C4E257UL, 0xAAE529CCCCAA83E5UL, 
+	0xD873E39090D83B73UL, 0x050F090606050C0FUL, 0x0103F4F7F701F503UL, 0x12362A1C1C123836UL, 
+	0xA3FE3CC2C2A39FFEUL, 0x5FE18B6A6A5FD4E1UL, 0xF910BEAEAEF94710UL, 0xD06B026969D0D26BUL, 
+	0x91A8BF1717912EA8UL, 0x58E87199995829E8UL, 0x2769533A3A277469UL, 0xB9D0F72727B94ED0UL, 
+	0x384891D9D938A948UL, 0x1335DEEBEB13CD35UL, 0xB3CEE52B2BB356CEUL, 0x3355772222334455UL, 
+	0xBBD604D2D2BBBFD6UL, 0x709039A9A9704990UL, 0x8980870707890E80UL, 0xA7F2C13333A766F2UL, 
+	0xB6C1EC2D2DB65AC1UL, 0x22665A3C3C227866UL, 0x92ADB81515922AADUL, 0x2060A9C9C9208960UL, 
+	0x49DB5C87874915DBUL, 0xFF1AB0AAAAFF4F1AUL, 0x7888D8505078A088UL, 0x7A8E2BA5A57A518EUL, 
+	0x8F8A8903038F068AUL, 0xF8134A5959F8B213UL, 0x809B92090980129BUL, 0x1739231A1A173439UL, 
+	0xDA75106565DACA75UL, 0x315384D7D731B553UL, 0xC651D58484C61351UL, 0xB8D303D0D0B8BBD3UL, 
+	0xC35EDC8282C31F5EUL, 0xB0CBE22929B052CBUL, 0x7799C35A5A77B499UL, 0x11332D1E1E113C33UL, 
+	0xCB463D7B7BCBF646UL, 0xFC1FB7A8A8FC4B1FUL, 0xD6610C6D6DD6DA61UL, 0x3A4E622C2C3A584EUL
+};
+
+#define RSTT(d, a, b0, b1, b2, b3, b4, b5, b6, b7)   do { \
+		t[d] = T0_G[B64_0(a[b0])] \
+			^ R64(T0_G[B64_1(a[b1])],  8) \
+			^ R64(T0_G[B64_2(a[b2])], 16) \
+			^ R64(T0_G[B64_3(a[b3])], 24) \
+			^ T4_G[B64_4(a[b4])] \
+			^ R64(T4_G[B64_5(a[b5])],  8) \
+			^ R64(T4_G[B64_6(a[b6])], 16) \
+			^ R64(T4_G[B64_7(a[b7])], 24); \
+		} while (0)
+
+#define ROUND_SMALL_P(a, r)   do { \
+		ulong t[8]; \
+		a[0] ^= PC64(0x00, r); \
+		a[1] ^= PC64(0x10, r); \
+		a[2] ^= PC64(0x20, r); \
+		a[3] ^= PC64(0x30, r); \
+		a[4] ^= PC64(0x40, r); \
+		a[5] ^= PC64(0x50, r); \
+		a[6] ^= PC64(0x60, r); \
+		a[7] ^= PC64(0x70, r); \
+		RSTT(0, a, 0, 1, 2, 3, 4, 5, 6, 7); \
+		RSTT(1, a, 1, 2, 3, 4, 5, 6, 7, 0); \
+		RSTT(2, a, 2, 3, 4, 5, 6, 7, 0, 1); \
+		RSTT(3, a, 3, 4, 5, 6, 7, 0, 1, 2); \
+		RSTT(4, a, 4, 5, 6, 7, 0, 1, 2, 3); \
+		RSTT(5, a, 5, 6, 7, 0, 1, 2, 3, 4); \
+		RSTT(6, a, 6, 7, 0, 1, 2, 3, 4, 5); \
+		RSTT(7, a, 7, 0, 1, 2, 3, 4, 5, 6); \
+		a[0] = t[0]; \
+		a[1] = t[1]; \
+		a[2] = t[2]; \
+		a[3] = t[3]; \
+		a[4] = t[4]; \
+		a[5] = t[5]; \
+		a[6] = t[6]; \
+		a[7] = t[7]; \
+		} while (0)
+
+#define ROUND_SMALL_Pf(a,r)   do { \
+		a[0] ^= PC64(0x00, r); \
+		a[1] ^= PC64(0x10, r); \
+		a[2] ^= PC64(0x20, r); \
+		a[3] ^= PC64(0x30, r); \
+		a[4] ^= PC64(0x40, r); \
+		a[5] ^= PC64(0x50, r); \
+		a[6] ^= PC64(0x60, r); \
+		a[7] ^= PC64(0x70, r); \
+		RSTT(7, a, 7, 0, 1, 2, 3, 4, 5, 6); \
+		a[7] = t[7]; \
+			} while (0)
+
+#define ROUND_SMALL_Q(a, r)   do { \
+		ulong t[8]; \
+		a[0] ^= QC64(0x00, r); \
+		a[1] ^= QC64(0x10, r); \
+		a[2] ^= QC64(0x20, r); \
+		a[3] ^= QC64(0x30, r); \
+		a[4] ^= QC64(0x40, r); \
+		a[5] ^= QC64(0x50, r); \
+		a[6] ^= QC64(0x60, r); \
+		a[7] ^= QC64(0x70, r); \
+		RSTT(0, a, 1, 3, 5, 7, 0, 2, 4, 6); \
+		RSTT(1, a, 2, 4, 6, 0, 1, 3, 5, 7); \
+		RSTT(2, a, 3, 5, 7, 1, 2, 4, 6, 0); \
+		RSTT(3, a, 4, 6, 0, 2, 3, 5, 7, 1); \
+		RSTT(4, a, 5, 7, 1, 3, 4, 6, 0, 2); \
+		RSTT(5, a, 6, 0, 2, 4, 5, 7, 1, 3); \
+		RSTT(6, a, 7, 1, 3, 5, 6, 0, 2, 4); \
+		RSTT(7, a, 0, 2, 4, 6, 7, 1, 3, 5); \
+		a[0] = t[0]; \
+		a[1] = t[1]; \
+		a[2] = t[2]; \
+		a[3] = t[3]; \
+		a[4] = t[4]; \
+		a[5] = t[5]; \
+		a[6] = t[6]; \
+		a[7] = t[7]; \
+		} while (0)
+
+#define PERM_SMALL_P(a)   do { \
+		for (int r = 0; r < 10; r ++) \
+			ROUND_SMALL_P(a, r); \
+		} while (0)
+
+#define PERM_SMALL_Pf(a)   do { \
+		for (int r = 0; r < 9; r ++) { \
+			ROUND_SMALL_P(a, r);} \
+            ROUND_SMALL_Pf(a,9); \
+			} while (0)
+
+#define PERM_SMALL_Q(a)   do { \
+		for (int r = 0; r < 10; r ++) \
+			ROUND_SMALL_Q(a, r); \
+		} while (0)
+

src/backend/opencl/cl/cn/jh.cl

@@ -0,0 +1,271 @@
+/* $Id: jh.c 255 2011-06-07 19:50:20Z tp $ */
+/*
+ * JH implementation.
+ *
+ * ==========================(LICENSE BEGIN)============================
+ *
+ * Copyright (c) 2007-2010  Projet RNRT SAPHIR
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ===========================(LICENSE END)=============================
+ *
+ * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
+ */
+
+#define SPH_JH_64   1
+#define SPH_LITTLE_ENDIAN 1
+
+#define SPH_C32(x)	x
+#define SPH_C64(x)	x
+typedef uint sph_u32;
+typedef ulong sph_u64;
+
+/*
+ * The internal bitslice representation may use either big-endian or
+ * little-endian (true bitslice operations do not care about the bit
+ * ordering, and the bit-swapping linear operations in JH happen to
+ * be invariant through endianness-swapping). The constants must be
+ * defined according to the chosen endianness; we use some
+ * byte-swapping macros for that.
+ */
+
+#if SPH_LITTLE_ENDIAN
+
+#define C32e(x)     ((SPH_C32(x) >> 24) \
+          | ((SPH_C32(x) >>  8) & SPH_C32(0x0000FF00)) \
+          | ((SPH_C32(x) <<  8) & SPH_C32(0x00FF0000)) \
+          | ((SPH_C32(x) << 24) & SPH_C32(0xFF000000)))
+#define dec32e_aligned   sph_dec32le_aligned
+#define enc32e           sph_enc32le
+
+#define C64e(x)     ((SPH_C64(x) >> 56) \
+          | ((SPH_C64(x) >> 40) & SPH_C64(0x000000000000FF00)) \
+          | ((SPH_C64(x) >> 24) & SPH_C64(0x0000000000FF0000)) \
+          | ((SPH_C64(x) >>  8) & SPH_C64(0x00000000FF000000)) \
+          | ((SPH_C64(x) <<  8) & SPH_C64(0x000000FF00000000)) \
+          | ((SPH_C64(x) << 24) & SPH_C64(0x0000FF0000000000)) \
+          | ((SPH_C64(x) << 40) & SPH_C64(0x00FF000000000000)) \
+          | ((SPH_C64(x) << 56) & SPH_C64(0xFF00000000000000)))
+#define dec64e_aligned   sph_dec64le_aligned
+#define enc64e           sph_enc64le
+
+#else
+
+#define C32e(x)     SPH_C32(x)
+#define dec32e_aligned   sph_dec32be_aligned
+#define enc32e           sph_enc32be
+#define C64e(x)     SPH_C64(x)
+#define dec64e_aligned   sph_dec64be_aligned
+#define enc64e           sph_enc64be
+
+#endif
+
+#define Sb(x0, x1, x2, x3, c)   do { \
+    x3 = ~x3; \
+    x0 ^= (c) & ~x2; \
+    tmp = (c) ^ (x0 & x1); \
+    x0 ^= x2 & x3; \
+    x3 ^= ~x1 & x2; \
+    x1 ^= x0 & x2; \
+    x2 ^= x0 & ~x3; \
+    x0 ^= x1 | x3; \
+    x3 ^= x1 & x2; \
+    x1 ^= tmp & x0; \
+    x2 ^= tmp; \
+  } while (0)
+
+#define Lb(x0, x1, x2, x3, x4, x5, x6, x7)   do { \
+    x4 ^= x1; \
+    x5 ^= x2; \
+    x6 ^= x3 ^ x0; \
+    x7 ^= x0; \
+    x0 ^= x5; \
+    x1 ^= x6; \
+    x2 ^= x7 ^ x4; \
+    x3 ^= x4; \
+  } while (0)
+
+static const __constant ulong C[] =
+{
+	0x67F815DFA2DED572UL, 0x571523B70A15847BUL, 0xF6875A4D90D6AB81UL, 0x402BD1C3C54F9F4EUL, 
+	0x9CFA455CE03A98EAUL, 0x9A99B26699D2C503UL, 0x8A53BBF2B4960266UL, 0x31A2DB881A1456B5UL, 
+	0xDB0E199A5C5AA303UL, 0x1044C1870AB23F40UL, 0x1D959E848019051CUL, 0xDCCDE75EADEB336FUL, 
+	0x416BBF029213BA10UL, 0xD027BBF7156578DCUL, 0x5078AA3739812C0AUL, 0xD3910041D2BF1A3FUL, 
+	0x907ECCF60D5A2D42UL, 0xCE97C0929C9F62DDUL, 0xAC442BC70BA75C18UL, 0x23FCC663D665DFD1UL, 
+	0x1AB8E09E036C6E97UL, 0xA8EC6C447E450521UL, 0xFA618E5DBB03F1EEUL, 0x97818394B29796FDUL, 
+	0x2F3003DB37858E4AUL, 0x956A9FFB2D8D672AUL, 0x6C69B8F88173FE8AUL, 0x14427FC04672C78AUL, 
+	0xC45EC7BD8F15F4C5UL, 0x80BB118FA76F4475UL, 0xBC88E4AEB775DE52UL, 0xF4A3A6981E00B882UL, 
+	0x1563A3A9338FF48EUL, 0x89F9B7D524565FAAUL, 0xFDE05A7C20EDF1B6UL, 0x362C42065AE9CA36UL, 
+	0x3D98FE4E433529CEUL, 0xA74B9A7374F93A53UL, 0x86814E6F591FF5D0UL, 0x9F5AD8AF81AD9D0EUL, 
+	0x6A6234EE670605A7UL, 0x2717B96EBE280B8BUL, 0x3F1080C626077447UL, 0x7B487EC66F7EA0E0UL, 
+	0xC0A4F84AA50A550DUL, 0x9EF18E979FE7E391UL, 0xD48D605081727686UL, 0x62B0E5F3415A9E7EUL, 
+	0x7A205440EC1F9FFCUL, 0x84C9F4CE001AE4E3UL, 0xD895FA9DF594D74FUL, 0xA554C324117E2E55UL, 
+	0x286EFEBD2872DF5BUL, 0xB2C4A50FE27FF578UL, 0x2ED349EEEF7C8905UL, 0x7F5928EB85937E44UL, 
+	0x4A3124B337695F70UL, 0x65E4D61DF128865EUL, 0xE720B95104771BC7UL, 0x8A87D423E843FE74UL, 
+	0xF2947692A3E8297DUL, 0xC1D9309B097ACBDDUL, 0xE01BDC5BFB301B1DUL, 0xBF829CF24F4924DAUL, 
+	0xFFBF70B431BAE7A4UL, 0x48BCF8DE0544320DUL, 0x39D3BB5332FCAE3BUL, 0xA08B29E0C1C39F45UL, 
+	0x0F09AEF7FD05C9E5UL, 0x34F1904212347094UL, 0x95ED44E301B771A2UL, 0x4A982F4F368E3BE9UL, 
+	0x15F66CA0631D4088UL, 0xFFAF52874B44C147UL, 0x30C60AE2F14ABB7EUL, 0xE68C6ECCC5B67046UL, 
+	0x00CA4FBD56A4D5A4UL, 0xAE183EC84B849DDAUL, 0xADD1643045CE5773UL, 0x67255C1468CEA6E8UL, 
+	0x16E10ECBF28CDAA3UL, 0x9A99949A5806E933UL, 0x7B846FC220B2601FUL, 0x1885D1A07FACCED1UL, 
+	0xD319DD8DA15B5932UL, 0x46B4A5AAC01C9A50UL, 0xBA6B04E467633D9FUL, 0x7EEE560BAB19CAF6UL, 
+	0x742128A9EA79B11FUL, 0xEE51363B35F7BDE9UL, 0x76D350755AAC571DUL, 0x01707DA3FEC2463AUL, 
+	0x42D8A498AFC135F7UL, 0x79676B9E20ECED78UL, 0xA8DB3AEA15638341UL, 0x832C83324D3BC3FAUL, 
+	0xF347271C1F3B40A7UL, 0x9A762DB734F04059UL, 0xFD4F21D26C4E3EE7UL, 0xEF5957DC398DFDB8UL, 
+	0xDAEB492B490C9B8DUL, 0x0D70F36849D7A25BUL, 0x84558D7AD0AE3B7DUL, 0x658EF8E4F0E9A5F5UL, 
+	0x533B1036F4A2B8A0UL, 0x5AEC3E759E07A80CUL, 0x4F88E85692946891UL, 0x4CBCBAF8555CB05BUL, 
+	0x7B9487F3993BBBE3UL, 0x5D1C6B72D6F4DA75UL, 0x6DB334DC28ACAE64UL, 0x71DB28B850A5346CUL, 
+	0x2A518D10F2E261F8UL, 0xFC75DD593364DBE3UL, 0xA23FCE43F1BCAC1CUL, 0xB043E8023CD1BB67UL, 
+	0x75A12988CA5B0A33UL, 0x5C5316B44D19347FUL, 0x1E4D790EC3943B92UL, 0x3FAFEEB6D7757479UL, 
+	0x21391ABEF7D4A8EAUL, 0x5127234C097EF45CUL, 0xD23C32BA5324A326UL, 0xADD5A66D4A17A344UL, 
+	0x08C9F2AFA63E1DB5UL, 0x563C6B91983D5983UL, 0x4D608672A17CF84CUL, 0xF6C76E08CC3EE246UL, 
+	0x5E76BCB1B333982FUL, 0x2AE6C4EFA566D62BUL, 0x36D4C1BEE8B6F406UL, 0x6321EFBC1582EE74UL, 
+	0x69C953F40D4EC1FDUL, 0x26585806C45A7DA7UL, 0x16FAE0061614C17EUL, 0x3F9D63283DAF907EUL, 
+	0x0CD29B00E3F2C9D2UL, 0x300CD4B730CEAA5FUL, 0x9832E0F216512A74UL, 0x9AF8CEE3D830EB0DUL, 
+	0x9279F1B57B9EC54BUL, 0xD36886046EE651FFUL, 0x316796E6574D239BUL, 0x05750A17F3A6E6CCUL, 
+	0xCE6C3213D98176B1UL, 0x62A205F88452173CUL, 0x47154778B3CB2BF4UL, 0x486A9323825446FFUL, 
+	0x65655E4E0758DF38UL, 0x8E5086FC897CFCF2UL, 0x86CA0BD0442E7031UL, 0x4E477830A20940F0UL, 
+	0x8338F7D139EEA065UL, 0xBD3A2CE437E95EF7UL, 0x6FF8130126B29721UL, 0xE7DE9FEFD1ED44A3UL, 
+	0xD992257615DFA08BUL, 0xBE42DC12F6F7853CUL, 0x7EB027AB7CECA7D8UL, 0xDEA83EAADA7D8D53UL, 
+	0xD86902BD93CE25AAUL, 0xF908731AFD43F65AUL, 0xA5194A17DAEF5FC0UL, 0x6A21FD4C33664D97UL, 
+	0x701541DB3198B435UL, 0x9B54CDEDBB0F1EEAUL, 0x72409751A163D09AUL, 0xE26F4791BF9D75F6UL
+};
+
+#define Ceven_hi(r)   (C[((r) << 2) + 0])
+#define Ceven_lo(r)   (C[((r) << 2) + 1])
+#define Codd_hi(r)    (C[((r) << 2) + 2])
+#define Codd_lo(r)    (C[((r) << 2) + 3])
+
+#define S(x0, x1, x2, x3, cb, r)   do { \
+    Sb(x0 ## h, x1 ## h, x2 ## h, x3 ## h, cb ## hi(r)); \
+    Sb(x0 ## l, x1 ## l, x2 ## l, x3 ## l, cb ## lo(r)); \
+  } while (0)
+
+#define L(x0, x1, x2, x3, x4, x5, x6, x7)   do { \
+    Lb(x0 ## h, x1 ## h, x2 ## h, x3 ## h, \
+      x4 ## h, x5 ## h, x6 ## h, x7 ## h); \
+    Lb(x0 ## l, x1 ## l, x2 ## l, x3 ## l, \
+      x4 ## l, x5 ## l, x6 ## l, x7 ## l); \
+  } while (0)
+
+#define Wz(x, c, n)   do { \
+    sph_u64 t = (x ## h & (c)) << (n); \
+    x ## h = ((x ## h >> (n)) & (c)) | t; \
+    t = (x ## l & (c)) << (n); \
+    x ## l = ((x ## l >> (n)) & (c)) | t; \
+  } while (0)
+
+#define W0(x)   Wz(x, SPH_C64(0x5555555555555555),  1)
+#define W1(x)   Wz(x, SPH_C64(0x3333333333333333),  2)
+#define W2(x)   Wz(x, SPH_C64(0x0F0F0F0F0F0F0F0F),  4)
+#define W3(x)   Wz(x, SPH_C64(0x00FF00FF00FF00FF),  8)
+#define W4(x)   Wz(x, SPH_C64(0x0000FFFF0000FFFF), 16)
+#define W5(x)   Wz(x, SPH_C64(0x00000000FFFFFFFF), 32)
+#define W6(x)   do { \
+    sph_u64 t = x ## h; \
+    x ## h = x ## l; \
+    x ## l = t; \
+  } while (0)
+
+#define SL(ro)   SLu(r + ro, ro)
+
+#define SLu(r, ro)   do { \
+    S(h0, h2, h4, h6, Ceven_, r); \
+    S(h1, h3, h5, h7, Codd_, r); \
+    L(h0, h2, h4, h6, h1, h3, h5, h7); \
+    W ## ro(h1); \
+    W ## ro(h3); \
+    W ## ro(h5); \
+    W ## ro(h7); \
+  } while (0)
+
+#if SPH_SMALL_FOOTPRINT_JH
+
+/*
+ * The "small footprint" 64-bit version just uses a partially unrolled
+ * loop.
+ */
+
+#define E8   do { \
+    unsigned r; \
+    for (r = 0; r < 42; r += 7) { \
+      SL(0); \
+      SL(1); \
+      SL(2); \
+      SL(3); \
+      SL(4); \
+      SL(5); \
+      SL(6); \
+    } \
+  } while (0)
+
+#else
+
+/*
+ * On a "true 64-bit" architecture, we can unroll at will.
+ */
+
+#define E8   do { \
+    SLu( 0, 0); \
+    SLu( 1, 1); \
+    SLu( 2, 2); \
+    SLu( 3, 3); \
+    SLu( 4, 4); \
+    SLu( 5, 5); \
+    SLu( 6, 6); \
+    SLu( 7, 0); \
+    SLu( 8, 1); \
+    SLu( 9, 2); \
+    SLu(10, 3); \
+    SLu(11, 4); \
+    SLu(12, 5); \
+    SLu(13, 6); \
+    SLu(14, 0); \
+    SLu(15, 1); \
+    SLu(16, 2); \
+    SLu(17, 3); \
+    SLu(18, 4); \
+    SLu(19, 5); \
+    SLu(20, 6); \
+    SLu(21, 0); \
+    SLu(22, 1); \
+    SLu(23, 2); \
+    SLu(24, 3); \
+    SLu(25, 4); \
+    SLu(26, 5); \
+    SLu(27, 6); \
+    SLu(28, 0); \
+    SLu(29, 1); \
+    SLu(30, 2); \
+    SLu(31, 3); \
+    SLu(32, 4); \
+    SLu(33, 5); \
+    SLu(34, 6); \
+    SLu(35, 0); \
+    SLu(36, 1); \
+    SLu(37, 2); \
+    SLu(38, 3); \
+    SLu(39, 4); \
+    SLu(40, 5); \
+    SLu(41, 6); \
+  } while (0)
+
+#endif

src/backend/opencl/cl/cn/keccak.cl

@@ -0,0 +1,155 @@
+#ifndef XMRIG_KECCAK_CL
+#define XMRIG_KECCAK_CL
+
+
+static const __constant ulong keccakf_rndc[24] =
+{
+    0x0000000000000001, 0x0000000000008082, 0x800000000000808a,
+    0x8000000080008000, 0x000000000000808b, 0x0000000080000001,
+    0x8000000080008081, 0x8000000000008009, 0x000000000000008a,
+    0x0000000000000088, 0x0000000080008009, 0x000000008000000a,
+    0x000000008000808b, 0x800000000000008b, 0x8000000000008089,
+    0x8000000000008003, 0x8000000000008002, 0x8000000000000080,
+    0x000000000000800a, 0x800000008000000a, 0x8000000080008081,
+    0x8000000000008080, 0x0000000080000001, 0x8000000080008008
+};
+
+
+static const __constant uint keccakf_rotc[24] =
+{
+    1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14,
+    27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
+};
+
+
+static const __constant uint keccakf_piln[24] =
+{
+    10, 7,  11, 17, 18, 3, 5,  16, 8,  21, 24, 4,
+    15, 23, 19, 13, 12, 2, 20, 14, 22, 9,  6,  1
+};
+
+
+void keccakf1600_1(ulong *st)
+{
+    int i, round;
+    ulong t, bc[5];
+
+    #pragma unroll 1
+    for (round = 0; round < 24; ++round) {
+        // Theta
+        bc[0] = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20];
+        bc[1] = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21];
+        bc[2] = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22];
+        bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23];
+        bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24];
+
+        #pragma unroll 1
+        for (i = 0; i < 5; ++i) {
+            t = bc[(i + 4) % 5] ^ rotate(bc[(i + 1) % 5], 1UL);
+            st[i     ] ^= t;
+            st[i +  5] ^= t;
+            st[i + 10] ^= t;
+            st[i + 15] ^= t;
+            st[i + 20] ^= t;
+        }
+
+        // Rho Pi
+        t = st[1];
+        #pragma unroll 1
+        for (i = 0; i < 24; ++i) {
+            bc[0] = st[keccakf_piln[i]];
+            st[keccakf_piln[i]] = rotate(t, (ulong)keccakf_rotc[i]);
+            t = bc[0];
+        }
+
+        #pragma unroll 1
+        for (int i = 0; i < 25; i += 5) {
+            ulong tmp[5];
+
+            #pragma unroll 1
+            for (int x = 0; x < 5; ++x) {
+                tmp[x] = bitselect(st[i + x] ^ st[i + ((x + 2) % 5)], st[i + x], st[i + ((x + 1) % 5)]);
+            }
+
+            #pragma unroll 1
+            for (int x = 0; x < 5; ++x) {
+                st[i + x] = tmp[x];
+            }
+        }
+
+        //  Iota
+        st[0] ^= keccakf_rndc[round];
+    }
+}
+
+
+void keccakf1600_2(__local ulong *st)
+{
+    int i, round;
+    ulong t, bc[5];
+
+    #pragma unroll 1
+    for (round = 0; round < 24; ++round) {
+        bc[0] = st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20] ^ rotate(st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22], 1UL);
+        bc[1] = st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21] ^ rotate(st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23], 1UL);
+        bc[2] = st[2] ^ st[7] ^ st[12] ^ st[17] ^ st[22] ^ rotate(st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24], 1UL);
+        bc[3] = st[3] ^ st[8] ^ st[13] ^ st[18] ^ st[23] ^ rotate(st[0] ^ st[5] ^ st[10] ^ st[15] ^ st[20], 1UL);
+        bc[4] = st[4] ^ st[9] ^ st[14] ^ st[19] ^ st[24] ^ rotate(st[1] ^ st[6] ^ st[11] ^ st[16] ^ st[21], 1UL);
+
+        st[0]  ^= bc[4];
+        st[5]  ^= bc[4];
+        st[10] ^= bc[4];
+        st[15] ^= bc[4];
+        st[20] ^= bc[4];
+
+        st[1]  ^= bc[0];
+        st[6]  ^= bc[0];
+        st[11] ^= bc[0];
+        st[16] ^= bc[0];
+        st[21] ^= bc[0];
+
+        st[2]  ^= bc[1];
+        st[7]  ^= bc[1];
+        st[12] ^= bc[1];
+        st[17] ^= bc[1];
+        st[22] ^= bc[1];
+
+        st[3]  ^= bc[2];
+        st[8]  ^= bc[2];
+        st[13] ^= bc[2];
+        st[18] ^= bc[2];
+        st[23] ^= bc[2];
+
+        st[4]  ^= bc[3];
+        st[9]  ^= bc[3];
+        st[14] ^= bc[3];
+        st[19] ^= bc[3];
+        st[24] ^= bc[3];
+
+        // Rho Pi
+        t = st[1];
+        #pragma unroll 1
+        for (i = 0; i < 24; ++i) {
+            bc[0] = st[keccakf_piln[i]];
+            st[keccakf_piln[i]] = rotate(t, (ulong)keccakf_rotc[i]);
+            t = bc[0];
+        }
+
+        #pragma unroll 1
+        for (int i = 0; i < 25; i += 5) {
+            ulong tmp1 = st[i], tmp2 = st[i + 1];
+
+            st[i] = bitselect(st[i] ^ st[i + 2], st[i], st[i + 1]);
+            st[i + 1] = bitselect(st[i + 1] ^ st[i + 3], st[i + 1], st[i + 2]);
+            st[i + 2] = bitselect(st[i + 2] ^ st[i + 4], st[i + 2], st[i + 3]);
+            st[i + 3] = bitselect(st[i + 3] ^ tmp1, st[i + 3], st[i + 4]);
+            st[i + 4] = bitselect(st[i + 4] ^ tmp2, st[i + 4], tmp1);
+        }
+
+        //  Iota
+        st[0] ^= keccakf_rndc[round];
+    }
+}
+
+
+#endif

src/backend/opencl/cl/cn/wolf-aes.cl

@@ -0,0 +1,194 @@
+#ifndef WOLF_AES_CL
+#define WOLF_AES_CL
+
+#ifdef cl_amd_media_ops2
+#   pragma OPENCL EXTENSION cl_amd_media_ops2 : enable
+
+#   define xmrig_amd_bfe(src0, src1, src2) amd_bfe(src0, src1, src2)
+#else
+/* taken from: https://www.khronos.org/registry/OpenCL/extensions/amd/cl_amd_media_ops2.txt
+ *     Built-in Function:
+ *     uintn amd_bfe (uintn src0, uintn src1, uintn src2)
+ *   Description
+ *     NOTE: operator >> below represent logical right shift
+ *     offset = src1.s0 & 31;
+ *     width = src2.s0 & 31;
+ *     if width = 0
+ *         dst.s0 = 0;
+ *     else if (offset + width) < 32
+ *         dst.s0 = (src0.s0 << (32 - offset - width)) >> (32 - width);
+ *     else
+ *         dst.s0 = src0.s0 >> offset;
+ *     similar operation applied to other components of the vectors
+ */
+inline int xmrig_amd_bfe(const uint src0, const uint offset, const uint width)
+{
+    /* casts are removed because we can implement everything as uint
+     * int offset = src1;
+     * int width = src2;
+     * remove check for edge case, this function is always called with
+     * `width==8`
+     * @code
+     *   if ( width == 0 )
+     *      return 0;
+     * @endcode
+     */
+    if ((offset + width) < 32u) {
+        return (src0 << (32u - offset - width)) >> (32u - width);
+    }
+
+    return src0 >> offset;
+}
+#endif
+
+
+// AES table - the other three are generated on the fly
+
+static const __constant uint AES0_C[256] =
+{
+    0xA56363C6U, 0x847C7CF8U, 0x997777EEU, 0x8D7B7BF6U,
+    0x0DF2F2FFU, 0xBD6B6BD6U, 0xB16F6FDEU, 0x54C5C591U,
+    0x50303060U, 0x03010102U, 0xA96767CEU, 0x7D2B2B56U,
+    0x19FEFEE7U, 0x62D7D7B5U, 0xE6ABAB4DU, 0x9A7676ECU,
+    0x45CACA8FU, 0x9D82821FU, 0x40C9C989U, 0x877D7DFAU,
+    0x15FAFAEFU, 0xEB5959B2U, 0xC947478EU, 0x0BF0F0FBU,
+    0xECADAD41U, 0x67D4D4B3U, 0xFDA2A25FU, 0xEAAFAF45U,
+    0xBF9C9C23U, 0xF7A4A453U, 0x967272E4U, 0x5BC0C09BU,
+    0xC2B7B775U, 0x1CFDFDE1U, 0xAE93933DU, 0x6A26264CU,
+    0x5A36366CU, 0x413F3F7EU, 0x02F7F7F5U, 0x4FCCCC83U,
+    0x5C343468U, 0xF4A5A551U, 0x34E5E5D1U, 0x08F1F1F9U,
+    0x937171E2U, 0x73D8D8ABU, 0x53313162U, 0x3F15152AU,
+    0x0C040408U, 0x52C7C795U, 0x65232346U, 0x5EC3C39DU,
+    0x28181830U, 0xA1969637U, 0x0F05050AU, 0xB59A9A2FU,
+    0x0907070EU, 0x36121224U, 0x9B80801BU, 0x3DE2E2DFU,
+    0x26EBEBCDU, 0x6927274EU, 0xCDB2B27FU, 0x9F7575EAU,
+    0x1B090912U, 0x9E83831DU, 0x742C2C58U, 0x2E1A1A34U,
+    0x2D1B1B36U, 0xB26E6EDCU, 0xEE5A5AB4U, 0xFBA0A05BU,
+    0xF65252A4U, 0x4D3B3B76U, 0x61D6D6B7U, 0xCEB3B37DU,
+    0x7B292952U, 0x3EE3E3DDU, 0x712F2F5EU, 0x97848413U,
+    0xF55353A6U, 0x68D1D1B9U, 0x00000000U, 0x2CEDEDC1U,
+    0x60202040U, 0x1FFCFCE3U, 0xC8B1B179U, 0xED5B5BB6U,
+    0xBE6A6AD4U, 0x46CBCB8DU, 0xD9BEBE67U, 0x4B393972U,
+    0xDE4A4A94U, 0xD44C4C98U, 0xE85858B0U, 0x4ACFCF85U,
+    0x6BD0D0BBU, 0x2AEFEFC5U, 0xE5AAAA4FU, 0x16FBFBEDU,
+    0xC5434386U, 0xD74D4D9AU, 0x55333366U, 0x94858511U,
+    0xCF45458AU, 0x10F9F9E9U, 0x06020204U, 0x817F7FFEU,
+    0xF05050A0U, 0x443C3C78U, 0xBA9F9F25U, 0xE3A8A84BU,
+    0xF35151A2U, 0xFEA3A35DU, 0xC0404080U, 0x8A8F8F05U,
+    0xAD92923FU, 0xBC9D9D21U, 0x48383870U, 0x04F5F5F1U,
+    0xDFBCBC63U, 0xC1B6B677U, 0x75DADAAFU, 0x63212142U,
+    0x30101020U, 0x1AFFFFE5U, 0x0EF3F3FDU, 0x6DD2D2BFU,
+    0x4CCDCD81U, 0x140C0C18U, 0x35131326U, 0x2FECECC3U,
+    0xE15F5FBEU, 0xA2979735U, 0xCC444488U, 0x3917172EU,
+    0x57C4C493U, 0xF2A7A755U, 0x827E7EFCU, 0x473D3D7AU,
+    0xAC6464C8U, 0xE75D5DBAU, 0x2B191932U, 0x957373E6U,
+    0xA06060C0U, 0x98818119U, 0xD14F4F9EU, 0x7FDCDCA3U,
+    0x66222244U, 0x7E2A2A54U, 0xAB90903BU, 0x8388880BU,
+    0xCA46468CU, 0x29EEEEC7U, 0xD3B8B86BU, 0x3C141428U,
+    0x79DEDEA7U, 0xE25E5EBCU, 0x1D0B0B16U, 0x76DBDBADU,
+    0x3BE0E0DBU, 0x56323264U, 0x4E3A3A74U, 0x1E0A0A14U,
+    0xDB494992U, 0x0A06060CU, 0x6C242448U, 0xE45C5CB8U,
+    0x5DC2C29FU, 0x6ED3D3BDU, 0xEFACAC43U, 0xA66262C4U,
+    0xA8919139U, 0xA4959531U, 0x37E4E4D3U, 0x8B7979F2U,
+    0x32E7E7D5U, 0x43C8C88BU, 0x5937376EU, 0xB76D6DDAU,
+    0x8C8D8D01U, 0x64D5D5B1U, 0xD24E4E9CU, 0xE0A9A949U,
+    0xB46C6CD8U, 0xFA5656ACU, 0x07F4F4F3U, 0x25EAEACFU,
+    0xAF6565CAU, 0x8E7A7AF4U, 0xE9AEAE47U, 0x18080810U,
+    0xD5BABA6FU, 0x887878F0U, 0x6F25254AU, 0x722E2E5CU,
+    0x241C1C38U, 0xF1A6A657U, 0xC7B4B473U, 0x51C6C697U,
+    0x23E8E8CBU, 0x7CDDDDA1U, 0x9C7474E8U, 0x211F1F3EU,
+    0xDD4B4B96U, 0xDCBDBD61U, 0x868B8B0DU, 0x858A8A0FU,
+    0x907070E0U, 0x423E3E7CU, 0xC4B5B571U, 0xAA6666CCU,
+    0xD8484890U, 0x05030306U, 0x01F6F6F7U, 0x120E0E1CU,
+    0xA36161C2U, 0x5F35356AU, 0xF95757AEU, 0xD0B9B969U,
+    0x91868617U, 0x58C1C199U, 0x271D1D3AU, 0xB99E9E27U,
+    0x38E1E1D9U, 0x13F8F8EBU, 0xB398982BU, 0x33111122U,
+    0xBB6969D2U, 0x70D9D9A9U, 0x898E8E07U, 0xA7949433U,
+    0xB69B9B2DU, 0x221E1E3CU, 0x92878715U, 0x20E9E9C9U,
+    0x49CECE87U, 0xFF5555AAU, 0x78282850U, 0x7ADFDFA5U,
+    0x8F8C8C03U, 0xF8A1A159U, 0x80898909U, 0x170D0D1AU,
+    0xDABFBF65U, 0x31E6E6D7U, 0xC6424284U, 0xB86868D0U,
+    0xC3414182U, 0xB0999929U, 0x772D2D5AU, 0x110F0F1EU,
+    0xCBB0B07BU, 0xFC5454A8U, 0xD6BBBB6DU, 0x3A16162CU
+};
+
+#define BYTE(x, y) (xmrig_amd_bfe((x), (y) << 3U, 8U))
+
+#if (ALGO == ALGO_CN_HEAVY_TUBE)
+inline uint4 AES_Round_bittube2(const __local uint *AES0, const __local uint *AES1, uint4 x, uint4 k)
+{
+    x = ~x;
+    k.s0 ^= AES0[BYTE(x.s0, 0)] ^ AES1[BYTE(x.s1, 1)] ^ rotate(AES0[BYTE(x.s2, 2)] ^ AES1[BYTE(x.s3, 3)], 16U);
+    x.s0 ^= k.s0;
+    k.s1 ^= AES0[BYTE(x.s1, 0)] ^ AES1[BYTE(x.s2, 1)] ^ rotate(AES0[BYTE(x.s3, 2)] ^ AES1[BYTE(x.s0, 3)], 16U);
+    x.s1 ^= k.s1;
+    k.s2 ^= AES0[BYTE(x.s2, 0)] ^ AES1[BYTE(x.s3, 1)] ^ rotate(AES0[BYTE(x.s0, 2)] ^ AES1[BYTE(x.s1, 3)], 16U);
+    x.s2 ^= k.s2;
+    k.s3 ^= AES0[BYTE(x.s3, 0)] ^ AES1[BYTE(x.s0, 1)] ^ rotate(AES0[BYTE(x.s1, 2)] ^ AES1[BYTE(x.s2, 3)], 16U);
+    return k;
+}
+#endif
+
+uint4 AES_Round(const __local uint *AES0, const __local uint *AES1, const __local uint *AES2, const __local uint *AES3, const uint4 X, uint4 key)
+{
+    key.s0 ^= AES0[BYTE(X.s0, 0)] ^ AES1[BYTE(X.s1, 1)] ^ AES2[BYTE(X.s2, 2)] ^ AES3[BYTE(X.s3, 3)];
+    key.s1 ^= AES0[BYTE(X.s1, 0)] ^ AES1[BYTE(X.s2, 1)] ^ AES2[BYTE(X.s3, 2)] ^ AES3[BYTE(X.s0, 3)];
+    key.s2 ^= AES0[BYTE(X.s2, 0)] ^ AES1[BYTE(X.s3, 1)] ^ AES2[BYTE(X.s0, 2)] ^ AES3[BYTE(X.s1, 3)];
+    key.s3 ^= AES0[BYTE(X.s3, 0)] ^ AES1[BYTE(X.s0, 1)] ^ AES2[BYTE(X.s1, 2)] ^ AES3[BYTE(X.s2, 3)];
+
+    return key;
+}
+
+uint4 AES_Round_Two_Tables(const __local uint *AES0, const __local uint *AES1, const uint4 X, uint4 key)
+{
+    key.s0 ^= AES0[BYTE(X.s0, 0)] ^ AES1[BYTE(X.s1, 1)] ^ rotate(AES0[BYTE(X.s2, 2)] ^ AES1[BYTE(X.s3, 3)], 16U);
+    key.s1 ^= AES0[BYTE(X.s1, 0)] ^ AES1[BYTE(X.s2, 1)] ^ rotate(AES0[BYTE(X.s3, 2)] ^ AES1[BYTE(X.s0, 3)], 16U);
+    key.s2 ^= AES0[BYTE(X.s2, 0)] ^ AES1[BYTE(X.s3, 1)] ^ rotate(AES0[BYTE(X.s0, 2)] ^ AES1[BYTE(X.s1, 3)], 16U);
+    key.s3 ^= AES0[BYTE(X.s3, 0)] ^ AES1[BYTE(X.s0, 1)] ^ rotate(AES0[BYTE(X.s1, 2)] ^ AES1[BYTE(X.s2, 3)], 16U);
+
+    return key;
+}
+
+
+static const __constant uchar rcon[8] = { 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40 };
+
+
+static const __constant uchar sbox[256] =
+{
+    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
+};
+
+
+#define SubWord(inw) ((sbox[BYTE(inw, 3)] << 24) | (sbox[BYTE(inw, 2)] << 16) | (sbox[BYTE(inw, 1)] << 8) | sbox[BYTE(inw, 0)])
+
+
+void AESExpandKey256(uint *keybuf)
+{
+    //#pragma unroll 4
+    for (uint c = 8, i = 1; c < 40; ++c) {
+        // For 256-bit keys, an sbox permutation is done every other 4th uint generated, AND every 8th
+        uint t = ((!(c & 7)) || ((c & 7) == 4)) ? SubWord(keybuf[c - 1]) : keybuf[c - 1];
+
+        // If the uint we're generating has an index that is a multiple of 8, rotate and XOR with the round constant,
+        // then XOR this with previously generated uint. If it's 4 after a multiple of 8, only the sbox permutation
+        // is done, followed by the XOR. If neither are true, only the XOR with the previously generated uint is done.
+        keybuf[c] = keybuf[c - 8] ^ ((!(c & 7)) ? rotate(t, 24U) ^ as_uint((uchar4)(rcon[i++], 0U, 0U, 0U)) : t);
+    }
+}
+
+#endif

src/backend/opencl/cl/cn/wolf-skein.cl

@@ -0,0 +1,138 @@
+#ifndef WOLF_SKEIN_CL
+#define WOLF_SKEIN_CL
+
+#ifdef cl_amd_media_ops
+#   pragma OPENCL EXTENSION cl_amd_media_ops : enable
+#   define xmrig_amd_bitalign(src0, src1, src2) amd_bitalign(src0, src1, src2)
+#else
+/* taken from https://www.khronos.org/registry/OpenCL/extensions/amd/cl_amd_media_ops.txt
+ * Build-in Function
+ *     uintn  amd_bitalign (uintn src0, uintn src1, uintn src2)
+ *   Description
+ *     dst.s0 =  (uint) (((((long)src0.s0) << 32) | (long)src1.s0) >> (src2.s0 & 31))
+ *     similar operation applied to other components of the vectors.
+ *
+ * The implemented function is modified because the last is in our case always a scalar.
+ * We can ignore the bitwise AND operation.
+ */
+inline uint2 xmrig_amd_bitalign(const uint2 src0, const uint2 src1, const uint src2)
+{
+    uint2 result;
+    result.s0 = (uint) (((((long)src0.s0) << 32) | (long)src1.s0) >> (src2));
+    result.s1 = (uint) (((((long)src0.s1) << 32) | (long)src1.s1) >> (src2));
+    return result;
+}
+#endif
+
+// Vectorized Skein implementation macros and functions by Wolf
+
+#define SKEIN_KS_PARITY 0x1BD11BDAA9FC1A22
+
+static const __constant ulong SKEIN256_IV[8] =
+{
+    0xCCD044A12FDB3E13UL, 0xE83590301A79A9EBUL,
+    0x55AEA0614F816E6FUL, 0x2A2767A4AE9B94DBUL,
+    0xEC06025E74DD7683UL, 0xE7A436CDC4746251UL,
+    0xC36FBAF9393AD185UL, 0x3EEDBA1833EDFC13UL
+};
+
+static const __constant ulong SKEIN512_256_IV[8] =
+{
+    0xCCD044A12FDB3E13UL, 0xE83590301A79A9EBUL,
+    0x55AEA0614F816E6FUL, 0x2A2767A4AE9B94DBUL,
+    0xEC06025E74DD7683UL, 0xE7A436CDC4746251UL,
+    0xC36FBAF9393AD185UL, 0x3EEDBA1833EDFC13UL
+};
+
+#define SKEIN_INJECT_KEY(p, s)  do { \
+    p += h; \
+    p.s5 += t[s % 3]; \
+    p.s6 += t[(s + 1) % 3]; \
+    p.s7 += s; \
+} while(0)
+
+ulong SKEIN_ROT(const uint2 x, const uint y)
+{
+    if (y < 32) {
+        return(as_ulong(xmrig_amd_bitalign(x, x.s10, 32 - y)));
+    }
+    else {
+        return(as_ulong(xmrig_amd_bitalign(x.s10, x, 32 - (y - 32))));
+    }
+}
+
+void SkeinMix8(ulong4 *pv0, ulong4 *pv1, const uint rc0, const uint rc1, const uint rc2, const uint rc3)
+{
+    *pv0 += *pv1;
+    (*pv1).s0 = SKEIN_ROT(as_uint2((*pv1).s0), rc0);
+    (*pv1).s1 = SKEIN_ROT(as_uint2((*pv1).s1), rc1);
+    (*pv1).s2 = SKEIN_ROT(as_uint2((*pv1).s2), rc2);
+    (*pv1).s3 = SKEIN_ROT(as_uint2((*pv1).s3), rc3);
+    *pv1 ^= *pv0;
+}
+
+ulong8 SkeinEvenRound(ulong8 p, const ulong8 h, const ulong *t, const uint s)
+{
+    SKEIN_INJECT_KEY(p, s);
+    ulong4 pv0 = p.even, pv1 = p.odd;
+    
+    SkeinMix8(&pv0, &pv1, 46, 36, 19, 37);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 33, 27, 14, 42);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 17, 49, 36, 39);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 44, 9, 54, 56);
+    return(shuffle2(pv0, pv1, (ulong8)(1, 4, 2, 7, 3, 6, 0, 5)));
+}
+
+ulong8 SkeinOddRound(ulong8 p, const ulong8 h, const ulong *t, const uint s)
+{
+    SKEIN_INJECT_KEY(p, s);
+    ulong4 pv0 = p.even, pv1 = p.odd;
+    
+    SkeinMix8(&pv0, &pv1, 39, 30, 34, 24);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 13, 50, 10, 17);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 25, 29, 39, 43);
+    pv0 = shuffle(pv0, (ulong4)(1, 2, 3, 0));
+    pv1 = shuffle(pv1, (ulong4)(0, 3, 2, 1));
+    
+    SkeinMix8(&pv0, &pv1, 8, 35, 56, 22);
+    return(shuffle2(pv0, pv1, (ulong8)(1, 4, 2, 7, 3, 6, 0, 5)));
+}
+
+ulong8 Skein512Block(ulong8 p, ulong8 h, ulong h8, const ulong *t)
+{
+    #pragma unroll
+    for(int i = 0; i < 18; ++i)
+    {
+        p = SkeinEvenRound(p, h, t, i);
+        ++i;
+        ulong tmp = h.s0;
+        h = shuffle(h, (ulong8)(1, 2, 3, 4, 5, 6, 7, 0));
+        h.s7 = h8;
+        h8 = tmp;
+        p = SkeinOddRound(p, h, t, i);
+        tmp = h.s0;
+        h = shuffle(h, (ulong8)(1, 2, 3, 4, 5, 6, 7, 0));
+        h.s7 = h8;
+        h8 = tmp;
+    }
+    
+    SKEIN_INJECT_KEY(p, 18);
+    return(p);
+}
+
+#endif

src/backend/opencl/cl/rx/aes.cl

@@ -0,0 +1,635 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+__constant static const uint AES_TABLE[2048] =
+{
+	0xa56363c6U, 0x847c7cf8U, 0x997777eeU, 0x8d7b7bf6U,
+	0x0df2f2ffU, 0xbd6b6bd6U, 0xb16f6fdeU, 0x54c5c591U,
+	0x50303060U, 0x03010102U, 0xa96767ceU, 0x7d2b2b56U,
+	0x19fefee7U, 0x62d7d7b5U, 0xe6abab4dU, 0x9a7676ecU,
+	0x45caca8fU, 0x9d82821fU, 0x40c9c989U, 0x877d7dfaU,
+	0x15fafaefU, 0xeb5959b2U, 0xc947478eU, 0x0bf0f0fbU,
+	0xecadad41U, 0x67d4d4b3U, 0xfda2a25fU, 0xeaafaf45U,
+	0xbf9c9c23U, 0xf7a4a453U, 0x967272e4U, 0x5bc0c09bU,
+	0xc2b7b775U, 0x1cfdfde1U, 0xae93933dU, 0x6a26264cU,
+	0x5a36366cU, 0x413f3f7eU, 0x02f7f7f5U, 0x4fcccc83U,
+	0x5c343468U, 0xf4a5a551U, 0x34e5e5d1U, 0x08f1f1f9U,
+	0x937171e2U, 0x73d8d8abU, 0x53313162U, 0x3f15152aU,
+	0x0c040408U, 0x52c7c795U, 0x65232346U, 0x5ec3c39dU,
+	0x28181830U, 0xa1969637U, 0x0f05050aU, 0xb59a9a2fU,
+	0x0907070eU, 0x36121224U, 0x9b80801bU, 0x3de2e2dfU,
+	0x26ebebcdU, 0x6927274eU, 0xcdb2b27fU, 0x9f7575eaU,
+	0x1b090912U, 0x9e83831dU, 0x742c2c58U, 0x2e1a1a34U,
+	0x2d1b1b36U, 0xb26e6edcU, 0xee5a5ab4U, 0xfba0a05bU,
+	0xf65252a4U, 0x4d3b3b76U, 0x61d6d6b7U, 0xceb3b37dU,
+	0x7b292952U, 0x3ee3e3ddU, 0x712f2f5eU, 0x97848413U,
+	0xf55353a6U, 0x68d1d1b9U, 0x00000000U, 0x2cededc1U,
+	0x60202040U, 0x1ffcfce3U, 0xc8b1b179U, 0xed5b5bb6U,
+	0xbe6a6ad4U, 0x46cbcb8dU, 0xd9bebe67U, 0x4b393972U,
+	0xde4a4a94U, 0xd44c4c98U, 0xe85858b0U, 0x4acfcf85U,
+	0x6bd0d0bbU, 0x2aefefc5U, 0xe5aaaa4fU, 0x16fbfbedU,
+	0xc5434386U, 0xd74d4d9aU, 0x55333366U, 0x94858511U,
+	0xcf45458aU, 0x10f9f9e9U, 0x06020204U, 0x817f7ffeU,
+	0xf05050a0U, 0x443c3c78U, 0xba9f9f25U, 0xe3a8a84bU,
+	0xf35151a2U, 0xfea3a35dU, 0xc0404080U, 0x8a8f8f05U,
+	0xad92923fU, 0xbc9d9d21U, 0x48383870U, 0x04f5f5f1U,
+	0xdfbcbc63U, 0xc1b6b677U, 0x75dadaafU, 0x63212142U,
+	0x30101020U, 0x1affffe5U, 0x0ef3f3fdU, 0x6dd2d2bfU,
+	0x4ccdcd81U, 0x140c0c18U, 0x35131326U, 0x2fececc3U,
+	0xe15f5fbeU, 0xa2979735U, 0xcc444488U, 0x3917172eU,
+	0x57c4c493U, 0xf2a7a755U, 0x827e7efcU, 0x473d3d7aU,
+	0xac6464c8U, 0xe75d5dbaU, 0x2b191932U, 0x957373e6U,
+	0xa06060c0U, 0x98818119U, 0xd14f4f9eU, 0x7fdcdca3U,
+	0x66222244U, 0x7e2a2a54U, 0xab90903bU, 0x8388880bU,
+	0xca46468cU, 0x29eeeec7U, 0xd3b8b86bU, 0x3c141428U,
+	0x79dedea7U, 0xe25e5ebcU, 0x1d0b0b16U, 0x76dbdbadU,
+	0x3be0e0dbU, 0x56323264U, 0x4e3a3a74U, 0x1e0a0a14U,
+	0xdb494992U, 0x0a06060cU, 0x6c242448U, 0xe45c5cb8U,
+	0x5dc2c29fU, 0x6ed3d3bdU, 0xefacac43U, 0xa66262c4U,
+	0xa8919139U, 0xa4959531U, 0x37e4e4d3U, 0x8b7979f2U,
+	0x32e7e7d5U, 0x43c8c88bU, 0x5937376eU, 0xb76d6ddaU,
+	0x8c8d8d01U, 0x64d5d5b1U, 0xd24e4e9cU, 0xe0a9a949U,
+	0xb46c6cd8U, 0xfa5656acU, 0x07f4f4f3U, 0x25eaeacfU,
+	0xaf6565caU, 0x8e7a7af4U, 0xe9aeae47U, 0x18080810U,
+	0xd5baba6fU, 0x887878f0U, 0x6f25254aU, 0x722e2e5cU,
+	0x241c1c38U, 0xf1a6a657U, 0xc7b4b473U, 0x51c6c697U,
+	0x23e8e8cbU, 0x7cdddda1U, 0x9c7474e8U, 0x211f1f3eU,
+	0xdd4b4b96U, 0xdcbdbd61U, 0x868b8b0dU, 0x858a8a0fU,
+	0x907070e0U, 0x423e3e7cU, 0xc4b5b571U, 0xaa6666ccU,
+	0xd8484890U, 0x05030306U, 0x01f6f6f7U, 0x120e0e1cU,
+	0xa36161c2U, 0x5f35356aU, 0xf95757aeU, 0xd0b9b969U,
+	0x91868617U, 0x58c1c199U, 0x271d1d3aU, 0xb99e9e27U,
+	0x38e1e1d9U, 0x13f8f8ebU, 0xb398982bU, 0x33111122U,
+	0xbb6969d2U, 0x70d9d9a9U, 0x898e8e07U, 0xa7949433U,
+	0xb69b9b2dU, 0x221e1e3cU, 0x92878715U, 0x20e9e9c9U,
+	0x49cece87U, 0xff5555aaU, 0x78282850U, 0x7adfdfa5U,
+	0x8f8c8c03U, 0xf8a1a159U, 0x80898909U, 0x170d0d1aU,
+	0xdabfbf65U, 0x31e6e6d7U, 0xc6424284U, 0xb86868d0U,
+	0xc3414182U, 0xb0999929U, 0x772d2d5aU, 0x110f0f1eU,
+	0xcbb0b07bU, 0xfc5454a8U, 0xd6bbbb6dU, 0x3a16162cU,
+	0x6363c6a5U, 0x7c7cf884U, 0x7777ee99U, 0x7b7bf68dU,
+	0xf2f2ff0dU, 0x6b6bd6bdU, 0x6f6fdeb1U, 0xc5c59154U,
+	0x30306050U, 0x01010203U, 0x6767cea9U, 0x2b2b567dU,
+	0xfefee719U, 0xd7d7b562U, 0xabab4de6U, 0x7676ec9aU,
+	0xcaca8f45U, 0x82821f9dU, 0xc9c98940U, 0x7d7dfa87U,
+	0xfafaef15U, 0x5959b2ebU, 0x47478ec9U, 0xf0f0fb0bU,
+	0xadad41ecU, 0xd4d4b367U, 0xa2a25ffdU, 0xafaf45eaU,
+	0x9c9c23bfU, 0xa4a453f7U, 0x7272e496U, 0xc0c09b5bU,
+	0xb7b775c2U, 0xfdfde11cU, 0x93933daeU, 0x26264c6aU,
+	0x36366c5aU, 0x3f3f7e41U, 0xf7f7f502U, 0xcccc834fU,
+	0x3434685cU, 0xa5a551f4U, 0xe5e5d134U, 0xf1f1f908U,
+	0x7171e293U, 0xd8d8ab73U, 0x31316253U, 0x15152a3fU,
+	0x0404080cU, 0xc7c79552U, 0x23234665U, 0xc3c39d5eU,
+	0x18183028U, 0x969637a1U, 0x05050a0fU, 0x9a9a2fb5U,
+	0x07070e09U, 0x12122436U, 0x80801b9bU, 0xe2e2df3dU,
+	0xebebcd26U, 0x27274e69U, 0xb2b27fcdU, 0x7575ea9fU,
+	0x0909121bU, 0x83831d9eU, 0x2c2c5874U, 0x1a1a342eU,
+	0x1b1b362dU, 0x6e6edcb2U, 0x5a5ab4eeU, 0xa0a05bfbU,
+	0x5252a4f6U, 0x3b3b764dU, 0xd6d6b761U, 0xb3b37dceU,
+	0x2929527bU, 0xe3e3dd3eU, 0x2f2f5e71U, 0x84841397U,
+	0x5353a6f5U, 0xd1d1b968U, 0x00000000U, 0xededc12cU,
+	0x20204060U, 0xfcfce31fU, 0xb1b179c8U, 0x5b5bb6edU,
+	0x6a6ad4beU, 0xcbcb8d46U, 0xbebe67d9U, 0x3939724bU,
+	0x4a4a94deU, 0x4c4c98d4U, 0x5858b0e8U, 0xcfcf854aU,
+	0xd0d0bb6bU, 0xefefc52aU, 0xaaaa4fe5U, 0xfbfbed16U,
+	0x434386c5U, 0x4d4d9ad7U, 0x33336655U, 0x85851194U,
+	0x45458acfU, 0xf9f9e910U, 0x02020406U, 0x7f7ffe81U,
+	0x5050a0f0U, 0x3c3c7844U, 0x9f9f25baU, 0xa8a84be3U,
+	0x5151a2f3U, 0xa3a35dfeU, 0x404080c0U, 0x8f8f058aU,
+	0x92923fadU, 0x9d9d21bcU, 0x38387048U, 0xf5f5f104U,
+	0xbcbc63dfU, 0xb6b677c1U, 0xdadaaf75U, 0x21214263U,
+	0x10102030U, 0xffffe51aU, 0xf3f3fd0eU, 0xd2d2bf6dU,
+	0xcdcd814cU, 0x0c0c1814U, 0x13132635U, 0xececc32fU,
+	0x5f5fbee1U, 0x979735a2U, 0x444488ccU, 0x17172e39U,
+	0xc4c49357U, 0xa7a755f2U, 0x7e7efc82U, 0x3d3d7a47U,
+	0x6464c8acU, 0x5d5dbae7U, 0x1919322bU, 0x7373e695U,
+	0x6060c0a0U, 0x81811998U, 0x4f4f9ed1U, 0xdcdca37fU,
+	0x22224466U, 0x2a2a547eU, 0x90903babU, 0x88880b83U,
+	0x46468ccaU, 0xeeeec729U, 0xb8b86bd3U, 0x1414283cU,
+	0xdedea779U, 0x5e5ebce2U, 0x0b0b161dU, 0xdbdbad76U,
+	0xe0e0db3bU, 0x32326456U, 0x3a3a744eU, 0x0a0a141eU,
+	0x494992dbU, 0x06060c0aU, 0x2424486cU, 0x5c5cb8e4U,
+	0xc2c29f5dU, 0xd3d3bd6eU, 0xacac43efU, 0x6262c4a6U,
+	0x919139a8U, 0x959531a4U, 0xe4e4d337U, 0x7979f28bU,
+	0xe7e7d532U, 0xc8c88b43U, 0x37376e59U, 0x6d6ddab7U,
+	0x8d8d018cU, 0xd5d5b164U, 0x4e4e9cd2U, 0xa9a949e0U,
+	0x6c6cd8b4U, 0x5656acfaU, 0xf4f4f307U, 0xeaeacf25U,
+	0x6565caafU, 0x7a7af48eU, 0xaeae47e9U, 0x08081018U,
+	0xbaba6fd5U, 0x7878f088U, 0x25254a6fU, 0x2e2e5c72U,
+	0x1c1c3824U, 0xa6a657f1U, 0xb4b473c7U, 0xc6c69751U,
+	0xe8e8cb23U, 0xdddda17cU, 0x7474e89cU, 0x1f1f3e21U,
+	0x4b4b96ddU, 0xbdbd61dcU, 0x8b8b0d86U, 0x8a8a0f85U,
+	0x7070e090U, 0x3e3e7c42U, 0xb5b571c4U, 0x6666ccaaU,
+	0x484890d8U, 0x03030605U, 0xf6f6f701U, 0x0e0e1c12U,
+	0x6161c2a3U, 0x35356a5fU, 0x5757aef9U, 0xb9b969d0U,
+	0x86861791U, 0xc1c19958U, 0x1d1d3a27U, 0x9e9e27b9U,
+	0xe1e1d938U, 0xf8f8eb13U, 0x98982bb3U, 0x11112233U,
+	0x6969d2bbU, 0xd9d9a970U, 0x8e8e0789U, 0x949433a7U,
+	0x9b9b2db6U, 0x1e1e3c22U, 0x87871592U, 0xe9e9c920U,
+	0xcece8749U, 0x5555aaffU, 0x28285078U, 0xdfdfa57aU,
+	0x8c8c038fU, 0xa1a159f8U, 0x89890980U, 0x0d0d1a17U,
+	0xbfbf65daU, 0xe6e6d731U, 0x424284c6U, 0x6868d0b8U,
+	0x414182c3U, 0x999929b0U, 0x2d2d5a77U, 0x0f0f1e11U,
+	0xb0b07bcbU, 0x5454a8fcU, 0xbbbb6dd6U, 0x16162c3aU,
+	0x63c6a563U, 0x7cf8847cU, 0x77ee9977U, 0x7bf68d7bU,
+	0xf2ff0df2U, 0x6bd6bd6bU, 0x6fdeb16fU, 0xc59154c5U,
+	0x30605030U, 0x01020301U, 0x67cea967U, 0x2b567d2bU,
+	0xfee719feU, 0xd7b562d7U, 0xab4de6abU, 0x76ec9a76U,
+	0xca8f45caU, 0x821f9d82U, 0xc98940c9U, 0x7dfa877dU,
+	0xfaef15faU, 0x59b2eb59U, 0x478ec947U, 0xf0fb0bf0U,
+	0xad41ecadU, 0xd4b367d4U, 0xa25ffda2U, 0xaf45eaafU,
+	0x9c23bf9cU, 0xa453f7a4U, 0x72e49672U, 0xc09b5bc0U,
+	0xb775c2b7U, 0xfde11cfdU, 0x933dae93U, 0x264c6a26U,
+	0x366c5a36U, 0x3f7e413fU, 0xf7f502f7U, 0xcc834fccU,
+	0x34685c34U, 0xa551f4a5U, 0xe5d134e5U, 0xf1f908f1U,
+	0x71e29371U, 0xd8ab73d8U, 0x31625331U, 0x152a3f15U,
+	0x04080c04U, 0xc79552c7U, 0x23466523U, 0xc39d5ec3U,
+	0x18302818U, 0x9637a196U, 0x050a0f05U, 0x9a2fb59aU,
+	0x070e0907U, 0x12243612U, 0x801b9b80U, 0xe2df3de2U,
+	0xebcd26ebU, 0x274e6927U, 0xb27fcdb2U, 0x75ea9f75U,
+	0x09121b09U, 0x831d9e83U, 0x2c58742cU, 0x1a342e1aU,
+	0x1b362d1bU, 0x6edcb26eU, 0x5ab4ee5aU, 0xa05bfba0U,
+	0x52a4f652U, 0x3b764d3bU, 0xd6b761d6U, 0xb37dceb3U,
+	0x29527b29U, 0xe3dd3ee3U, 0x2f5e712fU, 0x84139784U,
+	0x53a6f553U, 0xd1b968d1U, 0x00000000U, 0xedc12cedU,
+	0x20406020U, 0xfce31ffcU, 0xb179c8b1U, 0x5bb6ed5bU,
+	0x6ad4be6aU, 0xcb8d46cbU, 0xbe67d9beU, 0x39724b39U,
+	0x4a94de4aU, 0x4c98d44cU, 0x58b0e858U, 0xcf854acfU,
+	0xd0bb6bd0U, 0xefc52aefU, 0xaa4fe5aaU, 0xfbed16fbU,
+	0x4386c543U, 0x4d9ad74dU, 0x33665533U, 0x85119485U,
+	0x458acf45U, 0xf9e910f9U, 0x02040602U, 0x7ffe817fU,
+	0x50a0f050U, 0x3c78443cU, 0x9f25ba9fU, 0xa84be3a8U,
+	0x51a2f351U, 0xa35dfea3U, 0x4080c040U, 0x8f058a8fU,
+	0x923fad92U, 0x9d21bc9dU, 0x38704838U, 0xf5f104f5U,
+	0xbc63dfbcU, 0xb677c1b6U, 0xdaaf75daU, 0x21426321U,
+	0x10203010U, 0xffe51affU, 0xf3fd0ef3U, 0xd2bf6dd2U,
+	0xcd814ccdU, 0x0c18140cU, 0x13263513U, 0xecc32fecU,
+	0x5fbee15fU, 0x9735a297U, 0x4488cc44U, 0x172e3917U,
+	0xc49357c4U, 0xa755f2a7U, 0x7efc827eU, 0x3d7a473dU,
+	0x64c8ac64U, 0x5dbae75dU, 0x19322b19U, 0x73e69573U,
+	0x60c0a060U, 0x81199881U, 0x4f9ed14fU, 0xdca37fdcU,
+	0x22446622U, 0x2a547e2aU, 0x903bab90U, 0x880b8388U,
+	0x468cca46U, 0xeec729eeU, 0xb86bd3b8U, 0x14283c14U,
+	0xdea779deU, 0x5ebce25eU, 0x0b161d0bU, 0xdbad76dbU,
+	0xe0db3be0U, 0x32645632U, 0x3a744e3aU, 0x0a141e0aU,
+	0x4992db49U, 0x060c0a06U, 0x24486c24U, 0x5cb8e45cU,
+	0xc29f5dc2U, 0xd3bd6ed3U, 0xac43efacU, 0x62c4a662U,
+	0x9139a891U, 0x9531a495U, 0xe4d337e4U, 0x79f28b79U,
+	0xe7d532e7U, 0xc88b43c8U, 0x376e5937U, 0x6ddab76dU,
+	0x8d018c8dU, 0xd5b164d5U, 0x4e9cd24eU, 0xa949e0a9U,
+	0x6cd8b46cU, 0x56acfa56U, 0xf4f307f4U, 0xeacf25eaU,
+	0x65caaf65U, 0x7af48e7aU, 0xae47e9aeU, 0x08101808U,
+	0xba6fd5baU, 0x78f08878U, 0x254a6f25U, 0x2e5c722eU,
+	0x1c38241cU, 0xa657f1a6U, 0xb473c7b4U, 0xc69751c6U,
+	0xe8cb23e8U, 0xdda17cddU, 0x74e89c74U, 0x1f3e211fU,
+	0x4b96dd4bU, 0xbd61dcbdU, 0x8b0d868bU, 0x8a0f858aU,
+	0x70e09070U, 0x3e7c423eU, 0xb571c4b5U, 0x66ccaa66U,
+	0x4890d848U, 0x03060503U, 0xf6f701f6U, 0x0e1c120eU,
+	0x61c2a361U, 0x356a5f35U, 0x57aef957U, 0xb969d0b9U,
+	0x86179186U, 0xc19958c1U, 0x1d3a271dU, 0x9e27b99eU,
+	0xe1d938e1U, 0xf8eb13f8U, 0x982bb398U, 0x11223311U,
+	0x69d2bb69U, 0xd9a970d9U, 0x8e07898eU, 0x9433a794U,
+	0x9b2db69bU, 0x1e3c221eU, 0x87159287U, 0xe9c920e9U,
+	0xce8749ceU, 0x55aaff55U, 0x28507828U, 0xdfa57adfU,
+	0x8c038f8cU, 0xa159f8a1U, 0x89098089U, 0x0d1a170dU,
+	0xbf65dabfU, 0xe6d731e6U, 0x4284c642U, 0x68d0b868U,
+	0x4182c341U, 0x9929b099U, 0x2d5a772dU, 0x0f1e110fU,
+	0xb07bcbb0U, 0x54a8fc54U, 0xbb6dd6bbU, 0x162c3a16U,
+	0xc6a56363U, 0xf8847c7cU, 0xee997777U, 0xf68d7b7bU,
+	0xff0df2f2U, 0xd6bd6b6bU, 0xdeb16f6fU, 0x9154c5c5U,
+	0x60503030U, 0x02030101U, 0xcea96767U, 0x567d2b2bU,
+	0xe719fefeU, 0xb562d7d7U, 0x4de6ababU, 0xec9a7676U,
+	0x8f45cacaU, 0x1f9d8282U, 0x8940c9c9U, 0xfa877d7dU,
+	0xef15fafaU, 0xb2eb5959U, 0x8ec94747U, 0xfb0bf0f0U,
+	0x41ecadadU, 0xb367d4d4U, 0x5ffda2a2U, 0x45eaafafU,
+	0x23bf9c9cU, 0x53f7a4a4U, 0xe4967272U, 0x9b5bc0c0U,
+	0x75c2b7b7U, 0xe11cfdfdU, 0x3dae9393U, 0x4c6a2626U,
+	0x6c5a3636U, 0x7e413f3fU, 0xf502f7f7U, 0x834fccccU,
+	0x685c3434U, 0x51f4a5a5U, 0xd134e5e5U, 0xf908f1f1U,
+	0xe2937171U, 0xab73d8d8U, 0x62533131U, 0x2a3f1515U,
+	0x080c0404U, 0x9552c7c7U, 0x46652323U, 0x9d5ec3c3U,
+	0x30281818U, 0x37a19696U, 0x0a0f0505U, 0x2fb59a9aU,
+	0x0e090707U, 0x24361212U, 0x1b9b8080U, 0xdf3de2e2U,
+	0xcd26ebebU, 0x4e692727U, 0x7fcdb2b2U, 0xea9f7575U,
+	0x121b0909U, 0x1d9e8383U, 0x58742c2cU, 0x342e1a1aU,
+	0x362d1b1bU, 0xdcb26e6eU, 0xb4ee5a5aU, 0x5bfba0a0U,
+	0xa4f65252U, 0x764d3b3bU, 0xb761d6d6U, 0x7dceb3b3U,
+	0x527b2929U, 0xdd3ee3e3U, 0x5e712f2fU, 0x13978484U,
+	0xa6f55353U, 0xb968d1d1U, 0x00000000U, 0xc12cededU,
+	0x40602020U, 0xe31ffcfcU, 0x79c8b1b1U, 0xb6ed5b5bU,
+	0xd4be6a6aU, 0x8d46cbcbU, 0x67d9bebeU, 0x724b3939U,
+	0x94de4a4aU, 0x98d44c4cU, 0xb0e85858U, 0x854acfcfU,
+	0xbb6bd0d0U, 0xc52aefefU, 0x4fe5aaaaU, 0xed16fbfbU,
+	0x86c54343U, 0x9ad74d4dU, 0x66553333U, 0x11948585U,
+	0x8acf4545U, 0xe910f9f9U, 0x04060202U, 0xfe817f7fU,
+	0xa0f05050U, 0x78443c3cU, 0x25ba9f9fU, 0x4be3a8a8U,
+	0xa2f35151U, 0x5dfea3a3U, 0x80c04040U, 0x058a8f8fU,
+	0x3fad9292U, 0x21bc9d9dU, 0x70483838U, 0xf104f5f5U,
+	0x63dfbcbcU, 0x77c1b6b6U, 0xaf75dadaU, 0x42632121U,
+	0x20301010U, 0xe51affffU, 0xfd0ef3f3U, 0xbf6dd2d2U,
+	0x814ccdcdU, 0x18140c0cU, 0x26351313U, 0xc32fececU,
+	0xbee15f5fU, 0x35a29797U, 0x88cc4444U, 0x2e391717U,
+	0x9357c4c4U, 0x55f2a7a7U, 0xfc827e7eU, 0x7a473d3dU,
+	0xc8ac6464U, 0xbae75d5dU, 0x322b1919U, 0xe6957373U,
+	0xc0a06060U, 0x19988181U, 0x9ed14f4fU, 0xa37fdcdcU,
+	0x44662222U, 0x547e2a2aU, 0x3bab9090U, 0x0b838888U,
+	0x8cca4646U, 0xc729eeeeU, 0x6bd3b8b8U, 0x283c1414U,
+	0xa779dedeU, 0xbce25e5eU, 0x161d0b0bU, 0xad76dbdbU,
+	0xdb3be0e0U, 0x64563232U, 0x744e3a3aU, 0x141e0a0aU,
+	0x92db4949U, 0x0c0a0606U, 0x486c2424U, 0xb8e45c5cU,
+	0x9f5dc2c2U, 0xbd6ed3d3U, 0x43efacacU, 0xc4a66262U,
+	0x39a89191U, 0x31a49595U, 0xd337e4e4U, 0xf28b7979U,
+	0xd532e7e7U, 0x8b43c8c8U, 0x6e593737U, 0xdab76d6dU,
+	0x018c8d8dU, 0xb164d5d5U, 0x9cd24e4eU, 0x49e0a9a9U,
+	0xd8b46c6cU, 0xacfa5656U, 0xf307f4f4U, 0xcf25eaeaU,
+	0xcaaf6565U, 0xf48e7a7aU, 0x47e9aeaeU, 0x10180808U,
+	0x6fd5babaU, 0xf0887878U, 0x4a6f2525U, 0x5c722e2eU,
+	0x38241c1cU, 0x57f1a6a6U, 0x73c7b4b4U, 0x9751c6c6U,
+	0xcb23e8e8U, 0xa17cddddU, 0xe89c7474U, 0x3e211f1fU,
+	0x96dd4b4bU, 0x61dcbdbdU, 0x0d868b8bU, 0x0f858a8aU,
+	0xe0907070U, 0x7c423e3eU, 0x71c4b5b5U, 0xccaa6666U,
+	0x90d84848U, 0x06050303U, 0xf701f6f6U, 0x1c120e0eU,
+	0xc2a36161U, 0x6a5f3535U, 0xaef95757U, 0x69d0b9b9U,
+	0x17918686U, 0x9958c1c1U, 0x3a271d1dU, 0x27b99e9eU,
+	0xd938e1e1U, 0xeb13f8f8U, 0x2bb39898U, 0x22331111U,
+	0xd2bb6969U, 0xa970d9d9U, 0x07898e8eU, 0x33a79494U,
+	0x2db69b9bU, 0x3c221e1eU, 0x15928787U, 0xc920e9e9U,
+	0x8749ceceU, 0xaaff5555U, 0x50782828U, 0xa57adfdfU,
+	0x038f8c8cU, 0x59f8a1a1U, 0x09808989U, 0x1a170d0dU,
+	0x65dabfbfU, 0xd731e6e6U, 0x84c64242U, 0xd0b86868U,
+	0x82c34141U, 0x29b09999U, 0x5a772d2dU, 0x1e110f0fU,
+	0x7bcbb0b0U, 0xa8fc5454U, 0x6dd6bbbbU, 0x2c3a1616U,
+	0x50a7f451U, 0x5365417eU, 0xc3a4171aU, 0x965e273aU,
+	0xcb6bab3bU, 0xf1459d1fU, 0xab58faacU, 0x9303e34bU,
+	0x55fa3020U, 0xf66d76adU, 0x9176cc88U, 0x254c02f5U,
+	0xfcd7e54fU, 0xd7cb2ac5U, 0x80443526U, 0x8fa362b5U,
+	0x495ab1deU, 0x671bba25U, 0x980eea45U, 0xe1c0fe5dU,
+	0x02752fc3U, 0x12f04c81U, 0xa397468dU, 0xc6f9d36bU,
+	0xe75f8f03U, 0x959c9215U, 0xeb7a6dbfU, 0xda595295U,
+	0x2d83bed4U, 0xd3217458U, 0x2969e049U, 0x44c8c98eU,
+	0x6a89c275U, 0x78798ef4U, 0x6b3e5899U, 0xdd71b927U,
+	0xb64fe1beU, 0x17ad88f0U, 0x66ac20c9U, 0xb43ace7dU,
+	0x184adf63U, 0x82311ae5U, 0x60335197U, 0x457f5362U,
+	0xe07764b1U, 0x84ae6bbbU, 0x1ca081feU, 0x942b08f9U,
+	0x58684870U, 0x19fd458fU, 0x876cde94U, 0xb7f87b52U,
+	0x23d373abU, 0xe2024b72U, 0x578f1fe3U, 0x2aab5566U,
+	0x0728ebb2U, 0x03c2b52fU, 0x9a7bc586U, 0xa50837d3U,
+	0xf2872830U, 0xb2a5bf23U, 0xba6a0302U, 0x5c8216edU,
+	0x2b1ccf8aU, 0x92b479a7U, 0xf0f207f3U, 0xa1e2694eU,
+	0xcdf4da65U, 0xd5be0506U, 0x1f6234d1U, 0x8afea6c4U,
+	0x9d532e34U, 0xa055f3a2U, 0x32e18a05U, 0x75ebf6a4U,
+	0x39ec830bU, 0xaaef6040U, 0x069f715eU, 0x51106ebdU,
+	0xf98a213eU, 0x3d06dd96U, 0xae053eddU, 0x46bde64dU,
+	0xb58d5491U, 0x055dc471U, 0x6fd40604U, 0xff155060U,
+	0x24fb9819U, 0x97e9bdd6U, 0xcc434089U, 0x779ed967U,
+	0xbd42e8b0U, 0x888b8907U, 0x385b19e7U, 0xdbeec879U,
+	0x470a7ca1U, 0xe90f427cU, 0xc91e84f8U, 0x00000000U,
+	0x83868009U, 0x48ed2b32U, 0xac70111eU, 0x4e725a6cU,
+	0xfbff0efdU, 0x5638850fU, 0x1ed5ae3dU, 0x27392d36U,
+	0x64d90f0aU, 0x21a65c68U, 0xd1545b9bU, 0x3a2e3624U,
+	0xb1670a0cU, 0x0fe75793U, 0xd296eeb4U, 0x9e919b1bU,
+	0x4fc5c080U, 0xa220dc61U, 0x694b775aU, 0x161a121cU,
+	0x0aba93e2U, 0xe52aa0c0U, 0x43e0223cU, 0x1d171b12U,
+	0x0b0d090eU, 0xadc78bf2U, 0xb9a8b62dU, 0xc8a91e14U,
+	0x8519f157U, 0x4c0775afU, 0xbbdd99eeU, 0xfd607fa3U,
+	0x9f2601f7U, 0xbcf5725cU, 0xc53b6644U, 0x347efb5bU,
+	0x7629438bU, 0xdcc623cbU, 0x68fcedb6U, 0x63f1e4b8U,
+	0xcadc31d7U, 0x10856342U, 0x40229713U, 0x2011c684U,
+	0x7d244a85U, 0xf83dbbd2U, 0x1132f9aeU, 0x6da129c7U,
+	0x4b2f9e1dU, 0xf330b2dcU, 0xec52860dU, 0xd0e3c177U,
+	0x6c16b32bU, 0x99b970a9U, 0xfa489411U, 0x2264e947U,
+	0xc48cfca8U, 0x1a3ff0a0U, 0xd82c7d56U, 0xef903322U,
+	0xc74e4987U, 0xc1d138d9U, 0xfea2ca8cU, 0x360bd498U,
+	0xcf81f5a6U, 0x28de7aa5U, 0x268eb7daU, 0xa4bfad3fU,
+	0xe49d3a2cU, 0x0d927850U, 0x9bcc5f6aU, 0x62467e54U,
+	0xc2138df6U, 0xe8b8d890U, 0x5ef7392eU, 0xf5afc382U,
+	0xbe805d9fU, 0x7c93d069U, 0xa92dd56fU, 0xb31225cfU,
+	0x3b99acc8U, 0xa77d1810U, 0x6e639ce8U, 0x7bbb3bdbU,
+	0x097826cdU, 0xf418596eU, 0x01b79aecU, 0xa89a4f83U,
+	0x656e95e6U, 0x7ee6ffaaU, 0x08cfbc21U, 0xe6e815efU,
+	0xd99be7baU, 0xce366f4aU, 0xd4099feaU, 0xd67cb029U,
+	0xafb2a431U, 0x31233f2aU, 0x3094a5c6U, 0xc066a235U,
+	0x37bc4e74U, 0xa6ca82fcU, 0xb0d090e0U, 0x15d8a733U,
+	0x4a9804f1U, 0xf7daec41U, 0x0e50cd7fU, 0x2ff69117U,
+	0x8dd64d76U, 0x4db0ef43U, 0x544daaccU, 0xdf0496e4U,
+	0xe3b5d19eU, 0x1b886a4cU, 0xb81f2cc1U, 0x7f516546U,
+	0x04ea5e9dU, 0x5d358c01U, 0x737487faU, 0x2e410bfbU,
+	0x5a1d67b3U, 0x52d2db92U, 0x335610e9U, 0x1347d66dU,
+	0x8c61d79aU, 0x7a0ca137U, 0x8e14f859U, 0x893c13ebU,
+	0xee27a9ceU, 0x35c961b7U, 0xede51ce1U, 0x3cb1477aU,
+	0x59dfd29cU, 0x3f73f255U, 0x79ce1418U, 0xbf37c773U,
+	0xeacdf753U, 0x5baafd5fU, 0x146f3ddfU, 0x86db4478U,
+	0x81f3afcaU, 0x3ec468b9U, 0x2c342438U, 0x5f40a3c2U,
+	0x72c31d16U, 0x0c25e2bcU, 0x8b493c28U, 0x41950dffU,
+	0x7101a839U, 0xdeb30c08U, 0x9ce4b4d8U, 0x90c15664U,
+	0x6184cb7bU, 0x70b632d5U, 0x745c6c48U, 0x4257b8d0U,
+	0xa7f45150U, 0x65417e53U, 0xa4171ac3U, 0x5e273a96U,
+	0x6bab3bcbU, 0x459d1ff1U, 0x58faacabU, 0x03e34b93U,
+	0xfa302055U, 0x6d76adf6U, 0x76cc8891U, 0x4c02f525U,
+	0xd7e54ffcU, 0xcb2ac5d7U, 0x44352680U, 0xa362b58fU,
+	0x5ab1de49U, 0x1bba2567U, 0x0eea4598U, 0xc0fe5de1U,
+	0x752fc302U, 0xf04c8112U, 0x97468da3U, 0xf9d36bc6U,
+	0x5f8f03e7U, 0x9c921595U, 0x7a6dbfebU, 0x595295daU,
+	0x83bed42dU, 0x217458d3U, 0x69e04929U, 0xc8c98e44U,
+	0x89c2756aU, 0x798ef478U, 0x3e58996bU, 0x71b927ddU,
+	0x4fe1beb6U, 0xad88f017U, 0xac20c966U, 0x3ace7db4U,
+	0x4adf6318U, 0x311ae582U, 0x33519760U, 0x7f536245U,
+	0x7764b1e0U, 0xae6bbb84U, 0xa081fe1cU, 0x2b08f994U,
+	0x68487058U, 0xfd458f19U, 0x6cde9487U, 0xf87b52b7U,
+	0xd373ab23U, 0x024b72e2U, 0x8f1fe357U, 0xab55662aU,
+	0x28ebb207U, 0xc2b52f03U, 0x7bc5869aU, 0x0837d3a5U,
+	0x872830f2U, 0xa5bf23b2U, 0x6a0302baU, 0x8216ed5cU,
+	0x1ccf8a2bU, 0xb479a792U, 0xf207f3f0U, 0xe2694ea1U,
+	0xf4da65cdU, 0xbe0506d5U, 0x6234d11fU, 0xfea6c48aU,
+	0x532e349dU, 0x55f3a2a0U, 0xe18a0532U, 0xebf6a475U,
+	0xec830b39U, 0xef6040aaU, 0x9f715e06U, 0x106ebd51U,
+	0x8a213ef9U, 0x06dd963dU, 0x053eddaeU, 0xbde64d46U,
+	0x8d5491b5U, 0x5dc47105U, 0xd406046fU, 0x155060ffU,
+	0xfb981924U, 0xe9bdd697U, 0x434089ccU, 0x9ed96777U,
+	0x42e8b0bdU, 0x8b890788U, 0x5b19e738U, 0xeec879dbU,
+	0x0a7ca147U, 0x0f427ce9U, 0x1e84f8c9U, 0x00000000U,
+	0x86800983U, 0xed2b3248U, 0x70111eacU, 0x725a6c4eU,
+	0xff0efdfbU, 0x38850f56U, 0xd5ae3d1eU, 0x392d3627U,
+	0xd90f0a64U, 0xa65c6821U, 0x545b9bd1U, 0x2e36243aU,
+	0x670a0cb1U, 0xe757930fU, 0x96eeb4d2U, 0x919b1b9eU,
+	0xc5c0804fU, 0x20dc61a2U, 0x4b775a69U, 0x1a121c16U,
+	0xba93e20aU, 0x2aa0c0e5U, 0xe0223c43U, 0x171b121dU,
+	0x0d090e0bU, 0xc78bf2adU, 0xa8b62db9U, 0xa91e14c8U,
+	0x19f15785U, 0x0775af4cU, 0xdd99eebbU, 0x607fa3fdU,
+	0x2601f79fU, 0xf5725cbcU, 0x3b6644c5U, 0x7efb5b34U,
+	0x29438b76U, 0xc623cbdcU, 0xfcedb668U, 0xf1e4b863U,
+	0xdc31d7caU, 0x85634210U, 0x22971340U, 0x11c68420U,
+	0x244a857dU, 0x3dbbd2f8U, 0x32f9ae11U, 0xa129c76dU,
+	0x2f9e1d4bU, 0x30b2dcf3U, 0x52860decU, 0xe3c177d0U,
+	0x16b32b6cU, 0xb970a999U, 0x489411faU, 0x64e94722U,
+	0x8cfca8c4U, 0x3ff0a01aU, 0x2c7d56d8U, 0x903322efU,
+	0x4e4987c7U, 0xd138d9c1U, 0xa2ca8cfeU, 0x0bd49836U,
+	0x81f5a6cfU, 0xde7aa528U, 0x8eb7da26U, 0xbfad3fa4U,
+	0x9d3a2ce4U, 0x9278500dU, 0xcc5f6a9bU, 0x467e5462U,
+	0x138df6c2U, 0xb8d890e8U, 0xf7392e5eU, 0xafc382f5U,
+	0x805d9fbeU, 0x93d0697cU, 0x2dd56fa9U, 0x1225cfb3U,
+	0x99acc83bU, 0x7d1810a7U, 0x639ce86eU, 0xbb3bdb7bU,
+	0x7826cd09U, 0x18596ef4U, 0xb79aec01U, 0x9a4f83a8U,
+	0x6e95e665U, 0xe6ffaa7eU, 0xcfbc2108U, 0xe815efe6U,
+	0x9be7bad9U, 0x366f4aceU, 0x099fead4U, 0x7cb029d6U,
+	0xb2a431afU, 0x233f2a31U, 0x94a5c630U, 0x66a235c0U,
+	0xbc4e7437U, 0xca82fca6U, 0xd090e0b0U, 0xd8a73315U,
+	0x9804f14aU, 0xdaec41f7U, 0x50cd7f0eU, 0xf691172fU,
+	0xd64d768dU, 0xb0ef434dU, 0x4daacc54U, 0x0496e4dfU,
+	0xb5d19ee3U, 0x886a4c1bU, 0x1f2cc1b8U, 0x5165467fU,
+	0xea5e9d04U, 0x358c015dU, 0x7487fa73U, 0x410bfb2eU,
+	0x1d67b35aU, 0xd2db9252U, 0x5610e933U, 0x47d66d13U,
+	0x61d79a8cU, 0x0ca1377aU, 0x14f8598eU, 0x3c13eb89U,
+	0x27a9ceeeU, 0xc961b735U, 0xe51ce1edU, 0xb1477a3cU,
+	0xdfd29c59U, 0x73f2553fU, 0xce141879U, 0x37c773bfU,
+	0xcdf753eaU, 0xaafd5f5bU, 0x6f3ddf14U, 0xdb447886U,
+	0xf3afca81U, 0xc468b93eU, 0x3424382cU, 0x40a3c25fU,
+	0xc31d1672U, 0x25e2bc0cU, 0x493c288bU, 0x950dff41U,
+	0x01a83971U, 0xb30c08deU, 0xe4b4d89cU, 0xc1566490U,
+	0x84cb7b61U, 0xb632d570U, 0x5c6c4874U, 0x57b8d042U,
+	0xf45150a7U, 0x417e5365U, 0x171ac3a4U, 0x273a965eU,
+	0xab3bcb6bU, 0x9d1ff145U, 0xfaacab58U, 0xe34b9303U,
+	0x302055faU, 0x76adf66dU, 0xcc889176U, 0x02f5254cU,
+	0xe54ffcd7U, 0x2ac5d7cbU, 0x35268044U, 0x62b58fa3U,
+	0xb1de495aU, 0xba25671bU, 0xea45980eU, 0xfe5de1c0U,
+	0x2fc30275U, 0x4c8112f0U, 0x468da397U, 0xd36bc6f9U,
+	0x8f03e75fU, 0x9215959cU, 0x6dbfeb7aU, 0x5295da59U,
+	0xbed42d83U, 0x7458d321U, 0xe0492969U, 0xc98e44c8U,
+	0xc2756a89U, 0x8ef47879U, 0x58996b3eU, 0xb927dd71U,
+	0xe1beb64fU, 0x88f017adU, 0x20c966acU, 0xce7db43aU,
+	0xdf63184aU, 0x1ae58231U, 0x51976033U, 0x5362457fU,
+	0x64b1e077U, 0x6bbb84aeU, 0x81fe1ca0U, 0x08f9942bU,
+	0x48705868U, 0x458f19fdU, 0xde94876cU, 0x7b52b7f8U,
+	0x73ab23d3U, 0x4b72e202U, 0x1fe3578fU, 0x55662aabU,
+	0xebb20728U, 0xb52f03c2U, 0xc5869a7bU, 0x37d3a508U,
+	0x2830f287U, 0xbf23b2a5U, 0x0302ba6aU, 0x16ed5c82U,
+	0xcf8a2b1cU, 0x79a792b4U, 0x07f3f0f2U, 0x694ea1e2U,
+	0xda65cdf4U, 0x0506d5beU, 0x34d11f62U, 0xa6c48afeU,
+	0x2e349d53U, 0xf3a2a055U, 0x8a0532e1U, 0xf6a475ebU,
+	0x830b39ecU, 0x6040aaefU, 0x715e069fU, 0x6ebd5110U,
+	0x213ef98aU, 0xdd963d06U, 0x3eddae05U, 0xe64d46bdU,
+	0x5491b58dU, 0xc471055dU, 0x06046fd4U, 0x5060ff15U,
+	0x981924fbU, 0xbdd697e9U, 0x4089cc43U, 0xd967779eU,
+	0xe8b0bd42U, 0x8907888bU, 0x19e7385bU, 0xc879dbeeU,
+	0x7ca1470aU, 0x427ce90fU, 0x84f8c91eU, 0x00000000U,
+	0x80098386U, 0x2b3248edU, 0x111eac70U, 0x5a6c4e72U,
+	0x0efdfbffU, 0x850f5638U, 0xae3d1ed5U, 0x2d362739U,
+	0x0f0a64d9U, 0x5c6821a6U, 0x5b9bd154U, 0x36243a2eU,
+	0x0a0cb167U, 0x57930fe7U, 0xeeb4d296U, 0x9b1b9e91U,
+	0xc0804fc5U, 0xdc61a220U, 0x775a694bU, 0x121c161aU,
+	0x93e20abaU, 0xa0c0e52aU, 0x223c43e0U, 0x1b121d17U,
+	0x090e0b0dU, 0x8bf2adc7U, 0xb62db9a8U, 0x1e14c8a9U,
+	0xf1578519U, 0x75af4c07U, 0x99eebbddU, 0x7fa3fd60U,
+	0x01f79f26U, 0x725cbcf5U, 0x6644c53bU, 0xfb5b347eU,
+	0x438b7629U, 0x23cbdcc6U, 0xedb668fcU, 0xe4b863f1U,
+	0x31d7cadcU, 0x63421085U, 0x97134022U, 0xc6842011U,
+	0x4a857d24U, 0xbbd2f83dU, 0xf9ae1132U, 0x29c76da1U,
+	0x9e1d4b2fU, 0xb2dcf330U, 0x860dec52U, 0xc177d0e3U,
+	0xb32b6c16U, 0x70a999b9U, 0x9411fa48U, 0xe9472264U,
+	0xfca8c48cU, 0xf0a01a3fU, 0x7d56d82cU, 0x3322ef90U,
+	0x4987c74eU, 0x38d9c1d1U, 0xca8cfea2U, 0xd498360bU,
+	0xf5a6cf81U, 0x7aa528deU, 0xb7da268eU, 0xad3fa4bfU,
+	0x3a2ce49dU, 0x78500d92U, 0x5f6a9bccU, 0x7e546246U,
+	0x8df6c213U, 0xd890e8b8U, 0x392e5ef7U, 0xc382f5afU,
+	0x5d9fbe80U, 0xd0697c93U, 0xd56fa92dU, 0x25cfb312U,
+	0xacc83b99U, 0x1810a77dU, 0x9ce86e63U, 0x3bdb7bbbU,
+	0x26cd0978U, 0x596ef418U, 0x9aec01b7U, 0x4f83a89aU,
+	0x95e6656eU, 0xffaa7ee6U, 0xbc2108cfU, 0x15efe6e8U,
+	0xe7bad99bU, 0x6f4ace36U, 0x9fead409U, 0xb029d67cU,
+	0xa431afb2U, 0x3f2a3123U, 0xa5c63094U, 0xa235c066U,
+	0x4e7437bcU, 0x82fca6caU, 0x90e0b0d0U, 0xa73315d8U,
+	0x04f14a98U, 0xec41f7daU, 0xcd7f0e50U, 0x91172ff6U,
+	0x4d768dd6U, 0xef434db0U, 0xaacc544dU, 0x96e4df04U,
+	0xd19ee3b5U, 0x6a4c1b88U, 0x2cc1b81fU, 0x65467f51U,
+	0x5e9d04eaU, 0x8c015d35U, 0x87fa7374U, 0x0bfb2e41U,
+	0x67b35a1dU, 0xdb9252d2U, 0x10e93356U, 0xd66d1347U,
+	0xd79a8c61U, 0xa1377a0cU, 0xf8598e14U, 0x13eb893cU,
+	0xa9ceee27U, 0x61b735c9U, 0x1ce1ede5U, 0x477a3cb1U,
+	0xd29c59dfU, 0xf2553f73U, 0x141879ceU, 0xc773bf37U,
+	0xf753eacdU, 0xfd5f5baaU, 0x3ddf146fU, 0x447886dbU,
+	0xafca81f3U, 0x68b93ec4U, 0x24382c34U, 0xa3c25f40U,
+	0x1d1672c3U, 0xe2bc0c25U, 0x3c288b49U, 0x0dff4195U,
+	0xa8397101U, 0x0c08deb3U, 0xb4d89ce4U, 0x566490c1U,
+	0xcb7b6184U, 0x32d570b6U, 0x6c48745cU, 0xb8d04257U,
+	0x5150a7f4U, 0x7e536541U, 0x1ac3a417U, 0x3a965e27U,
+	0x3bcb6babU, 0x1ff1459dU, 0xacab58faU, 0x4b9303e3U,
+	0x2055fa30U, 0xadf66d76U, 0x889176ccU, 0xf5254c02U,
+	0x4ffcd7e5U, 0xc5d7cb2aU, 0x26804435U, 0xb58fa362U,
+	0xde495ab1U, 0x25671bbaU, 0x45980eeaU, 0x5de1c0feU,
+	0xc302752fU, 0x8112f04cU, 0x8da39746U, 0x6bc6f9d3U,
+	0x03e75f8fU, 0x15959c92U, 0xbfeb7a6dU, 0x95da5952U,
+	0xd42d83beU, 0x58d32174U, 0x492969e0U, 0x8e44c8c9U,
+	0x756a89c2U, 0xf478798eU, 0x996b3e58U, 0x27dd71b9U,
+	0xbeb64fe1U, 0xf017ad88U, 0xc966ac20U, 0x7db43aceU,
+	0x63184adfU, 0xe582311aU, 0x97603351U, 0x62457f53U,
+	0xb1e07764U, 0xbb84ae6bU, 0xfe1ca081U, 0xf9942b08U,
+	0x70586848U, 0x8f19fd45U, 0x94876cdeU, 0x52b7f87bU,
+	0xab23d373U, 0x72e2024bU, 0xe3578f1fU, 0x662aab55U,
+	0xb20728ebU, 0x2f03c2b5U, 0x869a7bc5U, 0xd3a50837U,
+	0x30f28728U, 0x23b2a5bfU, 0x02ba6a03U, 0xed5c8216U,
+	0x8a2b1ccfU, 0xa792b479U, 0xf3f0f207U, 0x4ea1e269U,
+	0x65cdf4daU, 0x06d5be05U, 0xd11f6234U, 0xc48afea6U,
+	0x349d532eU, 0xa2a055f3U, 0x0532e18aU, 0xa475ebf6U,
+	0x0b39ec83U, 0x40aaef60U, 0x5e069f71U, 0xbd51106eU,
+	0x3ef98a21U, 0x963d06ddU, 0xddae053eU, 0x4d46bde6U,
+	0x91b58d54U, 0x71055dc4U, 0x046fd406U, 0x60ff1550U,
+	0x1924fb98U, 0xd697e9bdU, 0x89cc4340U, 0x67779ed9U,
+	0xb0bd42e8U, 0x07888b89U, 0xe7385b19U, 0x79dbeec8U,
+	0xa1470a7cU, 0x7ce90f42U, 0xf8c91e84U, 0x00000000U,
+	0x09838680U, 0x3248ed2bU, 0x1eac7011U, 0x6c4e725aU,
+	0xfdfbff0eU, 0x0f563885U, 0x3d1ed5aeU, 0x3627392dU,
+	0x0a64d90fU, 0x6821a65cU, 0x9bd1545bU, 0x243a2e36U,
+	0x0cb1670aU, 0x930fe757U, 0xb4d296eeU, 0x1b9e919bU,
+	0x804fc5c0U, 0x61a220dcU, 0x5a694b77U, 0x1c161a12U,
+	0xe20aba93U, 0xc0e52aa0U, 0x3c43e022U, 0x121d171bU,
+	0x0e0b0d09U, 0xf2adc78bU, 0x2db9a8b6U, 0x14c8a91eU,
+	0x578519f1U, 0xaf4c0775U, 0xeebbdd99U, 0xa3fd607fU,
+	0xf79f2601U, 0x5cbcf572U, 0x44c53b66U, 0x5b347efbU,
+	0x8b762943U, 0xcbdcc623U, 0xb668fcedU, 0xb863f1e4U,
+	0xd7cadc31U, 0x42108563U, 0x13402297U, 0x842011c6U,
+	0x857d244aU, 0xd2f83dbbU, 0xae1132f9U, 0xc76da129U,
+	0x1d4b2f9eU, 0xdcf330b2U, 0x0dec5286U, 0x77d0e3c1U,
+	0x2b6c16b3U, 0xa999b970U, 0x11fa4894U, 0x472264e9U,
+	0xa8c48cfcU, 0xa01a3ff0U, 0x56d82c7dU, 0x22ef9033U,
+	0x87c74e49U, 0xd9c1d138U, 0x8cfea2caU, 0x98360bd4U,
+	0xa6cf81f5U, 0xa528de7aU, 0xda268eb7U, 0x3fa4bfadU,
+	0x2ce49d3aU, 0x500d9278U, 0x6a9bcc5fU, 0x5462467eU,
+	0xf6c2138dU, 0x90e8b8d8U, 0x2e5ef739U, 0x82f5afc3U,
+	0x9fbe805dU, 0x697c93d0U, 0x6fa92dd5U, 0xcfb31225U,
+	0xc83b99acU, 0x10a77d18U, 0xe86e639cU, 0xdb7bbb3bU,
+	0xcd097826U, 0x6ef41859U, 0xec01b79aU, 0x83a89a4fU,
+	0xe6656e95U, 0xaa7ee6ffU, 0x2108cfbcU, 0xefe6e815U,
+	0xbad99be7U, 0x4ace366fU, 0xead4099fU, 0x29d67cb0U,
+	0x31afb2a4U, 0x2a31233fU, 0xc63094a5U, 0x35c066a2U,
+	0x7437bc4eU, 0xfca6ca82U, 0xe0b0d090U, 0x3315d8a7U,
+	0xf14a9804U, 0x41f7daecU, 0x7f0e50cdU, 0x172ff691U,
+	0x768dd64dU, 0x434db0efU, 0xcc544daaU, 0xe4df0496U,
+	0x9ee3b5d1U, 0x4c1b886aU, 0xc1b81f2cU, 0x467f5165U,
+	0x9d04ea5eU, 0x015d358cU, 0xfa737487U, 0xfb2e410bU,
+	0xb35a1d67U, 0x9252d2dbU, 0xe9335610U, 0x6d1347d6U,
+	0x9a8c61d7U, 0x377a0ca1U, 0x598e14f8U, 0xeb893c13U,
+	0xceee27a9U, 0xb735c961U, 0xe1ede51cU, 0x7a3cb147U,
+	0x9c59dfd2U, 0x553f73f2U, 0x1879ce14U, 0x73bf37c7U,
+	0x53eacdf7U, 0x5f5baafdU, 0xdf146f3dU, 0x7886db44U,
+	0xca81f3afU, 0xb93ec468U, 0x382c3424U, 0xc25f40a3U,
+	0x1672c31dU, 0xbc0c25e2U, 0x288b493cU, 0xff41950dU,
+	0x397101a8U, 0x08deb30cU, 0xd89ce4b4U, 0x6490c156U,
+	0x7b6184cbU, 0xd570b632U, 0x48745c6cU, 0xd04257b8U,
+};
+
+__constant static const uint AES_KEY_FILL[16] = {
+	0x6daca553, 0x62716609, 0xdbb5552b, 0xb4f44917,
+	0x6d7caf07, 0x846a710d, 0x1725d378, 0x0da1dc4e,
+	0x3f1262f1, 0x9f947ec6, 0xf4c0794f, 0x3e20e345,
+	0x6aef8135, 0xb1ba317c, 0x16314c88, 0x49169154,
+};
+
+__constant static const uint AES_STATE_HASH[16] = {
+	0x92b52c0d, 0x9fa856de, 0xcc82db47, 0xd7983aad,
+	0x338d996e, 0x15c7b798, 0xf59e125a, 0xace78057,
+	0x6a770017, 0xae62c7d0, 0x5079506b, 0xe8a07ce4,
+	0x630a240c, 0x07ad828d, 0x79a10005, 0x7e994948,
+};
+
+uint get_byte32(uint a, uint start_bit) { return (a >> start_bit) & 0xFF; }
+
+#define fillAes_name fillAes1Rx4_scratchpad
+#define outputSize RANDOMX_SCRATCHPAD_L3
+#define outputSize0 (outputSize + 64)
+#define unroll_factor 8
+#define num_rounds 1
+	#include "fillAes1Rx4.cl"
+#undef num_rounds
+#undef unroll_factor
+#undef outputSize
+#undef outputSize0
+#undef fillAes_name
+
+#define fillAes_name fillAes4Rx4_entropy
+#define outputSize ENTROPY_SIZE
+#define outputSize0 outputSize
+#define unroll_factor 2
+#define num_rounds 4
+	#include "fillAes1Rx4.cl"
+#undef num_rounds
+#undef unroll_factor
+#undef outputSize
+#undef outputSize0
+#undef fillAes_name
+
+#define inputSize RANDOMX_SCRATCHPAD_L3
+
+__attribute__((reqd_work_group_size(64, 1, 1)))
+__kernel void hashAes1Rx4(__global const void* input, __global void* hash, uint hashOffsetBytes, uint hashStrideBytes, uint batch_size)
+{
+	__local uint T[2048];
+
+	const uint global_index = get_global_id(0);
+	if (global_index >= batch_size * 4)
+		return;
+
+	const uint idx = global_index / 4;
+	const uint sub = global_index % 4;
+
+	for (uint i = get_local_id(0), step = get_local_size(0); i < 2048; i += step)
+		T[i] = AES_TABLE[i];
+
+	barrier(CLK_LOCAL_MEM_FENCE);
+
+	uint x[4] = { AES_STATE_HASH[sub * 4], AES_STATE_HASH[sub * 4 + 1], AES_STATE_HASH[sub * 4 + 2], AES_STATE_HASH[sub * 4 + 3] };
+
+	const uint s1 = ((sub & 1) == 0) ? 8 : 24;
+	const uint s3 = ((sub & 1) == 0) ? 24 : 8;
+
+	__global const uint4* p = ((__global uint4*) input) + idx * ((inputSize + 64) / sizeof(uint4)) + sub;
+
+	__local const uint* const t0 = ((sub & 1) == 0) ? T : (T + 1024);
+	__local const uint* const t1 = ((sub & 1) == 0) ? (T + 256) : (T + 1792);
+	__local const uint* const t2 = ((sub & 1) == 0) ? (T + 512) : (T + 1536);
+	__local const uint* const t3 = ((sub & 1) == 0) ? (T + 768) : (T + 1280);
+
+	#pragma unroll(8)
+	for (uint i = 0; i < inputSize / sizeof(uint4); i += 4, p += 4)
+	{
+		uint k[4], y[4];
+		*(uint4*)(k) = *p;
+		y[0] = t0[get_byte32(x[0], 0)] ^ t1[get_byte32(x[1], s1)] ^ t2[get_byte32(x[2], 16)] ^ t3[get_byte32(x[3], s3)] ^ k[0];
+		y[1] = t0[get_byte32(x[1], 0)] ^ t1[get_byte32(x[2], s1)] ^ t2[get_byte32(x[3], 16)] ^ t3[get_byte32(x[0], s3)] ^ k[1];
+		y[2] = t0[get_byte32(x[2], 0)] ^ t1[get_byte32(x[3], s1)] ^ t2[get_byte32(x[0], 16)] ^ t3[get_byte32(x[1], s3)] ^ k[2];
+		y[3] = t0[get_byte32(x[3], 0)] ^ t1[get_byte32(x[0], s1)] ^ t2[get_byte32(x[1], 16)] ^ t3[get_byte32(x[2], s3)] ^ k[3];
+		x[0] = y[0];
+		x[1] = y[1];
+		x[2] = y[2];
+		x[3] = y[3];
+	}
+
+	uint y[4];
+
+	y[0] = t0[get_byte32(x[0], 0)] ^ t1[get_byte32(x[1], s1)] ^ t2[get_byte32(x[2], 16)] ^ t3[get_byte32(x[3], s3)] ^ 0xf6fa8389;
+	y[1] = t0[get_byte32(x[1], 0)] ^ t1[get_byte32(x[2], s1)] ^ t2[get_byte32(x[3], 16)] ^ t3[get_byte32(x[0], s3)] ^ 0x8b24949f;
+	y[2] = t0[get_byte32(x[2], 0)] ^ t1[get_byte32(x[3], s1)] ^ t2[get_byte32(x[0], 16)] ^ t3[get_byte32(x[1], s3)] ^ 0x90dc56bf;
+	y[3] = t0[get_byte32(x[3], 0)] ^ t1[get_byte32(x[0], s1)] ^ t2[get_byte32(x[1], 16)] ^ t3[get_byte32(x[2], s3)] ^ 0x06890201;
+
+	x[0] = t0[get_byte32(y[0], 0)] ^ t1[get_byte32(y[1], s1)] ^ t2[get_byte32(y[2], 16)] ^ t3[get_byte32(y[3], s3)] ^ 0x61b263d1;
+	x[1] = t0[get_byte32(y[1], 0)] ^ t1[get_byte32(y[2], s1)] ^ t2[get_byte32(y[3], 16)] ^ t3[get_byte32(y[0], s3)] ^ 0x51f4e03c;
+	x[2] = t0[get_byte32(y[2], 0)] ^ t1[get_byte32(y[3], s1)] ^ t2[get_byte32(y[0], 16)] ^ t3[get_byte32(y[1], s3)] ^ 0xee1043c6;
+	x[3] = t0[get_byte32(y[3], 0)] ^ t1[get_byte32(y[0], s1)] ^ t2[get_byte32(y[1], 16)] ^ t3[get_byte32(y[2], s3)] ^ 0xed18f99b;
+
+	*((__global uint4*)(hash) + idx * (hashStrideBytes / sizeof(uint4)) + sub + (hashOffsetBytes / sizeof(uint4))) = *(uint4*)(x);
+}

src/backend/opencl/cl/rx/blake2b.cl

@@ -0,0 +1,157 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+__constant static const uchar blake2b_sigma[12 * 16] = {
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+	11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+	7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+	9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+	2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+	12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+	13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+	6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+	10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+};
+
+enum Blake2b_IV
+{
+	iv0 = 0x6a09e667f3bcc908ul,
+	iv1 = 0xbb67ae8584caa73bul,
+	iv2 = 0x3c6ef372fe94f82bul,
+	iv3 = 0xa54ff53a5f1d36f1ul,
+	iv4 = 0x510e527fade682d1ul,
+	iv5 = 0x9b05688c2b3e6c1ful,
+	iv6 = 0x1f83d9abfb41bd6bul,
+	iv7 = 0x5be0cd19137e2179ul,
+};
+
+ulong rotr64(ulong a, ulong shift) { return rotate(a, 64 - shift); }
+
+#define G(r, i, a, b, c, d)                                                    \
+	do {                                                                       \
+		a = a + b + m[blake2b_sigma[r * 16 + 2 * i + 0]];                      \
+		d = rotr64(d ^ a, 32);                                                 \
+		c = c + d;                                                             \
+		b = rotr64(b ^ c, 24);                                                 \
+		a = a + b + m[blake2b_sigma[r * 16 + 2 * i + 1]];                      \
+		d = rotr64(d ^ a, 16);                                                 \
+		c = c + d;                                                             \
+		b = rotr64(b ^ c, 63);                                                 \
+	} while (0)
+
+#define ROUND(r)                                                               \
+	do {                                                                       \
+		G(r, 0, v[0], v[4], v[8], v[12]);                                      \
+		G(r, 1, v[1], v[5], v[9], v[13]);                                      \
+		G(r, 2, v[2], v[6], v[10], v[14]);                                     \
+		G(r, 3, v[3], v[7], v[11], v[15]);                                     \
+		G(r, 4, v[0], v[5], v[10], v[15]);                                     \
+		G(r, 5, v[1], v[6], v[11], v[12]);                                     \
+		G(r, 6, v[2], v[7], v[8], v[13]);                                      \
+		G(r, 7, v[3], v[4], v[9], v[14]);                                      \
+	} while (0)
+
+#define BLAKE2B_ROUNDS() ROUND(0);ROUND(1);ROUND(2);ROUND(3);ROUND(4);ROUND(5);ROUND(6);ROUND(7);ROUND(8);ROUND(9);ROUND(10);ROUND(11);
+
+void blake2b_512_process_single_block(ulong *h, const ulong* m, uint blockTemplateSize)
+{
+	ulong v[16] =
+	{
+		iv0 ^ 0x01010040, iv1, iv2, iv3, iv4                    , iv5,  iv6, iv7,
+		iv0             , iv1, iv2, iv3, iv4 ^ blockTemplateSize, iv5, ~iv6, iv7,
+	};
+
+	BLAKE2B_ROUNDS();
+
+	h[0] = v[0] ^ v[ 8] ^ iv0 ^ 0x01010040;
+	h[1] = v[1] ^ v[ 9] ^ iv1;
+	h[2] = v[2] ^ v[10] ^ iv2;
+	h[3] = v[3] ^ v[11] ^ iv3;
+	h[4] = v[4] ^ v[12] ^ iv4;
+	h[5] = v[5] ^ v[13] ^ iv5;
+	h[6] = v[6] ^ v[14] ^ iv6;
+	h[7] = v[7] ^ v[15] ^ iv7;
+}
+
+__attribute__((reqd_work_group_size(64, 1, 1)))
+__kernel void blake2b_initial_hash(__global void *out, __global const void* blockTemplate, uint blockTemplateSize, uint start_nonce)
+{
+	const uint global_index = get_global_id(0);
+
+	__global const ulong* p = (__global const ulong*) blockTemplate;
+	ulong m[16] = {
+		(blockTemplateSize >   0) ? p[ 0] : 0,
+		(blockTemplateSize >   8) ? p[ 1] : 0,
+		(blockTemplateSize >  16) ? p[ 2] : 0,
+		(blockTemplateSize >  24) ? p[ 3] : 0,
+		(blockTemplateSize >  32) ? p[ 4] : 0,
+		(blockTemplateSize >  40) ? p[ 5] : 0,
+		(blockTemplateSize >  48) ? p[ 6] : 0,
+		(blockTemplateSize >  56) ? p[ 7] : 0,
+		(blockTemplateSize >  64) ? p[ 8] : 0,
+		(blockTemplateSize >  72) ? p[ 9] : 0,
+		(blockTemplateSize >  80) ? p[10] : 0,
+		(blockTemplateSize >  88) ? p[11] : 0,
+		(blockTemplateSize >  96) ? p[12] : 0,
+		(blockTemplateSize > 104) ? p[13] : 0,
+		(blockTemplateSize > 112) ? p[14] : 0,
+		(blockTemplateSize > 120) ? p[15] : 0,
+	};
+
+	if (blockTemplateSize % sizeof(ulong))
+		m[blockTemplateSize / sizeof(ulong)] &= (ulong)(-1) >> (64 - (blockTemplateSize % sizeof(ulong)) * 8);
+
+	const ulong nonce = start_nonce + global_index;
+	m[4] = (m[4] & ((ulong)(-1) >>  8)) | (nonce << 56);
+	m[5] = (m[5] & ((ulong)(-1) << 24)) | (nonce >>  8);
+
+	ulong hash[8];
+	blake2b_512_process_single_block(hash, m, blockTemplateSize);
+
+	__global ulong* t = ((__global ulong*) out) + global_index * 8;
+	t[0] = hash[0];
+	t[1] = hash[1];
+	t[2] = hash[2];
+	t[3] = hash[3];
+	t[4] = hash[4];
+	t[5] = hash[5];
+	t[6] = hash[6];
+	t[7] = hash[7];
+}
+
+#define in_len 256
+
+#define out_len 32
+#define blake2b_512_process_double_block_name blake2b_512_process_double_block_32
+#define blake2b_hash_registers_name blake2b_hash_registers_32
+	#include "blake2b_double_block.cl"
+#undef blake2b_hash_registers_name
+#undef blake2b_512_process_double_block_name
+#undef out_len
+
+#define out_len 64
+#define blake2b_512_process_double_block_name blake2b_512_process_double_block_64
+#define blake2b_hash_registers_name blake2b_hash_registers_64
+	#include "blake2b_double_block.cl"
+#undef blake2b_hash_registers_name
+#undef blake2b_512_process_double_block_name
+#undef out_len

src/backend/opencl/cl/rx/blake2b_double_block.cl

@@ -0,0 +1,100 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+void blake2b_512_process_double_block_name(ulong *out, ulong* m, __global const ulong* in)
+{
+	ulong v[16] =
+	{
+		iv0 ^ (0x01010000u | out_len), iv1, iv2, iv3, iv4      , iv5, iv6, iv7,
+		iv0               , iv1, iv2, iv3, iv4 ^ 128, iv5, iv6, iv7,
+	};
+
+	BLAKE2B_ROUNDS();
+
+	ulong h[8];
+	v[0] = h[0] = v[0] ^ v[8] ^ iv0 ^ (0x01010000u | out_len);
+	v[1] = h[1] = v[1] ^ v[9] ^ iv1;
+	v[2] = h[2] = v[2] ^ v[10] ^ iv2;
+	v[3] = h[3] = v[3] ^ v[11] ^ iv3;
+	v[4] = h[4] = v[4] ^ v[12] ^ iv4;
+	v[5] = h[5] = v[5] ^ v[13] ^ iv5;
+	v[6] = h[6] = v[6] ^ v[14] ^ iv6;
+	v[7] = h[7] = v[7] ^ v[15] ^ iv7;
+	v[8] = iv0;
+	v[9] = iv1;
+	v[10] = iv2;
+	v[11] = iv3;
+	v[12] = iv4 ^ in_len;
+	v[13] = iv5;
+	v[14] = ~iv6;
+	v[15] = iv7;
+
+	m[ 0] = (in_len > 128) ? in[16] : 0;
+	m[ 1] = (in_len > 136) ? in[17] : 0;
+	m[ 2] = (in_len > 144) ? in[18] : 0;
+	m[ 3] = (in_len > 152) ? in[19] : 0;
+	m[ 4] = (in_len > 160) ? in[20] : 0;
+	m[ 5] = (in_len > 168) ? in[21] : 0;
+	m[ 6] = (in_len > 176) ? in[22] : 0;
+	m[ 7] = (in_len > 184) ? in[23] : 0;
+	m[ 8] = (in_len > 192) ? in[24] : 0;
+	m[ 9] = (in_len > 200) ? in[25] : 0;
+	m[10] = (in_len > 208) ? in[26] : 0;
+	m[11] = (in_len > 216) ? in[27] : 0;
+	m[12] = (in_len > 224) ? in[28] : 0;
+	m[13] = (in_len > 232) ? in[29] : 0;
+	m[14] = (in_len > 240) ? in[30] : 0;
+	m[15] = (in_len > 248) ? in[31] : 0;
+
+	if (in_len % sizeof(ulong))
+		m[(in_len - 128) / sizeof(ulong)] &= (ulong)(-1) >> (64 - (in_len % sizeof(ulong)) * 8);
+
+	BLAKE2B_ROUNDS();
+
+	if (out_len >  0) out[0] = h[0] ^ v[0] ^ v[8];
+	if (out_len >  8) out[1] = h[1] ^ v[1] ^ v[9];
+	if (out_len > 16) out[2] = h[2] ^ v[2] ^ v[10];
+	if (out_len > 24) out[3] = h[3] ^ v[3] ^ v[11];
+	if (out_len > 32) out[4] = h[4] ^ v[4] ^ v[12];
+	if (out_len > 40) out[5] = h[5] ^ v[5] ^ v[13];
+	if (out_len > 48) out[6] = h[6] ^ v[6] ^ v[14];
+	if (out_len > 56) out[7] = h[7] ^ v[7] ^ v[15];
+}
+
+__attribute__((reqd_work_group_size(64, 1, 1)))
+__kernel void blake2b_hash_registers_name(__global void *out, __global const void* in, uint inStrideBytes)
+{
+	const uint global_index = get_global_id(0);
+	__global const ulong* p = ((__global const ulong*) in) + global_index * (inStrideBytes / sizeof(ulong));
+	__global ulong* h = ((__global ulong*) out) + global_index * (out_len / sizeof(ulong));
+
+	ulong m[16] = { p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[10], p[11], p[12], p[13], p[14], p[15] };
+
+	ulong hash[8];
+	blake2b_512_process_double_block_name(hash, m, p);
+
+	if (out_len >  0) h[0] = hash[0];
+	if (out_len >  8) h[1] = hash[1];
+	if (out_len > 16) h[2] = hash[2];
+	if (out_len > 24) h[3] = hash[3];
+	if (out_len > 32) h[4] = hash[4];
+	if (out_len > 40) h[5] = hash[5];
+	if (out_len > 48) h[6] = hash[6];
+	if (out_len > 56) h[7] = hash[7];
+}

src/backend/opencl/cl/rx/fillAes1Rx4.cl

@@ -0,0 +1,118 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+__attribute__((reqd_work_group_size(64, 1, 1)))
+__kernel void fillAes_name(__global void* state, __global void* out, uint batch_size, uint rx_version)
+{
+	__local uint T[2048];
+
+	const uint global_index = get_global_id(0);
+	if (global_index >= batch_size * 4)
+		return;
+
+	const uint idx = global_index / 4;
+	const uint sub = global_index % 4;
+
+	for (uint i = get_local_id(0), step = get_local_size(0); i < 2048; i += step)
+		T[i] = AES_TABLE[i];
+
+	barrier(CLK_LOCAL_MEM_FENCE);
+
+#if num_rounds != 4
+	const uint k[4] = { AES_KEY_FILL[sub * 4], AES_KEY_FILL[sub * 4 + 1], AES_KEY_FILL[sub * 4 + 2], AES_KEY_FILL[sub * 4 + 3] };
+#else
+	const bool b1 = (rx_version < 104);
+	const bool b2 = (sub < 2);
+
+	uint k[16];
+	k[ 0] = b1 ? 0xf890465du : (b2 ? 0x6421aaddu : 0xb5826f73u);
+	k[ 1] = b1 ? 0x7ffbe4a6u : (b2 ? 0xd1833ddbu : 0xe3d6a7a6u);
+	k[ 2] = b1 ? 0x141f82b7u : (b2 ? 0x2f546d2bu : 0x3d518b6du);
+	k[ 3] = b1 ? 0xcf359e95u : (b2 ? 0x99e5d23fu : 0x229effb4u);
+	k[ 4] = b1 ? 0x6a55c450u : (b2 ? 0xb20e3450u : 0xc7566bf3u);
+	k[ 5] = b1 ? 0xfee8278au : (b2 ? 0xb6913f55u : 0x9c10b3d9u);
+	k[ 6] = b1 ? 0xbd5c5ac3u : (b2 ? 0x06f79d53u : 0xe9024d4eu);
+	k[ 7] = b1 ? 0x6741ffdcu : (b2 ? 0xa5dfcde5u : 0xb272b7d2u);
+	k[ 8] = b1 ? 0x114c47a4u : (b2 ? 0x5c3ed904u : 0xf273c9e7u);
+	k[ 9] = b1 ? 0xd524fde4u : (b2 ? 0x515e7bafu : 0xf765a38bu);
+	k[10] = b1 ? 0xa7279ad2u : (b2 ? 0x0aa4679fu : 0x2ba9660au);
+	k[11] = b1 ? 0x3d324aacu : (b2 ? 0x171c02bfu : 0xf63befa7u);
+	k[12] = b1 ? 0x810c3a2au : (b2 ? 0x85623763u : 0x7a7cd609u);
+	k[13] = b1 ? 0x99a9aeffu : (b2 ? 0xe78f5d08u : 0x915839deu);
+	k[14] = b1 ? 0x42d3dbd9u : (b2 ? 0xcd673785u : 0x0c06d1fdu);
+	k[15] = b1 ? 0x76f6db08u : (b2 ? 0xd8ded291u : 0xc0b0762du);
+#endif
+
+	__global uint* s = ((__global uint*) state) + idx * (64 / sizeof(uint)) + sub * (16 / sizeof(uint));
+	uint x[4] = { s[0], s[1], s[2], s[3] };
+
+	const uint s1 = (sub & 1) ? 8 : 24;
+	const uint s3 = (sub & 1) ? 24 : 8;
+
+	__global uint4* p = ((__global uint4*) out) + idx * (outputSize0 / sizeof(uint4)) + sub;
+
+	const __local uint* const t0 = (sub & 1) ? T : (T + 1024);
+	const __local uint* const t1 = (sub & 1) ? (T + 256) : (T + 1792);
+	const __local uint* const t2 = (sub & 1) ? (T + 512) : (T + 1536);
+	const __local uint* const t3 = (sub & 1) ? (T + 768) : (T + 1280);
+
+	#pragma unroll(unroll_factor)
+	for (uint i = 0; i < outputSize / sizeof(uint4); i += 4, p += 4)
+	{
+		uint y[4];
+
+#if num_rounds != 4
+		y[0] = t0[get_byte32(x[0], 0)] ^ t1[get_byte32(x[1], s1)] ^ t2[get_byte32(x[2], 16)] ^ t3[get_byte32(x[3], s3)] ^ k[0];
+		y[1] = t0[get_byte32(x[1], 0)] ^ t1[get_byte32(x[2], s1)] ^ t2[get_byte32(x[3], 16)] ^ t3[get_byte32(x[0], s3)] ^ k[1];
+		y[2] = t0[get_byte32(x[2], 0)] ^ t1[get_byte32(x[3], s1)] ^ t2[get_byte32(x[0], 16)] ^ t3[get_byte32(x[1], s3)] ^ k[2];
+		y[3] = t0[get_byte32(x[3], 0)] ^ t1[get_byte32(x[0], s1)] ^ t2[get_byte32(x[1], 16)] ^ t3[get_byte32(x[2], s3)] ^ k[3];
+
+		*p = *(uint4*)(y);
+
+		x[0] = y[0];
+		x[1] = y[1];
+		x[2] = y[2];
+		x[3] = y[3];
+#else
+		y[0] = t0[get_byte32(x[0], 0)] ^ t1[get_byte32(x[1], s1)] ^ t2[get_byte32(x[2], 16)] ^ t3[get_byte32(x[3], s3)] ^ k[ 0];
+		y[1] = t0[get_byte32(x[1], 0)] ^ t1[get_byte32(x[2], s1)] ^ t2[get_byte32(x[3], 16)] ^ t3[get_byte32(x[0], s3)] ^ k[ 1];
+		y[2] = t0[get_byte32(x[2], 0)] ^ t1[get_byte32(x[3], s1)] ^ t2[get_byte32(x[0], 16)] ^ t3[get_byte32(x[1], s3)] ^ k[ 2];
+		y[3] = t0[get_byte32(x[3], 0)] ^ t1[get_byte32(x[0], s1)] ^ t2[get_byte32(x[1], 16)] ^ t3[get_byte32(x[2], s3)] ^ k[ 3];
+
+		x[0] = t0[get_byte32(y[0], 0)] ^ t1[get_byte32(y[1], s1)] ^ t2[get_byte32(y[2], 16)] ^ t3[get_byte32(y[3], s3)] ^ k[ 4];
+		x[1] = t0[get_byte32(y[1], 0)] ^ t1[get_byte32(y[2], s1)] ^ t2[get_byte32(y[3], 16)] ^ t3[get_byte32(y[0], s3)] ^ k[ 5];
+		x[2] = t0[get_byte32(y[2], 0)] ^ t1[get_byte32(y[3], s1)] ^ t2[get_byte32(y[0], 16)] ^ t3[get_byte32(y[1], s3)] ^ k[ 6];
+		x[3] = t0[get_byte32(y[3], 0)] ^ t1[get_byte32(y[0], s1)] ^ t2[get_byte32(y[1], 16)] ^ t3[get_byte32(y[2], s3)] ^ k[ 7];
+
+		y[0] = t0[get_byte32(x[0], 0)] ^ t1[get_byte32(x[1], s1)] ^ t2[get_byte32(x[2], 16)] ^ t3[get_byte32(x[3], s3)] ^ k[ 8];
+		y[1] = t0[get_byte32(x[1], 0)] ^ t1[get_byte32(x[2], s1)] ^ t2[get_byte32(x[3], 16)] ^ t3[get_byte32(x[0], s3)] ^ k[ 9];
+		y[2] = t0[get_byte32(x[2], 0)] ^ t1[get_byte32(x[3], s1)] ^ t2[get_byte32(x[0], 16)] ^ t3[get_byte32(x[1], s3)] ^ k[10];
+		y[3] = t0[get_byte32(x[3], 0)] ^ t1[get_byte32(x[0], s1)] ^ t2[get_byte32(x[1], 16)] ^ t3[get_byte32(x[2], s3)] ^ k[11];
+
+		x[0] = t0[get_byte32(y[0], 0)] ^ t1[get_byte32(y[1], s1)] ^ t2[get_byte32(y[2], 16)] ^ t3[get_byte32(y[3], s3)] ^ k[12];
+		x[1] = t0[get_byte32(y[1], 0)] ^ t1[get_byte32(y[2], s1)] ^ t2[get_byte32(y[3], 16)] ^ t3[get_byte32(y[0], s3)] ^ k[13];
+		x[2] = t0[get_byte32(y[2], 0)] ^ t1[get_byte32(y[3], s1)] ^ t2[get_byte32(y[0], 16)] ^ t3[get_byte32(y[1], s3)] ^ k[14];
+		x[3] = t0[get_byte32(y[3], 0)] ^ t1[get_byte32(y[0], s1)] ^ t2[get_byte32(y[1], 16)] ^ t3[get_byte32(y[2], s3)] ^ k[15];
+
+		*p = *(uint4*)(x);
+#endif
+	}
+
+	*(__global uint4*)(s) = *(uint4*)(x);
+}

src/backend/opencl/cl/rx/randomx.cl

@@ -0,0 +1,14 @@
+#include "../cn/algorithm.cl"
+
+#if (ALGO == ALGO_RX_0)
+#include "randomx_constants_monero.h"
+#elif (ALGO == ALGO_RX_WOW)
+#include "randomx_constants_wow.h"
+#elif (ALGO == ALGO_RX_LOKI)
+#include "randomx_constants_loki.h"
+#endif
+
+#include "aes.cl"
+#include "blake2b.cl"
+#include "randomx_vm.cl"
+#include "randomx_jit.cl"

src/backend/opencl/cl/rx/randomx_constants_loki.h

@@ -0,0 +1,96 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+//Dataset base size in bytes. Must be a power of 2.
+#define RANDOMX_DATASET_BASE_SIZE  2147483648
+
+//Dataset extra size. Must be divisible by 64.
+#define RANDOMX_DATASET_EXTRA_SIZE 33554368
+
+//Scratchpad L3 size in bytes. Must be a power of 2.
+#define RANDOMX_SCRATCHPAD_L3      2097152
+
+//Scratchpad L2 size in bytes. Must be a power of two and less than or equal to RANDOMX_SCRATCHPAD_L3.
+#define RANDOMX_SCRATCHPAD_L2      262144
+
+//Scratchpad L1 size in bytes. Must be a power of two (minimum 64) and less than or equal to RANDOMX_SCRATCHPAD_L2.
+#define RANDOMX_SCRATCHPAD_L1      16384
+
+//Jump condition mask size in bits.
+#define RANDOMX_JUMP_BITS          8
+
+//Jump condition mask offset in bits. The sum of RANDOMX_JUMP_BITS and RANDOMX_JUMP_OFFSET must not exceed 16.
+#define RANDOMX_JUMP_OFFSET        8
+
+//Integer instructions
+#define RANDOMX_FREQ_IADD_RS       25
+#define RANDOMX_FREQ_IADD_M         7
+#define RANDOMX_FREQ_ISUB_R        16
+#define RANDOMX_FREQ_ISUB_M         7
+#define RANDOMX_FREQ_IMUL_R        16
+#define RANDOMX_FREQ_IMUL_M         4
+#define RANDOMX_FREQ_IMULH_R        4
+#define RANDOMX_FREQ_IMULH_M        1
+#define RANDOMX_FREQ_ISMULH_R       4
+#define RANDOMX_FREQ_ISMULH_M       1
+#define RANDOMX_FREQ_IMUL_RCP       8
+#define RANDOMX_FREQ_INEG_R         2
+#define RANDOMX_FREQ_IXOR_R        15
+#define RANDOMX_FREQ_IXOR_M         5
+#define RANDOMX_FREQ_IROR_R         8
+#define RANDOMX_FREQ_IROL_R         2
+#define RANDOMX_FREQ_ISWAP_R        4
+
+//Floating point instructions
+#define RANDOMX_FREQ_FSWAP_R        4
+#define RANDOMX_FREQ_FADD_R        16
+#define RANDOMX_FREQ_FADD_M         5
+#define RANDOMX_FREQ_FSUB_R        16
+#define RANDOMX_FREQ_FSUB_M         5
+#define RANDOMX_FREQ_FSCAL_R        6
+#define RANDOMX_FREQ_FMUL_R        32
+#define RANDOMX_FREQ_FDIV_M         4
+#define RANDOMX_FREQ_FSQRT_R        6
+
+//Control instructions
+#define RANDOMX_FREQ_CBRANCH       16
+#define RANDOMX_FREQ_CFROUND        1
+
+//Store instruction
+#define RANDOMX_FREQ_ISTORE        16
+
+//No-op instruction
+#define RANDOMX_FREQ_NOP            0
+
+#define RANDOMX_DATASET_ITEM_SIZE 64
+
+#define RANDOMX_PROGRAM_SIZE 320
+
+#define HASH_SIZE 64
+#define ENTROPY_SIZE (128 + RANDOMX_PROGRAM_SIZE * 8)
+#define REGISTERS_SIZE 256
+#define IMM_BUF_SIZE (RANDOMX_PROGRAM_SIZE * 4 - REGISTERS_SIZE)
+#define IMM_INDEX_COUNT ((IMM_BUF_SIZE / 4) - 2)
+#define VM_STATE_SIZE (REGISTERS_SIZE + IMM_BUF_SIZE + RANDOMX_PROGRAM_SIZE * 4)
+#define ROUNDING_MODE (RANDOMX_FREQ_CFROUND ? -1 : 0)
+
+// Scratchpad L1/L2/L3 bits
+#define LOC_L1 (32 - 14)
+#define LOC_L2 (32 - 18)
+#define LOC_L3 (32 - 21)

src/backend/opencl/cl/rx/randomx_constants_monero.h

@@ -0,0 +1,96 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+//Dataset base size in bytes. Must be a power of 2.
+#define RANDOMX_DATASET_BASE_SIZE  2147483648
+
+//Dataset extra size. Must be divisible by 64.
+#define RANDOMX_DATASET_EXTRA_SIZE 33554368
+
+//Scratchpad L3 size in bytes. Must be a power of 2.
+#define RANDOMX_SCRATCHPAD_L3      2097152
+
+//Scratchpad L2 size in bytes. Must be a power of two and less than or equal to RANDOMX_SCRATCHPAD_L3.
+#define RANDOMX_SCRATCHPAD_L2      262144
+
+//Scratchpad L1 size in bytes. Must be a power of two (minimum 64) and less than or equal to RANDOMX_SCRATCHPAD_L2.
+#define RANDOMX_SCRATCHPAD_L1      16384
+
+//Jump condition mask size in bits.
+#define RANDOMX_JUMP_BITS          8
+
+//Jump condition mask offset in bits. The sum of RANDOMX_JUMP_BITS and RANDOMX_JUMP_OFFSET must not exceed 16.
+#define RANDOMX_JUMP_OFFSET        8
+
+//Integer instructions
+#define RANDOMX_FREQ_IADD_RS       16
+#define RANDOMX_FREQ_IADD_M         7
+#define RANDOMX_FREQ_ISUB_R        16
+#define RANDOMX_FREQ_ISUB_M         7
+#define RANDOMX_FREQ_IMUL_R        16
+#define RANDOMX_FREQ_IMUL_M         4
+#define RANDOMX_FREQ_IMULH_R        4
+#define RANDOMX_FREQ_IMULH_M        1
+#define RANDOMX_FREQ_ISMULH_R       4
+#define RANDOMX_FREQ_ISMULH_M       1
+#define RANDOMX_FREQ_IMUL_RCP       8
+#define RANDOMX_FREQ_INEG_R         2
+#define RANDOMX_FREQ_IXOR_R        15
+#define RANDOMX_FREQ_IXOR_M         5
+#define RANDOMX_FREQ_IROR_R         8
+#define RANDOMX_FREQ_IROL_R         2
+#define RANDOMX_FREQ_ISWAP_R        4
+
+//Floating point instructions
+#define RANDOMX_FREQ_FSWAP_R        4
+#define RANDOMX_FREQ_FADD_R        16
+#define RANDOMX_FREQ_FADD_M         5
+#define RANDOMX_FREQ_FSUB_R        16
+#define RANDOMX_FREQ_FSUB_M         5
+#define RANDOMX_FREQ_FSCAL_R        6
+#define RANDOMX_FREQ_FMUL_R        32
+#define RANDOMX_FREQ_FDIV_M         4
+#define RANDOMX_FREQ_FSQRT_R        6
+
+//Control instructions
+#define RANDOMX_FREQ_CBRANCH       25
+#define RANDOMX_FREQ_CFROUND        1
+
+//Store instruction
+#define RANDOMX_FREQ_ISTORE        16
+
+//No-op instruction
+#define RANDOMX_FREQ_NOP            0
+
+#define RANDOMX_DATASET_ITEM_SIZE 64
+
+#define RANDOMX_PROGRAM_SIZE 256
+
+#define HASH_SIZE 64
+#define ENTROPY_SIZE (128 + RANDOMX_PROGRAM_SIZE * 8)
+#define REGISTERS_SIZE 256
+#define IMM_BUF_SIZE (RANDOMX_PROGRAM_SIZE * 4 - REGISTERS_SIZE)
+#define IMM_INDEX_COUNT ((IMM_BUF_SIZE / 4) - 2)
+#define VM_STATE_SIZE (REGISTERS_SIZE + IMM_BUF_SIZE + RANDOMX_PROGRAM_SIZE * 4)
+#define ROUNDING_MODE (RANDOMX_FREQ_CFROUND ? -1 : 0)
+
+// Scratchpad L1/L2/L3 bits
+#define LOC_L1 (32 - 14)
+#define LOC_L2 (32 - 18)
+#define LOC_L3 (32 - 21)

src/backend/opencl/cl/rx/randomx_constants_wow.h

@@ -0,0 +1,96 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+//Dataset base size in bytes. Must be a power of 2.
+#define RANDOMX_DATASET_BASE_SIZE  2147483648
+
+//Dataset extra size. Must be divisible by 64.
+#define RANDOMX_DATASET_EXTRA_SIZE 33554368
+
+//Scratchpad L3 size in bytes. Must be a power of 2.
+#define RANDOMX_SCRATCHPAD_L3      1048576
+
+//Scratchpad L2 size in bytes. Must be a power of two and less than or equal to RANDOMX_SCRATCHPAD_L3.
+#define RANDOMX_SCRATCHPAD_L2      131072
+
+//Scratchpad L1 size in bytes. Must be a power of two (minimum 64) and less than or equal to RANDOMX_SCRATCHPAD_L2.
+#define RANDOMX_SCRATCHPAD_L1      16384
+
+//Jump condition mask size in bits.
+#define RANDOMX_JUMP_BITS          8
+
+//Jump condition mask offset in bits. The sum of RANDOMX_JUMP_BITS and RANDOMX_JUMP_OFFSET must not exceed 16.
+#define RANDOMX_JUMP_OFFSET        8
+
+//Integer instructions
+#define RANDOMX_FREQ_IADD_RS       25
+#define RANDOMX_FREQ_IADD_M         7
+#define RANDOMX_FREQ_ISUB_R        16
+#define RANDOMX_FREQ_ISUB_M         7
+#define RANDOMX_FREQ_IMUL_R        16
+#define RANDOMX_FREQ_IMUL_M         4
+#define RANDOMX_FREQ_IMULH_R        4
+#define RANDOMX_FREQ_IMULH_M        1
+#define RANDOMX_FREQ_ISMULH_R       4
+#define RANDOMX_FREQ_ISMULH_M       1
+#define RANDOMX_FREQ_IMUL_RCP       8
+#define RANDOMX_FREQ_INEG_R         2
+#define RANDOMX_FREQ_IXOR_R        15
+#define RANDOMX_FREQ_IXOR_M         5
+#define RANDOMX_FREQ_IROR_R        10
+#define RANDOMX_FREQ_IROL_R         0
+#define RANDOMX_FREQ_ISWAP_R        4
+
+//Floating point instructions
+#define RANDOMX_FREQ_FSWAP_R        8
+#define RANDOMX_FREQ_FADD_R        20
+#define RANDOMX_FREQ_FADD_M         5
+#define RANDOMX_FREQ_FSUB_R        20
+#define RANDOMX_FREQ_FSUB_M         5
+#define RANDOMX_FREQ_FSCAL_R        6
+#define RANDOMX_FREQ_FMUL_R        20
+#define RANDOMX_FREQ_FDIV_M         4
+#define RANDOMX_FREQ_FSQRT_R        6
+
+//Control instructions
+#define RANDOMX_FREQ_CBRANCH       16
+#define RANDOMX_FREQ_CFROUND        1
+
+//Store instruction
+#define RANDOMX_FREQ_ISTORE        16
+
+//No-op instruction
+#define RANDOMX_FREQ_NOP            0
+
+#define RANDOMX_DATASET_ITEM_SIZE 64
+
+#define RANDOMX_PROGRAM_SIZE 256
+
+#define HASH_SIZE 64
+#define ENTROPY_SIZE (128 + RANDOMX_PROGRAM_SIZE * 8)
+#define REGISTERS_SIZE 256
+#define IMM_BUF_SIZE (RANDOMX_PROGRAM_SIZE * 4 - REGISTERS_SIZE)
+#define IMM_INDEX_COUNT ((IMM_BUF_SIZE / 4) - 2)
+#define VM_STATE_SIZE (REGISTERS_SIZE + IMM_BUF_SIZE + RANDOMX_PROGRAM_SIZE * 4)
+#define ROUNDING_MODE (RANDOMX_FREQ_CFROUND ? -1 : 0)
+
+// Scratchpad L1/L2/L3 bits
+#define LOC_L1 (32 - 14)
+#define LOC_L2 (32 - 17)
+#define LOC_L3 (32 - 20)

src/backend/opencl/cl/rx/randomx_run_gfx803.asm

@@ -0,0 +1,712 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+.amdcl2
+.gpu GFX803
+.64bit
+.arch_minor 0
+.arch_stepping 0
+.driver_version 203603
+.kernel randomx_run
+	.config
+		.dims x
+		.cws 64, 1, 1
+		.sgprsnum 96
+		# 6 waves per SIMD: 37-40 VGPRs
+		# 5 waves per SIMD: 41-48 VGPRs
+		# 4 waves per SIMD: 49-64 VGPRs
+		# 3 waves per SIMD: 65-84 VGPRs
+		# 2 waves per SIMD: 85-128 VGPRs
+		# 1 wave  per SIMD: 129-256 VGPRs
+		.vgprsnum 128
+		.localsize 256
+		.floatmode 0xc0
+		.pgmrsrc1 0x00ac035f
+		.pgmrsrc2 0x0000008c
+		.dx10clamp
+		.ieeemode
+		.useargs
+		.priority 0
+		.arg _.global_offset_0, "size_t", long
+		.arg _.global_offset_1, "size_t", long
+		.arg _.global_offset_2, "size_t", long
+		.arg _.printf_buffer, "size_t", void*, global, , rdonly
+		.arg _.vqueue_pointer, "size_t", long
+		.arg _.aqlwrap_pointer, "size_t", long
+		.arg dataset, "uchar*", uchar*, global, const, rdonly
+		.arg scratchpad, "uchar*", uchar*, global, 
+		.arg registers, "ulong*", ulong*, global, 
+		.arg rounding_modes, "uint*", uint*, global,
+		.arg programs, "uint*", uint*, global, 
+		.arg batch_size, "uint", uint
+		.arg rx_parameters, "uint", uint
+	.text
+		s_mov_b32       m0, 0x10000
+		s_dcache_wb
+		s_waitcnt       vmcnt(0) & lgkmcnt(0)
+		s_icache_inv
+		s_branch begin
+
+		# pgmrsrc2 = 0x00000090, bits 1:5 = 8, so first 8 SGPRs (s0-s7) contain user data
+		# s8 contains group id
+		# v0 contains local id
+begin:
+		s_mov_b32 s8, s6
+		v_lshlrev_b32   v1, 6, s8
+		v_add_u32       v1, vcc, v1, v0
+		s_load_dwordx2  s[0:1], s[4:5], 0x0
+		s_load_dwordx2  s[2:3], s[4:5], 0x40
+		s_load_dwordx2  s[64:65], s[4:5], 0x48
+		s_waitcnt       lgkmcnt(0)
+
+		# load rounding mode
+		s_lshl_b32      s16, s8, 2
+		s_add_u32       s64, s64, s16
+		s_addc_u32      s65, s65, 0
+		v_mov_b32       v8, s64
+		v_mov_b32       v9, s65
+		flat_load_dword v8, v[8:9]
+		s_waitcnt       vmcnt(0)
+		v_readlane_b32  s66, v8, 0
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		s_mov_b32       s67, 0
+
+		# used in FSQRT_R to check for "positive normal value" (v_cmpx_class_f64)
+		s_mov_b32       s68, 256
+		s_mov_b32       s69, 0
+
+		v_add_u32       v1, vcc, s0, v1
+		v_lshrrev_b32   v2, 6, v1
+		v_lshlrev_b32   v3, 5, v2
+		v_and_b32       v1, 63, v1
+		v_mov_b32       v4, 0
+		v_lshlrev_b64   v[3:4], 3, v[3:4]
+		v_lshlrev_b32   v5, 4, v1
+		v_add_u32       v3, vcc, s2, v3
+		v_mov_b32       v6, s3
+		v_addc_u32      v4, vcc, v6, v4, vcc
+		v_lshlrev_b32   v41, 2, v1
+		v_add_u32       v6, vcc, v3, v41
+		v_addc_u32      v7, vcc, v4, 0, vcc
+		flat_load_dword v6, v[6:7]
+		v_mov_b32       v0, 0
+		s_waitcnt       vmcnt(0)
+		ds_write_b32    v41, v6
+		s_waitcnt       lgkmcnt(0)
+		s_mov_b64       s[0:1], exec
+		v_cmpx_le_u32   s[2:3], v1, 7
+		s_cbranch_execz program_end
+
+		# rx_parameters
+		s_load_dword    s20, s[4:5], 0x5c
+		s_waitcnt       lgkmcnt(0)
+
+		# Scratchpad L1 size
+		s_bfe_u32       s21, s20, 0x050000
+		s_lshl_b32      s21, 1, s21
+
+		# Scratchpad L2 size
+		s_bfe_u32       s22, s20, 0x050005
+		s_lshl_b32      s22, 1, s22
+
+		# Scratchpad L3 size
+		s_bfe_u32       s23, s20, 0x05000A
+		s_lshl_b32      s23, 1, s23
+
+		# program iterations
+		s_bfe_u32       s24, s20, 0x04000F
+		s_lshl_b32      s24, 1, s24
+
+		# Base address for scratchpads
+		s_add_u32       s2, s23, 64
+		v_mul_hi_u32    v20, v2, s2
+		v_mul_lo_u32    v2, v2, s2
+
+		# v41, v44 = 0
+		v_mov_b32       v41, 0
+		v_mov_b32       v44, 0
+
+		ds_read_b32     v6, v0 offset:152
+		v_cmp_lt_u32    s[2:3], v1, 4
+		ds_read2_b64    v[34:37], v0 offset0:18 offset1:16
+		ds_read_b64     v[11:12], v0 offset:136
+		s_movk_i32      s9, 0x0
+		s_mov_b64       s[6:7], exec
+		s_andn2_b64     exec, s[6:7], s[2:3]
+		ds_read_b64     v[13:14], v0 offset:160
+		s_andn2_b64     exec, s[6:7], exec
+		v_mov_b32       v13, 0
+		v_mov_b32       v14, 0
+		s_mov_b64       exec, s[6:7]
+
+		# compiled program size
+		s_mov_b64       s[6:7], s[8:9]
+		s_mulk_i32      s6, 10048
+
+		v_add_u32       v5, vcc, v0, v5
+		v_add_u32       v5, vcc, v5, 64
+		s_mov_b64       s[8:9], exec
+		s_andn2_b64     exec, s[8:9], s[2:3]
+		ds_read_b64     v[15:16], v0 offset:168
+		s_andn2_b64     exec, s[8:9], exec
+		v_mov_b32       v15, 0
+		v_mov_b32       v16, 0
+		s_mov_b64       exec, s[8:9]
+		s_load_dwordx4  s[8:11], s[4:5], 0x30
+
+		# batch_size
+		s_load_dword    s16, s[4:5], 0x58
+
+		s_load_dwordx2  s[4:5], s[4:5], 0x50
+		v_lshlrev_b32   v1, 3, v1
+		v_add_u32       v17, vcc, v0, v1
+		s_waitcnt       lgkmcnt(0)
+		v_add_u32       v2, vcc, s10, v2
+		v_mov_b32       v18, s11
+		v_addc_u32      v18, vcc, v18, v20, vcc
+		v_mov_b32       v19, 0xffffff
+		v_add_u32       v6, vcc, s8, v6
+		v_mov_b32       v20, s9
+		v_addc_u32      v20, vcc, v20, 0, vcc
+		ds_read_b64     v[21:22], v17
+		s_add_u32       s4, s4, s6
+		s_addc_u32      s5, s5, s7
+		v_cndmask_b32   v19, v19, -1, s[2:3]
+		v_lshlrev_b32   v8, 3, v35
+		v_lshlrev_b32   v7, 3, v34
+		v_lshlrev_b32   v12, 3, v12
+		v_lshlrev_b32   v10, 3, v11
+		v_add_u32       v8, vcc, v8, v0
+		v_add_u32       v7, vcc, v7, v0
+		v_add_u32       v12, vcc, v12, v0
+		v_add_u32       v0, vcc, v10, v0
+		v_mov_b32       v10, v36
+		v_mov_b32       v23, v37
+
+		# loop counter
+		s_sub_u32       s2, s24, 1
+
+		# batch_size
+		s_mov_b32       s3, s16
+
+		# Scratchpad masks for scratchpads
+		v_sub_u32       v38, vcc, s21, 8
+		v_sub_u32       v39, vcc, s22, 8
+		v_sub_u32       v50, vcc, s23, 8
+
+		# mask for FSCAL_R
+		v_mov_b32       v51, 0x80F00000
+
+		# swap v3 and v18
+		v_mov_b32       v52, v3
+		v_mov_b32       v3, v18
+		v_mov_b32       v18, v52
+
+		# load scratchpad base address
+		v_readlane_b32	s0, v2, 0
+		v_readlane_b32	s1, v3, 0
+
+		# save current executiom mask
+		s_mov_b64       s[36:37], exec
+
+		# v41 = 0 on lane 0, set it to 8 on lane 1
+		# v44 = 0 on lane 0, set it to 4 on lane 1
+		s_mov_b64       exec, 2
+		v_mov_b32       v41, 8
+		v_mov_b32       v44, 4
+
+		# load group A registers
+		# Read low 8 bytes into lane 0 and high 8 bytes into lane 1
+		s_mov_b64       exec, 3
+		ds_read2_b64    v[52:55], v41 offset0:24 offset1:26
+		ds_read2_b64    v[56:59], v41 offset0:28 offset1:30
+
+		# xmantissaMask
+		v_mov_b32       v77, (1 << 24) - 1
+
+		# xexponentMask
+		ds_read_b64     v[78:79], v41 offset:160
+
+		# Restore execution mask
+		s_mov_b64       exec, s[36:37]
+
+		# sign mask (used in FSQRT_R)
+		v_mov_b32       v82, 0x80000000
+
+		# High 32 bits of "1.0" constant (used in FDIV_M)
+		v_mov_b32       v83, (1023 << 20)
+
+		# Used to multiply FP64 values by 0.5
+		v_mov_b32       v84, (1 << 20)
+
+		s_getpc_b64 s[14:15]
+cur_addr:
+
+		# get addresses of FSQRT_R subroutines
+		s_add_u32       s40, s14, fsqrt_r_sub0 - cur_addr
+		s_addc_u32      s41, s15, 0
+		s_add_u32       s42, s14, fsqrt_r_sub1 - cur_addr
+		s_addc_u32      s43, s15, 0
+		s_add_u32       s44, s14, fsqrt_r_sub2 - cur_addr
+		s_addc_u32      s45, s15, 0
+		s_add_u32       s46, s14, fsqrt_r_sub3 - cur_addr
+		s_addc_u32      s47, s15, 0
+
+		# get addresses of FDIV_M subroutines
+		s_add_u32       s48, s14, fdiv_m_sub0 - cur_addr
+		s_addc_u32      s49, s15, 0
+		s_add_u32       s50, s14, fdiv_m_sub1 - cur_addr
+		s_addc_u32      s51, s15, 0
+		s_add_u32       s52, s14, fdiv_m_sub2 - cur_addr
+		s_addc_u32      s53, s15, 0
+		s_add_u32       s54, s14, fdiv_m_sub3 - cur_addr
+		s_addc_u32      s55, s15, 0
+
+		# get address for ISMULH_R subroutine
+		s_add_u32       s56, s14, ismulh_r_sub - cur_addr
+		s_addc_u32      s57, s15, 0
+
+		# get address for IMULH_R subroutine
+		s_add_u32       s58, s14, imulh_r_sub - cur_addr
+		s_addc_u32      s59, s15, 0
+
+		# used in IXOR_R instruction
+		s_mov_b32       s63, -1
+
+		# used in CBRANCH instruction
+		s_mov_b32       s70, (0xFF << 8)
+		s_mov_b32       s71, (0xFF << 9)
+		s_mov_b32       s72, (0xFF << 10)
+		s_mov_b32       s73, (0xFF << 11)
+		s_mov_b32       s74, (0xFF << 12)
+		s_mov_b32       s75, (0xFF << 13)
+		s_mov_b32       s76, (0xFF << 14)
+		s_mov_b32       s77, (0xFF << 15)
+		s_mov_b32       s78, (0xFF << 16)
+		s_mov_b32       s79, (0xFF << 17)
+		s_mov_b32       s80, (0xFF << 18)
+		s_mov_b32       s81, (0xFF << 19)
+		s_mov_b32       s82, (0xFF << 20)
+		s_mov_b32       s83, (0xFF << 21)
+		s_mov_b32       s84, (0xFF << 22)
+		s_mov_b32       s85, (0xFF << 23)
+
+		# ScratchpadL3Mask64
+		s_sub_u32       s86, s23, 64
+
+main_loop:
+		# const uint2 spMix = as_uint2(R[readReg0] ^ R[readReg1]);
+		ds_read_b64     v[24:25], v0
+		ds_read_b64     v[26:27], v12
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v25, v27, v25
+		v_xor_b32       v24, v26, v24
+
+		# spAddr1 ^= spMix.y;
+		# spAddr0 ^= spMix.x;
+		v_xor_b32       v10, v25, v10
+		v_xor_b32       v23, v24, v23
+
+		# spAddr1 &= ScratchpadL3Mask64;
+		# spAddr0 &= ScratchpadL3Mask64;
+		v_and_b32       v10, s86, v10
+		v_and_b32       v23, s86, v23
+
+		# Offset for scratchpads
+		# offset1 = spAddr1 + sub * 8
+		# offset0 = spAddr0 + sub * 8
+		v_add_u32       v10, vcc, v10, v1
+		v_add_u32       v23, vcc, v23, v1
+
+		# __global ulong* p1 = (__global ulong*)(scratchpad + offset1);
+		# __global ulong* p0 = (__global ulong*)(scratchpad + offset0);
+		v_add_u32       v26, vcc, v2, v10
+		v_addc_u32      v27, vcc, v3, 0, vcc
+		v_add_u32       v23, vcc, v2, v23
+		v_addc_u32      v24, vcc, v3, 0, vcc
+
+		# load from spAddr1
+		flat_load_dwordx2 v[28:29], v[26:27]
+
+		# load from spAddr0
+		flat_load_dwordx2 v[30:31], v[23:24]
+		s_waitcnt       vmcnt(1)
+
+		v_cvt_f64_i32   v[32:33], v28
+		v_cvt_f64_i32   v[28:29], v29
+		s_waitcnt       vmcnt(0)
+
+		# R[sub] ^= *p0;
+		v_xor_b32       v34, v21, v30
+		v_xor_b32       v35, v22, v31
+
+		v_add_u32       v22, vcc, v6, v36
+		v_addc_u32      v25, vcc, v20, 0, vcc
+		v_add_u32       v21, vcc, v22, v1
+		v_addc_u32      v22, vcc, v25, 0, vcc
+		flat_load_dwordx2 v[21:22], v[21:22]
+		v_or_b32        v30, v32, v13
+		v_and_b32       v31, v33, v19
+		v_or_b32        v31, v31, v14
+		v_or_b32        v28, v28, v15
+		v_and_b32       v29, v29, v19
+		v_or_b32        v29, v29, v16
+		ds_write2_b64   v5, v[30:31], v[28:29] offset1:1
+		s_waitcnt       lgkmcnt(0)
+
+		# Program 0
+
+		# load group F,E registers
+		# Read low 8 bytes into lane 0 and high 8 bytes into lane 1
+		s_mov_b64       exec, 3
+		ds_read2_b64    v[60:63], v41 offset0:8 offset1:10
+		ds_read2_b64    v[64:67], v41 offset0:12 offset1:14
+		ds_read2_b64    v[68:71], v41 offset0:16 offset1:18
+		ds_read2_b64    v[72:75], v41 offset0:20 offset1:22
+
+		# load VM integer registers
+		v_readlane_b32	s16, v34, 0
+		v_readlane_b32	s17, v35, 0
+		v_readlane_b32	s18, v34, 1
+		v_readlane_b32	s19, v35, 1
+		v_readlane_b32	s20, v34, 2
+		v_readlane_b32	s21, v35, 2
+		v_readlane_b32	s22, v34, 3
+		v_readlane_b32	s23, v35, 3
+		v_readlane_b32	s24, v34, 4
+		v_readlane_b32	s25, v35, 4
+		v_readlane_b32	s26, v34, 5
+		v_readlane_b32	s27, v35, 5
+		v_readlane_b32	s28, v34, 6
+		v_readlane_b32	s29, v35, 6
+		v_readlane_b32	s30, v34, 7
+		v_readlane_b32	s31, v35, 7
+
+		s_waitcnt       lgkmcnt(0)
+
+		# call JIT code
+		s_swappc_b64    s[12:13], s[4:5]
+
+		# Write out group F,E registers
+		# Write low 8 bytes from lane 0 and high 8 bytes from lane 1
+		ds_write2_b64   v41, v[60:61], v[62:63] offset0:8 offset1:10
+		ds_write2_b64   v41, v[64:65], v[66:67] offset0:12 offset1:14
+		ds_write2_b64   v41, v[68:69], v[70:71] offset0:16 offset1:18
+		ds_write2_b64   v41, v[72:73], v[74:75] offset0:20 offset1:22
+
+		# store VM integer registers
+		v_writelane_b32 v28, s16, 0
+		v_writelane_b32 v29, s17, 0
+		v_writelane_b32 v28, s18, 1
+		v_writelane_b32 v29, s19, 1
+		v_writelane_b32 v28, s20, 2
+		v_writelane_b32 v29, s21, 2
+		v_writelane_b32 v28, s22, 3
+		v_writelane_b32 v29, s23, 3
+		v_writelane_b32 v28, s24, 4
+		v_writelane_b32 v29, s25, 4
+		v_writelane_b32 v28, s26, 5
+		v_writelane_b32 v29, s27, 5
+		v_writelane_b32 v28, s28, 6
+		v_writelane_b32 v29, s29, 6
+		v_writelane_b32 v28, s30, 7
+		v_writelane_b32 v29, s31, 7
+
+		# Restore execution mask
+		s_mov_b64       exec, s[36:37]
+
+		# Write out VM integer registers
+		ds_write_b64    v17, v[28:29]
+
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v21, v28, v21
+		v_xor_b32       v22, v29, v22
+		ds_read_b32     v28, v7
+		ds_read_b32     v29, v8
+		ds_write_b64    v17, v[21:22]
+		s_waitcnt       lgkmcnt(1)
+		ds_read2_b64    v[30:33], v17 offset0:8 offset1:16
+		v_xor_b32       v10, v28, v37
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v30, v32, v30
+		v_xor_b32       v31, v33, v31
+		v_xor_b32       v10, v10, v29
+		flat_store_dwordx2 v[26:27], v[21:22]
+		v_and_b32       v10, 0x7fffffc0, v10
+		flat_store_dwordx2 v[23:24], v[30:31]
+		s_cmp_eq_u32    s2, 0
+		s_cbranch_scc1  main_loop_end
+		s_sub_i32       s2, s2, 1
+		v_mov_b32       v37, v36
+		v_mov_b32       v23, 0
+		v_mov_b32       v36, v10
+		v_mov_b32       v10, 0
+		s_branch        main_loop
+main_loop_end:
+
+		v_add_u32       v0, vcc, v18, v1
+		v_addc_u32      v1, vcc, v4, 0, vcc
+		flat_store_dwordx2 v[0:1], v[21:22]
+		v_add_u32       v0, vcc, v0, 64
+		v_addc_u32      v1, vcc, v1, 0, vcc
+		flat_store_dwordx2 v[0:1], v[30:31]
+		v_add_u32       v0, vcc, v0, 64
+		v_addc_u32      v1, vcc, v1, 0, vcc
+		flat_store_dwordx2 v[0:1], v[32:33]
+
+		# store rounding mode
+		v_mov_b32       v0, s64
+		v_mov_b32       v1, s65
+		v_mov_b32       v2, s66
+		flat_store_dword v[0:1], v2
+
+program_end:
+		s_endpgm
+
+fsqrt_r_sub0:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[68:69]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[68:69]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[68:69]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, vcc, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[68:69]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[68:69], s[68:69]
+		v_mov_b32       v68, v42
+		v_mov_b32       v69, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub1:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[70:71]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[70:71]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[70:71]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, vcc, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[70:71]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[70:71], s[68:69]
+		v_mov_b32       v70, v42
+		v_mov_b32       v71, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub2:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[72:73]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[72:73]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[72:73]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, vcc, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[72:73]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[72:73], s[68:69]
+		v_mov_b32       v72, v42
+		v_mov_b32       v73, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub3:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[74:75]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[74:75]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[74:75]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, vcc, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[74:75]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[74:75], s[68:69]
+		v_mov_b32       v74, v42
+		v_mov_b32       v75, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub0:
+		v_or_b32        v28, v28, v78
+		v_and_b32       v29, v29, v77
+		v_or_b32        v29, v29, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[68:69], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[68:69]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[68:69]
+		v_cmpx_eq_f64   s[14:15], v[68:69], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v68, v80
+		v_mov_b32       v69, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub1:
+		v_or_b32        v28, v28, v78
+		v_and_b32       v29, v29, v77
+		v_or_b32        v29, v29, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[70:71], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[70:71]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[70:71]
+		v_cmpx_eq_f64   s[14:15], v[70:71], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v70, v80
+		v_mov_b32       v71, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub2:
+		v_or_b32        v28, v28, v78
+		v_and_b32       v29, v29, v77
+		v_or_b32        v29, v29, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[72:73], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[72:73]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[72:73]
+		v_cmpx_eq_f64   s[14:15], v[72:73], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v72, v80
+		v_mov_b32       v73, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub3:
+		v_or_b32        v28, v28, v78
+		v_and_b32       v29, v29, v77
+		v_or_b32        v29, v29, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[74:75], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[74:75]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[74:75]
+		v_cmpx_eq_f64   s[14:15], v[74:75], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v74, v80
+		v_mov_b32       v75, v81
+		s_setpc_b64     s[60:61]
+
+ismulh_r_sub:
+		s_mov_b64       exec, 1
+		v_mov_b32       v45, s14
+		v_mul_hi_u32    v40, s38, v45
+		v_mov_b32       v47, s15
+		v_mad_u64_u32   v[42:43], s[32:33], s38, v47, v[40:41]
+		v_mov_b32       v40, v42
+		v_mad_u64_u32   v[45:46], s[32:33], s39, v45, v[40:41]
+		v_mad_u64_u32   v[42:43], s[32:33], s39, v47, v[43:44]
+		v_add_u32       v42, vcc, v42, v46
+		v_addc_u32      v43, vcc, 0, v43, vcc
+		v_readlane_b32  s32, v42, 0
+		v_readlane_b32  s33, v43, 0
+		s_cmp_lt_i32    s15, 0
+		s_cselect_b64   s[34:35], s[38:39], 0
+		s_sub_u32       s32, s32, s34
+		s_subb_u32      s33, s33, s35
+		s_cmp_lt_i32    s39, 0
+		s_cselect_b64   s[34:35], s[14:15], 0
+		s_sub_u32       s14, s32, s34
+		s_subb_u32      s15, s33, s35
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+imulh_r_sub:
+		s_mov_b64       exec, 1
+		v_mov_b32       v45, s38
+		v_mul_hi_u32    v40, s14, v45
+		v_mov_b32       v47, s39
+		v_mad_u64_u32   v[42:43], s[32:33], s14, v47, v[40:41]
+		v_mov_b32       v40, v42
+		v_mad_u64_u32   v[45:46], s[32:33], s15, v45, v[40:41]
+		v_mad_u64_u32   v[42:43], s[32:33], s15, v47, v[43:44]
+		v_add_u32       v42, vcc, v42, v46
+		v_addc_u32      v43, vcc, 0, v43, vcc
+		v_readlane_b32  s14, v42, 0
+		v_readlane_b32  s15, v43, 0
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]

src/backend/opencl/cl/rx/randomx_run_gfx803.h

@@ -0,0 +1,218 @@
+/*
+This file was auto-generated from randomx_run_gfx803.asm:
+
+clrxasm randomx_run_gfx803.asm -o randomx_run_gfx803.bin
+bin2h -c randomx_run_gfx803_bin < randomx_run_gfx803.bin > randomx_run_gfx803.h
+
+clrxasm can be downloaded here: https://github.com/CLRX/CLRX-mirror/releases
+bin2h can be downloaded here: http://www.deadnode.org/sw/bin2h/
+*/
+
+static unsigned char randomx_run_gfx803_bin[]={
+0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x5b,0xaf,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe8,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x07,0x00,0x01,0x00,0x00
+,0x2e,0x73,0x68,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x73,0x79,0x6d,0x74,0x61,0x62,0x00,0x2e,0x63,0x6f,0x6d,0x6d,0x65
+,0x6e,0x74,0x00,0x2e,0x72,0x6f,0x64,0x61,0x74,0x61,0x00,0x2e,0x74,0x65,0x78,0x74,0x00,0x00,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x26,0x5f,0x5f,0x4f,0x70
+,0x65,0x6e,0x43,0x4c,0x5f,0x72,0x61,0x6e,0x64,0x6f,0x6d,0x78,0x5f,0x72,0x75,0x6e,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x5f,0x6d,0x65,0x74,0x61,0x64,0x61,0x74,0x61
+,0x00,0x61,0x63,0x6c,0x5f,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x5f,0x73,0x74,0x72,0x69,0x6e,0x67,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3b
+,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x01,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41
+,0x4d,0x44,0x2d,0x43,0x4f,0x4d,0x50,0x2d,0x4c,0x49,0x42,0x2d,0x76,0x30,0x2e,0x38,0x20,0x28,0x30,0x2e,0x30,0x2e,0x53,0x43,0x5f,0x42,0x55,0x49,0x4c,0x44,0x5f,0x4e
+,0x55,0x4d,0x42,0x45,0x52,0x29,0x10,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x3b,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x68,0x00
+,0x00,0x00,0x24,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x40,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x64
+,0x75,0x6d,0x6d,0x79,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x00,0x67,0x65,0x6e,0x65,0x72,0x69,0x63,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x10,0x00,0x00
+,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x50,0x00,0x00
+,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00
+,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00
+,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x09,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x90,0x00,0x00
+,0x00,0x07,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0xa0,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x04,0x00,0x00
+,0x00,0x08,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0xb0,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0d,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x5f,0x2e,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,0x5f,0x30,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e
+,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,0x5f,0x31,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f
+,0x6f,0x66,0x66,0x73,0x65,0x74,0x5f,0x32,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x70,0x72,0x69,0x6e,0x74,0x66,0x5f,0x62,0x75,0x66,0x66,0x65,0x72,0x00
+,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x76,0x71,0x75,0x65,0x75,0x65,0x5f,0x70,0x6f,0x69,0x6e,0x74,0x65,0x72,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f
+,0x2e,0x61,0x71,0x6c,0x77,0x72,0x61,0x70,0x5f,0x70,0x6f,0x69,0x6e,0x74,0x65,0x72,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x64,0x61,0x74,0x61,0x73,0x65,0x74,0x00
+,0x75,0x63,0x68,0x61,0x72,0x2a,0x00,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x00,0x75,0x63,0x68,0x61,0x72,0x2a,0x00,0x72,0x65,0x67,0x69,0x73,0x74,0x65
+,0x72,0x73,0x00,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x00,0x72,0x6f,0x75,0x6e,0x64,0x69,0x6e,0x67,0x5f,0x6d,0x6f,0x64,0x65,0x73,0x00,0x75,0x69,0x6e,0x74,0x2a,0x00,0x70
+,0x72,0x6f,0x67,0x72,0x61,0x6d,0x73,0x00,0x75,0x69,0x6e,0x74,0x2a,0x00,0x62,0x61,0x74,0x63,0x68,0x5f,0x73,0x69,0x7a,0x65,0x00,0x75,0x69,0x6e,0x74,0x00,0x72,0x78
+,0x5f,0x70,0x61,0x72,0x61,0x6d,0x65,0x74,0x65,0x72,0x73,0x00,0x75,0x69,0x6e,0x74,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0xe0,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x38,0x00,0x01,0x00,0x40,0x00,0x06,0x00,0x01
+,0x00,0x03,0x00,0x00,0x60,0x05,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0xb4,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0xb4,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2e,0x73,0x68,0x73,0x74,0x72
+,0x74,0x61,0x62,0x00,0x2e,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x6e,0x6f,0x74,0x65,0x00,0x2e,0x68,0x73,0x61,0x74,0x65,0x78,0x74,0x00,0x2e,0x73,0x79,0x6d,0x74
+,0x61,0x62,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x26,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x72,0x61,0x6e,0x64,0x6f,0x6d,0x78,0x5f,0x72,0x75,0x6e,0x5f
+,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x00,0x5f,0x5f,0x68,0x73,0x61,0x5f,0x73,0x65,0x63,0x74,0x69,0x6f,0x6e,0x2e,0x68,0x73,0x61,0x74,0x65,0x78,0x74,0x00,0x00,0x00,0x00
+,0x00,0x04,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x0c,0x00,0x00
+,0x00,0x02,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x03,0x00,0x00
+,0x00,0x41,0x4d,0x44,0x00,0x04,0x00,0x07,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x41,0x4d,0x44,0x47,0x50,0x55,0x00
+,0x00,0x04,0x00,0x00,0x00,0x29,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x19,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41,0x4d,0x44
+,0x20,0x48,0x53,0x41,0x20,0x52,0x75,0x6e,0x74,0x69,0x6d,0x65,0x20,0x46,0x69,0x6e,0x61,0x6c,0x69,0x7a,0x65,0x72,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00
+,0x00,0x1a,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x16,0x00,0x2d,0x68,0x73,0x61,0x5f,0x63,0x61,0x6c,0x6c,0x5f,0x63,0x6f,0x6e,0x76,0x65,0x6e,0x74
+,0x69,0x6f,0x6e,0x3d,0x30,0x00,0x74,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x03,0xac,0x00,0x8c,0x00,0x00,0x00,0x09,0x00,0x0a,0x00,0x00,0x00,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x62,0x00,0x80,0x00,0x80,0x00,0x00,0x00,0x60,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x04,0x04,0x04,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0xff,0x00,0xfc,0xbe,0x00,0x00,0x01,0x00,0x00,0x00,0x84,0xc0,0x00,0x00,0x00,0x00,0x70,0x00,0x8c,0xbf,0x00,0x00,0x93,0xbf,0x00,0x00,0x82,0xbf,0x06,0x00,0x88
+,0xbe,0x01,0x00,0x12,0xd1,0x86,0x10,0x00,0x00,0x01,0x01,0x02,0x32,0x02,0x00,0x06,0xc0,0x00,0x00,0x00,0x00,0x82,0x00,0x06,0xc0,0x40,0x00,0x00,0x00,0x02,0x10,0x06
+,0xc0,0x48,0x00,0x00,0x00,0x7f,0x00,0x8c,0xbf,0x08,0x82,0x10,0x8e,0x40,0x10,0x40,0x80,0x41,0x80,0x41,0x82,0x40,0x02,0x10,0x7e,0x41,0x02,0x12,0x7e,0x00,0x00,0x50
+,0xdc,0x08,0x00,0x00,0x08,0x70,0x0f,0x8c,0xbf,0x42,0x00,0x89,0xd2,0x08,0x01,0x01,0x00,0x81,0x08,0x42,0xb9,0x80,0x00,0xc3,0xbe,0xff,0x00,0xc4,0xbe,0x00,0x01,0x00
+,0x00,0x80,0x00,0xc5,0xbe,0x00,0x02,0x02,0x32,0x86,0x02,0x04,0x20,0x85,0x04,0x06,0x24,0xbf,0x02,0x02,0x26,0x80,0x02,0x08,0x7e,0x03,0x00,0x8f,0xd2,0x83,0x06,0x02
+,0x00,0x84,0x02,0x0a,0x24,0x02,0x06,0x06,0x32,0x03,0x02,0x0c,0x7e,0x06,0x09,0x08,0x38,0x82,0x02,0x52,0x24,0x03,0x53,0x0c,0x32,0x07,0x6a,0x1c,0xd1,0x04,0x01,0xa9
+,0x01,0x00,0x00,0x50,0xdc,0x06,0x00,0x00,0x06,0x80,0x02,0x00,0x7e,0x70,0x0f,0x8c,0xbf,0x00,0x00,0x1a,0xd8,0x29,0x06,0x00,0x00,0x7f,0x00,0x8c,0xbf,0x7e,0x01,0x80
+,0xbe,0x02,0x00,0xdb,0xd0,0x01,0x0f,0x01,0x00,0x75,0x01,0x88,0xbf,0x02,0x05,0x02,0xc0,0x5c,0x00,0x00,0x00,0x7f,0x00,0x8c,0xbf,0x14,0xff,0x95,0x92,0x00,0x00,0x05
+,0x00,0x81,0x15,0x15,0x8e,0x14,0xff,0x96,0x92,0x05,0x00,0x05,0x00,0x81,0x16,0x16,0x8e,0x14,0xff,0x97,0x92,0x0a,0x00,0x05,0x00,0x81,0x17,0x17,0x8e,0x14,0xff,0x98
+,0x92,0x0f,0x00,0x04,0x00,0x81,0x18,0x18,0x8e,0x17,0xc0,0x02,0x80,0x14,0x00,0x86,0xd2,0x02,0x05,0x00,0x00,0x02,0x00,0x85,0xd2,0x02,0x05,0x00,0x00,0x80,0x02,0x52
+,0x7e,0x80,0x02,0x58,0x7e,0x98,0x00,0x6c,0xd8,0x00,0x00,0x00,0x06,0x02,0x00,0xc9,0xd0,0x01,0x09,0x01,0x00,0x12,0x10,0xee,0xd8,0x00,0x00,0x00,0x22,0x88,0x00,0xec
+,0xd8,0x00,0x00,0x00,0x0b,0x00,0x00,0x09,0xb0,0x7e,0x01,0x86,0xbe,0x06,0x02,0xfe,0x89,0xa0,0x00,0xec,0xd8,0x00,0x00,0x00,0x0d,0x06,0x7e,0xfe,0x89,0x80,0x02,0x1a
+,0x7e,0x80,0x02,0x1c,0x7e,0x06,0x01,0xfe,0xbe,0x08,0x01,0x86,0xbe,0x40,0x27,0x86,0xb7,0x00,0x0b,0x0a,0x32,0x05,0x6a,0x19,0xd1,0x05,0x81,0x01,0x00,0x7e,0x01,0x88
+,0xbe,0x08,0x02,0xfe,0x89,0xa8,0x00,0xec,0xd8,0x00,0x00,0x00,0x0f,0x08,0x7e,0xfe,0x89,0x80,0x02,0x1e,0x7e,0x80,0x02,0x20,0x7e,0x08,0x01,0xfe,0xbe,0x02,0x02,0x0a
+,0xc0,0x30,0x00,0x00,0x00,0x02,0x04,0x02,0xc0,0x58,0x00,0x00,0x00,0x02,0x01,0x06,0xc0,0x50,0x00,0x00,0x00,0x83,0x02,0x02,0x24,0x00,0x03,0x22,0x32,0x7f,0x00,0x8c
+,0xbf,0x0a,0x04,0x04,0x32,0x0b,0x02,0x24,0x7e,0x12,0x29,0x24,0x38,0xff,0x02,0x26,0x7e,0xff,0xff,0xff,0x00,0x08,0x0c,0x0c,0x32,0x09,0x02,0x28,0x7e,0x14,0x6a,0x1c
+,0xd1,0x14,0x01,0xa9,0x01,0x00,0x00,0xec,0xd8,0x11,0x00,0x00,0x15,0x04,0x06,0x04,0x80,0x05,0x07,0x05,0x82,0x13,0x00,0x00,0xd1,0x13,0x83,0x09,0x00,0x83,0x46,0x10
+,0x24,0x83,0x44,0x0e,0x24,0x83,0x18,0x18,0x24,0x83,0x16,0x14,0x24,0x08,0x01,0x10,0x32,0x07,0x01,0x0e,0x32,0x0c,0x01,0x18,0x32,0x0a,0x01,0x00,0x32,0x24,0x03,0x14
+,0x7e,0x25,0x03,0x2e,0x7e,0x18,0x81,0x82,0x80,0x10,0x00,0x83,0xbe,0x26,0x6a,0x1a,0xd1,0x15,0x10,0x01,0x00,0x27,0x6a,0x1a,0xd1,0x16,0x10,0x01,0x00,0x32,0x6a,0x1a
+,0xd1,0x17,0x10,0x01,0x00,0xff,0x02,0x66,0x7e,0x00,0x00,0xf0,0x80,0x03,0x03,0x68,0x7e,0x12,0x03,0x06,0x7e,0x34,0x03,0x24,0x7e,0x00,0x00,0x89,0xd2,0x02,0x01,0x01
+,0x00,0x01,0x00,0x89,0xd2,0x03,0x01,0x01,0x00,0x7e,0x01,0xa4,0xbe,0x82,0x01,0xfe,0xbe,0x88,0x02,0x52,0x7e,0x84,0x02,0x58,0x7e,0x83,0x01,0xfe,0xbe,0x18,0x1a,0xee
+,0xd8,0x29,0x00,0x00,0x34,0x1c,0x1e,0xee,0xd8,0x29,0x00,0x00,0x38,0xff,0x02,0x9a,0x7e,0xff,0xff,0xff,0x00,0xa0,0x00,0xec,0xd8,0x29,0x00,0x00,0x4e,0x24,0x01,0xfe
+,0xbe,0xff,0x02,0xa4,0x7e,0x00,0x00,0x00,0x80,0xff,0x02,0xa6,0x7e,0x00,0x00,0xf0,0x3f,0xff,0x02,0xa8,0x7e,0x00,0x00,0x10,0x00,0x00,0x1c,0x8e,0xbe,0x0e,0xff,0x28
+,0x80,0xe8,0x03,0x00,0x00,0x0f,0x80,0x29,0x82,0x0e,0xff,0x2a,0x80,0x4c,0x04,0x00,0x00,0x0f,0x80,0x2b,0x82,0x0e,0xff,0x2c,0x80,0xb0,0x04,0x00,0x00,0x0f,0x80,0x2d
+,0x82,0x0e,0xff,0x2e,0x80,0x14,0x05,0x00,0x00,0x0f,0x80,0x2f,0x82,0x0e,0xff,0x30,0x80,0x78,0x05,0x00,0x00,0x0f,0x80,0x31,0x82,0x0e,0xff,0x32,0x80,0xe0,0x05,0x00
+,0x00,0x0f,0x80,0x33,0x82,0x0e,0xff,0x34,0x80,0x48,0x06,0x00,0x00,0x0f,0x80,0x35,0x82,0x0e,0xff,0x36,0x80,0xb0,0x06,0x00,0x00,0x0f,0x80,0x37,0x82,0x0e,0xff,0x38
+,0x80,0x18,0x07,0x00,0x00,0x0f,0x80,0x39,0x82,0x0e,0xff,0x3a,0x80,0x88,0x07,0x00,0x00,0x0f,0x80,0x3b,0x82,0xc1,0x00,0xbf,0xbe,0xff,0x00,0xc6,0xbe,0x00,0xff,0x00
+,0x00,0xff,0x00,0xc7,0xbe,0x00,0xfe,0x01,0x00,0xff,0x00,0xc8,0xbe,0x00,0xfc,0x03,0x00,0xff,0x00,0xc9,0xbe,0x00,0xf8,0x07,0x00,0xff,0x00,0xca,0xbe,0x00,0xf0,0x0f
+,0x00,0xff,0x00,0xcb,0xbe,0x00,0xe0,0x1f,0x00,0xff,0x00,0xcc,0xbe,0x00,0xc0,0x3f,0x00,0xff,0x00,0xcd,0xbe,0x00,0x80,0x7f,0x00,0xff,0x00,0xce,0xbe,0x00,0x00,0xff
+,0x00,0xff,0x00,0xcf,0xbe,0x00,0x00,0xfe,0x01,0xff,0x00,0xd0,0xbe,0x00,0x00,0xfc,0x03,0xff,0x00,0xd1,0xbe,0x00,0x00,0xf8,0x07,0xff,0x00,0xd2,0xbe,0x00,0x00,0xf0
+,0x0f,0xff,0x00,0xd3,0xbe,0x00,0x00,0xe0,0x1f,0xff,0x00,0xd4,0xbe,0x00,0x00,0xc0,0x3f,0xff,0x00,0xd5,0xbe,0x00,0x00,0x80,0x7f,0x17,0xc0,0xd6,0x80,0x00,0x00,0xec
+,0xd8,0x00,0x00,0x00,0x18,0x00,0x00,0xec,0xd8,0x0c,0x00,0x00,0x1a,0x7f,0x00,0x8c,0xbf,0x1b,0x33,0x32,0x2a,0x1a,0x31,0x30,0x2a,0x19,0x15,0x14,0x2a,0x18,0x2f,0x2e
+,0x2a,0x56,0x14,0x14,0x26,0x56,0x2e,0x2e,0x26,0x0a,0x03,0x14,0x32,0x17,0x03,0x2e,0x32,0x02,0x15,0x34,0x32,0x1b,0x6a,0x1c,0xd1,0x03,0x01,0xa9,0x01,0x02,0x2f,0x2e
+,0x32,0x18,0x6a,0x1c,0xd1,0x03,0x01,0xa9,0x01,0x00,0x00,0x54,0xdc,0x1a,0x00,0x00,0x1c,0x00,0x00,0x54,0xdc,0x17,0x00,0x00,0x1e,0x71,0x0f,0x8c,0xbf,0x1c,0x09,0x40
+,0x7e,0x1d,0x09,0x38,0x7e,0x70,0x0f,0x8c,0xbf,0x15,0x3d,0x44,0x2a,0x16,0x3f,0x46,0x2a,0x06,0x49,0x2c,0x32,0x19,0x6a,0x1c,0xd1,0x14,0x01,0xa9,0x01,0x16,0x03,0x2a
+,0x32,0x16,0x6a,0x1c,0xd1,0x19,0x01,0xa9,0x01,0x00,0x00,0x54,0xdc,0x15,0x00,0x00,0x15,0x20,0x1b,0x3c,0x28,0x21,0x27,0x3e,0x26,0x1f,0x1d,0x3e,0x28,0x1c,0x1f,0x38
+,0x28,0x1d,0x27,0x3a,0x26,0x1d,0x21,0x3a,0x28,0x00,0x01,0x9c,0xd8,0x05,0x1e,0x1c,0x00,0x7f,0x00,0x8c,0xbf,0x83,0x01,0xfe,0xbe,0x08,0x0a,0xee,0xd8,0x29,0x00,0x00
+,0x3c,0x0c,0x0e,0xee,0xd8,0x29,0x00,0x00,0x40,0x10,0x12,0xee,0xd8,0x29,0x00,0x00,0x44,0x14,0x16,0xee,0xd8,0x29,0x00,0x00,0x48,0x10,0x00,0x89,0xd2,0x22,0x01,0x01
+,0x00,0x11,0x00,0x89,0xd2,0x23,0x01,0x01,0x00,0x12,0x00,0x89,0xd2,0x22,0x03,0x01,0x00,0x13,0x00,0x89,0xd2,0x23,0x03,0x01,0x00,0x14,0x00,0x89,0xd2,0x22,0x05,0x01
+,0x00,0x15,0x00,0x89,0xd2,0x23,0x05,0x01,0x00,0x16,0x00,0x89,0xd2,0x22,0x07,0x01,0x00,0x17,0x00,0x89,0xd2,0x23,0x07,0x01,0x00,0x18,0x00,0x89,0xd2,0x22,0x09,0x01
+,0x00,0x19,0x00,0x89,0xd2,0x23,0x09,0x01,0x00,0x1a,0x00,0x89,0xd2,0x22,0x0b,0x01,0x00,0x1b,0x00,0x89,0xd2,0x23,0x0b,0x01,0x00,0x1c,0x00,0x89,0xd2,0x22,0x0d,0x01
+,0x00,0x1d,0x00,0x89,0xd2,0x23,0x0d,0x01,0x00,0x1e,0x00,0x89,0xd2,0x22,0x0f,0x01,0x00,0x1f,0x00,0x89,0xd2,0x23,0x0f,0x01,0x00,0x7f,0x00,0x8c,0xbf,0x04,0x1e,0x8c
+,0xbe,0x08,0x0a,0x9c,0xd8,0x29,0x3c,0x3e,0x00,0x0c,0x0e,0x9c,0xd8,0x29,0x40,0x42,0x00,0x10,0x12,0x9c,0xd8,0x29,0x44,0x46,0x00,0x14,0x16,0x9c,0xd8,0x29,0x48,0x4a
+,0x00,0x1c,0x00,0x8a,0xd2,0x10,0x00,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x11,0x00,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x12,0x02,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x13,0x02,0x01
+,0x00,0x1c,0x00,0x8a,0xd2,0x14,0x04,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x15,0x04,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x16,0x06,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x17,0x06,0x01
+,0x00,0x1c,0x00,0x8a,0xd2,0x18,0x08,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x19,0x08,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x1a,0x0a,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1b,0x0a,0x01
+,0x00,0x1c,0x00,0x8a,0xd2,0x1c,0x0c,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1d,0x0c,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x1e,0x0e,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1f,0x0e,0x01
+,0x00,0x24,0x01,0xfe,0xbe,0x00,0x00,0x9a,0xd8,0x11,0x1c,0x00,0x00,0x7f,0x00,0x8c,0xbf,0x1c,0x2b,0x2a,0x2a,0x1d,0x2d,0x2c,0x2a,0x00,0x00,0x6c,0xd8,0x07,0x00,0x00
+,0x1c,0x00,0x00,0x6c,0xd8,0x08,0x00,0x00,0x1d,0x00,0x00,0x9a,0xd8,0x11,0x15,0x00,0x00,0x7f,0x01,0x8c,0xbf,0x08,0x10,0xee,0xd8,0x11,0x00,0x00,0x1e,0x1c,0x4b,0x14
+,0x2a,0x7f,0x00,0x8c,0xbf,0x20,0x3d,0x3c,0x2a,0x21,0x3f,0x3e,0x2a,0x0a,0x3b,0x14,0x2a,0x00,0x00,0x74,0xdc,0x1a,0x15,0x00,0x00,0xff,0x14,0x14,0x26,0xc0,0xff,0xff
+,0x7f,0x00,0x00,0x74,0xdc,0x17,0x1e,0x00,0x00,0x02,0x80,0x06,0xbf,0x06,0x00,0x85,0xbf,0x02,0x81,0x82,0x81,0x24,0x03,0x4a,0x7e,0x80,0x02,0x2e,0x7e,0x0a,0x03,0x48
+,0x7e,0x80,0x02,0x14,0x7e,0x5d,0xff,0x82,0xbf,0x12,0x03,0x00,0x32,0x01,0x6a,0x1c,0xd1,0x04,0x01,0xa9,0x01,0x00,0x00,0x74,0xdc,0x00,0x15,0x00,0x00,0x00,0x6a,0x19
+,0xd1,0x00,0x81,0x01,0x00,0x01,0x6a,0x1c,0xd1,0x01,0x01,0xa9,0x01,0x00,0x00,0x74,0xdc,0x00,0x1e,0x00,0x00,0x00,0x6a,0x19,0xd1,0x00,0x81,0x01,0x00,0x01,0x6a,0x1c
+,0xd1,0x01,0x01,0xa9,0x01,0x00,0x00,0x74,0xdc,0x00,0x20,0x00,0x00,0x40,0x02,0x00,0x7e,0x41,0x02,0x02,0x7e,0x42,0x02,0x04,0x7e,0x00,0x00,0x70,0xdc,0x00,0x02,0x00
+,0x00,0x00,0x00,0x81,0xbf,0x81,0x08,0x43,0xb9,0x44,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x89,0x02,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9,0x62,0x34,0x1c,0x03,0x5c
+,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00,0xcc
+,0xd1,0x2a,0x55,0x12,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x44,0x89,0x00,0x00,0x2a,0x03,0x88,0x7e,0x2b,0x03,0x8a
+,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x46,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x8d,0x02,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9,0x62
+,0x34,0x1c,0x03,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d,0xc2
+,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55,0x1a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x46,0x89,0x00,0x00,0x2a,0x03,0x8c
+,0x7e,0x2b,0x03,0x8e,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x48,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x91,0x02,0x00,0x1c,0x03,0x60
+,0x7e,0x1d,0xa9,0x62,0x34,0x1c,0x03,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc
+,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55,0x22,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x48,0x89,0x00
+,0x00,0x2a,0x03,0x90,0x7e,0x2b,0x03,0x92,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x4a,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x95,0x02
+,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9,0x62,0x34,0x1c,0x03,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa
+,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55,0x2a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13
+,0xd0,0x4a,0x89,0x00,0x00,0x2a,0x03,0x94,0x7e,0x2b,0x03,0x96,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x9b,0x3a,0x26,0x1d,0x9f,0x3a
+,0x28,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x44,0x61,0x02
+,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x12,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x12,0x05,0x0e,0x00,0x72
+,0xd0,0x44,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x88,0x7e,0x51,0x03,0x8a,0x7e,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38
+,0x28,0x1d,0x9b,0x3a,0x26,0x1d,0x9f,0x3a,0x28,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2
+,0x04,0x50,0x00,0x81,0xd2,0x46,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x1a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf
+,0xd1,0x2a,0x39,0x1a,0x05,0x0e,0x00,0x72,0xd0,0x46,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x8c,0x7e,0x51,0x03,0x8e
+,0x7e,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x9b,0x3a,0x26,0x1d,0x9f,0x3a,0x28,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca
+,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x48,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x22,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc
+,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x22,0x05,0x0e,0x00,0x72,0xd0,0x48,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe
+,0xbe,0x50,0x03,0x90,0x7e,0x51,0x03,0x92,0x7e,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x9b,0x3a,0x26,0x1d,0x9f,0x3a,0x28,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60
+,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x4a,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x2a
+,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x2a,0x05,0x0e,0x00,0x72,0xd0,0x4a,0x39,0x02,0x00,0x80,0x02,0xa0
+,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x94,0x7e,0x51,0x03,0x96,0x7e,0x3c,0x1d,0x80,0xbe,0x81,0x01,0xfe,0xbe,0x0e,0x02,0x5a,0x7e,0x28,0x00,0x86
+,0xd2,0x26,0x5a,0x02,0x00,0x0f,0x02,0x5e,0x7e,0x2a,0x20,0xe8,0xd1,0x26,0x5e,0xa2,0x04,0x2a,0x03,0x50,0x7e,0x2d,0x20,0xe8,0xd1,0x27,0x5a,0xa2,0x04,0x2a,0x20,0xe8
+,0xd1,0x27,0x5e,0xae,0x04,0x2a,0x5d,0x54,0x32,0x80,0x56,0x56,0x38,0x20,0x00,0x89,0xd2,0x2a,0x01,0x01,0x00,0x21,0x00,0x89,0xd2,0x2b,0x01,0x01,0x00,0x0f,0x80,0x04
+,0xbf,0x26,0x80,0xa2,0x85,0x20,0x22,0xa0,0x80,0x21,0x23,0xa1,0x82,0x27,0x80,0x04,0xbf,0x0e,0x80,0xa2,0x85,0x20,0x22,0x8e,0x80,0x21,0x23,0x8f,0x82,0x83,0x01,0xfe
+,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x01,0xfe,0xbe,0x26,0x02,0x5a,0x7e,0x28,0x00,0x86,0xd2,0x0e,0x5a,0x02,0x00,0x27,0x02,0x5e,0x7e,0x2a,0x20,0xe8,0xd1,0x0e,0x5e,0xa2
+,0x04,0x2a,0x03,0x50,0x7e,0x2d,0x20,0xe8,0xd1,0x0f,0x5a,0xa2,0x04,0x2a,0x20,0xe8,0xd1,0x0f,0x5e,0xae,0x04,0x2a,0x5d,0x54,0x32,0x80,0x56,0x56,0x38,0x0e,0x00,0x89
+,0xd2,0x2a,0x01,0x01,0x00,0x0f,0x00,0x89,0xd2,0x2b,0x01,0x01,0x00,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1a,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0xb4,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x03,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x2a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x0b,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa8,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x34,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x13,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0xc8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x19,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x07,0x00,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00
+,0x00,0xb4,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x22,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb8,0x0d,0x00,0x00,0x00,0x00,0x00
+,0x00,0x48,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0b,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x72
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x43,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x13,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb8
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x48,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1b,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x27
+,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x3b,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2c,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x62
+,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+const int randomx_run_gfx803_bin_size=6568;

src/backend/opencl/cl/rx/randomx_run_gfx900.asm

@@ -0,0 +1,688 @@
+/*
+Copyright (c) 2019 SChernykh
+
+This file is part of RandomX OpenCL.
+
+RandomX OpenCL is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+RandomX OpenCL is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with RandomX OpenCL. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+.amdcl2
+.gpu GFX900
+.64bit
+.arch_minor 0
+.arch_stepping 0
+.driver_version 223600
+.kernel randomx_run
+	.config
+		.dims x
+		.cws 64, 1, 1
+		.sgprsnum 96
+		# 6 waves per SIMD: 37-40 VGPRs
+		# 5 waves per SIMD: 41-48 VGPRs
+		# 4 waves per SIMD: 49-64 VGPRs
+		# 3 waves per SIMD: 65-84 VGPRs
+		# 2 waves per SIMD: 85-128 VGPRs
+		# 1 wave  per SIMD: 129-256 VGPRs
+		.vgprsnum 128
+		.localsize 256
+		.floatmode 0xc0
+		.pgmrsrc1 0x00ac035f
+		.pgmrsrc2 0x00000090
+		.dx10clamp
+		.ieeemode
+		.useargs
+		.priority 0
+		.arg _.global_offset_0, "size_t", long
+		.arg _.global_offset_1, "size_t", long
+		.arg _.global_offset_2, "size_t", long
+		.arg _.printf_buffer, "size_t", void*, global, , rdonly
+		.arg _.vqueue_pointer, "size_t", long
+		.arg _.aqlwrap_pointer, "size_t", long
+		.arg dataset, "uchar*", uchar*, global, const, rdonly
+		.arg scratchpad, "uchar*", uchar*, global, 
+		.arg registers, "ulong*", ulong*, global, 
+		.arg rounding_modes, "uint*", uint*, global,
+		.arg programs, "uint*", uint*, global, 
+		.arg batch_size, "uint", uint
+		.arg rx_parameters, "uint", uint
+	.text
+		s_mov_b32       m0, 0x10000
+		s_dcache_wb
+		s_waitcnt       vmcnt(0) & lgkmcnt(0)
+		s_icache_inv
+		s_branch begin
+
+		# pgmrsrc2 = 0x00000090, bits 1:5 = 8, so first 8 SGPRs (s0-s7) contain user data
+		# s8 contains group id
+		# v0 contains local id
+begin:
+		v_lshl_add_u32  v1, s8, 6, v0
+		s_load_dwordx2  s[0:1], s[4:5], 0x0
+		s_load_dwordx2  s[2:3], s[4:5], 0x40
+		s_load_dwordx2  s[64:65], s[4:5], 0x48
+		s_waitcnt       lgkmcnt(0)
+
+		# load rounding mode
+		s_lshl_b32      s16, s8, 2
+		s_add_u32       s64, s64, s16
+		s_addc_u32      s65, s65, 0
+		v_mov_b32       v8, 0
+		global_load_dword v8, v8, s[64:65]
+		s_waitcnt       vmcnt(0)
+		v_readlane_b32  s66, v8, 0
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		s_mov_b32       s67, 0
+
+		# used in FSQRT_R to check for "positive normal value" (v_cmpx_class_f64)
+		s_mov_b32       s68, 256
+		s_mov_b32       s69, 0
+
+		v_add_u32       v1, s0, v1
+		v_lshrrev_b32   v2, 6, v1
+		v_lshlrev_b32   v3, 5, v2
+		v_and_b32       v1, 63, v1
+		v_mov_b32       v4, 0
+		v_lshlrev_b64   v[3:4], 3, v[3:4]
+		v_lshlrev_b32   v5, 4, v1
+		v_add_co_u32    v3, vcc, s2, v3
+		v_mov_b32       v6, s3
+		v_addc_co_u32   v4, vcc, v6, v4, vcc
+		v_lshlrev_b32   v41, 2, v1
+		v_add_co_u32    v6, vcc, v3, v41
+		v_addc_co_u32   v7, vcc, v4, 0, vcc
+		global_load_dword v6, v[6:7], off
+		v_mov_b32       v0, 0
+		s_waitcnt       vmcnt(0)
+		ds_write_b32    v41, v6
+		s_waitcnt       lgkmcnt(0)
+		s_mov_b64       s[0:1], exec
+		v_cmpx_le_u32   s[2:3], v1, 7
+		s_cbranch_execz program_end
+
+		# rx_parameters
+		s_load_dword    s20, s[4:5], 0x5c
+		s_waitcnt       lgkmcnt(0)
+
+		# Scratchpad L1 size
+		s_bfe_u32       s21, s20, 0x050000
+		s_lshl_b32      s21, 1, s21
+
+		# Scratchpad L2 size
+		s_bfe_u32       s22, s20, 0x050005
+		s_lshl_b32      s22, 1, s22
+
+		# Scratchpad L3 size
+		s_bfe_u32       s23, s20, 0x05000A
+		s_lshl_b32      s23, 1, s23
+
+		# program iterations
+		s_bfe_u32       s24, s20, 0x04000F
+		s_lshl_b32      s24, 1, s24
+
+		# Base address for scratchpads
+		s_add_u32       s2, s23, 64
+		v_mul_hi_u32    v20, v2, s2
+		v_mul_lo_u32    v2, v2, s2
+
+		# v41, v44 = 0
+		v_mov_b32       v41, 0
+		v_mov_b32       v44, 0
+
+		ds_read_b32     v6, v0 offset:152
+		v_cmp_lt_u32    s[2:3], v1, 4
+		ds_read2_b64    v[34:37], v0 offset0:18 offset1:16
+		ds_read_b64     v[11:12], v0 offset:136
+		s_movk_i32      s9, 0x0
+		s_mov_b64       s[6:7], exec
+		s_andn2_b64     exec, s[6:7], s[2:3]
+		ds_read_b64     v[13:14], v0 offset:160
+		s_andn2_b64     exec, s[6:7], exec
+		v_mov_b32       v13, 0
+		v_mov_b32       v14, 0
+		s_mov_b64       exec, s[6:7]
+
+		# compiled program size
+		s_mov_b64       s[6:7], s[8:9]
+		s_mulk_i32      s6, 10048
+
+		v_add3_u32      v5, v0, v5, 64
+		s_mov_b64       s[8:9], exec
+		s_andn2_b64     exec, s[8:9], s[2:3]
+		ds_read_b64     v[15:16], v0 offset:168
+		s_andn2_b64     exec, s[8:9], exec
+		v_mov_b32       v15, 0
+		v_mov_b32       v16, 0
+		s_mov_b64       exec, s[8:9]
+		s_load_dwordx4  s[8:11], s[4:5], 0x30
+
+		# batch_size
+		s_load_dword    s16, s[4:5], 0x58
+
+		s_load_dwordx2  s[4:5], s[4:5], 0x50
+		v_lshlrev_b32   v1, 3, v1
+		v_add_u32       v17, v0, v1
+		s_waitcnt       lgkmcnt(0)
+		v_add_co_u32    v2, vcc, s10, v2
+		v_mov_b32       v18, s11
+		v_addc_co_u32   v18, vcc, v18, v20, vcc
+		v_mov_b32       v19, 0xffffff
+		v_add_co_u32    v6, vcc, s8, v6
+		v_mov_b32       v20, s9
+		v_addc_co_u32   v20, vcc, v20, 0, vcc
+		ds_read_b64     v[21:22], v17
+		s_add_u32       s4, s4, s6
+		s_addc_u32      s5, s5, s7
+		v_cndmask_b32   v19, v19, -1, s[2:3]
+		v_lshl_add_u32  v8, v35, 3, v0
+		v_lshl_add_u32  v7, v34, 3, v0
+		v_lshl_add_u32  v12, v12, 3, v0
+		v_lshl_add_u32  v0, v11, 3, v0
+		v_mov_b32       v10, v36
+		v_mov_b32       v23, v37
+
+		# loop counter
+		s_sub_u32       s2, s24, 1
+
+		# batch_size
+		s_mov_b32       s3, s16
+
+		# Scratchpad masks for scratchpads
+		v_sub_u32       v38, s21, 8
+		v_sub_u32       v39, s22, 8
+		v_sub_u32       v50, s23, 8
+
+		# mask for FSCAL_R
+		v_mov_b32       v51, 0x80F00000
+
+		# load scratchpad base address
+		v_readlane_b32	s0, v2, 0
+		v_readlane_b32	s1, v18, 0
+
+		# save current executiom mask
+		s_mov_b64       s[36:37], exec
+
+		# v41 = 0 on lane 0, set it to 8 on lane 1
+		# v44 = 0 on lane 0, set it to 4 on lane 1
+		s_mov_b64       exec, 2
+		v_mov_b32       v41, 8
+		v_mov_b32       v44, 4
+
+		# load group A registers
+		# Read low 8 bytes into lane 0 and high 8 bytes into lane 1
+		s_mov_b64       exec, 3
+		ds_read2_b64    v[52:55], v41 offset0:24 offset1:26
+		ds_read2_b64    v[56:59], v41 offset0:28 offset1:30
+
+		# xmantissaMask
+		v_mov_b32       v77, (1 << 24) - 1
+
+		# xexponentMask
+		ds_read_b64     v[78:79], v41 offset:160
+
+		# Restore execution mask
+		s_mov_b64       exec, s[36:37]
+
+		# sign mask (used in FSQRT_R)
+		v_mov_b32       v82, 0x80000000
+
+		# High 32 bits of "1.0" constant (used in FDIV_M)
+		v_mov_b32       v83, (1023 << 20)
+
+		# Used to multiply FP64 values by 0.5
+		v_mov_b32       v84, (1 << 20)
+
+		s_getpc_b64 s[14:15]
+cur_addr:
+
+		# get addresses of FSQRT_R subroutines
+		s_add_u32       s40, s14, fsqrt_r_sub0 - cur_addr
+		s_addc_u32      s41, s15, 0
+		s_add_u32       s42, s14, fsqrt_r_sub1 - cur_addr
+		s_addc_u32      s43, s15, 0
+		s_add_u32       s44, s14, fsqrt_r_sub2 - cur_addr
+		s_addc_u32      s45, s15, 0
+		s_add_u32       s46, s14, fsqrt_r_sub3 - cur_addr
+		s_addc_u32      s47, s15, 0
+
+		# get addresses of FDIV_M subroutines
+		s_add_u32       s48, s14, fdiv_m_sub0 - cur_addr
+		s_addc_u32      s49, s15, 0
+		s_add_u32       s50, s14, fdiv_m_sub1 - cur_addr
+		s_addc_u32      s51, s15, 0
+		s_add_u32       s52, s14, fdiv_m_sub2 - cur_addr
+		s_addc_u32      s53, s15, 0
+		s_add_u32       s54, s14, fdiv_m_sub3 - cur_addr
+		s_addc_u32      s55, s15, 0
+
+		# get address for ISMULH_R subroutine
+		s_add_u32       s56, s14, ismulh_r_sub - cur_addr
+		s_addc_u32      s57, s15, 0
+
+		# get address for IMULH_R subroutine
+		s_add_u32       s58, s14, imulh_r_sub - cur_addr
+		s_addc_u32      s59, s15, 0
+
+		# used in IXOR_R instruction
+		s_mov_b32       s63, -1
+
+		# used in CBRANCH instruction
+		s_mov_b32       s70, (0xFF << 8)
+		s_mov_b32       s71, (0xFF << 9)
+		s_mov_b32       s72, (0xFF << 10)
+		s_mov_b32       s73, (0xFF << 11)
+		s_mov_b32       s74, (0xFF << 12)
+		s_mov_b32       s75, (0xFF << 13)
+		s_mov_b32       s76, (0xFF << 14)
+		s_mov_b32       s77, (0xFF << 15)
+		s_mov_b32       s78, (0xFF << 16)
+		s_mov_b32       s79, (0xFF << 17)
+		s_mov_b32       s80, (0xFF << 18)
+		s_mov_b32       s81, (0xFF << 19)
+		s_mov_b32       s82, (0xFF << 20)
+		s_mov_b32       s83, (0xFF << 21)
+		s_mov_b32       s84, (0xFF << 22)
+		s_mov_b32       s85, (0xFF << 23)
+
+		# ScratchpadL3Mask64
+		s_sub_u32       s86, s23, 64
+
+main_loop:
+		# const uint2 spMix = as_uint2(R[readReg0] ^ R[readReg1]);
+		ds_read_b64     v[24:25], v0
+		ds_read_b64     v[26:27], v12
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v25, v27, v25
+		v_xor_b32       v24, v26, v24
+
+		# spAddr1 ^= spMix.y;
+		# spAddr0 ^= spMix.x;
+		v_xor_b32       v10, v25, v10
+		v_xor_b32       v23, v24, v23
+
+		# spAddr1 &= ScratchpadL3Mask64;
+		# spAddr0 &= ScratchpadL3Mask64;
+		v_and_b32       v10, s86, v10
+		v_and_b32       v23, s86, v23
+
+		# Offset for scratchpads
+		# offset1 = spAddr1 + sub * 8
+		# offset0 = spAddr0 + sub * 8
+		v_add_u32       v10, v10, v1
+		v_add_u32       v23, v23, v1
+
+		# __global ulong* p1 = (__global ulong*)(scratchpad + offset1);
+		# __global ulong* p0 = (__global ulong*)(scratchpad + offset0);
+		v_add_co_u32    v26, vcc, v2, v10
+		v_addc_co_u32   v27, vcc, v18, 0, vcc
+		v_add_co_u32    v23, vcc, v2, v23
+		v_addc_co_u32   v24, vcc, v18, 0, vcc
+
+		# load from spAddr1
+		global_load_dwordx2 v[28:29], v[26:27], off
+
+		# load from spAddr0
+		global_load_dwordx2 v[30:31], v[23:24], off
+		s_waitcnt       vmcnt(1)
+
+		v_cvt_f64_i32   v[32:33], v28
+		v_cvt_f64_i32   v[28:29], v29
+		s_waitcnt       vmcnt(0)
+
+		# R[sub] ^= *p0;
+		v_xor_b32       v34, v21, v30
+		v_xor_b32       v35, v22, v31
+
+		v_add_co_u32    v22, vcc, v6, v36
+		v_addc_co_u32   v25, vcc, v20, 0, vcc
+		v_add_co_u32    v21, vcc, v22, v1
+		v_addc_co_u32   v22, vcc, v25, 0, vcc
+		global_load_dwordx2 v[21:22], v[21:22], off
+		v_or_b32        v30, v32, v13
+		v_and_or_b32    v31, v33, v19, v14
+		v_or_b32        v28, v28, v15
+		v_and_or_b32    v29, v29, v19, v16
+		ds_write2_b64   v5, v[30:31], v[28:29] offset1:1
+		s_waitcnt       lgkmcnt(0)
+
+		# Program 0
+
+		# load group F,E registers
+		# Read low 8 bytes into lane 0 and high 8 bytes into lane 1
+		s_mov_b64       exec, 3
+		ds_read2_b64    v[60:63], v41 offset0:8 offset1:10
+		ds_read2_b64    v[64:67], v41 offset0:12 offset1:14
+		ds_read2_b64    v[68:71], v41 offset0:16 offset1:18
+		ds_read2_b64    v[72:75], v41 offset0:20 offset1:22
+
+		# load VM integer registers
+		v_readlane_b32	s16, v34, 0
+		v_readlane_b32	s17, v35, 0
+		v_readlane_b32	s18, v34, 1
+		v_readlane_b32	s19, v35, 1
+		v_readlane_b32	s20, v34, 2
+		v_readlane_b32	s21, v35, 2
+		v_readlane_b32	s22, v34, 3
+		v_readlane_b32	s23, v35, 3
+		v_readlane_b32	s24, v34, 4
+		v_readlane_b32	s25, v35, 4
+		v_readlane_b32	s26, v34, 5
+		v_readlane_b32	s27, v35, 5
+		v_readlane_b32	s28, v34, 6
+		v_readlane_b32	s29, v35, 6
+		v_readlane_b32	s30, v34, 7
+		v_readlane_b32	s31, v35, 7
+
+		s_waitcnt       lgkmcnt(0)
+
+		# call JIT code
+		s_swappc_b64    s[12:13], s[4:5]
+
+		# Write out group F,E registers
+		# Write low 8 bytes from lane 0 and high 8 bytes from lane 1
+		ds_write2_b64   v41, v[60:61], v[62:63] offset0:8 offset1:10
+		ds_write2_b64   v41, v[64:65], v[66:67] offset0:12 offset1:14
+		ds_write2_b64   v41, v[68:69], v[70:71] offset0:16 offset1:18
+		ds_write2_b64   v41, v[72:73], v[74:75] offset0:20 offset1:22
+
+		# store VM integer registers
+		v_writelane_b32 v28, s16, 0
+		v_writelane_b32 v29, s17, 0
+		v_writelane_b32 v28, s18, 1
+		v_writelane_b32 v29, s19, 1
+		v_writelane_b32 v28, s20, 2
+		v_writelane_b32 v29, s21, 2
+		v_writelane_b32 v28, s22, 3
+		v_writelane_b32 v29, s23, 3
+		v_writelane_b32 v28, s24, 4
+		v_writelane_b32 v29, s25, 4
+		v_writelane_b32 v28, s26, 5
+		v_writelane_b32 v29, s27, 5
+		v_writelane_b32 v28, s28, 6
+		v_writelane_b32 v29, s29, 6
+		v_writelane_b32 v28, s30, 7
+		v_writelane_b32 v29, s31, 7
+
+		# Restore execution mask
+		s_mov_b64       exec, s[36:37]
+
+		# Write out VM integer registers
+		ds_write_b64    v17, v[28:29]
+
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v21, v28, v21
+		v_xor_b32       v22, v29, v22
+		ds_read_b32     v28, v7
+		ds_read_b32     v29, v8
+		ds_write_b64    v17, v[21:22]
+		s_waitcnt       lgkmcnt(1)
+		ds_read2_b64    v[30:33], v17 offset0:8 offset1:16
+		v_xor_b32       v10, v28, v37
+		s_waitcnt       lgkmcnt(0)
+		v_xor_b32       v30, v32, v30
+		v_xor_b32       v31, v33, v31
+		v_xor_b32       v10, v10, v29
+		global_store_dwordx2 v[26:27], v[21:22], off
+		v_and_b32       v10, 0x7fffffc0, v10
+		global_store_dwordx2 v[23:24], v[30:31], off
+		s_cmp_eq_u32    s2, 0
+		s_cbranch_scc1  main_loop_end
+		s_sub_i32       s2, s2, 1
+		v_mov_b32       v37, v36
+		v_mov_b32       v23, 0
+		v_mov_b32       v36, v10
+		v_mov_b32       v10, 0
+		s_branch        main_loop
+main_loop_end:
+
+		v_add_co_u32    v0, vcc, v3, v1
+		v_addc_co_u32   v1, vcc, v4, 0, vcc
+		global_store_dwordx2 v[0:1], v[21:22], off
+		global_store_dwordx2 v[0:1], v[30:31], off inst_offset:64
+		global_store_dwordx2 v[0:1], v[32:33], off inst_offset:128
+
+		# store rounding mode
+		v_mov_b32       v0, 0
+		v_mov_b32       v1, s66
+		global_store_dword v0, v1, s[64:65]
+
+program_end:
+		s_endpgm
+
+fsqrt_r_sub0:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[68:69]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[68:69]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[68:69]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[68:69]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[68:69], s[68:69]
+		v_mov_b32       v68, v42
+		v_mov_b32       v69, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub1:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[70:71]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[70:71]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[70:71]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[70:71]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[70:71], s[68:69]
+		v_mov_b32       v70, v42
+		v_mov_b32       v71, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub2:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[72:73]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[72:73]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[72:73]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[72:73]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[72:73], s[68:69]
+		v_mov_b32       v72, v42
+		v_mov_b32       v73, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fsqrt_r_sub3:
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rsq_f64       v[28:29], v[74:75]
+
+		# Improve initial approximation (can be skipped)
+		#v_mul_f64       v[42:43], v[28:29], v[74:75]
+		#v_mul_f64       v[48:49], v[28:29], -0.5
+		#v_fma_f64       v[48:49], v[48:49], v[42:43], 0.5
+		#v_fma_f64       v[28:29], v[28:29], v[48:49], v[28:29]
+
+		v_mul_f64       v[42:43], v[28:29], v[74:75]
+		v_mov_b32       v48, v28
+		v_sub_u32       v49, v29, v84
+		v_mov_b32       v46, v28
+		v_xor_b32       v47, v49, v82
+		v_fma_f64       v[46:47], v[46:47], v[42:43], 0.5
+		v_fma_f64       v[42:43], v[42:43], v[46:47], v[42:43]
+		v_fma_f64       v[48:49], v[48:49], v[46:47], v[48:49]
+		v_fma_f64       v[46:47], -v[42:43], v[42:43], v[74:75]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64       v[42:43], v[46:47], v[48:49], v[42:43]
+		v_cmpx_class_f64 s[14:15], v[74:75], s[68:69]
+		v_mov_b32       v74, v42
+		v_mov_b32       v75, v43
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub0:
+		v_or_b32        v28, v28, v78
+		v_and_or_b32    v29, v29, v77, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[68:69], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[68:69]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[68:69]
+		v_cmpx_eq_f64   s[14:15], v[68:69], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v68, v80
+		v_mov_b32       v69, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub1:
+		v_or_b32        v28, v28, v78
+		v_and_or_b32    v29, v29, v77, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[70:71], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[70:71]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[70:71]
+		v_cmpx_eq_f64   s[14:15], v[70:71], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v70, v80
+		v_mov_b32       v71, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub2:
+		v_or_b32        v28, v28, v78
+		v_and_or_b32    v29, v29, v77, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[72:73], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[72:73]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[72:73]
+		v_cmpx_eq_f64   s[14:15], v[72:73], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v72, v80
+		v_mov_b32       v73, v81
+		s_setpc_b64     s[60:61]
+
+fdiv_m_sub3:
+		v_or_b32        v28, v28, v78
+		v_and_or_b32    v29, v29, v77, v79
+		s_setreg_b32    hwreg(mode, 2, 2), s67
+		v_rcp_f64       v[48:49], v[28:29]
+		v_fma_f64       v[80:81], -v[28:29], v[48:49], 1.0
+		v_fma_f64       v[48:49], v[48:49], v[80:81], v[48:49]
+		v_mul_f64       v[80:81], v[74:75], v[48:49]
+		v_fma_f64       v[42:43], -v[28:29], v[80:81], v[74:75]
+		s_setreg_b32    hwreg(mode, 2, 2), s66
+		v_fma_f64  v[42:43], v[42:43], v[48:49], v[80:81]
+		v_div_fixup_f64 v[80:81], v[42:43], v[28:29], v[74:75]
+		v_cmpx_eq_f64   s[14:15], v[74:75], v[28:29]
+		v_mov_b32 v80, 0
+		v_mov_b32 v81, v83
+		s_mov_b64       exec, 3
+		v_mov_b32       v74, v80
+		v_mov_b32       v75, v81
+		s_setpc_b64     s[60:61]
+
+ismulh_r_sub:
+		s_mov_b64       exec, 1
+		v_mov_b32       v45, s14
+		v_mul_hi_u32    v40, s38, v45
+		v_mov_b32       v47, s15
+		v_mad_u64_u32   v[42:43], s[32:33], s38, v47, v[40:41]
+		v_mov_b32       v40, v42
+		v_mad_u64_u32   v[45:46], s[32:33], s39, v45, v[40:41]
+		v_mad_u64_u32   v[42:43], s[32:33], s39, v47, v[43:44]
+		v_add_co_u32    v42, vcc, v42, v46
+		v_addc_co_u32   v43, vcc, 0, v43, vcc
+		v_readlane_b32  s32, v42, 0
+		v_readlane_b32  s33, v43, 0
+		s_cmp_lt_i32    s15, 0
+		s_cselect_b64   s[34:35], s[38:39], 0
+		s_sub_u32       s32, s32, s34
+		s_subb_u32      s33, s33, s35
+		s_cmp_lt_i32    s39, 0
+		s_cselect_b64   s[34:35], s[14:15], 0
+		s_sub_u32       s14, s32, s34
+		s_subb_u32      s15, s33, s35
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]
+
+imulh_r_sub:
+		s_mov_b64       exec, 1
+		v_mov_b32       v45, s38
+		v_mul_hi_u32    v40, s14, v45
+		v_mov_b32       v47, s39
+		v_mad_u64_u32   v[42:43], s[32:33], s14, v47, v[40:41]
+		v_mov_b32       v40, v42
+		v_mad_u64_u32   v[45:46], s[32:33], s15, v45, v[40:41]
+		v_mad_u64_u32   v[42:43], s[32:33], s15, v47, v[43:44]
+		v_add_co_u32    v42, vcc, v42, v46
+		v_addc_co_u32   v43, vcc, 0, v43, vcc
+		v_readlane_b32  s14, v42, 0
+		v_readlane_b32  s15, v43, 0
+		s_mov_b64       exec, 3
+		s_setpc_b64     s[60:61]

src/backend/opencl/cl/rx/randomx_run_gfx900.h

@@ -0,0 +1,215 @@
+/*
+This file was auto-generated from randomx_run_gfx900.asm:
+
+clrxasm randomx_run_gfx900.asm -o randomx_run_gfx900.bin
+bin2h -c randomx_run_gfx900_bin < randomx_run_gfx900.bin > randomx_run_gfx900.h
+
+clrxasm can be downloaded here: https://github.com/CLRX/CLRX-mirror/releases
+bin2h can be downloaded here: http://www.deadnode.org/sw/bin2h/
+*/
+
+static unsigned char randomx_run_gfx900_bin[]={
+0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x5b,0xaf,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0x17,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x07,0x00,0x01,0x00,0x00
+,0x2e,0x73,0x68,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x73,0x79,0x6d,0x74,0x61,0x62,0x00,0x2e,0x63,0x6f,0x6d,0x6d,0x65
+,0x6e,0x74,0x00,0x2e,0x72,0x6f,0x64,0x61,0x74,0x61,0x00,0x2e,0x74,0x65,0x78,0x74,0x00,0x00,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x26,0x5f,0x5f,0x4f,0x70
+,0x65,0x6e,0x43,0x4c,0x5f,0x72,0x61,0x6e,0x64,0x6f,0x6d,0x78,0x5f,0x72,0x75,0x6e,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x5f,0x6d,0x65,0x74,0x61,0x64,0x61,0x74,0x61
+,0x00,0x61,0x63,0x6c,0x5f,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x5f,0x73,0x74,0x72,0x69,0x6e,0x67,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38
+,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x01,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41
+,0x4d,0x44,0x2d,0x43,0x4f,0x4d,0x50,0x2d,0x4c,0x49,0x42,0x2d,0x76,0x30,0x2e,0x38,0x20,0x28,0x30,0x2e,0x30,0x2e,0x53,0x43,0x5f,0x42,0x55,0x49,0x4c,0x44,0x5f,0x4e
+,0x55,0x4d,0x42,0x45,0x52,0x29,0x10,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x68,0x00
+,0x00,0x00,0x24,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x40,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x64
+,0x75,0x6d,0x6d,0x79,0x5f,0x6b,0x65,0x72,0x6e,0x65,0x6c,0x00,0x47,0x46,0x58,0x39,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x05,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x40,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x11,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x50,0x00,0x00,0x00,0x05,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00
+,0x00,0x00,0x04,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x80,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x09,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x90,0x00,0x00,0x00,0x07,0x00
+,0x00,0x00,0x04,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0xa0,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x08,0x00
+,0x00,0x00,0x04,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0xb0,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x58,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0d,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0xc0,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x5f,0x2e,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,0x5f,0x30,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x67,0x6c,0x6f
+,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66,0x73,0x65,0x74,0x5f,0x31,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x67,0x6c,0x6f,0x62,0x61,0x6c,0x5f,0x6f,0x66,0x66
+,0x73,0x65,0x74,0x5f,0x32,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x70,0x72,0x69,0x6e,0x74,0x66,0x5f,0x62,0x75,0x66,0x66,0x65,0x72,0x00,0x73,0x69,0x7a
+,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x76,0x71,0x75,0x65,0x75,0x65,0x5f,0x70,0x6f,0x69,0x6e,0x74,0x65,0x72,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x5f,0x2e,0x61,0x71
+,0x6c,0x77,0x72,0x61,0x70,0x5f,0x70,0x6f,0x69,0x6e,0x74,0x65,0x72,0x00,0x73,0x69,0x7a,0x65,0x5f,0x74,0x00,0x64,0x61,0x74,0x61,0x73,0x65,0x74,0x00,0x75,0x63,0x68
+,0x61,0x72,0x2a,0x00,0x73,0x63,0x72,0x61,0x74,0x63,0x68,0x70,0x61,0x64,0x00,0x75,0x63,0x68,0x61,0x72,0x2a,0x00,0x72,0x65,0x67,0x69,0x73,0x74,0x65,0x72,0x73,0x00
+,0x75,0x6c,0x6f,0x6e,0x67,0x2a,0x00,0x72,0x6f,0x75,0x6e,0x64,0x69,0x6e,0x67,0x5f,0x6d,0x6f,0x64,0x65,0x73,0x00,0x75,0x69,0x6e,0x74,0x2a,0x00,0x70,0x72,0x6f,0x67
+,0x72,0x61,0x6d,0x73,0x00,0x75,0x69,0x6e,0x74,0x2a,0x00,0x62,0x61,0x74,0x63,0x68,0x5f,0x73,0x69,0x7a,0x65,0x00,0x75,0x69,0x6e,0x74,0x00,0x72,0x78,0x5f,0x70,0x61
+,0x72,0x61,0x6d,0x65,0x74,0x65,0x72,0x73,0x00,0x75,0x69,0x6e,0x74,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0x45
+,0x4c,0x46,0x02,0x01,0x01,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0xe0,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x38,0x00,0x01,0x00,0x40,0x00,0x06,0x00,0x01,0x00,0x03,0x00
+,0x00,0x60,0x05,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x0b
+,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2e,0x73,0x68,0x73,0x74,0x72,0x74,0x61,0x62
+,0x00,0x2e,0x73,0x74,0x72,0x74,0x61,0x62,0x00,0x2e,0x6e,0x6f,0x74,0x65,0x00,0x2e,0x68,0x73,0x61,0x74,0x65,0x78,0x74,0x00,0x2e,0x73,0x79,0x6d,0x74,0x61,0x62,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x26,0x5f,0x5f,0x4f,0x70,0x65,0x6e,0x43,0x4c,0x5f,0x72,0x61,0x6e,0x64,0x6f,0x6d,0x78,0x5f,0x72,0x75,0x6e,0x5f,0x6b,0x65,0x72
+,0x6e,0x65,0x6c,0x00,0x5f,0x5f,0x68,0x73,0x61,0x5f,0x73,0x65,0x63,0x74,0x69,0x6f,0x6e,0x2e,0x68,0x73,0x61,0x74,0x65,0x78,0x74,0x00,0x00,0x00,0x00,0x00,0x04,0x00
+,0x00,0x00,0x08,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x0c,0x00,0x00,0x00,0x02,0x00
+,0x00,0x00,0x41,0x4d,0x44,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x01,0x00,0x04,0x00,0x00,0x00,0x1a,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x41,0x4d
+,0x44,0x00,0x04,0x00,0x07,0x00,0x09,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x41,0x4d,0x44,0x47,0x50,0x55,0x00,0x00,0x04,0x00
+,0x00,0x00,0x29,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x19,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x41,0x4d,0x44,0x20,0x48,0x53
+,0x41,0x20,0x52,0x75,0x6e,0x74,0x69,0x6d,0x65,0x20,0x46,0x69,0x6e,0x61,0x6c,0x69,0x7a,0x65,0x72,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x00,0x00,0x1a,0x00
+,0x00,0x00,0x05,0x00,0x00,0x00,0x41,0x4d,0x44,0x00,0x16,0x00,0x2d,0x68,0x73,0x61,0x5f,0x63,0x61,0x6c,0x6c,0x5f,0x63,0x6f,0x6e,0x76,0x65,0x6e,0x74,0x69,0x6f,0x6e
+,0x3d,0x30,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x03,0xac,0x00,0x90,0x00,0x00,0x00,0x29,0x00,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x01
+,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x62,0x00,0x80,0x00,0x80,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x04,0x04,0x04,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x00
+,0xfc,0xbe,0x00,0x00,0x01,0x00,0x00,0x00,0x84,0xc0,0x00,0x00,0x00,0x00,0x70,0x00,0x8c,0xbf,0x00,0x00,0x93,0xbf,0x00,0x00,0x82,0xbf,0x01,0x00,0xfd,0xd1,0x08,0x0c
+,0x01,0x04,0x02,0x00,0x06,0xc0,0x00,0x00,0x00,0x00,0x82,0x00,0x06,0xc0,0x40,0x00,0x00,0x00,0x02,0x10,0x06,0xc0,0x48,0x00,0x00,0x00,0x7f,0xc0,0x8c,0xbf,0x08,0x82
+,0x10,0x8e,0x40,0x10,0x40,0x80,0x41,0x80,0x41,0x82,0x80,0x02,0x10,0x7e,0x00,0x80,0x50,0xdc,0x08,0x00,0x40,0x08,0x70,0x0f,0x8c,0xbf,0x42,0x00,0x89,0xd2,0x08,0x01
+,0x01,0x00,0x81,0x08,0x42,0xb9,0x80,0x00,0xc3,0xbe,0xff,0x00,0xc4,0xbe,0x00,0x01,0x00,0x00,0x80,0x00,0xc5,0xbe,0x00,0x02,0x02,0x68,0x86,0x02,0x04,0x20,0x85,0x04
+,0x06,0x24,0xbf,0x02,0x02,0x26,0x80,0x02,0x08,0x7e,0x03,0x00,0x8f,0xd2,0x83,0x06,0x02,0x00,0x84,0x02,0x0a,0x24,0x02,0x06,0x06,0x32,0x03,0x02,0x0c,0x7e,0x06,0x09
+,0x08,0x38,0x82,0x02,0x52,0x24,0x03,0x53,0x0c,0x32,0x07,0x6a,0x1c,0xd1,0x04,0x01,0xa9,0x01,0x00,0x80,0x50,0xdc,0x06,0x00,0x7f,0x06,0x80,0x02,0x00,0x7e,0x70,0x0f
+,0x8c,0xbf,0x00,0x00,0x1a,0xd8,0x29,0x06,0x00,0x00,0x7f,0xc0,0x8c,0xbf,0x7e,0x01,0x80,0xbe,0x02,0x00,0xdb,0xd0,0x01,0x0f,0x01,0x00,0x68,0x01,0x88,0xbf,0x02,0x05
+,0x02,0xc0,0x5c,0x00,0x00,0x00,0x7f,0xc0,0x8c,0xbf,0x14,0xff,0x95,0x92,0x00,0x00,0x05,0x00,0x81,0x15,0x15,0x8e,0x14,0xff,0x96,0x92,0x05,0x00,0x05,0x00,0x81,0x16
+,0x16,0x8e,0x14,0xff,0x97,0x92,0x0a,0x00,0x05,0x00,0x81,0x17,0x17,0x8e,0x14,0xff,0x98,0x92,0x0f,0x00,0x04,0x00,0x81,0x18,0x18,0x8e,0x17,0xc0,0x02,0x80,0x14,0x00
+,0x86,0xd2,0x02,0x05,0x00,0x00,0x02,0x00,0x85,0xd2,0x02,0x05,0x00,0x00,0x80,0x02,0x52,0x7e,0x80,0x02,0x58,0x7e,0x98,0x00,0x6c,0xd8,0x00,0x00,0x00,0x06,0x02,0x00
+,0xc9,0xd0,0x01,0x09,0x01,0x00,0x12,0x10,0xee,0xd8,0x00,0x00,0x00,0x22,0x88,0x00,0xec,0xd8,0x00,0x00,0x00,0x0b,0x00,0x00,0x09,0xb0,0x7e,0x01,0x86,0xbe,0x06,0x02
+,0xfe,0x89,0xa0,0x00,0xec,0xd8,0x00,0x00,0x00,0x0d,0x06,0x7e,0xfe,0x89,0x80,0x02,0x1a,0x7e,0x80,0x02,0x1c,0x7e,0x06,0x01,0xfe,0xbe,0x08,0x01,0x86,0xbe,0x40,0x27
+,0x86,0xb7,0x05,0x00,0xff,0xd1,0x00,0x0b,0x02,0x03,0x7e,0x01,0x88,0xbe,0x08,0x02,0xfe,0x89,0xa8,0x00,0xec,0xd8,0x00,0x00,0x00,0x0f,0x08,0x7e,0xfe,0x89,0x80,0x02
+,0x1e,0x7e,0x80,0x02,0x20,0x7e,0x08,0x01,0xfe,0xbe,0x02,0x02,0x0a,0xc0,0x30,0x00,0x00,0x00,0x02,0x04,0x02,0xc0,0x58,0x00,0x00,0x00,0x02,0x01,0x06,0xc0,0x50,0x00
+,0x00,0x00,0x83,0x02,0x02,0x24,0x00,0x03,0x22,0x68,0x7f,0xc0,0x8c,0xbf,0x0a,0x04,0x04,0x32,0x0b,0x02,0x24,0x7e,0x12,0x29,0x24,0x38,0xff,0x02,0x26,0x7e,0xff,0xff
+,0xff,0x00,0x08,0x0c,0x0c,0x32,0x09,0x02,0x28,0x7e,0x14,0x6a,0x1c,0xd1,0x14,0x01,0xa9,0x01,0x00,0x00,0xec,0xd8,0x11,0x00,0x00,0x15,0x04,0x06,0x04,0x80,0x05,0x07
+,0x05,0x82,0x13,0x00,0x00,0xd1,0x13,0x83,0x09,0x00,0x08,0x00,0xfd,0xd1,0x23,0x07,0x01,0x04,0x07,0x00,0xfd,0xd1,0x22,0x07,0x01,0x04,0x0c,0x00,0xfd,0xd1,0x0c,0x07
+,0x01,0x04,0x00,0x00,0xfd,0xd1,0x0b,0x07,0x01,0x04,0x24,0x03,0x14,0x7e,0x25,0x03,0x2e,0x7e,0x18,0x81,0x82,0x80,0x10,0x00,0x83,0xbe,0x26,0x00,0x35,0xd1,0x15,0x10
+,0x01,0x00,0x27,0x00,0x35,0xd1,0x16,0x10,0x01,0x00,0x32,0x00,0x35,0xd1,0x17,0x10,0x01,0x00,0xff,0x02,0x66,0x7e,0x00,0x00,0xf0,0x80,0x00,0x00,0x89,0xd2,0x02,0x01
+,0x01,0x00,0x01,0x00,0x89,0xd2,0x12,0x01,0x01,0x00,0x7e,0x01,0xa4,0xbe,0x82,0x01,0xfe,0xbe,0x88,0x02,0x52,0x7e,0x84,0x02,0x58,0x7e,0x83,0x01,0xfe,0xbe,0x18,0x1a
+,0xee,0xd8,0x29,0x00,0x00,0x34,0x1c,0x1e,0xee,0xd8,0x29,0x00,0x00,0x38,0xff,0x02,0x9a,0x7e,0xff,0xff,0xff,0x00,0xa0,0x00,0xec,0xd8,0x29,0x00,0x00,0x4e,0x24,0x01
+,0xfe,0xbe,0xff,0x02,0xa4,0x7e,0x00,0x00,0x00,0x80,0xff,0x02,0xa6,0x7e,0x00,0x00,0xf0,0x3f,0xff,0x02,0xa8,0x7e,0x00,0x00,0x10,0x00,0x00,0x1c,0x8e,0xbe,0x0e,0xff
+,0x28,0x80,0xc4,0x03,0x00,0x00,0x0f,0x80,0x29,0x82,0x0e,0xff,0x2a,0x80,0x28,0x04,0x00,0x00,0x0f,0x80,0x2b,0x82,0x0e,0xff,0x2c,0x80,0x8c,0x04,0x00,0x00,0x0f,0x80
+,0x2d,0x82,0x0e,0xff,0x2e,0x80,0xf0,0x04,0x00,0x00,0x0f,0x80,0x2f,0x82,0x0e,0xff,0x30,0x80,0x54,0x05,0x00,0x00,0x0f,0x80,0x31,0x82,0x0e,0xff,0x32,0x80,0xbc,0x05
+,0x00,0x00,0x0f,0x80,0x33,0x82,0x0e,0xff,0x34,0x80,0x24,0x06,0x00,0x00,0x0f,0x80,0x35,0x82,0x0e,0xff,0x36,0x80,0x8c,0x06,0x00,0x00,0x0f,0x80,0x37,0x82,0x0e,0xff
+,0x38,0x80,0xf4,0x06,0x00,0x00,0x0f,0x80,0x39,0x82,0x0e,0xff,0x3a,0x80,0x64,0x07,0x00,0x00,0x0f,0x80,0x3b,0x82,0xc1,0x00,0xbf,0xbe,0xff,0x00,0xc6,0xbe,0x00,0xff
+,0x00,0x00,0xff,0x00,0xc7,0xbe,0x00,0xfe,0x01,0x00,0xff,0x00,0xc8,0xbe,0x00,0xfc,0x03,0x00,0xff,0x00,0xc9,0xbe,0x00,0xf8,0x07,0x00,0xff,0x00,0xca,0xbe,0x00,0xf0
+,0x0f,0x00,0xff,0x00,0xcb,0xbe,0x00,0xe0,0x1f,0x00,0xff,0x00,0xcc,0xbe,0x00,0xc0,0x3f,0x00,0xff,0x00,0xcd,0xbe,0x00,0x80,0x7f,0x00,0xff,0x00,0xce,0xbe,0x00,0x00
+,0xff,0x00,0xff,0x00,0xcf,0xbe,0x00,0x00,0xfe,0x01,0xff,0x00,0xd0,0xbe,0x00,0x00,0xfc,0x03,0xff,0x00,0xd1,0xbe,0x00,0x00,0xf8,0x07,0xff,0x00,0xd2,0xbe,0x00,0x00
+,0xf0,0x0f,0xff,0x00,0xd3,0xbe,0x00,0x00,0xe0,0x1f,0xff,0x00,0xd4,0xbe,0x00,0x00,0xc0,0x3f,0xff,0x00,0xd5,0xbe,0x00,0x00,0x80,0x7f,0x17,0xc0,0xd6,0x80,0x00,0x00
+,0xec,0xd8,0x00,0x00,0x00,0x18,0x00,0x00,0xec,0xd8,0x0c,0x00,0x00,0x1a,0x7f,0xc0,0x8c,0xbf,0x1b,0x33,0x32,0x2a,0x1a,0x31,0x30,0x2a,0x19,0x15,0x14,0x2a,0x18,0x2f
+,0x2e,0x2a,0x56,0x14,0x14,0x26,0x56,0x2e,0x2e,0x26,0x0a,0x03,0x14,0x68,0x17,0x03,0x2e,0x68,0x02,0x15,0x34,0x32,0x1b,0x6a,0x1c,0xd1,0x12,0x01,0xa9,0x01,0x02,0x2f
+,0x2e,0x32,0x18,0x6a,0x1c,0xd1,0x12,0x01,0xa9,0x01,0x00,0x80,0x54,0xdc,0x1a,0x00,0x7f,0x1c,0x00,0x80,0x54,0xdc,0x17,0x00,0x7f,0x1e,0x71,0x0f,0x8c,0xbf,0x1c,0x09
+,0x40,0x7e,0x1d,0x09,0x38,0x7e,0x70,0x0f,0x8c,0xbf,0x15,0x3d,0x44,0x2a,0x16,0x3f,0x46,0x2a,0x06,0x49,0x2c,0x32,0x19,0x6a,0x1c,0xd1,0x14,0x01,0xa9,0x01,0x16,0x03
+,0x2a,0x32,0x16,0x6a,0x1c,0xd1,0x19,0x01,0xa9,0x01,0x00,0x80,0x54,0xdc,0x15,0x00,0x7f,0x15,0x20,0x1b,0x3c,0x28,0x1f,0x00,0x01,0xd2,0x21,0x27,0x3a,0x04,0x1c,0x1f
+,0x38,0x28,0x1d,0x00,0x01,0xd2,0x1d,0x27,0x42,0x04,0x00,0x01,0x9c,0xd8,0x05,0x1e,0x1c,0x00,0x7f,0xc0,0x8c,0xbf,0x83,0x01,0xfe,0xbe,0x08,0x0a,0xee,0xd8,0x29,0x00
+,0x00,0x3c,0x0c,0x0e,0xee,0xd8,0x29,0x00,0x00,0x40,0x10,0x12,0xee,0xd8,0x29,0x00,0x00,0x44,0x14,0x16,0xee,0xd8,0x29,0x00,0x00,0x48,0x10,0x00,0x89,0xd2,0x22,0x01
+,0x01,0x00,0x11,0x00,0x89,0xd2,0x23,0x01,0x01,0x00,0x12,0x00,0x89,0xd2,0x22,0x03,0x01,0x00,0x13,0x00,0x89,0xd2,0x23,0x03,0x01,0x00,0x14,0x00,0x89,0xd2,0x22,0x05
+,0x01,0x00,0x15,0x00,0x89,0xd2,0x23,0x05,0x01,0x00,0x16,0x00,0x89,0xd2,0x22,0x07,0x01,0x00,0x17,0x00,0x89,0xd2,0x23,0x07,0x01,0x00,0x18,0x00,0x89,0xd2,0x22,0x09
+,0x01,0x00,0x19,0x00,0x89,0xd2,0x23,0x09,0x01,0x00,0x1a,0x00,0x89,0xd2,0x22,0x0b,0x01,0x00,0x1b,0x00,0x89,0xd2,0x23,0x0b,0x01,0x00,0x1c,0x00,0x89,0xd2,0x22,0x0d
+,0x01,0x00,0x1d,0x00,0x89,0xd2,0x23,0x0d,0x01,0x00,0x1e,0x00,0x89,0xd2,0x22,0x0f,0x01,0x00,0x1f,0x00,0x89,0xd2,0x23,0x0f,0x01,0x00,0x7f,0xc0,0x8c,0xbf,0x04,0x1e
+,0x8c,0xbe,0x08,0x0a,0x9c,0xd8,0x29,0x3c,0x3e,0x00,0x0c,0x0e,0x9c,0xd8,0x29,0x40,0x42,0x00,0x10,0x12,0x9c,0xd8,0x29,0x44,0x46,0x00,0x14,0x16,0x9c,0xd8,0x29,0x48
+,0x4a,0x00,0x1c,0x00,0x8a,0xd2,0x10,0x00,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x11,0x00,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x12,0x02,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x13,0x02
+,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x14,0x04,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x15,0x04,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x16,0x06,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x17,0x06
+,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x18,0x08,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x19,0x08,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x1a,0x0a,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1b,0x0a
+,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x1c,0x0c,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1d,0x0c,0x01,0x00,0x1c,0x00,0x8a,0xd2,0x1e,0x0e,0x01,0x00,0x1d,0x00,0x8a,0xd2,0x1f,0x0e
+,0x01,0x00,0x24,0x01,0xfe,0xbe,0x00,0x00,0x9a,0xd8,0x11,0x1c,0x00,0x00,0x7f,0xc0,0x8c,0xbf,0x1c,0x2b,0x2a,0x2a,0x1d,0x2d,0x2c,0x2a,0x00,0x00,0x6c,0xd8,0x07,0x00
+,0x00,0x1c,0x00,0x00,0x6c,0xd8,0x08,0x00,0x00,0x1d,0x00,0x00,0x9a,0xd8,0x11,0x15,0x00,0x00,0x7f,0xc1,0x8c,0xbf,0x08,0x10,0xee,0xd8,0x11,0x00,0x00,0x1e,0x1c,0x4b
+,0x14,0x2a,0x7f,0xc0,0x8c,0xbf,0x20,0x3d,0x3c,0x2a,0x21,0x3f,0x3e,0x2a,0x0a,0x3b,0x14,0x2a,0x00,0x80,0x74,0xdc,0x1a,0x15,0x7f,0x00,0xff,0x14,0x14,0x26,0xc0,0xff
+,0xff,0x7f,0x00,0x80,0x74,0xdc,0x17,0x1e,0x7f,0x00,0x02,0x80,0x06,0xbf,0x06,0x00,0x85,0xbf,0x02,0x81,0x82,0x81,0x24,0x03,0x4a,0x7e,0x80,0x02,0x2e,0x7e,0x0a,0x03
+,0x48,0x7e,0x80,0x02,0x14,0x7e,0x5d,0xff,0x82,0xbf,0x03,0x03,0x00,0x32,0x01,0x6a,0x1c,0xd1,0x04,0x01,0xa9,0x01,0x00,0x80,0x74,0xdc,0x00,0x15,0x7f,0x00,0x40,0x80
+,0x74,0xdc,0x00,0x1e,0x7f,0x00,0x80,0x80,0x74,0xdc,0x00,0x20,0x7f,0x00,0x80,0x02,0x00,0x7e,0x42,0x02,0x02,0x7e,0x00,0x80,0x70,0xdc,0x00,0x01,0x40,0x00,0x00,0x00
+,0x81,0xbf,0x81,0x08,0x43,0xb9,0x44,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x89,0x02,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9,0x62,0x6a,0x1c,0x03,0x5c,0x7e,0x31,0xa5
+,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55
+,0x12,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x44,0x89,0x00,0x00,0x2a,0x03,0x88,0x7e,0x2b,0x03,0x8a,0x7e,0x83,0x01
+,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x46,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x8d,0x02,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9,0x62,0x6a,0x1c,0x03
+,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00
+,0xcc,0xd1,0x2a,0x55,0x1a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x46,0x89,0x00,0x00,0x2a,0x03,0x8c,0x7e,0x2b,0x03
+,0x8e,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x48,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x91,0x02,0x00,0x1c,0x03,0x60,0x7e,0x1d,0xa9
+,0x62,0x6a,0x1c,0x03,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00,0xcc,0xd1,0x30,0x5d
+,0xc2,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55,0x22,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x48,0x89,0x00,0x00,0x2a,0x03
+,0x90,0x7e,0x2b,0x03,0x92,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x81,0x08,0x43,0xb9,0x4a,0x4d,0x38,0x7e,0x2a,0x00,0x81,0xd2,0x1c,0x95,0x02,0x00,0x1c,0x03
+,0x60,0x7e,0x1d,0xa9,0x62,0x6a,0x1c,0x03,0x5c,0x7e,0x31,0xa5,0x5e,0x2a,0x2e,0x00,0xcc,0xd1,0x2e,0x55,0xc2,0x03,0x2a,0x00,0xcc,0xd1,0x2a,0x5d,0xaa,0x04,0x30,0x00
+,0xcc,0xd1,0x30,0x5d,0xc2,0x04,0x2e,0x00,0xcc,0xd1,0x2a,0x55,0x2a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2e,0x61,0xaa,0x04,0x0e,0x00,0x13,0xd0,0x4a,0x89
+,0x00,0x00,0x2a,0x03,0x94,0x7e,0x2b,0x03,0x96,0x7e,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x00,0x01,0xd2,0x1d,0x9b,0x3e,0x05,0x81,0x08
+,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x44,0x61,0x02,0x00,0x2a,0x00
+,0xcc,0xd1,0x1c,0xa1,0x12,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x12,0x05,0x0e,0x00,0x72,0xd0,0x44,0x39
+,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x88,0x7e,0x51,0x03,0x8a,0x7e,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x00
+,0x01,0xd2,0x1d,0x9b,0x3e,0x05,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00
+,0x81,0xd2,0x46,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x1a,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39
+,0x1a,0x05,0x0e,0x00,0x72,0xd0,0x46,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x8c,0x7e,0x51,0x03,0x8e,0x7e,0x3c,0x1d
+,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x00,0x01,0xd2,0x1d,0x9b,0x3e,0x05,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00
+,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x48,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x22,0x25,0x81,0x08,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61
+,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x22,0x05,0x0e,0x00,0x72,0xd0,0x48,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03
+,0x90,0x7e,0x51,0x03,0x92,0x7e,0x3c,0x1d,0x80,0xbe,0x1c,0x9d,0x38,0x28,0x1d,0x00,0x01,0xd2,0x1d,0x9b,0x3e,0x05,0x81,0x08,0x43,0xb9,0x1c,0x4b,0x60,0x7e,0x50,0x00
+,0xcc,0xd1,0x1c,0x61,0xca,0x23,0x30,0x00,0xcc,0xd1,0x30,0xa1,0xc2,0x04,0x50,0x00,0x81,0xd2,0x4a,0x61,0x02,0x00,0x2a,0x00,0xcc,0xd1,0x1c,0xa1,0x2a,0x25,0x81,0x08
+,0x42,0xb9,0x2a,0x00,0xcc,0xd1,0x2a,0x61,0x42,0x05,0x50,0x00,0xdf,0xd1,0x2a,0x39,0x2a,0x05,0x0e,0x00,0x72,0xd0,0x4a,0x39,0x02,0x00,0x80,0x02,0xa0,0x7e,0x53,0x03
+,0xa2,0x7e,0x83,0x01,0xfe,0xbe,0x50,0x03,0x94,0x7e,0x51,0x03,0x96,0x7e,0x3c,0x1d,0x80,0xbe,0x81,0x01,0xfe,0xbe,0x0e,0x02,0x5a,0x7e,0x28,0x00,0x86,0xd2,0x26,0x5a
+,0x02,0x00,0x0f,0x02,0x5e,0x7e,0x2a,0x20,0xe8,0xd1,0x26,0x5e,0xa2,0x04,0x2a,0x03,0x50,0x7e,0x2d,0x20,0xe8,0xd1,0x27,0x5a,0xa2,0x04,0x2a,0x20,0xe8,0xd1,0x27,0x5e
+,0xae,0x04,0x2a,0x5d,0x54,0x32,0x80,0x56,0x56,0x38,0x20,0x00,0x89,0xd2,0x2a,0x01,0x01,0x00,0x21,0x00,0x89,0xd2,0x2b,0x01,0x01,0x00,0x0f,0x80,0x04,0xbf,0x26,0x80
+,0xa2,0x85,0x20,0x22,0xa0,0x80,0x21,0x23,0xa1,0x82,0x27,0x80,0x04,0xbf,0x0e,0x80,0xa2,0x85,0x20,0x22,0x8e,0x80,0x21,0x23,0x8f,0x82,0x83,0x01,0xfe,0xbe,0x3c,0x1d
+,0x80,0xbe,0x81,0x01,0xfe,0xbe,0x26,0x02,0x5a,0x7e,0x28,0x00,0x86,0xd2,0x0e,0x5a,0x02,0x00,0x27,0x02,0x5e,0x7e,0x2a,0x20,0xe8,0xd1,0x0e,0x5e,0xa2,0x04,0x2a,0x03
+,0x50,0x7e,0x2d,0x20,0xe8,0xd1,0x0f,0x5a,0xa2,0x04,0x2a,0x20,0xe8,0xd1,0x0f,0x5e,0xae,0x04,0x2a,0x5d,0x54,0x32,0x80,0x56,0x56,0x38,0x0e,0x00,0x89,0xd2,0x2a,0x01
+,0x01,0x00,0x0f,0x00,0x89,0xd2,0x2b,0x01,0x01,0x00,0x83,0x01,0xfe,0xbe,0x3c,0x1d,0x80,0xbe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x1a,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x0b
+,0x00,0x00,0x00,0x00,0x00,0x00,0x1e,0x00,0x00,0x00,0x03,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00
+,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2a,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0b,0x00
+,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x34,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x13,0x00
+,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xc8,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x19,0x00
+,0x00,0x00,0x01,0x00,0x00,0x00,0x07,0x00,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x74,0x0b
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x22,0x00
+,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x48,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01
+,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x32
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0b
+,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x72,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x43
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x13
+,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xb8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x48
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1b
+,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x27
+,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x24
+,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x27,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x38
+,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2c
+,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x40
+,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+const int randomx_run_gfx900_bin_size=6496;

src/backend/opencl/generators/ocl_generic_cn_generator.cpp

@@ -0,0 +1,118 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclThreads.h"
+#include "backend/opencl/wrappers/OclDevice.h"
+#include "crypto/cn/CnAlgo.h"
+#include "crypto/common/Algorithm.h"
+
+
+#include <algorithm>
+
+
+namespace xmrig {
+
+
+constexpr const size_t oneMiB = 1024u * 1024u;
+
+
+static inline uint32_t getMaxThreads(const OclDevice &device, const Algorithm &algorithm)
+{
+    if (device.vendorId() == OCL_VENDOR_NVIDIA && (device.name().contains("P100") || device.name().contains("V100"))) {
+        return 40000u;
+    }
+
+    return ((algorithm.l3() <= oneMiB) ? 2u : 1u) * 1000u;
+}
+
+
+static inline uint32_t getPossibleIntensity(const OclDevice &device, const Algorithm &algorithm)
+{
+    const uint32_t maxThreads   = getMaxThreads(device, algorithm);
+    const size_t minFreeMem     = (maxThreads == 40000u ? 512u : 128u) * oneMiB;
+    const size_t availableMem   = device.freeMemSize() - minFreeMem;
+    const size_t perThread      = algorithm.l3() + 224u;
+    const auto maxIntensity     = static_cast<uint32_t>(availableMem / perThread);
+
+    return std::min<uint32_t>(maxThreads, maxIntensity);
+}
+
+
+static uint32_t getIntensity(const OclDevice &device, const Algorithm &algorithm)
+{
+    if (device.type() == OclDevice::Raven) {
+        return 0;
+    }
+
+    const uint32_t maxIntensity = getPossibleIntensity(device, algorithm);
+
+    uint32_t intensity = (maxIntensity / (8 * device.computeUnits())) * device.computeUnits() * 8;
+    if (intensity == 0) {
+        return 0;
+    }
+
+    if (device.vendorId() == OCL_VENDOR_AMD && (device.type() == OclDevice::Lexa || device.type() == OclDevice::Baffin || device.computeUnits() <= 16)) {
+        intensity /= 2;
+
+        if (algorithm.family() == Algorithm::CN_HEAVY) {
+            intensity /= 2;
+        }
+    }
+
+    return intensity;
+}
+
+
+static uint32_t getStridedIndex(const OclDevice &device, const Algorithm &algorithm)
+{
+    if (device.vendorId() != OCL_VENDOR_AMD) {
+        return 0;
+    }
+
+    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 2 : 1;
+}
+
+
+bool ocl_generic_cn_generator(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads)
+{
+    if (!algorithm.isCN()) {
+        return false;
+    }
+
+    const uint32_t intensity = getIntensity(device, algorithm);
+    if (intensity == 0) {
+        return false;
+    }
+
+    const uint32_t threadCount = ((device.globalMemSize() - intensity * 2 * algorithm.l3()) > 128 * oneMiB) ? 2 : 1;
+
+    threads.add(OclThread(device.index(), intensity, 8, getStridedIndex(device, algorithm), 2, threadCount, 8));
+
+    return true;
+}
+
+
+} // namespace xmrig

src/backend/opencl/generators/ocl_generic_cn_gpu_generator.cpp

@@ -0,0 +1,87 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclThreads.h"
+#include "backend/opencl/wrappers/OclDevice.h"
+#include "crypto/common/Algorithm.h"
+
+
+#include <algorithm>
+
+
+namespace xmrig {
+
+
+constexpr const size_t oneMiB = 1024u * 1024u;
+
+
+
+bool ocl_generic_cn_gpu_generator(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads)
+{
+    if (algorithm != Algorithm::CN_GPU) {
+        return false;
+    }
+
+    uint32_t worksize   = 8;
+    uint32_t numThreads = 1u;
+    size_t minFreeMem   = 128u * oneMiB;
+
+    if (device.type() == OclDevice::Vega_10 || device.type() == OclDevice::Vega_20) {
+        minFreeMem  = oneMiB;
+        worksize    = 16;
+    }
+    else if (device.type() == OclDevice::Navi_10) {
+        numThreads = 2u;
+    }
+    else if (device.name() == "Fiji") {
+        worksize = 16;
+    }
+
+    size_t maxThreads = device.computeUnits() * 6 * 8;
+
+    const size_t maxAvailableFreeMem = device.freeMemSize() - minFreeMem;
+    const size_t memPerThread        = std::min(device.maxMemAllocSize(), maxAvailableFreeMem);
+
+    size_t memPerHash           = algorithm.l3() + 240u;
+    size_t maxIntensity         = memPerThread / memPerHash;
+    size_t possibleIntensity    = std::min(maxThreads, maxIntensity);
+    size_t intensity            = 0;
+    size_t cuUtilization        = ((possibleIntensity * 100)  / (worksize * device.computeUnits())) % 100;
+
+    if (cuUtilization >= 75) {
+        intensity = (possibleIntensity / worksize) * worksize;
+    }
+    else {
+        intensity = (possibleIntensity / (worksize * device.computeUnits())) * device.computeUnits() * worksize;
+    }
+
+    threads.add(OclThread(device.index(), intensity, worksize, numThreads, 1));
+
+    return true;
+}
+
+
+} // namespace xmrig

src/backend/opencl/generators/ocl_generic_rx_generator.cpp

@@ -0,0 +1,95 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclThreads.h"
+#include "backend/opencl/wrappers/OclDevice.h"
+#include "crypto/common/Algorithm.h"
+#include "crypto/randomx/randomx.h"
+#include "crypto/rx/RxAlgo.h"
+
+
+namespace xmrig {
+
+
+bool ocl_generic_rx_generator(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads)
+{
+    if (algorithm.family() != Algorithm::RANDOM_X) {
+        return false;
+    }
+
+    const size_t mem = device.globalMemSize();
+    auto config      = RxAlgo::base(algorithm);
+    bool gcnAsm      = false;
+
+    switch (device.type()) {
+    case OclDevice::Baffin:
+    case OclDevice::Polaris:
+    case OclDevice::Lexa:
+    case OclDevice::Vega_10:
+    case OclDevice::Vega_20:
+        gcnAsm = true;
+        break;
+
+    default:
+        break;
+    }
+
+    // Must have space for dataset, scratchpads and 128 MB of free memory
+    const uint32_t dataset_mem = config->DatasetBaseSize + config->DatasetExtraSize + (128U << 20);
+
+    // Use dataset on host if not enough memory
+    bool datasetHost = (mem < dataset_mem);
+
+    // Each thread uses 1 scratchpad plus a few small buffers on GPU
+    const uint32_t per_thread_mem = config->ScratchpadL3_Size + 32768;
+
+    uint32_t intensity = static_cast<uint32_t>((mem - (datasetHost ? 0 : dataset_mem)) / per_thread_mem / 2);
+
+    // Too high intensity makes hashrate worse
+    if (intensity > device.computeUnits() * 16) {
+        intensity = device.computeUnits() * 16;
+    }
+
+    intensity -= intensity % 64;
+
+    // If there are too few threads, use dataset on host to get more threads
+    if (intensity < device.computeUnits() * 4) {
+        datasetHost = true;
+        intensity = static_cast<uint32_t>(mem / per_thread_mem / 2);
+        intensity -= intensity % 64;
+    }
+
+    if (!intensity) {
+        return false;
+    }
+
+    threads.add(OclThread(device.index(), intensity, 8, 2, gcnAsm, datasetHost, 6));
+
+    return true;
+}
+
+
+} // namespace xmrig

src/backend/opencl/generators/ocl_vega_cn_generator.cpp

@@ -0,0 +1,135 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018      Lee Clagett <https://github.com/vtnerd>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/OclThreads.h"
+#include "backend/opencl/wrappers/OclDevice.h"
+#include "crypto/cn/CnAlgo.h"
+#include "crypto/common/Algorithm.h"
+
+
+#include <algorithm>
+
+
+namespace xmrig {
+
+
+constexpr const size_t oneMiB = 1024u * 1024u;
+
+
+static inline bool isMatch(const OclDevice &device, const Algorithm &algorithm)
+{
+    return algorithm.isCN() &&
+           device.vendorId() == OCL_VENDOR_AMD &&
+           (device.type() == OclDevice::Vega_10 || device.type() == OclDevice::Vega_20);
+}
+
+
+static inline uint32_t getMaxThreads(const OclDevice &device, const Algorithm &algorithm)
+{
+    const uint32_t ratio = (algorithm.l3() <= oneMiB) ? 2u : 1u;
+
+    if (device.type() == OclDevice::Vega_10) {
+        if (device.computeUnits() == 56 && algorithm.family() == Algorithm::CN && CnAlgo<>::base(algorithm) == Algorithm::CN_2) {
+            return 1792u;
+        }
+    }
+
+    return ratio * 2024u;
+}
+
+
+static inline uint32_t getPossibleIntensity(const OclDevice &device, const Algorithm &algorithm)
+{
+    const uint32_t maxThreads   = getMaxThreads(device, algorithm);
+    const size_t availableMem   = device.freeMemSize() - (128u * oneMiB);
+    const size_t perThread      = algorithm.l3() + 224u;
+    const auto maxIntensity     = static_cast<uint32_t>(availableMem / perThread);
+
+    return std::min<uint32_t>(maxThreads, maxIntensity);
+}
+
+
+static inline uint32_t getIntensity(const OclDevice &device, const Algorithm &algorithm)
+{
+    const uint32_t maxIntensity = getPossibleIntensity(device, algorithm);
+
+    if (device.type() == OclDevice::Vega_10) {
+        if (algorithm.family() == Algorithm::CN_HEAVY && device.computeUnits() == 64 && maxIntensity > 976) {
+            return 976;
+        }
+    }
+
+    return maxIntensity / device.computeUnits() * device.computeUnits();
+}
+
+
+static inline uint32_t getWorksize(const Algorithm &algorithm)
+{
+    if (algorithm.family() == Algorithm::CN_PICO) {
+        return 64;
+    }
+
+    if (CnAlgo<>::base(algorithm) == Algorithm::CN_2) {
+        return 16;
+    }
+
+    return 8;
+}
+
+
+static uint32_t getStridedIndex(const Algorithm &algorithm)
+{
+    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 2 : 1;
+}
+
+
+static inline uint32_t getMemChunk(const Algorithm &algorithm)
+{
+    return CnAlgo<>::base(algorithm) == Algorithm::CN_2 ? 1 : 2;
+}
+
+
+bool ocl_vega_cn_generator(const OclDevice &device, const Algorithm &algorithm, OclThreads &threads)
+{
+    if (!isMatch(device, algorithm)) {
+        return false;
+    }
+
+    const uint32_t intensity = getIntensity(device, algorithm);
+    if (intensity == 0) {
+        return false;
+    }
+
+    const uint32_t worksize = getWorksize(algorithm);
+    const uint32_t memChunk = getMemChunk(algorithm);
+
+    threads.add(OclThread(device.index(), intensity, worksize, getStridedIndex(algorithm), memChunk, 2, 8));
+
+    return true;
+}
+
+
+} // namespace xmrig

src/backend/opencl/interfaces/IOclRunner.h

@@ -0,0 +1,75 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_IOCLRUNNER_H
+#define XMRIG_IOCLRUNNER_H
+
+
+#include "base/tools/Object.h"
+
+
+#include <cstdint>
+
+
+using cl_context = struct _cl_context *;
+
+
+namespace xmrig {
+
+
+class Algorithm;
+class Job;
+class OclLaunchData;
+
+
+class IOclRunner
+{
+public:
+    XMRIG_DISABLE_COPY_MOVE(IOclRunner)
+
+    IOclRunner()          = default;
+    virtual ~IOclRunner() = default;
+
+    virtual void run(uint32_t nonce, uint32_t *hashOutput)  = 0;
+    virtual void set(const Job &job, uint8_t *blob)         = 0;
+    virtual cl_context ctx() const                          = 0;
+    virtual const Algorithm &algorithm() const              = 0;
+    virtual const char *buildOptions() const                = 0;
+    virtual const char *deviceKey() const                   = 0;
+    virtual const char *source() const                      = 0;
+    virtual const OclLaunchData &data() const               = 0;
+    virtual size_t threadId() const                         = 0;
+    virtual uint32_t deviceIndex() const                    = 0;
+    virtual void build()                                    = 0;
+    virtual void init()                                     = 0;
+
+protected:
+    virtual size_t bufferSize() const                       = 0;
+};
+
+
+} /* namespace xmrig */
+
+
+#endif // XMRIG_IOCLRUNNER_H

src/backend/opencl/kernels/Cn00RyoKernel.cpp

@@ -0,0 +1,44 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/Cn00RyoKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Cn00RyoKernel::enqueue(cl_command_queue queue, size_t threads)
+{
+    const size_t gthreads = threads * 64;
+    const size_t lthreads = 64;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void cn00(__global int *Scratchpad, __global ulong *states)
+void xmrig::Cn00RyoKernel::setArgs(cl_mem scratchpads, cl_mem states)
+{
+    setArg(0, sizeof(cl_mem), &scratchpads);
+    setArg(1, sizeof(cl_mem), &states);
+}

src/backend/opencl/kernels/Cn00RyoKernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN00RYOKERNEL_H
+#define XMRIG_CN00RYOKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn00RyoKernel : public OclKernel
+{
+public:
+    inline Cn00RyoKernel(cl_program program) : OclKernel(program, "cn00") {}
+
+    void enqueue(cl_command_queue queue, size_t threads);
+    void setArgs(cl_mem scratchpads, cl_mem states);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN00RYOKERNEL_H */

src/backend/opencl/kernels/Cn0Kernel.cpp

@@ -0,0 +1,47 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/Cn0Kernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Cn0Kernel::enqueue(cl_command_queue queue, uint32_t nonce, size_t threads)
+{
+    const size_t offset[2]          = { nonce, 1 };
+    const size_t gthreads[2]        = { threads, 8 };
+    static const size_t lthreads[2] = { 8, 8 };
+
+    enqueueNDRange(queue, 2, offset, gthreads, lthreads);
+}
+
+
+// __kernel void cn0(__global ulong *input, __global uint4 *Scratchpad, __global ulong *states, uint Threads)
+void xmrig::Cn0Kernel::setArgs(cl_mem input, cl_mem scratchpads, cl_mem states, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &input);
+    setArg(1, sizeof(cl_mem), &scratchpads);
+    setArg(2, sizeof(cl_mem), &states);
+    setArg(3, sizeof(uint32_t), &threads);
+}

src/backend/opencl/kernels/Cn0Kernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN0KERNEL_H
+#define XMRIG_CN0KERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn0Kernel : public OclKernel
+{
+public:
+    inline Cn0Kernel(cl_program program) : OclKernel(program, "cn0") {}
+
+    void enqueue(cl_command_queue queue, uint32_t nonce, size_t threads);
+    void setArgs(cl_mem input, cl_mem scratchpads, cl_mem states, uint32_t threads);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN0KERNEL_H */

src/backend/opencl/kernels/Cn1Kernel.cpp

@@ -0,0 +1,63 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <string>
+
+
+#include "backend/opencl/kernels/Cn1Kernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+xmrig::Cn1Kernel::Cn1Kernel(cl_program program)
+    : OclKernel(program, "cn1")
+{
+}
+
+
+xmrig::Cn1Kernel::Cn1Kernel(cl_program program, uint64_t height)
+    : OclKernel(program, ("cn1_" + std::to_string(height)).c_str())
+{
+
+}
+
+
+void xmrig::Cn1Kernel::enqueue(cl_command_queue queue, uint32_t nonce, size_t threads, size_t worksize)
+{
+    const size_t offset   = nonce;
+    const size_t gthreads = threads;
+    const size_t lthreads = worksize;
+
+    enqueueNDRange(queue, 1, &offset, &gthreads, &lthreads);
+}
+
+
+// __kernel void cn1(__global ulong *input, __global uint4 *Scratchpad, __global ulong *states, uint Threads)
+void xmrig::Cn1Kernel::setArgs(cl_mem input, cl_mem scratchpads, cl_mem states, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &input);
+    setArg(1, sizeof(cl_mem), &scratchpads);
+    setArg(2, sizeof(cl_mem), &states);
+    setArg(3, sizeof(uint32_t), &threads);
+}

src/backend/opencl/kernels/Cn1Kernel.h

@@ -0,0 +1,49 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN1KERNEL_H
+#define XMRIG_CN1KERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn1Kernel : public OclKernel
+{
+public:
+    Cn1Kernel(cl_program program);
+    Cn1Kernel(cl_program program, uint64_t height);
+
+    void enqueue(cl_command_queue queue, uint32_t nonce, size_t threads, size_t worksize);
+    void setArgs(cl_mem input, cl_mem scratchpads, cl_mem states, uint32_t threads);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN1KERNEL_H */

src/backend/opencl/kernels/Cn1RyoKernel.cpp

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include <string>
+
+
+#include "backend/opencl/kernels/Cn1RyoKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Cn1RyoKernel::enqueue(cl_command_queue queue, size_t threads, size_t worksize)
+{
+    const size_t gthreads = threads * 16;
+    const size_t lthreads = worksize * 16;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void cn1(__global int *lpad_in, __global int *spad, uint numThreads)
+void xmrig::Cn1RyoKernel::setArgs(cl_mem scratchpads, cl_mem states, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &scratchpads);
+    setArg(1, sizeof(cl_mem), &states);
+    setArg(2, sizeof(uint32_t), &threads);
+}

src/backend/opencl/kernels/Cn1RyoKernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN1RYOKERNEL_H
+#define XMRIG_CN1RYOKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn1RyoKernel : public OclKernel
+{
+public:
+    inline Cn1RyoKernel(cl_program program) : OclKernel(program, "cn1") {}
+
+    void enqueue(cl_command_queue queue, size_t threads, size_t worksize);
+    void setArgs(cl_mem scratchpads, cl_mem states, uint32_t threads);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN1RYOKERNEL_H */

src/backend/opencl/kernels/Cn2Kernel.cpp

@@ -0,0 +1,50 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/Cn2Kernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Cn2Kernel::enqueue(cl_command_queue queue, uint32_t nonce, size_t threads)
+{
+    const size_t offset[2]          = { nonce, 1 };
+    const size_t gthreads[2]        = { threads, 8 };
+    static const size_t lthreads[2] = { 8, 8 };
+
+    enqueueNDRange(queue, 2, offset, gthreads, lthreads);
+}
+
+
+// __kernel void cn2(__global uint4 *Scratchpad, __global ulong *states, __global uint *Branch0, __global uint *Branch1, __global uint *Branch2, __global uint *Branch3, uint Threads)
+void xmrig::Cn2Kernel::setArgs(cl_mem scratchpads, cl_mem states, const std::vector<cl_mem> &branches, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &scratchpads);
+    setArg(1, sizeof(cl_mem), &states);
+    setArg(6, sizeof(uint32_t), &threads);
+
+    for (uint32_t i = 0; i < branches.size(); ++i) {
+        setArg(i + 2, sizeof(cl_mem), &branches[i]);
+    }
+}

src/backend/opencl/kernels/Cn2Kernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN2KERNEL_H
+#define XMRIG_CN2KERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn2Kernel : public OclKernel
+{
+public:
+    inline Cn2Kernel(cl_program program) : OclKernel(program, "cn2") {}
+
+    void enqueue(cl_command_queue queue, uint32_t nonce, size_t threads);
+    void setArgs(cl_mem scratchpads, cl_mem states, const std::vector<cl_mem> &branches, uint32_t threads);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN2KERNEL_H */

src/backend/opencl/kernels/Cn2RyoKernel.cpp

@@ -0,0 +1,53 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/Cn2RyoKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Cn2RyoKernel::enqueue(cl_command_queue queue, uint32_t nonce, size_t threads)
+{
+    const size_t offset[2]          = { nonce, 1 };
+    const size_t gthreads[2]        = { threads, 8 };
+    static const size_t lthreads[2] = { 8, 8 };
+
+    enqueueNDRange(queue, 2, offset, gthreads, lthreads);
+}
+
+
+// __kernel void cn2(__global uint4 *Scratchpad, __global ulong *states, __global uint *output, ulong Target, uint Threads)
+void xmrig::Cn2RyoKernel::setArgs(cl_mem scratchpads, cl_mem states, cl_mem output, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &scratchpads);
+    setArg(1, sizeof(cl_mem), &states);
+    setArg(2, sizeof(cl_mem), &output);
+    setArg(4, sizeof(uint32_t), &threads);
+}
+
+
+void xmrig::Cn2RyoKernel::setTarget(uint64_t target)
+{
+    setArg(3, sizeof(cl_ulong), &target);
+}

src/backend/opencl/kernels/Cn2RyoKernel.h

@@ -0,0 +1,49 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CN2RYOKERNEL_H
+#define XMRIG_CN2RYOKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Cn2RyoKernel : public OclKernel
+{
+public:
+    inline Cn2RyoKernel(cl_program program) : OclKernel(program, "cn2") {}
+
+    void enqueue(cl_command_queue queue, uint32_t nonce, size_t threads);
+    void setArgs(cl_mem scratchpads, cl_mem states, cl_mem output, uint32_t threads);
+    void setTarget(uint64_t target);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CN2RYOKERNEL_H */

src/backend/opencl/kernels/CnBranchKernel.cpp

@@ -0,0 +1,67 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/CnBranchKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+namespace xmrig {
+
+
+static const char *names[4] = { "Blake", "Groestl", "JH", "Skein" };
+
+
+} // namespace xmrig
+
+
+xmrig::CnBranchKernel::CnBranchKernel(size_t index, cl_program program) : OclKernel(program, names[index])
+{
+}
+
+
+void xmrig::CnBranchKernel::enqueue(cl_command_queue queue, uint32_t nonce, size_t threads, size_t worksize)
+{
+    const size_t offset   = nonce;
+    const size_t gthreads = threads;
+    const size_t lthreads = worksize;
+
+    enqueueNDRange(queue, 1, &offset, &gthreads, &lthreads);
+}
+
+
+// __kernel void Skein(__global ulong *states, __global uint *BranchBuf, __global uint *output, ulong Target, uint Threads)
+void xmrig::CnBranchKernel::setArgs(cl_mem states, cl_mem branch, cl_mem output, uint32_t threads)
+{
+    setArg(0, sizeof(cl_mem), &states);
+    setArg(1, sizeof(cl_mem), &branch);
+    setArg(2, sizeof(cl_mem), &output);
+    setArg(4, sizeof(cl_uint), &threads);
+}
+
+
+void xmrig::CnBranchKernel::setTarget(uint64_t target)
+{
+    setArg(3, sizeof(cl_ulong), &target);
+}

src/backend/opencl/kernels/CnBranchKernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_CNBRANCHKERNEL_H
+#define XMRIG_CNBRANCHKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class CnBranchKernel : public OclKernel
+{
+public:
+    CnBranchKernel(size_t index, cl_program program);
+    void enqueue(cl_command_queue queue, uint32_t nonce, size_t threads, size_t worksize);
+    void setArgs(cl_mem states, cl_mem branch, cl_mem output, uint32_t threads);
+    void setTarget(uint64_t target);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_CNBRANCHKERNEL_H */

src/backend/opencl/kernels/rx/Blake2bHashRegistersKernel.cpp

@@ -0,0 +1,46 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/rx/Blake2bHashRegistersKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Blake2bHashRegistersKernel::enqueue(cl_command_queue queue, size_t threads)
+{
+    const size_t gthreads        = threads;
+    static const size_t lthreads = 64;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void blake2b_hash_registers_32(__global void *out, __global const void* in, uint inStrideBytes)
+// __kernel void blake2b_hash_registers_64(__global void *out, __global const void* in, uint inStrideBytes)
+void xmrig::Blake2bHashRegistersKernel::setArgs(cl_mem out, cl_mem in, uint32_t inStrideBytes)
+{
+    setArg(0, sizeof(cl_mem), &out);
+    setArg(1, sizeof(cl_mem), &in);
+    setArg(2, sizeof(uint32_t), &inStrideBytes);
+}

src/backend/opencl/kernels/rx/Blake2bHashRegistersKernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_BLAKE2BHASHREGISTERSKERNEL_H
+#define XMRIG_BLAKE2BHASHREGISTERSKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Blake2bHashRegistersKernel : public OclKernel
+{
+public:
+    inline Blake2bHashRegistersKernel(cl_program program, const char *name) : OclKernel(program, name) {}
+
+    void enqueue(cl_command_queue queue, size_t threads);
+    void setArgs(cl_mem out, cl_mem in, uint32_t inStrideBytes);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_BLAKE2BHASHREGISTERSKERNEL_H */

src/backend/opencl/kernels/rx/Blake2bInitialHashKernel.cpp

@@ -0,0 +1,58 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/rx/Blake2bInitialHashKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::Blake2bInitialHashKernel::enqueue(cl_command_queue queue, size_t threads)
+{
+    const size_t gthreads        = threads;
+    static const size_t lthreads = 64;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void blake2b_initial_hash(__global void *out, __global const void* blockTemplate, uint blockTemplateSize, uint start_nonce)
+void xmrig::Blake2bInitialHashKernel::setArgs(cl_mem out, cl_mem blockTemplate)
+{
+    setArg(0, sizeof(cl_mem), &out);
+    setArg(1, sizeof(cl_mem), &blockTemplate);
+}
+
+
+void xmrig::Blake2bInitialHashKernel::setBlobSize(size_t size)
+{
+    const uint32_t s = size;
+
+    setArg(2, sizeof(uint32_t), &s);
+}
+
+
+void xmrig::Blake2bInitialHashKernel::setNonce(uint32_t nonce)
+{
+    setArg(3, sizeof(uint32_t), &nonce);
+}

src/backend/opencl/kernels/rx/Blake2bInitialHashKernel.h

@@ -0,0 +1,50 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_BLAKE2BINITIALHASHKERNEL_H
+#define XMRIG_BLAKE2BINITIALHASHKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class Blake2bInitialHashKernel : public OclKernel
+{
+public:
+    inline Blake2bInitialHashKernel(cl_program program) : OclKernel(program, "blake2b_initial_hash") {}
+
+    void enqueue(cl_command_queue queue, size_t threads);
+    void setArgs(cl_mem out, cl_mem blockTemplate);
+    void setBlobSize(size_t size);
+    void setNonce(uint32_t nonce);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_BLAKE2BINITIALHASHKERNEL_H */

src/backend/opencl/kernels/rx/ExecuteVmKernel.cpp

@@ -0,0 +1,67 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/rx/ExecuteVmKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::ExecuteVmKernel::enqueue(cl_command_queue queue, size_t threads, size_t worksize)
+{
+    const size_t gthreads = (worksize == 16) ? (threads * 16) : (threads * 8);
+    const size_t lthreads = (worksize == 16) ? 32 : 16;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void execute_vm(__global void* vm_states, __global void* rounding, __global void* scratchpads, __global const void* dataset_ptr, uint32_t batch_size, uint32_t num_iterations, uint32_t first, uint32_t last)
+void xmrig::ExecuteVmKernel::setArgs(cl_mem vm_states, cl_mem rounding, cl_mem scratchpads, cl_mem dataset_ptr, uint32_t batch_size)
+{
+    setArg(0, sizeof(cl_mem), &vm_states);
+    setArg(1, sizeof(cl_mem), &rounding);
+    setArg(2, sizeof(cl_mem), &scratchpads);
+    setArg(3, sizeof(cl_mem), &dataset_ptr);
+    setArg(4, sizeof(uint32_t), &batch_size);
+}
+
+
+void xmrig::ExecuteVmKernel::setFirst(uint32_t first)
+{
+    setArg(6, sizeof(uint32_t), &first);
+}
+
+
+void xmrig::ExecuteVmKernel::setIterations(uint32_t num_iterations)
+{
+    setArg(5, sizeof(uint32_t), &num_iterations);
+    setFirst(1);
+    setLast(0);
+}
+
+
+void xmrig::ExecuteVmKernel::setLast(uint32_t last)
+{
+    setArg(7, sizeof(uint32_t), &last);
+}

src/backend/opencl/kernels/rx/ExecuteVmKernel.h

@@ -0,0 +1,51 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_EXECUTEVMKERNEL_H
+#define XMRIG_EXECUTEVMKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class ExecuteVmKernel : public OclKernel
+{
+public:
+    inline ExecuteVmKernel(cl_program program) : OclKernel(program, "execute_vm") {}
+
+    void enqueue(cl_command_queue queue, size_t threads, size_t worksize);
+    void setArgs(cl_mem vm_states, cl_mem rounding, cl_mem scratchpads, cl_mem dataset_ptr, uint32_t batch_size);
+    void setFirst(uint32_t first);
+    void setIterations(uint32_t num_iterations);
+    void setLast(uint32_t last);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_EXECUTEVMKERNEL_H */

src/backend/opencl/kernels/rx/FillAesKernel.cpp

@@ -0,0 +1,47 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/rx/FillAesKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::FillAesKernel::enqueue(cl_command_queue queue, size_t threads)
+{
+    const size_t gthreads        = threads * 4;
+    static const size_t lthreads = 64;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void fillAes1Rx4_scratchpad(__global void* state, __global void* out, uint batch_size, uint rx_version)
+// __kernel void fillAes4Rx4_entropy(__global void* state, __global void* out, uint batch_size, uint rx_version)
+void xmrig::FillAesKernel::setArgs(cl_mem state, cl_mem out, uint32_t batch_size, uint32_t rx_version)
+{
+    setArg(0, sizeof(cl_mem), &state);
+    setArg(1, sizeof(cl_mem), &out);
+    setArg(2, sizeof(uint32_t), &batch_size);
+    setArg(3, sizeof(uint32_t), &rx_version);
+}

src/backend/opencl/kernels/rx/FillAesKernel.h

@@ -0,0 +1,48 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_FILLAESKERNEL_H
+#define XMRIG_FILLAESKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class FillAesKernel : public OclKernel
+{
+public:
+    inline FillAesKernel(cl_program program, const char *name) : OclKernel(program, name) {}
+
+    void enqueue(cl_command_queue queue, size_t threads);
+    void setArgs(cl_mem state, cl_mem out, uint32_t batch_size, uint32_t rx_version);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_FILLAESKERNEL_H */

src/backend/opencl/kernels/rx/FindSharesKernel.cpp

@@ -0,0 +1,56 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "backend/opencl/kernels/rx/FindSharesKernel.h"
+#include "backend/opencl/wrappers/OclLib.h"
+
+
+void xmrig::FindSharesKernel::enqueue(cl_command_queue queue, size_t threads)
+{
+    const size_t gthreads        = threads;
+    static const size_t lthreads = 64;
+
+    enqueueNDRange(queue, 1, nullptr, &gthreads, &lthreads);
+}
+
+
+// __kernel void find_shares(__global const uint64_t* hashes, uint64_t target, uint32_t start_nonce, __global uint32_t* shares)
+void xmrig::FindSharesKernel::setArgs(cl_mem hashes, cl_mem shares)
+{
+    setArg(0, sizeof(cl_mem), &hashes);
+    setArg(3, sizeof(cl_mem), &shares);
+}
+
+
+void xmrig::FindSharesKernel::setTarget(uint64_t target)
+{
+    setArg(1, sizeof(uint64_t), &target);
+}
+
+
+void xmrig::FindSharesKernel::setNonce(uint32_t nonce)
+{
+    setArg(2, sizeof(uint32_t), &nonce);
+}

src/backend/opencl/kernels/rx/FindSharesKernel.h

@@ -0,0 +1,50 @@
+/* XMRig
+ * Copyright 2010      Jeff Garzik <jgarzik@pobox.com>
+ * Copyright 2012-2014 pooler      <pooler@litecoinpool.org>
+ * Copyright 2014      Lucas Jones <https://github.com/lucasjones>
+ * Copyright 2014-2016 Wolf9466    <https://github.com/OhGodAPet>
+ * Copyright 2016      Jay D Dee   <jayddee246@gmail.com>
+ * Copyright 2017-2018 XMR-Stak    <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright 2018-2019 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2019 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef XMRIG_FINDSHARESKERNEL_H
+#define XMRIG_FINDSHARESKERNEL_H
+
+
+#include "backend/opencl/wrappers/OclKernel.h"
+
+
+namespace xmrig {
+
+
+class FindSharesKernel : public OclKernel
+{
+public:
+    inline FindSharesKernel(cl_program program) : OclKernel(program, "find_shares") {}
+
+    void enqueue(cl_command_queue queue, size_t threads);
+    void setArgs(cl_mem hashes, cl_mem shares);
+    void setTarget(uint64_t target);
+    void setNonce(uint32_t nonce);
+};
+
+
+} // namespace xmrig
+
+
+#endif /* XMRIG_FINDSHARESKERNEL_H */