chore: 添加虚拟环境到仓库

- 添加 backend_service/venv 虚拟环境
- 包含所有Python依赖包
- 注意：虚拟环境约393MB，包含12655个文件

backend_service/venv/lib/python3.13/site-packages/mmh3/__init__.pyi

@@ -0,0 +1,67 @@
+import sys
+from typing import Any, Union, final
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from _typeshed import ReadableBuffer as Buffer
+
+def hash(key: Union[bytes, str], seed: int = 0, signed: Any = True) -> int: ...
+def hash_from_buffer(
+    key: Union[Buffer, str], seed: int = 0, signed: Any = True
+) -> int: ...
+def hash64(
+    key: Union[bytes, str], seed: int = 0, x64arch: Any = True, signed: Any = True
+) -> tuple[int, int]: ...
+def hash128(
+    key: Union[bytes, str], seed: int = 0, x64arch: Any = True, signed: Any = False
+) -> int: ...
+def hash_bytes(key: Union[bytes, str], seed: int = 0, x64arch: Any = True) -> bytes: ...
+def mmh3_32_digest(key: Union[Buffer, str], seed: int = 0) -> bytes: ...
+def mmh3_32_sintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_32_uintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_x64_128_digest(key: Union[Buffer, str], seed: int = 0) -> bytes: ...
+def mmh3_x64_128_sintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_x64_128_uintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_x64_128_stupledigest(
+    key: Union[Buffer, str], seed: int = 0
+) -> tuple[int, int]: ...
+def mmh3_x64_128_utupledigest(
+    key: Union[Buffer, str], seed: int = 0
+) -> tuple[int, int]: ...
+def mmh3_x86_128_digest(key: Union[Buffer, str], seed: int = 0) -> bytes: ...
+def mmh3_x86_128_sintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_x86_128_uintdigest(key: Union[Buffer, str], seed: int = 0) -> int: ...
+def mmh3_x86_128_stupledigest(
+    key: Union[Buffer, str], seed: int = 0
+) -> tuple[int, int]: ...
+def mmh3_x86_128_utupledigest(
+    key: Union[Buffer, str], seed: int = 0
+) -> tuple[int, int]: ...
+
+class Hasher:
+    def __init__(self, data: Union[Buffer, None] = None, seed: int = 0) -> None: ...
+    def update(self, data: Buffer) -> None: ...
+    def digest(self) -> bytes: ...
+    def sintdigest(self) -> int: ...
+    def uintdigest(self) -> int: ...
+    def copy(self) -> Hasher: ...
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+
+@final
+class mmh3_32(Hasher): ...
+
+@final
+class mmh3_x64_128(Hasher):
+    def stupledigest(self) -> tuple[int, int]: ...
+    def utupledigest(self) -> tuple[int, int]: ...
+
+@final
+class mmh3_x86_128(Hasher):
+    def stupledigest(self) -> tuple[int, int]: ...
+    def utupledigest(self) -> tuple[int, int]: ...

backend_service/venv/lib/python3.13/site-packages/mmh3/hashlib.h

