#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 uint32_t;

/* Variables and functions */
void rgph_jenkins2_mix(uint32_t h[]) {
  h[0] -= h[1];
  h[0] -= h[2];
  h[0] ^= (h[2] >> 13);
  h[1] -= h[2];
  h[1] -= h[0];
  h[1] ^= (h[0] << 8);
  h[2] -= h[0];
  h[2] -= h[1];
  h[2] ^= (h[1] >> 13);
  h[0] -= h[1];
  h[0] -= h[2];
  h[0] ^= (h[2] >> 12);
  h[1] -= h[2];
  h[1] -= h[0];
  h[1] ^= (h[0] << 16);
  h[2] -= h[0];
  h[2] -= h[1];
  h[2] ^= (h[1] >> 5);
  h[0] -= h[1];
  h[0] -= h[2];
  h[0] ^= (h[2] >> 3);
  h[1] -= h[2];
  h[1] -= h[0];
  h[1] ^= (h[0] << 10);
  h[2] -= h[0];
  h[2] -= h[1];
  h[2] ^= (h[1] >> 15);
}


x86 assembly (clang, -O0):
<rgph_jenkins2_mix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sar    $0xd,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
shl    $0x8,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sar    $0xd,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sar    $0xc,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
shl    $0x10,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sar    $0x5,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
sub    %edx,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sar    $0x3,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
shl    $0xa,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
sub    %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
sar    $0xf,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<rgph_jenkins2_mix>:
mov    (%rdi),%eax
mov    0x4(%rdi),%r8d
mov    0x8(%rdi),%r9d
sub    %r8d,%eax
sub    %r9d,%eax
mov    %r9d,%esi
sar    $0xd,%esi
xor    %eax,%esi
sub    %r9d,%r8d
sub    %esi,%r8d
mov    %esi,%ecx
shl    $0x8,%ecx
xor    %r8d,%ecx
sub    %esi,%r9d
sub    %ecx,%r9d
mov    %ecx,%edx
sar    $0xd,%edx
xor    %r9d,%edx
sub    %ecx,%esi
sub    %edx,%esi
mov    %edx,%eax
sar    $0xc,%eax
xor    %esi,%eax
sub    %edx,%ecx
sub    %eax,%ecx
mov    %eax,%esi
shl    $0x10,%esi
xor    %ecx,%esi
sub    %eax,%edx
sub    %esi,%edx
mov    %esi,%ecx
sar    $0x5,%ecx
xor    %edx,%ecx
sub    %esi,%eax
sub    %ecx,%eax
mov    %ecx,%edx
sar    $0x3,%edx
xor    %eax,%edx
mov    %edx,(%rdi)
sub    %ecx,%esi
sub    %edx,%esi
mov    %edx,%eax
shl    $0xa,%eax
xor    %esi,%eax
mov    %eax,0x4(%rdi)
add    %eax,%edx
sub    %edx,%ecx
sar    $0xf,%eax
xor    %ecx,%eax
mov    %eax,0x8(%rdi)
ret

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

LLVM IR (-O2):
define void @rgph_jenkins2_mix(i32* nocapture %0) {
%2 = getelementptr inbounds i32, i32* %0, i64 1
%3 = load i32, i32* %2
%4 = load i32, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 2
%6 = load i32, i32* %5
%7 = add i32 %3, %6
%8 = sub i32 %4, %7
%9 = ashr i32 %6, 13
%10 = xor i32 %8, %9
%11 = add i32 %6, %10
%12 = sub i32 %3, %11
%13 = shl i32 %10, 8
%14 = xor i32 %12, %13
%15 = add i32 %10, %14
%16 = sub i32 %6, %15
%17 = ashr i32 %14, 13
%18 = xor i32 %16, %17
%19 = add i32 %14, %18
%20 = sub i32 %10, %19
%21 = ashr i32 %18, 12
%22 = xor i32 %20, %21
%23 = add i32 %18, %22
%24 = sub i32 %14, %23
%25 = shl i32 %22, 16
%26 = xor i32 %24, %25
%27 = add i32 %22, %26
%28 = sub i32 %18, %27
%29 = ashr i32 %26, 5
%30 = xor i32 %28, %29
%31 = add i32 %26, %30
%32 = sub i32 %22, %31
%33 = ashr i32 %30, 3
%34 = xor i32 %32, %33
store i32 %34, i32* %0
%35 = add i32 %30, %34
%36 = sub i32 %26, %35
%37 = shl i32 %34, 10
%38 = xor i32 %36, %37
store i32 %38, i32* %2
%39 = add i32 %34, %38
%40 = sub i32 %30, %39
%41 = ashr i32 %38, 15
%42 = xor i32 %40, %41
store i32 %42, i32* %5
ret void
}