#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*/ printf(char *, ...);
double sqrt(double);
void histogram_print(unsigned long long h[129][65]) {
  int i, j;
  unsigned long long n, N;
  double x, y, s, s2;
  double mean[65], variance[65], median[65];
  for (j = 0; j < 65; ++j)
    printf("; %d", j * 2 - 64);
  printf("; total; mean; error; bias; precision");
  for (i = 0; i < 129; ++i) {
    printf("\n%d", i - 64);
    n = s = s2 = 0;
    x = (i - 64);
    for (j = 0; j < 65; ++j) {
      y = 2 * j - 64;
      printf("; %lld", h[i][j]);
      n += h[i][j];
      s += y * h[i][j];
      s2 += (x - y) * (x - y) * h[i][j];
    }
    s /= n;
    s2 /= (n - 1);
    if (n > 5)
      printf("; %lld; %.2f; %.2f; %.2f; %.2f", n, s, sqrt(s2), x - s,
             sqrt(s2 - (x - s) * (x - s)));
    else if (n > 0)
      printf("; %lld; %.2f; %.2f", n, s, sqrt(s2));
    else
      printf("; %lld", n);
  }
  printf("\n");
  N = 0;
  printf("total");
  for (j = 0; j < 65; ++j) {
    n = s = s2 = 0;
    y = 2 * j - 64;
    for (i = 0; i < 129; ++i) {
      x = (i - 64);
      n += h[i][j];
      s += x * h[i][j];
      s2 += (x - y) * (x - y) * h[i][j];
    }
    N += n;
    mean[j] = s / n;
    variance[j] = s2 / (n - 1);
    s = 0;
    if ((n & 1) == 1) {
      for (i = 0; i < 129; ++i) {
        s += h[i][j];
        if (s >= (n + 1) / 2) {
          median[j] = i - 64;
          break;
        }
      }
    } else {
      for (i = 0; i < 129; ++i) {
        s += h[i][j];
        if (s == n / 2) {
          median[j] = i - 63.5;
          break;
        } else if (s > n / 2) {
          median[j] = i - 64;
          break;
        }
      }
    }
    printf("; %lld", n);
  }
  printf("; %lld\n", N);
  printf("mean");
  for (j = 0; j < 65; ++j)
    printf("; %.2f", mean[j]);
  printf("\n");
  printf("median");
  for (j = 0; j < 65; ++j)
    printf("; %.2f", median[j]);
  printf("\n");
  printf("error");
  for (j = 0; j < 65; ++j)
    printf("; %.2f", sqrt(variance[j]));
  printf("\n");
  printf("bias");
  for (j = 0; j < 65; ++j)
    printf("; %.2f", (2 * j - 64) - mean[j]);
  printf("\n");
  printf("precision");
  for (j = 0; j < 65; ++j) {
    x = (2 * j - 64) - mean[j];
    printf("; %.2f", sqrt(variance[j] - x * x));
  }
  printf("\n");
}


