#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 */
float *calloc(int, int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ printf(char *);
float sqrt(float);
float conv_damping(int nBasis, float alpha, float *PA, float *PB) {
  static float *prevPA = NULL;
  static float *prevPB = NULL;
  static int nIter = 0;
  int i, j;
  float avgdP;
  if (nBasis == 0 && alpha == 0.0 && PA == NULL && PB == NULL) {
    nIter = 0;
    if (prevPA != NULL) {
      free(prevPA);
      prevPA = NULL;
    }
    if (prevPB != NULL) {
      free(prevPB);
      prevPB = NULL;
    }
    return 0.0;
  }
  if (alpha < 0.0 || alpha > 1.0) {
    printf("conv_damping : invalid range of alpha\n");
    exit(-1);
  }
  if (nIter == 0) {
    if (prevPA != NULL || prevPB != NULL) {
      printf("conv_damping : detect prior initialized pointers\n");
      exit(-1);
    }
    prevPA = calloc(nBasis * nBasis, sizeof(float));
    prevPB = calloc(nBasis * nBasis, sizeof(float));
    if (prevPA == NULL || prevPB == NULL) {
      printf("conv_damping : cannot allocate memory\n");
      exit(-1);
    }
    for (i = 0; i < nBasis; i++)
      for (j = 0; j < nBasis; j++) {
        prevPA[i * nBasis + j] = PA[i * nBasis + j];
        prevPB[i * nBasis + j] = PB[i * nBasis + j];
      }
    nIter++;
    return 0.0;
  }
  avgdP = 0.0;
  for (i = 0; i < nBasis; i++)
    for (j = 0; j < nBasis; j++) {
      avgdP += (PA[i * nBasis + j] - prevPA[i * nBasis + j]) *
               (PA[i * nBasis + j] - prevPA[i * nBasis + j]);
      avgdP += (PB[i * nBasis + j] - prevPB[i * nBasis + j]) *
               (PB[i * nBasis + j] - prevPB[i * nBasis + j]);
    }
  avgdP = sqrt(avgdP / nBasis / nBasis / 2.0);
  for (i = 0; i < nBasis; i++)
    for (j = 0; j < nBasis; j++) {
      PA[i * nBasis + j] =
          prevPA[i * nBasis + j] +
          alpha * (PA[i * nBasis + j] - prevPA[i * nBasis + j]);
      PB[i * nBasis + j] =
          prevPB[i * nBasis + j] +
          alpha * (PB[i * nBasis + j] - prevPB[i * nBasis + j]);
    }
  for (i = 0; i < nBasis; i++)
    for (j = 0; j < nBasis; j++) {
      prevPA[i * nBasis + j] = PA[i * nBasis + j];
      prevPB[i * nBasis + j] = PB[i * nBasis + j];
    }
  nIter++;
  return avgdP;
}


x86 assembly (clang, -O0):
<conv_damping>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpl   $0x0,-0x8(%rbp)
jne    1205 <conv_damping+0xb5>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1205 <conv_damping+0xb5>
jp     1205 <conv_damping+0xb5>
cmpq   $0x0,-0x18(%rbp)
jne    1205 <conv_damping+0xb5>
cmpq   $0x0,-0x20(%rbp)
jne    1205 <conv_damping+0xb5>
movl   $0x0,0x2eb2(%rip)
cmpq   $0x0,0x2e9a(%rip)
je     11d3 <conv_damping+0x83>
mov    0x2e8d(%rip),%rdi
call   1030 <free@plt>
movq   $0x0,0x2e7d(%rip)
cmpq   $0x0,0x2e7d(%rip)
je     11f8 <conv_damping+0xa8>
mov    0x2e70(%rip),%rdi
call   1030 <free@plt>
movq   $0x0,0x2e60(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    16ed <conv_damping+0x59d>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
ja     1236 <conv_damping+0xe6>
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdd4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    124c <conv_damping+0xfc>
lea    0xdd3(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
cmpl   $0x0,0x2e0d(%rip)
jne    13ae <conv_damping+0x25e>
cmpq   $0x0,0x2def(%rip)
jne    1275 <conv_damping+0x125>
cmpq   $0x0,0x2de9(%rip)
je     128b <conv_damping+0x13b>
lea    0xdbb(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
mov    -0x8(%rbp),%edi
imul   -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0x2dad(%rip)
mov    -0x8(%rbp),%edi
imul   -0x8(%rbp),%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0x2d9d(%rip)
cmpq   $0x0,0x2d8d(%rip)
je     12d7 <conv_damping+0x187>
cmpq   $0x0,0x2d87(%rip)
jne    12ed <conv_damping+0x19d>
lea    0xd8b(%rip),%rdi
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   1070 <exit@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1392 <conv_damping+0x242>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    137f <conv_damping+0x22f>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2d20(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2cf9(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1307 <conv_damping+0x1b7>
jmp    1384 <conv_damping+0x234>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12f4 <conv_damping+0x1a4>
mov    0x2cc8(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2cbf(%rip)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    16ed <conv_damping+0x59d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14dd <conv_damping+0x38d>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14ca <conv_damping+0x37a>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2c57(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x2c28(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2bef(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x2bc0(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13d0 <conv_damping+0x280>
jmp    14cf <conv_damping+0x37f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13bd <conv_damping+0x26d>
movss  -0x2c(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb08(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1060 <sqrt@plt>
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    162f <conv_damping+0x4df>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    161c <conv_damping+0x4cc>
mov    0x2b11(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0xc(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x2add(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x2aae(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0xc(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x2a7a(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    152c <conv_damping+0x3dc>
jmp    1621 <conv_damping+0x4d1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1519 <conv_damping+0x3c9>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16d4 <conv_damping+0x584>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16c1 <conv_damping+0x571>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x29de(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x29b7(%rip),%rax
mov    -0x24(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1649 <conv_damping+0x4f9>
jmp    16c6 <conv_damping+0x576>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1636 <conv_damping+0x4e6>
mov    0x2986(%rip),%eax
add    $0x1,%eax
mov    %eax,0x297d(%rip)
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conv_damping>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r14
movaps %xmm0,%xmm5
mov    %edi,%r12d
test   %edi,%edi
je     12fc <conv_damping+0x19c>
xorps  %xmm0,%xmm0
ucomiss %xmm5,%xmm0
ja     1b3c <conv_damping+0x9dc>
ucomiss 0xe6b(%rip),%xmm5
ja     1b3c <conv_damping+0x9dc>
cmpl   $0x0,0x2ec6(%rip)
mov    %r14,0x20(%rsp)
mov    %rsi,0x10(%rsp)
mov    %r12,0x18(%rsp)
je     1371 <conv_damping+0x211>
xorps  %xmm1,%xmm1
mov    %r12d,%r13d
xorps  %xmm0,%xmm0
test   %r12d,%r12d
jle    12c6 <conv_damping+0x166>
mov    0x2e88(%rip),%r8
mov    0x2e89(%rip),%r9
mov    %r13d,%r15d
and    $0xfffffffe,%r15d
lea    0x4(%r9),%rdx
lea    0x0(,%r13,4),%r10
lea    0x4(%r14),%rbp
lea    0x4(%r8),%rax
lea    0x4(%rsi),%rcx
xorps  %xmm0,%xmm0
xor    %r11d,%r11d
jmp    1219 <conv_damping+0xb9>
xchg   %ax,%ax
add    $0x1,%r11
add    %r10,%rdx
add    %r10,%rbp
add    %r10,%rax
add    %r10,%rcx
cmp    %r13,%r11
je     12c6 <conv_damping+0x166>
xor    %edi,%edi
cmp    $0x1,%r12d
je     1286 <conv_damping+0x126>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rcx,%rdi,4),%xmm2
movss  (%rcx,%rdi,4),%xmm3
subss  -0x4(%rax,%rdi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
movss  -0x4(%rbp,%rdi,4),%xmm4
movss  0x0(%rbp,%rdi,4),%xmm0
subss  -0x4(%rdx,%rdi,4),%xmm4
mulss  %xmm4,%xmm4
addss  %xmm2,%xmm4
subss  (%rax,%rdi,4),%xmm3
mulss  %xmm3,%xmm3
addss  %xmm4,%xmm3
subss  (%rdx,%rdi,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
add    $0x2,%rdi
cmp    %rdi,%r15
jne    1230 <conv_damping+0xd0>
test   $0x1,%r13b
je     1200 <conv_damping+0xa0>
mov    %r11,%rbx
imul   %r13,%rbx
add    %rbx,%rdi
movss  (%rsi,%rdi,4),%xmm2
subss  (%r8,%rdi,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
movss  (%r14,%rdi,4),%xmm0
subss  (%r9,%rdi,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm2,%xmm0
jmp    1200 <conv_damping+0xa0>
xorps  %xmm2,%xmm2
cvtsi2ss %r12d,%xmm2
divss  %xmm2,%xmm0
divss  %xmm2,%xmm0
mulss  0xd26(%rip),%xmm0
ucomiss %xmm1,%xmm0
jb     1526 <conv_damping+0x3c6>
xorps  %xmm3,%xmm3
sqrtss %xmm0,%xmm3
test   %r12d,%r12d
jg     1541 <conv_damping+0x3e1>
jmp    1b20 <conv_damping+0x9c0>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm5
jne    1182 <conv_damping+0x22>
jp     1182 <conv_damping+0x22>
test   %rsi,%rsi
jne    1182 <conv_damping+0x22>
test   %r14,%r14
jne    1182 <conv_damping+0x22>
movl   $0x0,0x2d3e(%rip)
mov    0x2d27(%rip),%rdi
test   %rdi,%rdi
je     1346 <conv_damping+0x1e6>
call   1030 <free@plt>
movq   $0x0,0x2d12(%rip)
mov    0x2d13(%rip),%rdi
xorps  %xmm3,%xmm3
test   %rdi,%rdi
je     1b27 <conv_damping+0x9c7>
call   1030 <free@plt>
xorps  %xmm3,%xmm3
movq   $0x0,0x2cf4(%rip)
jmp    1b27 <conv_damping+0x9c7>
mov    0x2ce0(%rip),%rax
or     0x2ce1(%rip),%rax
jne    1b45 <conv_damping+0x9e5>
mov    %r12d,%ebx
imul   %r12d,%ebx
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r15
mov    %rax,0x2cb6(%rip)
mov    %ebx,%edi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,0x2cab(%rip)
mov    %r15,0x50(%rsp)
test   %r15,%r15
je     1b4e <conv_damping+0x9ee>
mov    %rax,%rbp
test   %rax,%rax
je     1b4e <conv_damping+0x9ee>
test   %r12d,%r12d
jle    1514 <conv_damping+0x3b4>
mov    %r12,%rax
mov    %eax,%ecx
lea    0x0(,%rcx,4),%rbx
xor    %r12d,%r12d
cmp    $0x1,%eax
je     14d2 <conv_damping+0x372>
mov    0x18(%rsp),%rax
add    %eax,%eax
mov    %eax,0x38(%rsp)
mov    %rcx,0x48(%rsp)
and    $0xfffffffe,%ecx
neg    %rcx
mov    %rcx,0x40(%rsp)
xor    %r12d,%r12d
mov    %rbx,0x28(%rsp)
xor    %r13d,%r13d
mov    0x28(%rsp),%r15
nopl   0x0(%rax)
movslq %r13d,%r13
mov    0x10(%rsp),%r14
lea    (%r14,%r13,4),%rsi
mov    0x50(%rsp),%rax
lea    (%rax,%r13,4),%rdi
mov    0x20(%rsp),%rax
lea    (%rax,%r13,4),%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%r13,4),%rbx
add    %rbp,%rbx
mov    %r15,%rdx
call   1060 <memcpy@plt>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    0x20(%rsp),%rbx
mov    %r15,%rdx
call   1060 <memcpy@plt>
mov    0x18(%rsp),%rax
add    %r13d,%eax
cltq
lea    (%r14,%rax,4),%rsi
mov    %rbx,%r14
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
lea    (%rbx,%rax,4),%rcx
mov    %rcx,0x8(%rsp)
lea    0x0(,%rax,4),%rbx
add    %rbp,%rbx
mov    %r15,%rdx
call   1060 <memcpy@plt>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    %r15,%rdx
call   1060 <memcpy@plt>
add    0x38(%rsp),%r13d
add    $0xfffffffffffffffe,%r12
cmp    %r12,0x40(%rsp)
jne    1420 <conv_damping+0x2c0>
neg    %r12d
mov    0x28(%rsp),%rbx
mov    0x48(%rsp),%rcx
test   $0x1,%cl
mov    0x18(%rsp),%rax
je     1514 <conv_damping+0x3b4>
imul   %eax,%r12d
movslq %r12d,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
lea    (%r14,%rax,4),%r14
lea    0x0(%rbp,%rax,4),%rbp
mov    %rbx,%rdx
call   1060 <memcpy@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1060 <memcpy@plt>
movl   $0x1,0x2b4a(%rip)
xorps  %xmm3,%xmm3
jmp    1b27 <conv_damping+0x9c7>
movaps %xmm5,0x50(%rsp)
call   1070 <sqrt@plt>
movaps 0x50(%rsp),%xmm5
movaps %xmm0,%xmm3
test   %r12d,%r12d
jle    1b20 <conv_damping+0x9c0>
mov    0x2b10(%rip),%rax
mov    0x2b11(%rip),%rcx
mov    %r13d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x68(%rsp)
movaps %xmm5,%xmm0
shufps $0x0,%xmm5,%xmm0
lea    0x0(,%r13,4),%rdi
mov    %rdi,%r11
and    $0xfffffffffffffff0,%r11
xor    %ebx,%ebx
mov    %rax,0x48(%rsp)
mov    0x10(%rsp),%r8
mov    %r8,%rdx
mov    %rcx,0x70(%rsp)
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%r9
mov    %rdi,0x30(%rsp)
jmp    15b9 <conv_damping+0x459>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    %rdi,%rsi
add    %rdi,%rcx
add    %rdi,%rdx
add    %rdi,%rax
cmp    %r13,%rbx
je     1754 <conv_damping+0x5f4>
cmp    $0x4,%r9d
jae    1620 <conv_damping+0x4c0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rbp,4),%xmm1
movss  (%rdx,%rbp,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rdx,%rbp,4)
movss  (%rcx,%rbp,4),%xmm1
movss  (%rsi,%rbp,4),%xmm2
subss  %xmm1,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rsi,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    15d0 <conv_damping+0x470>
jmp    15a0 <conv_damping+0x440>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,0x8(%rsp)
imul   %r13,%rbx
lea    (%rbx,%r13,1),%rbp
lea    (%r8,%rbx,4),%rdi
lea    (%r8,%rbp,4),%r8
mov    0x20(%rsp),%r9
lea    (%r9,%rbx,4),%r15
lea    (%r9,%rbp,4),%r10
mov    0x48(%rsp),%r12
lea    (%r12,%rbx,4),%r14
lea    (%r12,%rbp,4),%r12
mov    0x70(%rsp),%r9
lea    (%r9,%rbp,4),%rbp
cmp    %r10,%rdi
setb   0x50(%rsp)
cmp    %r8,%r15
setb   0x28(%rsp)
cmp    %r12,%rdi
setb   0x38(%rsp)
cmp    %r8,%r14
setb   0x40(%rsp)
cmp    %rbp,%rdi
lea    (%r9,%rbx,4),%rbx
setb   %dil
cmp    %r8,%rbx
setb   %r8b
cmp    %r12,%r15
setb   %r12b
cmp    %r10,%r14
setb   %r9b
cmp    %rbp,%r15
setb   %r15b
cmp    %r10,%rbx
setb   %r10b
mov    0x28(%rsp),%bl
test   %bl,0x50(%rsp)
jne    1739 <conv_damping+0x5d9>
mov    0x40(%rsp),%bl
and    %bl,0x38(%rsp)
jne    1739 <conv_damping+0x5d9>
and    %r8b,%dil
jne    1739 <conv_damping+0x5d9>
and    %r9b,%r12b
jne    1739 <conv_damping+0x5d9>
mov    $0x0,%ebp
and    %r10b,%r15b
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%rbx
jne    15d0 <conv_damping+0x470>
xor    %ebp,%ebp
nopl   0x0(%rax)
movups (%rax,%rbp,1),%xmm1
movups (%rdx,%rbp,1),%xmm2
subps  %xmm1,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rbp,1)
movups (%rcx,%rbp,1),%xmm1
movups (%rsi,%rbp,1),%xmm2
subps  %xmm1,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rbp,1)
add    $0x10,%rbp
cmp    %rbp,%r11
jne    16f0 <conv_damping+0x590>
mov    0x68(%rsp),%r10
mov    %r10,%rbp
cmp    %r13,%r10
jne    15d0 <conv_damping+0x470>
jmp    15a0 <conv_damping+0x440>
xor    %ebp,%ebp
mov    0x10(%rsp),%r8
mov    0x18(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%rbx
jmp    15d0 <conv_damping+0x470>
test   %r9d,%r9d
jle    1b20 <conv_damping+0x9c0>
mov    0x28f4(%rip),%rdi
mov    0x28f5(%rip),%r9
mov    %r13d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x90(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x88(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x80(%rsp)
mov    %r13,%rax
neg    %rax
mov    %rax,0xa0(%rsp)
lea    0x30(%r9),%r12
lea    0x0(,%r13,4),%r11
mov    0x20(%rsp),%rsi
lea    0x30(%rsi),%rdx
lea    0x30(%rdi),%rbp
mov    0x10(%rsp),%rcx
lea    0x30(%rcx),%rax
add    $0x4,%rcx
mov    %rdi,0x28(%rsp)
add    $0x4,%rdi
lea    0x4(%rsi),%r8
mov    %r9,0x38(%rsp)
add    $0x4,%r9
xor    %r10d,%r10d
mov    %r11,0x78(%rsp)
jmp    1825 <conv_damping+0x6c5>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    %r11,%r12
add    %r11,%rdx
add    %r11,%rbp
add    %r11,%rax
add    %r11,%rcx
add    %r11,%rdi
add    %r11,%r8
add    %r11,%r9
cmp    %r13,%r10
je     1b20 <conv_damping+0x9c0>
mov    %r10,%rsi
imul   %r13,%rsi
mov    %rsi,0x50(%rsp)
cmpl   $0x8,0x18(%rsp)
jae    18e0 <conv_damping+0x780>
xor    %r15d,%r15d
mov    %r15,%r14
test   $0x1,%r13b
je     187f <conv_damping+0x71f>
mov    0x50(%rsp),%rbx
add    %r15,%rbx
mov    0x10(%rsp),%rsi
movss  (%rsi,%rbx,4),%xmm0
mov    0x28(%rsp),%rsi
movss  %xmm0,(%rsi,%rbx,4)
mov    0x20(%rsp),%rsi
movss  (%rsi,%rbx,4),%xmm0
mov    0x38(%rsp),%rsi
movss  %xmm0,(%rsi,%rbx,4)
mov    %r15,%r14
or     $0x1,%r14
not    %r15
cmp    0xa0(%rsp),%r15
je     1800 <conv_damping+0x6a0>
movss  -0x4(%rcx,%r14,4),%xmm0
movss  %xmm0,-0x4(%rdi,%r14,4)
movss  -0x4(%r8,%r14,4),%xmm0
movss  %xmm0,-0x4(%r9,%r14,4)
movss  (%rcx,%r14,4),%xmm0
movss  %xmm0,(%rdi,%r14,4)
movss  (%r8,%r14,4),%xmm0
movss  %xmm0,(%r9,%r14,4)
add    $0x2,%r14
cmp    %r14,%r13
jne    1890 <conv_damping+0x730>
jmp    1800 <conv_damping+0x6a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r10,0x40(%rsp)
mov    %r10,%rsi
imul   %r13,%rsi
lea    (%rsi,%r13,1),%r11
mov    0x28(%rsp),%r10
lea    (%r10,%rsi,4),%r15
lea    (%r10,%r11,4),%rbx
mov    %rbx,0x60(%rsp)
mov    0x38(%rsp),%r10
lea    (%r10,%rsi,4),%rbx
mov    %rbx,0xa8(%rsp)
lea    (%r10,%r11,4),%r14
mov    %r14,0x30(%rsp)
mov    0x10(%rsp),%r10
lea    (%r10,%rsi,4),%rbx
mov    %rbx,0x68(%rsp)
lea    (%r10,%r11,4),%rbx
mov    %rbx,0x8(%rsp)
mov    0x20(%rsp),%rbx
lea    (%rbx,%r11,4),%rbx
mov    %rbx,0xb0(%rsp)
cmp    %r14,%r15
setb   0x48(%rsp)
mov    0xa8(%rsp),%r11
mov    0x60(%rsp),%r14
cmp    %r14,%r11
setb   0x70(%rsp)
cmp    0x8(%rsp),%r15
setb   0x7(%rsp)
mov    0x68(%rsp),%r10
cmp    %r14,%r10
setb   0x6(%rsp)
cmp    %rbx,%r15
mov    0x20(%rsp),%rbx
lea    (%rbx,%rsi,4),%r15
setb   0x5(%rsp)
cmp    %r14,%r15
setb   0x60(%rsp)
cmp    0x8(%rsp),%r11
setb   %r14b
mov    0x30(%rsp),%rsi
cmp    %rsi,%r10
setb   0x8(%rsp)
cmp    0xb0(%rsp),%r11
setb   %r10b
cmp    %rsi,%r15
setb   %r15b
mov    0x70(%rsp),%bl
test   %bl,0x48(%rsp)
jne    1b0e <conv_damping+0x9ae>
mov    %r10d,%esi
mov    0x6(%rsp),%bl
and    %bl,0x7(%rsp)
mov    0x78(%rsp),%r11
mov    0x40(%rsp),%r10
jne    183c <conv_damping+0x6dc>
mov    0x60(%rsp),%bl
and    %bl,0x5(%rsp)
jne    183c <conv_damping+0x6dc>
and    0x8(%rsp),%r14b
jne    183c <conv_damping+0x6dc>
mov    %r15d,%ebx
mov    $0x0,%r15d
and    %bl,%sil
jne    183f <conv_damping+0x6df>
cmpq   $0x0,0x90(%rsp)
je     1aff <conv_damping+0x99f>
mov    0x80(%rsp),%rsi
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%r14,4),%xmm0
movups -0x20(%rax,%r14,4),%xmm1
movups %xmm0,-0x30(%rbp,%r14,4)
movups %xmm1,-0x20(%rbp,%r14,4)
movups -0x30(%rdx,%r14,4),%xmm0
movups -0x20(%rdx,%r14,4),%xmm1
movups %xmm0,-0x30(%r12,%r14,4)
movups %xmm1,-0x20(%r12,%r14,4)
movups -0x10(%rax,%r14,4),%xmm0
movups (%rax,%r14,4),%xmm1
movups %xmm0,-0x10(%rbp,%r14,4)
movups %xmm1,0x0(%rbp,%r14,4)
movups -0x10(%rdx,%r14,4),%xmm0
movups (%rdx,%r14,4),%xmm1
movups %xmm0,-0x10(%r12,%r14,4)
movups %xmm1,(%r12,%r14,4)
add    $0x10,%r14
add    $0xfffffffffffffffe,%rsi
jne    1a30 <conv_damping+0x8d0>
testb  $0x1,0x88(%rsp)
01
je     1ae6 <conv_damping+0x986>
add    0x50(%rsp),%r14
mov    0x10(%rsp),%rsi
movups (%rsi,%r14,4),%xmm0
movups 0x10(%rsi,%r14,4),%xmm1
mov    0x28(%rsp),%rsi
movups %xmm0,(%rsi,%r14,4)
movups %xmm1,0x10(%rsi,%r14,4)
mov    0x20(%rsp),%rsi
movups (%rsi,%r14,4),%xmm0
movups 0x10(%rsi,%r14,4),%xmm1
mov    0x38(%rsp),%rsi
movups %xmm0,(%rsi,%r14,4)
movups %xmm1,0x10(%rsi,%r14,4)
mov    0x98(%rsp),%rsi
mov    %rsi,%r15
cmp    %r13,%rsi
je     1800 <conv_damping+0x6a0>
jmp    183f <conv_damping+0x6df>
xor    %r14d,%r14d
testb  $0x1,0x88(%rsp)
01
jne    1aa1 <conv_damping+0x941>
jmp    1ae6 <conv_damping+0x986>
xor    %r15d,%r15d
mov    0x78(%rsp),%r11
mov    0x40(%rsp),%r10
jmp    183f <conv_damping+0x6df>
addl   $0x1,0x2541(%rip)
movaps %xmm3,%xmm0
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x51c(%rip),%rdi
jmp    1b55 <conv_damping+0x9f5>
lea    0x4e2(%rip),%rdi
jmp    1b55 <conv_damping+0x9f5>
lea    0x4b3(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@conv_damping.prevPA = internal global float* null
@conv_damping.prevPB = internal global float* null
@conv_damping.nIter = internal global i32 0
@.str = [39 x i8] c"conv_damping : invalid range of alpha\0A\00"
@.str.1 = [50 x i8] c"conv_damping : detect prior initialized pointers\0A\00"
@.str.2 = [39 x i8] c"conv_damping : cannot allocate memory\0A\00"
define float @conv_damping(i32 %0, float %1, float* %2, float* %3) {
%5 = alloca float
%6 = alloca i32
%7 = alloca float
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca float
store i32 %0, i32* %6
store float %1, float* %7
store float* %2, float** %8
store float* %3, float** %9
%13 = load i32, i32* %6
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %38
15: ; preds = %4
%16 = load float, float* %7
%17 = fpext float %16 to double
%18 = fcmp oeq double %17, 0.000000e+00
br i1 %18, label %19, label %38
19: ; preds = %15
%20 = load float*, float** %8
%21 = icmp eq float* %20, null
br i1 %21, label %22, label %38
22: ; preds = %19
%23 = load float*, float** %9
%24 = icmp eq float* %23, null
br i1 %24, label %25, label %38
25: ; preds = %22
store i32 0, i32* @conv_damping.nIter
%26 = load float*, float** @conv_damping.prevPA
%27 = icmp ne float* %26, null
br i1 %27, label %28, label %31
28: ; preds = %25
%29 = load float*, float** @conv_damping.prevPA
%30 = call i32 @free(float* %29)
store float* null, float** @conv_damping.prevPA
br label %31
31: ; preds = %28, %25
%32 = load float*, float** @conv_damping.prevPB
%33 = icmp ne float* %32, null
br i1 %33, label %34, label %37
34: ; preds = %31
%35 = load float*, float** @conv_damping.prevPB
%36 = call i32 @free(float* %35)
store float* null, float** @conv_damping.prevPB
br label %37
37: ; preds = %34, %31
store float 0.000000e+00, float* %5
br label %392
38: ; preds = %22, %19, %15, %4
%39 = load float, float* %7
%40 = fpext float %39 to double
%41 = fcmp olt double %40, 0.000000e+00
br i1 %41, label %46, label %42
42: ; preds = %38
%43 = load float, float* %7
%44 = fpext float %43 to double
%45 = fcmp ogt double %44, 1.000000e+00
br i1 %45, label %46, label %49
46: ; preds = %42, %38
%47 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
%48 = call i32 @exit(i32 -1)
unreachable
49: ; preds = %42
%50 = load i32, i32* @conv_damping.nIter
%51 = icmp eq i32 %50, 0
br i1 %51, label %52, label %133
52: ; preds = %49
%53 = load float*, float** @conv_damping.prevPA
%54 = icmp ne float* %53, null
br i1 %54, label %58, label %55
55: ; preds = %52
%56 = load float*, float** @conv_damping.prevPB
%57 = icmp ne float* %56, null
br i1 %57, label %58, label %61
58: ; preds = %55, %52
%59 = call i32 @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.1, i64 0, i64 0))
%60 = call i32 @exit(i32 -1)
unreachable
61: ; preds = %55
%62 = load i32, i32* %6
%63 = load i32, i32* %6
%64 = mul nsw i32 %62, %63
%65 = call float* @calloc(i32 %64, i32 4)
store float* %65, float** @conv_damping.prevPA
%66 = load i32, i32* %6
%67 = load i32, i32* %6
%68 = mul nsw i32 %66, %67
%69 = call float* @calloc(i32 %68, i32 4)
store float* %69, float** @conv_damping.prevPB
%70 = load float*, float** @conv_damping.prevPA
%71 = icmp eq float* %70, null
br i1 %71, label %75, label %72
72: ; preds = %61
%73 = load float*, float** @conv_damping.prevPB
%74 = icmp eq float* %73, null
br i1 %74, label %75, label %78
75: ; preds = %72, %61
%76 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0))
%77 = call i32 @exit(i32 -1)
unreachable
78: ; preds = %72
store i32 0, i32* %10
br label %79
79: ; preds = %127, %78
%80 = load i32, i32* %10
%81 = load i32, i32* %6
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %130
83: ; preds = %79
store i32 0, i32* %11
br label %84
84: ; preds = %123, %83
%85 = load i32, i32* %11
%86 = load i32, i32* %6
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %126
88: ; preds = %84
%89 = load float*, float** %8
%90 = load i32, i32* %10
%91 = load i32, i32* %6
%92 = mul nsw i32 %90, %91
%93 = load i32, i32* %11
%94 = add nsw i32 %92, %93
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %89, i64 %95
%97 = load float, float* %96
%98 = load float*, float** @conv_damping.prevPA
%99 = load i32, i32* %10
%100 = load i32, i32* %6
%101 = mul nsw i32 %99, %100
%102 = load i32, i32* %11
%103 = add nsw i32 %101, %102
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %98, i64 %104
store float %97, float* %105
%106 = load float*, float** %9
%107 = load i32, i32* %10
%108 = load i32, i32* %6
%109 = mul nsw i32 %107, %108
%110 = load i32, i32* %11
%111 = add nsw i32 %109, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %106, i64 %112
%114 = load float, float* %113
%115 = load float*, float** @conv_damping.prevPB
%116 = load i32, i32* %10
%117 = load i32, i32* %6
%118 = mul nsw i32 %116, %117
%119 = load i32, i32* %11
%120 = add nsw i32 %118, %119
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds float, float* %115, i64 %121
store float %114, float* %122
br label %123
123: ; preds = %88
%124 = load i32, i32* %11
%125 = add nsw i32 %124, 1
store i32 %125, i32* %11
br label %84
126: ; preds = %84
br label %127
127: ; preds = %126
%128 = load i32, i32* %10
%129 = add nsw i32 %128, 1
store i32 %129, i32* %10
br label %79
130: ; preds = %79
%131 = load i32, i32* @conv_damping.nIter
%132 = add nsw i32 %131, 1
store i32 %132, i32* @conv_damping.nIter
store float 0.000000e+00, float* %5
br label %392
133: ; preds = %49
store float 0.000000e+00, float* %12
store i32 0, i32* %10
br label %134
134: ; preds = %228, %133
%135 = load i32, i32* %10
%136 = load i32, i32* %6
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %231
138: ; preds = %134
store i32 0, i32* %11
br label %139
139: ; preds = %224, %138
%140 = load i32, i32* %11
%141 = load i32, i32* %6
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %227
143: ; preds = %139
%144 = load float*, float** %8
%145 = load i32, i32* %10
%146 = load i32, i32* %6
%147 = mul nsw i32 %145, %146
%148 = load i32, i32* %11
%149 = add nsw i32 %147, %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %144, i64 %150
%152 = load float, float* %151
%153 = load float*, float** @conv_damping.prevPA
%154 = load i32, i32* %10
%155 = load i32, i32* %6
%156 = mul nsw i32 %154, %155
%157 = load i32, i32* %11
%158 = add nsw i32 %156, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %153, i64 %159
%161 = load float, float* %160
%162 = fsub float %152, %161
%163 = load float*, float** %8
%164 = load i32, i32* %10
%165 = load i32, i32* %6
%166 = mul nsw i32 %164, %165
%167 = load i32, i32* %11
%168 = add nsw i32 %166, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %163, i64 %169
%171 = load float, float* %170
%172 = load float*, float** @conv_damping.prevPA
%173 = load i32, i32* %10
%174 = load i32, i32* %6
%175 = mul nsw i32 %173, %174
%176 = load i32, i32* %11
%177 = add nsw i32 %175, %176
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %172, i64 %178
%180 = load float, float* %179
%181 = fsub float %171, %180
%182 = load float, float* %12
%183 = call float @llvm.fmuladd.f32(float %162, float %181, float %182)
store float %183, float* %12
%184 = load float*, float** %9
%185 = load i32, i32* %10
%186 = load i32, i32* %6
%187 = mul nsw i32 %185, %186
%188 = load i32, i32* %11
%189 = add nsw i32 %187, %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %184, i64 %190
%192 = load float, float* %191
%193 = load float*, float** @conv_damping.prevPB
%194 = load i32, i32* %10
%195 = load i32, i32* %6
%196 = mul nsw i32 %194, %195
%197 = load i32, i32* %11
%198 = add nsw i32 %196, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float, float* %193, i64 %199
%201 = load float, float* %200
%202 = fsub float %192, %201
%203 = load float*, float** %9
%204 = load i32, i32* %10
%205 = load i32, i32* %6
%206 = mul nsw i32 %204, %205
%207 = load i32, i32* %11
%208 = add nsw i32 %206, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %203, i64 %209
%211 = load float, float* %210
%212 = load float*, float** @conv_damping.prevPB
%213 = load i32, i32* %10
%214 = load i32, i32* %6
%215 = mul nsw i32 %213, %214
%216 = load i32, i32* %11
%217 = add nsw i32 %215, %216
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %212, i64 %218
%220 = load float, float* %219
%221 = fsub float %211, %220
%222 = load float, float* %12
%223 = call float @llvm.fmuladd.f32(float %202, float %221, float %222)
store float %223, float* %12
br label %224
224: ; preds = %143
%225 = load i32, i32* %11
%226 = add nsw i32 %225, 1
store i32 %226, i32* %11
br label %139
227: ; preds = %139
br label %228
228: ; preds = %227
%229 = load i32, i32* %10
%230 = add nsw i32 %229, 1
store i32 %230, i32* %10
br label %134
231: ; preds = %134
%232 = load float, float* %12
%233 = load i32, i32* %6
%234 = sitofp i32 %233 to float
%235 = fdiv float %232, %234
%236 = load i32, i32* %6
%237 = sitofp i32 %236 to float
%238 = fdiv float %235, %237
%239 = fpext float %238 to double
%240 = fdiv double %239, 2.000000e+00
%241 = fptrunc double %240 to float
%242 = call float @sqrt(float %241)
store float %242, float* %12
store i32 0, i32* %10
br label %243
243: ; preds = %333, %231
%244 = load i32, i32* %10
%245 = load i32, i32* %6
%246 = icmp slt i32 %244, %245
br i1 %246, label %247, label %336
247: ; preds = %243
store i32 0, i32* %11
br label %248
248: ; preds = %329, %247
%249 = load i32, i32* %11
%250 = load i32, i32* %6
%251 = icmp slt i32 %249, %250
br i1 %251, label %252, label %332
252: ; preds = %248
%253 = load float*, float** @conv_damping.prevPA
%254 = load i32, i32* %10
%255 = load i32, i32* %6
%256 = mul nsw i32 %254, %255
%257 = load i32, i32* %11
%258 = add nsw i32 %256, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds float, float* %253, i64 %259
%261 = load float, float* %260
%262 = load float, float* %7
%263 = load float*, float** %8
%264 = load i32, i32* %10
%265 = load i32, i32* %6
%266 = mul nsw i32 %264, %265
%267 = load i32, i32* %11
%268 = add nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds float, float* %263, i64 %269
%271 = load float, float* %270
%272 = load float*, float** @conv_damping.prevPA
%273 = load i32, i32* %10
%274 = load i32, i32* %6
%275 = mul nsw i32 %273, %274
%276 = load i32, i32* %11
%277 = add nsw i32 %275, %276
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds float, float* %272, i64 %278
%280 = load float, float* %279
%281 = fsub float %271, %280
%282 = call float @llvm.fmuladd.f32(float %262, float %281, float %261)
%283 = load float*, float** %8
%284 = load i32, i32* %10
%285 = load i32, i32* %6
%286 = mul nsw i32 %284, %285
%287 = load i32, i32* %11
%288 = add nsw i32 %286, %287
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds float, float* %283, i64 %289
store float %282, float* %290
%291 = load float*, float** @conv_damping.prevPB
%292 = load i32, i32* %10
%293 = load i32, i32* %6
%294 = mul nsw i32 %292, %293
%295 = load i32, i32* %11
%296 = add nsw i32 %294, %295
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds float, float* %291, i64 %297
%299 = load float, float* %298
%300 = load float, float* %7
%301 = load float*, float** %9
%302 = load i32, i32* %10
%303 = load i32, i32* %6
%304 = mul nsw i32 %302, %303
%305 = load i32, i32* %11
%306 = add nsw i32 %304, %305
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %301, i64 %307
%309 = load float, float* %308
%310 = load float*, float** @conv_damping.prevPB
%311 = load i32, i32* %10
%312 = load i32, i32* %6
%313 = mul nsw i32 %311, %312
%314 = load i32, i32* %11
%315 = add nsw i32 %313, %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %310, i64 %316
%318 = load float, float* %317
%319 = fsub float %309, %318
%320 = call float @llvm.fmuladd.f32(float %300, float %319, float %299)
%321 = load float*, float** %9
%322 = load i32, i32* %10
%323 = load i32, i32* %6
%324 = mul nsw i32 %322, %323
%325 = load i32, i32* %11
%326 = add nsw i32 %324, %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %321, i64 %327
store float %320, float* %328
br label %329
329: ; preds = %252
%330 = load i32, i32* %11
%331 = add nsw i32 %330, 1
store i32 %331, i32* %11
br label %248
332: ; preds = %248
br label %333
333: ; preds = %332
%334 = load i32, i32* %10
%335 = add nsw i32 %334, 1
store i32 %335, i32* %10
br label %243
336: ; preds = %243
store i32 0, i32* %10
br label %337
337: ; preds = %385, %336
%338 = load i32, i32* %10
%339 = load i32, i32* %6
%340 = icmp slt i32 %338, %339
br i1 %340, label %341, label %388
341: ; preds = %337
store i32 0, i32* %11
br label %342
342: ; preds = %381, %341
%343 = load i32, i32* %11
%344 = load i32, i32* %6
%345 = icmp slt i32 %343, %344
br i1 %345, label %346, label %384
346: ; preds = %342
%347 = load float*, float** %8
%348 = load i32, i32* %10
%349 = load i32, i32* %6
%350 = mul nsw i32 %348, %349
%351 = load i32, i32* %11
%352 = add nsw i32 %350, %351
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %347, i64 %353
%355 = load float, float* %354
%356 = load float*, float** @conv_damping.prevPA
%357 = load i32, i32* %10
%358 = load i32, i32* %6
%359 = mul nsw i32 %357, %358
%360 = load i32, i32* %11
%361 = add nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %356, i64 %362
store float %355, float* %363
%364 = load float*, float** %9
%365 = load i32, i32* %10
%366 = load i32, i32* %6
%367 = mul nsw i32 %365, %366
%368 = load i32, i32* %11
%369 = add nsw i32 %367, %368
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds float, float* %364, i64 %370
%372 = load float, float* %371
%373 = load float*, float** @conv_damping.prevPB
%374 = load i32, i32* %10
%375 = load i32, i32* %6
%376 = mul nsw i32 %374, %375
%377 = load i32, i32* %11
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %373, i64 %379
store float %372, float* %380
br label %381
381: ; preds = %346
%382 = load i32, i32* %11
%383 = add nsw i32 %382, 1
store i32 %383, i32* %11
br label %342
384: ; preds = %342
br label %385
385: ; preds = %384
%386 = load i32, i32* %10
%387 = add nsw i32 %386, 1
store i32 %387, i32* %10
br label %337
388: ; preds = %337
%389 = load i32, i32* @conv_damping.nIter
%390 = add nsw i32 %389, 1
store i32 %390, i32* @conv_damping.nIter
%391 = load float, float* %12
store float %391, float* %5
br label %392
392: ; preds = %388, %130, %37
%393 = load float, float* %5
ret float %393
}

LLVM IR (-O2):
@conv_damping.prevPA = internal unnamed_addr global float* null
@conv_damping.prevPB = internal unnamed_addr global float* null
@conv_damping.nIter = internal unnamed_addr global i32 0
@str = [38 x i8] c"conv_damping : cannot allocate memory\00"
@str.3 = [49 x i8] c"conv_damping : detect prior initialized pointers\00"
@str.4 = [38 x i8] c"conv_damping : invalid range of alpha\00"
define float @conv_damping(i32 %0, float %1, float* %2, float* %3) {
%5 = icmp eq i32 %0, 0
br i1 %5, label %6, label %22
6: ; preds = %4
%7 = fcmp oeq float %1, 0.000000e+00
%8 = icmp eq float* %2, null
%9 = and i1 %7, %8
%10 = icmp eq float* %3, null
%11 = and i1 %9, %10
br i1 %11, label %12, label %22
12: ; preds = %6
store i32 0, i32* @conv_damping.nIter
%13 = load float*, float** @conv_damping.prevPA
%14 = icmp eq float* %13, null
br i1 %14, label %17, label %15
15: ; preds = %12
%16 = tail call i32 @free(float* %13)
store float* null, float** @conv_damping.prevPA
br label %17
17: ; preds = %15, %12
%18 = load float*, float** @conv_damping.prevPB
%19 = icmp eq float* %18, null
br i1 %19, label %441, label %20
20: ; preds = %17
%21 = tail call i32 @free(float* %18)
store float* null, float** @conv_damping.prevPB
br label %441
22: ; preds = %6, %4
%23 = fcmp olt float %1, 0.000000e+00
%24 = fcmp ogt float %1, 1.000000e+00
%25 = or i1 %23, %24
br i1 %25, label %26, label %29
26: ; preds = %22
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.4, i64 0, i64 0))
%28 = tail call i32 @exit(i32 -1)
unreachable
29: ; preds = %22
%30 = load i32, i32* @conv_damping.nIter
%31 = icmp eq i32 %30, 0
br i1 %31, label %43, label %32
32: ; preds = %29
%33 = icmp sgt i32 %0, 0
br i1 %33, label %34, label %177
34: ; preds = %32
%35 = load float*, float** @conv_damping.prevPA
%36 = load float*, float** @conv_damping.prevPB
%37 = zext i32 %0 to i64
%38 = zext i32 %0 to i64
%39 = and i64 %37, 1
%40 = icmp eq i32 %0, 1
%41 = and i64 %37, 4294967294
%42 = icmp eq i64 %39, 0
br label %117
43: ; preds = %29
%44 = load float*, float** @conv_damping.prevPA
%45 = icmp ne float* %44, null
%46 = load float*, float** @conv_damping.prevPB
%47 = icmp ne float* %46, null
%48 = select i1 %45, i1 true, i1 %47
br i1 %48, label %49, label %52
49: ; preds = %43
%50 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str.3, i64 0, i64 0))
%51 = tail call i32 @exit(i32 -1)
unreachable
52: ; preds = %43
%53 = mul nsw i32 %0, %0
%54 = tail call float* @calloc(i32 %53, i32 4)
store float* %54, float** @conv_damping.prevPA
%55 = tail call float* @calloc(i32 %53, i32 4)
store float* %55, float** @conv_damping.prevPB
%56 = icmp eq float* %54, null
%57 = icmp eq float* %55, null
%58 = or i1 %56, %57
br i1 %58, label %68, label %59
59: ; preds = %52
%60 = icmp sgt i32 %0, 0
br i1 %60, label %61, label %116
61: ; preds = %59
%62 = zext i32 %0 to i64
%63 = shl nuw nsw i64 %62, 2
%64 = and i64 %62, 1
%65 = icmp eq i32 %0, 1
br i1 %65, label %102, label %66
66: ; preds = %61
%67 = and i64 %62, 4294967294
br label %71
68: ; preds = %52
%69 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str, i64 0, i64 0))
%70 = tail call i32 @exit(i32 -1)
unreachable
71: ; preds = %71, %66
%72 = phi i64 [ 0, %66 ], [ %97, %71 ]
%73 = phi i64 [ 0, %66 ], [ %98, %71 ]
%74 = trunc i64 %72 to i32
%75 = mul i32 %74, %0
%76 = sext i32 %75 to i64
%77 = getelementptr float, float* %2, i64 %76
%78 = bitcast float* %77 to i8*
%79 = getelementptr float, float* %54, i64 %76
%80 = bitcast float* %79 to i8*
%81 = getelementptr float, float* %3, i64 %76
%82 = bitcast float* %81 to i8*
%83 = getelementptr float, float* %55, i64 %76
%84 = bitcast float* %83 to i8*
%85 = trunc i64 %72 to i32
%86 = or i32 %85, 1
%87 = mul i32 %86, %0
%88 = sext i32 %87 to i64
%89 = getelementptr float, float* %2, i64 %88
%90 = bitcast float* %89 to i8*
%91 = getelementptr float, float* %54, i64 %88
%92 = bitcast float* %91 to i8*
%93 = getelementptr float, float* %3, i64 %88
%94 = bitcast float* %93 to i8*
%95 = getelementptr float, float* %55, i64 %88
%96 = bitcast float* %95 to i8*
%97 = add nuw nsw i64 %72, 2
%98 = add i64 %73, 2
%99 = icmp eq i64 %98, %67
br i1 %99, label %100, label %71
100: ; preds = %71
%101 = trunc i64 %97 to i32
br label %102
102: ; preds = %100, %61
%103 = phi i32 [ 0, %61 ], [ %101, %100 ]
%104 = icmp eq i64 %64, 0
br i1 %104, label %116, label %105
105: ; preds = %102
%106 = mul i32 %103, %0
%107 = sext i32 %106 to i64
%108 = getelementptr float, float* %2, i64 %107
%109 = bitcast float* %108 to i8*
%110 = getelementptr float, float* %54, i64 %107
%111 = bitcast float* %110 to i8*
%112 = getelementptr float, float* %3, i64 %107
%113 = bitcast float* %112 to i8*
%114 = getelementptr float, float* %55, i64 %107
%115 = bitcast float* %114 to i8*
br label %116
116: ; preds = %105, %102, %59
store i32 1, i32* @conv_damping.nIter
br label %441
117: ; preds = %173, %34
%118 = phi i64 [ 0, %34 ], [ %175, %173 ]
%119 = phi float [ 0.000000e+00, %34 ], [ %174, %173 ]
%120 = mul nsw i64 %118, %37
br i1 %40, label %155, label %121
121: ; preds = %117, %121
%122 = phi i64 [ %152, %121 ], [ 0, %117 ]
%123 = phi float [ %151, %121 ], [ %119, %117 ]
%124 = phi i64 [ %153, %121 ], [ 0, %117 ]
%125 = add nuw nsw i64 %122, %120
%126 = getelementptr inbounds float, float* %2, i64 %125
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %35, i64 %125
%129 = load float, float* %128
%130 = fsub float %127, %129
%131 = tail call float @llvm.fmuladd.f32(float %130, float %130, float %123)
%132 = getelementptr inbounds float, float* %3, i64 %125
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %36, i64 %125
%135 = load float, float* %134
%136 = fsub float %133, %135
%137 = tail call float @llvm.fmuladd.f32(float %136, float %136, float %131)
%138 = or i64 %122, 1
%139 = add nuw nsw i64 %138, %120
%140 = getelementptr inbounds float, float* %2, i64 %139
%141 = load float, float* %140
%142 = getelementptr inbounds float, float* %35, i64 %139
%143 = load float, float* %142
%144 = fsub float %141, %143
%145 = tail call float @llvm.fmuladd.f32(float %144, float %144, float %137)
%146 = getelementptr inbounds float, float* %3, i64 %139
%147 = load float, float* %146
%148 = getelementptr inbounds float, float* %36, i64 %139
%149 = load float, float* %148
%150 = fsub float %147, %149
%151 = tail call float @llvm.fmuladd.f32(float %150, float %150, float %145)
%152 = add nuw nsw i64 %122, 2
%153 = add i64 %124, 2
%154 = icmp eq i64 %153, %41
br i1 %154, label %155, label %121
155: ; preds = %121, %117
%156 = phi float [ undef, %117 ], [ %151, %121 ]
%157 = phi i64 [ 0, %117 ], [ %152, %121 ]
%158 = phi float [ %119, %117 ], [ %151, %121 ]
br i1 %42, label %173, label %159
159: ; preds = %155
%160 = add nuw nsw i64 %157, %120
%161 = getelementptr inbounds float, float* %2, i64 %160
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %35, i64 %160
%164 = load float, float* %163
%165 = fsub float %162, %164
%166 = tail call float @llvm.fmuladd.f32(float %165, float %165, float %158)
%167 = getelementptr inbounds float, float* %3, i64 %160
%168 = load float, float* %167
%169 = getelementptr inbounds float, float* %36, i64 %160
%170 = load float, float* %169
%171 = fsub float %168, %170
%172 = tail call float @llvm.fmuladd.f32(float %171, float %171, float %166)
br label %173
173: ; preds = %155, %159
%174 = phi float [ %156, %155 ], [ %172, %159 ]
%175 = add nuw nsw i64 %118, 1
%176 = icmp eq i64 %175, %38
br i1 %176, label %177, label %117
177: ; preds = %173, %32
%178 = phi float [ 0.000000e+00, %32 ], [ %174, %173 ]
%179 = sitofp i32 %0 to float
%180 = fdiv float %178, %179
%181 = fdiv float %180, %179
%182 = fmul float %181, 5.000000e-01
%183 = tail call float @sqrt(float %182)
br i1 %33, label %184, label %438
184: ; preds = %177
%185 = load float*, float** @conv_damping.prevPA
%186 = load float*, float** @conv_damping.prevPB
%187 = zext i32 %0 to i64
%188 = zext i32 %0 to i64
%189 = icmp ult i32 %0, 4
%190 = and i64 %188, 4294967292
%191 = insertelement <4 x float> poison, float %1, i64 0
%192 = shufflevector <4 x float> %191, <4 x float> poison, <4 x i32> zeroinitializer
%193 = icmp eq i64 %190, %188
br label %194
194: ; preds = %290, %184
%195 = phi i64 [ 0, %184 ], [ %291, %290 ]
%196 = mul i64 %195, %188
%197 = getelementptr float, float* %2, i64 %196
%198 = add i64 %196, %188
%199 = getelementptr float, float* %2, i64 %198
%200 = getelementptr float, float* %3, i64 %196
%201 = getelementptr float, float* %3, i64 %198
%202 = getelementptr float, float* %185, i64 %196
%203 = getelementptr float, float* %185, i64 %198
%204 = getelementptr float, float* %186, i64 %196
%205 = getelementptr float, float* %186, i64 %198
%206 = mul nsw i64 %195, %187
br i1 %189, label %251, label %207
207: ; preds = %194
%208 = icmp ult float* %197, %201
%209 = icmp ult float* %200, %199
%210 = and i1 %208, %209
%211 = icmp ult float* %197, %203
%212 = icmp ult float* %202, %199
%213 = and i1 %211, %212
%214 = or i1 %210, %213
%215 = icmp ult float* %197, %205
%216 = icmp ult float* %204, %199
%217 = and i1 %215, %216
%218 = or i1 %214, %217
%219 = icmp ult float* %200, %203
%220 = icmp ult float* %202, %201
%221 = and i1 %219, %220
%222 = or i1 %218, %221
%223 = icmp ult float* %200, %205
%224 = icmp ult float* %204, %201
%225 = and i1 %223, %224
%226 = or i1 %222, %225
br i1 %226, label %251, label %227
227: ; preds = %207, %227
%228 = phi i64 [ %248, %227 ], [ 0, %207 ]
%229 = add nuw nsw i64 %228, %206
%230 = getelementptr inbounds float, float* %185, i64 %229
%231 = bitcast float* %230 to <4 x float>*
%232 = load <4 x float>, <4 x float>* %231
%233 = getelementptr inbounds float, float* %2, i64 %229
%234 = bitcast float* %233 to <4 x float>*
%235 = load <4 x float>, <4 x float>* %234
%236 = fsub <4 x float> %235, %232
%237 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %192, <4 x float> %236, <4 x float> %232)
%238 = bitcast float* %233 to <4 x float>*
store <4 x float> %237, <4 x float>* %238
%239 = getelementptr inbounds float, float* %186, i64 %229
%240 = bitcast float* %239 to <4 x float>*
%241 = load <4 x float>, <4 x float>* %240
%242 = getelementptr inbounds float, float* %3, i64 %229
%243 = bitcast float* %242 to <4 x float>*
%244 = load <4 x float>, <4 x float>* %243
%245 = fsub <4 x float> %244, %241
%246 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %192, <4 x float> %245, <4 x float> %241)
%247 = bitcast float* %242 to <4 x float>*
store <4 x float> %246, <4 x float>* %247
%248 = add nuw i64 %228, 4
%249 = icmp eq i64 %248, %190
br i1 %249, label %250, label %227
250: ; preds = %227
br i1 %193, label %290, label %251
251: ; preds = %207, %194, %250
%252 = phi i64 [ 0, %207 ], [ 0, %194 ], [ %190, %250 ]
br label %273
253: ; preds = %290
br i1 %33, label %254, label %438
254: ; preds = %253
%255 = load float*, float** @conv_damping.prevPA
%256 = load float*, float** @conv_damping.prevPB
%257 = zext i32 %0 to i64
%258 = zext i32 %0 to i64
%259 = and i64 %188, 4294967288
%260 = add nsw i64 %259, -8
%261 = lshr exact i64 %260, 3
%262 = add nuw nsw i64 %261, 1
%263 = icmp ult i32 %0, 8
%264 = and i64 %188, 4294967288
%265 = and i64 %262, 1
%266 = icmp eq i64 %260, 0
%267 = and i64 %262, 4611686018427387902
%268 = icmp eq i64 %265, 0
%269 = icmp eq i64 %264, %188
%270 = and i64 %188, 1
%271 = icmp eq i64 %270, 0
%272 = sub nsw i64 0, %188
br label %293
273: ; preds = %251, %273
%274 = phi i64 [ %288, %273 ], [ %252, %251 ]
%275 = add nuw nsw i64 %274, %206
%276 = getelementptr inbounds float, float* %185, i64 %275
%277 = load float, float* %276
%278 = getelementptr inbounds float, float* %2, i64 %275
%279 = load float, float* %278
%280 = fsub float %279, %277
%281 = tail call float @llvm.fmuladd.f32(float %1, float %280, float %277)
store float %281, float* %278
%282 = getelementptr inbounds float, float* %186, i64 %275
%283 = load float, float* %282
%284 = getelementptr inbounds float, float* %3, i64 %275
%285 = load float, float* %284
%286 = fsub float %285, %283
%287 = tail call float @llvm.fmuladd.f32(float %1, float %286, float %283)
store float %287, float* %284
%288 = add nuw nsw i64 %274, 1
%289 = icmp eq i64 %288, %188
br i1 %289, label %290, label %273
290: ; preds = %273, %250
%291 = add nuw nsw i64 %195, 1
%292 = icmp eq i64 %291, %188
br i1 %292, label %253, label %194
293: ; preds = %435, %254
%294 = phi i64 [ 0, %254 ], [ %436, %435 ]
%295 = mul i64 %294, %188
%296 = getelementptr float, float* %255, i64 %295
%297 = add i64 %295, %188
%298 = getelementptr float, float* %255, i64 %297
%299 = getelementptr float, float* %256, i64 %295
%300 = getelementptr float, float* %256, i64 %297
%301 = getelementptr float, float* %2, i64 %295
%302 = getelementptr float, float* %2, i64 %297
%303 = getelementptr float, float* %3, i64 %295
%304 = getelementptr float, float* %3, i64 %297
%305 = mul nsw i64 %294, %257
br i1 %263, label %401, label %306
306: ; preds = %293
%307 = icmp ult float* %296, %300
%308 = icmp ult float* %299, %298
%309 = and i1 %307, %308
%310 = icmp ult float* %296, %302
%311 = icmp ult float* %301, %298
%312 = and i1 %310, %311
%313 = or i1 %309, %312
%314 = icmp ult float* %296, %304
%315 = icmp ult float* %303, %298
%316 = and i1 %314, %315
%317 = or i1 %313, %316
%318 = icmp ult float* %299, %302
%319 = icmp ult float* %301, %300
%320 = and i1 %318, %319
%321 = or i1 %317, %320
%322 = icmp ult float* %299, %304
%323 = icmp ult float* %303, %300
%324 = and i1 %322, %323
%325 = or i1 %321, %324
br i1 %325, label %401, label %326
326: ; preds = %306
br i1 %266, label %376, label %327
327: ; preds = %326, %327
%328 = phi i64 [ %373, %327 ], [ 0, %326 ]
%329 = phi i64 [ %374, %327 ], [ 0, %326 ]
%330 = add nuw nsw i64 %328, %305
%331 = getelementptr inbounds float, float* %2, i64 %330
%332 = bitcast float* %331 to <4 x float>*
%333 = load <4 x float>, <4 x float>* %332
%334 = getelementptr inbounds float, float* %331, i64 4
%335 = bitcast float* %334 to <4 x float>*
%336 = load <4 x float>, <4 x float>* %335
%337 = getelementptr inbounds float, float* %255, i64 %330
%338 = bitcast float* %337 to <4 x float>*
store <4 x float> %333, <4 x float>* %338
%339 = getelementptr inbounds float, float* %337, i64 4
%340 = bitcast float* %339 to <4 x float>*
store <4 x float> %336, <4 x float>* %340
%341 = getelementptr inbounds float, float* %3, i64 %330
%342 = bitcast float* %341 to <4 x float>*
%343 = load <4 x float>, <4 x float>* %342
%344 = getelementptr inbounds float, float* %341, i64 4
%345 = bitcast float* %344 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = getelementptr inbounds float, float* %256, i64 %330
%348 = bitcast float* %347 to <4 x float>*
store <4 x float> %343, <4 x float>* %348
%349 = getelementptr inbounds float, float* %347, i64 4
%350 = bitcast float* %349 to <4 x float>*
store <4 x float> %346, <4 x float>* %350
%351 = or i64 %328, 8
%352 = add nuw nsw i64 %351, %305
%353 = getelementptr inbounds float, float* %2, i64 %352
%354 = bitcast float* %353 to <4 x float>*
%355 = load <4 x float>, <4 x float>* %354
%356 = getelementptr inbounds float, float* %353, i64 4
%357 = bitcast float* %356 to <4 x float>*
%358 = load <4 x float>, <4 x float>* %357
%359 = getelementptr inbounds float, float* %255, i64 %352
%360 = bitcast float* %359 to <4 x float>*
store <4 x float> %355, <4 x float>* %360
%361 = getelementptr inbounds float, float* %359, i64 4
%362 = bitcast float* %361 to <4 x float>*
store <4 x float> %358, <4 x float>* %362
%363 = getelementptr inbounds float, float* %3, i64 %352
%364 = bitcast float* %363 to <4 x float>*
%365 = load <4 x float>, <4 x float>* %364
%366 = getelementptr inbounds float, float* %363, i64 4
%367 = bitcast float* %366 to <4 x float>*
%368 = load <4 x float>, <4 x float>* %367
%369 = getelementptr inbounds float, float* %256, i64 %352
%370 = bitcast float* %369 to <4 x float>*
store <4 x float> %365, <4 x float>* %370
%371 = getelementptr inbounds float, float* %369, i64 4
%372 = bitcast float* %371 to <4 x float>*
store <4 x float> %368, <4 x float>* %372
%373 = add nuw i64 %328, 16
%374 = add i64 %329, 2
%375 = icmp eq i64 %374, %267
br i1 %375, label %376, label %327
376: ; preds = %327, %326
%377 = phi i64 [ 0, %326 ], [ %373, %327 ]
br i1 %268, label %400, label %378
378: ; preds = %376
%379 = add nuw nsw i64 %377, %305
%380 = getelementptr inbounds float, float* %2, i64 %379
%381 = bitcast float* %380 to <4 x float>*
%382 = load <4 x float>, <4 x float>* %381
%383 = getelementptr inbounds float, float* %380, i64 4
%384 = bitcast float* %383 to <4 x float>*
%385 = load <4 x float>, <4 x float>* %384
%386 = getelementptr inbounds float, float* %255, i64 %379
%387 = bitcast float* %386 to <4 x float>*
store <4 x float> %382, <4 x float>* %387
%388 = getelementptr inbounds float, float* %386, i64 4
%389 = bitcast float* %388 to <4 x float>*
store <4 x float> %385, <4 x float>* %389
%390 = getelementptr inbounds float, float* %3, i64 %379
%391 = bitcast float* %390 to <4 x float>*
%392 = load <4 x float>, <4 x float>* %391
%393 = getelementptr inbounds float, float* %390, i64 4
%394 = bitcast float* %393 to <4 x float>*
%395 = load <4 x float>, <4 x float>* %394
%396 = getelementptr inbounds float, float* %256, i64 %379
%397 = bitcast float* %396 to <4 x float>*
store <4 x float> %392, <4 x float>* %397
%398 = getelementptr inbounds float, float* %396, i64 4
%399 = bitcast float* %398 to <4 x float>*
store <4 x float> %395, <4 x float>* %399
br label %400
400: ; preds = %376, %378
br i1 %269, label %435, label %401
401: ; preds = %306, %293, %400
%402 = phi i64 [ 0, %306 ], [ 0, %293 ], [ %264, %400 ]
%403 = xor i64 %402, -1
br i1 %271, label %413, label %404
404: ; preds = %401
%405 = add nuw nsw i64 %402, %305
%406 = getelementptr inbounds float, float* %2, i64 %405
%407 = load float, float* %406
%408 = getelementptr inbounds float, float* %255, i64 %405
store float %407, float* %408
%409 = getelementptr inbounds float, float* %3, i64 %405
%410 = load float, float* %409
%411 = getelementptr inbounds float, float* %256, i64 %405
store float %410, float* %411
%412 = or i64 %402, 1
br label %413
413: ; preds = %404, %401
%414 = phi i64 [ %402, %401 ], [ %412, %404 ]
%415 = icmp eq i64 %403, %272
br i1 %415, label %435, label %416
416: ; preds = %413, %416
%417 = phi i64 [ %433, %416 ], [ %414, %413 ]
%418 = add nuw nsw i64 %417, %305
%419 = getelementptr inbounds float, float* %2, i64 %418
%420 = load float, float* %419
%421 = getelementptr inbounds float, float* %255, i64 %418
store float %420, float* %421
%422 = getelementptr inbounds float, float* %3, i64 %418
%423 = load float, float* %422
%424 = getelementptr inbounds float, float* %256, i64 %418
store float %423, float* %424
%425 = add nuw nsw i64 %417, 1
%426 = add nuw nsw i64 %425, %305
%427 = getelementptr inbounds float, float* %2, i64 %426
%428 = load float, float* %427
%429 = getelementptr inbounds float, float* %255, i64 %426
store float %428, float* %429
%430 = getelementptr inbounds float, float* %3, i64 %426
%431 = load float, float* %430
%432 = getelementptr inbounds float, float* %256, i64 %426
store float %431, float* %432
%433 = add nuw nsw i64 %417, 2
%434 = icmp eq i64 %433, %258
br i1 %434, label %435, label %416
435: ; preds = %413, %416, %400
%436 = add nuw nsw i64 %294, 1
%437 = icmp eq i64 %436, %258
br i1 %437, label %438, label %293
438: ; preds = %435, %177, %253
%439 = load i32, i32* @conv_damping.nIter
%440 = add nsw i32 %439, 1
store i32 %440, i32* @conv_damping.nIter
br label %441
441: ; preds = %17, %20, %438, %116
%442 = phi float [ 0.000000e+00, %116 ], [ %183, %438 ], [ 0.000000e+00, %20 ], [ 0.000000e+00, %17 ]
ret float %442
}