#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 */
int /*<<< orphan*/ _magic_pin_start();
int /*<<< orphan*/ _magic_pin_stop();
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(unsigned int);
int main(int argc, char **argv) {
  unsigned int size = 2e6;
  {
    double *a = (double *)malloc(size * sizeof(double));
    double *b = (double *)malloc(size * sizeof(double));
    double *c = (double *)malloc(size * sizeof(double));
    double *d = (double *)malloc(size * sizeof(double));
    for (unsigned int i = 0; i < size; ++i) {
      a[i] = 1.01;
      b[i] = 1.02;
      c[i] = 1.03;
      d[i] = 1.04;
    }
    _magic_pin_start();
    for (unsigned int i = 0; i < size; ++i)
      a[i] = b[i] + c[i] * d[i];
    _magic_pin_stop();
    free(a);
    free(b);
    free(c);
    free(d);
  }
  {
    double *a = (double *)malloc(size * sizeof(double));
    double *b = (double *)malloc(size * sizeof(double));
    double s = 0.98;
    for (unsigned int i = 0; i < size; ++i) {
      a[i] = 1.01;
      b[i] = 1.02;
    }
    for (unsigned int i = 0; i < size; ++i)
      a[i] = s * b[i];
    free(a);
    free(b);
  }
  {
    double *a = (double *)malloc(size * sizeof(double));
    double *b = (double *)malloc(size * sizeof(double));
    double *c = (double *)malloc(size * sizeof(double));
    for (unsigned int i = 0; i < size; ++i) {
      a[i] = 1.01;
      b[i] = 1.02;
      c[i] = 1.03;
    }
    for (unsigned int i = 0; i < size; ++i)
      a[i] = b[i] + c[i];
    free(a);
    free(b);
    free(c);
  }
  {
    double *a = (double *)malloc(size * sizeof(double));
    double *b = (double *)malloc(size * sizeof(double));
    for (unsigned int i = 0; i < size; ++i) {
      a[i] = 1.01;
      b[i] = 1.02;
    }
    for (unsigned int i = 0; i < size; ++i)
      a[i] = b[i];
    free(a);
    free(b);
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1e8480,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1219 <main+0xd9>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  0xe46(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  0xe2a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  0xe26(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%ecx
movsd  0xe1a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11af <main+0x6f>
mov    $0x0,%al
call   1040 <_magic_pin_start@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1279 <main+0x139>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1227 <main+0xe7>
mov    $0x0,%al
call   1050 <_magic_pin_stop@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movsd  0xd30(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    131e <main+0x1de>
mov    -0x48(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movsd  0xd19(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
mov    -0x5c(%rbp),%ecx
movsd  0xcfd(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12dc <main+0x19c>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    135c <main+0x21c>
movsd  -0x58(%rbp),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1325 <main+0x1e5>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1401 <main+0x2c1>
mov    -0x68(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movsd  0xc4a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movsd  0xc2e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movsd  0xc2a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    13ab <main+0x26b>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1446 <main+0x306>
mov    -0x70(%rbp),%rax
mov    -0x80(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x80(%rbp),%ecx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x80(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1408 <main+0x2c8>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    14ec <main+0x3ac>
mov    -0x88(%rbp),%rax
mov    -0x94(%rbp),%ecx
movsd  0xb57(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x90(%rbp),%rax
mov    -0x94(%rbp),%ecx
movsd  0xb35(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1495 <main+0x355>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    153d <main+0x3fd>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%ecx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
mov    -0x98(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    14f6 <main+0x3b6>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
lea    0xf42400(%r15),%rdx
lea    0xf42400(%r14),%rsi
lea    0xf42400(%r12),%rbp
lea    0xf42400(%rax),%rdi
cmp    %rsi,%r15
setb   %r8b
cmp    %rdx,%r14
setb   %r10b
cmp    %rbp,%r15
setb   %cl
cmp    %rdx,%r12
setb   %r11b
cmp    %rdi,%r15
setb   %al
mov    %rdx,0x20(%rsp)
cmp    %rdx,%rbx
setb   0x6(%rsp)
cmp    %rbp,%r14
setb   %dl
cmp    %rsi,%r12
setb   0x7(%rsp)
cmp    %rdi,%r14
setb   %r9b
mov    %rsi,0x8(%rsp)
cmp    %rsi,%rbx
setb   0x5(%rsp)
mov    %rdi,0x18(%rsp)
cmp    %rdi,%r12
setb   %dil
mov    %rbp,0x10(%rsp)
cmp    %rbp,%rbx
setb   %sil
movabs $0x3ff028f5c28f5c29,%r13
28 f0 3f
movabs $0x3ff051eb851eb852,%rbp
51 f0 3f
test   %r10b,%r8b
jne    12f6 <main+0x1b6>
and    %r11b,%cl
jne    12f6 <main+0x1b6>
and    0x6(%rsp),%al
jne    12f6 <main+0x1b6>
and    0x7(%rsp),%dl
jne    12f6 <main+0x1b6>
and    0x5(%rsp),%r9b
jne    12f6 <main+0x1b6>
and    %sil,%dil
jne    12f6 <main+0x1b6>
mov    $0x6,%eax
movapd 0xd9e(%rip),%xmm0
movapd 0xda6(%rip),%xmm1
movapd 0xdae(%rip),%xmm2
movapd 0xdb6(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x30(%r15,%rax,8)
movupd %xmm0,-0x20(%r15,%rax,8)
movupd %xmm1,-0x30(%r14,%rax,8)
movupd %xmm1,-0x20(%r14,%rax,8)
movupd %xmm2,-0x30(%r12,%rax,8)
movupd %xmm2,-0x20(%r12,%rax,8)
movupd %xmm3,-0x30(%rbx,%rax,8)
movupd %xmm3,-0x20(%rbx,%rax,8)
movupd %xmm0,-0x10(%r15,%rax,8)
movupd %xmm0,(%r15,%rax,8)
movupd %xmm1,-0x10(%r14,%rax,8)
movupd %xmm1,(%r14,%rax,8)
movupd %xmm2,-0x10(%r12,%rax,8)
movupd %xmm2,(%r12,%rax,8)
movupd %xmm3,-0x10(%rbx,%rax,8)
movupd %xmm3,(%rbx,%rax,8)
add    $0x8,%rax
cmp    $0x1e8486,%rax
jne    1280 <main+0x140>
jmp    1340 <main+0x200>
mov    $0x1,%eax
movabs $0x3ff0a3d70a3d70a4,%rcx
a3 f0 3f
movabs $0x3ff07ae147ae147b,%rdx
7a f0 3f
nop
mov    %r13,-0x8(%r15,%rax,8)
mov    %rbp,-0x8(%r14,%rax,8)
mov    %rdx,-0x8(%r12,%rax,8)
mov    %rcx,-0x8(%rbx,%rax,8)
mov    %r13,(%r15,%rax,8)
mov    %rbp,(%r14,%rax,8)
mov    %rdx,(%r12,%rax,8)
mov    %rcx,(%rbx,%rax,8)
add    $0x2,%rax
cmp    $0x1e8481,%rax
jne    1310 <main+0x1d0>
xor    %eax,%eax
call   1040 <_magic_pin_start@plt>
cmp    0x8(%rsp),%r15
setb   %r8b
mov    0x20(%rsp),%rsi
cmp    %rsi,%r14
setb   %dl
cmp    0x10(%rsp),%r15
setb   %cl
cmp    %rsi,%r12
setb   %dil
cmp    0x18(%rsp),%r15
setb   %al
cmp    %rsi,%rbx
setb   %sil
test   %dl,%r8b
jne    143a <main+0x2fa>
and    %dil,%cl
jne    143a <main+0x2fa>
and    %sil,%al
jne    143a <main+0x2fa>
mov    $0x6,%eax
nopl   0x0(%rax)
movupd -0x30(%r14,%rax,8),%xmm0
movupd -0x20(%r14,%rax,8),%xmm1
movupd -0x30(%r12,%rax,8),%xmm2
movupd -0x20(%r12,%rax,8),%xmm3
movupd -0x30(%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd -0x20(%rbx,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,-0x30(%r15,%rax,8)
movupd %xmm0,-0x20(%r15,%rax,8)
movupd -0x10(%r14,%rax,8),%xmm0
movupd (%r14,%rax,8),%xmm1
movupd -0x10(%r12,%rax,8),%xmm2
movupd (%r12,%rax,8),%xmm3
movupd -0x10(%rbx,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm0,%xmm4
movupd (%rbx,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm4,-0x10(%r15,%rax,8)
movupd %xmm0,(%r15,%rax,8)
add    $0x8,%rax
cmp    $0x1e8486,%rax
jne    13a0 <main+0x260>
jmp    147e <main+0x33e>
mov    $0x1,%eax
nop
movsd  -0x8(%r12,%rax,8),%xmm0
mulsd  -0x8(%rbx,%rax,8),%xmm0
addsd  -0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x2,%rax
cmp    $0x1e8481,%rax
jne    1440 <main+0x300>
xor    %eax,%eax
call   1050 <_magic_pin_stop@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
lea    0xf42400(%r14),%rax
lea    0xf42400(%rbx),%rcx
cmp    %rcx,%r14
jae    1522 <main+0x3e2>
cmp    %rax,%rbx
jae    1522 <main+0x3e2>
mov    $0x4,%edx
nopl   0x0(%rax)
mov    %r13,-0x20(%r14,%rdx,8)
mov    %rbp,-0x20(%rbx,%rdx,8)
mov    %r13,-0x18(%r14,%rdx,8)
mov    %rbp,-0x18(%rbx,%rdx,8)
mov    %r13,-0x10(%r14,%rdx,8)
mov    %rbp,-0x10(%rbx,%rdx,8)
mov    %r13,-0x8(%r14,%rdx,8)
mov    %rbp,-0x8(%rbx,%rdx,8)
mov    %r13,(%r14,%rdx,8)
mov    %rbp,(%rbx,%rdx,8)
add    $0x5,%rdx
cmp    $0x1e8484,%rdx
jne    14e0 <main+0x3a0>
jmp    15d7 <main+0x497>
mov    $0x12,%edx
movapd 0xad1(%rip),%xmm0
movapd 0xad9(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x90(%r14,%rdx,8)
ff ff ff
movupd %xmm0,-0x80(%r14,%rdx,8)
movupd %xmm1,-0x90(%rbx,%rdx,8)
ff ff
movupd %xmm1,-0x80(%rbx,%rdx,8)
movupd %xmm0,-0x70(%r14,%rdx,8)
movupd %xmm0,-0x60(%r14,%rdx,8)
movupd %xmm1,-0x70(%rbx,%rdx,8)
movupd %xmm1,-0x60(%rbx,%rdx,8)
movupd %xmm0,-0x50(%r14,%rdx,8)
movupd %xmm0,-0x40(%r14,%rdx,8)
movupd %xmm1,-0x50(%rbx,%rdx,8)
movupd %xmm1,-0x40(%rbx,%rdx,8)
movupd %xmm0,-0x30(%r14,%rdx,8)
movupd %xmm0,-0x20(%r14,%rdx,8)
movupd %xmm1,-0x30(%rbx,%rdx,8)
movupd %xmm1,-0x20(%rbx,%rdx,8)
movupd %xmm0,-0x10(%r14,%rdx,8)
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,-0x10(%rbx,%rdx,8)
movupd %xmm1,(%rbx,%rdx,8)
add    $0x14,%rdx
cmp    $0x1e8492,%rdx
jne    1540 <main+0x400>
cmp    %rcx,%r14
jae    1651 <main+0x511>
cmp    %rax,%rbx
jae    1651 <main+0x511>
mov    $0x4,%eax
movsd  0xa62(%rip),%xmm0
xchg   %ax,%ax
movsd  -0x20(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x20(%r14,%rax,8)
movsd  -0x18(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x18(%r14,%rax,8)
movsd  -0x10(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x10(%r14,%rax,8)
movsd  -0x8(%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r14,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x5,%rax
cmp    $0x1e8484,%rax
jne    15f0 <main+0x4b0>
jmp    16ae <main+0x56e>
mov    $0x6,%eax
movapd 0x9e2(%rip),%xmm0
xchg   %ax,%ax
movupd -0x30(%rbx,%rax,8),%xmm1
movupd -0x20(%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%r14,%rax,8)
movupd %xmm2,-0x20(%r14,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm1
movupd (%rbx,%rax,8),%xmm2
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%r14,%rax,8)
movupd %xmm2,(%r14,%rax,8)
add    $0x8,%rax
cmp    $0x1e8486,%rax
jne    1660 <main+0x520>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
lea    0xf42400(%r14),%rdi
lea    0xf42400(%r15),%r9
lea    0xf42400(%rax),%r8
cmp    %r9,%r14
setb   %r11b
cmp    %rdi,%r15
setb   %al
cmp    %r8,%r14
setb   %dl
cmp    %rdi,%rbx
setb   %r10b
cmp    %r8,%r15
setb   %cl
cmp    %r9,%rbx
setb   %sil
test   %al,%r11b
jne    17bc <main+0x67c>
and    %r10b,%dl
jne    17bc <main+0x67c>
and    %sil,%cl
jne    17bc <main+0x67c>
mov    $0x6,%esi
movapd 0x8b7(%rip),%xmm0
movapd 0x8bf(%rip),%xmm1
movapd 0x8c7(%rip),%xmm2
nopl   0x0(%rax)
movupd %xmm0,-0x30(%r14,%rsi,8)
movupd %xmm0,-0x20(%r14,%rsi,8)
movupd %xmm1,-0x30(%r15,%rsi,8)
movupd %xmm1,-0x20(%r15,%rsi,8)
movupd %xmm2,-0x30(%rbx,%rsi,8)
movupd %xmm2,-0x20(%rbx,%rsi,8)
movupd %xmm0,-0x10(%r14,%rsi,8)
movupd %xmm0,(%r14,%rsi,8)
movupd %xmm1,-0x10(%r15,%rsi,8)
movupd %xmm1,(%r15,%rsi,8)
movupd %xmm2,-0x10(%rbx,%rsi,8)
movupd %xmm2,(%rbx,%rsi,8)
add    $0x8,%rsi
cmp    $0x1e8486,%rsi
jne    1760 <main+0x620>
jmp    17f8 <main+0x6b8>
mov    $0x1,%esi
movabs $0x3ff07ae147ae147b,%rax
7a f0 3f
nopl   0x0(%rax,%rax,1)
mov    %r13,-0x8(%r14,%rsi,8)
mov    %rbp,-0x8(%r15,%rsi,8)
mov    %rax,-0x8(%rbx,%rsi,8)
mov    %r13,(%r14,%rsi,8)
mov    %rbp,(%r15,%rsi,8)
mov    %rax,(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    $0x1e8481,%rsi
jne    17d0 <main+0x690>
cmp    %r9,%r14
setb   %dl
cmp    %rdi,%r15
setb   %cl
cmp    %r8,%r14
setb   %al
cmp    %rdi,%rbx
setb   %sil
test   %cl,%dl
jne    188b <main+0x74b>
and    %sil,%al
jne    188b <main+0x74b>
mov    $0x6,%eax
nop
movupd -0x30(%r15,%rax,8),%xmm0
movupd -0x20(%r15,%rax,8),%xmm1
movupd -0x30(%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd -0x20(%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r14,%rax,8)
movupd %xmm0,-0x20(%r14,%rax,8)
movupd -0x10(%r15,%rax,8),%xmm0
movupd (%r15,%rax,8),%xmm1
movupd -0x10(%rbx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd (%rbx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r14,%rax,8)
movupd %xmm0,(%r14,%rax,8)
add    $0x8,%rax
cmp    $0x1e8486,%rax
jne    1820 <main+0x6e0>
jmp    18e9 <main+0x7a9>
mov    $0x3,%eax
movsd  -0x18(%r15,%rax,8),%xmm0
addsd  -0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%r14,%rax,8)
movsd  -0x10(%r15,%rax,8),%xmm0
addsd  -0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r14,%rax,8)
movsd  -0x8(%r15,%rax,8),%xmm0
addsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rax,8)
movsd  (%r15,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x4,%rax
cmp    $0x1e8483,%rax
jne    1890 <main+0x750>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0xf42400,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
lea    0xf42400(%r14),%rax
lea    0xf42400(%rbx),%rcx
cmp    %rcx,%r14
jae    1982 <main+0x842>
cmp    %rax,%rbx
jae    1982 <main+0x842>
mov    $0x4,%edx
nopl   0x0(%rax,%rax,1)
mov    %r13,-0x20(%r14,%rdx,8)
mov    %rbp,-0x20(%rbx,%rdx,8)
mov    %r13,-0x18(%r14,%rdx,8)
mov    %rbp,-0x18(%rbx,%rdx,8)
mov    %r13,-0x10(%r14,%rdx,8)
mov    %rbp,-0x10(%rbx,%rdx,8)
mov    %r13,-0x8(%r14,%rdx,8)
mov    %rbp,-0x8(%rbx,%rdx,8)
mov    %r13,(%r14,%rdx,8)
mov    %rbp,(%rbx,%rdx,8)
add    $0x5,%rdx
cmp    $0x1e8484,%rdx
jne    1940 <main+0x800>
jmp    1a37 <main+0x8f7>
mov    $0x12,%edx
movapd 0x671(%rip),%xmm0
movapd 0x679(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x90(%r14,%rdx,8)
ff ff ff
movupd %xmm0,-0x80(%r14,%rdx,8)
movupd %xmm1,-0x90(%rbx,%rdx,8)
ff ff
movupd %xmm1,-0x80(%rbx,%rdx,8)
movupd %xmm0,-0x70(%r14,%rdx,8)
movupd %xmm0,-0x60(%r14,%rdx,8)
movupd %xmm1,-0x70(%rbx,%rdx,8)
movupd %xmm1,-0x60(%rbx,%rdx,8)
movupd %xmm0,-0x50(%r14,%rdx,8)
movupd %xmm0,-0x40(%r14,%rdx,8)
movupd %xmm1,-0x50(%rbx,%rdx,8)
movupd %xmm1,-0x40(%rbx,%rdx,8)
movupd %xmm0,-0x30(%r14,%rdx,8)
movupd %xmm0,-0x20(%r14,%rdx,8)
movupd %xmm1,-0x30(%rbx,%rdx,8)
movupd %xmm1,-0x20(%rbx,%rdx,8)
movupd %xmm0,-0x10(%r14,%rdx,8)
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,-0x10(%rbx,%rdx,8)
movupd %xmm1,(%rbx,%rdx,8)
add    $0x14,%rdx
cmp    $0x1e8492,%rdx
jne    19a0 <main+0x860>
cmp    %rcx,%r14
jae    1aa0 <main+0x960>
cmp    %rax,%rbx
jae    1aa0 <main+0x960>
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x20(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x20(%r14,%rax,8)
movsd  -0x18(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x18(%r14,%rax,8)
movsd  -0x10(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r14,%rax,8)
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x5,%rax
cmp    $0x1e8484,%rax
jne    1a50 <main+0x910>
jmp    1b36 <main+0x9f6>
mov    $0x12,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x90(%rbx,%rax,8),%xmm0
ff
movups -0x80(%rbx,%rax,8),%xmm1
movups %xmm0,-0x90(%r14,%rax,8)
ff ff
movups %xmm1,-0x80(%r14,%rax,8)
movups -0x70(%rbx,%rax,8),%xmm0
movups -0x60(%rbx,%rax,8),%xmm1
movups %xmm0,-0x70(%r14,%rax,8)
movups %xmm1,-0x60(%r14,%rax,8)
movups -0x50(%rbx,%rax,8),%xmm0
movups -0x40(%rbx,%rax,8),%xmm1
movups %xmm0,-0x50(%r14,%rax,8)
movups %xmm1,-0x40(%r14,%rax,8)
movups -0x30(%rbx,%rax,8),%xmm0
movups -0x20(%rbx,%rax,8),%xmm1
movups %xmm0,-0x30(%r14,%rax,8)
movups %xmm1,-0x20(%r14,%rax,8)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm1
movupd %xmm0,-0x10(%r14,%rax,8)
movupd %xmm1,(%r14,%rax,8)
add    $0x14,%rax
cmp    $0x1e8492,%rax
jne    1ab0 <main+0x970>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = tail call i64 @malloc(i32 16000000)
%4 = inttoptr i64 %3 to double*
%5 = inttoptr i64 %3 to i8*
%6 = tail call i64 @malloc(i32 16000000)
%7 = inttoptr i64 %6 to double*
%8 = inttoptr i64 %6 to i8*
%9 = tail call i64 @malloc(i32 16000000)
%10 = inttoptr i64 %9 to double*
%11 = inttoptr i64 %9 to i8*
%12 = tail call i64 @malloc(i32 16000000)
%13 = inttoptr i64 %12 to double*
%14 = inttoptr i64 %12 to i8*
%15 = getelementptr double, double* %4, i64 2000000
%16 = bitcast double* %15 to i8*
%17 = getelementptr double, double* %7, i64 2000000
%18 = bitcast double* %17 to i8*
%19 = getelementptr double, double* %10, i64 2000000
%20 = bitcast double* %19 to i8*
%21 = getelementptr double, double* %13, i64 2000000
%22 = bitcast double* %21 to i8*
%23 = icmp ult i8* %5, %18
%24 = icmp ult i8* %8, %16
%25 = and i1 %23, %24
%26 = icmp ult i8* %5, %20
%27 = icmp ult i8* %11, %16
%28 = and i1 %26, %27
%29 = or i1 %25, %28
%30 = icmp ult i8* %5, %22
%31 = icmp ult i8* %14, %16
%32 = and i1 %30, %31
%33 = or i1 %29, %32
%34 = icmp ult i8* %8, %20
%35 = icmp ult i8* %11, %18
%36 = and i1 %34, %35
%37 = or i1 %33, %36
%38 = icmp ult i8* %8, %22
%39 = icmp ult i8* %14, %18
%40 = and i1 %38, %39
%41 = or i1 %37, %40
%42 = icmp ult i8* %11, %22
%43 = icmp ult i8* %14, %20
%44 = and i1 %42, %43
%45 = or i1 %41, %44
br i1 %45, label %157, label %46
46: ; preds = %2, %46
%47 = phi i64 [ %81, %46 ], [ 0, %2 ]
%48 = getelementptr inbounds double, double* %4, i64 %47
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %49
%50 = getelementptr inbounds double, double* %48, i64 2
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %51
%52 = getelementptr inbounds double, double* %7, i64 %47
%53 = bitcast double* %52 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %53
%54 = getelementptr inbounds double, double* %52, i64 2
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %55
%56 = getelementptr inbounds double, double* %10, i64 %47
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %59
%60 = getelementptr inbounds double, double* %13, i64 %47
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> <double 1.040000e+00, double 1.040000e+00>, <2 x double>* %61
%62 = getelementptr inbounds double, double* %60, i64 2
%63 = bitcast double* %62 to <2 x double>*
store <2 x double> <double 1.040000e+00, double 1.040000e+00>, <2 x double>* %63
%64 = or i64 %47, 4
%65 = getelementptr inbounds double, double* %4, i64 %64
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %66
%67 = getelementptr inbounds double, double* %65, i64 2
%68 = bitcast double* %67 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %68
%69 = getelementptr inbounds double, double* %7, i64 %64
%70 = bitcast double* %69 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %70
%71 = getelementptr inbounds double, double* %69, i64 2
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %72
%73 = getelementptr inbounds double, double* %10, i64 %64
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %74
%75 = getelementptr inbounds double, double* %73, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %76
%77 = getelementptr inbounds double, double* %13, i64 %64
%78 = bitcast double* %77 to <2 x double>*
store <2 x double> <double 1.040000e+00, double 1.040000e+00>, <2 x double>* %78
%79 = getelementptr inbounds double, double* %77, i64 2
%80 = bitcast double* %79 to <2 x double>*
store <2 x double> <double 1.040000e+00, double 1.040000e+00>, <2 x double>* %80
%81 = add nuw nsw i64 %47, 8
%82 = icmp eq i64 %81, 2000000
br i1 %82, label %83, label %46
83: ; preds = %46, %157
%84 = tail call i32 (...) @_magic_pin_start()
%85 = getelementptr double, double* %4, i64 2000000
%86 = bitcast double* %85 to i8*
%87 = getelementptr double, double* %7, i64 2000000
%88 = bitcast double* %87 to i8*
%89 = getelementptr double, double* %10, i64 2000000
%90 = bitcast double* %89 to i8*
%91 = getelementptr double, double* %13, i64 2000000
%92 = bitcast double* %91 to i8*
%93 = icmp ult i8* %5, %88
%94 = icmp ult i8* %8, %86
%95 = and i1 %93, %94
%96 = icmp ult i8* %5, %90
%97 = icmp ult i8* %11, %86
%98 = and i1 %96, %97
%99 = or i1 %95, %98
%100 = icmp ult i8* %5, %92
%101 = icmp ult i8* %14, %86
%102 = and i1 %100, %101
%103 = or i1 %99, %102
br i1 %103, label %237, label %104
104: ; preds = %83, %104
%105 = phi i64 [ %155, %104 ], [ 0, %83 ]
%106 = getelementptr inbounds double, double* %7, i64 %105
%107 = bitcast double* %106 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = getelementptr inbounds double, double* %106, i64 2
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = getelementptr inbounds double, double* %10, i64 %105
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %112, i64 2
%116 = bitcast double* %115 to <2 x double>*
%117 = load <2 x double>, <2 x double>* %116
%118 = getelementptr inbounds double, double* %13, i64 %105
%119 = bitcast double* %118 to <2 x double>*
%120 = load <2 x double>, <2 x double>* %119
%121 = getelementptr inbounds double, double* %118, i64 2
%122 = bitcast double* %121 to <2 x double>*
%123 = load <2 x double>, <2 x double>* %122
%124 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %114, <2 x double> %120, <2 x double> %108)
%125 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %117, <2 x double> %123, <2 x double> %111)
%126 = getelementptr inbounds double, double* %4, i64 %105
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> %124, <2 x double>* %127
%128 = getelementptr inbounds double, double* %126, i64 2
%129 = bitcast double* %128 to <2 x double>*
store <2 x double> %125, <2 x double>* %129
%130 = or i64 %105, 4
%131 = getelementptr inbounds double, double* %7, i64 %130
%132 = bitcast double* %131 to <2 x double>*
%133 = load <2 x double>, <2 x double>* %132
%134 = getelementptr inbounds double, double* %131, i64 2
%135 = bitcast double* %134 to <2 x double>*
%136 = load <2 x double>, <2 x double>* %135
%137 = getelementptr inbounds double, double* %10, i64 %130
%138 = bitcast double* %137 to <2 x double>*
%139 = load <2 x double>, <2 x double>* %138
%140 = getelementptr inbounds double, double* %137, i64 2
%141 = bitcast double* %140 to <2 x double>*
%142 = load <2 x double>, <2 x double>* %141
%143 = getelementptr inbounds double, double* %13, i64 %130
%144 = bitcast double* %143 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr inbounds double, double* %143, i64 2
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %139, <2 x double> %145, <2 x double> %133)
%150 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %142, <2 x double> %148, <2 x double> %136)
%151 = getelementptr inbounds double, double* %4, i64 %130
%152 = bitcast double* %151 to <2 x double>*
store <2 x double> %149, <2 x double>* %152
%153 = getelementptr inbounds double, double* %151, i64 2
%154 = bitcast double* %153 to <2 x double>*
store <2 x double> %150, <2 x double>* %154
%155 = add nuw nsw i64 %105, 8
%156 = icmp eq i64 %155, 2000000
br i1 %156, label %170, label %104
157: ; preds = %2, %157
%158 = phi i64 [ %168, %157 ], [ 0, %2 ]
%159 = getelementptr inbounds double, double* %4, i64 %158
store double 1.010000e+00, double* %159
%160 = getelementptr inbounds double, double* %7, i64 %158
store double 1.020000e+00, double* %160
%161 = getelementptr inbounds double, double* %10, i64 %158
store double 1.030000e+00, double* %161
%162 = getelementptr inbounds double, double* %13, i64 %158
store double 1.040000e+00, double* %162
%163 = or i64 %158, 1
%164 = getelementptr inbounds double, double* %4, i64 %163
store double 1.010000e+00, double* %164
%165 = getelementptr inbounds double, double* %7, i64 %163
store double 1.020000e+00, double* %165
%166 = getelementptr inbounds double, double* %10, i64 %163
store double 1.030000e+00, double* %166
%167 = getelementptr inbounds double, double* %13, i64 %163
store double 1.040000e+00, double* %167
%168 = add nuw nsw i64 %158, 2
%169 = icmp eq i64 %168, 2000000
br i1 %169, label %83, label %157
170: ; preds = %104, %237
%171 = tail call i32 (...) @_magic_pin_stop()
%172 = tail call i32 @free(double* %4)
%173 = tail call i32 @free(double* %7)
%174 = tail call i32 @free(double* %10)
%175 = tail call i32 @free(double* %13)
%176 = tail call i64 @malloc(i32 16000000)
%177 = inttoptr i64 %176 to double*
%178 = inttoptr i64 %176 to i8*
%179 = tail call i64 @malloc(i32 16000000)
%180 = inttoptr i64 %179 to double*
%181 = inttoptr i64 %179 to i8*
%182 = getelementptr double, double* %177, i64 2000000
%183 = bitcast double* %182 to i8*
%184 = getelementptr double, double* %180, i64 2000000
%185 = bitcast double* %184 to i8*
%186 = icmp ult i8* %178, %185
%187 = icmp ult i8* %181, %183
%188 = and i1 %186, %187
br i1 %188, label %258, label %189
189: ; preds = %170, %189
%190 = phi i64 [ %235, %189 ], [ 0, %170 ]
%191 = getelementptr inbounds double, double* %177, i64 %190
%192 = bitcast double* %191 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %192
%193 = getelementptr inbounds double, double* %191, i64 2
%194 = bitcast double* %193 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %194
%195 = getelementptr inbounds double, double* %180, i64 %190
%196 = bitcast double* %195 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %196
%197 = getelementptr inbounds double, double* %195, i64 2
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %198
%199 = add nuw nsw i64 %190, 4
%200 = getelementptr inbounds double, double* %177, i64 %199
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %201
%202 = getelementptr inbounds double, double* %200, i64 2
%203 = bitcast double* %202 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %203
%204 = getelementptr inbounds double, double* %180, i64 %199
%205 = bitcast double* %204 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %205
%206 = getelementptr inbounds double, double* %204, i64 2
%207 = bitcast double* %206 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %207
%208 = add nuw nsw i64 %190, 8
%209 = getelementptr inbounds double, double* %177, i64 %208
%210 = bitcast double* %209 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %210
%211 = getelementptr inbounds double, double* %209, i64 2
%212 = bitcast double* %211 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %212
%213 = getelementptr inbounds double, double* %180, i64 %208
%214 = bitcast double* %213 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %214
%215 = getelementptr inbounds double, double* %213, i64 2
%216 = bitcast double* %215 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %216
%217 = add nuw nsw i64 %190, 12
%218 = getelementptr inbounds double, double* %177, i64 %217
%219 = bitcast double* %218 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %219
%220 = getelementptr inbounds double, double* %218, i64 2
%221 = bitcast double* %220 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %221
%222 = getelementptr inbounds double, double* %180, i64 %217
%223 = bitcast double* %222 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %223
%224 = getelementptr inbounds double, double* %222, i64 2
%225 = bitcast double* %224 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %225
%226 = add nuw nsw i64 %190, 16
%227 = getelementptr inbounds double, double* %177, i64 %226
%228 = bitcast double* %227 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %228
%229 = getelementptr inbounds double, double* %227, i64 2
%230 = bitcast double* %229 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %230
%231 = getelementptr inbounds double, double* %180, i64 %226
%232 = bitcast double* %231 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %232
%233 = getelementptr inbounds double, double* %231, i64 2
%234 = bitcast double* %233 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %234
%235 = add nuw nsw i64 %190, 20
%236 = icmp eq i64 %235, 2000000
br i1 %236, label %276, label %189
237: ; preds = %83, %237
%238 = phi i64 [ %256, %237 ], [ 0, %83 ]
%239 = getelementptr inbounds double, double* %7, i64 %238
%240 = load double, double* %239
%241 = getelementptr inbounds double, double* %10, i64 %238
%242 = load double, double* %241
%243 = getelementptr inbounds double, double* %13, i64 %238
%244 = load double, double* %243
%245 = tail call double @llvm.fmuladd.f64(double %242, double %244, double %240)
%246 = getelementptr inbounds double, double* %4, i64 %238
store double %245, double* %246
%247 = or i64 %238, 1
%248 = getelementptr inbounds double, double* %7, i64 %247
%249 = load double, double* %248
%250 = getelementptr inbounds double, double* %10, i64 %247
%251 = load double, double* %250
%252 = getelementptr inbounds double, double* %13, i64 %247
%253 = load double, double* %252
%254 = tail call double @llvm.fmuladd.f64(double %251, double %253, double %249)
%255 = getelementptr inbounds double, double* %4, i64 %247
store double %254, double* %255
%256 = add nuw nsw i64 %238, 2
%257 = icmp eq i64 %256, 2000000
br i1 %257, label %170, label %237
258: ; preds = %170, %258
%259 = phi i64 [ %274, %258 ], [ 0, %170 ]
%260 = getelementptr inbounds double, double* %177, i64 %259
store double 1.010000e+00, double* %260
%261 = getelementptr inbounds double, double* %180, i64 %259
store double 1.020000e+00, double* %261
%262 = add nuw nsw i64 %259, 1
%263 = getelementptr inbounds double, double* %177, i64 %262
store double 1.010000e+00, double* %263
%264 = getelementptr inbounds double, double* %180, i64 %262
store double 1.020000e+00, double* %264
%265 = add nuw nsw i64 %259, 2
%266 = getelementptr inbounds double, double* %177, i64 %265
store double 1.010000e+00, double* %266
%267 = getelementptr inbounds double, double* %180, i64 %265
store double 1.020000e+00, double* %267
%268 = add nuw nsw i64 %259, 3
%269 = getelementptr inbounds double, double* %177, i64 %268
store double 1.010000e+00, double* %269
%270 = getelementptr inbounds double, double* %180, i64 %268
store double 1.020000e+00, double* %270
%271 = add nuw nsw i64 %259, 4
%272 = getelementptr inbounds double, double* %177, i64 %271
store double 1.010000e+00, double* %272
%273 = getelementptr inbounds double, double* %180, i64 %271
store double 1.020000e+00, double* %273
%274 = add nuw nsw i64 %259, 5
%275 = icmp eq i64 %274, 2000000
br i1 %275, label %276, label %258
276: ; preds = %189, %258
%277 = getelementptr double, double* %177, i64 2000000
%278 = bitcast double* %277 to i8*
%279 = getelementptr double, double* %180, i64 2000000
%280 = bitcast double* %279 to i8*
%281 = icmp ult i8* %178, %280
%282 = icmp ult i8* %181, %278
%283 = and i1 %281, %282
br i1 %283, label %371, label %284
284: ; preds = %276, %284
%285 = phi i64 [ %311, %284 ], [ 0, %276 ]
%286 = getelementptr inbounds double, double* %180, i64 %285
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = getelementptr inbounds double, double* %286, i64 2
%290 = bitcast double* %289 to <2 x double>*
%291 = load <2 x double>, <2 x double>* %290
%292 = fmul <2 x double> %288, <double 0x3FEF5C28F5C28F5C, double 0x3FEF5C28F5C28F5C>
%293 = fmul <2 x double> %291, <double 0x3FEF5C28F5C28F5C, double 0x3FEF5C28F5C28F5C>
%294 = getelementptr inbounds double, double* %177, i64 %285
%295 = bitcast double* %294 to <2 x double>*
store <2 x double> %292, <2 x double>* %295
%296 = getelementptr inbounds double, double* %294, i64 2
%297 = bitcast double* %296 to <2 x double>*
store <2 x double> %293, <2 x double>* %297
%298 = or i64 %285, 4
%299 = getelementptr inbounds double, double* %180, i64 %298
%300 = bitcast double* %299 to <2 x double>*
%301 = load <2 x double>, <2 x double>* %300
%302 = getelementptr inbounds double, double* %299, i64 2
%303 = bitcast double* %302 to <2 x double>*
%304 = load <2 x double>, <2 x double>* %303
%305 = fmul <2 x double> %301, <double 0x3FEF5C28F5C28F5C, double 0x3FEF5C28F5C28F5C>
%306 = fmul <2 x double> %304, <double 0x3FEF5C28F5C28F5C, double 0x3FEF5C28F5C28F5C>
%307 = getelementptr inbounds double, double* %177, i64 %298
%308 = bitcast double* %307 to <2 x double>*
store <2 x double> %305, <2 x double>* %308
%309 = getelementptr inbounds double, double* %307, i64 2
%310 = bitcast double* %309 to <2 x double>*
store <2 x double> %306, <2 x double>* %310
%311 = add nuw nsw i64 %285, 8
%312 = icmp eq i64 %311, 2000000
br i1 %312, label %313, label %284
313: ; preds = %284, %371
%314 = tail call i32 @free(double* %177)
%315 = tail call i32 @free(double* %180)
%316 = tail call i64 @malloc(i32 16000000)
%317 = inttoptr i64 %316 to double*
%318 = inttoptr i64 %316 to i8*
%319 = tail call i64 @malloc(i32 16000000)
%320 = inttoptr i64 %319 to double*
%321 = inttoptr i64 %319 to i8*
%322 = tail call i64 @malloc(i32 16000000)
%323 = inttoptr i64 %322 to double*
%324 = inttoptr i64 %322 to i8*
%325 = getelementptr double, double* %317, i64 2000000
%326 = bitcast double* %325 to i8*
%327 = getelementptr double, double* %320, i64 2000000
%328 = bitcast double* %327 to i8*
%329 = getelementptr double, double* %323, i64 2000000
%330 = bitcast double* %329 to i8*
%331 = icmp ult i8* %318, %328
%332 = icmp ult i8* %321, %326
%333 = and i1 %331, %332
%334 = icmp ult i8* %318, %330
%335 = icmp ult i8* %324, %326
%336 = and i1 %334, %335
%337 = or i1 %333, %336
%338 = icmp ult i8* %321, %330
%339 = icmp ult i8* %324, %328
%340 = and i1 %338, %339
%341 = or i1 %337, %340
br i1 %341, label %399, label %342
342: ; preds = %313, %342
%343 = phi i64 [ %369, %342 ], [ 0, %313 ]
%344 = getelementptr inbounds double, double* %317, i64 %343
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %345
%346 = getelementptr inbounds double, double* %344, i64 2
%347 = bitcast double* %346 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %347
%348 = getelementptr inbounds double, double* %320, i64 %343
%349 = bitcast double* %348 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %349
%350 = getelementptr inbounds double, double* %348, i64 2
%351 = bitcast double* %350 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %351
%352 = getelementptr inbounds double, double* %323, i64 %343
%353 = bitcast double* %352 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %353
%354 = getelementptr inbounds double, double* %352, i64 2
%355 = bitcast double* %354 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %355
%356 = or i64 %343, 4
%357 = getelementptr inbounds double, double* %317, i64 %356
%358 = bitcast double* %357 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %358
%359 = getelementptr inbounds double, double* %357, i64 2
%360 = bitcast double* %359 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %360
%361 = getelementptr inbounds double, double* %320, i64 %356
%362 = bitcast double* %361 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %362
%363 = getelementptr inbounds double, double* %361, i64 2
%364 = bitcast double* %363 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %364
%365 = getelementptr inbounds double, double* %323, i64 %356
%366 = bitcast double* %365 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %366
%367 = getelementptr inbounds double, double* %365, i64 2
%368 = bitcast double* %367 to <2 x double>*
store <2 x double> <double 1.030000e+00, double 1.030000e+00>, <2 x double>* %368
%369 = add nuw nsw i64 %343, 8
%370 = icmp eq i64 %369, 2000000
br i1 %370, label %410, label %342
371: ; preds = %276, %371
%372 = phi i64 [ %397, %371 ], [ 0, %276 ]
%373 = getelementptr inbounds double, double* %180, i64 %372
%374 = load double, double* %373
%375 = fmul double %374, 0x3FEF5C28F5C28F5C
%376 = getelementptr inbounds double, double* %177, i64 %372
store double %375, double* %376
%377 = add nuw nsw i64 %372, 1
%378 = getelementptr inbounds double, double* %180, i64 %377
%379 = load double, double* %378
%380 = fmul double %379, 0x3FEF5C28F5C28F5C
%381 = getelementptr inbounds double, double* %177, i64 %377
store double %380, double* %381
%382 = add nuw nsw i64 %372, 2
%383 = getelementptr inbounds double, double* %180, i64 %382
%384 = load double, double* %383
%385 = fmul double %384, 0x3FEF5C28F5C28F5C
%386 = getelementptr inbounds double, double* %177, i64 %382
store double %385, double* %386
%387 = add nuw nsw i64 %372, 3
%388 = getelementptr inbounds double, double* %180, i64 %387
%389 = load double, double* %388
%390 = fmul double %389, 0x3FEF5C28F5C28F5C
%391 = getelementptr inbounds double, double* %177, i64 %387
store double %390, double* %391
%392 = add nuw nsw i64 %372, 4
%393 = getelementptr inbounds double, double* %180, i64 %392
%394 = load double, double* %393
%395 = fmul double %394, 0x3FEF5C28F5C28F5C
%396 = getelementptr inbounds double, double* %177, i64 %392
store double %395, double* %396
%397 = add nuw nsw i64 %372, 5
%398 = icmp eq i64 %397, 2000000
br i1 %398, label %313, label %371
399: ; preds = %313, %399
%400 = phi i64 [ %408, %399 ], [ 0, %313 ]
%401 = getelementptr inbounds double, double* %317, i64 %400
store double 1.010000e+00, double* %401
%402 = getelementptr inbounds double, double* %320, i64 %400
store double 1.020000e+00, double* %402
%403 = getelementptr inbounds double, double* %323, i64 %400
store double 1.030000e+00, double* %403
%404 = or i64 %400, 1
%405 = getelementptr inbounds double, double* %317, i64 %404
store double 1.010000e+00, double* %405
%406 = getelementptr inbounds double, double* %320, i64 %404
store double 1.020000e+00, double* %406
%407 = getelementptr inbounds double, double* %323, i64 %404
store double 1.030000e+00, double* %407
%408 = add nuw nsw i64 %400, 2
%409 = icmp eq i64 %408, 2000000
br i1 %409, label %410, label %399
410: ; preds = %342, %399
%411 = getelementptr double, double* %317, i64 2000000
%412 = bitcast double* %411 to i8*
%413 = getelementptr double, double* %320, i64 2000000
%414 = bitcast double* %413 to i8*
%415 = getelementptr double, double* %323, i64 2000000
%416 = bitcast double* %415 to i8*
%417 = icmp ult i8* %318, %414
%418 = icmp ult i8* %321, %412
%419 = and i1 %417, %418
%420 = icmp ult i8* %318, %416
%421 = icmp ult i8* %324, %412
%422 = and i1 %420, %421
%423 = or i1 %419, %422
br i1 %423, label %530, label %424
424: ; preds = %410, %424
%425 = phi i64 [ %463, %424 ], [ 0, %410 ]
%426 = getelementptr inbounds double, double* %320, i64 %425
%427 = bitcast double* %426 to <2 x double>*
%428 = load <2 x double>, <2 x double>* %427
%429 = getelementptr inbounds double, double* %426, i64 2
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = getelementptr inbounds double, double* %323, i64 %425
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = getelementptr inbounds double, double* %432, i64 2
%436 = bitcast double* %435 to <2 x double>*
%437 = load <2 x double>, <2 x double>* %436
%438 = fadd <2 x double> %428, %434
%439 = fadd <2 x double> %431, %437
%440 = getelementptr inbounds double, double* %317, i64 %425
%441 = bitcast double* %440 to <2 x double>*
store <2 x double> %438, <2 x double>* %441
%442 = getelementptr inbounds double, double* %440, i64 2
%443 = bitcast double* %442 to <2 x double>*
store <2 x double> %439, <2 x double>* %443
%444 = or i64 %425, 4
%445 = getelementptr inbounds double, double* %320, i64 %444
%446 = bitcast double* %445 to <2 x double>*
%447 = load <2 x double>, <2 x double>* %446
%448 = getelementptr inbounds double, double* %445, i64 2
%449 = bitcast double* %448 to <2 x double>*
%450 = load <2 x double>, <2 x double>* %449
%451 = getelementptr inbounds double, double* %323, i64 %444
%452 = bitcast double* %451 to <2 x double>*
%453 = load <2 x double>, <2 x double>* %452
%454 = getelementptr inbounds double, double* %451, i64 2
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = fadd <2 x double> %447, %453
%458 = fadd <2 x double> %450, %456
%459 = getelementptr inbounds double, double* %317, i64 %444
%460 = bitcast double* %459 to <2 x double>*
store <2 x double> %457, <2 x double>* %460
%461 = getelementptr inbounds double, double* %459, i64 2
%462 = bitcast double* %461 to <2 x double>*
store <2 x double> %458, <2 x double>* %462
%463 = add nuw nsw i64 %425, 8
%464 = icmp eq i64 %463, 2000000
br i1 %464, label %465, label %424
465: ; preds = %424, %530
%466 = tail call i32 @free(double* %317)
%467 = tail call i32 @free(double* %320)
%468 = tail call i32 @free(double* %323)
%469 = tail call i64 @malloc(i32 16000000)
%470 = inttoptr i64 %469 to double*
%471 = inttoptr i64 %469 to i8*
%472 = tail call i64 @malloc(i32 16000000)
%473 = inttoptr i64 %472 to double*
%474 = inttoptr i64 %472 to i8*
%475 = getelementptr double, double* %470, i64 2000000
%476 = bitcast double* %475 to i8*
%477 = getelementptr double, double* %473, i64 2000000
%478 = bitcast double* %477 to i8*
%479 = icmp ult i8* %471, %478
%480 = icmp ult i8* %474, %476
%481 = and i1 %479, %480
br i1 %481, label %561, label %482
482: ; preds = %465, %482
%483 = phi i64 [ %528, %482 ], [ 0, %465 ]
%484 = getelementptr inbounds double, double* %470, i64 %483
%485 = bitcast double* %484 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %485
%486 = getelementptr inbounds double, double* %484, i64 2
%487 = bitcast double* %486 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %487
%488 = getelementptr inbounds double, double* %473, i64 %483
%489 = bitcast double* %488 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %489
%490 = getelementptr inbounds double, double* %488, i64 2
%491 = bitcast double* %490 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %491
%492 = add nuw nsw i64 %483, 4
%493 = getelementptr inbounds double, double* %470, i64 %492
%494 = bitcast double* %493 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %494
%495 = getelementptr inbounds double, double* %493, i64 2
%496 = bitcast double* %495 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %496
%497 = getelementptr inbounds double, double* %473, i64 %492
%498 = bitcast double* %497 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %498
%499 = getelementptr inbounds double, double* %497, i64 2
%500 = bitcast double* %499 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %500
%501 = add nuw nsw i64 %483, 8
%502 = getelementptr inbounds double, double* %470, i64 %501
%503 = bitcast double* %502 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %503
%504 = getelementptr inbounds double, double* %502, i64 2
%505 = bitcast double* %504 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %505
%506 = getelementptr inbounds double, double* %473, i64 %501
%507 = bitcast double* %506 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %507
%508 = getelementptr inbounds double, double* %506, i64 2
%509 = bitcast double* %508 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %509
%510 = add nuw nsw i64 %483, 12
%511 = getelementptr inbounds double, double* %470, i64 %510
%512 = bitcast double* %511 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %512
%513 = getelementptr inbounds double, double* %511, i64 2
%514 = bitcast double* %513 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %514
%515 = getelementptr inbounds double, double* %473, i64 %510
%516 = bitcast double* %515 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %516
%517 = getelementptr inbounds double, double* %515, i64 2
%518 = bitcast double* %517 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %518
%519 = add nuw nsw i64 %483, 16
%520 = getelementptr inbounds double, double* %470, i64 %519
%521 = bitcast double* %520 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %521
%522 = getelementptr inbounds double, double* %520, i64 2
%523 = bitcast double* %522 to <2 x double>*
store <2 x double> <double 1.010000e+00, double 1.010000e+00>, <2 x double>* %523
%524 = getelementptr inbounds double, double* %473, i64 %519
%525 = bitcast double* %524 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %525
%526 = getelementptr inbounds double, double* %524, i64 2
%527 = bitcast double* %526 to <2 x double>*
store <2 x double> <double 1.020000e+00, double 1.020000e+00>, <2 x double>* %527
%528 = add nuw nsw i64 %483, 20
%529 = icmp eq i64 %528, 2000000
br i1 %529, label %579, label %482
530: ; preds = %410, %530
%531 = phi i64 [ %559, %530 ], [ 0, %410 ]
%532 = getelementptr inbounds double, double* %320, i64 %531
%533 = load double, double* %532
%534 = getelementptr inbounds double, double* %323, i64 %531
%535 = load double, double* %534
%536 = fadd double %533, %535
%537 = getelementptr inbounds double, double* %317, i64 %531
store double %536, double* %537
%538 = or i64 %531, 1
%539 = getelementptr inbounds double, double* %320, i64 %538
%540 = load double, double* %539
%541 = getelementptr inbounds double, double* %323, i64 %538
%542 = load double, double* %541
%543 = fadd double %540, %542
%544 = getelementptr inbounds double, double* %317, i64 %538
store double %543, double* %544
%545 = or i64 %531, 2
%546 = getelementptr inbounds double, double* %320, i64 %545
%547 = load double, double* %546
%548 = getelementptr inbounds double, double* %323, i64 %545
%549 = load double, double* %548
%550 = fadd double %547, %549
%551 = getelementptr inbounds double, double* %317, i64 %545
store double %550, double* %551
%552 = or i64 %531, 3
%553 = getelementptr inbounds double, double* %320, i64 %552
%554 = load double, double* %553
%555 = getelementptr inbounds double, double* %323, i64 %552
%556 = load double, double* %555
%557 = fadd double %554, %556
%558 = getelementptr inbounds double, double* %317, i64 %552
store double %557, double* %558
%559 = add nuw nsw i64 %531, 4
%560 = icmp eq i64 %559, 2000000
br i1 %560, label %465, label %530
561: ; preds = %465, %561
%562 = phi i64 [ %577, %561 ], [ 0, %465 ]
%563 = getelementptr inbounds double, double* %470, i64 %562
store double 1.010000e+00, double* %563
%564 = getelementptr inbounds double, double* %473, i64 %562
store double 1.020000e+00, double* %564
%565 = add nuw nsw i64 %562, 1
%566 = getelementptr inbounds double, double* %470, i64 %565
store double 1.010000e+00, double* %566
%567 = getelementptr inbounds double, double* %473, i64 %565
store double 1.020000e+00, double* %567
%568 = add nuw nsw i64 %562, 2
%569 = getelementptr inbounds double, double* %470, i64 %568
store double 1.010000e+00, double* %569
%570 = getelementptr inbounds double, double* %473, i64 %568
store double 1.020000e+00, double* %570
%571 = add nuw nsw i64 %562, 3
%572 = getelementptr inbounds double, double* %470, i64 %571
store double 1.010000e+00, double* %572
%573 = getelementptr inbounds double, double* %473, i64 %571
store double 1.020000e+00, double* %573
%574 = add nuw nsw i64 %562, 4
%575 = getelementptr inbounds double, double* %470, i64 %574
store double 1.010000e+00, double* %575
%576 = getelementptr inbounds double, double* %473, i64 %574
store double 1.020000e+00, double* %576
%577 = add nuw nsw i64 %562, 5
%578 = icmp eq i64 %577, 2000000
br i1 %578, label %579, label %561
579: ; preds = %482, %561
%580 = getelementptr double, double* %470, i64 2000000
%581 = bitcast double* %580 to i8*
%582 = getelementptr double, double* %473, i64 2000000
%583 = bitcast double* %582 to i8*
%584 = icmp ult i8* %471, %583
%585 = icmp ult i8* %474, %581
%586 = and i1 %584, %585
br i1 %586, label %648, label %587
587: ; preds = %579, %587
%588 = phi i64 [ %643, %587 ], [ 0, %579 ]
%589 = getelementptr inbounds double, double* %473, i64 %588
%590 = bitcast double* %589 to <2 x double>*
%591 = load <2 x double>, <2 x double>* %590
%592 = getelementptr inbounds double, double* %589, i64 2
%593 = bitcast double* %592 to <2 x double>*
%594 = load <2 x double>, <2 x double>* %593
%595 = getelementptr inbounds double, double* %470, i64 %588
%596 = bitcast double* %595 to <2 x double>*
store <2 x double> %591, <2 x double>* %596
%597 = getelementptr inbounds double, double* %595, i64 2
%598 = bitcast double* %597 to <2 x double>*
store <2 x double> %594, <2 x double>* %598
%599 = add nuw nsw i64 %588, 4
%600 = getelementptr inbounds double, double* %473, i64 %599
%601 = bitcast double* %600 to <2 x double>*
%602 = load <2 x double>, <2 x double>* %601
%603 = getelementptr inbounds double, double* %600, i64 2
%604 = bitcast double* %603 to <2 x double>*
%605 = load <2 x double>, <2 x double>* %604
%606 = getelementptr inbounds double, double* %470, i64 %599
%607 = bitcast double* %606 to <2 x double>*
store <2 x double> %602, <2 x double>* %607
%608 = getelementptr inbounds double, double* %606, i64 2
%609 = bitcast double* %608 to <2 x double>*
store <2 x double> %605, <2 x double>* %609
%610 = add nuw nsw i64 %588, 8
%611 = getelementptr inbounds double, double* %473, i64 %610
%612 = bitcast double* %611 to <2 x double>*
%613 = load <2 x double>, <2 x double>* %612
%614 = getelementptr inbounds double, double* %611, i64 2
%615 = bitcast double* %614 to <2 x double>*
%616 = load <2 x double>, <2 x double>* %615
%617 = getelementptr inbounds double, double* %470, i64 %610
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %613, <2 x double>* %618
%619 = getelementptr inbounds double, double* %617, i64 2
%620 = bitcast double* %619 to <2 x double>*
store <2 x double> %616, <2 x double>* %620
%621 = add nuw nsw i64 %588, 12
%622 = getelementptr inbounds double, double* %473, i64 %621
%623 = bitcast double* %622 to <2 x double>*
%624 = load <2 x double>, <2 x double>* %623
%625 = getelementptr inbounds double, double* %622, i64 2
%626 = bitcast double* %625 to <2 x double>*
%627 = load <2 x double>, <2 x double>* %626
%628 = getelementptr inbounds double, double* %470, i64 %621
%629 = bitcast double* %628 to <2 x double>*
store <2 x double> %624, <2 x double>* %629
%630 = getelementptr inbounds double, double* %628, i64 2
%631 = bitcast double* %630 to <2 x double>*
store <2 x double> %627, <2 x double>* %631
%632 = add nuw nsw i64 %588, 16
%633 = getelementptr inbounds double, double* %473, i64 %632
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %633, i64 2
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = getelementptr inbounds double, double* %470, i64 %632
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %635, <2 x double>* %640
%641 = getelementptr inbounds double, double* %639, i64 2
%642 = bitcast double* %641 to <2 x double>*
store <2 x double> %638, <2 x double>* %642
%643 = add nuw nsw i64 %588, 20
%644 = icmp eq i64 %643, 2000000
br i1 %644, label %645, label %587
645: ; preds = %587, %648
%646 = tail call i32 @free(double* %470)
%647 = tail call i32 @free(double* %473)
ret i32 0
648: ; preds = %579, %648
%649 = phi i64 [ %669, %648 ], [ 0, %579 ]
%650 = getelementptr inbounds double, double* %473, i64 %649
%651 = load double, double* %650
%652 = getelementptr inbounds double, double* %470, i64 %649
store double %651, double* %652
%653 = add nuw nsw i64 %649, 1
%654 = getelementptr inbounds double, double* %473, i64 %653
%655 = load double, double* %654
%656 = getelementptr inbounds double, double* %470, i64 %653
store double %655, double* %656
%657 = add nuw nsw i64 %649, 2
%658 = getelementptr inbounds double, double* %473, i64 %657
%659 = load double, double* %658
%660 = getelementptr inbounds double, double* %470, i64 %657
store double %659, double* %660
%661 = add nuw nsw i64 %649, 3
%662 = getelementptr inbounds double, double* %473, i64 %661
%663 = load double, double* %662
%664 = getelementptr inbounds double, double* %470, i64 %661
store double %663, double* %664
%665 = add nuw nsw i64 %649, 4
%666 = getelementptr inbounds double, double* %473, i64 %665
%667 = load double, double* %666
%668 = getelementptr inbounds double, double* %470, i64 %665
store double %667, double* %668
%669 = add nuw nsw i64 %649, 5
%670 = icmp eq i64 %669, 2000000
br i1 %670, label %645, label %648
}