@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/tlx/meta.hpp

@@ -1,55 +0,0 @@
-/*******************************************************************************
- * tlx/meta.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_META_HEADER
-#define TLX_META_HEADER
-
-//! \defgroup tlx_meta Meta-Template Programming
-//! Tools for easier meta-template programming
-
-/*[[[perl
-foreach (sort glob("tlx/meta/"."*.hpp")) {
-  print "#include <$_> // NOLINT(misc-include-cleaner)\n"
-}
-]]]*/
-#include <tlx/meta/apply_tuple.hpp>        // NOLINT(misc-include-cleaner)
-#include <tlx/meta/call_for_range.hpp>     // NOLINT(misc-include-cleaner)
-#include <tlx/meta/call_foreach.hpp>       // NOLINT(misc-include-cleaner)
-#include <tlx/meta/call_foreach_tuple.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/meta/call_foreach_tuple_with_index.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/meta/call_foreach_with_index.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/meta/enable_if.hpp>               // NOLINT(misc-include-cleaner)
-#include <tlx/meta/fold_left.hpp>               // NOLINT(misc-include-cleaner)
-#include <tlx/meta/fold_left_tuple.hpp>         // NOLINT(misc-include-cleaner)
-#include <tlx/meta/fold_right.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/meta/fold_right_tuple.hpp>        // NOLINT(misc-include-cleaner)
-#include <tlx/meta/function_chain.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/meta/function_stack.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/meta/has_member.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/meta/has_method.hpp>              // NOLINT(misc-include-cleaner)
-#include <tlx/meta/index_sequence.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/meta/is_std_array.hpp>            // NOLINT(misc-include-cleaner)
-#include <tlx/meta/is_std_pair.hpp>             // NOLINT(misc-include-cleaner)
-#include <tlx/meta/is_std_tuple.hpp>            // NOLINT(misc-include-cleaner)
-#include <tlx/meta/is_std_vector.hpp>           // NOLINT(misc-include-cleaner)
-#include <tlx/meta/log2.hpp>                    // NOLINT(misc-include-cleaner)
-#include <tlx/meta/no_operation.hpp>            // NOLINT(misc-include-cleaner)
-#include <tlx/meta/static_index.hpp>            // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vexpand.hpp>                 // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vmap_for_range.hpp>          // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vmap_foreach.hpp>            // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vmap_foreach_tuple.hpp>      // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vmap_foreach_tuple_with_index.hpp> // NOLINT(misc-include-cleaner)
-#include <tlx/meta/vmap_foreach_with_index.hpp> // NOLINT(misc-include-cleaner)
-// [[[end]]]
-
-#endif // !TLX_META_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/multi_timer.hpp

