remove 'newer' hashes that arent really mine

1 files changed, 0 insertions, 168 deletions

diff --git a/src/hash/farmhash.c b/src/hash/farmhash.c
deleted file mode 100644
index 3db7ef4..0000000
--- a/src/hash/farmhash.c
+++ /dev/null
@@ -1,168 +0,0 @@
-#include "../crypto.h" //include city hash too

-#include <stdint.h>

-#include <inttypes.h>

-uint32_t farmhash32len13to24(uint8_t* in, size_t len) {

-    uint32_t seed = 0;

-    uint32_t a = UNALIGNED_LOAD32(in - 4 + (len >> 1));

-    uint32_t b = UNALIGNED_LOAD32(in + 4);

-    uint32_t c = UNALIGNED_LOAD32(in + len - 8);

-    uint32_t d = UNALIGNED_LOAD32(in + (len >> 1));

-    uint32_t e = UNALIGNED_LOAD32(in);

-    uint32_t f = UNALIGNED_LOAD32(in + len - 4);

-    uint32_t h = d * c1 + len + seed;

-    a = rot32(a, 12) + f;

-    h = mur(c, h) + a;

-    a = rot32(a, 3) + c;

-    h = mur(e, h) + a;

-    a = rot32(a + f, 12) + d;

-    h = mur(b ^ seed, h) + a;

-    return fmix(h);

-}

-

-uint32_t farmhash32(uint8_t* in, size_t len){

-    if(len <= 24){

-        if(len <= 12){

-            if(len <= 4) return hash32len0to4(in, len);

-            else return hash32len5to12(in, len);

-        } else return farmhash32len13to24(in, len);

-    }

-

-    uint32_t h = len, g = c1 * len, f = g;

-    uint32_t a0 = rot32(UNALIGNED_LOAD32(in + len - 4) * c1, 17) * c2;

-    uint32_t a1 = rot32(UNALIGNED_LOAD32(in + len - 8) * c1, 17) * c2;

-    uint32_t a2 = rot32(UNALIGNED_LOAD32(in + len - 16) * c1, 17) * c2;

-    uint32_t a3 = rot32(UNALIGNED_LOAD32(in + len - 12) * c1, 17) * c2;

-    uint32_t a4 = rot32(UNALIGNED_LOAD32(in + len - 20) * c1, 17) * c2;

-

-    h ^= a0;

-    h = rot32(h, 19);

-    h = h * 5 + 0xe6546b64;

-    h ^= a2;

-    h = rot32(h, 19);

-    h = h * 5 + 0xe6546b64;

-    g ^= a1;

-    g = rot32(g, 19);

-    g = g * 5 + 0xe6546b64;

-    g ^= a3;

-    g = rot32(g, 19);

-    g = g * 5 + 0xe6546b64;

-    f += a4;

-    f = rot32(f, 19) + 113;

-    size_t iters = (len - 1) / 20;

-    for(int i = (len - 1) / 20; i != 0; i--){

-        uint32_t a = UNALIGNED_LOAD32(in);

-        uint32_t b = UNALIGNED_LOAD32(in + 4);

-        uint32_t c = UNALIGNED_LOAD32(in + 8);

-        uint32_t d = UNALIGNED_LOAD32(in + 12);

-        uint32_t e = UNALIGNED_LOAD32(in + 16);

-        h += a;

-        g += b;

-        f += c;

-        h = mur(d, h) + e;

-        g = mur(c, g) + a;

-        f = mur(b + e * c1, f) + d;

-        f += g;

-        g += f;

-        in += 20;

-    }

-    g = rot32(g, 11) * c1;

-    g = rot32(g, 17) * c1;

-    f = rot32(f, 11) * c1;

-    f = rot32(f, 17) * c1;

-    h = rot32(h + g, 19);

-    h = h * 5 + 0xe6546b64;

-    h = rot32(h, 17) * c1;

-    h = rot32(h + f, 19);

-    h = h * 5 + 0xe6546b64;

-    h = rot32(h, 17) * c1;

-    return h;

-}

-

