#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*/ binlensd3(double, double, double, double, double *, double *,
                             double *, double *, double *);
int /*<<< orphan*/ binlensd4(double, double, double, double, double *, double *,
                             double *, double *, double *, double *);
int /*<<< orphan*/ binlensd5(double, double, double, double, double *, double *,
                             double *, double *, double *, double *, double *);
int /*<<< orphan*/ printf(char *, ...);
void test_der(void) {
  double y1111, y1112, y1122, y1222, y2222;
  double z1111, z1112, z1122, z1222, z2222;
  double y11111, y11112, y11122, y11222, y12222, y22222;
  double z11111, z11112, z11122, z11222, z12222, z22222;
  double y111111, y111112, y111122, y111222, y112222, y122222, y222222;
  double x1, x2, d, m1;
  double delta;
  x1 = 0.7;
  x2 = 0.4;
  d = 0.3;
  m1 = 0.45;
  delta = 1e-10;
  binlensd3(x1, x2, d, m1, &y1111, &y1112, &y1122, &y1222, &y2222);
  binlensd3(x1 + delta, x2, d, m1, &z1111, &z1112, &z1122, &z1222, &z2222);
  binlensd4(x1, x2, d, m1, &y11111, &y11112, &y11122, &y11222, &y12222,
            &y22222);
  printf("%-8.6le %-8.6le\n", (z1111 - y1111) / delta, y11111);
  printf("%-8.6le %-8.6le\n", (z1112 - y1112) / delta, y11112);
  printf("%-8.6le %-8.6le\n", (z1122 - y1122) / delta, y11122);
  printf("%-8.6le %-8.6le\n", (z1222 - y1222) / delta, y11222);
  printf("%-8.6le %-8.6le\n", (z2222 - y2222) / delta, y12222);
  printf("\nx2-der\n");
  binlensd3(x1, x2 + delta, d, m1, &z1111, &z1112, &z1122, &z1222, &z2222);
  printf("%-8.6le %-8.6le\n", (z1111 - y1111) / delta, y11112);
  printf("%-8.6le %-8.6le\n", (z1112 - y1112) / delta, y11122);
  printf("%-8.6le %-8.6le\n", (z1122 - y1122) / delta, y11222);
  printf("%-8.6le %-8.6le\n", (z1222 - y1222) / delta, y12222);
  printf("%-8.6le %-8.6le\n", (z2222 - y2222) / delta, y22222);
  printf("\n");
  binlensd4(x1, x2, d, m1, &y11111, &y11112, &y11122, &y11222, &y12222,
            &y22222);
  binlensd4(x1 + delta, x2, d, m1, &z11111, &z11112, &z11122, &z11222, &z12222,
            &z22222);
  binlensd5(x1, x2, d, m1, &y111111, &y111112, &y111122, &y111222, &y112222,
            &y122222, &y222222);
  printf("%-8.6le %-8.6le\n", (z11111 - y11111) / delta, y111111);
  printf("%-8.6le %-8.6le\n", (z11112 - y11112) / delta, y111112);
  printf("%-8.6le %-8.6le\n", (z11122 - y11122) / delta, y111122);
  printf("%-8.6le %-8.6le\n", (z11222 - y11222) / delta, y111222);
  printf("%-8.6le %-8.6le\n", (z12222 - y12222) / delta, y112222);
  printf("%-8.6le %-8.6le\n", (z22222 - y22222) / delta, y122222);
  printf("\nx2-der\n");
  binlensd4(x1, x2 + delta, d, m1, &z11111, &z11112, &z11122, &z11222, &z12222,
            &z22222);
  printf("%-8.6le %-8.6le\n", (z11111 - y11111) / delta, y111112);
  printf("%-8.6le %-8.6le\n", (z11112 - y11112) / delta, y111122);
  printf("%-8.6le %-8.6le\n", (z11122 - y11122) / delta, y111222);
  printf("%-8.6le %-8.6le\n", (z11222 - y11222) / delta, y112222);
  printf("%-8.6le %-8.6le\n", (z12222 - y12222) / delta, y122222);
  printf("%-8.6le %-8.6le\n", (z22222 - y22222) / delta, y222222);
}


