void restartMapping(double *g, double *z, double *v, double lambda, int nn) {
  int i, n = nn + 1;
  double temp;
  int *S = (int *)malloc(sizeof(int) * nn);
  double *x = (double *)malloc(sizeof(double) * n);
  double *s = (double *)malloc(sizeof(double) * nn);
  double *Av = (double *)malloc(sizeof(double) * nn);
  int numS = -1;
  for (i = 0; i < nn; i++)
    Av[i] = v[i + 1] - v[i];
  g[0] = z[0] + z[0] - z[1] - Av[0];
  for (i = 1; i < nn - 1; i++) {
    g[i] = -z[i - 1] + z[i] + z[i] - z[i + 1] - Av[i];
  }
  g[nn - 1] = -z[nn - 2] + z[nn - 1] + z[nn - 1] - Av[nn - 1];
  numS = supportSet(x, v, z, g, S, lambda, nn);
  for (i = 0; i < nn; i++)
    s[i] = Av[i] - x[i + 1] + x[i];
  Thomas(&temp, g, s, nn);
  for (i = 0; i < nn; i++) {
    if (g[i] > lambda)
      g[i] = lambda;
    else if (g[i] < -lambda)
      g[i] = -lambda;
  }
  free(S);
  free(x);
  free(s);
  free(Av);
}


