Function CityHash64

Sources/nCine/Base/HashFunctions.cpp:382–418

	}

	std::uint64_t CityHash64(const char* s, std::size_t len)
	{
		if (len <= 32) {
			if (len <= 16) {
				return HashLen0to16(s, len);
			} else {
				return HashLen17to32(s, len);
			}
		} else if (len <= 64) {
			return HashLen33to64(s, len);
		}

		// For strings over 64 bytes we hash the end first, and then as we
		// loop we keep 56 bytes of state: v, w, x, y, and z.
		std::uint64_t x = Fetch64(s + len - 40);
		std::uint64_t y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
		std::uint64_t z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
		std::pair<std::uint64_t, std::uint64_t> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
		std::pair<std::uint64_t, std::uint64_t> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
		x = x * k1 + Fetch64(s);

		// Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
		len = (len - 1) & ~static_cast<std::size_t>(63);
		do {
			x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
			y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
			x ^= w.second;
			y += v.first + Fetch64(s + 40);
			z = Rotate(z + w.first, 33) * k1;
			v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
			w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
			std::swap(z, x);
			s += 64;
			len -= 64;
		} while (len != 0);
		return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z, HashLen16(v.second, w.second) + x);
	}

	std::uint64_t CityHash64WithSeeds(const char* s, std::size_t len, std::uint64_t seed0, uint64_t seed1)
	{