@@ -1,148 +0,0 @@
-/*******************************************************************************
- * tlx/multi_timer.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018-2019 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_MULTI_TIMER_HEADER
-#define TLX_MULTI_TIMER_HEADER
-
-#include <chrono>
-#include <cstdint>
-#include <ostream>
-#include <vector>
-
-namespace tlx {
-
-/*!
- * MultiTimer can be used to measure time usage of different phases in a program
- * or algorithm. It contains multiple named "timers", which can be activated
- * without prior definition. At most one timer is start at any time, which
- * means `start()` will stop any current timer and start a new one.
- *
- * Timers are identified by strings, which are passed as const char*, which MUST
- * remain valid for the lifetime of the MultiTimer. Dynamic strings will not
- * work, the standard way is to use plain string literals. The strings are hash
- * for faster searches.
- *
- * MultiTimer can also be used for multi-threading parallel programs. Each
- * thread must create and keep its own MultiTimer instance, which can then be
- * added together into a global MultiTimer object. The add() method of the
- * global object is internally thread-safe using a global mutex.
- */
-class MultiTimer
-{
-public:
-    //! constructor
-    MultiTimer();
-
-    //! default copy-constructor
-    MultiTimer(const MultiTimer&);
-    //! default assignment operator
-    MultiTimer& operator=(const MultiTimer&);
-    //! move-constructor: default
-    MultiTimer(MultiTimer&&) noexcept;
-    //! move-assignment operator: default
-    MultiTimer& operator=(MultiTimer&&) noexcept;
-
-    //! destructor
-    ~MultiTimer();
-
-    //! start new timer phase, stop the currently running one.
-    void start(const char* timer);
-
-    //! stop the currently running timer.
-    void stop();
-
-    //! zero timers.
-    void reset();
-
-    //! return name of currently running timer.
-    const char* running() const;
-
-    //! return timer duration in seconds of timer.
-    double get(const char* timer);
-    //! return total duration of all timers.
-    double total() const;
-
-    //! print all timers as a TIMER line to os
-    void print(const char* info, std::ostream& os) const;
-    //! print all timers as a TIMER line to stderr
-    void print(const char* info) const;
-
-    //! add all timers from another, internally holds a global mutex lock,
-    //! because this is used to add thread values
-    MultiTimer& add(const MultiTimer& b);
-
-    //! add all timers from another, internally holds a global mutex lock,
-    //! because this is used to add thread values
-    MultiTimer& operator+=(const MultiTimer& b);
-
-private:
-    //! timer entry
-    struct Entry;
-
-    //! array of timers
-    std::vector<Entry> timers_;
-
-    //! total duration
-    std::chrono::duration<double> total_duration_;
-
-    //! currently running timer name
-    const char* running_ = nullptr;
-    //! hash of running_
-    std::uint32_t running_hash_ = 0;
-    //! start of currently running timer name
-    std::chrono::time_point<std::chrono::high_resolution_clock> time_point_;
-
-    //! internal methods to find or create new timer entries
-    Entry& find_or_create(const char* name);
-};
-
-//! RAII Scoped MultiTimer switcher: switches the timer of a MultiTimer on
-//! construction and back to old one on destruction.
-class ScopedMultiTimerSwitch
-{
-public:
-    //! construct and timer to switch to
-    ScopedMultiTimerSwitch(MultiTimer& timer, const char* new_timer);
-
-    //! change back timer to previous timer.
-    ~ScopedMultiTimerSwitch();
-
-private:
-    //! reference to MultiTimer
-    MultiTimer& timer_;
-
-    //! previous timer, used to switch back to on destruction
-    const char* previous_;
-};
-
-//! Independent RAII Scoped MultiTimer: contains a MultiTimer which is started
-//! with the given timer, and added to the base MultiTimer on destruction.
-class ScopedMultiTimer
-{
-public:
-    //! construct and change timer to tm
-    ScopedMultiTimer(MultiTimer& base, const char* timer);
-
-    //! change back timer to previous timer.
-    ~ScopedMultiTimer();
-
-private:
-    //! reference to base timer
-    MultiTimer& base_;
-
-    //! contained independent timer
-    MultiTimer timer_;
-};
-
-} // namespace tlx
-
-#endif // !TLX_MULTI_TIMER_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/port/setenv.hpp

@@ -1,31 +0,0 @@
-/*******************************************************************************
- * tlx/port/setenv.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2016-2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_PORT_SETENV_HEADER
-#define TLX_PORT_SETENV_HEADER
-
-namespace tlx {
-
-//! \addtogroup tlx_port
-//! \{
-
-/*!
- * setenv - change or add an environment variable.
- * Windows porting madness because setenv() is apparently dangerous.
- */
-int setenv(const char* name, const char* value, int overwrite);
-
-//! \}
-
-} // namespace tlx
-
-#endif // !TLX_PORT_SETENV_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/port.hpp

@@ -1,27 +0,0 @@
-/*******************************************************************************
- * tlx/port.hpp
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_PORT_HEADER
-#define TLX_PORT_HEADER
-
-//! \defgroup tlx_port Helpers for Portable Code
-//! Tools to enable easier writing of portable code.
-
-/*[[[perl
-foreach (sort glob("tlx/port/"."*.hpp")) {
-  print "#include <$_> // NOLINT(misc-include-cleaner)\n";
-}
-]]]*/
-#include <tlx/port/setenv.hpp> // NOLINT(misc-include-cleaner)
-// [[[end]]]
-
-#endif // !TLX_PORT_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/semaphore.hpp