x86 assembly (clang, -O0):
<restartMapping>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x2,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x2c(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0xffffffff,-0x5c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11fd <restartMapping+0xbd>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b7 <restartMapping+0x77>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
addsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x58(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12bb <restartMapping+0x17b>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    122d <restartMapping+0xed>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x8(%rbp),%rcx
mov    -0x40(%rbp),%r8
movsd  -0x20(%rbp),%xmm0
mov    -0x24(%rbp),%r9d
mov    $0x1,%al
call   1050 <supportSet@plt>
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13ad <restartMapping+0x26d>
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    135a <restartMapping+0x21a>
mov    -0x8(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%ecx
lea    -0x38(%rbp),%rdi
mov    $0x0,%al
call   1060 <Thomas@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1479 <restartMapping+0x339>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    1405 <restartMapping+0x2c5>
movsd  -0x20(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1466 <restartMapping+0x326>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1461 <restartMapping+0x321>
movsd  -0x20(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1466 <restartMapping+0x326>
jmp    146b <restartMapping+0x32b>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ca <restartMapping+0x28a>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<restartMapping>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%r12d
movaps %xmm0,0x10(%rsp)
mov    %rdx,%rbp
mov    %rsi,%r14
mov    %rdi,%r13
movslq %ecx,%r15
lea    0x0(,%r15,4),%rdi
call   1040 <malloc@plt>
mov    %rax,0x8(%rsp)
lea    0x8(,%r15,8),%rdi
call   1040 <malloc@plt>
mov    %rax,(%rsp)
lea    0x0(,%r15,8),%rbx
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rbx,%rdi
call   1040 <malloc@plt>
mov    %r15,%r10
mov    %r12,%r9
mov    %rax,%rbx
mov    %r9d,%r12d
test   %r10d,%r10d
jle    11cf <restartMapping+0x8f>
movsd  0x0(%rbp),%xmm4
cmp    $0x4,%r9d
jae    11de <restartMapping+0x9e>
xor    %eax,%eax
movapd 0x10(%rsp),%xmm0
mov    (%rsp),%r15
jmp    12e0 <restartMapping+0x1a0>
movapd 0x10(%rsp),%xmm0
mov    (%rsp),%r15
jmp    1307 <restartMapping+0x1c7>
mov    %r12d,%eax
and    $0xfffffffc,%eax
unpcklpd %xmm4,%xmm4
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     16c3 <restartMapping+0x583>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movapd 0x10(%rsp),%xmm0
mov    (%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd 0x8(%rbp,%rcx,8),%xmm1
movupd 0x18(%rbp,%rcx,8),%xmm2
shufpd $0x1,%xmm1,%xmm4
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
subpd  %xmm4,%xmm1
movapd %xmm2,%xmm4
subpd  %xmm3,%xmm4
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm4,0x10(%rbx,%rcx,8)
movupd 0x28(%rbp,%rcx,8),%xmm1
movupd 0x38(%rbp,%rcx,8),%xmm4
shufpd $0x1,%xmm1,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm4,%xmm3
subpd  %xmm2,%xmm1
movapd %xmm4,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm1,0x20(%rbx,%rcx,8)
movupd %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1220 <restartMapping+0xe0>
test   $0x1,%dl
je     12cf <restartMapping+0x18f>
lea    0x0(,%rcx,8),%rdx
or     $0x8,%rdx
movupd 0x0(%rbp,%rdx,1),%xmm1
movupd 0x10(%rbp,%rdx,1),%xmm2
shufpd $0x1,%xmm1,%xmm4
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
subpd  %xmm4,%xmm1
movapd %xmm2,%xmm4
subpd  %xmm3,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
cmp    %r12,%rax
je     1303 <restartMapping+0x1c3>
unpckhpd %xmm4,%xmm4
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rbp,%rax,8),%xmm1
movapd %xmm1,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rbx,%rax,8)
lea    0x1(%rax),%rcx
movapd %xmm1,%xmm4
mov    %rcx,%rax
cmp    %rcx,%r12
jne    12e0 <restartMapping+0x1a0>
movsd  (%rbx),%xmm2
movsd  (%r14),%xmm1
addsd  %xmm1,%xmm1
subsd  0x8(%r14),%xmm1
movsd  %xmm2,(%rsp)
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13)
lea    -0x1(%r9),%eax
cmp    $0x3,%r9d
jl     149d <restartMapping+0x35d>
mov    %eax,%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x4,%r8
jb     13f6 <restartMapping+0x2b6>
lea    0x8(%r13),%rsi
lea    (%r14,%rcx,8),%rdi
add    $0x8,%rdi
cmp    %rdi,%rsi
jae    136d <restartMapping+0x22d>
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
cmp    %r14,%rsi
ja     13f6 <restartMapping+0x2b6>
mov    %r8,%rdi
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rdi),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rsi,8),%xmm5
movupd 0x8(%r14,%rsi,8),%xmm1
movupd 0x10(%r14,%rsi,8),%xmm2
movupd 0x18(%r14,%rsi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm5,%xmm4
movapd %xmm3,%xmm5
subpd  %xmm2,%xmm5
addpd  %xmm1,%xmm4
addpd  %xmm3,%xmm5
movupd 0x20(%r14,%rsi,8),%xmm1
subpd  %xmm1,%xmm5
subpd  %xmm2,%xmm4
movupd 0x8(%rbx,%rsi,8),%xmm1
subpd  %xmm1,%xmm4
movupd 0x18(%rbx,%rsi,8),%xmm1
subpd  %xmm1,%xmm5
movupd %xmm4,0x8(%r13,%rsi,8)
movupd %xmm5,0x18(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    1380 <restartMapping+0x240>
cmp    %rdi,%r8
je     149d <restartMapping+0x35d>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
jne    142d <restartMapping+0x2ed>
movsd  (%r14,%rdx,8),%xmm2
movapd %xmm2,%xmm1
subsd  -0x8(%r14,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
subsd  0x8(%r14,%rdx,8),%xmm1
subsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    %rcx,%rsi
je     149d <restartMapping+0x35d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rdx,8),%xmm2
movapd %xmm2,%xmm1
subsd  -0x8(%r14,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
subsd  0x8(%r14,%rdx,8),%xmm1
subsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm2
movapd %xmm2,%xmm1
subsd  (%r14,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
subsd  0x10(%r14,%rdx,8),%xmm1
subsd  0x8(%rbx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%r13,%rdx,8)
lea    0x2(%rdx),%rsi
mov    %rsi,%rdx
cmp    %rsi,%rcx
jne    1440 <restartMapping+0x300>
cltq
movsd  (%r14,%rax,8),%xmm2
movapd %xmm2,%xmm1
subsd  -0x10(%r14,%r10,8),%xmm1
addsd  %xmm2,%xmm1
subsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    0x8(%rsp),%r8
mov    %r9,%r14
mov    $0x1,%al
call   1050 <supportSet@plt>
mov    %r14,%rcx
test   %ecx,%ecx
jle    1616 <restartMapping+0x4d6>
movsd  0x8(%r15),%xmm0
movsd  (%rsp),%xmm1
subsd  %xmm0,%xmm1
addsd  (%r15),%xmm1
mov    0x28(%rsp),%rbp
movsd  %xmm1,0x0(%rbp)
cmp    $0x1,%ecx
je     15ba <restartMapping+0x47a>
lea    -0x1(%r12),%rdi
mov    $0x1,%eax
cmp    $0x4,%rdi
jb     1590 <restartMapping+0x450>
mov    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rax
unpcklpd %xmm0,%xmm0
xor    %esi,%esi
xchg   %ax,%ax
movupd 0x8(%rbx,%rsi,8),%xmm1
movupd 0x18(%rbx,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
shufpd $0x1,%xmm3,%xmm0
subpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movupd 0x20(%r15,%rsi,8),%xmm0
shufpd $0x1,%xmm0,%xmm3
subpd  %xmm0,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm1,0x8(%rbp,%rsi,8)
movupd %xmm2,0x18(%rbp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1530 <restartMapping+0x3f0>
cmp    %rdx,%rdi
je     15ba <restartMapping+0x47a>
unpckhpd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm2
subsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
lea    0x1(%rax),%rdx
movapd %xmm2,%xmm0
mov    %rdx,%rax
cmp    %rdx,%r12
jne    1590 <restartMapping+0x450>
lea    0x30(%rsp),%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1060 <Thomas@plt>
test   %r14d,%r14d
movapd 0x10(%rsp),%xmm3
mov    0x8(%rsp),%rdi
jle    1632 <restartMapping+0x4f2>
movapd 0xa1c(%rip),%xmm0
xorpd  %xmm3,%xmm0
cmp    $0x1,%r14d
jne    165e <restartMapping+0x51e>
xor    %eax,%eax
test   $0x1,%r12b
je     1632 <restartMapping+0x4f2>
movsd  0x0(%r13,%rax,8),%xmm1
ucomisd %xmm3,%xmm1
ja     160d <restartMapping+0x4cd>
ucomisd %xmm1,%xmm0
movapd %xmm0,%xmm3
jbe    1632 <restartMapping+0x4f2>
movsd  %xmm3,0x0(%r13,%rax,8)
jmp    1632 <restartMapping+0x4f2>
lea    0x30(%rsp),%rdi
mov    %r13,%rsi
mov    0x28(%rsp),%rbp
mov    %rbp,%rdx
xor    %eax,%eax
call   1060 <Thomas@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
xor    %eax,%eax
jmp    1684 <restartMapping+0x544>
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
je     15f0 <restartMapping+0x4b0>
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
movapd %xmm3,%xmm1
ja     169f <restartMapping+0x55f>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
jbe    16a6 <restartMapping+0x566>
movsd  %xmm1,0x0(%r13,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
movapd %xmm3,%xmm1
ja     1670 <restartMapping+0x530>
ucomisd %xmm2,%xmm0
movapd %xmm0,%xmm1
ja     1670 <restartMapping+0x530>
jmp    1677 <restartMapping+0x537>
xor    %ecx,%ecx
movapd 0x10(%rsp),%xmm0
mov    (%rsp),%r15
test   $0x1,%dl
jne    1292 <restartMapping+0x152>
jmp    12cf <restartMapping+0x18f>

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

LLVM IR (-O2):
define void @restartMapping(double* %0, double* %1, double* %2, double %3, i32 %4) {
%6 = alloca double
%7 = add nsw i32 %4, 1
%8 = bitcast double* %6 to i8*
%9 = sext i32 %4 to i64
%10 = shl nsw i64 %9, 2
%11 = tail call i8* @malloc(i64 %10)
%12 = bitcast i8* %11 to i32*
%13 = sext i32 %7 to i64
%14 = shl nsw i64 %13, 3
%15 = tail call i8* @malloc(i64 %14)
%16 = bitcast i8* %15 to double*
%17 = shl nsw i64 %9, 3
%18 = tail call i8* @malloc(i64 %17)
%19 = bitcast i8* %18 to double*
%20 = tail call i8* @malloc(i64 %17)
%21 = bitcast i8* %20 to double*
%22 = icmp sgt i32 %4, 0
br i1 %22, label %23, label %114
23: ; preds = %5
%24 = zext i32 %4 to i64
%25 = load double, double* %2
%26 = icmp ult i32 %4, 4
br i1 %26, label %100, label %27
27: ; preds = %23
%28 = and i64 %24, 4294967292
%29 = insertelement <2 x double> poison, double %25, i64 1
%30 = add nsw i64 %28, -4
%31 = lshr exact i64 %30, 2
%32 = add nuw nsw i64 %31, 1
%33 = and i64 %32, 1
%34 = icmp eq i64 %30, 0
br i1 %34, label %75, label %35
35: ; preds = %27
%36 = and i64 %32, 9223372036854775806
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %72, %37 ]
%39 = phi <2 x double> [ %29, %35 ], [ %63, %37 ]
%40 = phi i64 [ 0, %35 ], [ %73, %37 ]
%41 = or i64 %38, 1
%42 = getelementptr inbounds double, double* %2, i64 %41
%43 = bitcast double* %42 to <2 x double>*
%44 = load <2 x double>, <2 x double>* %43
%45 = getelementptr inbounds double, double* %42, i64 2
%46 = bitcast double* %45 to <2 x double>*
%47 = load <2 x double>, <2 x double>* %46
%48 = shufflevector <2 x double> %39, <2 x double> %44, <2 x i32> <i32 1, i32 2>
%49 = shufflevector <2 x double> %44, <2 x double> %47, <2 x i32> <i32 1, i32 2>
%50 = fsub <2 x double> %44, %48
%51 = fsub <2 x double> %47, %49
%52 = getelementptr inbounds double, double* %21, i64 %38
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> %50, <2 x double>* %53
%54 = getelementptr inbounds double, double* %52, i64 2
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %51, <2 x double>* %55
%56 = or i64 %38, 4
%57 = or i64 %38, 5
%58 = getelementptr inbounds double, double* %2, i64 %57
%59 = bitcast double* %58 to <2 x double>*
%60 = load <2 x double>, <2 x double>* %59
%61 = getelementptr inbounds double, double* %58, i64 2
%62 = bitcast double* %61 to <2 x double>*
%63 = load <2 x double>, <2 x double>* %62
%64 = shufflevector <2 x double> %47, <2 x double> %60, <2 x i32> <i32 1, i32 2>
%65 = shufflevector <2 x double> %60, <2 x double> %63, <2 x i32> <i32 1, i32 2>
%66 = fsub <2 x double> %60, %64
%67 = fsub <2 x double> %63, %65
%68 = getelementptr inbounds double, double* %21, i64 %56
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> %66, <2 x double>* %69
%70 = getelementptr inbounds double, double* %68, i64 2
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %67, <2 x double>* %71
%72 = add nuw i64 %38, 8
%73 = add i64 %40, 2
%74 = icmp eq i64 %73, %36
br i1 %74, label %75, label %37
75: ; preds = %37, %27
%76 = phi <2 x double> [ undef, %27 ], [ %63, %37 ]
%77 = phi i64 [ 0, %27 ], [ %72, %37 ]
%78 = phi <2 x double> [ %29, %27 ], [ %63, %37 ]
%79 = icmp eq i64 %33, 0
br i1 %79, label %96, label %80
80: ; preds = %75
%81 = or i64 %77, 1
%82 = getelementptr inbounds double, double* %2, i64 %81
%83 = bitcast double* %82 to <2 x double>*
%84 = load <2 x double>, <2 x double>* %83
%85 = getelementptr inbounds double, double* %82, i64 2
%86 = bitcast double* %85 to <2 x double>*
%87 = load <2 x double>, <2 x double>* %86
%88 = shufflevector <2 x double> %78, <2 x double> %84, <2 x i32> <i32 1, i32 2>
%89 = shufflevector <2 x double> %84, <2 x double> %87, <2 x i32> <i32 1, i32 2>
%90 = fsub <2 x double> %84, %88
%91 = fsub <2 x double> %87, %89
%92 = getelementptr inbounds double, double* %21, i64 %77
%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
br label %96
96: ; preds = %75, %80
%97 = phi <2 x double> [ %76, %75 ], [ %87, %80 ]
%98 = icmp eq i64 %28, %24
%99 = extractelement <2 x double> %97, i64 1
br i1 %98, label %112, label %100
100: ; preds = %23, %96
%101 = phi double [ %99, %96 ], [ %25, %23 ]
%102 = phi i64 [ %28, %96 ], [ 0, %23 ]
br label %103
103: ; preds = %100, %103
%104 = phi double [ %108, %103 ], [ %101, %100 ]
%105 = phi i64 [ %106, %103 ], [ %102, %100 ]
%106 = add nuw nsw i64 %105, 1
%107 = getelementptr inbounds double, double* %2, i64 %106
%108 = load double, double* %107
%109 = fsub double %108, %104
%110 = getelementptr inbounds double, double* %21, i64 %105
store double %109, double* %110
%111 = icmp eq i64 %106, %24
br i1 %111, label %112, label %103
112: ; preds = %103, %96
%113 = load double, double* %21
br label %114
114: ; preds = %112, %5
%115 = phi double [ %113, %112 ], [ undef, %5 ]
%116 = load double, double* %1
%117 = fadd double %116, %116
%118 = getelementptr inbounds double, double* %1, i64 1
%119 = load double, double* %118
%120 = fsub double %117, %119
%121 = fsub double %120, %115
store double %121, double* %0
%122 = add i32 %4, -1
%123 = icmp sgt i32 %4, 2
br i1 %123, label %124, label %240
124: ; preds = %114
%125 = zext i32 %122 to i64
%126 = add nsw i64 %125, -1
%127 = icmp ult i64 %126, 4
br i1 %127, label %183, label %128
128: ; preds = %124
%129 = getelementptr double, double* %0, i64 1
%130 = getelementptr double, double* %0, i64 %125
%131 = add nuw nsw i64 %125, 1
%132 = getelementptr double, double* %1, i64 %131
%133 = icmp ult double* %129, %132
%134 = icmp ugt double* %130, %1
%135 = and i1 %133, %134
br i1 %135, label %183, label %136
136: ; preds = %128
%137 = and i64 %126, -4
%138 = or i64 %137, 1
br label %139
139: ; preds = %139, %136
%140 = phi i64 [ 0, %136 ], [ %179, %139 ]
%141 = or i64 %140, 1
%142 = getelementptr inbounds double, double* %1, i64 %140
%143 = bitcast double* %142 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = getelementptr inbounds double, double* %142, i64 2
%146 = bitcast double* %145 to <2 x double>*
%147 = load <2 x double>, <2 x double>* %146
%148 = getelementptr inbounds double, double* %1, i64 %141
%149 = bitcast double* %148 to <2 x double>*
%150 = load <2 x double>, <2 x double>* %149
%151 = getelementptr inbounds double, double* %148, i64 2
%152 = bitcast double* %151 to <2 x double>*
%153 = load <2 x double>, <2 x double>* %152
%154 = fsub <2 x double> %150, %144
%155 = fsub <2 x double> %153, %147
%156 = fadd <2 x double> %150, %154
%157 = fadd <2 x double> %153, %155
%158 = or i64 %140, 2
%159 = getelementptr inbounds double, double* %1, i64 %158
%160 = bitcast double* %159 to <2 x double>*
%161 = load <2 x double>, <2 x double>* %160
%162 = getelementptr inbounds double, double* %159, i64 2
%163 = bitcast double* %162 to <2 x double>*
%164 = load <2 x double>, <2 x double>* %163
%165 = fsub <2 x double> %156, %161
%166 = fsub <2 x double> %157, %164
%167 = getelementptr inbounds double, double* %21, i64 %141
%168 = bitcast double* %167 to <2 x double>*
%169 = load <2 x double>, <2 x double>* %168
%170 = getelementptr inbounds double, double* %167, i64 2
%171 = bitcast double* %170 to <2 x double>*
%172 = load <2 x double>, <2 x double>* %171
%173 = fsub <2 x double> %165, %169
%174 = fsub <2 x double> %166, %172
%175 = getelementptr inbounds double, double* %0, i64 %141
%176 = bitcast double* %175 to <2 x double>*
store <2 x double> %173, <2 x double>* %176
%177 = getelementptr inbounds double, double* %175, i64 2
%178 = bitcast double* %177 to <2 x double>*
store <2 x double> %174, <2 x double>* %178
%179 = add nuw i64 %140, 4
%180 = icmp eq i64 %179, %137
br i1 %180, label %181, label %139
181: ; preds = %139
%182 = icmp eq i64 %126, %137
br i1 %182, label %240, label %183
183: ; preds = %128, %124, %181
%184 = phi i64 [ 1, %128 ], [ 1, %124 ], [ %138, %181 ]
%185 = xor i64 %184, -1
%186 = and i64 %125, 1
%187 = icmp eq i64 %186, 0
br i1 %187, label %188, label %204
188: ; preds = %183
%189 = add nsw i64 %184, -1
%190 = getelementptr inbounds double, double* %1, i64 %189
%191 = load double, double* %190
%192 = getelementptr inbounds double, double* %1, i64 %184
%193 = load double, double* %192
%194 = fsub double %193, %191
%195 = fadd double %193, %194
%196 = add nuw nsw i64 %184, 1
%197 = getelementptr inbounds double, double* %1, i64 %196
%198 = load double, double* %197
%199 = fsub double %195, %198
%200 = getelementptr inbounds double, double* %21, i64 %184
%201 = load double, double* %200
%202 = fsub double %199, %201
%203 = getelementptr inbounds double, double* %0, i64 %184
store double %202, double* %203
br label %204
204: ; preds = %188, %183
%205 = phi i64 [ %184, %183 ], [ %196, %188 ]
%206 = sub nsw i64 0, %125
%207 = icmp eq i64 %185, %206
br i1 %207, label %240, label %208
208: ; preds = %204, %208
%209 = phi i64 [ %231, %208 ], [ %205, %204 ]
%210 = add nsw i64 %209, -1
%211 = getelementptr inbounds double, double* %1, i64 %210
%212 = load double, double* %211
%213 = getelementptr inbounds double, double* %1, i64 %209
%214 = load double, double* %213
%215 = fsub double %214, %212
%216 = fadd double %214, %215
%217 = add nuw nsw i64 %209, 1
%218 = getelementptr inbounds double, double* %1, i64 %217
%219 = load double, double* %218
%220 = fsub double %216, %219
%221 = getelementptr inbounds double, double* %21, i64 %209
%222 = load double, double* %221
%223 = fsub double %220, %222
%224 = getelementptr inbounds double, double* %0, i64 %209
store double %223, double* %224
%225 = getelementptr inbounds double, double* %1, i64 %209
%226 = load double, double* %225
%227 = getelementptr inbounds double, double* %1, i64 %217
%228 = load double, double* %227
%229 = fsub double %228, %226
%230 = fadd double %228, %229
%231 = add nuw nsw i64 %209, 2
%232 = getelementptr inbounds double, double* %1, i64 %231
%233 = load double, double* %232
%234 = fsub double %230, %233
%235 = getelementptr inbounds double, double* %21, i64 %217
%236 = load double, double* %235
%237 = fsub double %234, %236
%238 = getelementptr inbounds double, double* %0, i64 %217
store double %237, double* %238
%239 = icmp eq i64 %231, %125
br i1 %239, label %240, label %208
240: ; preds = %204, %208, %181, %114
%241 = add nsw i32 %4, -2
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %1, i64 %242
%244 = load double, double* %243
%245 = sext i32 %122 to i64
%246 = getelementptr inbounds double, double* %1, i64 %245
%247 = load double, double* %246
%248 = fsub double %247, %244
%249 = fadd double %247, %248
%250 = getelementptr inbounds double, double* %21, i64 %245
%251 = load double, double* %250
%252 = fsub double %249, %251
%253 = getelementptr inbounds double, double* %0, i64 %245
store double %252, double* %253
%254 = tail call i32 (double*, double*, double*, double*, i32*, double, i32, ...) bitcast (i32 (...)* @supportSet to i32 (double*, double*, double*, double*, i32*, double, i32, ...)*)(double* %16, double* %2, double* %1, double* %0, i32* %12, double %3, i32 %4)
br i1 %22, label %257, label %255
255: ; preds = %240
%256 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @Thomas to i32 (double*, double*, double*, i32, ...)*)(double* %6, double* %0, double* %19, i32 %4)
br label %361
257: ; preds = %240
%258 = zext i32 %4 to i64
%259 = load double, double* %16
%260 = getelementptr inbounds double, double* %16, i64 1
%261 = load double, double* %260
%262 = fsub double %115, %261
%263 = fadd double %262, %259
store double %263, double* %19
%264 = icmp eq i32 %4, 1
br i1 %264, label %319, label %265
265: ; preds = %257
%266 = add nsw i64 %258, -1
%267 = icmp ult i64 %266, 4
br i1 %267, label %304, label %268
268: ; preds = %265
%269 = and i64 %266, -4
%270 = or i64 %269, 1
%271 = insertelement <2 x double> poison, double %261, i64 1
br label %272
272: ; preds = %272, %268
%273 = phi i64 [ 0, %268 ], [ %299, %272 ]
%274 = phi <2 x double> [ %271, %268 ], [ %288, %272 ]
%275 = or i64 %273, 1
%276 = getelementptr inbounds double, double* %21, i64 %275
%277 = bitcast double* %276 to <2 x double>*
%278 = load <2 x double>, <2 x double>* %277
%279 = getelementptr inbounds double, double* %276, i64 2
%280 = bitcast double* %279 to <2 x double>*
%281 = load <2 x double>, <2 x double>* %280
%282 = or i64 %273, 2
%283 = getelementptr inbounds double, double* %16, i64 %282
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %283, i64 2
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = shufflevector <2 x double> %274, <2 x double> %285, <2 x i32> <i32 1, i32 2>
%290 = shufflevector <2 x double> %285, <2 x double> %288, <2 x i32> <i32 1, i32 2>
%291 = fsub <2 x double> %278, %285
%292 = fsub <2 x double> %281, %288
%293 = fadd <2 x double> %291, %289
%294 = fadd <2 x double> %292, %290
%295 = getelementptr inbounds double, double* %19, i64 %275
%296 = bitcast double* %295 to <2 x double>*
store <2 x double> %293, <2 x double>* %296
%297 = getelementptr inbounds double, double* %295, i64 2
%298 = bitcast double* %297 to <2 x double>*
store <2 x double> %294, <2 x double>* %298
%299 = add nuw i64 %273, 4
%300 = icmp eq i64 %299, %269
br i1 %300, label %301, label %272
301: ; preds = %272
%302 = icmp eq i64 %266, %269
%303 = extractelement <2 x double> %288, i64 1
br i1 %302, label %319, label %304
304: ; preds = %265, %301
%305 = phi double [ %303, %301 ], [ %261, %265 ]
%306 = phi i64 [ %270, %301 ], [ 1, %265 ]
br label %307
307: ; preds = %304, %307
%308 = phi double [ %314, %307 ], [ %305, %304 ]
%309 = phi i64 [ %312, %307 ], [ %306, %304 ]
%310 = getelementptr inbounds double, double* %21, i64 %309
%311 = load double, double* %310
%312 = add nuw nsw i64 %309, 1
%313 = getelementptr inbounds double, double* %16, i64 %312
%314 = load double, double* %313
%315 = fsub double %311, %314
%316 = fadd double %315, %308
%317 = getelementptr inbounds double, double* %19, i64 %309
store double %316, double* %317
%318 = icmp eq i64 %312, %258
br i1 %318, label %319, label %307
319: ; preds = %307, %301, %257
%320 = call i32 (double*, double*, double*, i32, ...) bitcast (i32 (...)* @Thomas to i32 (double*, double*, double*, i32, ...)*)(double* %6, double* %0, double* %19, i32 %4)
br i1 %22, label %321, label %361
321: ; preds = %319
%322 = fneg double %3
%323 = and i64 %258, 1
%324 = icmp eq i32 %4, 1
br i1 %324, label %350, label %325
325: ; preds = %321
%326 = and i64 %258, 4294967294
br label %327
327: ; preds = %346, %325
%328 = phi i64 [ 0, %325 ], [ %347, %346 ]
%329 = phi i64 [ 0, %325 ], [ %348, %346 ]
%330 = getelementptr inbounds double, double* %0, i64 %328
%331 = load double, double* %330
%332 = fcmp ogt double %331, %3
br i1 %332, label %335, label %333
333: ; preds = %327
%334 = fcmp olt double %331, %322
br i1 %334, label %335, label %337
335: ; preds = %333, %327
%336 = phi double [ %3, %327 ], [ %322, %333 ]
store double %336, double* %330
br label %337
337: ; preds = %335, %333
%338 = or i64 %328, 1
%339 = getelementptr inbounds double, double* %0, i64 %338
%340 = load double, double* %339
%341 = fcmp ogt double %340, %3
br i1 %341, label %344, label %342
342: ; preds = %337
%343 = fcmp olt double %340, %322
br i1 %343, label %344, label %346
344: ; preds = %342, %337
%345 = phi double [ %3, %337 ], [ %322, %342 ]
store double %345, double* %339
br label %346
346: ; preds = %344, %342
%347 = add nuw nsw i64 %328, 2
%348 = add i64 %329, 2
%349 = icmp eq i64 %348, %326
br i1 %349, label %350, label %327
350: ; preds = %346, %321
%351 = phi i64 [ 0, %321 ], [ %347, %346 ]
%352 = icmp eq i64 %323, 0
br i1 %352, label %361, label %353
353: ; preds = %350
%354 = getelementptr inbounds double, double* %0, i64 %351
%355 = load double, double* %354
%356 = fcmp ogt double %355, %3
br i1 %356, label %359, label %357
357: ; preds = %353
%358 = fcmp olt double %355, %322
br i1 %358, label %359, label %361
359: ; preds = %357, %353
%360 = phi double [ %3, %353 ], [ %322, %357 ]
store double %360, double* %354
br label %361
361: ; preds = %350, %359, %357, %255, %319
ret void
}