#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 */

/* Variables and functions */
double sqrt(double);
void PreConditioning(double *A, int neq, int len, int *ia, int *iz,
                     double alpha, int precFlg, double *C, int *ier) {
  int i = 0, j = 0, jlo = 0, jup = 0, k = 0, klo = 0, kup = 0, l = 0, llo = 0,
      lup = 0;
  int id = 0, nILU = 0, m = 0;
  double factor;
  factor = 1.0 / (1.0 + alpha);
  C[0] = A[0];
  for (i = 1; i < neq; i++) {
    jlo = iz[i - 1] + 1;
    jup = iz[i];
    C[jup] = A[jup];
    for (j = jlo; j < jup; j++)
      C[j] = A[j] * factor;
  }
  nILU = neq;
  for (i = 1; i < nILU; i++) {
    jlo = iz[i - 1] + 1;
    jup = iz[i];
    for (j = jlo; j < jup; j++) {
      C[j] /= C[iz[ia[j]]];
      klo = j + 1;
      kup = jup;
      for (k = klo; k <= kup; k++) {
        m = ia[k];
        llo = iz[m - 1] + 1;
        lup = iz[m];
        for (l = llo; l <= lup; l++) {
          if (ia[l] > ia[j])
            break;
          if (ia[l] < ia[j])
            continue;
          C[k] -= C[j] * C[l];
          break;
        }
      }
    }
    id = iz[i];
    if (C[id] < 1.0e-6) {
      return;
    }
    C[id] = sqrt(C[id]);
  }
  *ier = 1;
  return;
}