@@ -1,119 +0,0 @@
-/*******************************************************************************
- * tlx/semaphore.hpp
- *
- * A simple semaphore implementation using C++11 synchronization methods.
- *
- * Copied and modified from STXXL https://github.com/stxxl/stxxl, which is
- * distributed under the Boost Software License, Version 1.0.
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2002 Roman Dementiev <dementiev@mpi-sb.mpg.de>
- * Copyright (C) 2013-2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_SEMAPHORE_HEADER
-#define TLX_SEMAPHORE_HEADER
-
-#include <condition_variable>
-#include <cstddef>
-#include <mutex>
-
-namespace tlx {
-
-//! A simple semaphore implementation using C++11 synchronization methods.
-class Semaphore
-{
-public:
-    //! construct semaphore
-    explicit Semaphore(size_t initial_value = 0) : value_(initial_value)
-    {
-    }
-
-    //! non-copyable: delete copy-constructor
-    Semaphore(const Semaphore&) = delete;
-    //! non-copyable: delete assignment operator
-    Semaphore& operator=(const Semaphore&) = delete;
-
-    //! move-constructor: just move the value
-    Semaphore(Semaphore&& s) noexcept : value_(s.value_)
-    {
-    }
-
-    //! move-assignment: just move the value
-    Semaphore& operator=(Semaphore&& s) noexcept
-    {
-        value_ = s.value_;
-        return *this;
-    }
-
-    //! function increments the semaphore and signals any threads that are
-    //! blocked waiting a change in the semaphore
-    size_t signal()
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        size_t res = ++value_;
-        cv_.notify_one();
-        return res;
-    }
-
-    //! function increments the semaphore and signals any threads that are
-    //! blocked waiting a change in the semaphore
-    size_t signal(size_t delta)
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        size_t res = (value_ += delta);
-        cv_.notify_all();
-        return res;
-    }
-
-    //! function decrements the semaphore by delta and blocks if the semaphore
-    //! is < (delta + slack) until another thread signals a change
-    size_t wait(size_t delta = 1, size_t slack = 0)
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        while (value_ < delta + slack)
-            cv_.wait(lock);
-        value_ -= delta;
-        return value_;
-    }
-
-    //! function decrements the semaphore by delta if (delta + slack) tokens are
-    //! available as a batch. the function will not block and returns true if
-    //! delta was acquired otherwise false.
-    bool try_acquire(size_t delta = 1, size_t slack = 0)
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        if (value_ < delta + slack)
-            return false;
-        value_ -= delta;
-        return true;
-    }
-
-    //! return the current value -- should only be used for debugging.
-    size_t value() const
-    {
-        return value_;
-    }
-
-private:
-    //! value of the semaphore
-    size_t value_;
-
-    //! mutex for condition variable
-    std::mutex mutex_;
-
-    //! condition variable
-    std::condition_variable cv_;
-};
-
-//! alias for STL-like code style
-using semaphore = Semaphore;
-
-} // namespace tlx
-
-#endif // !TLX_SEMAPHORE_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/simple_vector.hpp

@@ -1,20 +0,0 @@
-/*******************************************************************************
- * tlx/simple_vector.hpp
- *
- * Alias for <tlx/container/simple_vector.hpp>
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_SIMPLE_VECTOR_HEADER
-#define TLX_SIMPLE_VECTOR_HEADER
-
-#include <tlx/container/simple_vector.hpp> // NOLINT(misc-include-cleaner)
-
-#endif // !TLX_SIMPLE_VECTOR_HEADER
-
-/******************************************************************************/

package/vendor/include/tlx/siphash.hpp

