#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 */
typedef int uint64_t;
typedef int /*<<< orphan*/ mpfr_t;
typedef int int64_t;

/* Variables and functions */
int /*<<< orphan*/ MPFR_RNDN;
int /*<<< orphan*/ invert_poorly(int /*<<< orphan*/ **, int /*<<< orphan*/ **);
int leeway_of(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_add(int /*<<< orphan*/, int /*<<< orphan*/,
                            int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_atan(int /*<<< orphan*/, int /*<<< orphan*/,
                             int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_cos(int /*<<< orphan*/, int /*<<< orphan*/,
                            int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_div_si(int /*<<< orphan*/, int /*<<< orphan*/, int,
                               int /*<<< orphan*/);
double mpfr_get_d(int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_init2(int /*<<< orphan*/, int);
int /*<<< orphan*/ mpfr_mul(int /*<<< orphan*/, int /*<<< orphan*/,
                            int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_set(int /*<<< orphan*/, int /*<<< orphan*/,
                            int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_set_d(int /*<<< orphan*/, double, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_set_si(int /*<<< orphan*/, long, int /*<<< orphan*/);
int /*<<< orphan*/ mpfr_sub(int /*<<< orphan*/, int /*<<< orphan*/,
                            int /*<<< orphan*/, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int, ...);
long time(int /*<<< orphan*/);
int find_tuple(int ii, int min_leeway) {
  int64_t r = 0;
  double xi_orig_d = ii / 256.0;
  uint64_t xi_orig = (*((uint64_t *)((char *)&xi_orig_d)));
  double range_a = -1 / 512.0;
  double range_b = 1 / 512.0;
  uint64_t xi;
  double xi_d;
  mpfr_t xi_m;
  int best_lee = 0;
  long int best_r = 0;
  mpfr_t t[10];
  mpfr_t cn[5 + 2];
  mpfr_t bi[5 + 2];
  mpfr_t best_bi[5 + 2];
  mpfr_t best_xi;
  mpfr_t xij[5 + 2][5 + 2];
  mpfr_t xijinv[5 + 2][5 + 2];
  mpfr_t fxi[5 + 2];
  double t_d = 0.0;
  uint64_t t_u = 0;
  long ec = 1;
  long start = time(0);
  long end = start;
  mpfr_init2(xi_m, 200);
  mpfr_init2(best_xi, 200);
  for (int i = 0; i < 10; ++i) {
    mpfr_init2(t[i], 200);
  }
  mpfr_set_d(t[1], range_a, MPFR_RNDN);
  mpfr_set_d(t[2], range_b, MPFR_RNDN);
  mpfr_add(t[3], t[2], t[1], MPFR_RNDN);
  mpfr_sub(t[4], t[2], t[1], MPFR_RNDN);
  mpfr_div_si(t[3], t[3], 2, MPFR_RNDN);
  mpfr_div_si(t[4], t[4], 2, MPFR_RNDN);
  for (int i = 0; i < (5 + 2); ++i) {
    mpfr_init2(cn[i], 200);
    mpfr_init2(bi[i], 200);
    mpfr_init2(best_bi[i], 200);
    mpfr_set_si(best_bi[i], 0, MPFR_RNDN);
    mpfr_init2(fxi[i], 200);
    mpfr_set_si(cn[i], 2 * i - 1, MPFR_RNDN);
    mpfr_div_si(cn[i], cn[i], 2 * (5 + 2), MPFR_RNDN);
    mpfr_cos(cn[i], cn[i], MPFR_RNDN);
    mpfr_mul(cn[i], cn[i], t[4], MPFR_RNDN);
    mpfr_add(cn[i], cn[i], t[3], MPFR_RNDN);
  }
  for (int i = 0; i < (5 + 2); ++i) {
    mpfr_set_si(t[1], 1, MPFR_RNDN);
    for (int j = 0; j < (5 + 1); ++j) {
      mpfr_init2(xij[i][j], 200);
      mpfr_init2(xijinv[i][j], 200);
      mpfr_set(xij[i][j], t[1], MPFR_RNDN);
      mpfr_mul(t[1], t[1], cn[i], MPFR_RNDN);
    }
    mpfr_init2(xij[i][5 + 1], 200);
    mpfr_init2(xijinv[i][5 + 1], 200);
    mpfr_set_si(xij[i][5 + 1], ec, MPFR_RNDN);
    ec *= -1;
  }
  invert_poorly(xij, xijinv);
  while (r < (1 << 28)) {
    xi = xi_orig + r;
    xi_d = (*((double *)((char *)&xi)));
    mpfr_set_d(xi_m, xi_d, MPFR_RNDN);
    for (int i = 0; i < (5 + 2); ++i) {
      mpfr_sub(fxi[i], cn[i], xi_m, MPFR_RNDN);
      mpfr_atan(fxi[i], fxi[i], MPFR_RNDN);
    }
    for (int i = 0; i < (5 + 2); ++i) {
      mpfr_set_si(bi[i], 0, MPFR_RNDN);
      for (int j = 0; j < (5 + 2); ++j) {
        mpfr_mul(t[i], xijinv[i][j], fxi[j], MPFR_RNDN);
        mpfr_add(bi[i], bi[i], t[i], MPFR_RNDN);
      }
    }
    double e = mpfr_get_d(bi[5 + 1], MPFR_RNDN);
    if ((*((uint64_t *)((char *)&e))) & 0x7fffffffffffffff > 0x08) {
      goto next_r;
    }
    int leeA = leeway_of(t[0], bi[0]);
    int leeB = 0;
    int lee = 0;
    if (leeA <= min_leeway) {
      goto next_r;
    }
    leeB = leeway_of(t[0], bi[1]);
    if (leeB + 4 <= min_leeway) {
      goto next_r;
    }
    lee = ((leeA) < (leeB + 4) ? (leeA) : (leeB + 4));
    if (lee <= best_lee) {
      goto next_r;
    }
    best_lee = lee;
    best_r = r;
    mpfr_set(best_xi, xi_m, MPFR_RNDN);
    for (int i = 0; i < (5 + 2); ++i) {
      mpfr_set(best_bi[i], bi[i], MPFR_RNDN);
    }
  next_r:
    if (r <= 0) {
      r = 1 - r;
    } else {
      r = -r;
    }
  }
  end = time(0);
  if (best_lee < min_leeway) {
    return -1;
  }
  t_d = mpfr_get_d(best_xi, MPFR_RNDN);
  t_u = (*((uint64_t *)((char *)&t_d)));
  printf("(%#018lx, ", t_u);
  for (int i = 0; i < 5; ++i) {
    t_d = mpfr_get_d(best_bi[i], MPFR_RNDN);
    printf("%#018lx, ", (*((uint64_t *)((char *)&t_d))));
  }
  t_d = mpfr_get_d(best_bi[5], MPFR_RNDN);
  t_u = (*((uint64_t *)((char *)&t_d)));
  printf("%#018lx), ", t_u);
  printf("/* i = %03d, l = %02d, r = %010ld, t = %ld */\n", ii, best_lee,
         best_r, end - start);
  return 0;
}


x86 assembly (clang, -O0):
<find_tuple>:
push   %rbp
mov    %rsp,%rbp
sub    $0x310,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  0xdfb(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movsd  0xddc(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xdc7(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
movl   $0x0,-0x2ac(%rbp)
movq   $0x1,-0x2b8(%rbp)
xor    %edi,%edi
call   10d0 <time@plt>
mov    %rax,-0x2c0(%rbp)
mov    -0x2c0(%rbp),%rax
mov    %rax,-0x2c8(%rbp)
mov    -0x44(%rbp),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
mov    -0xe4(%rbp),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movl   $0x0,-0x2cc(%rbp)
cmpl   $0xa,-0x2cc(%rbp)
jge    12e6 <find_tuple+0xf6>
movslq -0x2cc(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    12b0 <find_tuple+0xc0>
mov    -0x7c(%rbp),%edi
movsd  -0x28(%rbp),%xmm0
mov    0x2cf3(%rip),%rax
mov    (%rax),%esi
call   1070 <mpfr_set_d@plt>
mov    -0x78(%rbp),%edi
movsd  -0x30(%rbp),%xmm0
mov    0x2cdd(%rip),%rax
mov    (%rax),%esi
call   1070 <mpfr_set_d@plt>
mov    -0x74(%rbp),%edi
mov    -0x78(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    0x2cc6(%rip),%rax
mov    (%rax),%ecx
call   1090 <mpfr_add@plt>
mov    -0x70(%rbp),%edi
mov    -0x78(%rbp),%esi
mov    -0x7c(%rbp),%edx
mov    0x2caf(%rip),%rax
mov    (%rax),%ecx
call   1040 <mpfr_sub@plt>
mov    -0x74(%rbp),%edi
mov    -0x74(%rbp),%esi
mov    0x2c9b(%rip),%rax
mov    (%rax),%ecx
mov    $0x2,%edx
call   10f0 <mpfr_div_si@plt>
mov    -0x70(%rbp),%edi
mov    -0x70(%rbp),%esi
mov    0x2c82(%rip),%rax
mov    (%rax),%ecx
mov    $0x2,%edx
call   10f0 <mpfr_div_si@plt>
movl   $0x0,-0x2d0(%rbp)
cmpl   $0x7,-0x2d0(%rbp)
jge    14fb <find_tuple+0x30b>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%edi
mov    0x2c02(%rip),%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    %eax,%esi
call   1100 <mpfr_set_si@plt>
movslq -0x2d0(%rbp),%rax
mov    -0x2a0(%rbp,%rax,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
mov    -0x2d0(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
movslq %eax,%rsi
mov    0x2bbb(%rip),%rax
mov    (%rax),%edx
call   1100 <mpfr_set_si@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%esi
mov    0x2b91(%rip),%rax
mov    (%rax),%ecx
mov    $0xe,%edx
call   10f0 <mpfr_div_si@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%esi
mov    0x2b62(%rip),%rax
mov    (%rax),%edx
call   10c0 <mpfr_cos@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%esi
mov    -0x70(%rbp),%edx
mov    0x2b35(%rip),%rax
mov    (%rax),%ecx
call   1060 <mpfr_mul@plt>
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edi
movslq -0x2d0(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%esi
mov    -0x74(%rbp),%edx
mov    0x2b08(%rip),%rax
mov    (%rax),%ecx
call   1090 <mpfr_add@plt>
mov    -0x2d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d0(%rbp)
jmp    137c <find_tuple+0x18c>
movl   $0x0,-0x2d4(%rbp)
cmpl   $0x7,-0x2d4(%rbp)
jge    168b <find_tuple+0x49b>
mov    -0x7c(%rbp),%edi
mov    0x2acc(%rip),%rax
mov    (%rax),%edx
mov    $0x1,%esi
call   1100 <mpfr_set_si@plt>
movl   $0x0,-0x2d8(%rbp)
cmpl   $0x6,-0x2d8(%rbp)
jge    15f7 <find_tuple+0x407>
movslq -0x2d4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x2d8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d4(%rbp),%rcx
lea    -0x280(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x2d8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x2d8(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x7c(%rbp),%esi
mov    0x2a2e(%rip),%rax
mov    (%rax),%edx
call   10a0 <mpfr_set@plt>
mov    -0x7c(%rbp),%edi
mov    -0x7c(%rbp),%esi
movslq -0x2d4(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%edx
mov    0x2a0c(%rip),%rax
mov    (%rax),%ecx
call   1060 <mpfr_mul@plt>
mov    -0x2d8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d8(%rbp)
jmp    1532 <find_tuple+0x342>
movslq -0x2d4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    0x18(%rax),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d4(%rbp),%rcx
lea    -0x280(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    0x18(%rax),%edi
mov    $0xc8,%esi
call   1110 <mpfr_init2@plt>
movslq -0x2d4(%rbp),%rcx
lea    -0x1b0(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
mov    0x18(%rax),%edi
mov    -0x2b8(%rbp),%rsi
mov    0x2987(%rip),%rax
mov    (%rax),%edx
call   1100 <mpfr_set_si@plt>
imul   $0xffffffffffffffff,-0x2b8(%rbp),%rax
ff
mov    %rax,-0x2b8(%rbp)
mov    -0x2d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d4(%rbp)
jmp    1505 <find_tuple+0x315>
lea    -0x1b0(%rbp),%rdi
lea    -0x280(%rbp),%rsi
call   1030 <invert_poorly@plt>
cmpl   $0x10000000,-0x10(%rbp)
jge    19e6 <find_tuple+0x7f6>
mov    -0x1c(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
movsd  -0x34(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%edi
movsd  -0x40(%rbp),%xmm0
mov    0x291b(%rip),%rax
mov    (%rax),%esi
call   1070 <mpfr_set_d@plt>
movl   $0x0,-0x2dc(%rbp)
cmpl   $0x7,-0x2dc(%rbp)
jge    1756 <find_tuple+0x566>
movslq -0x2dc(%rbp),%rax
mov    -0x2a0(%rbp,%rax,4),%edi
movslq -0x2dc(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%esi
mov    -0x44(%rbp),%edx
mov    0x28d7(%rip),%rax
mov    (%rax),%ecx
call   1040 <mpfr_sub@plt>
movslq -0x2dc(%rbp),%rax
mov    -0x2a0(%rbp,%rax,4),%edi
movslq -0x2dc(%rbp),%rax
mov    -0x2a0(%rbp,%rax,4),%esi
mov    0x28ad(%rip),%rax
mov    (%rax),%edx
call   10e0 <mpfr_atan@plt>
mov    -0x2dc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2dc(%rbp)
jmp    16de <find_tuple+0x4ee>
movl   $0x0,-0x2e0(%rbp)
cmpl   $0x7,-0x2e0(%rbp)
jge    184c <find_tuple+0x65c>
movslq -0x2e0(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edi
mov    0x2866(%rip),%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    %eax,%esi
call   1100 <mpfr_set_si@plt>
movl   $0x0,-0x2e4(%rbp)
cmpl   $0x7,-0x2e4(%rbp)
jge    1833 <find_tuple+0x643>
movslq -0x2e0(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%edi
movslq -0x2e0(%rbp),%rcx
lea    -0x280(%rbp),%rax
imul   $0x1c,%rcx,%rcx
add    %rcx,%rax
movslq -0x2e4(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
movslq -0x2e4(%rbp),%rax
mov    -0x2a0(%rbp,%rax,4),%edx
mov    0x2805(%rip),%rax
mov    (%rax),%ecx
call   1060 <mpfr_mul@plt>
movslq -0x2e0(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edi
movslq -0x2e0(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%esi
movslq -0x2e0(%rbp),%rax
mov    -0x80(%rbp,%rax,4),%edx
mov    0x27d0(%rip),%rax
mov    (%rax),%ecx
call   1090 <mpfr_add@plt>
mov    -0x2e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2e4(%rbp)
jmp    1797 <find_tuple+0x5a7>
jmp    1838 <find_tuple+0x648>
mov    -0x2e0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2e0(%rbp)
jmp    1760 <find_tuple+0x570>
mov    -0xa8(%rbp),%edi
mov    0x278f(%rip),%rax
mov    (%rax),%esi
call   1050 <mpfr_get_d@plt>
movsd  %xmm0,-0x2f0(%rbp)
ff
mov    -0x2f0(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     187f <find_tuple+0x68f>
jmp    19bf <find_tuple+0x7cf>
mov    -0x80(%rbp),%edi
mov    -0xc0(%rbp),%esi
call   10b0 <leeway_of@plt>
mov    %eax,-0x2f4(%rbp)
movl   $0x0,-0x2f8(%rbp)
movl   $0x0,-0x2fc(%rbp)
mov    -0x2f4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     18bb <find_tuple+0x6cb>
jmp    19bf <find_tuple+0x7cf>
mov    -0x80(%rbp),%edi
mov    -0xbc(%rbp),%esi
call   10b0 <leeway_of@plt>
mov    %eax,-0x2f8(%rbp)
mov    -0x2f8(%rbp),%eax
add    $0x4,%eax
cmp    -0xc(%rbp),%eax
jg     18e6 <find_tuple+0x6f6>
jmp    19bf <find_tuple+0x7cf>
mov    -0x2f4(%rbp),%eax
mov    -0x2f8(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    190e <find_tuple+0x71e>
mov    -0x2f4(%rbp),%eax
mov    %eax,-0x308(%rbp)
jmp    191d <find_tuple+0x72d>
mov    -0x2f8(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x308(%rbp)
mov    -0x308(%rbp),%eax
mov    %eax,-0x2fc(%rbp)
mov    -0x2fc(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     193d <find_tuple+0x74d>
jmp    19bf <find_tuple+0x7cf>
mov    -0x2fc(%rbp),%eax
mov    %eax,-0x48(%rbp)
movslq -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0xe4(%rbp),%edi
mov    -0x44(%rbp),%esi
mov    0x268a(%rip),%rax
mov    (%rax),%edx
call   10a0 <mpfr_set@plt>
movl   $0x0,-0x300(%rbp)
cmpl   $0x7,-0x300(%rbp)
jge    19ba <find_tuple+0x7ca>
movslq -0x300(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%edi
movslq -0x300(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%esi
mov    0x2649(%rip),%rax
mov    (%rax),%edx
call   10a0 <mpfr_set@plt>
mov    -0x300(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x300(%rbp)
jmp    196f <find_tuple+0x77f>
jmp    19bf <find_tuple+0x7cf>
cmpl   $0x0,-0x10(%rbp)
jg     19d9 <find_tuple+0x7e9>
mov    $0x1,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    19e1 <find_tuple+0x7f1>
xor    %eax,%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    169e <find_tuple+0x4ae>
xor    %edi,%edi
call   10d0 <time@plt>
mov    %rax,-0x2c8(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a0c <find_tuple+0x81c>
movl   $0xffffffff,-0x4(%rbp)
jmp    1b14 <find_tuple+0x924>
mov    -0xe4(%rbp),%edi
mov    0x25cf(%rip),%rax
mov    (%rax),%esi
call   1050 <mpfr_get_d@plt>
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x2a8(%rbp),%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x2ac(%rbp),%esi
lea    0x5d7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x304(%rbp)
cmpl   $0x5,-0x304(%rbp)
jge    1aab <find_tuple+0x8bb>
movslq -0x304(%rbp),%rax
mov    -0xe0(%rbp,%rax,4),%edi
mov    0x2574(%rip),%rax
mov    (%rax),%esi
call   1050 <mpfr_get_d@plt>
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x2a8(%rbp),%esi
lea    0x589(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
jmp    1a52 <find_tuple+0x862>
mov    -0xcc(%rbp),%edi
mov    0x2530(%rip),%rax
mov    (%rax),%esi
call   1050 <mpfr_get_d@plt>
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x2a8(%rbp),%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x2ac(%rbp),%esi
lea    0x543(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x8(%rbp),%esi
mov    -0x48(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    -0x2c8(%rbp),%r8
sub    -0x2c0(%rbp),%r8
lea    0x528(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x310,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_tuple>:
push   %rbx
xor    %edi,%edi
call   1060 <time@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    $0xc8,%esi
call   1080 <mpfr_init2@plt>
mov    0x2e01(%rip),%rbx
mov    (%rbx),%esi
movsd  0xe0f(%rip),%xmm0
call   1040 <mpfr_set_d@plt>
mov    (%rbx),%esi
movsd  0xe08(%rip),%xmm0
call   1040 <mpfr_set_d@plt>
mov    (%rbx),%ecx
call   1050 <mpfr_add@plt>
mov    (%rbx),%ecx
call   1030 <mpfr_sub@plt>
mov    (%rbx),%ecx
mov    $0x2,%edx
call   1070 <mpfr_div_si@plt>
mov    (%rbx),%ecx
mov    $0x2,%edx
call   1070 <mpfr_div_si@plt>

LLVM IR (-O0):
@MPFR_RNDN = global i32 0
@.str = [11 x i8] c"(%lx, \00"
@.str.1 = [10 x i8] c"%lx, \00"
@.str.2 = [11 x i8] c"%lx), \00"
@.str.3 = [47 x i8] c"/* i = %03d, l = %02d, r = %010ld, t = %ld */\0A\00"
define i32 @find_tuple(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca double
%8 = alloca i32
%9 = alloca double
%10 = alloca double
%11 = alloca i32
%12 = alloca double
%13 = alloca i32
%14 = alloca i32
%15 = alloca i64
%16 = alloca [10 x i32]
%17 = alloca [7 x i32]
%18 = alloca [7 x i32]
%19 = alloca [7 x i32]
%20 = alloca i32
%21 = alloca [7 x [7 x i32]]
%22 = alloca [7 x [7 x i32]]
%23 = alloca [7 x i32]
%24 = alloca double
%25 = alloca i32
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
store i32 %0, i32* %4
store i32 %1, i32* %5
store i32 0, i32* %6
%42 = load i32, i32* %4
%43 = sitofp i32 %42 to double
%44 = fdiv double %43, 2.560000e+02
store double %44, double* %7
%45 = bitcast double* %7 to i8*
%46 = bitcast i8* %45 to i32*
%47 = load i32, i32* %46
store i32 %47, i32* %8
store double 0xBF60000000000000, double* %9
store double 0x3F60000000000000, double* %10
store i32 0, i32* %14
store i64 0, i64* %15
store double 0.000000e+00, double* %24
store i32 0, i32* %25
store i64 1, i64* %26
%48 = call i64 @time(i32 0)
store i64 %48, i64* %27
%49 = load i64, i64* %27
store i64 %49, i64* %28
%50 = load i32, i32* %13
%51 = call i32 @mpfr_init2(i32 %50, i32 200)
%52 = load i32, i32* %20
%53 = call i32 @mpfr_init2(i32 %52, i32 200)
store i32 0, i32* %29
br label %54
54: ; preds = %63, %2
%55 = load i32, i32* %29
%56 = icmp slt i32 %55, 10
br i1 %56, label %57, label %66
57: ; preds = %54
%58 = load i32, i32* %29
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = call i32 @mpfr_init2(i32 %61, i32 200)
br label %63
63: ; preds = %57
%64 = load i32, i32* %29
%65 = add nsw i32 %64, 1
store i32 %65, i32* %29
br label %54
66: ; preds = %54
%67 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%68 = load i32, i32* %67
%69 = load double, double* %9
%70 = load i32, i32* @MPFR_RNDN
%71 = call i32 @mpfr_set_d(i32 %68, double %69, i32 %70)
%72 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 2
%73 = load i32, i32* %72
%74 = load double, double* %10
%75 = load i32, i32* @MPFR_RNDN
%76 = call i32 @mpfr_set_d(i32 %73, double %74, i32 %75)
%77 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 3
%78 = load i32, i32* %77
%79 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 2
%80 = load i32, i32* %79
%81 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%82 = load i32, i32* %81
%83 = load i32, i32* @MPFR_RNDN
%84 = call i32 @mpfr_add(i32 %78, i32 %80, i32 %82, i32 %83)
%85 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 4
%86 = load i32, i32* %85
%87 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 2
%88 = load i32, i32* %87
%89 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%90 = load i32, i32* %89
%91 = load i32, i32* @MPFR_RNDN
%92 = call i32 @mpfr_sub(i32 %86, i32 %88, i32 %90, i32 %91)
%93 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 3
%94 = load i32, i32* %93
%95 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 3
%96 = load i32, i32* %95
%97 = load i32, i32* @MPFR_RNDN
%98 = call i32 @mpfr_div_si(i32 %94, i32 %96, i32 2, i32 %97)
%99 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 4
%100 = load i32, i32* %99
%101 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 4
%102 = load i32, i32* %101
%103 = load i32, i32* @MPFR_RNDN
%104 = call i32 @mpfr_div_si(i32 %100, i32 %102, i32 2, i32 %103)
store i32 0, i32* %30
br label %105
105: ; preds = %189, %66
%106 = load i32, i32* %30
%107 = icmp slt i32 %106, 7
br i1 %107, label %108, label %192
108: ; preds = %105
%109 = load i32, i32* %30
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %110
%112 = load i32, i32* %111
%113 = call i32 @mpfr_init2(i32 %112, i32 200)
%114 = load i32, i32* %30
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %115
%117 = load i32, i32* %116
%118 = call i32 @mpfr_init2(i32 %117, i32 200)
%119 = load i32, i32* %30
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [7 x i32], [7 x i32]* %19, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = call i32 @mpfr_init2(i32 %122, i32 200)
%124 = load i32, i32* %30
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [7 x i32], [7 x i32]* %19, i64 0, i64 %125
%127 = load i32, i32* %126
%128 = load i32, i32* @MPFR_RNDN
%129 = call i32 @mpfr_set_si(i32 %127, i64 0, i32 %128)
%130 = load i32, i32* %30
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [7 x i32], [7 x i32]* %23, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = call i32 @mpfr_init2(i32 %133, i32 200)
%135 = load i32, i32* %30
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = load i32, i32* %30
%140 = mul nsw i32 2, %139
%141 = sub nsw i32 %140, 1
%142 = sext i32 %141 to i64
%143 = load i32, i32* @MPFR_RNDN
%144 = call i32 @mpfr_set_si(i32 %138, i64 %142, i32 %143)
%145 = load i32, i32* %30
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %146
%148 = load i32, i32* %147
%149 = load i32, i32* %30
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %150
%152 = load i32, i32* %151
%153 = load i32, i32* @MPFR_RNDN
%154 = call i32 @mpfr_div_si(i32 %148, i32 %152, i32 14, i32 %153)
%155 = load i32, i32* %30
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %156
%158 = load i32, i32* %157
%159 = load i32, i32* %30
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %160
%162 = load i32, i32* %161
%163 = load i32, i32* @MPFR_RNDN
%164 = call i32 @mpfr_cos(i32 %158, i32 %162, i32 %163)
%165 = load i32, i32* %30
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %166
%168 = load i32, i32* %167
%169 = load i32, i32* %30
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %170
%172 = load i32, i32* %171
%173 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 4
%174 = load i32, i32* %173
%175 = load i32, i32* @MPFR_RNDN
%176 = call i32 @mpfr_mul(i32 %168, i32 %172, i32 %174, i32 %175)
%177 = load i32, i32* %30
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %178
%180 = load i32, i32* %179
%181 = load i32, i32* %30
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %182
%184 = load i32, i32* %183
%185 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 3
%186 = load i32, i32* %185
%187 = load i32, i32* @MPFR_RNDN
%188 = call i32 @mpfr_add(i32 %180, i32 %184, i32 %186, i32 %187)
br label %189
189: ; preds = %108
%190 = load i32, i32* %30
%191 = add nsw i32 %190, 1
store i32 %191, i32* %30
br label %105
192: ; preds = %105
store i32 0, i32* %31
br label %193
193: ; preds = %268, %192
%194 = load i32, i32* %31
%195 = icmp slt i32 %194, 7
br i1 %195, label %196, label %271
196: ; preds = %193
%197 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%198 = load i32, i32* %197
%199 = load i32, i32* @MPFR_RNDN
%200 = call i32 @mpfr_set_si(i32 %198, i64 1, i32 %199)
store i32 0, i32* %32
br label %201
201: ; preds = %242, %196
%202 = load i32, i32* %32
%203 = icmp slt i32 %202, 6
br i1 %203, label %204, label %245
204: ; preds = %201
%205 = load i32, i32* %31
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %21, i64 0, i64 %206
%208 = load i32, i32* %32
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [7 x i32], [7 x i32]* %207, i64 0, i64 %209
%211 = load i32, i32* %210
%212 = call i32 @mpfr_init2(i32 %211, i32 200)
%213 = load i32, i32* %31
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %22, i64 0, i64 %214
%216 = load i32, i32* %32
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [7 x i32], [7 x i32]* %215, i64 0, i64 %217
%219 = load i32, i32* %218
%220 = call i32 @mpfr_init2(i32 %219, i32 200)
%221 = load i32, i32* %31
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %21, i64 0, i64 %222
%224 = load i32, i32* %32
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds [7 x i32], [7 x i32]* %223, i64 0, i64 %225
%227 = load i32, i32* %226
%228 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%229 = load i32, i32* %228
%230 = load i32, i32* @MPFR_RNDN
%231 = call i32 @mpfr_set(i32 %227, i32 %229, i32 %230)
%232 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%233 = load i32, i32* %232
%234 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 1
%235 = load i32, i32* %234
%236 = load i32, i32* %31
%237 = sext i32 %236 to i64
%238 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %237
%239 = load i32, i32* %238
%240 = load i32, i32* @MPFR_RNDN
%241 = call i32 @mpfr_mul(i32 %233, i32 %235, i32 %239, i32 %240)
br label %242
242: ; preds = %204
%243 = load i32, i32* %32
%244 = add nsw i32 %243, 1
store i32 %244, i32* %32
br label %201
245: ; preds = %201
%246 = load i32, i32* %31
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %21, i64 0, i64 %247
%249 = getelementptr inbounds [7 x i32], [7 x i32]* %248, i64 0, i64 6
%250 = load i32, i32* %249
%251 = call i32 @mpfr_init2(i32 %250, i32 200)
%252 = load i32, i32* %31
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %22, i64 0, i64 %253
%255 = getelementptr inbounds [7 x i32], [7 x i32]* %254, i64 0, i64 6
%256 = load i32, i32* %255
%257 = call i32 @mpfr_init2(i32 %256, i32 200)
%258 = load i32, i32* %31
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %21, i64 0, i64 %259
%261 = getelementptr inbounds [7 x i32], [7 x i32]* %260, i64 0, i64 6
%262 = load i32, i32* %261
%263 = load i64, i64* %26
%264 = load i32, i32* @MPFR_RNDN
%265 = call i32 @mpfr_set_si(i32 %262, i64 %263, i32 %264)
%266 = load i64, i64* %26
%267 = mul nsw i64 %266, -1
store i64 %267, i64* %26
br label %268
268: ; preds = %245
%269 = load i32, i32* %31
%270 = add nsw i32 %269, 1
store i32 %270, i32* %31
br label %193
271: ; preds = %193
%272 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %21, i64 0, i64 0
%273 = bitcast [7 x i32]* %272 to i32**
%274 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %22, i64 0, i64 0
%275 = bitcast [7 x i32]* %274 to i32**
%276 = call i32 @invert_poorly(i32** %273, i32** %275)
br label %277
277: ; preds = %455, %271
%278 = load i32, i32* %6
%279 = icmp slt i32 %278, 268435456
br i1 %279, label %280, label %456
280: ; preds = %277
%281 = load i32, i32* %8
%282 = load i32, i32* %6
%283 = add nsw i32 %281, %282
store i32 %283, i32* %11
%284 = bitcast i32* %11 to i8*
%285 = bitcast i8* %284 to double*
%286 = load double, double* %285
store double %286, double* %12
%287 = load i32, i32* %13
%288 = load double, double* %12
%289 = load i32, i32* @MPFR_RNDN
%290 = call i32 @mpfr_set_d(i32 %287, double %288, i32 %289)
store i32 0, i32* %33
br label %291
291: ; preds = %316, %280
%292 = load i32, i32* %33
%293 = icmp slt i32 %292, 7
br i1 %293, label %294, label %319
294: ; preds = %291
%295 = load i32, i32* %33
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds [7 x i32], [7 x i32]* %23, i64 0, i64 %296
%298 = load i32, i32* %297
%299 = load i32, i32* %33
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds [7 x i32], [7 x i32]* %17, i64 0, i64 %300
%302 = load i32, i32* %301
%303 = load i32, i32* %13
%304 = load i32, i32* @MPFR_RNDN
%305 = call i32 @mpfr_sub(i32 %298, i32 %302, i32 %303, i32 %304)
%306 = load i32, i32* %33
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds [7 x i32], [7 x i32]* %23, i64 0, i64 %307
%309 = load i32, i32* %308
%310 = load i32, i32* %33
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds [7 x i32], [7 x i32]* %23, i64 0, i64 %311
%313 = load i32, i32* %312
%314 = load i32, i32* @MPFR_RNDN
%315 = call i32 @mpfr_atan(i32 %309, i32 %313, i32 %314)
br label %316
316: ; preds = %294
%317 = load i32, i32* %33
%318 = add nsw i32 %317, 1
store i32 %318, i32* %33
br label %291
319: ; preds = %291
store i32 0, i32* %34
br label %320
320: ; preds = %369, %319
%321 = load i32, i32* %34
%322 = icmp slt i32 %321, 7
br i1 %322, label %323, label %372
323: ; preds = %320
%324 = load i32, i32* %34
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %325
%327 = load i32, i32* %326
%328 = load i32, i32* @MPFR_RNDN
%329 = call i32 @mpfr_set_si(i32 %327, i64 0, i32 %328)
store i32 0, i32* %35
br label %330
330: ; preds = %365, %323
%331 = load i32, i32* %35
%332 = icmp slt i32 %331, 7
br i1 %332, label %333, label %368
333: ; preds = %330
%334 = load i32, i32* %34
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 %335
%337 = load i32, i32* %336
%338 = load i32, i32* %34
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds [7 x [7 x i32]], [7 x [7 x i32]]* %22, i64 0, i64 %339
%341 = load i32, i32* %35
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds [7 x i32], [7 x i32]* %340, i64 0, i64 %342
%344 = load i32, i32* %343
%345 = load i32, i32* %35
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds [7 x i32], [7 x i32]* %23, i64 0, i64 %346
%348 = load i32, i32* %347
%349 = load i32, i32* @MPFR_RNDN
%350 = call i32 @mpfr_mul(i32 %337, i32 %344, i32 %348, i32 %349)
%351 = load i32, i32* %34
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %352
%354 = load i32, i32* %353
%355 = load i32, i32* %34
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %356
%358 = load i32, i32* %357
%359 = load i32, i32* %34
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 %360
%362 = load i32, i32* %361
%363 = load i32, i32* @MPFR_RNDN
%364 = call i32 @mpfr_add(i32 %354, i32 %358, i32 %362, i32 %363)
br label %365
365: ; preds = %333
%366 = load i32, i32* %35
%367 = add nsw i32 %366, 1
store i32 %367, i32* %35
br label %330
368: ; preds = %330
br label %369
369: ; preds = %368
%370 = load i32, i32* %34
%371 = add nsw i32 %370, 1
store i32 %371, i32* %34
br label %320
372: ; preds = %320
%373 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 6
%374 = load i32, i32* %373
%375 = load i32, i32* @MPFR_RNDN
%376 = call double @mpfr_get_d(i32 %374, i32 %375)
store double %376, double* %36
%377 = bitcast double* %36 to i8*
%378 = bitcast i8* %377 to i32*
%379 = load i32, i32* %378
%380 = and i32 %379, 1
%381 = icmp ne i32 %380, 0
br i1 %381, label %382, label %383
382: ; preds = %372
br label %446
383: ; preds = %372
%384 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 0
%385 = load i32, i32* %384
%386 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 0
%387 = load i32, i32* %386
%388 = call i32 @leeway_of(i32 %385, i32 %387)
store i32 %388, i32* %37
store i32 0, i32* %38
store i32 0, i32* %39
%389 = load i32, i32* %37
%390 = load i32, i32* %5
%391 = icmp sle i32 %389, %390
br i1 %391, label %392, label %393
392: ; preds = %383
br label %446
393: ; preds = %383
%394 = getelementptr inbounds [10 x i32], [10 x i32]* %16, i64 0, i64 0
%395 = load i32, i32* %394
%396 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 1
%397 = load i32, i32* %396
%398 = call i32 @leeway_of(i32 %395, i32 %397)
store i32 %398, i32* %38
%399 = load i32, i32* %38
%400 = add nsw i32 %399, 4
%401 = load i32, i32* %5
%402 = icmp sle i32 %400, %401
br i1 %402, label %403, label %404
403: ; preds = %393
br label %446
404: ; preds = %393
%405 = load i32, i32* %37
%406 = load i32, i32* %38
%407 = add nsw i32 %406, 4
%408 = icmp slt i32 %405, %407
br i1 %408, label %409, label %411
409: ; preds = %404
%410 = load i32, i32* %37
br label %414
411: ; preds = %404
%412 = load i32, i32* %38
%413 = add nsw i32 %412, 4
br label %414
414: ; preds = %411, %409
%415 = phi i32 [ %410, %409 ], [ %413, %411 ]
store i32 %415, i32* %39
%416 = load i32, i32* %39
%417 = load i32, i32* %14
%418 = icmp sle i32 %416, %417
br i1 %418, label %419, label %420
419: ; preds = %414
br label %446
420: ; preds = %414
%421 = load i32, i32* %39
store i32 %421, i32* %14
%422 = load i32, i32* %6
%423 = sext i32 %422 to i64
store i64 %423, i64* %15
%424 = load i32, i32* %20
%425 = load i32, i32* %13
%426 = load i32, i32* @MPFR_RNDN
%427 = call i32 @mpfr_set(i32 %424, i32 %425, i32 %426)
store i32 0, i32* %40
br label %428
428: ; preds = %442, %420
%429 = load i32, i32* %40
%430 = icmp slt i32 %429, 7
br i1 %430, label %431, label %445
431: ; preds = %428
%432 = load i32, i32* %40
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds [7 x i32], [7 x i32]* %19, i64 0, i64 %433
%435 = load i32, i32* %434
%436 = load i32, i32* %40
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [7 x i32], [7 x i32]* %18, i64 0, i64 %437
%439 = load i32, i32* %438
%440 = load i32, i32* @MPFR_RNDN
%441 = call i32 @mpfr_set(i32 %435, i32 %439, i32 %440)
br label %442
442: ; preds = %431
%443 = load i32, i32* %40
%444 = add nsw i32 %443, 1
store i32 %444, i32* %40
br label %428
445: ; preds = %428
br label %446
446: ; preds = %445, %419, %403, %392, %382
%447 = load i32, i32* %6
%448 = icmp sle i32 %447, 0
br i1 %448, label %449, label %452
449: ; preds = %446
%450 = load i32, i32* %6
%451 = sub nsw i32 1, %450
store i32 %451, i32* %6
br label %455
452: ; preds = %446
%453 = load i32, i32* %6
%454 = sub nsw i32 0, %453
store i32 %454, i32* %6
br label %455
455: ; preds = %452, %449
br label %277
456: ; preds = %277
%457 = call i64 @time(i32 0)
store i64 %457, i64* %28
%458 = load i32, i32* %14
%459 = load i32, i32* %5
%460 = icmp slt i32 %458, %459
br i1 %460, label %461, label %462
461: ; preds = %456
store i32 -1, i32* %3
br label %505
462: ; preds = %456
%463 = load i32, i32* %20
%464 = load i32, i32* @MPFR_RNDN
%465 = call double @mpfr_get_d(i32 %463, i32 %464)
store double %465, double* %24
%466 = bitcast double* %24 to i8*
%467 = bitcast i8* %466 to i32*
%468 = load i32, i32* %467
store i32 %468, i32* %25
%469 = load i32, i32* %25
%470 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i32 %469)
store i32 0, i32* %41
br label %471
471: ; preds = %485, %462
%472 = load i32, i32* %41
%473 = icmp slt i32 %472, 5
br i1 %473, label %474, label %488
474: ; preds = %471
%475 = load i32, i32* %41
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds [7 x i32], [7 x i32]* %19, i64 0, i64 %476
%478 = load i32, i32* %477
%479 = load i32, i32* @MPFR_RNDN
%480 = call double @mpfr_get_d(i32 %478, i32 %479)
store double %480, double* %24
%481 = bitcast double* %24 to i8*
%482 = bitcast i8* %481 to i32*
%483 = load i32, i32* %482
%484 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 %483)
br label %485
485: ; preds = %474
%486 = load i32, i32* %41
%487 = add nsw i32 %486, 1
store i32 %487, i32* %41
br label %471
488: ; preds = %471
%489 = getelementptr inbounds [7 x i32], [7 x i32]* %19, i64 0, i64 5
%490 = load i32, i32* %489
%491 = load i32, i32* @MPFR_RNDN
%492 = call double @mpfr_get_d(i32 %490, i32 %491)
store double %492, double* %24
%493 = bitcast double* %24 to i8*
%494 = bitcast i8* %493 to i32*
%495 = load i32, i32* %494
store i32 %495, i32* %25
%496 = load i32, i32* %25
%497 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0), i32 %496)
%498 = load i32, i32* %4
%499 = load i32, i32* %14
%500 = load i64, i64* %15
%501 = load i64, i64* %28
%502 = load i64, i64* %27
%503 = sub nsw i64 %501, %502
%504 = call i32 (i8*, i32, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.3, i64 0, i64 0), i32 %498, i32 %499, i64 %500, i64 %503)
store i32 0, i32* %3
br label %505
505: ; preds = %488, %461
%506 = load i32, i32* %3
ret i32 %506
}

LLVM IR (-O2):
@MPFR_RNDN = global i32 0
define i32 @find_tuple(i32 %0, i32 %1) {
%3 = tail call i64 @time(i32 0)
%4 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%5 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%6 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%7 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%8 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%9 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%10 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%11 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%12 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%13 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%14 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%15 = tail call i32 @mpfr_init2(i32 undef, i32 200)
%16 = load i32, i32* @MPFR_RNDN
%17 = tail call i32 @mpfr_set_d(i32 undef, double 0xBF60000000000000, i32 %16)
%18 = load i32, i32* @MPFR_RNDN
%19 = tail call i32 @mpfr_set_d(i32 undef, double 0x3F60000000000000, i32 %18)
%20 = load i32, i32* @MPFR_RNDN
%21 = tail call i32 @mpfr_add(i32 undef, i32 undef, i32 undef, i32 %20)
%22 = load i32, i32* @MPFR_RNDN
%23 = tail call i32 @mpfr_sub(i32 undef, i32 undef, i32 undef, i32 %22)
%24 = load i32, i32* @MPFR_RNDN
%25 = tail call i32 @mpfr_div_si(i32 undef, i32 undef, i32 2, i32 %24)
%26 = load i32, i32* @MPFR_RNDN
%27 = tail call i32 @mpfr_div_si(i32 undef, i32 undef, i32 2, i32 %26)
unreachable
}