x86 assembly (clang, -O0):
<PreConditioning>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
movsd  0xe62(%rip),%xmm1
addsd  -0x28(%rbp),%xmm1
movsd  0xe55(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1267 <PreConditioning+0x157>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1254 <PreConditioning+0x144>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    121b <PreConditioning+0x10b>
jmp    1259 <PreConditioning+0x149>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11cb <PreConditioning+0xbb>
mov    -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    146f <PreConditioning+0x35f>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1414 <PreConditioning+0x304>
mov    0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x18(%rbp),%rdx
movslq -0x34(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1401 <PreConditioning+0x2f1>
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     13ee <PreConditioning+0x2de>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    136f <PreConditioning+0x25f>
jmp    13ee <PreConditioning+0x2de>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1390 <PreConditioning+0x280>
jmp    13e0 <PreConditioning+0x2d0>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    13ee <PreConditioning+0x2de>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1342 <PreConditioning+0x232>
jmp    13f3 <PreConditioning+0x2e3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12fe <PreConditioning+0x1ee>
jmp    1406 <PreConditioning+0x2f6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12aa <PreConditioning+0x19a>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  0xbd6(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1442 <PreConditioning+0x332>
jmp    1479 <PreConditioning+0x369>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <sqrt@plt>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1274 <PreConditioning+0x164>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PreConditioning>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    0x70(%rsp),%r15
movsd  (%rdi),%xmm1
movsd  %xmm1,(%r15)
cmp    $0x2,%esi
jl     14cf <PreConditioning+0x3bf>
mov    %r8,%r14
mov    %rcx,%rbx
movsd  0xebd(%rip),%xmm1
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm1
mov    %esi,0x4(%rsp)
mov    %esi,%r12d
mov    (%r8),%r13d
lea    0x8(%r15),%rax
mov    %rax,0x28(%rsp)
lea    0x8(%rdi),%r10
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    0x30(%r15),%rax
mov    %rax,0x10(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,0x8(%rsp)
mov    $0x1,%eax
mov    %r12,0x20(%rsp)
mov    %r10,0x18(%rsp)
jmp    119d <PreConditioning+0x8d>
nopl   (%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     13a1 <PreConditioning+0x291>
mov    %r13d,%esi
movslq (%r14,%rax,4),%r13
movsd  (%rdi,%r13,8),%xmm2
movsd  %xmm2,(%r15,%r13,8)
lea    0x1(%rsi),%ecx
cmp    %r13d,%ecx
jge    1190 <PreConditioning+0x80>
mov    %r13d,%r8d
movslq %ecx,%rcx
mov    %r8d,%ebp
sub    %esi,%ebp
add    $0xfffffffe,%ebp
cmp    $0x3,%ebp
jb     12f0 <PreConditioning+0x1e0>
lea    (%r15,%rcx,8),%r9
mov    %r8d,%edx
sub    %esi,%edx
add    $0xfffffffe,%edx
add    %rcx,%rdx
lea    (%r10,%rdx,8),%rsi
cmp    %rsi,%r9
jae    11fd <PreConditioning+0xed>
mov    0x28(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%rdi,%rcx,8),%rsi
cmp    %rdx,%rsi
jb     12f0 <PreConditioning+0x1e0>
add    $0x1,%rbp
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0x30(%rsp)
lea    -0x4(%rdx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1390 <PreConditioning+0x280>
mov    %rdx,%r9
and    $0xfffffffffffffffe,%r9
mov    0x10(%rsp),%rsi
lea    (%rsi,%rcx,8),%r11
mov    0x8(%rsp),%rsi
lea    (%rsi,%rcx,8),%r12
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r12,%r10,8),%xmm2
movupd -0x20(%r12,%r10,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,-0x30(%r11,%r10,8)
movupd %xmm3,-0x20(%r11,%r10,8)
movupd -0x10(%r12,%r10,8),%xmm2
movupd (%r12,%r10,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,-0x10(%r11,%r10,8)
movupd %xmm3,(%r11,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r9
jne    1250 <PreConditioning+0x140>
test   $0x1,%dl
je     12ca <PreConditioning+0x1ba>
add    %rcx,%r10
movupd (%rdi,%r10,8),%xmm2
movupd 0x10(%rdi,%r10,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd %xmm2,(%r15,%r10,8)
movupd %xmm3,0x10(%r15,%r10,8)
mov    0x30(%rsp),%rdx
cmp    %rdx,%rbp
mov    0x20(%rsp),%r12
mov    0x18(%rsp),%r10
je     1190 <PreConditioning+0x80>
add    %rdx,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%ebp
sub    %ecx,%ebp
mov    %ecx,%esi
not    %esi
add    %r8d,%esi
and    $0x3,%ebp
je     1328 <PreConditioning+0x218>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
add    $0x1,%rcx
add    $0xffffffff,%ebp
jne    1310 <PreConditioning+0x200>
cmp    $0x3,%esi
jb     1190 <PreConditioning+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r15,%rcx,8)
movsd  0x10(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x10(%r15,%rcx,8)
movsd  0x18(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,0x18(%r15,%rcx,8)
add    $0x4,%rcx
cmp    %ecx,%r8d
jne    1340 <PreConditioning+0x230>
jmp    1190 <PreConditioning+0x80>
xor    %r10d,%r10d
test   $0x1,%dl
jne    12a5 <PreConditioning+0x195>
jmp    12ca <PreConditioning+0x1ba>
cmpl   $0x2,0x4(%rsp)
jl     14cf <PreConditioning+0x3bf>
mov    $0x1,%r13d
movsd  0xc4e(%rip),%xmm2
xorpd  %xmm3,%xmm3
jmp    13e4 <PreConditioning+0x2d4>
call   1030 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0xc37(%rip),%xmm2
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%r13
cmp    %r12,%r13
je     14cf <PreConditioning+0x3bf>
mov    -0x4(%r14,%r13,4),%eax
lea    0x1(%rax),%ecx
movslq (%r14,%r13,4),%rbp
cmp    %ebp,%ecx
jge    14b0 <PreConditioning+0x3a0>
add    $0x2,%eax
movslq %eax,%r9
movslq %ecx,%r8
jmp    141d <PreConditioning+0x30d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
cmp    %r8d,%ebp
je     14b0 <PreConditioning+0x3a0>
mov    %r8,%r10
movslq (%rbx,%r8,4),%rsi
movslq (%r14,%rsi,4),%rax
movsd  (%r15,%r8,8),%xmm0
divsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%r8,8)
add    $0x1,%r8
mov    %r9,%rdi
jmp    145c <PreConditioning+0x34c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rdi),%rax
cmp    %rbp,%rdi
mov    %rax,%rdi
jge    1410 <PreConditioning+0x300>
movslq (%rbx,%rdi,4),%rax
movslq -0x4(%r14,%rax,4),%rcx
mov    (%r14,%rax,4),%eax
cmp    %eax,%ecx
cmovg  %ecx,%eax
cltq
cmp    %rcx,%rax
je     1450 <PreConditioning+0x340>
mov    0x4(%rbx,%rcx,4),%edx
cmp    %esi,%edx
jg     1450 <PreConditioning+0x340>
add    $0x1,%rcx
cmp    %esi,%edx
jl     1470 <PreConditioning+0x360>
movsd  (%r15,%r10,8),%xmm0
movsd  (%r15,%rdi,8),%xmm1
mulsd  (%r15,%rcx,8),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdi,8)
jmp    1450 <PreConditioning+0x340>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rbp,8),%xmm0
ucomisd %xmm0,%xmm2
ja     14da <PreConditioning+0x3ca>
ucomisd %xmm3,%xmm0
jb     13c0 <PreConditioning+0x2b0>
sqrtsd %xmm0,%xmm0
jmp    13d1 <PreConditioning+0x2c1>
mov    0x78(%rsp),%rax
movl   $0x1,(%rax)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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