void lowertriag(float *array, int n) {
  int i, j;
  for (j = n - 1; j >= 1; j--) {
    int k = j, l;
    float pivot1 = *(array + (2 * n) * j + j);
    for (l = k - 1; l >= 0; l--) {
      float next = *(array + (2 * n) * (l) + j) / pivot1;
      for (i = j; i >= 0; i--) {
        *(array + (2 * n) * l + i) -= *(array + (2 * n) * (k) + i) * next;
      }
      for (i = n; i < 2 * n; i++) {
        *(array + (2 * n) * l + i) -= *(array + (2 * n) * (k) + i) * next;
      }
    }
  }
}


x86 assembly (clang, -O0):
<lowertriag>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jl     12b5 <lowertriag+0x1b5>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     12a2 <lowertriag+0x1a2>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     1208 <lowertriag+0x108>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    118e <lowertriag+0x8e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    128f <lowertriag+0x18f>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x24(%rbp),%xmm2
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
shl    $0x1,%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    120e <lowertriag+0x10e>
jmp    1294 <lowertriag+0x194>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1153 <lowertriag+0x53>
jmp    12a7 <lowertriag+0x1a7>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1114 <lowertriag+0x14>
pop    %rbp
ret

x86 assembly (clang, -O2):
<lowertriag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc0,%rsp
mov    %rdi,-0x80(%rsp)
mov    %rsi,-0x48(%rsp)
cmp    $0x2,%esi
jl     1685 <lowertriag+0x585>
mov    -0x48(%rsp),%rax
lea    (%rax,%rax,1),%ecx
lea    -0x1(%rax),%ebx
mov    %eax,%r10d
lea    -0x2(%rax),%r12d
mov    %ecx,-0x64(%rsp)
movslq %ecx,%rdx
mov    %rdx,%rcx
imul   %r12,%rcx
lea    0x1(%r12),%rax
imul   %rdx,%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%r10),%r8
imul   %rdx,%r8
mov    %rdx,%rsi
imul   %r10,%rsi
mov    %rsi,(%rsp)
mov    %rdx,%rdi
sub    %r10,%rdi
lea    0x0(,%rdx,4),%rsi
mov    %rsi,%rax
neg    %rax
mov    %rax,-0x38(%rsp)
xor    $0xfffffffffffffffc,%rsi
lea    (%r8,%rbx,1),%r9
mov    %rdi,-0x58(%rsp)
mov    %rdi,%rax
and    $0xfffffffffffffff8,%rax
mov    %rdx,%rdi
neg    %rdi
mov    %rdi,0x98(%rsp)
mov    -0x80(%rsp),%rdi
lea    (%rdi,%r9,4),%rbp
mov    %rbp,-0x10(%rsp)
lea    0x4(%rdi,%r9,4),%rbp
mov    %rbp,0xa0(%rsp)
lea    -0xc(%rdi,%r9,4),%r11
lea    (%rcx,%r10,1),%r9
lea    (%rcx,%rbx,1),%r15
lea    0x1(%rcx,%rbx,1),%rbp
mov    %rbp,0x90(%rsp)
lea    (%rdi,%rcx,4),%rcx
lea    (%r8,%r10,1),%rbp
lea    (%rdi,%r8,4),%r14
movaps 0xe18(%rip),%xmm0
mov    %rax,0x40(%rsp)
lea    (%rax,%r10,1),%rax
mov    %rax,0x38(%rsp)
mov    %r15,-0x28(%rsp)
lea    -0xc(%rdi,%r15,4),%rax
mov    %rbp,-0x18(%rsp)
lea    0x10(%rdi,%rbp,4),%rbp
mov    %rbp,-0x60(%rsp)
mov    %r9,0x60(%rsp)
lea    0x10(%rdi,%r9,4),%rbp
mov    %rax,%r9
mov    %r10,-0x50(%rsp)
mov    %r10,-0x70(%rsp)
mov    %rcx,%r10
xor    %ecx,%ecx
mov    %rsi,-0x8(%rsp)
jmp    128f <lowertriag+0x18f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rbx
mov    0x30(%rsp),%r12
add    $0xffffffffffffffff,%r12
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
mov    -0x8(%rsp),%rsi
add    %rsi,%r11
mov    0x20(%rsp),%r9
add    %rsi,%r9
mov    -0x38(%rsp),%rax
mov    0x28(%rsp),%r10
add    %rax,%r10
add    %rax,%r14
add    %rax,-0x60(%rsp)
mov    0x18(%rsp),%rbp
add    %rax,%rbp
cmpq   $0x3,0x8(%rsp)
jl     1685 <lowertriag+0x585>
mov    -0x70(%rsp),%r8
test   %ebx,%ebx
mov    $0x0,%eax
cmovs  %ebx,%eax
mov    %ebx,%edi
sub    %eax,%edi
lea    0x1(%rdi),%rax
mov    %rax,0x88(%rsp)
mov    %rax,%r13
and    $0xfffffffffffffff8,%r13
mov    %r13,%r15
neg    %r15
imul   %rcx,%rsi
mov    -0x10(%rsp),%rax
mov    %rsi,-0x30(%rsp)
add    %rsi,%rax
mov    %rdi,-0x20(%rsp)
lea    0x0(,%rdi,4),%rsi
mov    %rax,0xa8(%rsp)
sub    %rsi,%rax
mov    %rax,-0x40(%rsp)
neg    %rsi
mov    %rsi,0xb0(%rsp)
mov    %rcx,0x10(%rsp)
mov    %rcx,%rsi
imul   %rdx,%rsi
mov    -0x18(%rsp),%rax
sub    %rsi,%rax
mov    -0x80(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0x50(%rsp)
mov    (%rsp),%rax
mov    %rsi,0x70(%rsp)
sub    %rsi,%rax
lea    (%rcx,%rax,4),%rax
mov    %rax,0x68(%rsp)
lea    -0x1(%r8),%rax
mov    %rax,%rsi
mov    %rax,-0x70(%rsp)
imul   %rdx,%rax
lea    (%rcx,%rax,4),%rax
mov    %r8,0x8(%rsp)
mov    %rax,0x58(%rsp)
movss  -0x4(%rax,%r8,4),%xmm1
mov    %rbx,%rax
mov    %r13,0x80(%rsp)
sub    %r13,%rax
mov    %rax,0x78(%rsp)
mov    %rbp,0x18(%rsp)
mov    %r10,0x28(%rsp)
mov    %r9,0x20(%rsp)
xor    %ecx,%ecx
mov    %r12,0x30(%rsp)
mov    %rbx,-0x78(%rsp)
jmp    13a8 <lowertriag+0x2a8>
lea    -0x1(%r12),%rax
add    $0x1,%rcx
mov    -0x38(%rsp),%rsi
add    %rsi,%r9
add    %rsi,%r10
add    %rsi,%rbp
test   %r12,%r12
mov    %rax,%r12
mov    -0x78(%rsp),%rbx
jle    1240 <lowertriag+0x140>
mov    %rcx,%rsi
imul   %rdx,%rsi
mov    %r12,%rax
imul   %rdx,%rax
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
mov    -0x70(%rsp),%rax
mov    %rdi,0xb8(%rsp)
movss  (%rdi,%rax,4),%xmm2
divss  %xmm1,%xmm2
mov    %rbx,%rax
cmpl   $0x7,-0x20(%rsp)
jb     14f0 <lowertriag+0x3f0>
mov    -0x28(%rsp),%rax
sub    %rsi,%rax
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
add    -0x30(%rsp),%rdi
mov    0xb0(%rsp),%rax
lea    (%rdi,%rax,1),%rbx
mov    -0x78(%rsp),%rax
cmp    %rdi,%rbx
ja     14f0 <lowertriag+0x3f0>
mov    -0x78(%rsp),%rax
mov    -0x40(%rsp),%rdi
cmp    0xa8(%rsp),%rdi
ja     14f0 <lowertriag+0x3f0>
mov    -0x20(%rsp),%rax
add    %rsi,%rax
mov    -0x28(%rsp),%rdi
sub    %rax,%rdi
mov    -0x80(%rsp),%rax
lea    (%rax,%rdi,4),%rax
cmp    0xa0(%rsp),%rax
jae    1473 <lowertriag+0x373>
mov    0x90(%rsp),%rax
sub    %rsi,%rax
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rax,4),%rdi
add    -0x30(%rsp),%rdi
mov    -0x78(%rsp),%rax
cmp    %rdi,-0x40(%rsp)
jb     14f0 <lowertriag+0x3f0>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%r11,%rbx,4),%xmm4
movups (%r11,%rbx,4),%xmm5
shufps $0x1b,%xmm5,%xmm5
shufps $0x1b,%xmm4,%xmm4
movups -0x10(%r9,%rbx,4),%xmm6
movups (%r9,%rbx,4),%xmm7
xorps  %xmm0,%xmm5
xorps  %xmm0,%xmm4
mulps  %xmm3,%xmm5
mulps  %xmm3,%xmm4
shufps $0x1b,%xmm5,%xmm5
addps  %xmm7,%xmm5
movups %xmm5,(%r9,%rbx,4)
shufps $0x1b,%xmm4,%xmm4
addps  %xmm6,%xmm4
movups %xmm4,-0x10(%r9,%rbx,4)
add    $0xfffffffffffffff8,%rbx
cmp    %rbx,%r15
jne    1480 <lowertriag+0x380>
mov    0x78(%rsp),%rax
mov    0x80(%rsp),%rdi
cmp    %rdi,0x88(%rsp)
je     1527 <lowertriag+0x427>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rax),%ebx
lea    (%r10,%rax,4),%rdi
lea    (%r14,%rax,4),%rax
xor    %r13d,%r13d
xchg   %ax,%ax
movss  (%rdi,%r13,4),%xmm3
movss  (%rax,%r13,4),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,(%rdi,%r13,4)
add    $0xffffffffffffffff,%r13
lea    (%rbx,%r13,1),%r8d
test   %r8d,%r8d
jg     1500 <lowertriag+0x400>
mov    -0x64(%rsp),%eax
cmp    -0x48(%rsp),%eax
jle    1380 <lowertriag+0x280>
mov    -0x50(%rsp),%rbx
cmpq   $0x8,-0x58(%rsp)
jb     15f0 <lowertriag+0x4f0>
add    0x70(%rsp),%rsi
mov    0x60(%rsp),%rax
sub    %rsi,%rax
mov    -0x80(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
cmp    0x68(%rsp),%rax
jae    1580 <lowertriag+0x480>
mov    0x48(%rsp),%rax
sub    %rsi,%rax
mov    -0x80(%rsp),%rsi
lea    (%rsi,%rax,4),%rax
mov    -0x50(%rsp),%rbx
cmp    %rax,0x50(%rsp)
jb     15f0 <lowertriag+0x4f0>
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
xor    %eax,%eax
mov    0x40(%rsp),%rsi
mov    -0x60(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdi,%rax,4),%xmm4
movups (%rdi,%rax,4),%xmm5
movups -0x10(%rbp,%rax,4),%xmm6
movups 0x0(%rbp,%rax,4),%xmm7
mulps  %xmm3,%xmm4
subps  %xmm4,%xmm6
mulps  %xmm3,%xmm5
subps  %xmm5,%xmm7
movups %xmm6,-0x10(%rbp,%rax,4)
movups %xmm7,0x0(%rbp,%rax,4)
add    $0x8,%rax
cmp    %rax,%rsi
jne    15a0 <lowertriag+0x4a0>
mov    0x38(%rsp),%rbx
cmp    %rsi,-0x58(%rsp)
je     1380 <lowertriag+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rsi
test   $0x1,%bl
je     1620 <lowertriag+0x520>
mov    0xb8(%rsp),%rsi
movss  (%rsi,%rbx,4),%xmm3
mov    0x58(%rsp),%rax
movss  (%rax,%rbx,4),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,(%rsi,%rbx,4)
lea    0x1(%rbx),%rsi
not    %rbx
cmp    0x98(%rsp),%rbx
je     1380 <lowertriag+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rsi,4),%xmm3
mulss  %xmm2,%xmm3
movss  (%r10,%rsi,4),%xmm4
subss  %xmm3,%xmm4
movss  0x4(%r10,%rsi,4),%xmm3
movss  %xmm4,(%r10,%rsi,4)
movss  0x4(%r14,%rsi,4),%xmm4
mulss  %xmm2,%xmm4
subss  %xmm4,%xmm3
movss  %xmm3,0x4(%r10,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rdx
jne    1640 <lowertriag+0x540>
jmp    1380 <lowertriag+0x280>
add    $0xc0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @lowertriag(float* %0, i32 %1) {
%3 = alloca float*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
%10 = alloca float
store float* %0, float** %3
store i32 %1, i32* %4
%11 = load i32, i32* %4
%12 = sub nsw i32 %11, 1
store i32 %12, i32* %6
br label %13
13: ; preds = %122, %2
%14 = load i32, i32* %6
%15 = icmp sge i32 %14, 1
br i1 %15, label %16, label %125
16: ; preds = %13
%17 = load i32, i32* %6
store i32 %17, i32* %7
%18 = load float*, float** %3
%19 = load i32, i32* %4
%20 = mul nsw i32 2, %19
%21 = load i32, i32* %6
%22 = mul nsw i32 %20, %21
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %18, i64 %23
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float, float* %24, i64 %26
%28 = load float, float* %27
store float %28, float* %9
%29 = load i32, i32* %7
%30 = sub nsw i32 %29, 1
store i32 %30, i32* %8
br label %31
31: ; preds = %118, %16
%32 = load i32, i32* %8
%33 = icmp sge i32 %32, 0
br i1 %33, label %34, label %121
34: ; preds = %31
%35 = load float*, float** %3
%36 = load i32, i32* %4
%37 = mul nsw i32 2, %36
%38 = load i32, i32* %8
%39 = mul nsw i32 %37, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %35, i64 %40
%42 = load i32, i32* %6
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
%45 = load float, float* %44
%46 = load float, float* %9
%47 = fdiv float %45, %46
store float %47, float* %10
%48 = load i32, i32* %6
store i32 %48, i32* %5
br label %49
49: ; preds = %78, %34
%50 = load i32, i32* %5
%51 = icmp sge i32 %50, 0
br i1 %51, label %52, label %81
52: ; preds = %49
%53 = load float*, float** %3
%54 = load i32, i32* %4
%55 = mul nsw i32 2, %54
%56 = load i32, i32* %7
%57 = mul nsw i32 %55, %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %53, i64 %58
%60 = load i32, i32* %5
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = load float, float* %10
%65 = load float*, float** %3
%66 = load i32, i32* %4
%67 = mul nsw i32 2, %66
%68 = load i32, i32* %8
%69 = mul nsw i32 %67, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %65, i64 %70
%72 = load i32, i32* %5
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %71, i64 %73
%75 = load float, float* %74
%76 = fneg float %63
%77 = call float @llvm.fmuladd.f32(float %76, float %64, float %75)
store float %77, float* %74
br label %78
78: ; preds = %52
%79 = load i32, i32* %5
%80 = add nsw i32 %79, -1
store i32 %80, i32* %5
br label %49
81: ; preds = %49
%82 = load i32, i32* %4
store i32 %82, i32* %5
br label %83
83: ; preds = %114, %81
%84 = load i32, i32* %5
%85 = load i32, i32* %4
%86 = mul nsw i32 2, %85
%87 = icmp slt i32 %84, %86
br i1 %87, label %88, label %117
88: ; preds = %83
%89 = load float*, float** %3
%90 = load i32, i32* %4
%91 = mul nsw i32 2, %90
%92 = load i32, i32* %7
%93 = mul nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %89, i64 %94
%96 = load i32, i32* %5
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float, float* %98
%100 = load float, float* %10
%101 = load float*, float** %3
%102 = load i32, i32* %4
%103 = mul nsw i32 2, %102
%104 = load i32, i32* %8
%105 = mul nsw i32 %103, %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %101, i64 %106
%108 = load i32, i32* %5
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
%111 = load float, float* %110
%112 = fneg float %99
%113 = call float @llvm.fmuladd.f32(float %112, float %100, float %111)
store float %113, float* %110
br label %114
114: ; preds = %88
%115 = load i32, i32* %5
%116 = add nsw i32 %115, 1
store i32 %116, i32* %5
br label %83
117: ; preds = %83
br label %118
118: ; preds = %117
%119 = load i32, i32* %8
%120 = add nsw i32 %119, -1
store i32 %120, i32* %8
br label %31
121: ; preds = %31
br label %122
122: ; preds = %121
%123 = load i32, i32* %6
%124 = add nsw i32 %123, -1
store i32 %124, i32* %6
br label %13
125: ; preds = %13
ret void
}

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