@@ -0,0 +1,84 @@
+// This code was taken from a part of CPython's code base (Modules/hashlib.h)
+// at commit 9ce0f48e918860ffa32751a85b0fe7967723e2e3
+// Below is a copy of the license of CPython
+
+// PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+// --------------------------------------------
+//
+// 1. This LICENSE AGREEMENT is between the Python Software Foundation
+// ("PSF"), and the Individual or Organization ("Licensee") accessing and
+// otherwise using this software ("Python") in source or binary form and
+// its associated documentation.
+//
+// 2. Subject to the terms and conditions of this License Agreement, PSF hereby
+// grants Licensee a nonexclusive, royalty-free, world-wide license to
+// reproduce, analyze, test, perform and/or display publicly, prepare
+// derivative works, distribute, and otherwise use Python alone or in any
+// derivative version, provided, however, that PSF's License Agreement and
+// PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004,
+// 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016,
+// 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation; All
+// Rights Reserved" are retained in Python alone or in any derivative version
+// prepared by Licensee.
+//
+// 3. In the event Licensee prepares a derivative work that is based on
+// or incorporates Python or any part thereof, and wants to make
+// the derivative work available to others as provided herein, then
+// Licensee hereby agrees to include in any such work a brief summary of
+// the changes made to Python.
+//
+// 4. PSF is making Python available to Licensee on an "AS IS"
+// basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+// IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+// DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+// FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+// INFRINGE ANY THIRD PARTY RIGHTS.
+//
+// 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+// FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+// A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+// OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+//
+// 6. This License Agreement will automatically terminate upon a material
+// breach of its terms and conditions.
+//
+// 7. Nothing in this License Agreement shall be deemed to create any
+// relationship of agency, partnership, or joint venture between PSF and
+// Licensee.  This License Agreement does not grant permission to use PSF
+// trademarks or trade name in a trademark sense to endorse or promote
+// products or services of Licensee, or any third party.
+//
+// 8. By copying, installing or otherwise using Python, Licensee
+// agrees to be bound by the terms and conditions of this License
+// Agreement.
+
+/*
+ * Given a PyObject* obj, fill in the Py_buffer* viewp with the result
+ * of PyObject_GetBuffer.  Sets an exception and issues the erraction
+ * on any errors, e.g. 'return NULL' or 'goto error'.
+ */
+#define GET_BUFFER_VIEW_OR_ERROR(obj, viewp, erraction)                   \
+    do {                                                                  \
+        if (PyUnicode_Check((obj))) {                                     \
+            PyErr_SetString(PyExc_TypeError,                              \
+                            "Strings must be encoded before hashing");    \
+            erraction;                                                    \
+        }                                                                 \
+        if (!PyObject_CheckBuffer((obj))) {                               \
+            PyErr_SetString(PyExc_TypeError,                              \
+                            "object supporting the buffer API required"); \
+            erraction;                                                    \
+        }                                                                 \
+        if (PyObject_GetBuffer((obj), (viewp), PyBUF_SIMPLE) == -1) {     \
+            erraction;                                                    \
+        }                                                                 \
+        if ((viewp)->ndim > 1) {                                          \
+            PyErr_SetString(PyExc_BufferError,                            \
+                            "Buffer must be single dimension");           \
+            PyBuffer_Release((viewp));                                    \
+            erraction;                                                    \
+        }                                                                 \
+    } while (0)
+
+#define GET_BUFFER_VIEW_OR_ERROUT(obj, viewp) \
+    GET_BUFFER_VIEW_OR_ERROR(obj, viewp, return NULL)

backend_service/venv/lib/python3.13/site-packages/mmh3/murmurhash3.c