@@ -1,282 +0,0 @@
-/*******************************************************************************
- * tlx/siphash.hpp
- *
- * SipHash Implementations borrowed under Public Domain license from
- * https://github.com/floodyberry/siphash
- *
- * Part of tlx - http://panthema.net/tlx
- *
- * Copyright (C) 2017-2024 Timo Bingmann <tb@panthema.net>
- *
- * All rights reserved. Published under the Boost Software License, Version 1.0
- ******************************************************************************/
-
-#ifndef TLX_SIPHASH_HEADER
-#define TLX_SIPHASH_HEADER
-
-#include <tlx/container/string_view.hpp>
-#include <tlx/define/attribute_fallthrough.hpp>
-#include <tlx/math/bswap_le.hpp>
-#include <tlx/math/rol.hpp>
-#include <cstdint>
-#include <cstdlib>
-
-#if defined(_MSC_VER)
-
-#include <intrin.h>
-
-#if (_MSC_VER > 1200) || defined(_mm_free)
-#define __SSE2__
-#endif
-
-#endif // !defined(_MSC_VER)
-
-#if defined(__SSE2__)
-#include <emmintrin.h>
-#include <xmmintrin.h>
-#endif
-
-namespace tlx {
-
-static inline std::uint64_t siphash_plain(const std::uint8_t key[16],
-                                          const std::uint8_t* m, size_t len)
-{
-    std::uint64_t v0, v1, v2, v3;
-    std::uint64_t mi, k0, k1;
-    std::uint64_t last7;
-    size_t i, blocks;
-
-    k0 = bswap64_le(*reinterpret_cast<const std::uint64_t*>(key + 0));
-    k1 = bswap64_le(*reinterpret_cast<const std::uint64_t*>(key + 8));
-    v0 = k0 ^ 0x736f6d6570736575ULL;
-    v1 = k1 ^ 0x646f72616e646f6dULL;
-    v2 = k0 ^ 0x6c7967656e657261ULL;
-    v3 = k1 ^ 0x7465646279746573ULL;
-
-    last7 = static_cast<std::uint64_t>(len & 0xff) << 56;
-
-#define TLX_SIPCOMPRESS()                                                      \
-    v0 += v1;                                                                  \
-    v2 += v3;                                                                  \
-    v1 = rol64(v1, 13);                                                        \
-    v3 = rol64(v3, 16);                                                        \
-    v1 ^= v0;                                                                  \
-    v3 ^= v2;                                                                  \
-    v0 = rol64(v0, 32);                                                        \
-    v2 += v1;                                                                  \
-    v0 += v3;                                                                  \
-    v1 = rol64(v1, 17);                                                        \
-    v3 = rol64(v3, 21);                                                        \
-    v1 ^= v2;                                                                  \
-    v3 ^= v0;                                                                  \
-    v2 = rol64(v2, 32);
-
-    for (i = 0, blocks = (len & ~7); i < blocks; i += 8)
-    {
-        mi = bswap64_le(*reinterpret_cast<const std::uint64_t*>(m + i));
-        v3 ^= mi;
-        TLX_SIPCOMPRESS();
-        TLX_SIPCOMPRESS();
-        v0 ^= mi;
-    }
-
-    switch (len - blocks)
-    {
-    case 7:
-        last7 |= static_cast<std::uint64_t>(m[i + 6]) << 48;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 6:
-        last7 |= static_cast<std::uint64_t>(m[i + 5]) << 40;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 5:
-        last7 |= static_cast<std::uint64_t>(m[i + 4]) << 32;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 4:
-        last7 |= static_cast<std::uint64_t>(m[i + 3]) << 24;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 3:
-        last7 |= static_cast<std::uint64_t>(m[i + 2]) << 16;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 2:
-        last7 |= static_cast<std::uint64_t>(m[i + 1]) << 8;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 1:
-        last7 |= static_cast<std::uint64_t>(m[i + 0]);
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 0:
-    default:;
-    }
-
-    v3 ^= last7;
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    v0 ^= last7;
-    v2 ^= 0xff;
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-
-#undef TLX_SIPCOMPRESS
-
-    return v0 ^ v1 ^ v2 ^ v3;
-}
-
-/******************************************************************************/
-// SSE2 vectorization
-
-#if defined(__SSE2__)
-
-union siphash_packedelem64
-{
-    std::uint64_t u[2];
-    __m128i v;
-};
-
-/* 0,2,1,3 */
-static const siphash_packedelem64 siphash_init[2] = {
-    {{0x736f6d6570736575ULL, 0x6c7967656e657261ULL}},
-    {{0x646f72616e646f6dULL, 0x7465646279746573ULL}}};
-
-static const siphash_packedelem64 siphash_final = {
-    {0x0000000000000000ULL, 0x00000000000000ffULL}};
-
-static inline std::uint64_t siphash_sse2(const std::uint8_t key[16],
-                                         const std::uint8_t* m, size_t len)
-{
-    __m128i k, v02, v20, v13, v11, v33, mi;
-    std::uint64_t last7;
-    std::uint32_t lo, hi;
-    size_t i, blocks;
-
-    k = _mm_loadu_si128(reinterpret_cast<const __m128i*>(key + 0));
-    v02 = siphash_init[0].v;
-    v13 = siphash_init[1].v;
-    v02 = _mm_xor_si128(v02, _mm_unpacklo_epi64(k, k));
-    v13 = _mm_xor_si128(v13, _mm_unpackhi_epi64(k, k));
-
-    last7 = static_cast<std::uint64_t>(len & 0xff) << 56;
-
-#define TLX_SIPCOMPRESS()                                                      \
-    v11 = v13;                                                                 \
-    v33 = _mm_shuffle_epi32(v13, _MM_SHUFFLE(1, 0, 3, 2));                     \
-    v11 = _mm_or_si128(_mm_slli_epi64(v11, 13), _mm_srli_epi64(v11, 64 - 13)); \
-    v02 = _mm_add_epi64(v02, v13);                                             \
-    v33 = _mm_shufflelo_epi16(v33, _MM_SHUFFLE(2, 1, 0, 3));                   \
-    v13 = _mm_unpacklo_epi64(v11, v33);                                        \
-    v13 = _mm_xor_si128(v13, v02);                                             \
-    v20 = _mm_shuffle_epi32(v02, _MM_SHUFFLE(0, 1, 3, 2));                     \
-    v11 = v13;                                                                 \
-    v33 = _mm_shuffle_epi32(v13, _MM_SHUFFLE(1, 0, 3, 2));                     \
-    v11 = _mm_or_si128(_mm_slli_epi64(v11, 17), _mm_srli_epi64(v11, 64 - 17)); \
-    v20 = _mm_add_epi64(v20, v13);                                             \
-    v33 = _mm_or_si128(_mm_slli_epi64(v33, 21), _mm_srli_epi64(v33, 64 - 21)); \
-    v13 = _mm_unpacklo_epi64(v11, v33);                                        \
-    v02 = _mm_shuffle_epi32(v20, _MM_SHUFFLE(0, 1, 3, 2));                     \
-    v13 = _mm_xor_si128(v13, v20);
-
-    for (i = 0, blocks = (len & ~7); i < blocks; i += 8)
-    {
-        mi = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(m + i));
-        v13 = _mm_xor_si128(v13, _mm_slli_si128(mi, 8));
-        TLX_SIPCOMPRESS();
-        TLX_SIPCOMPRESS();
-        v02 = _mm_xor_si128(v02, mi);
-    }
-
-    switch (len - blocks)
-    {
-    case 7:
-        last7 |= static_cast<std::uint64_t>(m[i + 6]) << 48;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 6:
-        last7 |= static_cast<std::uint64_t>(m[i + 5]) << 40;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 5:
-        last7 |= static_cast<std::uint64_t>(m[i + 4]) << 32;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 4:
-        last7 |= static_cast<std::uint64_t>(m[i + 3]) << 24;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 3:
-        last7 |= static_cast<std::uint64_t>(m[i + 2]) << 16;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 2:
-        last7 |= static_cast<std::uint64_t>(m[i + 1]) << 8;
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 1:
-        last7 |= static_cast<std::uint64_t>(m[i + 0]);
-        TLX_ATTRIBUTE_FALLTHROUGH;
-    case 0:
-    default:;
-    }
-
-    mi = _mm_unpacklo_epi32(
-        _mm_cvtsi32_si128(static_cast<std::uint32_t>(last7)),
-        _mm_cvtsi32_si128(static_cast<std::uint32_t>(last7 >> 32)));
-    v13 = _mm_xor_si128(v13, _mm_slli_si128(mi, 8));
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    v02 = _mm_xor_si128(v02, mi);
-    v02 = _mm_xor_si128(v02, siphash_final.v);
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-    TLX_SIPCOMPRESS();
-
-    v02 = _mm_xor_si128(v02, v13);
-    v02 = _mm_xor_si128(v02, _mm_shuffle_epi32(v02, _MM_SHUFFLE(1, 0, 3, 2)));
-    lo = _mm_cvtsi128_si32(v02);
-    hi = _mm_cvtsi128_si32(_mm_srli_si128(v02, 4));
-
-#undef TLX_SIPCOMPRESS
-
-    return (static_cast<std::uint64_t>(hi) << 32) | lo;
-}
-
-#endif // defined(__SSE2__)
-
-/******************************************************************************/
-// Switch between available implementations
-
-static inline std::uint64_t siphash(const std::uint8_t key[16],
-                                    const std::uint8_t* msg, size_t size)
-{
-#if defined(__SSE2__)
-    return siphash_sse2(key, msg, size);
-#else
-    return siphash_plain(key, msg, size);
-#endif
-}
-
-static inline std::uint64_t siphash(const std::uint8_t* msg, size_t size)
-{
-    const unsigned char key[16] = {0, 1, 2,  3,  4,  5,  6,  7,
-                                   8, 9, 10, 11, 12, 13, 14, 15};
-    return siphash(key, msg, size);
-}
-
-static inline std::uint64_t siphash(const char* msg, size_t size)
-{
-    return siphash(reinterpret_cast<const std::uint8_t*>(msg), size);
-}
-
-static inline std::uint64_t siphash(tlx::string_view str)
-{
-    return siphash(str.data(), str.size());
-}
-
-template <typename Type>
-static inline std::uint64_t siphash(const Type& value)
-{
-    return siphash(reinterpret_cast<const std::uint8_t*>(&value),
-                   sizeof(value));
-}
-
-#undef rol64
-
-} // namespace tlx
-
-#endif // !TLX_SIPHASH_HEADER
-
-/******************************************************************************/