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

/* Variables and functions */
size_t shuffle(size_t, size_t, size_t);
float K(uint32_t a, uint32_t A[3], uint32_t i, uint32_t j, uint32_t k, float u,
        float v, float w) {
  float s = (float)(A[0] + A[1] + A[2]) / 6.f;
  float x = u - (float)A[0] + s;
  float y = v - (float)A[1] + s;
  float z = w - (float)A[2] + s;
  float t = .6f - x * x - y * y - z * z;
  uint32_t h = shuffle(i + A[0], j + A[1], k + A[2]);
  A[a]++;
  if (t < 0)
    return 0;
  uint32_t b5 = h >> 5 & 1;
  uint32_t b4 = h >> 4 & 1;
  uint32_t b3 = h >> 3 & 1;
  uint32_t b2 = h >> 2 & 1;
  uint32_t b = h & 3;
  float p = (b == 1 ? x : (b == 2 ? y : z));
  float q = (b == 1 ? y : (b == 2 ? z : x));
  float r = (b == 1 ? z : (b == 2 ? x : y));
  p = (b5 == b3 ? -p : p);
  q = (b5 == b4 ? -q : q);
  r = (b5 != (b4 ^ b3) ? -r : r);
  t *= t;
  return 25.0f * t * t * (p + (b == 0 ? q + r : (b2 == 0 ? q : r)));
}