@@ -0,0 +1,365 @@
+/***
+ * This file is under MIT <year> Hajime Senuma, just like other files.
+ * See LICENSE for details.
+ *
+ * It was originally written by Austin Appleby in C++ under the public domain,
+ * but ported to PEP 7 C for Python 3.6 and later by the mmh3 project.
+ *
+ * Any issues should be reported to https://github.com/hajimes/mmh3/issues.
+ *
+ * The following is the original public domain notice by Austin Appleby.
+ */
+
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+// Note - The x86 and x64 versions do _not_ produce the same results, as the
+// algorithms are optimized for their respective platforms. You can still
+// compile and run any of them on any platform, but your performance with the
+// non-native version will be less than optimal.
+
+#include "murmurhash3.h"
+
+//-----------------------------------------------------------------------------
+
+void
+murmurhash3_x86_32(const void *key, Py_ssize_t len, uint32_t seed, void *out)
+{
+    const uint8_t *data = (const uint8_t *)key;
+    const Py_ssize_t nblocks = len / 4;
+
+    uint32_t h1 = seed;
+
+    const uint32_t c1 = 0xcc9e2d51;
+    const uint32_t c2 = 0x1b873593;
+
+    //----------
+    // body
+
+    const uint32_t *blocks = (const uint32_t *)(data + nblocks * 4);
+
+    for (Py_ssize_t i = -nblocks; i; i++) {
+        uint32_t k1 = getblock32(blocks, i);
+
+        k1 *= c1;
+        k1 = ROTL32(k1, 15);
+        k1 *= c2;
+
+        h1 ^= k1;
+        h1 = ROTL32(h1, 13);
+        h1 = h1 * 5 + 0xe6546b64;
+    }
+
+    //----------
+    // tail
+
+    const uint8_t *tail = (const uint8_t *)(data + nblocks * 4);
+
+    uint32_t k1 = 0;
+
+    switch (len & 3) {
+        case 3:
+            k1 ^= tail[2] << 16;
+        case 2:
+            k1 ^= tail[1] << 8;
+        case 1:
+            k1 ^= tail[0];
+            k1 *= c1;
+            k1 = ROTL32(k1, 15);
+            k1 *= c2;
+            h1 ^= k1;
+    };
+
+    //----------
+    // finalization
+
+    h1 ^= len;
+
+    h1 = fmix32(h1);
+
+    *(uint32_t *)out = h1;
+}
+
+//-----------------------------------------------------------------------------
+
+void
+murmurhash3_x86_128(const void *key, const Py_ssize_t len, uint32_t seed,
+                    void *out)
+{
+    const uint8_t *data = (const uint8_t *)key;
+    const Py_ssize_t nblocks = len / 16;
+
+    uint32_t h1 = seed;
+    uint32_t h2 = seed;
+    uint32_t h3 = seed;
+    uint32_t h4 = seed;
+
+    const uint32_t c1 = 0x239b961b;
+    const uint32_t c2 = 0xab0e9789;
+    const uint32_t c3 = 0x38b34ae5;
+    const uint32_t c4 = 0xa1e38b93;
+
+    //----------
+    // body
+
+    const uint32_t *blocks = (const uint32_t *)(data + nblocks * 16);
+
+    for (Py_ssize_t i = -nblocks; i; i++) {
+        uint32_t k1 = getblock32(blocks, i * 4 + 0);
+        uint32_t k2 = getblock32(blocks, i * 4 + 1);
+        uint32_t k3 = getblock32(blocks, i * 4 + 2);
+        uint32_t k4 = getblock32(blocks, i * 4 + 3);
+
+        k1 *= c1;
+        k1 = ROTL32(k1, 15);
+        k1 *= c2;
+        h1 ^= k1;
+
+        h1 = ROTL32(h1, 19);
+        h1 += h2;
+        h1 = h1 * 5 + 0x561ccd1b;
+
+        k2 *= c2;
+        k2 = ROTL32(k2, 16);
+        k2 *= c3;
+        h2 ^= k2;
+
+        h2 = ROTL32(h2, 17);
+        h2 += h3;
+        h2 = h2 * 5 + 0x0bcaa747;
+
+        k3 *= c3;
+        k3 = ROTL32(k3, 17);
+        k3 *= c4;
+        h3 ^= k3;
+
+        h3 = ROTL32(h3, 15);
+        h3 += h4;
+        h3 = h3 * 5 + 0x96cd1c35;
+
+        k4 *= c4;
+        k4 = ROTL32(k4, 18);
+        k4 *= c1;
+        h4 ^= k4;
+
+        h4 = ROTL32(h4, 13);
+        h4 += h1;
+        h4 = h4 * 5 + 0x32ac3b17;
+    }
+
+    //----------
+    // tail
+
+    const uint8_t *tail = (const uint8_t *)(data + nblocks * 16);
+
+    uint32_t k1 = 0;
+    uint32_t k2 = 0;
+    uint32_t k3 = 0;
+    uint32_t k4 = 0;
+
+    switch (len & 15) {
+        case 15:
+            k4 ^= tail[14] << 16;
+        case 14:
+            k4 ^= tail[13] << 8;
+        case 13:
+            k4 ^= tail[12] << 0;
+            k4 *= c4;
+            k4 = ROTL32(k4, 18);
+            k4 *= c1;
+            h4 ^= k4;
+
+        case 12:
+            k3 ^= tail[11] << 24;
+        case 11:
+            k3 ^= tail[10] << 16;
+        case 10:
+            k3 ^= tail[9] << 8;
+        case 9:
+            k3 ^= tail[8] << 0;
+            k3 *= c3;
+            k3 = ROTL32(k3, 17);
+            k3 *= c4;
+            h3 ^= k3;
+
+        case 8:
+            k2 ^= tail[7] << 24;
+        case 7:
+            k2 ^= tail[6] << 16;
+        case 6:
+            k2 ^= tail[5] << 8;
+        case 5:
+            k2 ^= tail[4] << 0;
+            k2 *= c2;
+            k2 = ROTL32(k2, 16);
+            k2 *= c3;
+            h2 ^= k2;
+
+        case 4:
+            k1 ^= tail[3] << 24;
+        case 3:
+            k1 ^= tail[2] << 16;
+        case 2:
+            k1 ^= tail[1] << 8;
+        case 1:
+            k1 ^= tail[0] << 0;
+            k1 *= c1;
+            k1 = ROTL32(k1, 15);
+            k1 *= c2;
+            h1 ^= k1;
+    };
+
+    //----------
+    // finalization
+
+    h1 ^= len;
+    h2 ^= len;
+    h3 ^= len;
+    h4 ^= len;
+
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+
+    h1 = fmix32(h1);
+    h2 = fmix32(h2);
+    h3 = fmix32(h3);
+    h4 = fmix32(h4);
+
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    ((uint32_t *)out)[0] = h2;
+    ((uint32_t *)out)[1] = h1;
+    ((uint32_t *)out)[2] = h4;
+    ((uint32_t *)out)[3] = h3;
+#else
+    ((uint32_t *)out)[0] = h1;
+    ((uint32_t *)out)[1] = h2;
+    ((uint32_t *)out)[2] = h3;
+    ((uint32_t *)out)[3] = h4;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+
+void
+murmurhash3_x64_128(const void *key, const Py_ssize_t len, const uint32_t seed,
+                    void *out)
+{
+    const uint8_t *data = (const uint8_t *)key;
+    const Py_ssize_t nblocks = len / 16;
+
+    uint64_t h1 = seed;
+    uint64_t h2 = seed;
+
+    const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+    const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+    //----------
+    // body
+
+    const uint64_t *blocks = (const uint64_t *)(data);
+
+    for (Py_ssize_t i = 0; i < nblocks; i++) {
+        uint64_t k1 = getblock64(blocks, i * 2 + 0);
+        uint64_t k2 = getblock64(blocks, i * 2 + 1);
+
+        k1 *= c1;
+        k1 = ROTL64(k1, 31);
+        k1 *= c2;
+        h1 ^= k1;
+
+        h1 = ROTL64(h1, 27);
+        h1 += h2;
+        h1 = h1 * 5 + 0x52dce729;
+
+        k2 *= c2;
+        k2 = ROTL64(k2, 33);
+        k2 *= c1;
+        h2 ^= k2;
+
+        h2 = ROTL64(h2, 31);
+        h2 += h1;
+        h2 = h2 * 5 + 0x38495ab5;
+    }
+
+    //----------
+    // tail
+
+    const uint8_t *tail = (const uint8_t *)(data + nblocks * 16);
+
+    uint64_t k1 = 0;
+    uint64_t k2 = 0;
+
+    switch (len & 15) {
+        case 15:
+            k2 ^= ((uint64_t)tail[14]) << 48;
+        case 14:
+            k2 ^= ((uint64_t)tail[13]) << 40;
+        case 13:
+            k2 ^= ((uint64_t)tail[12]) << 32;
+        case 12:
+            k2 ^= ((uint64_t)tail[11]) << 24;
+        case 11:
+            k2 ^= ((uint64_t)tail[10]) << 16;
+        case 10:
+            k2 ^= ((uint64_t)tail[9]) << 8;
+        case 9:
+            k2 ^= ((uint64_t)tail[8]) << 0;
+            k2 *= c2;
+            k2 = ROTL64(k2, 33);
+            k2 *= c1;
+            h2 ^= k2;
+
+        case 8:
+            k1 ^= ((uint64_t)tail[7]) << 56;
+        case 7:
+            k1 ^= ((uint64_t)tail[6]) << 48;
+        case 6:
+            k1 ^= ((uint64_t)tail[5]) << 40;
+        case 5:
+            k1 ^= ((uint64_t)tail[4]) << 32;
+        case 4:
+            k1 ^= ((uint64_t)tail[3]) << 24;
+        case 3:
+            k1 ^= ((uint64_t)tail[2]) << 16;
+        case 2:
+            k1 ^= ((uint64_t)tail[1]) << 8;
+        case 1:
+            k1 ^= ((uint64_t)tail[0]) << 0;
+            k1 *= c1;
+            k1 = ROTL64(k1, 31);
+            k1 *= c2;
+            h1 ^= k1;
+    };
+
+    //----------
+    // finalization
+
+    h1 ^= len;
+    h2 ^= len;
+
+    h1 += h2;
+    h2 += h1;
+
+    h1 = fmix64(h1);
+    h2 = fmix64(h2);
+
+    h1 += h2;
+    h2 += h1;
+
+    ((uint64_t *)out)[0] = h1;
+    ((uint64_t *)out)[1] = h2;
+}
+
+//-----------------------------------------------------------------------------

backend_service/venv/lib/python3.13/site-packages/mmh3/murmurhash3.h

@@ -0,0 +1,325 @@
+/***
+ * This file is under MIT <year> Hajime Senuma, just like other files.
+ * See LICENSE for details.
+ *
+ * It was originally written by Austin Appleby in C++ under the public domain,
+ * but ported to PEP 7 C for Python 3.6 and later by the mmh3 project.
+ *
+ * Any issues should be reported to https://github.com/hajimes/mmh3/issues.
+ *
+ * The following is the original public domain notice by Austin Appleby.
+ */
+
+//-----------------------------------------------------------------------------
+// MurmurHash3 was written by Austin Appleby, and is placed in the public
+// domain. The author hereby disclaims copyright to this source code.
+
+#ifndef _MURMURHASH3_H_
+#define _MURMURHASH3_H_
+
+// To handle 64-bit data; see https://docs.python.org/3/c-api/arg.html
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+#include <Python.h>
+
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#include <byteswap.h>
+#endif
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+
+typedef signed __int8 int8_t;
+typedef signed __int32 int32_t;
+typedef signed __int64 int64_t;
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
+
+// Other compilers
+
+#else  // defined(_MSC_VER)
+
+#include <stdint.h>
+
+#endif  // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+// Microsoft Visual Studio
+
+#if defined(_MSC_VER)
+
+#define FORCE_INLINE __forceinline
+
+#include <stdlib.h>
+
+#define ROTL32(x, y) _rotl(x, y)
+#define ROTL64(x, y) _rotl64(x, y)
+
+#define BIG_CONSTANT(x) (x)
+
+// Other compilers
+
+#else  // defined(_MSC_VER)
+
+#if ((__GNUC__ > 4) || (__GNUC__ == 4 && GNUC_MINOR >= 4))
+/* gcc version >= 4.4 4.1 = RHEL 5, 4.4 = RHEL 6. Don't inline for RHEL 5 gcc
+ * which is 4.1*/
+#define FORCE_INLINE inline __attribute__((always_inline))
+#else
+#define FORCE_INLINE
+#endif
+
+static FORCE_INLINE uint32_t
+rotl32(uint32_t x, int8_t r)
+{
+    return (x << r) | (x >> (32 - r));
+}
+
+static FORCE_INLINE uint64_t
+rotl64(uint64_t x, int8_t r)
+{
+    return (x << r) | (x >> (64 - r));
+}
+
+#define ROTL32(x, y) rotl32(x, y)
+#define ROTL64(x, y) rotl64(x, y)
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+#endif  // !defined(_MSC_VER)
+
+//-----------------------------------------------------------------------------
+// Block read - if your platform needs to do endian-swapping or can only
+// handle aligned reads, do the conversion here
+
+static FORCE_INLINE uint32_t
+getblock32(const uint32_t *p, Py_ssize_t i)
+{
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    return bswap_32(p[i]);
+#else
+    return p[i];
+#endif
+}
+
+static FORCE_INLINE uint64_t
+getblock64(const uint64_t *p, Py_ssize_t i)
+{
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    return bswap_64(p[i]);
+#else
+    return p[i];
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Building blocks for multiply and rotate (MUR) operations.
+// Names are taken from Google Guava's implementation
+
+static FORCE_INLINE uint32_t
+mixK1(uint32_t k1)
+{
+    const uint32_t c1 = 0xcc9e2d51;
+    const uint32_t c2 = 0x1b873593;
+
+    k1 *= c1;
+    k1 = ROTL32(k1, 15);
+    k1 *= c2;
+
+    return k1;
+}
+static FORCE_INLINE uint32_t
+mixH1(uint32_t h1, const uint32_t h2, const uint8_t shift, const uint32_t c1)
+{
+    h1 = ROTL32(h1, shift);
+    h1 += h2;
+    h1 = h1 * 5 + c1;
+
+    return h1;
+}
+static FORCE_INLINE uint64_t
+mixK_x64_128(uint64_t k1, const uint8_t shift, const uint64_t c1,
+             const uint64_t c2)
+{
+    k1 *= c1;
+    k1 = ROTL64(k1, shift);
+    k1 *= c2;
+
+    return k1;
+}
+static FORCE_INLINE uint64_t
+mixK1_x64_128(uint64_t k1)
+{
+    const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+    const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+    k1 *= c1;
+    k1 = ROTL64(k1, 31);
+    k1 *= c2;
+
+    return k1;
+}
+static FORCE_INLINE uint64_t
+mixK2_x64_128(uint64_t k2)
+{
+    const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+    const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+    k2 *= c2;
+    k2 = ROTL64(k2, 33);
+    k2 *= c1;
+
+    return k2;
+}
+static FORCE_INLINE uint64_t
+mixH_x64_128(uint64_t h1, uint64_t h2, const uint8_t shift, const uint32_t c)
+{
+    h1 = ROTL64(h1, shift);
+    h1 += h2;
+    h1 = h1 * 5 + c;
+
+    return h1;
+}
+static FORCE_INLINE uint64_t
+mixK_x86_128(uint32_t k, const uint8_t shift, const uint32_t c1,
+             const uint32_t c2)
+{
+    k *= c1;
+    k = ROTL32(k, shift);
+    k *= c2;
+
+    return k;
+}
+
+//-----------------------------------------------------------------------------
+// Finalization mix - force all bits of a hash block to avalanche
+
+static FORCE_INLINE uint32_t
+fmix32(uint32_t h)
+{
+    h ^= h >> 16;
+    h *= 0x85ebca6b;
+    h ^= h >> 13;
+    h *= 0xc2b2ae35;
+    h ^= h >> 16;
+
+    return h;
+}
+
+//----------
+
+static FORCE_INLINE uint64_t
+fmix64(uint64_t k)
+{
+    k ^= k >> 33;
+    k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+    k ^= k >> 33;
+    k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+    k ^= k >> 33;
+
+    return k;
+}
+
+//-----------------------------------------------------------------------------
+// Finalization function
+
+static FORCE_INLINE void
+digest_x64_128_impl(uint64_t h1, uint64_t h2, const uint64_t k1,
+                    const uint64_t k2, const Py_ssize_t len, const char *out)
+{
+    h1 ^= mixK1_x64_128(k1);
+    h2 ^= mixK2_x64_128(k2);
+    h1 ^= len;
+    h2 ^= len;
+
+    h1 += h2;
+    h2 += h1;
+
+    h1 = fmix64(h1);
+    h2 = fmix64(h2);
+
+    h1 += h2;
+    h2 += h1;
+
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    ((uint64_t *)out)[0] = bswap_64(h1);
+    ((uint64_t *)out)[1] = bswap_64(h2);
+#else
+    ((uint64_t *)out)[0] = h1;
+    ((uint64_t *)out)[1] = h2;
+#endif
+}
+
+static FORCE_INLINE void
+digest_x86_128_impl(uint32_t h1, uint32_t h2, uint32_t h3, uint32_t h4,
+                    const uint32_t k1, const uint32_t k2, const uint32_t k3,
+                    const uint32_t k4, const Py_ssize_t len, const char *out)
+{
+    const uint32_t c1 = 0x239b961b;
+    const uint32_t c2 = 0xab0e9789;
+    const uint32_t c3 = 0x38b34ae5;
+    const uint32_t c4 = 0xa1e38b93;
+
+    h1 ^= mixK_x86_128(k1, 15, c1, c2);
+    h2 ^= mixK_x86_128(k2, 16, c2, c3);
+    h3 ^= mixK_x86_128(k3, 17, c3, c4);
+    h4 ^= mixK_x86_128(k4, 18, c4, c1);
+    h1 ^= len;
+    h2 ^= len;
+    h3 ^= len;
+    h4 ^= len;
+
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+
+    h1 = fmix32(h1);
+    h2 = fmix32(h2);
+    h3 = fmix32(h3);
+    h4 = fmix32(h4);
+
+    h1 += h2;
+    h1 += h3;
+    h1 += h4;
+    h2 += h1;
+    h3 += h1;
+    h4 += h1;
+
+#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+    ((uint32_t *)out)[0] = bswap_32(h1);
+    ((uint32_t *)out)[1] = bswap_32(h2);
+    ((uint32_t *)out)[2] = bswap_32(h3);
+    ((uint32_t *)out)[3] = bswap_32(h4);
+#else
+    ((uint32_t *)out)[0] = h1;
+    ((uint32_t *)out)[1] = h2;
+    ((uint32_t *)out)[2] = h3;
+    ((uint32_t *)out)[3] = h4;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+
+void
+murmurhash3_x86_32(const void *key, Py_ssize_t len, uint32_t seed, void *out);
+
+void
+murmurhash3_x86_128(const void *key, Py_ssize_t len, uint32_t seed, void *out);
+
+void
+murmurhash3_x64_128(const void *key, Py_ssize_t len, uint32_t seed, void *out);
+
+//-----------------------------------------------------------------------------
+
+#endif  // _MURMURHASH3_H_