x86 assembly (clang, -O0):
<test_der>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movsd  0xecd(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0xeb5(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0xe9d(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xe85(%rip),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0xe6d(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x8(%rbp),%rdi
lea    -0x10(%rbp),%rsi
lea    -0x18(%rbp),%rdx
lea    -0x20(%rbp),%rcx
lea    -0x28(%rbp),%r8
call   1060 <binlensd3@plt>
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x30(%rbp),%rdi
lea    -0x38(%rbp),%rsi
lea    -0x40(%rbp),%rdx
lea    -0x48(%rbp),%rcx
lea    -0x50(%rbp),%r8
call   1060 <binlensd3@plt>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x68(%rbp),%rdx
lea    -0x70(%rbp),%rcx
lea    -0x78(%rbp),%r8
lea    -0x80(%rbp),%r9
call   1030 <binlensd4@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm1
lea    0xdb8(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x38(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
lea    0xd93(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x40(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
lea    0xd6e(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x48(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
lea    0xd49(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x50(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
lea    0xd24(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xd27(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
addsd  -0x110(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x30(%rbp),%rdi
lea    -0x38(%rbp),%rsi
lea    -0x40(%rbp),%rdx
lea    -0x48(%rbp),%rcx
lea    -0x50(%rbp),%r8
call   1060 <binlensd3@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
lea    0xcb0(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x38(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
lea    0xc8b(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x40(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
lea    0xc66(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x48(%rbp),%xmm0
subsd  -0x20(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
lea    0xc41(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x50(%rbp),%xmm0
subsd  -0x28(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
lea    0xc1c(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xc1d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x58(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x68(%rbp),%rdx
lea    -0x70(%rbp),%rcx
lea    -0x78(%rbp),%r8
lea    -0x80(%rbp),%r9
call   1030 <binlensd4@plt>
movsd  -0xf0(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x88(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x98(%rbp),%rdx
lea    -0xa0(%rbp),%rcx
lea    -0xa8(%rbp),%r8
lea    -0xb0(%rbp),%r9
call   1030 <binlensd4@plt>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0xb8(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
lea    -0xc8(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
lea    -0xd8(%rbp),%r8
lea    -0xe0(%rbp),%r9
lea    -0xe8(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <binlensd5@plt>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x58(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
lea    0xaf5(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x60(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
lea    0xaca(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
lea    0xa9f(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
lea    0xa74(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
lea    0xa49(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
lea    0xa1e(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
lea    0xa21(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
addsd  -0x110(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm3
ff
lea    -0x88(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0x98(%rbp),%rdx
lea    -0xa0(%rbp),%rcx
lea    -0xa8(%rbp),%r8
lea    -0xb0(%rbp),%r9
call   1030 <binlensd4@plt>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x58(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
lea    0x98e(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
subsd  -0x60(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
lea    0x963(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
lea    0x938(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
lea    0x90d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xa8(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm1
ff
lea    0x8e2(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
divsd  -0x110(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
lea    0x8b7(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_der>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
movsd  0xe87(%rip),%xmm0
movsd  0xe87(%rip),%xmm1
movsd  0xe87(%rip),%xmm2
movsd  0xe87(%rip),%xmm3
lea    0xe0(%rsp),%rdi
lea    0xd8(%rsp),%rsi
lea    0xd0(%rsp),%rdx
lea    0xc8(%rsp),%rcx
lea    0xc0(%rsp),%r8
call   1080 <binlensd3@plt>
movsd  0xe5a(%rip),%xmm0
lea    0xb8(%rsp),%r14
lea    0xb0(%rsp),%r15
lea    0xa8(%rsp),%r12
lea    0xa0(%rsp),%r13
lea    0x98(%rsp),%rbp
movsd  0xe12(%rip),%xmm1
movsd  0xe12(%rip),%xmm2
movsd  0xe12(%rip),%xmm3
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
call   1080 <binlensd3@plt>
lea    0x38(%rsp),%rdi
lea    0x28(%rsp),%rsi
lea    0x20(%rsp),%rdx
lea    0x18(%rsp),%rcx
lea    0x10(%rsp),%r8
lea    0x30(%rsp),%r9
movsd  0xdc0(%rip),%xmm0
movsd  0xdc0(%rip),%xmm1
movsd  0xdc0(%rip),%xmm2
movsd  0xdc0(%rip),%xmm3
call   1050 <binlensd4@plt>
movsd  0xb8(%rsp),%xmm0
subsd  0xe0(%rsp),%xmm0
divsd  0xdb1(%rip),%xmm0
movsd  0x38(%rsp),%xmm1
lea    0xdb4(%rip),%rbx
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xb0(%rsp),%xmm0
subsd  0xd8(%rsp),%xmm0
divsd  0xd80(%rip),%xmm0
movsd  0x28(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xa8(%rsp),%xmm0
subsd  0xd0(%rsp),%xmm0
divsd  0xd56(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xa0(%rsp),%xmm0
subsd  0xc8(%rsp),%xmm0
divsd  0xd2c(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x98(%rsp),%xmm0
subsd  0xc0(%rsp),%xmm0
divsd  0xd02(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
lea    0xd0c(%rip),%rdi
call   1040 <puts@plt>
movsd  0xce6(%rip),%xmm1
movsd  0xcae(%rip),%xmm0
movsd  0xcb6(%rip),%xmm2
movsd  0xcb6(%rip),%xmm3
mov    %r14,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %rbp,%r8
call   1080 <binlensd3@plt>
movsd  0xb8(%rsp),%xmm0
subsd  0xe0(%rsp),%xmm0
divsd  0xc98(%rip),%xmm0
movsd  0x28(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xb0(%rsp),%xmm0
subsd  0xd8(%rsp),%xmm0
divsd  0xc6e(%rip),%xmm0
movsd  0x20(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xa8(%rsp),%xmm0
subsd  0xd0(%rsp),%xmm0
divsd  0xc44(%rip),%xmm0
movsd  0x18(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0xa0(%rsp),%xmm0
subsd  0xc8(%rsp),%xmm0
divsd  0xc1a(%rip),%xmm0
movsd  0x10(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x98(%rsp),%xmm0
subsd  0xc0(%rsp),%xmm0
divsd  0xbf0(%rip),%xmm0
movsd  0x30(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
movsd  0xba6(%rip),%xmm0
movsd  0xba6(%rip),%xmm1
movsd  0xba6(%rip),%xmm2
movsd  0xba6(%rip),%xmm3
lea    0x38(%rsp),%rdi
lea    0x28(%rsp),%rsi
lea    0x20(%rsp),%rdx
lea    0x18(%rsp),%rcx
lea    0x10(%rsp),%r8
lea    0x30(%rsp),%r9
call   1050 <binlensd4@plt>
lea    0x90(%rsp),%rbp
lea    0x88(%rsp),%r14
lea    0x80(%rsp),%r15
lea    0x78(%rsp),%r12
lea    0x70(%rsp),%r13
lea    0x40(%rsp),%r9
movsd  0xb5c(%rip),%xmm0
movsd  0xb3c(%rip),%xmm1
movsd  0xb3c(%rip),%xmm2
movsd  0xb3c(%rip),%xmm3
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r13,%r8
call   1050 <binlensd4@plt>
lea    0xe8(%rsp),%rax
mov    %rax,(%rsp)
lea    0xf0(%rsp),%rdi
lea    0x68(%rsp),%rsi
lea    0x60(%rsp),%rdx
lea    0x58(%rsp),%rcx
lea    0x50(%rsp),%r8
lea    0x48(%rsp),%r9
movsd  0xadb(%rip),%xmm0
movsd  0xadb(%rip),%xmm1
movsd  0xadb(%rip),%xmm2
movsd  0xadb(%rip),%xmm3
call   1070 <binlensd5@plt>
movsd  0x90(%rsp),%xmm0
subsd  0x38(%rsp),%xmm0
divsd  0xacf(%rip),%xmm0
movsd  0xf0(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x88(%rsp),%xmm0
subsd  0x28(%rsp),%xmm0
divsd  0xaa5(%rip),%xmm0
movsd  0x68(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x80(%rsp),%xmm0
subsd  0x20(%rsp),%xmm0
divsd  0xa7e(%rip),%xmm0
movsd  0x60(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x78(%rsp),%xmm0
subsd  0x18(%rsp),%xmm0
divsd  0xa5a(%rip),%xmm0
movsd  0x58(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x70(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
divsd  0xa36(%rip),%xmm0
movsd  0x50(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x40(%rsp),%xmm0
subsd  0x30(%rsp),%xmm0
divsd  0xa12(%rip),%xmm0
movsd  0x48(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
lea    0xa1c(%rip),%rdi
call   1040 <puts@plt>
movsd  0x9c6(%rip),%xmm0
movsd  0x9ee(%rip),%xmm1
movsd  0x9c6(%rip),%xmm2
movsd  0x9c6(%rip),%xmm3
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    %r13,%r8
lea    0x40(%rsp),%r9
call   1050 <binlensd4@plt>
movsd  0x90(%rsp),%xmm0
subsd  0x38(%rsp),%xmm0
divsd  0x9a6(%rip),%xmm0
movsd  0x68(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x88(%rsp),%xmm0
subsd  0x28(%rsp),%xmm0
divsd  0x97f(%rip),%xmm0
movsd  0x60(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x80(%rsp),%xmm0
subsd  0x20(%rsp),%xmm0
divsd  0x958(%rip),%xmm0
movsd  0x58(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x78(%rsp),%xmm0
subsd  0x18(%rsp),%xmm0
divsd  0x934(%rip),%xmm0
movsd  0x50(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x70(%rsp),%xmm0
subsd  0x10(%rsp),%xmm0
divsd  0x910(%rip),%xmm0
movsd  0x48(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
movsd  0x40(%rsp),%xmm0
subsd  0x30(%rsp),%xmm0
divsd  0x8ec(%rip),%xmm0
movsd  0xe8(%rsp),%xmm1
mov    %rbx,%rdi
mov    $0x2,%al
call   1060 <printf@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [17 x i8] c"%-8.6le %-8.6le\0A\00"
@str.3 = [8 x i8] c"\0Ax2-der\00"
define void @test_der() {
%1 = alloca double
%2 = alloca double
%3 = alloca double
%4 = alloca double
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = bitcast double* %1 to i8*
%31 = bitcast double* %2 to i8*
%32 = bitcast double* %3 to i8*
%33 = bitcast double* %4 to i8*
%34 = bitcast double* %5 to i8*
%35 = bitcast double* %6 to i8*
%36 = bitcast double* %7 to i8*
%37 = bitcast double* %8 to i8*
%38 = bitcast double* %9 to i8*
%39 = bitcast double* %10 to i8*
%40 = bitcast double* %11 to i8*
%41 = bitcast double* %12 to i8*
%42 = bitcast double* %13 to i8*
%43 = bitcast double* %14 to i8*
%44 = bitcast double* %15 to i8*
%45 = bitcast double* %16 to i8*
%46 = bitcast double* %17 to i8*
%47 = bitcast double* %18 to i8*
%48 = bitcast double* %19 to i8*
%49 = bitcast double* %20 to i8*
%50 = bitcast double* %21 to i8*
%51 = bitcast double* %22 to i8*
%52 = bitcast double* %23 to i8*
%53 = bitcast double* %24 to i8*
%54 = bitcast double* %25 to i8*
%55 = bitcast double* %26 to i8*
%56 = bitcast double* %27 to i8*
%57 = bitcast double* %28 to i8*
%58 = bitcast double* %29 to i8*
%59 = call i32 @binlensd3(double 0x3FE6666666666666, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %1, double* %2, double* %3, double* %4, double* %5)
%60 = call i32 @binlensd3(double 0x3FE66666667424D6, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %6, double* %7, double* %8, double* %9, double* %10)
%61 = call i32 @binlensd4(double 0x3FE6666666666666, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16)
%62 = load double, double* %6
%63 = load double, double* %1
%64 = fsub double %62, %63
%65 = fdiv double %64, 1.000000e-10
%66 = load double, double* %11
%67 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %65, double %66)
%68 = load double, double* %7
%69 = load double, double* %2
%70 = fsub double %68, %69
%71 = fdiv double %70, 1.000000e-10
%72 = load double, double* %12
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %71, double %72)
%74 = load double, double* %8
%75 = load double, double* %3
%76 = fsub double %74, %75
%77 = fdiv double %76, 1.000000e-10
%78 = load double, double* %13
%79 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %77, double %78)
%80 = load double, double* %9
%81 = load double, double* %4
%82 = fsub double %80, %81
%83 = fdiv double %82, 1.000000e-10
%84 = load double, double* %14
%85 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %83, double %84)
%86 = load double, double* %10
%87 = load double, double* %5
%88 = fsub double %86, %87
%89 = fdiv double %88, 1.000000e-10
%90 = load double, double* %15
%91 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %89, double %90)
%92 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.3, i64 0, i64 0))
%93 = call i32 @binlensd3(double 0x3FE6666666666666, double 0x3FD9999999B5167A, double 3.000000e-01, double 4.500000e-01, double* %6, double* %7, double* %8, double* %9, double* %10)
%94 = load double, double* %6
%95 = load double, double* %1
%96 = fsub double %94, %95
%97 = fdiv double %96, 1.000000e-10
%98 = load double, double* %12
%99 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %97, double %98)
%100 = load double, double* %7
%101 = load double, double* %2
%102 = fsub double %100, %101
%103 = fdiv double %102, 1.000000e-10
%104 = load double, double* %13
%105 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %103, double %104)
%106 = load double, double* %8
%107 = load double, double* %3
%108 = fsub double %106, %107
%109 = fdiv double %108, 1.000000e-10
%110 = load double, double* %14
%111 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %109, double %110)
%112 = load double, double* %9
%113 = load double, double* %4
%114 = fsub double %112, %113
%115 = fdiv double %114, 1.000000e-10
%116 = load double, double* %15
%117 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %115, double %116)
%118 = load double, double* %10
%119 = load double, double* %5
%120 = fsub double %118, %119
%121 = fdiv double %120, 1.000000e-10
%122 = load double, double* %16
%123 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %121, double %122)
%124 = call i32 @putchar(i32 10)
%125 = call i32 @binlensd4(double 0x3FE6666666666666, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16)
%126 = call i32 @binlensd4(double 0x3FE66666667424D6, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %17, double* %18, double* %19, double* %20, double* %21, double* %22)
%127 = call i32 @binlensd5(double 0x3FE6666666666666, double 4.000000e-01, double 3.000000e-01, double 4.500000e-01, double* %23, double* %24, double* %25, double* %26, double* %27, double* %28, double* %29)
%128 = load double, double* %17
%129 = load double, double* %11
%130 = fsub double %128, %129
%131 = fdiv double %130, 1.000000e-10
%132 = load double, double* %23
%133 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %131, double %132)
%134 = load double, double* %18
%135 = load double, double* %12
%136 = fsub double %134, %135
%137 = fdiv double %136, 1.000000e-10
%138 = load double, double* %24
%139 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %137, double %138)
%140 = load double, double* %19
%141 = load double, double* %13
%142 = fsub double %140, %141
%143 = fdiv double %142, 1.000000e-10
%144 = load double, double* %25
%145 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %143, double %144)
%146 = load double, double* %20
%147 = load double, double* %14
%148 = fsub double %146, %147
%149 = fdiv double %148, 1.000000e-10
%150 = load double, double* %26
%151 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %149, double %150)
%152 = load double, double* %21
%153 = load double, double* %15
%154 = fsub double %152, %153
%155 = fdiv double %154, 1.000000e-10
%156 = load double, double* %27
%157 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %155, double %156)
%158 = load double, double* %22
%159 = load double, double* %16
%160 = fsub double %158, %159
%161 = fdiv double %160, 1.000000e-10
%162 = load double, double* %28
%163 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %161, double %162)
%164 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.3, i64 0, i64 0))
%165 = call i32 @binlensd4(double 0x3FE6666666666666, double 0x3FD9999999B5167A, double 3.000000e-01, double 4.500000e-01, double* %17, double* %18, double* %19, double* %20, double* %21, double* %22)
%166 = load double, double* %17
%167 = load double, double* %11
%168 = fsub double %166, %167
%169 = fdiv double %168, 1.000000e-10
%170 = load double, double* %24
%171 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %169, double %170)
%172 = load double, double* %18
%173 = load double, double* %12
%174 = fsub double %172, %173
%175 = fdiv double %174, 1.000000e-10
%176 = load double, double* %25
%177 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %175, double %176)
%178 = load double, double* %19
%179 = load double, double* %13
%180 = fsub double %178, %179
%181 = fdiv double %180, 1.000000e-10
%182 = load double, double* %26
%183 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %181, double %182)
%184 = load double, double* %20
%185 = load double, double* %14
%186 = fsub double %184, %185
%187 = fdiv double %186, 1.000000e-10
%188 = load double, double* %27
%189 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %187, double %188)
%190 = load double, double* %21
%191 = load double, double* %15
%192 = fsub double %190, %191
%193 = fdiv double %192, 1.000000e-10
%194 = load double, double* %28
%195 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %193, double %194)
%196 = load double, double* %22
%197 = load double, double* %16
%198 = fsub double %196, %197
%199 = fdiv double %198, 1.000000e-10
%200 = load double, double* %29
%201 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), double %199, double %200)
ret void
}