x86 assembly (clang, -O0):
<K>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movss  %xmm0,-0x34(%rbp)
movss  %xmm1,-0x38(%rbp)
movss  %xmm2,-0x3c(%rbp)
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rax
mov    0x8(%rcx),%rdx
add    %rdx,%rax
mov    0x10(%rcx),%rcx
add    %rcx,%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x94(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x90(%rbp)
ff
js     1198 <K+0x88>
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x90(%rbp),%xmm0
ff
movss  0xe5c(%rip),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0x9c(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0x98(%rbp)
ff
js     120a <K+0xfa>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  -0x98(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xa8(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xa4(%rbp)
ff
js     1286 <K+0x176>
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movss  -0xa4(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
movss  -0x40(%rbp),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,%rdx
shr    %rdx
mov    %eax,%ecx
and    $0x1,%ecx
or     %rdx,%rcx
cvtsi2ss %rcx,%xmm0
addss  %xmm0,%xmm0
cvtsi2ss %rax,%xmm1
movss  %xmm1,-0xb4(%rbp)
ff
test   %rax,%rax
movss  %xmm0,-0xb0(%rbp)
ff
js     1302 <K+0x1f2>
movss  -0xb4(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xb8(%rbp),%xmm0
ff
movss  -0xb0(%rbp),%xmm1
ff
subss  %xmm1,%xmm0
addss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xcbd(%rip),%xmm1
addss  %xmm1,%xmm0
movss  -0x48(%rbp),%xmm1
movss  -0x48(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rax
add    (%rax),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x18(%rbp),%rax
add    0x8(%rax),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x18(%rbp),%rax
add    0x10(%rax),%rdx
call   1030 <shuffle@plt>
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
add    $0x1,%rdx
mov    %rdx,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
ucomiss -0x50(%rbp),%xmm0
jbe    13e4 <K+0x2d4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1722 <K+0x612>
mov    -0x58(%rbp),%rax
shr    $0x5,%rax
and    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
shr    $0x4,%rax
and    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
shr    $0x3,%rax
and    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rax
shr    $0x2,%rax
and    $0x1,%rax
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%rax
and    $0x3,%rax
mov    %rax,-0x80(%rbp)
cmpq   $0x1,-0x80(%rbp)
jne    144d <K+0x33d>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
jmp    1487 <K+0x377>
cmpq   $0x2,-0x80(%rbp)
jne    146a <K+0x35a>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
jmp    1477 <K+0x367>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xbc(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
cmpq   $0x1,-0x80(%rbp)
jne    14b4 <K+0x3a4>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
jmp    14ee <K+0x3de>
cmpq   $0x2,-0x80(%rbp)
jne    14d1 <K+0x3c1>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
jmp    14de <K+0x3ce>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xc4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
cmpq   $0x1,-0x80(%rbp)
jne    151b <K+0x40b>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
jmp    1555 <K+0x445>
cmpq   $0x2,-0x80(%rbp)
jne    1538 <K+0x428>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
jmp    1545 <K+0x435>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xcc(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x60(%rbp),%rax
cmp    -0x70(%rbp),%rax
jne    1595 <K+0x485>
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
jmp    15a5 <K+0x495>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x60(%rbp),%rax
cmp    -0x68(%rbp),%rax
jne    15e5 <K+0x4d5>
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
jmp    15f5 <K+0x4e5>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x60(%rbp),%rax
mov    -0x68(%rbp),%rcx
xor    -0x70(%rbp),%rcx
cmp    %rcx,%rax
je     163c <K+0x52c>
movss  -0x8c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
jmp    164c <K+0x53c>
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  0x995(%rip),%xmm0
mulss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
cmpq   $0x0,-0x80(%rbp)
jne    16bd <K+0x5ad>
movss  -0x88(%rbp),%xmm0
ff
addss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
jmp    16fd <K+0x5ed>
cmpq   $0x0,-0x78(%rbp)
jne    16dd <K+0x5cd>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
jmp    16ed <K+0x5dd>
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0xec(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  -0xe0(%rbp),%xmm1
ff
movss  -0xe8(%rbp),%xmm2
ff
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<K>:
push   %r15
push   %r14
push   %rbx
sub    $0x40,%rsp
mov    %rdx,%r9
mov    %rsi,%r15
mov    %rdi,%r14
mov    (%rsi),%rdi
mov    0x8(%rsi),%rsi
lea    (%rsi,%rdi,1),%rax
mov    0x10(%r15),%rdx
add    %rdx,%rax
js     1159 <K+0x49>
cvtsi2ss %rax,%xmm4
test   %rdi,%rdi
jns    1173 <K+0x63>
mov    %rdi,%rax
shr    %rax
mov    %edi,%ebx
and    $0x1,%ebx
or     %rax,%rbx
cvtsi2ss %rbx,%xmm3
addss  %xmm3,%xmm3
jmp    1178 <K+0x68>
mov    %rax,%rbx
shr    %rbx
and    $0x1,%eax
or     %rbx,%rax
cvtsi2ss %rax,%xmm4
addss  %xmm4,%xmm4
test   %rdi,%rdi
js     1140 <K+0x30>
cvtsi2ss %rdi,%xmm3
divss  0xe80(%rip),%xmm4
subss  %xmm3,%xmm0
test   %rsi,%rsi
js     1193 <K+0x83>
xorps  %xmm3,%xmm3
cvtsi2ss %rsi,%xmm3
jmp    11ad <K+0x9d>
mov    %rsi,%rax
shr    %rax
mov    %esi,%ebx
and    $0x1,%ebx
or     %rax,%rbx
xorps  %xmm3,%xmm3
cvtsi2ss %rbx,%xmm3
addss  %xmm3,%xmm3
addss  %xmm4,%xmm0
subss  %xmm3,%xmm1
addss  %xmm4,%xmm1
test   %rdx,%rdx
js     11c8 <K+0xb8>
xorps  %xmm3,%xmm3
cvtsi2ss %rdx,%xmm3
jmp    11e2 <K+0xd2>
mov    %rdx,%rax
shr    %rax
mov    %edx,%ebx
and    $0x1,%ebx
or     %rax,%rbx
xorps  %xmm3,%xmm3
cvtsi2ss %rbx,%xmm3
addss  %xmm3,%xmm3
subss  %xmm3,%xmm2
addss  %xmm4,%xmm2
movaps %xmm2,0x10(%rsp)
movaps %xmm0,%xmm3
mulss  %xmm0,%xmm3
movss  0xe06(%rip),%xmm4
subss  %xmm3,%xmm4
movaps %xmm1,%xmm3
mulss  %xmm1,%xmm3
subss  %xmm3,%xmm4
movaps %xmm2,%xmm3
mulss  %xmm2,%xmm3
subss  %xmm3,%xmm4
movss  %xmm4,0xc(%rsp)
add    %r9,%rdi
add    %rcx,%rsi
add    %r8,%rdx
movaps %xmm0,0x20(%rsp)
movaps %xmm1,0x30(%rsp)
call   1030 <shuffle@plt>
movss  0xc(%rsp),%xmm6
addq   $0x1,(%r15,%r14,8)
xorps  %xmm0,%xmm0
ucomiss %xmm6,%xmm0
ja     12f7 <K+0x1e7>
mov    %eax,%edx
shr    $0x5,%edx
and    $0x1,%edx
mov    %eax,%esi
shr    $0x4,%esi
mov    %eax,%edi
shr    $0x3,%edi
and    $0x1,%edi
mov    %eax,%ecx
and    $0x3,%ecx
movaps 0x30(%rsp),%xmm4
movaps %xmm4,%xmm0
movaps 0x10(%rsp),%xmm5
movaps %xmm5,%xmm1
movaps 0x20(%rsp),%xmm3
movaps %xmm3,%xmm2
cmp    $0x2,%rcx
je     128e <K+0x17e>
movaps %xmm5,%xmm0
movaps %xmm3,%xmm1
movaps %xmm4,%xmm2
and    $0x1,%esi
cmp    $0x1,%rcx
je     12a0 <K+0x190>
movaps %xmm0,%xmm3
movaps %xmm1,%xmm4
movaps %xmm2,%xmm5
movaps 0xd69(%rip),%xmm0
cmp    %rdi,%rdx
jne    12af <K+0x19f>
xorps  %xmm0,%xmm3
cmp    %rsi,%rdx
jne    12b7 <K+0x1a7>
xorps  %xmm0,%xmm4
xor    %rdi,%rsi
cmp    %rsi,%rdx
je     12c2 <K+0x1b2>
xorps  %xmm0,%xmm5
mulss  %xmm6,%xmm6
movss  0xd3a(%rip),%xmm1
mulss  %xmm6,%xmm1
movaps %xmm4,%xmm0
test   $0x4,%al
je     12dc <K+0x1cc>
movaps %xmm5,%xmm0
mulss  %xmm1,%xmm6
test   %rcx,%rcx
jne    12ec <K+0x1dc>
addss  %xmm5,%xmm4
movaps %xmm4,%xmm0
addss  %xmm0,%xmm3
mulss  %xmm3,%xmm6
movaps %xmm6,%xmm0
add    $0x40,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define float @K(i64 %0, i64* %1, i64 %2, i64 %3, i64 %4, float %5, float %6, float %7) {
%9 = alloca float
%10 = alloca i64
%11 = alloca i64*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca float
%30 = alloca float
%31 = alloca float
store i64 %0, i64* %10
store i64* %1, i64** %11
store i64 %2, i64* %12
store i64 %3, i64* %13
store i64 %4, i64* %14
store float %5, float* %15
store float %6, float* %16
store float %7, float* %17
%32 = load i64*, i64** %11
%33 = getelementptr inbounds i64, i64* %32, i64 0
%34 = load i64, i64* %33
%35 = load i64*, i64** %11
%36 = getelementptr inbounds i64, i64* %35, i64 1
%37 = load i64, i64* %36
%38 = add i64 %34, %37
%39 = load i64*, i64** %11
%40 = getelementptr inbounds i64, i64* %39, i64 2
%41 = load i64, i64* %40
%42 = add i64 %38, %41
%43 = uitofp i64 %42 to float
%44 = fdiv float %43, 6.000000e+00
store float %44, float* %18
%45 = load float, float* %15
%46 = load i64*, i64** %11
%47 = getelementptr inbounds i64, i64* %46, i64 0
%48 = load i64, i64* %47
%49 = uitofp i64 %48 to float
%50 = fsub float %45, %49
%51 = load float, float* %18
%52 = fadd float %50, %51
store float %52, float* %19
%53 = load float, float* %16
%54 = load i64*, i64** %11
%55 = getelementptr inbounds i64, i64* %54, i64 1
%56 = load i64, i64* %55
%57 = uitofp i64 %56 to float
%58 = fsub float %53, %57
%59 = load float, float* %18
%60 = fadd float %58, %59
store float %60, float* %20
%61 = load float, float* %17
%62 = load i64*, i64** %11
%63 = getelementptr inbounds i64, i64* %62, i64 2
%64 = load i64, i64* %63
%65 = uitofp i64 %64 to float
%66 = fsub float %61, %65
%67 = load float, float* %18
%68 = fadd float %66, %67
store float %68, float* %21
%69 = load float, float* %19
%70 = load float, float* %19
%71 = fneg float %69
%72 = call float @llvm.fmuladd.f32(float %71, float %70, float 0x3FE3333340000000)
%73 = load float, float* %20
%74 = load float, float* %20
%75 = fneg float %73
%76 = call float @llvm.fmuladd.f32(float %75, float %74, float %72)
%77 = load float, float* %21
%78 = load float, float* %21
%79 = fneg float %77
%80 = call float @llvm.fmuladd.f32(float %79, float %78, float %76)
store float %80, float* %22
%81 = load i64, i64* %12
%82 = load i64*, i64** %11
%83 = getelementptr inbounds i64, i64* %82, i64 0
%84 = load i64, i64* %83
%85 = add i64 %81, %84
%86 = load i64, i64* %13
%87 = load i64*, i64** %11
%88 = getelementptr inbounds i64, i64* %87, i64 1
%89 = load i64, i64* %88
%90 = add i64 %86, %89
%91 = load i64, i64* %14
%92 = load i64*, i64** %11
%93 = getelementptr inbounds i64, i64* %92, i64 2
%94 = load i64, i64* %93
%95 = add i64 %91, %94
%96 = call i64 @shuffle(i64 %85, i64 %90, i64 %95)
store i64 %96, i64* %23
%97 = load i64*, i64** %11
%98 = load i64, i64* %10
%99 = getelementptr inbounds i64, i64* %97, i64 %98
%100 = load i64, i64* %99
%101 = add i64 %100, 1
store i64 %101, i64* %99
%102 = load float, float* %22
%103 = fcmp olt float %102, 0.000000e+00
br i1 %103, label %104, label %105
104: ; preds = %8
store float 0.000000e+00, float* %9
br label %224
105: ; preds = %8
%106 = load i64, i64* %23
%107 = lshr i64 %106, 5
%108 = and i64 %107, 1
store i64 %108, i64* %24
%109 = load i64, i64* %23
%110 = lshr i64 %109, 4
%111 = and i64 %110, 1
store i64 %111, i64* %25
%112 = load i64, i64* %23
%113 = lshr i64 %112, 3
%114 = and i64 %113, 1
store i64 %114, i64* %26
%115 = load i64, i64* %23
%116 = lshr i64 %115, 2
%117 = and i64 %116, 1
store i64 %117, i64* %27
%118 = load i64, i64* %23
%119 = and i64 %118, 3
store i64 %119, i64* %28
%120 = load i64, i64* %28
%121 = icmp eq i64 %120, 1
br i1 %121, label %122, label %124
122: ; preds = %105
%123 = load float, float* %19
br label %133
124: ; preds = %105
%125 = load i64, i64* %28
%126 = icmp eq i64 %125, 2
br i1 %126, label %127, label %129
127: ; preds = %124
%128 = load float, float* %20
br label %131
129: ; preds = %124
%130 = load float, float* %21
br label %131
131: ; preds = %129, %127
%132 = phi float [ %128, %127 ], [ %130, %129 ]
br label %133
133: ; preds = %131, %122
%134 = phi float [ %123, %122 ], [ %132, %131 ]
store float %134, float* %29
%135 = load i64, i64* %28
%136 = icmp eq i64 %135, 1
br i1 %136, label %137, label %139
137: ; preds = %133
%138 = load float, float* %20
br label %148
139: ; preds = %133
%140 = load i64, i64* %28
%141 = icmp eq i64 %140, 2
br i1 %141, label %142, label %144
142: ; preds = %139
%143 = load float, float* %21
br label %146
144: ; preds = %139
%145 = load float, float* %19
br label %146
146: ; preds = %144, %142
%147 = phi float [ %143, %142 ], [ %145, %144 ]
br label %148
148: ; preds = %146, %137
%149 = phi float [ %138, %137 ], [ %147, %146 ]
store float %149, float* %30
%150 = load i64, i64* %28
%151 = icmp eq i64 %150, 1
br i1 %151, label %152, label %154
152: ; preds = %148
%153 = load float, float* %21
br label %163
154: ; preds = %148
%155 = load i64, i64* %28
%156 = icmp eq i64 %155, 2
br i1 %156, label %157, label %159
157: ; preds = %154
%158 = load float, float* %19
br label %161
159: ; preds = %154
%160 = load float, float* %20
br label %161
161: ; preds = %159, %157
%162 = phi float [ %158, %157 ], [ %160, %159 ]
br label %163
163: ; preds = %161, %152
%164 = phi float [ %153, %152 ], [ %162, %161 ]
store float %164, float* %31
%165 = load i64, i64* %24
%166 = load i64, i64* %26
%167 = icmp eq i64 %165, %166
br i1 %167, label %168, label %171
168: ; preds = %163
%169 = load float, float* %29
%170 = fneg float %169
br label %173
171: ; preds = %163
%172 = load float, float* %29
br label %173
173: ; preds = %171, %168
%174 = phi float [ %170, %168 ], [ %172, %171 ]
store float %174, float* %29
%175 = load i64, i64* %24
%176 = load i64, i64* %25
%177 = icmp eq i64 %175, %176
br i1 %177, label %178, label %181
178: ; preds = %173
%179 = load float, float* %30
%180 = fneg float %179
br label %183
181: ; preds = %173
%182 = load float, float* %30
br label %183
183: ; preds = %181, %178
%184 = phi float [ %180, %178 ], [ %182, %181 ]
store float %184, float* %30
%185 = load i64, i64* %24
%186 = load i64, i64* %25
%187 = load i64, i64* %26
%188 = xor i64 %186, %187
%189 = icmp ne i64 %185, %188
br i1 %189, label %190, label %193
190: ; preds = %183
%191 = load float, float* %31
%192 = fneg float %191
br label %195
193: ; preds = %183
%194 = load float, float* %31
br label %195
195: ; preds = %193, %190
%196 = phi float [ %192, %190 ], [ %194, %193 ]
store float %196, float* %31
%197 = load float, float* %22
%198 = load float, float* %22
%199 = fmul float %198, %197
store float %199, float* %22
%200 = load float, float* %22
%201 = fmul float 2.500000e+01, %200
%202 = load float, float* %22
%203 = fmul float %201, %202
%204 = load float, float* %29
%205 = load i64, i64* %28
%206 = icmp eq i64 %205, 0
br i1 %206, label %207, label %211
207: ; preds = %195
%208 = load float, float* %30
%209 = load float, float* %31
%210 = fadd float %208, %209
br label %220
211: ; preds = %195
%212 = load i64, i64* %27
%213 = icmp eq i64 %212, 0
br i1 %213, label %214, label %216
214: ; preds = %211
%215 = load float, float* %30
br label %218
216: ; preds = %211
%217 = load float, float* %31
br label %218
218: ; preds = %216, %214
%219 = phi float [ %215, %214 ], [ %217, %216 ]
br label %220
220: ; preds = %218, %207
%221 = phi float [ %210, %207 ], [ %219, %218 ]
%222 = fadd float %204, %221
%223 = fmul float %203, %222
store float %223, float* %9
br label %224
224: ; preds = %220, %104
%225 = load float, float* %9
ret float %225
}

LLVM IR (-O2):
define float @K(i64 %0, i64* nocapture %1, i64 %2, i64 %3, i64 %4, float %5, float %6, float %7) {
%9 = load i64, i64* %1
%10 = getelementptr inbounds i64, i64* %1, i64 1
%11 = load i64, i64* %10
%12 = add i64 %11, %9
%13 = getelementptr inbounds i64, i64* %1, i64 2
%14 = load i64, i64* %13
%15 = add i64 %12, %14
%16 = uitofp i64 %15 to float
%17 = fdiv float %16, 6.000000e+00
%18 = uitofp i64 %9 to float
%19 = fsub float %5, %18
%20 = fadd float %19, %17
%21 = uitofp i64 %11 to float
%22 = fsub float %6, %21
%23 = fadd float %22, %17
%24 = uitofp i64 %14 to float
%25 = fsub float %7, %24
%26 = fadd float %25, %17
%27 = fneg float %20
%28 = tail call float @llvm.fmuladd.f32(float %27, float %20, float 0x3FE3333340000000)
%29 = fneg float %23
%30 = tail call float @llvm.fmuladd.f32(float %29, float %23, float %28)
%31 = fneg float %26
%32 = tail call float @llvm.fmuladd.f32(float %31, float %26, float %30)
%33 = add i64 %9, %2
%34 = add i64 %11, %3
%35 = add i64 %14, %4
%36 = tail call i64 @shuffle(i64 %33, i64 %34, i64 %35)
%37 = getelementptr inbounds i64, i64* %1, i64 %0
%38 = load i64, i64* %37
%39 = add i64 %38, 1
store i64 %39, i64* %37
%40 = fcmp olt float %32, 0.000000e+00
br i1 %40, label %78, label %41
41: ; preds = %8
%42 = lshr i64 %36, 5
%43 = and i64 %42, 1
%44 = lshr i64 %36, 4
%45 = and i64 %44, 1
%46 = lshr i64 %36, 3
%47 = and i64 %46, 1
%48 = and i64 %36, 3
%49 = icmp eq i64 %48, 1
%50 = icmp eq i64 %48, 2
%51 = select i1 %50, float %23, float %26
%52 = select i1 %49, float %20, float %51
%53 = select i1 %50, float %26, float %20
%54 = select i1 %49, float %23, float %53
%55 = select i1 %50, float %20, float %23
%56 = select i1 %49, float %26, float %55
%57 = icmp eq i64 %43, %47
%58 = fneg float %52
%59 = select i1 %57, float %58, float %52
%60 = icmp eq i64 %43, %45
%61 = fneg float %54
%62 = select i1 %60, float %61, float %54
%63 = xor i64 %45, %47
%64 = icmp eq i64 %43, %63
%65 = fneg float %56
%66 = select i1 %64, float %56, float %65
%67 = fmul float %32, %32
%68 = fmul float %67, 2.500000e+01
%69 = fmul float %67, %68
%70 = icmp eq i64 %48, 0
%71 = fadd float %62, %66
%72 = and i64 %36, 4
%73 = icmp eq i64 %72, 0
%74 = select i1 %73, float %62, float %66
%75 = select i1 %70, float %71, float %74
%76 = fadd float %59, %75
%77 = fmul float %69, %76
br label %78
78: ; preds = %8, %41
%79 = phi float [ %77, %41 ], [ 0.000000e+00, %8 ]
ret float %79
}