#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;
typedef int /*<<< orphan*/ uint64_t;
typedef int /*<<< orphan*/ uint32_t;

/* Variables and functions */
int /*<<< orphan*/ htole32(int /*<<< orphan*/ const);
int /*<<< orphan*/ htole64(int /*<<< orphan*/ const);
int /*<<< orphan*/ rgph_read32u(int /*<<< orphan*/ const *, int,
                                int /*<<< orphan*/ *, int /*<<< orphan*/ *,
                                int);
int /*<<< orphan*/ rgph_read64u(int /*<<< orphan*/ const *, int,
                                int /*<<< orphan*/ *, int /*<<< orphan*/ *,
                                int);
int /*<<< orphan*/ rgph_xxh64s_finalise(int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_fmix1(int /*<<< orphan*/ const,
                                     int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_fmix4(int /*<<< orphan*/, int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_fmix8(int /*<<< orphan*/, int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_fold(size_t, int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_init(size_t, uintptr_t, int /*<<< orphan*/ *);
int /*<<< orphan*/ rgph_xxh64s_mix(int /*<<< orphan*/ *, int /*<<< orphan*/ *);
uint64_t rgph_u64_xxh64s_data(const void *data, size_t len, uintptr_t seed) {
  const uint8_t *key = data;
  const uint8_t *end = key + len;
  uint64_t w[4], h[4];
  const int down = ((uintptr_t)key) & 7;
  uint64_t carry =
      len > 0 && down != 0
          ? htole64(*(((const uint64_t *)(const char *)((key - down)))))
          : 0;
  rgph_xxh64s_init(len, seed, h);
  if (down == 0) {
    for (; end - key >= 32; key += 32) {
      w[0] = htole64(*(((const uint64_t *)(const char *)((&key[0])))));
      w[1] = htole64(*(((const uint64_t *)(const char *)((&key[8])))));
      w[2] = htole64(*(((const uint64_t *)(const char *)((&key[16])))));
      w[3] = htole64(*(((const uint64_t *)(const char *)((&key[24])))));
      rgph_xxh64s_mix(w, h);
    }
  } else {
    for (; end - key >= 32; key += 32) {
      rgph_read64u(key, 8 - down, &carry, w, 4);
      rgph_xxh64s_mix(w, h);
    }
  }
  rgph_xxh64s_fold(len, h);
  if (down == 0) {
    for (; end - key >= 8; key += 8) {
      w[0] = htole64(*(((const uint64_t *)(const char *)((&key[0])))));
      rgph_xxh64s_fmix8(w[0], h);
    }
  } else {
    for (; end - key >= 8; key += 8) {
      rgph_read64u(key, 8 - down, &carry, w, 1);
      rgph_xxh64s_fmix8(w[0], h);
    }
  }
  if (end - key >= 4) {
    uint32_t w[1];
    const int down = ((uintptr_t)key) & 3;
    uint32_t carry =
        down != 0 ? htole32(*(((const uint32_t *)(const char *)((key - down)))))
                  : 0;
    if (down == 0)
      w[0] = htole32(*(((const uint32_t *)(const char *)((&key[0])))));
    else
      rgph_read32u(key, 4 - down, &carry, w, 1);
    rgph_xxh64s_fmix4(w[0], h);
    key += 4;
  }
  for (; end - key >= 1; key += 1)
    rgph_xxh64s_fmix1(key[0], h);
  rgph_xxh64s_finalise(h);
  return h[0];
}


x86 assembly (clang, -O0):
<rgph_u64_xxh64s_data>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0x7,%rax
mov    %eax,-0x54(%rbp)
cmpq   $0x0,-0x10(%rbp)
jbe    121c <rgph_u64_xxh64s_data+0x6c>
cmpl   $0x0,-0x54(%rbp)
je     121c <rgph_u64_xxh64s_data+0x6c>
mov    -0x20(%rbp),%rax
movslq -0x54(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    (%rax,%rcx,4),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x68(%rbp)
jmp    1226 <rgph_u64_xxh64s_data+0x76>
xor    %eax,%eax
mov    %eax,-0x68(%rbp)
jmp    1226 <rgph_u64_xxh64s_data+0x76>
mov    -0x68(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
lea    -0x50(%rbp),%rdx
call   10a0 <rgph_xxh64s_init@plt>
cmpl   $0x0,-0x54(%rbp)
jne    12c5 <rgph_u64_xxh64s_data+0x115>
jmp    124c <rgph_u64_xxh64s_data+0x9c>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x20,%rax
jl     12c0 <rgph_u64_xxh64s_data+0x110>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    0x20(%rax),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x40(%rax),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    0x60(%rax),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x34(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   10b0 <rgph_xxh64s_mix@plt>
mov    -0x20(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x20(%rbp)
jmp    124c <rgph_u64_xxh64s_data+0x9c>
jmp    1327 <rgph_u64_xxh64s_data+0x177>
jmp    12ca <rgph_u64_xxh64s_data+0x11a>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x20,%rax
jl     1322 <rgph_u64_xxh64s_data+0x172>
mov    -0x20(%rbp),%rdi
mov    $0x8,%esi
sub    -0x54(%rbp),%esi
lea    -0x40(%rbp),%rcx
lea    -0x58(%rbp),%rdx
mov    $0x4,%r8d
call   10c0 <rgph_read64u@plt>
lea    -0x40(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   10b0 <rgph_xxh64s_mix@plt>
mov    -0x20(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x20(%rbp)
jmp    12ca <rgph_u64_xxh64s_data+0x11a>
jmp    1327 <rgph_u64_xxh64s_data+0x177>
mov    -0x10(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1060 <rgph_xxh64s_fold@plt>
cmpl   $0x0,-0x54(%rbp)
jne    138c <rgph_u64_xxh64s_data+0x1dc>
jmp    1343 <rgph_u64_xxh64s_data+0x193>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x8,%rax
jl     1387 <rgph_u64_xxh64s_data+0x1d7>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   10d0 <htole64@plt>
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%edi
lea    -0x50(%rbp),%rsi
call   1040 <rgph_xxh64s_fmix8@plt>
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
jmp    1343 <rgph_u64_xxh64s_data+0x193>
jmp    13eb <rgph_u64_xxh64s_data+0x23b>
jmp    1391 <rgph_u64_xxh64s_data+0x1e1>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x8,%rax
jl     13e6 <rgph_u64_xxh64s_data+0x236>
mov    -0x20(%rbp),%rdi
mov    $0x8,%esi
sub    -0x54(%rbp),%esi
lea    -0x40(%rbp),%rcx
lea    -0x58(%rbp),%rdx
mov    $0x1,%r8d
call   10c0 <rgph_read64u@plt>
mov    -0x40(%rbp),%edi
lea    -0x50(%rbp),%rsi
call   1040 <rgph_xxh64s_fmix8@plt>
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
jmp    1391 <rgph_u64_xxh64s_data+0x1e1>
jmp    13eb <rgph_u64_xxh64s_data+0x23b>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x4,%rax
jl     149a <rgph_u64_xxh64s_data+0x2ea>
mov    -0x20(%rbp),%rax
and    $0x3,%rax
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
je     1436 <rgph_u64_xxh64s_data+0x286>
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <htole32@plt>
mov    %eax,-0x6c(%rbp)
jmp    1440 <rgph_u64_xxh64s_data+0x290>
xor    %eax,%eax
mov    %eax,-0x6c(%rbp)
jmp    1440 <rgph_u64_xxh64s_data+0x290>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1463 <rgph_u64_xxh64s_data+0x2b3>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1030 <htole32@plt>
mov    %eax,-0x5c(%rbp)
jmp    1482 <rgph_u64_xxh64s_data+0x2d2>
mov    -0x20(%rbp),%rdi
mov    $0x4,%esi
sub    -0x60(%rbp),%esi
lea    -0x5c(%rbp),%rcx
lea    -0x64(%rbp),%rdx
mov    $0x1,%r8d
call   1070 <rgph_read32u@plt>
mov    -0x5c(%rbp),%edi
lea    -0x50(%rbp),%rsi
call   1050 <rgph_xxh64s_fmix4@plt>
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
jmp    149f <rgph_u64_xxh64s_data+0x2ef>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
cmp    $0x1,%rax
jl     14d8 <rgph_u64_xxh64s_data+0x328>
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
lea    -0x50(%rbp),%rsi
call   1090 <rgph_xxh64s_fmix1@plt>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    149f <rgph_u64_xxh64s_data+0x2ef>
lea    -0x50(%rbp),%rdi
call   1080 <rgph_xxh64s_finalise@plt>
mov    -0x50(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rgph_u64_xxh64s_data>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rbx
lea    (%rdi,%rsi,4),%rbp
mov    %ebx,%r12d
and    $0x7,%r12d
test   %rsi,%rsi
je     1206 <rgph_u64_xxh64s_data+0x56>
test   %r12d,%r12d
je     1206 <rgph_u64_xxh64s_data+0x56>
mov    %r12d,%eax
shl    $0x2,%rax
mov    %rbx,%rcx
sub    %rax,%rcx
mov    (%rcx),%edi
call   10d0 <htole64@plt>
mov    %eax,0xc(%rsp)
lea    0x10(%rsp),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   10a0 <rgph_xxh64s_init@plt>
jmp    122b <rgph_u64_xxh64s_data+0x7b>
movl   $0x0,0xc(%rsp)
lea    0x10(%rsp),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   10a0 <rgph_xxh64s_init@plt>
test   %r12d,%r12d
sete   %r13b
je     13f9 <rgph_u64_xxh64s_data+0x249>
mov    %rbp,%r14
sub    %rbx,%r14
cmp    $0x7d,%r14
jl     12a1 <rgph_u64_xxh64s_data+0xf1>
mov    %r15,0x40(%rsp)
mov    $0x8,%r15d
mov    %r12d,0x8(%rsp)
sub    %r12d,%r15d
lea    0x30(%rsp),%r12
lea    0x10(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15d,%esi
lea    0xc(%rsp),%rdx
mov    %r12,%rcx
mov    $0x4,%r8d
call   10c0 <rgph_read64u@plt>
mov    %r12,%rdi
mov    %r13,%rsi
call   10b0 <rgph_xxh64s_mix@plt>
sub    $0xffffffffffffff80,%rbx
add    $0xffffffffffffff80,%r14
cmp    $0x7c,%r14
jg     1260 <rgph_u64_xxh64s_data+0xb0>
xor    %r13d,%r13d
mov    0x8(%rsp),%r12d
mov    0x40(%rsp),%r15
jmp    12a4 <rgph_u64_xxh64s_data+0xf4>
xor    %r13d,%r13d
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1060 <rgph_xxh64s_fold@plt>
test   %r13b,%r13b
je     12e1 <rgph_u64_xxh64s_data+0x131>
mov    %rbp,%rax
sub    %rbx,%rax
mov    %rbx,%r13
cmp    $0x1d,%rax
jge    1350 <rgph_u64_xxh64s_data+0x1a0>
cmp    $0xd,%rax
jge    13b0 <rgph_u64_xxh64s_data+0x200>
test   %rax,%rax
jg     149b <rgph_u64_xxh64s_data+0x2eb>
jmp    14c7 <rgph_u64_xxh64s_data+0x317>
mov    %rbp,%rax
sub    %rbx,%rax
cmp    $0x1d,%rax
jl     13a3 <rgph_u64_xxh64s_data+0x1f3>
mov    $0x8,%r14d
sub    %r12d,%r14d
mov    %rbx,%r13
neg    %r13
lea    0x30(%rsp),%r15
lea    0x10(%rsp),%r12
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r14d,%esi
lea    0xc(%rsp),%rdx
mov    %r15,%rcx
mov    $0x1,%r8d
call   10c0 <rgph_read64u@plt>
mov    0x30(%rsp),%edi
mov    %r12,%rsi
call   1040 <rgph_xxh64s_fmix8@plt>
add    $0x20,%rbx
lea    -0x20(,%r13,1),%rax
ff
add    %rbp,%rax
add    $0xffffffffffffffe0,%r13
cmp    $0x1c,%rax
jg     1310 <rgph_u64_xxh64s_data+0x160>
jmp    138e <rgph_u64_xxh64s_data+0x1de>
neg    %r13
lea    0x10(%rsp),%r14
nopl   0x0(%rax,%rax,1)
mov    (%rbx),%edi
call   10d0 <htole64@plt>
mov    %eax,0x30(%rsp)
mov    %eax,%edi
mov    %r14,%rsi
call   1040 <rgph_xxh64s_fmix8@plt>
add    $0x20,%rbx
lea    -0x20(,%r13,1),%rax
ff
add    %rbp,%rax
add    $0xffffffffffffffe0,%r13
cmp    $0x1c,%rax
jg     1360 <rgph_u64_xxh64s_data+0x1b0>
mov    %rbp,%rax
add    %r13,%rax
neg    %r13
cmp    $0xd,%rax
jl     12d3 <rgph_u64_xxh64s_data+0x123>
jmp    13b0 <rgph_u64_xxh64s_data+0x200>
mov    %rbx,%r13
cmp    $0xd,%rax
jl     12d3 <rgph_u64_xxh64s_data+0x123>
and    $0x3,%r13d
je     146d <rgph_u64_xxh64s_data+0x2bd>
mov    %r13d,%eax
shl    $0x2,%rax
neg    %rax
mov    (%rbx,%rax,1),%edi
call   1030 <htole32@plt>
mov    %eax,0x28(%rsp)
mov    $0x4,%esi
sub    %r13d,%esi
lea    0x28(%rsp),%rdx
lea    0x2c(%rsp),%rcx
mov    %rbx,%rdi
mov    $0x1,%r8d
call   1070 <rgph_read32u@plt>
mov    0x2c(%rsp),%edi
jmp    1482 <rgph_u64_xxh64s_data+0x2d2>
mov    %rbp,%r14
sub    %rbx,%r14
cmp    $0x7c,%r14
jle    14e4 <rgph_u64_xxh64s_data+0x334>
mov    %r15,0x40(%rsp)
mov    %r12d,0x8(%rsp)
lea    0x30(%rsp),%r15
lea    0x10(%rsp),%r12
nopl   (%rax)
mov    (%rbx),%edi
call   10d0 <htole64@plt>
mov    %eax,0x30(%rsp)
mov    0x20(%rbx),%edi
call   10d0 <htole64@plt>
mov    %eax,0x34(%rsp)
mov    0x40(%rbx),%edi
call   10d0 <htole64@plt>
mov    %eax,0x38(%rsp)
mov    0x60(%rbx),%edi
call   10d0 <htole64@plt>
mov    %eax,0x3c(%rsp)
mov    %r15,%rdi
mov    %r12,%rsi
call   10b0 <rgph_xxh64s_mix@plt>
sub    $0xffffffffffffff80,%rbx
add    $0xffffffffffffff80,%r14
cmp    $0x7c,%r14
jg     1420 <rgph_u64_xxh64s_data+0x270>
jmp    1295 <rgph_u64_xxh64s_data+0xe5>
movl   $0x0,0x28(%rsp)
mov    (%rbx),%edi
call   1030 <htole32@plt>
mov    %eax,%edi
mov    %eax,0x2c(%rsp)
lea    0x10(%rsp),%rsi
call   1050 <rgph_xxh64s_fmix4@plt>
add    $0x10,%rbx
mov    %rbp,%rax
sub    %rbx,%rax
test   %rax,%rax
jle    14c7 <rgph_u64_xxh64s_data+0x317>
sub    %rbx,%rbp
lea    0x10(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx),%edi
mov    %r14,%rsi
call   1090 <rgph_xxh64s_fmix1@plt>
add    $0x4,%rbx
add    $0xfffffffffffffffc,%rbp
test   %rbp,%rbp
jg     14b0 <rgph_u64_xxh64s_data+0x300>
lea    0x10(%rsp),%rdi
call   1080 <rgph_xxh64s_finalise@plt>
mov    0x10(%rsp),%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1060 <rgph_xxh64s_fold@plt>
jmp    12b6 <rgph_u64_xxh64s_data+0x106>

LLVM IR (-O0):
define i32 @rgph_u64_xxh64s_data(i8* %0, i64 %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca [4 x i32]
%10 = alloca [4 x i32]
%11 = alloca i32
%12 = alloca i32
%13 = alloca [1 x i32]
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %4
store i64 %1, i64* %5
store i64 %2, i64* %6
%16 = load i8*, i8** %4
%17 = bitcast i8* %16 to i32*
store i32* %17, i32** %7
%18 = load i32*, i32** %7
%19 = load i64, i64* %5
%20 = getelementptr inbounds i32, i32* %18, i64 %19
store i32* %20, i32** %8
%21 = load i32*, i32** %7
%22 = ptrtoint i32* %21 to i64
%23 = and i64 %22, 7
%24 = trunc i64 %23 to i32
store i32 %24, i32* %11
%25 = load i64, i64* %5
%26 = icmp ugt i64 %25, 0
br i1 %26, label %27, label %40
27: ; preds = %3
%28 = load i32, i32* %11
%29 = icmp ne i32 %28, 0
br i1 %29, label %30, label %40
30: ; preds = %27
%31 = load i32*, i32** %7
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = sub i64 0, %33
%35 = getelementptr inbounds i32, i32* %31, i64 %34
%36 = bitcast i32* %35 to i8*
%37 = bitcast i8* %36 to i32*
%38 = load i32, i32* %37
%39 = call i32 @htole64(i32 %38)
br label %41
40: ; preds = %27, %3
br label %41
41: ; preds = %40, %30
%42 = phi i32 [ %39, %30 ], [ 0, %40 ]
store i32 %42, i32* %12
%43 = load i64, i64* %5
%44 = load i64, i64* %6
%45 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%46 = call i32 @rgph_xxh64s_init(i64 %43, i64 %44, i32* %45)
%47 = load i32, i32* %11
%48 = icmp eq i32 %47, 0
br i1 %48, label %49, label %94
49: ; preds = %41
br label %50
50: ; preds = %90, %49
%51 = load i32*, i32** %8
%52 = load i32*, i32** %7
%53 = ptrtoint i32* %51 to i64
%54 = ptrtoint i32* %52 to i64
%55 = sub i64 %53, %54
%56 = sdiv exact i64 %55, 4
%57 = icmp sge i64 %56, 32
br i1 %57, label %58, label %93
58: ; preds = %50
%59 = load i32*, i32** %7
%60 = getelementptr inbounds i32, i32* %59, i64 0
%61 = bitcast i32* %60 to i8*
%62 = bitcast i8* %61 to i32*
%63 = load i32, i32* %62
%64 = call i32 @htole64(i32 %63)
%65 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
store i32 %64, i32* %65
%66 = load i32*, i32** %7
%67 = getelementptr inbounds i32, i32* %66, i64 8
%68 = bitcast i32* %67 to i8*
%69 = bitcast i8* %68 to i32*
%70 = load i32, i32* %69
%71 = call i32 @htole64(i32 %70)
%72 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 1
store i32 %71, i32* %72
%73 = load i32*, i32** %7
%74 = getelementptr inbounds i32, i32* %73, i64 16
%75 = bitcast i32* %74 to i8*
%76 = bitcast i8* %75 to i32*
%77 = load i32, i32* %76
%78 = call i32 @htole64(i32 %77)
%79 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 2
store i32 %78, i32* %79
%80 = load i32*, i32** %7
%81 = getelementptr inbounds i32, i32* %80, i64 24
%82 = bitcast i32* %81 to i8*
%83 = bitcast i8* %82 to i32*
%84 = load i32, i32* %83
%85 = call i32 @htole64(i32 %84)
%86 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 3
store i32 %85, i32* %86
%87 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%88 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%89 = call i32 @rgph_xxh64s_mix(i32* %87, i32* %88)
br label %90
90: ; preds = %58
%91 = load i32*, i32** %7
%92 = getelementptr inbounds i32, i32* %91, i64 32
store i32* %92, i32** %7
br label %50
93: ; preds = %50
br label %116
94: ; preds = %41
br label %95
95: ; preds = %112, %94
%96 = load i32*, i32** %8
%97 = load i32*, i32** %7
%98 = ptrtoint i32* %96 to i64
%99 = ptrtoint i32* %97 to i64
%100 = sub i64 %98, %99
%101 = sdiv exact i64 %100, 4
%102 = icmp sge i64 %101, 32
br i1 %102, label %103, label %115
103: ; preds = %95
%104 = load i32*, i32** %7
%105 = load i32, i32* %11
%106 = sub nsw i32 8, %105
%107 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%108 = call i32 @rgph_read64u(i32* %104, i32 %106, i32* %12, i32* %107, i32 4)
%109 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%110 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%111 = call i32 @rgph_xxh64s_mix(i32* %109, i32* %110)
br label %112
112: ; preds = %103
%113 = load i32*, i32** %7
%114 = getelementptr inbounds i32, i32* %113, i64 32
store i32* %114, i32** %7
br label %95
115: ; preds = %95
br label %116
116: ; preds = %115, %93
%117 = load i64, i64* %5
%118 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%119 = call i32 @rgph_xxh64s_fold(i64 %117, i32* %118)
%120 = load i32, i32* %11
%121 = icmp eq i32 %120, 0
br i1 %121, label %122, label %147
122: ; preds = %116
br label %123
123: ; preds = %143, %122
%124 = load i32*, i32** %8
%125 = load i32*, i32** %7
%126 = ptrtoint i32* %124 to i64
%127 = ptrtoint i32* %125 to i64
%128 = sub i64 %126, %127
%129 = sdiv exact i64 %128, 4
%130 = icmp sge i64 %129, 8
br i1 %130, label %131, label %146
131: ; preds = %123
%132 = load i32*, i32** %7
%133 = getelementptr inbounds i32, i32* %132, i64 0
%134 = bitcast i32* %133 to i8*
%135 = bitcast i8* %134 to i32*
%136 = load i32, i32* %135
%137 = call i32 @htole64(i32 %136)
%138 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
store i32 %137, i32* %138
%139 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%140 = load i32, i32* %139
%141 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%142 = call i32 @rgph_xxh64s_fmix8(i32 %140, i32* %141)
br label %143
143: ; preds = %131
%144 = load i32*, i32** %7
%145 = getelementptr inbounds i32, i32* %144, i64 8
store i32* %145, i32** %7
br label %123
146: ; preds = %123
br label %170
147: ; preds = %116
br label %148
148: ; preds = %166, %147
%149 = load i32*, i32** %8
%150 = load i32*, i32** %7
%151 = ptrtoint i32* %149 to i64
%152 = ptrtoint i32* %150 to i64
%153 = sub i64 %151, %152
%154 = sdiv exact i64 %153, 4
%155 = icmp sge i64 %154, 8
br i1 %155, label %156, label %169
156: ; preds = %148
%157 = load i32*, i32** %7
%158 = load i32, i32* %11
%159 = sub nsw i32 8, %158
%160 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%161 = call i32 @rgph_read64u(i32* %157, i32 %159, i32* %12, i32* %160, i32 1)
%162 = getelementptr inbounds [4 x i32], [4 x i32]* %9, i64 0, i64 0
%163 = load i32, i32* %162
%164 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%165 = call i32 @rgph_xxh64s_fmix8(i32 %163, i32* %164)
br label %166
166: ; preds = %156
%167 = load i32*, i32** %7
%168 = getelementptr inbounds i32, i32* %167, i64 8
store i32* %168, i32** %7
br label %148
169: ; preds = %148
br label %170
170: ; preds = %169, %146
%171 = load i32*, i32** %8
%172 = load i32*, i32** %7
%173 = ptrtoint i32* %171 to i64
%174 = ptrtoint i32* %172 to i64
%175 = sub i64 %173, %174
%176 = sdiv exact i64 %175, 4
%177 = icmp sge i64 %176, 4
br i1 %177, label %178, label %221
178: ; preds = %170
%179 = load i32*, i32** %7
%180 = ptrtoint i32* %179 to i64
%181 = and i64 %180, 3
%182 = trunc i64 %181 to i32
store i32 %182, i32* %14
%183 = load i32, i32* %14
%184 = icmp ne i32 %183, 0
br i1 %184, label %185, label %195
185: ; preds = %178
%186 = load i32*, i32** %7
%187 = load i32, i32* %14
%188 = sext i32 %187 to i64
%189 = sub i64 0, %188
%190 = getelementptr inbounds i32, i32* %186, i64 %189
%191 = bitcast i32* %190 to i8*
%192 = bitcast i8* %191 to i32*
%193 = load i32, i32* %192
%194 = call i32 @htole32(i32 %193)
br label %196
195: ; preds = %178
br label %196
196: ; preds = %195, %185
%197 = phi i32 [ %194, %185 ], [ 0, %195 ]
store i32 %197, i32* %15
%198 = load i32, i32* %14
%199 = icmp eq i32 %198, 0
br i1 %199, label %200, label %208
200: ; preds = %196
%201 = load i32*, i32** %7
%202 = getelementptr inbounds i32, i32* %201, i64 0
%203 = bitcast i32* %202 to i8*
%204 = bitcast i8* %203 to i32*
%205 = load i32, i32* %204
%206 = call i32 @htole32(i32 %205)
%207 = getelementptr inbounds [1 x i32], [1 x i32]* %13, i64 0, i64 0
store i32 %206, i32* %207
br label %214
208: ; preds = %196
%209 = load i32*, i32** %7
%210 = load i32, i32* %14
%211 = sub nsw i32 4, %210
%212 = getelementptr inbounds [1 x i32], [1 x i32]* %13, i64 0, i64 0
%213 = call i32 @rgph_read32u(i32* %209, i32 %211, i32* %15, i32* %212, i32 1)
br label %214
214: ; preds = %208, %200
%215 = getelementptr inbounds [1 x i32], [1 x i32]* %13, i64 0, i64 0
%216 = load i32, i32* %215
%217 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%218 = call i32 @rgph_xxh64s_fmix4(i32 %216, i32* %217)
%219 = load i32*, i32** %7
%220 = getelementptr inbounds i32, i32* %219, i64 4
store i32* %220, i32** %7
br label %221
221: ; preds = %214, %170
br label %222
222: ; preds = %236, %221
%223 = load i32*, i32** %8
%224 = load i32*, i32** %7
%225 = ptrtoint i32* %223 to i64
%226 = ptrtoint i32* %224 to i64
%227 = sub i64 %225, %226
%228 = sdiv exact i64 %227, 4
%229 = icmp sge i64 %228, 1
br i1 %229, label %230, label %239
230: ; preds = %222
%231 = load i32*, i32** %7
%232 = getelementptr inbounds i32, i32* %231, i64 0
%233 = load i32, i32* %232
%234 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%235 = call i32 @rgph_xxh64s_fmix1(i32 %233, i32* %234)
br label %236
236: ; preds = %230
%237 = load i32*, i32** %7
%238 = getelementptr inbounds i32, i32* %237, i64 1
store i32* %238, i32** %7
br label %222
239: ; preds = %222
%240 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%241 = call i32 @rgph_xxh64s_finalise(i32* %240)
%242 = getelementptr inbounds [4 x i32], [4 x i32]* %10, i64 0, i64 0
%243 = load i32, i32* %242
ret i32 %243
}

LLVM IR (-O2):
define i32 @rgph_u64_xxh64s_data(i8* %0, i64 %1, i64 %2) {
%4 = alloca [4 x i32]
%5 = alloca [4 x i32]
%6 = alloca i32
%7 = alloca [1 x i32]
%8 = alloca i32
%9 = bitcast i8* %0 to i32*
%10 = getelementptr inbounds i32, i32* %9, i64 %1
%11 = bitcast [4 x i32]* %4 to i8*
%12 = bitcast [4 x i32]* %5 to i8*
%13 = ptrtoint i8* %0 to i64
%14 = trunc i64 %13 to i32
%15 = and i32 %14, 7
%16 = bitcast i32* %6 to i8*
%17 = icmp ne i64 %1, 0
%18 = icmp ne i32 %15, 0
%19 = and i1 %17, %18
br i1 %19, label %20, label %28
20: ; preds = %3
%21 = zext i32 %15 to i64
%22 = sub nsw i64 0, %21
%23 = getelementptr inbounds i32, i32* %9, i64 %22
%24 = load i32, i32* %23
%25 = tail call i32 @htole64(i32 %24)
store i32 %25, i32* %6
%26 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%27 = call i32 @rgph_xxh64s_init(i64 %1, i64 %2, i32* %26)
br label %32
28: ; preds = %3
store i32 0, i32* %6
%29 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%30 = call i32 @rgph_xxh64s_init(i64 %1, i64 %2, i32* %29)
%31 = icmp eq i32 %15, 0
br i1 %31, label %40, label %32
32: ; preds = %20, %28
%33 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%34 = ptrtoint i32* %10 to i64
%35 = sub i64 %34, %13
%36 = icmp sgt i64 %35, 124
br i1 %36, label %37, label %77
37: ; preds = %32
%38 = sub nuw nsw i32 8, %15
%39 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
br label %69
40: ; preds = %28
%41 = ptrtoint i32* %10 to i64
%42 = sub i64 %41, %13
%43 = icmp sgt i64 %42, 124
br i1 %43, label %46, label %44
44: ; preds = %40
%45 = call i32 @rgph_xxh64s_fold(i64 %1, i32* %29)
br label %90
46: ; preds = %40
%47 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
%48 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 1
%49 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 2
%50 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 3
br label %51
51: ; preds = %46, %51
%52 = phi i32* [ %9, %46 ], [ %65, %51 ]
%53 = load i32, i32* %52
%54 = call i32 @htole64(i32 %53)
store i32 %54, i32* %47
%55 = getelementptr inbounds i32, i32* %52, i64 8
%56 = load i32, i32* %55
%57 = call i32 @htole64(i32 %56)
store i32 %57, i32* %48
%58 = getelementptr inbounds i32, i32* %52, i64 16
%59 = load i32, i32* %58
%60 = call i32 @htole64(i32 %59)
store i32 %60, i32* %49
%61 = getelementptr inbounds i32, i32* %52, i64 24
%62 = load i32, i32* %61
%63 = call i32 @htole64(i32 %62)
store i32 %63, i32* %50
%64 = call i32 @rgph_xxh64s_mix(i32* %47, i32* %29)
%65 = getelementptr inbounds i32, i32* %52, i64 32
%66 = ptrtoint i32* %65 to i64
%67 = sub i64 %41, %66
%68 = icmp sgt i64 %67, 124
br i1 %68, label %51, label %77
69: ; preds = %37, %69
%70 = phi i32* [ %9, %37 ], [ %73, %69 ]
%71 = call i32 @rgph_read64u(i32* %70, i32 %38, i32* %6, i32* %39, i32 4)
%72 = call i32 @rgph_xxh64s_mix(i32* %39, i32* %33)
%73 = getelementptr inbounds i32, i32* %70, i64 32
%74 = ptrtoint i32* %73 to i64
%75 = sub i64 %34, %74
%76 = icmp sgt i64 %75, 124
br i1 %76, label %69, label %77
77: ; preds = %51, %69, %32
%78 = phi i1 [ false, %32 ], [ false, %69 ], [ %31, %51 ]
%79 = phi i32* [ %9, %32 ], [ %73, %69 ], [ %65, %51 ]
%80 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%81 = call i32 @rgph_xxh64s_fold(i64 %1, i32* %80)
br i1 %78, label %90, label %82
82: ; preds = %77
%83 = ptrtoint i32* %10 to i64
%84 = ptrtoint i32* %79 to i64
%85 = sub i64 %83, %84
%86 = icmp sgt i64 %85, 28
br i1 %86, label %87, label %121
87: ; preds = %82
%88 = sub nuw nsw i32 8, %15
%89 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
br label %108
90: ; preds = %44, %77
%91 = phi i32* [ %9, %44 ], [ %79, %77 ]
%92 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%93 = ptrtoint i32* %10 to i64
%94 = ptrtoint i32* %91 to i64
%95 = sub i64 %93, %94
%96 = icmp sgt i64 %95, 28
br i1 %96, label %97, label %121
97: ; preds = %90
%98 = getelementptr inbounds [4 x i32], [4 x i32]* %4, i64 0, i64 0
br label %99
99: ; preds = %97, %99
%100 = phi i32* [ %91, %97 ], [ %104, %99 ]
%101 = load i32, i32* %100
%102 = call i32 @htole64(i32 %101)
store i32 %102, i32* %98
%103 = call i32 @rgph_xxh64s_fmix8(i32 %102, i32* %92)
%104 = getelementptr inbounds i32, i32* %100, i64 8
%105 = ptrtoint i32* %104 to i64
%106 = sub i64 %93, %105
%107 = icmp sgt i64 %106, 28
br i1 %107, label %99, label %117
108: ; preds = %87, %108
%109 = phi i32* [ %79, %87 ], [ %113, %108 ]
%110 = call i32 @rgph_read64u(i32* %109, i32 %88, i32* %6, i32* %89, i32 1)
%111 = load i32, i32* %89
%112 = call i32 @rgph_xxh64s_fmix8(i32 %111, i32* %80)
%113 = getelementptr inbounds i32, i32* %109, i64 8
%114 = ptrtoint i32* %113 to i64
%115 = sub i64 %83, %114
%116 = icmp sgt i64 %115, 28
br i1 %116, label %108, label %119
117: ; preds = %99
%118 = ptrtoint i32* %104 to i64
br label %121
119: ; preds = %108
%120 = ptrtoint i32* %113 to i64
br label %121
121: ; preds = %119, %117, %82, %90
%122 = phi i64 [ %85, %82 ], [ %95, %90 ], [ %106, %117 ], [ %115, %119 ]
%123 = phi i64 [ %84, %82 ], [ %94, %90 ], [ %118, %117 ], [ %120, %119 ]
%124 = phi i64 [ %83, %82 ], [ %93, %90 ], [ %93, %117 ], [ %83, %119 ]
%125 = phi i32* [ %79, %82 ], [ %91, %90 ], [ %104, %117 ], [ %113, %119 ]
%126 = getelementptr inbounds [4 x i32], [4 x i32]* %5, i64 0, i64 0
%127 = icmp sgt i64 %122, 12
br i1 %127, label %128, label %154
128: ; preds = %121
%129 = bitcast [1 x i32]* %7 to i8*
%130 = trunc i64 %123 to i32
%131 = and i32 %130, 3
%132 = bitcast i32* %8 to i8*
%133 = icmp eq i32 %131, 0
br i1 %133, label %134, label %138
134: ; preds = %128
store i32 0, i32* %8
%135 = load i32, i32* %125
%136 = call i32 @htole32(i32 %135)
%137 = getelementptr inbounds [1 x i32], [1 x i32]* %7, i64 0, i64 0
store i32 %136, i32* %137
br label %148
138: ; preds = %128
%139 = zext i32 %131 to i64
%140 = sub nsw i64 0, %139
%141 = getelementptr inbounds i32, i32* %125, i64 %140
%142 = load i32, i32* %141
%143 = call i32 @htole32(i32 %142)
store i32 %143, i32* %8
%144 = sub nuw nsw i32 4, %131
%145 = getelementptr inbounds [1 x i32], [1 x i32]* %7, i64 0, i64 0
%146 = call i32 @rgph_read32u(i32* %125, i32 %144, i32* %8, i32* %145, i32 1)
%147 = load i32, i32* %145
br label %148
148: ; preds = %138, %134
%149 = phi i32 [ %147, %138 ], [ %136, %134 ]
%150 = call i32 @rgph_xxh64s_fmix4(i32 %149, i32* %126)
%151 = getelementptr inbounds i32, i32* %125, i64 4
%152 = ptrtoint i32* %151 to i64
%153 = sub i64 %124, %152
br label %154
154: ; preds = %148, %121
%155 = phi i64 [ %153, %148 ], [ %122, %121 ]
%156 = phi i32* [ %151, %148 ], [ %125, %121 ]
%157 = icmp sgt i64 %155, 0
br i1 %157, label %158, label %166
158: ; preds = %154, %158
%159 = phi i32* [ %162, %158 ], [ %156, %154 ]
%160 = load i32, i32* %159
%161 = call i32 @rgph_xxh64s_fmix1(i32 %160, i32* %126)
%162 = getelementptr inbounds i32, i32* %159, i64 1
%163 = ptrtoint i32* %162 to i64
%164 = sub i64 %124, %163
%165 = icmp sgt i64 %164, 0
br i1 %165, label %158, label %166
166: ; preds = %158, %154
%167 = call i32 @rgph_xxh64s_finalise(i32* %126)
%168 = load i32, i32* %126
ret i32 %168
}