x86 assembly (clang, -O0):
<histogram_print>:
push   %rbp
mov    %rsp,%rbp
sub    $0x6a0,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    1165 <histogram_print+0x45>
mov    -0x10(%rbp),%esi
shl    $0x1,%esi
sub    $0x40,%esi
lea    0xed8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1136 <histogram_print+0x16>
lea    0xec1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xc(%rbp)
cmpl   $0x81,-0xc(%rbp)
jge    148e <histogram_print+0x36e>
mov    -0xc(%rbp),%esi
sub    $0x40,%esi
lea    0xebf(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    12f6 <histogram_print+0x1d6>
mov    -0x10(%rbp),%ecx
mov    %ecx,%eax
lea    -0x40(%rax,%rax,1),%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xe4d(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm4
movaps 0xd9b(%rip),%xmm3
punpckldq %xmm3,%xmm4
movapd 0xd9f(%rip),%xmm1
subpd  %xmm1,%xmm4
movaps %xmm4,%xmm2
unpckhpd %xmm4,%xmm4
addsd  %xmm2,%xmm4
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm2
punpckldq %xmm3,%xmm2
subpd  %xmm1,%xmm2
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c9 <histogram_print+0xa9>
movq   -0x18(%rbp),%xmm3
movaps 0xcfe(%rip),%xmm2
punpckldq %xmm2,%xmm3
movapd 0xd02(%rip),%xmm0
subpd  %xmm0,%xmm3
movaps %xmm3,%xmm1
unpckhpd %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  -0x38(%rbp),%xmm1
divsd  %xmm3,%xmm1
movsd  %xmm1,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
movq   %rax,%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
cmpq   $0x5,-0x18(%rbp)
jbe    1412 <histogram_print+0x2f2>
mov    -0x18(%rbp),%rax
mov    %rax,-0x690(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x678(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x688(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x680(%rbp)
ff
movsd  -0x40(%rbp),%xmm1
movsd  -0x28(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
subsd  -0x38(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
mov    -0x690(%rbp),%rsi
movsd  -0x688(%rbp),%xmm1
ff
movsd  -0x680(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x678(%rbp),%xmm0
ff
lea    0xc58(%rip),%rdi
mov    $0x4,%al
call   1030 <printf@plt>
jmp    147b <histogram_print+0x35b>
cmpq   $0x0,-0x18(%rbp)
jbe    1464 <histogram_print+0x344>
mov    -0x18(%rbp),%rax
mov    %rax,-0x6a0(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x698(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    -0x6a0(%rbp),%rsi
movaps %xmm0,%xmm1
movsd  -0x698(%rbp),%xmm0
ff
lea    0xc25(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    1476 <histogram_print+0x356>
mov    -0x18(%rbp),%rsi
lea    0xbe8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    147b <histogram_print+0x35b>
jmp    1480 <histogram_print+0x360>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    117a <histogram_print+0x5a>
lea    0xc07(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movq   $0x0,-0x20(%rbp)
lea    0xbe5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    1862 <histogram_print+0x742>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x81,-0xc(%rbp)
jge    15f5 <histogram_print+0x4d5>
mov    -0xc(%rbp),%eax
add    $0xffffffc0,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm4
movaps 0xa9c(%rip),%xmm3
punpckldq %xmm3,%xmm4
movapd 0xaa0(%rip),%xmm1
subpd  %xmm1,%xmm4
movaps %xmm4,%xmm2
unpckhpd %xmm4,%xmm4
addsd  %xmm2,%xmm4
movsd  -0x38(%rbp),%xmm2
mulsd  %xmm4,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm2
punpckldq %xmm3,%xmm2
subpd  %xmm1,%xmm2
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    14f4 <histogram_print+0x3d4>
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
movsd  -0x38(%rbp),%xmm0
movq   -0x18(%rbp),%xmm1
movaps 0x9eb(%rip),%xmm3
punpckldq %xmm3,%xmm1
movapd 0x9ef(%rip),%xmm2
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm4
unpckhpd %xmm1,%xmm1
addsd  %xmm4,%xmm1
divsd  %xmm1,%xmm0
movslq -0x10(%rbp),%rax
movsd  %xmm0,-0x250(%rbp,%rax,8)
ff ff
movsd  -0x40(%rbp),%xmm0
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
movq   %rax,%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movslq -0x10(%rbp),%rax
movsd  %xmm0,-0x460(%rbp,%rax,8)
ff ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x1,%rax
jne    1747 <histogram_print+0x627>
movl   $0x0,-0xc(%rbp)
cmpl   $0x81,-0xc(%rbp)
jge    1742 <histogram_print+0x622>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm1
movaps 0x935(%rip),%xmm0
punpckldq %xmm0,%xmm1
movapd 0x939(%rip),%xmm0
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
add    $0x1,%rax
shr    %rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jb     172f <histogram_print+0x60f>
mov    -0xc(%rbp),%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movslq -0x10(%rbp),%rax
movsd  %xmm0,-0x670(%rbp,%rax,8)
ff ff
jmp    1742 <histogram_print+0x622>
jmp    1734 <histogram_print+0x614>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1698 <histogram_print+0x578>
jmp    1842 <histogram_print+0x722>
movl   $0x0,-0xc(%rbp)
cmpl   $0x81,-0xc(%rbp)
jge    183d <histogram_print+0x71d>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rdx
mov    %rdx,%rcx
shl    $0x9,%rcx
lea    (%rcx,%rdx,8),%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
movq   (%rax,%rcx,8),%xmm1
movaps 0x87f(%rip),%xmm0
punpckldq %xmm0,%xmm1
movapd 0x883(%rip),%xmm0
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x38(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
shr    %rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jne    17ee <histogram_print+0x6ce>
jp     17ee <histogram_print+0x6ce>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x848(%rip),%xmm1
subsd  %xmm1,%xmm0
movslq -0x10(%rbp),%rax
movsd  %xmm0,-0x670(%rbp,%rax,8)
ff ff
jmp    183d <histogram_print+0x71d>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
shr    %rax
cvtsi2sd %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    1825 <histogram_print+0x705>
mov    -0xc(%rbp),%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movslq -0x10(%rbp),%rax
movsd  %xmm0,-0x670(%rbp,%rax,8)
ff ff
jmp    183d <histogram_print+0x71d>
jmp    182a <histogram_print+0x70a>
jmp    182f <histogram_print+0x70f>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    174e <histogram_print+0x62e>
jmp    1842 <histogram_print+0x722>
mov    -0x18(%rbp),%rsi
lea    0x80a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    14b9 <histogram_print+0x399>
mov    -0x20(%rbp),%rsi
lea    0x829(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x823(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    18bc <histogram_print+0x79c>
movslq -0x10(%rbp),%rax
movsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
lea    0x7e2(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1889 <histogram_print+0x769>
lea    0x7d9(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x7d2(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    1912 <histogram_print+0x7f2>
movslq -0x10(%rbp),%rax
movsd  -0x670(%rbp,%rax,8),%xmm0
ff ff
lea    0x78c(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    18df <histogram_print+0x7bf>
lea    0x783(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x783(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    196d <histogram_print+0x84d>
movslq -0x10(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm0
ff ff
call   1040 <sqrt@plt>
lea    0x731(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1935 <histogram_print+0x815>
lea    0x728(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x72e(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    19d0 <histogram_print+0x8b0>
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movslq -0x10(%rbp),%rax
subsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
lea    0x6ce(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1990 <histogram_print+0x870>
lea    0x6c5(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0x664(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x10(%rbp)
cmpl   $0x41,-0x10(%rbp)
jge    1a73 <histogram_print+0x953>
mov    -0x10(%rbp),%eax
shl    $0x1,%eax
sub    $0x40,%eax
cvtsi2sd %eax,%xmm0
movslq -0x10(%rbp),%rax
subsd  -0x250(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x28(%rbp)
movslq -0x10(%rbp),%rax
movsd  -0x460(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x28(%rbp),%xmm0
movsd  -0x28(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
lea    0x62b(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    19f3 <histogram_print+0x8d3>
lea    0x622(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
add    $0x6a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<histogram_print>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x658,%rsp
mov    %rdi,%r13
mov    $0xffffffc0,%ebp
lea    0xee0(%rip),%r14
mov    %r14,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x2,%ebp
cmp    $0x42,%ebp
jne    1150 <histogram_print+0x20>
lea    0xeca(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xee6(%rip),%r15
mov    %r13,%rbx
xor    %r12d,%r12d
jmp    11e8 <histogram_print+0xb8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
movsd  %xmm2,0x8(%rsp)
movsd  %xmm1,0x20(%rsp)
call   1050 <sqrt@plt>
movsd  0x20(%rsp),%xmm1
movapd 0x10(%rsp),%xmm5
movsd  0x8(%rsp),%xmm2
movapd %xmm0,%xmm3
lea    0xea4(%rip),%rdi
mov    %rbp,%rsi
movapd %xmm5,%xmm0
mov    $0x4,%al
call   1040 <printf@plt>
add    $0x1,%r12
add    $0x208,%rbx
cmp    $0x81,%r12
je     13d3 <histogram_print+0x2a3>
lea    -0x40(%r12),%ebp
lea    0xe67(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
xorps  %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
xorps  %xmm4,%xmm4
xor    %r14d,%r14d
xor    %ebp,%ebp
movsd  %xmm2,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm4,0x20(%rsp)
lea    -0x40(%r14),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,0x10(%rsp)
mov    (%rbx,%r14,4),%rsi
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movapd 0x20(%rsp),%xmm4
movsd  0x8(%rsp),%xmm2
mov    (%rbx,%r14,4),%rax
add    %rax,%rbp
movq   %rax,%xmm0
punpckldq 0xd9c(%rip),%xmm0
subpd  0xda4(%rip),%xmm0
movapd %xmm2,%xmm1
movapd 0x10(%rsp),%xmm3
subsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm1
unpcklpd %xmm3,%xmm1
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
unpckhpd %xmm0,%xmm0
addpd  %xmm3,%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm0,%xmm4
add    $0x2,%r14
cmp    $0x82,%r14
jne    1220 <histogram_print+0xf0>
movq   %rbp,%xmm0
movdqa 0xd48(%rip),%xmm6
punpckldq %xmm6,%xmm0
movapd 0xd4c(%rip),%xmm3
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
divsd  %xmm1,%xmm5
lea    -0x1(%rbp),%rax
movq   %rax,%xmm0
punpckldq %xmm6,%xmm0
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
addsd  %xmm0,%xmm1
divsd  %xmm1,%xmm4
cmp    $0x6,%rbp
jb     1320 <histogram_print+0x1f0>
ucomisd 0xd19(%rip),%xmm4
movapd %xmm5,0x10(%rsp)
jb     1340 <histogram_print+0x210>
xorps  %xmm1,%xmm1
sqrtsd %xmm4,%xmm1
jmp    1365 <histogram_print+0x235>
test   %rbp,%rbp
je     138f <histogram_print+0x25f>
ucomisd 0xcfb(%rip),%xmm4
jb     13a0 <histogram_print+0x270>
xorps  %xmm1,%xmm1
sqrtsd %xmm4,%xmm1
jmp    13b9 <histogram_print+0x289>
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm0
movapd %xmm4,0x20(%rsp)
call   1050 <sqrt@plt>
movapd 0x10(%rsp),%xmm5
movapd 0x20(%rsp),%xmm4
movsd  0x8(%rsp),%xmm2
movapd %xmm0,%xmm1
subsd  %xmm5,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm0,%xmm4
ucomisd 0xcab(%rip),%xmm4
jb     1190 <histogram_print+0x60>
xorps  %xmm3,%xmm3
sqrtsd %xmm4,%xmm3
jmp    11bb <histogram_print+0x8b>
mov    %r15,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1040 <printf@plt>
jmp    11d0 <histogram_print+0xa0>
movapd %xmm4,%xmm0
movapd %xmm5,0x10(%rsp)
call   1050 <sqrt@plt>
movapd 0x10(%rsp),%xmm5
movapd %xmm0,%xmm1
lea    0xcc5(%rip),%rdi
mov    %rbp,%rsi
movapd %xmm5,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
jmp    11d0 <histogram_print+0xa0>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xcb4(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xc6d(%rip),%r15
xor    %ebp,%ebp
xor    %r14d,%r14d
jmp    142f <histogram_print+0x2ff>
add    $0xfffffffffffffffe,%rax
add    $0xffffffc0,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x450(%rsp,%rbp,8)
add    %rsi,%r14
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbp
add    $0x8,%r13
cmp    $0x41,%rbp
je     16f0 <histogram_print+0x5c0>
lea    -0x40(%rbp,%rbp,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm2,%xmm2
mov    $0x208,%eax
mov    $0xffffffc0,%ecx
xor    %esi,%esi
movdqa 0xbae(%rip),%xmm5
movapd 0xbb6(%rip),%xmm6
nopw   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
mov    -0x208(%r13,%rax,1),%rdx
ff
add    %rdx,%rsi
movq   %rdx,%xmm1
punpckldq %xmm5,%xmm1
subpd  %xmm6,%xmm1
movapd %xmm3,%xmm4
subsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
unpckhpd %xmm1,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
cmp    $0x10608,%rax
je     1510 <histogram_print+0x3e0>
lea    0x1(%rcx),%edx
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
mov    0x0(%r13,%rax,1),%rdx
add    %rdx,%rsi
movq   %rdx,%xmm2
punpckldq %xmm5,%xmm2
subpd  %xmm6,%xmm2
movapd %xmm3,%xmm4
subsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
unpckhpd %xmm2,%xmm2
addpd  %xmm3,%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
add    $0x410,%rax
add    $0x2,%ecx
jmp    1460 <histogram_print+0x330>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   %rsi,%xmm0
punpckldq %xmm5,%xmm0
movapd 0xaef(%rip),%xmm3
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0x30(%rsp,%rbp,8)
lea    -0x1(%rsi),%rax
movq   %rax,%xmm0
punpckldq %xmm5,%xmm0
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x240(%rsp,%rbp,8)
test   $0x1,%sil
jne    1610 <histogram_print+0x4e0>
mov    %rsi,%rax
shr    %rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorpd  %xmm1,%xmm1
mov    %r13,%rcx
xor    %eax,%eax
xchg   %ax,%ax
movapd %xmm1,%xmm2
movq   (%rcx),%xmm3
punpckldq %xmm5,%xmm3
subpd  %xmm6,%xmm3
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jne    15bc <histogram_print+0x48c>
jnp    16d3 <histogram_print+0x5a3>
ja     13fd <histogram_print+0x2cd>
cmp    $0x80,%rax
je     1410 <histogram_print+0x2e0>
movq   0x208(%rcx),%xmm2
punpckldq %xmm5,%xmm2
subpd  %xmm6,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
jne    15fa <histogram_print+0x4ca>
jnp    16cf <histogram_print+0x59f>
ja     16e7 <histogram_print+0x5b7>
add    $0x2,%rax
add    $0x410,%rcx
jmp    1590 <histogram_print+0x460>
nopl   (%rax)
lea    0x1(%rsi),%rax
shr    %rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
xorpd  %xmm1,%xmm1
mov    $0x2,%eax
mov    %r13,%rcx
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm2
movq   (%rcx),%xmm3
punpckldq %xmm5,%xmm3
subpd  %xmm6,%xmm3
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
addsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jae    13f9 <histogram_print+0x2c9>
movq   0x208(%rcx),%xmm2
punpckldq %xmm5,%xmm2
subpd  %xmm6,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
jae    16c6 <histogram_print+0x596>
movq   0x410(%rcx),%xmm2
punpckldq %xmm5,%xmm2
subpd  %xmm6,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
ucomisd %xmm0,%xmm1
jae    13fd <histogram_print+0x2cd>
add    $0x3,%rax
add    $0x618,%rcx
cmp    $0x83,%rax
jne    1630 <histogram_print+0x500>
jmp    1410 <histogram_print+0x2e0>
add    $0xffffffffffffffff,%rax
jmp    13fd <histogram_print+0x2cd>
add    $0x1,%rax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x93e(%rip),%xmm0
jmp    1407 <histogram_print+0x2d7>
add    $0x1,%rax
jmp    13fd <histogram_print+0x2cd>
lea    0x9a7(%rip),%rdi
xor    %ebp,%ebp
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x99c(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x979(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movsd  0x30(%rsp,%rbp,8),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x41,%rbp
jne    1720 <histogram_print+0x5f0>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x960(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x936(%rip),%rbx
nopl   0x0(%rax,%rax,1)
movsd  0x450(%rsp,%rbp,8),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x41,%rbp
jne    1760 <histogram_print+0x630>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x924(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x8f3(%rip),%rbx
jmp    17b9 <histogram_print+0x689>
call   1050 <sqrt@plt>
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x1,%rbp
cmp    $0x41,%rbp
je     17d2 <histogram_print+0x6a2>
movsd  0x240(%rsp,%rbp,8),%xmm0
ucomisd 0x85e(%rip),%xmm0
jb     17a0 <histogram_print+0x670>
sqrtsd %xmm0,%xmm0
jmp    17a5 <histogram_print+0x675>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x8d5(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x89e(%rip),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x40(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
subsd  0x30(%rsp,%rbp,4),%xmm0
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x2,%rbp
cmp    $0x82,%rbp
jne    1800 <histogram_print+0x6d0>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x819(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x849(%rip),%rbx
jmp    186c <histogram_print+0x73c>
nopw   0x0(%rax,%rax,1)
call   1050 <sqrt@plt>
mov    %rbx,%rdi
mov    $0x1,%al
call   1040 <printf@plt>
add    $0x2,%rbp
cmp    $0x82,%rbp
je     189d <histogram_print+0x76d>
lea    -0x40(%rbp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
subsd  0x30(%rsp,%rbp,4),%xmm1
movsd  0x240(%rsp,%rbp,4),%xmm0
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
ucomisd 0x793(%rip),%xmm0
jb     1850 <histogram_print+0x720>
sqrtsd %xmm0,%xmm0
jmp    1855 <histogram_print+0x725>
mov    $0xa,%edi
add    $0x658,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <putchar@plt>

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

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