-uint64_t farmhashlen33to64(uint8_t *s, size_t len) {

-  uint64_t mul = k2 + len * 2;

-  uint64_t a = UNALIGNED_LOAD64(s) * k2;

-  uint64_t b = UNALIGNED_LOAD64(s + 8);

-  uint64_t c = UNALIGNED_LOAD64(s + len - 8) * mul;

-  uint64_t d = UNALIGNED_LOAD64(s + len - 16) * k2;

-  uint64_t y = rot64(a + b, 43) + rot64(c, 30) + d;

-  uint64_t z = hashlen16(y, a + rot64(b + k2, 18) + c, mul);

-  uint64_t e = UNALIGNED_LOAD64(s + 16) * mul;

-  uint64_t f = UNALIGNED_LOAD64(s + 24);

-  uint64_t g = (y + UNALIGNED_LOAD64(s + len - 32)) * mul;

-  uint64_t h = (z + UNALIGNED_LOAD64(s + len - 24)) * mul;

-  return hashlen16(rot64(e + f, 43) + rot64(g, 30) + h,

-                   e + rot64(f + a, 18) + g, mul);

-}

-

-uint64_t farmhash64(uint8_t* in, size_t len){

-    if(len <= 32){

-        if(len <= 16) return hashlen0to16(in, len);

-        else return hashlen17to32(in, len);

-    } else if(len <= 64) return farmhashlen33to64(in, len);

-

-    uint64_t seed = 81;

-    uint64_t x = seed;

-    uint64_t y = seed * k1 + 113;

-    uint64_t z = shiftmix(y * k2 + 113) * k2;

-

-    uint64_t v1 = 0, w1 = 0;

-    int64_t  v2 = 0, w2 = 0; 

-    x = x * k2 + UNALIGNED_LOAD64(in);

-    uint8_t* end = in + ((len - 1) / 64) * 64;

-    uint8_t* last64 = end + ((len - 1) & 63) - 63;

-    //assert(in + len - 64 == last64);

-    for(; in != end; in += 64) {

-        x = rot64(x + y + v1 + UNALIGNED_LOAD64(in + 8), 37) * k1;

-        y = rot64(y + v2 + UNALIGNED_LOAD64(in + 48), 42) * k1;

-        x ^= w2;

-        y += v1 + UNALIGNED_LOAD64(in + 40);

-        z = rot64(z + w1, 33) * k1;

-        pWeakHashLen32WithSeeds(in, v2 * k1, x + w1, &v1, &v2);

-        pWeakHashLen32WithSeeds(in + 32, z + w2, y + UNALIGNED_LOAD64(in + 16), &w1, &w2);

-        uint64_t temp = z;

-        z = x; x = temp;

-    }

-    uint64_t mul = k1 + ((z & 0xff) << 1);

-

-    in = last64;

-    w1 += ((len - 1) & 63);

-    v1 += w1;

-    w1 += v1;

-    x = rot64(x + y + v1 + UNALIGNED_LOAD64(in + 8), 37) * mul;

-    y = rot64(y + v2 + UNALIGNED_LOAD64(in + 48), 42) * mul;

-    x ^= w2 * 9;

-    y += v1 * 9 + UNALIGNED_LOAD64(in + 40);

-    z = rot64(z + w1, 33) * mul;

-    pWeakHashLen32WithSeeds(in, v2 * mul, x + w1, &v1, &v2);

-    pWeakHashLen32WithSeeds(in + 32, z + w2, y + UNALIGNED_LOAD64(in + 16), &w1, &w2);

-    uint64_t temp = z;

-    z = x; x = temp;

-    return hashlen16(hashlen16(v1, w1, mul) + shiftmix(y) * k0 + z,

-                    hashlen16(v2, w2, mul) + x,

-                    mul);

-    return 1;

-}

-

-int l_farmhash32(lua_State* L){ 

-  size_t len = 0;

-  uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len);

-  

-  char digest[32];

-

-  uint32_t u = farmhash32(a, len);

-  sprintf(digest,"%04"PRIx32,u);

-  lua_pushstring(L, digest);

-  return 1;

-}

-

-int l_farmhash64(lua_State* L){ 

-  size_t len = 0;

-  uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len);

-  

-  char digest[64];

-

-  uint64_t u = farmhash64(a, len);

-  sprintf(digest,"%016"PRIx64,u);

-  lua_pushstring(L, digest);

-  return 1;

-}