#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 uint8_t;
typedef int uint32_t;
typedef scalar_t__ uint16_t;

/* Variables and functions */
size_t _jenkins_little2_step(const void *key, size_t length, uint32_t st[3]) {
  uint32_t a = st[0], b = st[1], c = st[2];
  union {
    const void *ptr;
    size_t i;
  } u;
  u.ptr = key;
  if (0 && ((u.i & 0x3) == 0)) {
    const uint32_t *k = (const uint32_t *)key;
    while (length >= 12) {
      a += k[0];
      b += k[1];
      c += k[2];
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 3;
    }
    switch (length) {
    case 12:
      c += k[2];
      b += k[1];
      a += k[0];
      break;
    case 11:
      c += k[2] & 0xffffff;
      b += k[1];
      a += k[0];
      break;
    case 10:
      c += k[2] & 0xffff;
      b += k[1];
      a += k[0];
      break;
    case 9:
      c += k[2] & 0xff;
      b += k[1];
      a += k[0];
      break;
    case 8:
      b += k[1];
      a += k[0];
      break;
    case 7:
      b += k[1] & 0xffffff;
      a += k[0];
      break;
    case 6:
      b += k[1] & 0xffff;
      a += k[0];
      break;
    case 5:
      b += k[1] & 0xff;
      a += k[0];
      break;
    case 4:
      a += k[0];
      break;
    case 3:
      a += k[0] & 0xffffff;
      break;
    case 2:
      a += k[0] & 0xffff;
      break;
    case 1:
      a += k[0] & 0xff;
      break;
    }
  } else if (0 && ((u.i & 0x1) == 0)) {
    const uint16_t *k = (const uint16_t *)key;
    const uint8_t *k8;
    while (length >= 12) {
      a += k[0] + (((uint32_t)k[1]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      c += k[4] + (((uint32_t)k[5]) << 16);
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 6;
    }
    k8 = (const uint8_t *)k;
    switch (length) {
    case 12:
      c += k[4] + (((uint32_t)k[5]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 11:
      c += ((uint32_t)k8[10]) << 16;
    case 10:
      c += k[4];
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 9:
      c += k8[8];
    case 8:
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 7:
      b += ((uint32_t)k8[6]) << 16;
    case 6:
      b += k[2];
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 5:
      b += k8[4];
    case 4:
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 3:
      a += ((uint32_t)k8[2]) << 16;
    case 2:
      a += k[0];
      break;
    case 1:
      a += k8[0];
      break;
    }
  } else {
    const uint8_t *k = (const uint8_t *)key;
    while (length >= 12) {
      a += k[0];
      a += ((uint32_t)k[1]) << 8;
      a += ((uint32_t)k[2]) << 16;
      a += ((uint32_t)k[3]) << 24;
      b += k[4];
      b += ((uint32_t)k[5]) << 8;
      b += ((uint32_t)k[6]) << 16;
      b += ((uint32_t)k[7]) << 24;
      c += k[8];
      c += ((uint32_t)k[9]) << 8;
      c += ((uint32_t)k[10]) << 16;
      c += ((uint32_t)k[11]) << 24;
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 12;
    }
    switch (length) {
    case 12:
      c += ((uint32_t)k[11]) << 24;
    case 11:
      c += ((uint32_t)k[10]) << 16;
    case 10:
      c += ((uint32_t)k[9]) << 8;
    case 9:
      c += k[8];
    case 8:
      b += ((uint32_t)k[7]) << 24;
    case 7:
      b += ((uint32_t)k[6]) << 16;
    case 6:
      b += ((uint32_t)k[5]) << 8;
    case 5:
      b += k[4];
    case 4:
      a += ((uint32_t)k[3]) << 24;
    case 3:
      a += ((uint32_t)k[2]) << 16;
    case 2:
      a += ((uint32_t)k[1]) << 8;
    case 1:
      a += k[0];
      break;
    }
  }
  st[0] = a;
  st[1] = b;
  st[2] = c;
  return length;
}


x86 assembly (clang, -O0):
<_jenkins_little2_step>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0xc,-0x10(%rbp)
jb     130b <_jenkins_little2_step+0x20b>
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2c(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x4,%eax
mov    -0x24(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x8,%eax
mov    -0x20(%rbp),%ecx
sar    $0x18,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x10,%eax
mov    -0x24(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x13,%eax
mov    -0x1c(%rbp),%ecx
sar    $0xd,%ecx
or     %ecx,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x4,%eax
mov    -0x20(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x38(%rbp)
jmp    113d <_jenkins_little2_step+0x3d>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
sub    $0xb,%rax
ja     13eb <_jenkins_little2_step+0x2eb>
mov    -0x40(%rbp),%rax
lea    0xcd4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x38(%rbp),%rax
mov    0x2c(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<_jenkins_little2_step>:
mov    %rsi,%rax
mov    (%rdx),%r9d
mov    0x4(%rdx),%r11d
mov    0x8(%rdx),%r8d
cmp    $0xc,%rsi
jb     1225 <_jenkins_little2_step+0x125>
nopl   0x0(%rax,%rax,1)
add    (%rdi),%r9d
mov    0x4(%rdi),%esi
mov    0x8(%rdi),%ecx
shl    $0x8,%esi
add    %r9d,%esi
shl    $0x10,%ecx
add    %esi,%ecx
mov    0xc(%rdi),%r9d
shl    $0x18,%r9d
add    0x10(%rdi),%r11d
add    %ecx,%r9d
mov    0x14(%rdi),%ecx
shl    $0x8,%ecx
add    %r11d,%ecx
mov    0x18(%rdi),%esi
shl    $0x10,%esi
add    %ecx,%esi
mov    0x1c(%rdi),%r10d
shl    $0x18,%r10d
add    %esi,%r10d
add    0x20(%rdi),%r8d
mov    0x24(%rdi),%ecx
shl    $0x8,%ecx
add    %r8d,%ecx
mov    0x28(%rdi),%esi
shl    $0x10,%esi
add    %ecx,%esi
mov    0x2c(%rdi),%r8d
shl    $0x18,%r8d
add    %esi,%r8d
sub    %r8d,%r9d
mov    %r8d,%esi
shl    $0x4,%esi
mov    %r8d,%ecx
sar    $0x1c,%ecx
or     %esi,%ecx
xor    %r9d,%ecx
add    %r10d,%r8d
sub    %ecx,%r10d
mov    %ecx,%r9d
shl    $0x6,%r9d
mov    %ecx,%esi
sar    $0x1a,%esi
or     %r9d,%esi
xor    %r10d,%esi
add    %r8d,%ecx
sub    %esi,%r8d
mov    %esi,%r9d
shl    $0x8,%r9d
mov    %esi,%r10d
sar    $0x18,%r10d
or     %r9d,%r10d
xor    %r8d,%r10d
add    %ecx,%esi
sub    %r10d,%ecx
mov    %r10d,%r8d
shl    $0x10,%r8d
mov    %r10d,%r9d
sar    $0x10,%r9d
or     %r8d,%r9d
xor    %ecx,%r9d
add    %esi,%r10d
sub    %r9d,%esi
mov    %r9d,%ecx
shl    $0x13,%ecx
mov    %r9d,%r11d
sar    $0xd,%r11d
or     %ecx,%r11d
xor    %esi,%r11d
add    %r10d,%r9d
sub    %r11d,%r10d
mov    %r11d,%ecx
shl    $0x4,%ecx
mov    %r11d,%r8d
sar    $0x1c,%r8d
or     %ecx,%r8d
xor    %r10d,%r8d
add    %r9d,%r11d
add    $0xfffffffffffffff4,%rax
add    $0x30,%rdi
cmp    $0xb,%rax
ja     1120 <_jenkins_little2_step+0x20>
lea    -0x1(%rax),%rsi
cmp    $0xa,%rsi
ja     1292 <_jenkins_little2_step+0x192>
lea    0xdca(%rip),%rcx
movslq (%rcx,%rsi,4),%rsi
add    %rcx,%rsi
jmp    *%rsi
mov    0x28(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r8d
mov    0x24(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%r8d
add    0x20(%rdi),%r8d
mov    0x1c(%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%r11d
mov    0x18(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r11d
mov    0x14(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%r11d
add    0x10(%rdi),%r11d
mov    0xc(%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%r9d
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r9d
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%r9d
add    (%rdi),%r9d
mov    %r9d,(%rdx)
mov    %r11d,0x4(%rdx)
mov    %r8d,0x8(%rdx)
ret

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

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