void lud_diagonal_omp(float *a, int size, int offset) {
  int i, j, k;
  for (i = 0; i < 16; i++) {
    for (j = i; j < 16; j++) {
      for (k = 0; k < i; k++) {
        a[offset * size + i * size + j + offset] =
            a[offset * size + i * size + j + offset] -
            a[offset * size + i * size + k + offset] *
                a[offset * size + k * size + j + offset];
      }
    }
    float temp = 1.f / a[offset * size + i * size + i + offset];
    for (j = i + 1; j < 16; j++) {
      for (k = 0; k < i; k++) {
        a[offset * size + j * size + i + offset] =
            a[offset * size + j * size + i + offset] -
            a[offset * size + j * size + k + offset] *
                a[offset * size + k * size + i + offset];
      }
      a[offset * size + j * size + i + offset] =
          a[offset * size + j * size + i + offset] * temp;
    }
  }
}


x86 assembly (clang, -O0):
<lud_diagonal_omp>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x10,-0x14(%rbp)
jge    136a <lud_diagonal_omp+0x26a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x18(%rbp)
jge    1200 <lud_diagonal_omp+0x100>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ed <lud_diagonal_omp+0xed>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x18(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1136 <lud_diagonal_omp+0x36>
jmp    11f2 <lud_diagonal_omp+0xf2>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1125 <lud_diagonal_omp+0x25>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x14(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  0xddb(%rip),%xmm0
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x10,-0x18(%rbp)
jge    1357 <lud_diagonal_omp+0x257>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1300 <lud_diagonal_omp+0x200>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x1c(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x1c(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1249 <lud_diagonal_omp+0x149>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
imul   -0xc(%rbp),%edx
add    %edx,%ecx
add    -0x14(%rbp),%ecx
add    -0x10(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1238 <lud_diagonal_omp+0x138>
jmp    135c <lud_diagonal_omp+0x25c>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1115 <lud_diagonal_omp+0x15>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lud_diagonal_omp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,%eax
imul   %esi,%eax
mov    %rax,-0x40(%rsp)
mov    %esi,%ebx
lea    0x1(%rsi),%ecx
mov    %rdx,%rax
mov    %rdx,-0x48(%rsp)
imul   %edx,%ecx
lea    (%rsi,%rcx,1),%eax
lea    (%rsi,%rsi,1),%r9d
mov    $0x1,%edx
mov    %rdx,-0x28(%rsp)
xor    %r10d,%r10d
movss  0xec0(%rip),%xmm0
mov    %rax,-0x20(%rsp)
mov    %eax,%r8d
mov    %ecx,%eax
mov    %ecx,-0x4c(%rsp)
mov    %rbx,-0x10(%rsp)
jmp    118f <lud_diagonal_omp+0x8f>
cs nopw 0x0(%rax,%rax,1)
nop
addq   $0x1,-0x28(%rsp)
add    %esi,-0x4c(%rsp)
mov    -0x2c(%rsp),%r8d
add    $0x1,%r8d
mov    -0x18(%rsp),%rcx
add    $0x1,%ecx
add    %rbx,-0x20(%rsp)
mov    -0x38(%rsp),%r10
cmp    $0x10,%r10
je     13ee <lud_diagonal_omp+0x2ee>
mov    %r10,%r13
and    $0xfffffffffffffffe,%r13
mov    %r10,%rdx
imul   %rbx,%rdx
mov    -0x40(%rsp),%rax
mov    %rdx,-0x8(%rsp)
add    %edx,%eax
add    -0x48(%rsp),%eax
mov    %rax,-0x38(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %ecx,%r12d
mov    %r8d,-0x2c(%rsp)
mov    %r10,%r15
jmp    11e6 <lud_diagonal_omp+0xe6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r15
add    $0x1,%r8d
add    $0x1,%r12d
cmp    $0x10,%r15
je     12b0 <lud_diagonal_omp+0x1b0>
test   %r10,%r10
je     11d0 <lud_diagonal_omp+0xd0>
mov    -0x38(%rsp),%rax
lea    (%rax,%r15,1),%ecx
movslq %ecx,%r14
movss  (%rdi,%r14,4),%xmm1
cmp    $0x1,%r10
jne    1210 <lud_diagonal_omp+0x110>
xor    %edx,%edx
jmp    126a <lud_diagonal_omp+0x16a>
nopw   0x0(%rax,%rax,1)
mov    %r12d,%ebp
mov    %r8d,%ebx
mov    -0x4c(%rsp),%eax
mov    %eax,%ecx
xor    %edx,%edx
xchg   %ax,%ax
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm2
movslq %ebp,%rbp
mulss  (%rdi,%rbp,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rdi,%r14,4)
lea    0x1(%rcx),%r11d
movslq %r11d,%rax
movss  (%rdi,%rax,4),%xmm2
movslq %ebx,%rbx
mulss  (%rdi,%rbx,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rdi,%r14,4)
add    $0x2,%rdx
add    $0x2,%ecx
add    %r9d,%ebx
add    %r9d,%ebp
cmp    %rdx,%r13
jne    1220 <lud_diagonal_omp+0x120>
test   $0x1,%r10b
je     11d0 <lud_diagonal_omp+0xd0>
mov    -0x48(%rsp),%rax
add    %r15d,%eax
add    -0x40(%rsp),%eax
mov    -0x38(%rsp),%rcx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rdi,%rcx,4),%xmm2
imul   %esi,%edx
add    %eax,%edx
movslq %edx,%rax
mulss  (%rdi,%rax,4),%xmm2
subss  %xmm2,%xmm1
movss  %xmm1,(%rdi,%r14,4)
jmp    11d0 <lud_diagonal_omp+0xd0>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r10),%rax
mov    %rax,-0x38(%rsp)
cmp    $0xe,%r10
mov    -0x10(%rsp),%rbx
ja     1160 <lud_diagonal_omp+0x60>
mov    -0x48(%rsp),%rax
lea    (%r10,%rax,1),%r12d
mov    -0x40(%rsp),%rax
lea    (%r12,%rax,1),%r11d
mov    -0x8(%rsp),%rax
add    %r11d,%eax
movslq %eax,%rcx
movaps %xmm0,%xmm1
divss  (%rdi,%rcx,4),%xmm1
mov    -0x20(%rsp),%rcx
mov    -0x28(%rsp),%rbp
jmp    132a <lud_diagonal_omp+0x22a>
nopl   0x0(%rax)
add    %r11d,%r14d
movslq %r14d,%rax
movss  (%rdi,%rax,4),%xmm2
mulss  %xmm1,%xmm2
movss  %xmm2,(%rdi,%rax,4)
add    $0x1,%rbp
mov    -0x10(%rsp),%rbx
add    %rbx,%rcx
cmp    $0x10,%rbp
je     1160 <lud_diagonal_omp+0x60>
mov    %rbp,%r14
imul   %rbx,%r14
test   %r10,%r10
je     1300 <lud_diagonal_omp+0x200>
mov    -0x40(%rsp),%rax
lea    (%rax,%r14,1),%r15d
lea    (%r12,%r15,1),%edx
movslq %edx,%r8
movss  (%rdi,%r8,4),%xmm2
cmp    $0x1,%r10
jne    1360 <lud_diagonal_omp+0x260>
xor    %edx,%edx
jmp    13b7 <lud_diagonal_omp+0x2b7>
cs nopw 0x0(%rax,%rax,1)
mov    -0x18(%rsp),%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rdx,1),%rax
cltq
movss  (%rdi,%rax,4),%xmm3
movslq %ebx,%rbx
mulss  (%rdi,%rbx,4),%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,(%rdi,%r8,4)
add    $0x1,%eax
cltq
movss  (%rdi,%rax,4),%xmm3
lea    (%rsi,%rbx,1),%eax
cltq
mulss  (%rdi,%rax,4),%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,(%rdi,%r8,4)
add    $0x2,%rdx
add    %r9d,%ebx
cmp    %rdx,%r13
jne    1370 <lud_diagonal_omp+0x270>
test   $0x1,%r10b
je     1300 <lud_diagonal_omp+0x200>
add    -0x48(%rsp),%r15d
add    %edx,%r15d
movslq %r15d,%rax
movss  (%rdi,%rax,4),%xmm3
imul   %esi,%edx
add    %r11d,%edx
movslq %edx,%rax
mulss  (%rdi,%rax,4),%xmm3
subss  %xmm3,%xmm2
movss  %xmm2,(%rdi,%r8,4)
jmp    1300 <lud_diagonal_omp+0x200>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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