#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 mp_size_t;
typedef unsigned long mp_limb_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
unsigned long call_mulredc(int, unsigned long *, unsigned long *,
                           unsigned long *, unsigned long *, unsigned long);
unsigned long call_mulredc1(int, unsigned long *, unsigned long,
                            unsigned long *, unsigned long *, unsigned long);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(unsigned long *);
scalar_t__ malloc(int);
scalar_t__ mpn_cmp(unsigned long *, unsigned long *, int);
unsigned long mpn_mul_1(unsigned long *, unsigned long *, int, unsigned long);
int /*<<< orphan*/ mpn_mul_n(unsigned long *, unsigned long *, unsigned long *,
                             int);
int /*<<< orphan*/ mpn_random2(unsigned long *, int);
int /*<<< orphan*/ mpn_tdiv_qr(unsigned long *, unsigned long *,
                               int /*<<< orphan*/, unsigned long *, int,
                               unsigned long *, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ stderr;
void test(mp_size_t N, int k) {
  mp_limb_t *x, *y, *yp, *z, *m, invm, cy, cy2, *tmp, *tmp2, *tmp3;
  int i, j;
  x = (mp_limb_t *)malloc(N * sizeof(mp_limb_t));
  y = (mp_limb_t *)malloc(N * sizeof(mp_limb_t));
  z = (mp_limb_t *)malloc((N + 1) * sizeof(mp_limb_t));
  m = (mp_limb_t *)malloc(N * sizeof(mp_limb_t));
  tmp = (mp_limb_t *)malloc((2 * N + 2) * sizeof(mp_limb_t));
  tmp2 = (mp_limb_t *)malloc((2 * N + 2) * sizeof(mp_limb_t));
  tmp3 = (mp_limb_t *)malloc((2 * N + 2) * sizeof(mp_limb_t));
  if (x == NULL || y == NULL || z == NULL || m == NULL || tmp == NULL ||
      tmp2 == NULL || tmp3 == NULL) {
    fprintf(stderr, "Cannot allocate memory in test_mulredc\n");
    exit(1);
  }
  mpn_random2(m, N);
  m[0] |= 1UL;
  if (m[N - 1] == 0)
    m[N - 1] = 1UL;
  invm = 1UL;
  for (i = 0; i < 10; ++i)
    invm = (2 * invm - m[0] * invm * invm);
  invm = -invm;
  assert((invm * m[0] + 1UL) == 0UL);
  yp = y;
  for (i = 0; i < k; ++i) {
    if (i == 0) {
      for (j = 0; j < N; j++)
        x[j] = y[j] = 0;
    } else if (i == 1) {
      for (j = 0; j < N; j++)
        x[j] = y[j] = 1;
    } else if (i == 2) {
      for (j = 0; j < N; j++)
        x[j] = y[j] = ~(0UL);
    } else {
      if (i % 2 == 0) {
        mpn_random2(x, N);
        yp = x;
      } else {
        mpn_random2(x, N);
        mpn_random2(y, N);
      }
    }
    cy = call_mulredc(N, z, x, yp, m, invm);
    if (cy)
      printf("!");
    z[N] = cy;
    for (j = 0; j < N; ++j) {
      tmp[j] = 0;
      tmp[j + N] = z[j];
    }
    tmp[2 * N] = z[N];
    mpn_tdiv_qr(tmp2, tmp3, 0, tmp, 2 * N + 1, m, N);
    for (j = 0; j < N; ++j)
      z[j] = tmp3[j];
    mpn_mul_n(tmp, x, yp, N);
    mpn_tdiv_qr(tmp2, tmp3, 0, tmp, 2 * N, m, N);
    assert(mpn_cmp(z, tmp3, N) == 0);
    z[N] = call_mulredc1(N, z, x[0], yp, m, invm);
    tmp[0] = 0;
    for (j = 0; j <= N; ++j)
      tmp[j + 1] = z[j];
    mpn_tdiv_qr(tmp2, tmp3, 0, tmp, N + 2, m, N);
    for (j = 0; j < N; ++j)
      z[j] = tmp3[j];
    tmp[N] = mpn_mul_1(tmp, yp, N, x[0]);
    mpn_tdiv_qr(tmp2, tmp3, 0, tmp, N + 1, m, N);
    assert(mpn_cmp(z, tmp3, N) == 0);
  }
  free(tmp);
  free(tmp2);
  free(tmp3);
  free(x);
  free(y);
  free(z);
  free(m);
}


x86 assembly (clang, -O0):
<test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x10(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x18(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x28(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x30(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x50(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x58(%rbp)
je     12c9 <test+0xf9>
cmpq   $0x0,-0x60(%rbp)
jne    12e8 <test+0x118>
mov    0x2d10(%rip),%rax
mov    (%rax),%edi
lea    0xd27(%rip),%rsi
call   1080 <fprintf@plt>
mov    $0x1,%edi
call   10f0 <exit@plt>
mov    -0x30(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   10c0 <mpn_random2@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
or     $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    132f <test+0x15f>
mov    -0x30(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movq   $0x1,(%rax,%rcx,8)
movq   $0x1,-0x38(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0xa,-0x64(%rbp)
jge    1376 <test+0x1a6>
mov    -0x38(%rbp),%rax
shl    $0x1,%rax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%rcx
imul   -0x38(%rbp),%rcx
imul   -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    133e <test+0x16e>
xor    %eax,%eax
sub    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
imul   (%rcx),%rax
add    $0x1,%rax
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    17bd <test+0x5ed>
cmpl   $0x0,-0x64(%rbp)
jne    140c <test+0x23c>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1407 <test+0x237>
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13cd <test+0x1fd>
jmp    1500 <test+0x330>
cmpl   $0x1,-0x64(%rbp)
jne    145c <test+0x28c>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1457 <test+0x287>
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0x1,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0x1,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    141d <test+0x24d>
jmp    14fb <test+0x32b>
cmpl   $0x2,-0x64(%rbp)
jne    14ac <test+0x2dc>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14a7 <test+0x2d7>
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0xffffffffffffffff,(%rax,%rcx,8)
ff
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0xffffffffffffffff,(%rax,%rcx,8)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    146d <test+0x29d>
jmp    14f6 <test+0x326>
mov    -0x64(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    14d9 <test+0x309>
mov    -0x10(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   10c0 <mpn_random2@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    14f1 <test+0x321>
mov    -0x10(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   10c0 <mpn_random2@plt>
mov    -0x18(%rbp),%rdi
mov    -0x4(%rbp),%esi
call   10c0 <mpn_random2@plt>
jmp    14f6 <test+0x326>
jmp    14fb <test+0x32b>
jmp    1500 <test+0x330>
mov    -0x4(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
call   10b0 <call_mulredc@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1537 <test+0x367>
lea    0xaf6(%rip),%rdi
call   1050 <printf@plt>
mov    -0x40(%rbp),%rdx
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1595 <test+0x3c5>
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x50(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x4(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    154e <test+0x37e>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x50(%rbp),%rax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x50(%rbp),%rcx
mov    -0x4(%rbp),%r8d
shl    $0x1,%r8d
add    $0x1,%r8d
mov    -0x30(%rbp),%r9
mov    -0x4(%rbp),%eax
xor    %edx,%edx
mov    %eax,(%rsp)
call   10e0 <mpn_tdiv_qr@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1614 <test+0x444>
mov    -0x60(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    15e2 <test+0x412>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x4(%rbp),%ecx
call   1040 <mpn_mul_n@plt>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x50(%rbp),%rcx
mov    -0x4(%rbp),%r8d
shl    $0x1,%r8d
mov    -0x30(%rbp),%r9
mov    -0x4(%rbp),%eax
xor    %edx,%edx
mov    %eax,(%rsp)
call   10e0 <mpn_tdiv_qr@plt>
mov    -0x28(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x4(%rbp),%edx
call   1090 <mpn_cmp@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0x4(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
call   10d0 <call_mulredc1@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movq   $0x0,(%rax)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16e5 <test+0x515>
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x50(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16ae <test+0x4de>
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x50(%rbp),%rcx
mov    -0x4(%rbp),%r8d
add    $0x2,%r8d
mov    -0x30(%rbp),%r9
mov    -0x4(%rbp),%eax
xor    %edx,%edx
mov    %eax,(%rsp)
call   10e0 <mpn_tdiv_qr@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1743 <test+0x573>
mov    -0x60(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1711 <test+0x541>
mov    -0x50(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x4(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
call   1060 <mpn_mul_1@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x50(%rbp),%rcx
mov    -0x4(%rbp),%r8d
add    $0x1,%r8d
mov    -0x30(%rbp),%r9
mov    -0x4(%rbp),%eax
xor    %edx,%edx
mov    %eax,(%rsp)
call   10e0 <mpn_tdiv_qr@plt>
mov    -0x28(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x4(%rbp),%edx
call   1090 <mpn_cmp@plt>
cmp    $0x0,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13b0 <test+0x1e0>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x10(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %esi,0x90(%rsp)
mov    %edi,%ebp
lea    0x0(,%rbp,8),%r12d
mov    %r12d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
mov    %r12d,%edi
call   10a0 <malloc@plt>
mov    %rax,0x28(%rsp)
lea    0x8(,%rbp,8),%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %r12d,%edi
call   10a0 <malloc@plt>
mov    %rax,%r12
mov    %rbp,0x18(%rsp)
shl    $0x4,%ebp
add    $0x10,%ebp
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   10a0 <malloc@plt>
mov    %rax,0x48(%rsp)
mov    %ebp,%edi
call   10a0 <malloc@plt>
test   %r14,%r14
je     23e3 <test+0x1213>
cmpq   $0x0,0x28(%rsp)
je     23e3 <test+0x1213>
test   %rbx,%rbx
je     23e3 <test+0x1213>
mov    %r12,%rdi
test   %r12,%r12
je     23e3 <test+0x1213>
test   %r13,%r13
je     23e3 <test+0x1213>
cmpq   $0x0,0x48(%rsp)
je     23e3 <test+0x1213>
mov    %rax,%r12
test   %rax,%rax
je     23e3 <test+0x1213>
mov    %r14,0x78(%rsp)
mov    0x18(%rsp),%rsi
movslq %esi,%rbp
mov    %rdi,0x40(%rsp)
call   10c0 <mpn_random2@plt>
mov    0x40(%rsp),%r8
mov    (%r8),%rax
or     $0x1,%rax
mov    %rax,(%r8)
mov    %rbp,0x38(%rsp)
cmpq   $0x0,-0x8(%r8,%rbp,8)
jne    12de <test+0x10e>
mov    0x38(%rsp),%rax
add    $0xffffffffffffffff,%rax
movq   $0x1,(%r8,%rax,8)
mov    (%r8),%rax
mov    $0x2,%ecx
mov    $0x2,%edx
sub    %rax,%rdx
mov    %rax,%rsi
imul   %rdx,%rsi
mov    $0x2,%edi
sub    %rsi,%rdi
imul   %rdx,%rdi
mov    %rax,%rdx
imul   %rdi,%rdx
mov    $0x2,%esi
sub    %rdx,%rsi
imul   %rdi,%rsi
mov    %rax,%rdx
imul   %rsi,%rdx
mov    $0x2,%edi
sub    %rdx,%rdi
imul   %rsi,%rdi
mov    %rax,%rdx
imul   %rdi,%rdx
mov    $0x2,%esi
sub    %rdx,%rsi
imul   %rdi,%rsi
mov    %rax,%rdx
imul   %rsi,%rdx
mov    $0x2,%edi
sub    %rdx,%rdi
imul   %rsi,%rdi
mov    %rax,%rdx
imul   %rdi,%rdx
mov    $0x2,%esi
sub    %rdx,%rsi
imul   %rdi,%rsi
mov    %rax,%rdx
imul   %rsi,%rdx
mov    $0x2,%edi
sub    %rdx,%rdi
imul   %rsi,%rdi
mov    %rax,%rdx
imul   %rdi,%rdx
sub    %rdx,%rcx
imul   %rdi,%rcx
mov    %rax,%rdx
imul   %rcx,%rdx
add    $0xfffffffffffffffe,%rdx
imul   %rcx,%rdx
mov    %rdx,0xd8(%rsp)
imul   %rdx,%rax
xor    %edi,%edi
cmp    $0xffffffffffffffff,%rax
sete   %dil
mov    %r8,%rbp
call   1070 <assert@plt>
cmpl   $0x0,0x90(%rsp)
jle    2394 <test+0x11c4>
mov    0x18(%rsp),%rdx
lea    0x1(%rdx),%eax
lea    (%rdx,%rdx,1),%ecx
mov    %rdx,%rsi
mov    %ecx,0xac(%rsp)
movslq %ecx,%rdx
mov    %rdx,%rcx
mov    %rdx,0xd0(%rsp)
or     $0x1,%ecx
mov    %ecx,0x8c(%rsp)
mov    %esi,%edi
mov    %eax,0x94(%rsp)
mov    %eax,%r11d
mov    0x38(%rsp),%r9
lea    (%r9,%rdi,1),%rax
lea    0x0(%r13,%rax,8),%r14
mov    0x28(%rsp),%r15
lea    (%r15,%rdi,8),%r8
mov    0x78(%rsp),%rax
lea    (%rax,%rdi,8),%rdx
mov    %rax,%rcx
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0x58(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r11d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x110(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x108(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
cmp    %rdx,%r15
setb   %dl
cmp    %r8,%rcx
setb   %al
and    %dl,%al
mov    %al,0x16(%rsp)
mov    %ebp,%r10d
and    $0x3,%r10d
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rsp)
mov    %edi,%eax
and    $0x3,%eax
mov    %rax,0x68(%rsp)
cmp    %r14,%r13
setb   %r8b
lea    0x0(,%rdi,8),%rdx
add    %r13,%rdx
lea    0x0(,%r9,8),%rcx
add    %r13,%rcx
cmp    %rdx,%rcx
setb   %al
and    %r8b,%al
lea    (%rbx,%rdi,8),%r8
cmp    %r8,%r13
setb   %r9b
cmp    %rdx,%rbx
setb   %dl
and    %r9b,%dl
or     %al,%dl
mov    %rcx,0xc8(%rsp)
cmp    %r8,%rcx
setb   %al
cmp    %r14,%rbx
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0x27(%rsp)
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
or     $0x2,%rcx
mov    %rbp,%rax
mov    %rbp,0x70(%rsp)
and    %rbp,%rcx
mov    %rcx,0xf8(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x120(%rsp)
lea    (%r12,%rdi,8),%rax
cmp    %rax,%rbx
setb   %al
cmp    %r8,%r12
setb   %cl
and    %al,%cl
mov    %cl,0x17(%rsp)
lea    0x8(%r13),%rax
lea    (%rbx,%r11,8),%rcx
cmp    %rcx,%rax
setb   %al
lea    0x8(,%r11,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rbx
setb   %cl
and    %al,%cl
mov    %cl,0x26(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,0xc0(%rsp)
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0xf0(%rsp)
mov    %r11,0x128(%rsp)
and    $0x3,%r11d
mov    %r11,0x118(%rsp)
mov    0x78(%rsp),%rax
add    $0x10,%rax
mov    %rax,0xa0(%rsp)
mov    %r15,%rax
add    $0x10,%rax
mov    %rax,0x98(%rsp)
mov    %r10,0xe8(%rsp)
shl    $0x5,%r10
mov    %r13,%rax
add    $0x30,%rax
mov    %rax,0x100(%rsp)
mov    %rbx,%rax
add    $0x10,%rax
mov    %rax,0xb8(%rsp)
mov    %r12,%rax
add    $0x10,%rax
mov    %rax,0xb0(%rsp)
pxor   %xmm0,%xmm0
mov    0x18(%rsp),%rax
add    $0x2,%eax
mov    %eax,0xa8(%rsp)
xor    %ecx,%ecx
mov    %r15,%r14
mov    %rdi,0x30(%rsp)
mov    %r10,0x80(%rsp)
jmp    168e <test+0x4be>
nopl   0x0(%rax)
mov    (%r15),%rcx
mov    %r13,%rdi
mov    0xe0(%rsp),%r14
mov    %r14,%rsi
mov    %rdx,%r15
call   1060 <mpn_mul_1@plt>
mov    0x38(%rsp),%rcx
mov    %rax,0x0(%r13,%rcx,8)
mov    %r15d,(%rsp)
mov    0x48(%rsp),%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    %r13,%rcx
mov    0x94(%rsp),%r8d
mov    0x40(%rsp),%rbp
mov    %rbp,%r9
call   10e0 <mpn_tdiv_qr@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %r15d,%edx
call   1090 <mpn_cmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1070 <assert@plt>
mov    0x30(%rsp),%rdi
mov    0x130(%rsp),%rcx
add    $0x1,%ecx
cmp    0x90(%rsp),%ecx
mov    0x80(%rsp),%r10
pxor   %xmm0,%xmm0
je     2394 <test+0x11c4>
test   %ecx,%ecx
mov    %rcx,0x130(%rsp)
je     16e0 <test+0x510>
cmp    $0x1,%ecx
mov    0x18(%rsp),%rsi
mov    0x78(%rsp),%r15
je     1710 <test+0x540>
cmp    $0x2,%ecx
jne    1730 <test+0x560>
test   %esi,%esi
jle    1c30 <test+0xa60>
cmp    $0x4,%esi
setb   %al
or     0x16(%rsp),%al
je     1761 <test+0x591>
xor    %eax,%eax
mov    0x30(%rsp),%rdi
mov    0x28(%rsp),%rbp
jmp    1890 <test+0x6c0>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rsi
test   %esi,%esi
mov    0x78(%rsp),%r15
jle    1c30 <test+0xa60>
cmp    $0x4,%esi
setb   %al
or     0x16(%rsp),%al
je     177e <test+0x5ae>
xor    %eax,%eax
mov    0x28(%rsp),%rbp
jmp    1a10 <test+0x840>
xchg   %ax,%ax
test   %esi,%esi
jle    1c30 <test+0xa60>
cmp    $0x4,%esi
setb   %al
or     0x16(%rsp),%al
je     1796 <test+0x5c6>
xor    %eax,%eax
mov    0x28(%rsp),%rbp
jmp    1b90 <test+0x9c0>
mov    %r15,%rdi
mov    %rcx,%rbp
call   10c0 <mpn_random2@plt>
mov    0x18(%rsp),%rsi
mov    %r15,%rcx
test   $0x1,%bpl
je     1c33 <test+0xa63>
mov    0x28(%rsp),%rdi
call   10c0 <mpn_random2@plt>
mov    0x18(%rsp),%rsi
jmp    1c30 <test+0xa60>
cmpq   $0xc,0x50(%rsp)
mov    0x30(%rsp),%rdi
pcmpeqd %xmm0,%xmm0
mov    0x28(%rsp),%rbp
jae    17b6 <test+0x5e6>
xor    %eax,%eax
jmp    1831 <test+0x661>
cmpq   $0xc,0x50(%rsp)
mov    0x28(%rsp),%rbp
jae    1935 <test+0x765>
xor    %eax,%eax
jmp    19b1 <test+0x7e1>
cmpq   $0xc,0x50(%rsp)
movdqa 0x185c(%rip),%xmm0
mov    0x28(%rsp),%rbp
jae    1ab5 <test+0x8e5>
xor    %eax,%eax
jmp    1b31 <test+0x961>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movdqu %xmm0,0x0(%rbp,%rax,8)
movdqu %xmm0,0x10(%rbp,%rax,8)
movdqu %xmm0,(%r15,%rax,8)
movdqu %xmm0,0x10(%r15,%rax,8)
movdqu %xmm0,0x20(%rbp,%rax,8)
movdqu %xmm0,0x30(%rbp,%rax,8)
movdqu %xmm0,0x20(%r15,%rax,8)
movdqu %xmm0,0x30(%r15,%rax,8)
movdqu %xmm0,0x40(%rbp,%rax,8)
movdqu %xmm0,0x50(%rbp,%rax,8)
movdqu %xmm0,0x40(%r15,%rax,8)
movdqu %xmm0,0x50(%r15,%rax,8)
movdqu %xmm0,0x60(%rbp,%rax,8)
movdqu %xmm0,0x70(%rbp,%rax,8)
movdqu %xmm0,0x60(%r15,%rax,8)
movdqu %xmm0,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    17c0 <test+0x5f0>
cmpq   $0x0,0xe8(%rsp)
je     187f <test+0x6af>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm0,(%rax,%rdx,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1860 <test+0x690>
mov    0x58(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1c30 <test+0xa60>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
mov    0x68(%rsp),%rdx
test   %rdx,%rdx
je     18cb <test+0x6fb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   $0xffffffffffffffff,0x0(%rbp,%rax,8)
ff ff
movq   $0xffffffffffffffff,(%r15,%rax,8)
ff
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18b0 <test+0x6e0>
cmp    $0x3,%rcx
jb     1c30 <test+0xa60>
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0xffffffffffffffff,0x0(%rbp,%rax,8)
ff ff
movq   $0xffffffffffffffff,(%r15,%rax,8)
ff
movq   $0xffffffffffffffff,0x8(%rbp,%rax,8)
ff ff
movq   $0xffffffffffffffff,0x8(%r15,%rax,8)
ff ff
movq   $0xffffffffffffffff,0x10(%rbp,%rax,8)
ff ff
movq   $0xffffffffffffffff,0x10(%r15,%rax,8)
ff ff
movq   $0xffffffffffffffff,0x18(%rbp,%rax,8)
ff ff
movq   $0xffffffffffffffff,0x18(%r15,%rax,8)
ff ff
add    $0x4,%rax
cmp    %rax,%rdi
jne    18e0 <test+0x710>
jmp    1c30 <test+0xa60>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movdqu %xmm0,0x0(%rbp,%rax,8)
movdqu %xmm0,0x10(%rbp,%rax,8)
movdqu %xmm0,(%r15,%rax,8)
movdqu %xmm0,0x10(%r15,%rax,8)
movdqu %xmm0,0x20(%rbp,%rax,8)
movdqu %xmm0,0x30(%rbp,%rax,8)
movdqu %xmm0,0x20(%r15,%rax,8)
movdqu %xmm0,0x30(%r15,%rax,8)
movdqu %xmm0,0x40(%rbp,%rax,8)
movdqu %xmm0,0x50(%rbp,%rax,8)
movdqu %xmm0,0x40(%r15,%rax,8)
movdqu %xmm0,0x50(%r15,%rax,8)
movdqu %xmm0,0x60(%rbp,%rax,8)
movdqu %xmm0,0x70(%rbp,%rax,8)
movdqu %xmm0,0x60(%r15,%rax,8)
movdqu %xmm0,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1940 <test+0x770>
testb  $0x3,0x70(%rsp)
je     19ff <test+0x82f>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm0,(%rax,%rdx,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    19e0 <test+0x810>
mov    0x58(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1c30 <test+0xa60>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   $0x3,%dil
mov    0x68(%rsp),%rdx
je     1a4b <test+0x87b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,0x0(%rbp,%rax,8)
movq   $0x0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1a30 <test+0x860>
cmp    $0x3,%rcx
jb     1c30 <test+0xa60>
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,0x0(%rbp,%rax,8)
movq   $0x0,(%r15,%rax,8)
movq   $0x0,0x8(%rbp,%rax,8)
movq   $0x0,0x8(%r15,%rax,8)
movq   $0x0,0x10(%rbp,%rax,8)
movq   $0x0,0x10(%r15,%rax,8)
movq   $0x0,0x18(%rbp,%rax,8)
movq   $0x0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1a60 <test+0x890>
jmp    1c30 <test+0xa60>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movdqu %xmm0,0x0(%rbp,%rax,8)
movdqu %xmm0,0x10(%rbp,%rax,8)
movdqu %xmm0,(%r15,%rax,8)
movdqu %xmm0,0x10(%r15,%rax,8)
movdqu %xmm0,0x20(%rbp,%rax,8)
movdqu %xmm0,0x30(%rbp,%rax,8)
movdqu %xmm0,0x20(%r15,%rax,8)
movdqu %xmm0,0x30(%r15,%rax,8)
movdqu %xmm0,0x40(%rbp,%rax,8)
movdqu %xmm0,0x50(%rbp,%rax,8)
movdqu %xmm0,0x40(%r15,%rax,8)
movdqu %xmm0,0x50(%r15,%rax,8)
movdqu %xmm0,0x60(%rbp,%rax,8)
movdqu %xmm0,0x70(%rbp,%rax,8)
movdqu %xmm0,0x60(%r15,%rax,8)
movdqu %xmm0,0x70(%r15,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1ac0 <test+0x8f0>
testb  $0x3,0x70(%rsp)
je     1b7f <test+0x9af>
mov    0xa0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x98(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm0,(%rax,%rdx,1)
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1b60 <test+0x990>
mov    0x58(%rsp),%rcx
mov    %rcx,%rax
cmp    %rdi,%rcx
je     1c30 <test+0xa60>
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
test   $0x3,%dil
mov    0x68(%rsp),%rdx
je     1bcb <test+0x9fb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x1,0x0(%rbp,%rax,8)
movq   $0x1,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1bb0 <test+0x9e0>
cmp    $0x3,%rcx
jb     1c30 <test+0xa60>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x1,0x0(%rbp,%rax,8)
movq   $0x1,(%r15,%rax,8)
movq   $0x1,0x8(%rbp,%rax,8)
movq   $0x1,0x8(%r15,%rax,8)
movq   $0x1,0x10(%rbp,%rax,8)
movq   $0x1,0x10(%r15,%rax,8)
movq   $0x1,0x18(%rbp,%rax,8)
movq   $0x1,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1be0 <test+0xa10>
mov    %r14,%rcx
mov    %esi,%edi
mov    %rbx,%rsi
mov    %r15,%rdx
mov    %rcx,0xe0(%rsp)
mov    0x40(%rsp),%r8
mov    0xd8(%rsp),%r9
call   10b0 <call_mulredc@plt>
mov    %rax,%rbp
test   %rax,%rax
je     1c67 <test+0xa97>
mov    $0x21,%edi
call   1040 <putchar@plt>
mov    0x38(%rsp),%rax
mov    %rbp,(%rbx,%rax,8)
mov    0x18(%rsp),%rsi
test   %esi,%esi
jle    1ca0 <test+0xad0>
cmp    $0x4,%esi
setb   %al
or     0x27(%rsp),%al
je     1ce0 <test+0xb10>
xor    %ecx,%ecx
mov    0x40(%rsp),%r9
mov    0x30(%rsp),%rdi
mov    0xc8(%rsp),%rbp
jmp    1da2 <test+0xbd2>
xchg   %ax,%ax
mov    0xd0(%rsp),%rax
mov    %rbp,0x0(%r13,%rax,8)
mov    %esi,(%rsp)
mov    0x48(%rsp),%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    %r13,%rcx
mov    0x8c(%rsp),%r8d
mov    0x40(%rsp),%r9
call   10e0 <mpn_tdiv_qr@plt>
mov    0x18(%rsp),%rcx
jmp    1fd0 <test+0xe00>
nopl   0x0(%rax)
cmpq   $0x0,0x50(%rsp)
mov    0x40(%rsp),%r9
mov    0xc8(%rsp),%rbp
mov    0x100(%rsp),%rdx
xorps  %xmm2,%xmm2
je     1e7d <test+0xcad>
mov    0xf8(%rsp),%rcx
xor    %eax,%eax
mov    0x30(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm2,-0x30(%rdx,%rax,8)
movups %xmm2,-0x20(%rdx,%rax,8)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,0x0(%rbp,%rax,8)
movups %xmm1,0x10(%rbp,%rax,8)
movups %xmm2,-0x10(%rdx,%rax,8)
movups %xmm2,(%rdx,%rax,8)
movdqu 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movdqu %xmm0,0x20(%rbp,%rax,8)
movups %xmm1,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1d20 <test+0xb50>
testb  $0x1,0x70(%rsp)
je     1d95 <test+0xbc5>
movups %xmm2,0x0(%r13,%rax,8)
movups %xmm2,0x10(%r13,%rax,8)
movdqu (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
add    0x38(%rsp),%rax
movdqu %xmm0,0x0(%r13,%rax,8)
movups %xmm1,0x10(%r13,%rax,8)
mov    0x58(%rsp),%rax
mov    %rax,%rcx
cmp    %rdi,%rax
je     1e0e <test+0xc3e>
mov    %rcx,%rax
test   $0x1,%dil
je     1dcc <test+0xbfc>
movq   $0x0,0x0(%r13,%rcx,8)
mov    (%rbx,%rcx,8),%rax
mov    0x38(%rsp),%rdx
add    %rcx,%rdx
mov    %rax,0x0(%r13,%rdx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x120(%rsp),%rcx
je     1e0e <test+0xc3e>
nopl   0x0(%rax)
movq   $0x0,0x0(%r13,%rax,8)
mov    (%rbx,%rax,8),%rcx
mov    %rcx,0x0(%rbp,%rax,8)
movq   $0x0,0x8(%r13,%rax,8)
mov    0x8(%rbx,%rax,8),%rcx
mov    %rcx,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1de0 <test+0xc10>
mov    0x38(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    0xd0(%rsp),%rcx
mov    %rax,0x0(%r13,%rcx,8)
mov    %esi,(%rsp)
mov    0x48(%rsp),%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    %r13,%rcx
mov    0x8c(%rsp),%r8d
call   10e0 <mpn_tdiv_qr@plt>
mov    0x30(%rsp),%rbp
mov    0x18(%rsp),%rcx
test   %ecx,%ecx
jle    1fd0 <test+0xe00>
cmp    $0x4,%ecx
setb   %al
or     0x17(%rsp),%al
je     1e66 <test+0xc96>
xor    %eax,%eax
jmp    1f6a <test+0xd9a>
cmpq   $0xc,0x50(%rsp)
jae    1e94 <test+0xcc4>
xor    %eax,%eax
mov    0x80(%rsp),%rdi
jmp    1f12 <test+0xd42>
xor    %eax,%eax
mov    0x30(%rsp),%rdi
testb  $0x1,0x70(%rsp)
jne    1d6d <test+0xb9d>
jmp    1d95 <test+0xbc5>
mov    0x60(%rsp),%rdx
xor    %eax,%eax
mov    0x80(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups 0x20(%r12,%rax,8),%xmm0
movups 0x30(%r12,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups 0x40(%r12,%rax,8),%xmm0
movups 0x50(%r12,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movdqu 0x60(%r12,%rax,8),%xmm0
movups 0x70(%r12,%rax,8),%xmm1
movdqu %xmm0,0x60(%rbx,%rax,8)
movups %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdx
jne    1eb0 <test+0xce0>
testb  $0x3,0x70(%rsp)
je     1f5d <test+0xd8d>
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
mov    0xb0(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1f40 <test+0xd70>
mov    0x58(%rsp),%rdx
mov    %rdx,%rax
cmp    %rbp,%rdx
je     1fd0 <test+0xe00>
mov    %rax,%rdi
not    %rdi
add    %rbp,%rdi
test   $0x3,%bpl
je     1f92 <test+0xdc2>
mov    0x68(%rsp),%rdx
xchg   %ax,%ax
mov    (%r12,%rax,8),%rsi
mov    %rsi,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1f80 <test+0xdb0>
cmp    $0x3,%rdi
jb     1fd0 <test+0xe00>
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rax,8),%rdx
mov    %rdx,(%rbx,%rax,8)
mov    0x8(%r12,%rax,8),%rdx
mov    %rdx,0x8(%rbx,%rax,8)
mov    0x10(%r12,%rax,8),%rdx
mov    %rdx,0x10(%rbx,%rax,8)
mov    0x18(%r12,%rax,8),%rdx
mov    %rdx,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1fa0 <test+0xdd0>
nop
mov    %r13,%rdi
mov    %r15,%rsi
mov    0xe0(%rsp),%r14
mov    %r14,%rdx
call   1050 <mpn_mul_n@plt>
mov    0x18(%rsp),%rax
mov    %eax,(%rsp)
mov    0x48(%rsp),%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    %r13,%rcx
mov    0xac(%rsp),%r8d
mov    0x40(%rsp),%rbp
mov    %rbp,%r9
call   10e0 <mpn_tdiv_qr@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x18(%rsp),%rdx
call   1090 <mpn_cmp@plt>
xor    %edi,%edi
test   %rax,%rax
sete   %dil
call   1070 <assert@plt>
mov    (%r15),%rdx
mov    0x18(%rsp),%rdi
mov    %rbx,%rsi
mov    %r14,%rcx
mov    %rbp,%r8
mov    0xd8(%rsp),%r9
call   10d0 <call_mulredc1@plt>
mov    0x18(%rsp),%rdi
mov    0x38(%rsp),%rcx
mov    %rax,(%rbx,%rcx,8)
movq   $0x0,0x0(%r13)
test   %edi,%edi
mov    0x128(%rsp),%rbp
js     21e0 <test+0x1010>
cmpl   $0x4,0x94(%rsp)
04
setb   %al
or     0x26(%rsp),%al
je     2090 <test+0xec0>
xor    %eax,%eax
jmp    216d <test+0xf9d>
nopw   0x0(%rax,%rax,1)
cmpq   $0xc,0x108(%rsp)
jae    209f <test+0xecf>
xor    %eax,%eax
jmp    2113 <test+0xf43>
mov    0xf0(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
movups %xmm0,0x8(%r13,%rax,8)
movups %xmm1,0x18(%r13,%rax,8)
movups 0x20(%rbx,%rax,8),%xmm0
movups 0x30(%rbx,%rax,8),%xmm1
movups %xmm0,0x28(%r13,%rax,8)
movups %xmm1,0x38(%r13,%rax,8)
movups 0x40(%rbx,%rax,8),%xmm0
movups 0x50(%rbx,%rax,8),%xmm1
movups %xmm0,0x48(%r13,%rax,8)
movups %xmm1,0x58(%r13,%rax,8)
movdqu 0x60(%rbx,%rax,8),%xmm0
movups 0x70(%rbx,%rax,8),%xmm1
movdqu %xmm0,0x68(%r13,%rax,8)
movups %xmm1,0x78(%r13,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    20b0 <test+0xee0>
cmpq   $0x0,0xc0(%rsp)
je     215d <test+0xf8d>
mov    0xc0(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movdqu (%rbx,%rax,8),%xmm0
movups 0x10(%rbx,%rax,8),%xmm1
lea    0x0(,%rax,8),%rdx
or     $0x8,%rdx
movdqu %xmm0,0x0(%r13,%rdx,1)
movups %xmm1,0x10(%r13,%rdx,1)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
jne    2130 <test+0xf60>
mov    0x110(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     21e0 <test+0x1010>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
mov    0x118(%rsp),%rdx
test   %rdx,%rdx
je     21a3 <test+0xfd3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rax,8),%rsi
mov    %rsi,0x8(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    2190 <test+0xfc0>
cmp    $0x3,%rcx
jb     21e0 <test+0x1010>
nopl   0x0(%rax)
mov    (%rbx,%rax,8),%rcx
mov    %rcx,0x8(%r13,%rax,8)
mov    0x8(%rbx,%rax,8),%rcx
mov    %rcx,0x10(%r13,%rax,8)
mov    0x10(%rbx,%rax,8),%rcx
mov    %rcx,0x18(%r13,%rax,8)
mov    0x18(%rbx,%rax,8),%rcx
mov    %rcx,0x20(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    21b0 <test+0xfe0>
mov    %edi,(%rsp)
mov    0x48(%rsp),%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    %r13,%rcx
mov    0xa8(%rsp),%r8d
mov    0x40(%rsp),%r9
call   10e0 <mpn_tdiv_qr@plt>
mov    0x18(%rsp),%rdx
test   %edx,%edx
mov    0x30(%rsp),%rbp
jle    1600 <test+0x430>
cmp    $0x4,%edx
setb   %al
or     0x17(%rsp),%al
je     2230 <test+0x1060>
xor    %eax,%eax
jmp    231e <test+0x114e>
nopw   0x0(%rax,%rax,1)
cmpq   $0xc,0x50(%rsp)
jae    2244 <test+0x1074>
xor    %eax,%eax
mov    0x80(%rsp),%rdi
jmp    22c2 <test+0x10f2>
mov    0x60(%rsp),%rcx
xor    %eax,%eax
mov    0x80(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups 0x20(%r12,%rax,8),%xmm0
movups 0x30(%r12,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups 0x40(%r12,%rax,8),%xmm0
movups 0x50(%r12,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movdqu 0x60(%r12,%rax,8),%xmm0
movups 0x70(%r12,%rax,8),%xmm1
movdqu %xmm0,0x60(%rbx,%rax,8)
movups %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    2260 <test+0x1090>
testb  $0x3,0x70(%rsp)
je     230d <test+0x113d>
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0xb0(%rsp),%rsi
lea    (%rsi,%rax,8),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    22f0 <test+0x1120>
mov    0x58(%rsp),%rcx
mov    %rcx,%rax
cmp    %rbp,%rcx
je     1600 <test+0x430>
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
test   $0x3,%bpl
je     2352 <test+0x1182>
mov    0x68(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rsi
mov    %rsi,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    2340 <test+0x1170>
cmp    $0x3,%rcx
jb     1600 <test+0x430>
nopl   0x0(%rax)
mov    (%r12,%rax,8),%rcx
mov    %rcx,(%rbx,%rax,8)
mov    0x8(%r12,%rax,8),%rcx
mov    %rcx,0x8(%rbx,%rax,8)
mov    0x10(%r12,%rax,8),%rcx
mov    %rcx,0x10(%rbx,%rax,8)
mov    0x18(%r12,%rax,8),%rcx
mov    %rcx,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2360 <test+0x1190>
jmp    1600 <test+0x430>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0x2bf6(%rip),%rax
mov    (%rax),%edi
lea    0xc1d(%rip),%rsi
call   1080 <fprintf@plt>
mov    $0x1,%edi
call   10f0 <exit@plt>

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [40 x i8] c"Cannot allocate memory in test_mulredc\0A\00"
define void @test(i32 %0, i32 %1) {
%3 = sext i32 %0 to i64
%4 = shl i32 %0, 3
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i64*
%7 = inttoptr i64 %5 to i8*
%8 = tail call i64 @malloc(i32 %4)
%9 = inttoptr i64 %8 to i64*
%10 = inttoptr i64 %8 to i8*
%11 = add i32 %0, 1
%12 = shl i32 %11, 3
%13 = tail call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to i64*
%15 = inttoptr i64 %13 to i8*
%16 = tail call i64 @malloc(i32 %4)
%17 = inttoptr i64 %16 to i64*
%18 = shl nsw i32 %0, 1
%19 = shl i32 %0, 4
%20 = add i32 %19, 16
%21 = tail call i64 @malloc(i32 %20)
%22 = inttoptr i64 %21 to i64*
%23 = inttoptr i64 %21 to i8*
%24 = tail call i64 @malloc(i32 %20)
%25 = inttoptr i64 %24 to i64*
%26 = tail call i64 @malloc(i32 %20)
%27 = inttoptr i64 %26 to i64*
%28 = inttoptr i64 %26 to i8*
%29 = icmp eq i64 %5, 0
%30 = icmp eq i64 %8, 0
%31 = select i1 %29, i1 true, i1 %30
%32 = icmp eq i64 %13, 0
%33 = select i1 %31, i1 true, i1 %32
%34 = icmp eq i64 %16, 0
%35 = select i1 %33, i1 true, i1 %34
%36 = icmp eq i64 %21, 0
%37 = select i1 %35, i1 true, i1 %36
%38 = icmp eq i64 %24, 0
%39 = select i1 %37, i1 true, i1 %38
%40 = icmp eq i64 %26, 0
%41 = select i1 %39, i1 true, i1 %40
br i1 %41, label %42, label %46
42: ; preds = %2
%43 = load i32, i32* @stderr
%44 = tail call i32 @fprintf(i32 %43, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
%45 = tail call i32 @exit(i32 1)
unreachable
46: ; preds = %2
%47 = tail call i32 @mpn_random2(i64* %17, i32 %0)
%48 = load i64, i64* %17
%49 = or i64 %48, 1
store i64 %49, i64* %17
%50 = add nsw i32 %0, -1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i64, i64* %17, i64 %51
%53 = load i64, i64* %52
%54 = icmp eq i64 %53, 0
br i1 %54, label %55, label %57
55: ; preds = %46
store i64 1, i64* %52
%56 = load i64, i64* %17
br label %57
57: ; preds = %55, %46
%58 = phi i64 [ %56, %55 ], [ %49, %46 ]
%59 = sub i64 2, %58
%60 = mul i64 %58, %59
%61 = sub i64 2, %60
%62 = mul i64 %61, %59
%63 = mul i64 %58, %62
%64 = sub i64 2, %63
%65 = mul i64 %64, %62
%66 = mul i64 %58, %65
%67 = sub i64 2, %66
%68 = mul i64 %67, %65
%69 = mul i64 %58, %68
%70 = sub i64 2, %69
%71 = mul i64 %70, %68
%72 = mul i64 %58, %71
%73 = sub i64 2, %72
%74 = mul i64 %73, %71
%75 = mul i64 %58, %74
%76 = sub i64 2, %75
%77 = mul i64 %76, %74
%78 = mul i64 %58, %77
%79 = sub i64 2, %78
%80 = mul i64 %79, %77
%81 = mul i64 %58, %80
%82 = sub i64 2, %81
%83 = mul i64 %82, %80
%84 = mul i64 %58, %83
%85 = add i64 %84, -2
%86 = mul i64 %85, %83
%87 = mul i64 %58, %86
%88 = icmp eq i64 %87, -1
%89 = zext i1 %88 to i32
%90 = tail call i32 @assert(i32 %89)
%91 = icmp sgt i32 %1, 0
br i1 %91, label %92, label %970
92: ; preds = %57
%93 = icmp sgt i32 %0, 0
%94 = getelementptr inbounds i64, i64* %14, i64 %3
%95 = sext i32 %18 to i64
%96 = getelementptr inbounds i64, i64* %22, i64 %95
%97 = or i32 %18, 1
%98 = icmp slt i32 %0, 0
%99 = add nsw i32 %0, 2
%100 = getelementptr inbounds i64, i64* %22, i64 %3
%101 = zext i32 %0 to i64
%102 = zext i32 %0 to i64
%103 = zext i32 %0 to i64
%104 = zext i32 %0 to i64
%105 = zext i32 %0 to i64
%106 = zext i32 %11 to i64
%107 = zext i32 %0 to i64
%108 = getelementptr i64, i64* %14, i64 %101
%109 = bitcast i64* %108 to i8*
%110 = getelementptr i64, i64* %27, i64 %101
%111 = bitcast i64* %110 to i8*
%112 = getelementptr i64, i64* %22, i64 1
%113 = add nuw nsw i64 %106, 1
%114 = getelementptr i64, i64* %22, i64 %113
%115 = bitcast i64* %114 to i8*
%116 = getelementptr i64, i64* %14, i64 %106
%117 = getelementptr i64, i64* %14, i64 %101
%118 = bitcast i64* %117 to i8*
%119 = getelementptr i64, i64* %27, i64 %101
%120 = bitcast i64* %119 to i8*
%121 = getelementptr i64, i64* %22, i64 %101
%122 = bitcast i64* %121 to i8*
%123 = getelementptr i64, i64* %22, i64 %3
%124 = add nsw i64 %3, %101
%125 = getelementptr i64, i64* %22, i64 %124
%126 = bitcast i64* %125 to i8*
%127 = getelementptr i64, i64* %14, i64 %101
%128 = bitcast i64* %127 to i8*
%129 = getelementptr i64, i64* %9, i64 %101
%130 = bitcast i64* %129 to i8*
%131 = getelementptr i64, i64* %6, i64 %101
%132 = bitcast i64* %131 to i8*
%133 = getelementptr i64, i64* %9, i64 %101
%134 = bitcast i64* %133 to i8*
%135 = getelementptr i64, i64* %6, i64 %101
%136 = bitcast i64* %135 to i8*
%137 = getelementptr i64, i64* %9, i64 %101
%138 = bitcast i64* %137 to i8*
%139 = getelementptr i64, i64* %6, i64 %101
%140 = bitcast i64* %139 to i8*
%141 = and i64 %101, 4294967292
%142 = add nsw i64 %141, -4
%143 = lshr exact i64 %142, 2
%144 = add nuw nsw i64 %143, 1
%145 = and i64 %106, 4294967292
%146 = add nsw i64 %145, -4
%147 = lshr exact i64 %146, 2
%148 = add nuw nsw i64 %147, 1
%149 = icmp ult i32 %0, 4
%150 = icmp ult i8* %10, %140
%151 = icmp ult i8* %7, %138
%152 = and i1 %150, %151
%153 = and i64 %101, 4294967292
%154 = and i64 %144, 3
%155 = icmp ult i64 %142, 12
%156 = and i64 %144, 9223372036854775804
%157 = icmp eq i64 %154, 0
%158 = icmp eq i64 %153, %101
%159 = and i64 %101, 3
%160 = icmp eq i64 %159, 0
%161 = icmp ult i32 %0, 4
%162 = icmp ult i8* %10, %136
%163 = icmp ult i8* %7, %134
%164 = and i1 %162, %163
%165 = and i64 %101, 4294967292
%166 = and i64 %144, 3
%167 = icmp ult i64 %142, 12
%168 = and i64 %144, 9223372036854775804
%169 = icmp eq i64 %166, 0
%170 = icmp eq i64 %165, %101
%171 = and i64 %101, 3
%172 = icmp eq i64 %171, 0
%173 = icmp ult i32 %0, 4
%174 = icmp ult i8* %10, %132
%175 = icmp ult i8* %7, %130
%176 = and i1 %174, %175
%177 = and i64 %101, 4294967292
%178 = and i64 %144, 3
%179 = icmp ult i64 %142, 12
%180 = and i64 %144, 9223372036854775804
%181 = icmp eq i64 %178, 0
%182 = icmp eq i64 %177, %101
%183 = and i64 %101, 3
%184 = icmp eq i64 %183, 0
%185 = icmp ult i32 %0, 4
%186 = icmp ult i8* %23, %126
%187 = icmp ult i64* %123, %121
%188 = and i1 %186, %187
%189 = icmp ult i8* %23, %128
%190 = icmp ult i8* %15, %122
%191 = and i1 %189, %190
%192 = or i1 %188, %191
%193 = icmp ult i64* %123, %127
%194 = icmp ult i8* %15, %126
%195 = and i1 %193, %194
%196 = or i1 %192, %195
%197 = and i64 %101, 4294967292
%198 = and i64 %144, 1
%199 = icmp eq i64 %142, 0
%200 = and i64 %144, 9223372036854775806
%201 = icmp eq i64 %198, 0
%202 = icmp eq i64 %197, %101
%203 = and i64 %101, 1
%204 = icmp eq i64 %203, 0
%205 = sub nsw i64 0, %101
%206 = icmp ult i32 %0, 4
%207 = icmp ult i8* %15, %120
%208 = icmp ult i8* %28, %118
%209 = and i1 %207, %208
%210 = and i64 %101, 4294967292
%211 = and i64 %144, 3
%212 = icmp ult i64 %142, 12
%213 = and i64 %144, 9223372036854775804
%214 = icmp eq i64 %211, 0
%215 = icmp eq i64 %210, %101
%216 = and i64 %101, 3
%217 = icmp eq i64 %216, 0
%218 = icmp ult i32 %11, 4
%219 = icmp ult i64* %112, %116
%220 = icmp ult i8* %15, %115
%221 = and i1 %219, %220
%222 = and i64 %106, 4294967292
%223 = and i64 %148, 3
%224 = icmp ult i64 %146, 12
%225 = and i64 %148, 9223372036854775804
%226 = icmp eq i64 %223, 0
%227 = icmp eq i64 %222, %106
%228 = and i64 %106, 3
%229 = icmp eq i64 %228, 0
%230 = icmp ult i32 %0, 4
%231 = icmp ult i8* %15, %111
%232 = icmp ult i8* %28, %109
%233 = and i1 %231, %232
%234 = and i64 %101, 4294967292
%235 = and i64 %144, 3
%236 = icmp ult i64 %142, 12
%237 = and i64 %144, 9223372036854775804
%238 = icmp eq i64 %235, 0
%239 = icmp eq i64 %234, %101
%240 = and i64 %101, 3
%241 = icmp eq i64 %240, 0
br label %242
242: ; preds = %92, %960
%243 = phi i32 [ 0, %92 ], [ %968, %960 ]
%244 = phi i64* [ %9, %92 ], [ %528, %960 ]
switch i32 %243, label %521 [
i32 0, label %399
i32 1, label %322
i32 2, label %245
]
245: ; preds = %242
br i1 %93, label %246, label %527
246: ; preds = %245
%247 = select i1 %149, i1 true, i1 %152
br i1 %247, label %307, label %248
248: ; preds = %246
br i1 %155, label %290, label %249
249: ; preds = %248, %249
%250 = phi i64 [ %287, %249 ], [ 0, %248 ]
%251 = phi i64 [ %288, %249 ], [ 0, %248 ]
%252 = getelementptr inbounds i64, i64* %9, i64 %250
%253 = bitcast i64* %252 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %253
%254 = getelementptr inbounds i64, i64* %252, i64 2
%255 = bitcast i64* %254 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %255
%256 = getelementptr inbounds i64, i64* %6, i64 %250
%257 = bitcast i64* %256 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %257
%258 = getelementptr inbounds i64, i64* %256, i64 2
%259 = bitcast i64* %258 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %259
%260 = or i64 %250, 4
%261 = getelementptr inbounds i64, i64* %9, i64 %260
%262 = bitcast i64* %261 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %262
%263 = getelementptr inbounds i64, i64* %261, i64 2
%264 = bitcast i64* %263 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %264
%265 = getelementptr inbounds i64, i64* %6, i64 %260
%266 = bitcast i64* %265 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %266
%267 = getelementptr inbounds i64, i64* %265, i64 2
%268 = bitcast i64* %267 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %268
%269 = or i64 %250, 8
%270 = getelementptr inbounds i64, i64* %9, i64 %269
%271 = bitcast i64* %270 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %271
%272 = getelementptr inbounds i64, i64* %270, i64 2
%273 = bitcast i64* %272 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %273
%274 = getelementptr inbounds i64, i64* %6, i64 %269
%275 = bitcast i64* %274 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %275
%276 = getelementptr inbounds i64, i64* %274, i64 2
%277 = bitcast i64* %276 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %277
%278 = or i64 %250, 12
%279 = getelementptr inbounds i64, i64* %9, i64 %278
%280 = bitcast i64* %279 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %280
%281 = getelementptr inbounds i64, i64* %279, i64 2
%282 = bitcast i64* %281 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %282
%283 = getelementptr inbounds i64, i64* %6, i64 %278
%284 = bitcast i64* %283 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %284
%285 = getelementptr inbounds i64, i64* %283, i64 2
%286 = bitcast i64* %285 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %286
%287 = add nuw i64 %250, 16
%288 = add nuw i64 %251, 4
%289 = icmp eq i64 %288, %156
br i1 %289, label %290, label %249
290: ; preds = %249, %248
%291 = phi i64 [ 0, %248 ], [ %287, %249 ]
br i1 %157, label %306, label %292
292: ; preds = %290, %292
%293 = phi i64 [ %303, %292 ], [ %291, %290 ]
%294 = phi i64 [ %304, %292 ], [ 0, %290 ]
%295 = getelementptr inbounds i64, i64* %9, i64 %293
%296 = bitcast i64* %295 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %296
%297 = getelementptr inbounds i64, i64* %295, i64 2
%298 = bitcast i64* %297 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %298
%299 = getelementptr inbounds i64, i64* %6, i64 %293
%300 = bitcast i64* %299 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %300
%301 = getelementptr inbounds i64, i64* %299, i64 2
%302 = bitcast i64* %301 to <2 x i64>*
store <2 x i64> <i64 -1, i64 -1>, <2 x i64>* %302
%303 = add nuw i64 %293, 4
%304 = add i64 %294, 1
%305 = icmp eq i64 %304, %154
br i1 %305, label %306, label %292
306: ; preds = %292, %290
br i1 %158, label %527, label %307
307: ; preds = %246, %306
%308 = phi i64 [ 0, %246 ], [ %153, %306 ]
%309 = xor i64 %308, -1
%310 = add nsw i64 %309, %101
br i1 %160, label %319, label %311
311: ; preds = %307, %311
%312 = phi i64 [ %316, %311 ], [ %308, %307 ]
%313 = phi i64 [ %317, %311 ], [ 0, %307 ]
%314 = getelementptr inbounds i64, i64* %9, i64 %312
store i64 -1, i64* %314
%315 = getelementptr inbounds i64, i64* %6, i64 %312
store i64 -1, i64* %315
%316 = add nuw nsw i64 %312, 1
%317 = add i64 %313, 1
%318 = icmp eq i64 %317, %159
br i1 %318, label %319, label %311
319: ; preds = %311, %307
%320 = phi i64 [ %308, %307 ], [ %316, %311 ]
%321 = icmp ult i64 %310, 3
br i1 %321, label %527, label %506
322: ; preds = %242
br i1 %93, label %323, label %527
323: ; preds = %322
%324 = select i1 %161, i1 true, i1 %164
br i1 %324, label %384, label %325
325: ; preds = %323
br i1 %167, label %367, label %326
326: ; preds = %325, %326
%327 = phi i64 [ %364, %326 ], [ 0, %325 ]
%328 = phi i64 [ %365, %326 ], [ 0, %325 ]
%329 = getelementptr inbounds i64, i64* %9, i64 %327
%330 = bitcast i64* %329 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %330
%331 = getelementptr inbounds i64, i64* %329, i64 2
%332 = bitcast i64* %331 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %332
%333 = getelementptr inbounds i64, i64* %6, i64 %327
%334 = bitcast i64* %333 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %334
%335 = getelementptr inbounds i64, i64* %333, i64 2
%336 = bitcast i64* %335 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %336
%337 = or i64 %327, 4
%338 = getelementptr inbounds i64, i64* %9, i64 %337
%339 = bitcast i64* %338 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %339
%340 = getelementptr inbounds i64, i64* %338, i64 2
%341 = bitcast i64* %340 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %341
%342 = getelementptr inbounds i64, i64* %6, i64 %337
%343 = bitcast i64* %342 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %343
%344 = getelementptr inbounds i64, i64* %342, i64 2
%345 = bitcast i64* %344 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %345
%346 = or i64 %327, 8
%347 = getelementptr inbounds i64, i64* %9, i64 %346
%348 = bitcast i64* %347 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %348
%349 = getelementptr inbounds i64, i64* %347, i64 2
%350 = bitcast i64* %349 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %350
%351 = getelementptr inbounds i64, i64* %6, i64 %346
%352 = bitcast i64* %351 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %352
%353 = getelementptr inbounds i64, i64* %351, i64 2
%354 = bitcast i64* %353 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %354
%355 = or i64 %327, 12
%356 = getelementptr inbounds i64, i64* %9, i64 %355
%357 = bitcast i64* %356 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %357
%358 = getelementptr inbounds i64, i64* %356, i64 2
%359 = bitcast i64* %358 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %359
%360 = getelementptr inbounds i64, i64* %6, i64 %355
%361 = bitcast i64* %360 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %361
%362 = getelementptr inbounds i64, i64* %360, i64 2
%363 = bitcast i64* %362 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %363
%364 = add nuw i64 %327, 16
%365 = add nuw i64 %328, 4
%366 = icmp eq i64 %365, %168
br i1 %366, label %367, label %326
367: ; preds = %326, %325
%368 = phi i64 [ 0, %325 ], [ %364, %326 ]
br i1 %169, label %383, label %369
369: ; preds = %367, %369
%370 = phi i64 [ %380, %369 ], [ %368, %367 ]
%371 = phi i64 [ %381, %369 ], [ 0, %367 ]
%372 = getelementptr inbounds i64, i64* %9, i64 %370
%373 = bitcast i64* %372 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %373
%374 = getelementptr inbounds i64, i64* %372, i64 2
%375 = bitcast i64* %374 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %375
%376 = getelementptr inbounds i64, i64* %6, i64 %370
%377 = bitcast i64* %376 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %377
%378 = getelementptr inbounds i64, i64* %376, i64 2
%379 = bitcast i64* %378 to <2 x i64>*
store <2 x i64> <i64 1, i64 1>, <2 x i64>* %379
%380 = add nuw i64 %370, 4
%381 = add i64 %371, 1
%382 = icmp eq i64 %381, %166
br i1 %382, label %383, label %369
383: ; preds = %369, %367
br i1 %170, label %527, label %384
384: ; preds = %323, %383
%385 = phi i64 [ 0, %323 ], [ %165, %383 ]
%386 = xor i64 %385, -1
%387 = add nsw i64 %386, %101
br i1 %172, label %396, label %388
388: ; preds = %384, %388
%389 = phi i64 [ %393, %388 ], [ %385, %384 ]
%390 = phi i64 [ %394, %388 ], [ 0, %384 ]
%391 = getelementptr inbounds i64, i64* %9, i64 %389
store i64 1, i64* %391
%392 = getelementptr inbounds i64, i64* %6, i64 %389
store i64 1, i64* %392
%393 = add nuw nsw i64 %389, 1
%394 = add i64 %390, 1
%395 = icmp eq i64 %394, %171
br i1 %395, label %396, label %388
396: ; preds = %388, %384
%397 = phi i64 [ %385, %384 ], [ %393, %388 ]
%398 = icmp ult i64 %387, 3
br i1 %398, label %527, label %491
399: ; preds = %242
br i1 %93, label %400, label %527
400: ; preds = %399
%401 = select i1 %173, i1 true, i1 %176
br i1 %401, label %461, label %402
402: ; preds = %400
br i1 %179, label %444, label %403
403: ; preds = %402, %403
%404 = phi i64 [ %441, %403 ], [ 0, %402 ]
%405 = phi i64 [ %442, %403 ], [ 0, %402 ]
%406 = getelementptr inbounds i64, i64* %9, i64 %404
%407 = bitcast i64* %406 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %407
%408 = getelementptr inbounds i64, i64* %406, i64 2
%409 = bitcast i64* %408 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %409
%410 = getelementptr inbounds i64, i64* %6, i64 %404
%411 = bitcast i64* %410 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %411
%412 = getelementptr inbounds i64, i64* %410, i64 2
%413 = bitcast i64* %412 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %413
%414 = or i64 %404, 4
%415 = getelementptr inbounds i64, i64* %9, i64 %414
%416 = bitcast i64* %415 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %416
%417 = getelementptr inbounds i64, i64* %415, i64 2
%418 = bitcast i64* %417 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %418
%419 = getelementptr inbounds i64, i64* %6, i64 %414
%420 = bitcast i64* %419 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %420
%421 = getelementptr inbounds i64, i64* %419, i64 2
%422 = bitcast i64* %421 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %422
%423 = or i64 %404, 8
%424 = getelementptr inbounds i64, i64* %9, i64 %423
%425 = bitcast i64* %424 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %425
%426 = getelementptr inbounds i64, i64* %424, i64 2
%427 = bitcast i64* %426 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %427
%428 = getelementptr inbounds i64, i64* %6, i64 %423
%429 = bitcast i64* %428 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %429
%430 = getelementptr inbounds i64, i64* %428, i64 2
%431 = bitcast i64* %430 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %431
%432 = or i64 %404, 12
%433 = getelementptr inbounds i64, i64* %9, i64 %432
%434 = bitcast i64* %433 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %434
%435 = getelementptr inbounds i64, i64* %433, i64 2
%436 = bitcast i64* %435 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %436
%437 = getelementptr inbounds i64, i64* %6, i64 %432
%438 = bitcast i64* %437 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %438
%439 = getelementptr inbounds i64, i64* %437, i64 2
%440 = bitcast i64* %439 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %440
%441 = add nuw i64 %404, 16
%442 = add nuw i64 %405, 4
%443 = icmp eq i64 %442, %180
br i1 %443, label %444, label %403
444: ; preds = %403, %402
%445 = phi i64 [ 0, %402 ], [ %441, %403 ]
br i1 %181, label %460, label %446
446: ; preds = %444, %446
%447 = phi i64 [ %457, %446 ], [ %445, %444 ]
%448 = phi i64 [ %458, %446 ], [ 0, %444 ]
%449 = getelementptr inbounds i64, i64* %9, i64 %447
%450 = bitcast i64* %449 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %450
%451 = getelementptr inbounds i64, i64* %449, i64 2
%452 = bitcast i64* %451 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %452
%453 = getelementptr inbounds i64, i64* %6, i64 %447
%454 = bitcast i64* %453 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %454
%455 = getelementptr inbounds i64, i64* %453, i64 2
%456 = bitcast i64* %455 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %456
%457 = add nuw i64 %447, 4
%458 = add i64 %448, 1
%459 = icmp eq i64 %458, %178
br i1 %459, label %460, label %446
460: ; preds = %446, %444
br i1 %182, label %527, label %461
461: ; preds = %400, %460
%462 = phi i64 [ 0, %400 ], [ %177, %460 ]
%463 = xor i64 %462, -1
%464 = add nsw i64 %463, %101
br i1 %184, label %473, label %465
465: ; preds = %461, %465
%466 = phi i64 [ %470, %465 ], [ %462, %461 ]
%467 = phi i64 [ %471, %465 ], [ 0, %461 ]
%468 = getelementptr inbounds i64, i64* %9, i64 %466
store i64 0, i64* %468
%469 = getelementptr inbounds i64, i64* %6, i64 %466
store i64 0, i64* %469
%470 = add nuw nsw i64 %466, 1
%471 = add i64 %467, 1
%472 = icmp eq i64 %471, %183
br i1 %472, label %473, label %465
473: ; preds = %465, %461
%474 = phi i64 [ %462, %461 ], [ %470, %465 ]
%475 = icmp ult i64 %464, 3
br i1 %475, label %527, label %476
476: ; preds = %473, %476
%477 = phi i64 [ %489, %476 ], [ %474, %473 ]
%478 = getelementptr inbounds i64, i64* %9, i64 %477
store i64 0, i64* %478
%479 = getelementptr inbounds i64, i64* %6, i64 %477
store i64 0, i64* %479
%480 = add nuw nsw i64 %477, 1
%481 = getelementptr inbounds i64, i64* %9, i64 %480
store i64 0, i64* %481
%482 = getelementptr inbounds i64, i64* %6, i64 %480
store i64 0, i64* %482
%483 = add nuw nsw i64 %477, 2
%484 = getelementptr inbounds i64, i64* %9, i64 %483
store i64 0, i64* %484
%485 = getelementptr inbounds i64, i64* %6, i64 %483
store i64 0, i64* %485
%486 = add nuw nsw i64 %477, 3
%487 = getelementptr inbounds i64, i64* %9, i64 %486
store i64 0, i64* %487
%488 = getelementptr inbounds i64, i64* %6, i64 %486
store i64 0, i64* %488
%489 = add nuw nsw i64 %477, 4
%490 = icmp eq i64 %489, %103
br i1 %490, label %527, label %476
491: ; preds = %396, %491
%492 = phi i64 [ %504, %491 ], [ %397, %396 ]
%493 = getelementptr inbounds i64, i64* %9, i64 %492
store i64 1, i64* %493
%494 = getelementptr inbounds i64, i64* %6, i64 %492
store i64 1, i64* %494
%495 = add nuw nsw i64 %492, 1
%496 = getelementptr inbounds i64, i64* %9, i64 %495
store i64 1, i64* %496
%497 = getelementptr inbounds i64, i64* %6, i64 %495
store i64 1, i64* %497
%498 = add nuw nsw i64 %492, 2
%499 = getelementptr inbounds i64, i64* %9, i64 %498
store i64 1, i64* %499
%500 = getelementptr inbounds i64, i64* %6, i64 %498
store i64 1, i64* %500
%501 = add nuw nsw i64 %492, 3
%502 = getelementptr inbounds i64, i64* %9, i64 %501
store i64 1, i64* %502
%503 = getelementptr inbounds i64, i64* %6, i64 %501
store i64 1, i64* %503
%504 = add nuw nsw i64 %492, 4
%505 = icmp eq i64 %504, %102
br i1 %505, label %527, label %491
506: ; preds = %319, %506
%507 = phi i64 [ %519, %506 ], [ %320, %319 ]
%508 = getelementptr inbounds i64, i64* %9, i64 %507
store i64 -1, i64* %508
%509 = getelementptr inbounds i64, i64* %6, i64 %507
store i64 -1, i64* %509
%510 = add nuw nsw i64 %507, 1
%511 = getelementptr inbounds i64, i64* %9, i64 %510
store i64 -1, i64* %511
%512 = getelementptr inbounds i64, i64* %6, i64 %510
store i64 -1, i64* %512
%513 = add nuw nsw i64 %507, 2
%514 = getelementptr inbounds i64, i64* %9, i64 %513
store i64 -1, i64* %514
%515 = getelementptr inbounds i64, i64* %6, i64 %513
store i64 -1, i64* %515
%516 = add nuw nsw i64 %507, 3
%517 = getelementptr inbounds i64, i64* %9, i64 %516
store i64 -1, i64* %517
%518 = getelementptr inbounds i64, i64* %6, i64 %516
store i64 -1, i64* %518
%519 = add nuw nsw i64 %507, 4
%520 = icmp eq i64 %519, %101
br i1 %520, label %527, label %506
521: ; preds = %242
%522 = and i32 %243, 1
%523 = icmp eq i32 %522, 0
%524 = tail call i32 @mpn_random2(i64* %6, i32 %0)
br i1 %523, label %527, label %525
525: ; preds = %521
%526 = tail call i32 @mpn_random2(i64* %9, i32 %0)
br label %527
527: ; preds = %319, %506, %396, %491, %473, %476, %306, %383, %460, %521, %245, %322, %399, %525
%528 = phi i64* [ %244, %525 ], [ %244, %399 ], [ %244, %322 ], [ %244, %245 ], [ %6, %521 ], [ %244, %460 ], [ %244, %383 ], [ %244, %306 ], [ %244, %476 ], [ %244, %473 ], [ %244, %491 ], [ %244, %396 ], [ %244, %506 ], [ %244, %319 ]
%529 = tail call i64 @call_mulredc(i32 %0, i64* %14, i64* %6, i64* %528, i64* %17, i64 %86)
%530 = icmp eq i64 %529, 0
br i1 %530, label %533, label %531
531: ; preds = %527
%532 = tail call i32 @putchar(i32 33)
br label %533
533: ; preds = %531, %527
store i64 %529, i64* %94
br i1 %93, label %534, label %606
534: ; preds = %533
%535 = select i1 %185, i1 true, i1 %196
br i1 %535, label %593, label %536
536: ; preds = %534
br i1 %199, label %574, label %537
537: ; preds = %536, %537
%538 = phi i64 [ %571, %537 ], [ 0, %536 ]
%539 = phi i64 [ %572, %537 ], [ 0, %536 ]
%540 = getelementptr inbounds i64, i64* %22, i64 %538
%541 = bitcast i64* %540 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %541
%542 = getelementptr inbounds i64, i64* %540, i64 2
%543 = bitcast i64* %542 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %543
%544 = getelementptr inbounds i64, i64* %14, i64 %538
%545 = bitcast i64* %544 to <2 x i64>*
%546 = load <2 x i64>, <2 x i64>* %545
%547 = getelementptr inbounds i64, i64* %544, i64 2
%548 = bitcast i64* %547 to <2 x i64>*
%549 = load <2 x i64>, <2 x i64>* %548
%550 = add nsw i64 %538, %3
%551 = getelementptr inbounds i64, i64* %22, i64 %550
%552 = bitcast i64* %551 to <2 x i64>*
store <2 x i64> %546, <2 x i64>* %552
%553 = getelementptr inbounds i64, i64* %551, i64 2
%554 = bitcast i64* %553 to <2 x i64>*
store <2 x i64> %549, <2 x i64>* %554
%555 = or i64 %538, 4
%556 = getelementptr inbounds i64, i64* %22, i64 %555
%557 = bitcast i64* %556 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %557
%558 = getelementptr inbounds i64, i64* %556, i64 2
%559 = bitcast i64* %558 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %559
%560 = getelementptr inbounds i64, i64* %14, i64 %555
%561 = bitcast i64* %560 to <2 x i64>*
%562 = load <2 x i64>, <2 x i64>* %561
%563 = getelementptr inbounds i64, i64* %560, i64 2
%564 = bitcast i64* %563 to <2 x i64>*
%565 = load <2 x i64>, <2 x i64>* %564
%566 = add nsw i64 %555, %3
%567 = getelementptr inbounds i64, i64* %22, i64 %566
%568 = bitcast i64* %567 to <2 x i64>*
store <2 x i64> %562, <2 x i64>* %568
%569 = getelementptr inbounds i64, i64* %567, i64 2
%570 = bitcast i64* %569 to <2 x i64>*
store <2 x i64> %565, <2 x i64>* %570
%571 = add nuw i64 %538, 8
%572 = add i64 %539, 2
%573 = icmp eq i64 %572, %200
br i1 %573, label %574, label %537
574: ; preds = %537, %536
%575 = phi i64 [ 0, %536 ], [ %571, %537 ]
br i1 %201, label %592, label %576
576: ; preds = %574
%577 = getelementptr inbounds i64, i64* %22, i64 %575
%578 = bitcast i64* %577 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %578
%579 = getelementptr inbounds i64, i64* %577, i64 2
%580 = bitcast i64* %579 to <2 x i64>*
store <2 x i64> zeroinitializer, <2 x i64>* %580
%581 = getelementptr inbounds i64, i64* %14, i64 %575
%582 = bitcast i64* %581 to <2 x i64>*
%583 = load <2 x i64>, <2 x i64>* %582
%584 = getelementptr inbounds i64, i64* %581, i64 2
%585 = bitcast i64* %584 to <2 x i64>*
%586 = load <2 x i64>, <2 x i64>* %585
%587 = add nsw i64 %575, %3
%588 = getelementptr inbounds i64, i64* %22, i64 %587
%589 = bitcast i64* %588 to <2 x i64>*
store <2 x i64> %583, <2 x i64>* %589
%590 = getelementptr inbounds i64, i64* %588, i64 2
%591 = bitcast i64* %590 to <2 x i64>*
store <2 x i64> %586, <2 x i64>* %591
br label %592
592: ; preds = %574, %576
br i1 %202, label %623, label %593
593: ; preds = %534, %592
%594 = phi i64 [ 0, %534 ], [ %197, %592 ]
%595 = xor i64 %594, -1
br i1 %204, label %603, label %596
596: ; preds = %593
%597 = getelementptr inbounds i64, i64* %22, i64 %594
store i64 0, i64* %597
%598 = getelementptr inbounds i64, i64* %14, i64 %594
%599 = load i64, i64* %598
%600 = add nsw i64 %594, %3
%601 = getelementptr inbounds i64, i64* %22, i64 %600
store i64 %599, i64* %601
%602 = or i64 %594, 1
br label %603
603: ; preds = %596, %593
%604 = phi i64 [ %594, %593 ], [ %602, %596 ]
%605 = icmp eq i64 %595, %205
br i1 %605, label %623, label %608
606: ; preds = %533
store i64 %529, i64* %96
%607 = tail call i32 @mpn_tdiv_qr(i64* %25, i64* %27, i32 0, i64* %22, i32 %97, i64* %17, i32 %0)
br label %732
608: ; preds = %603, %608
%609 = phi i64 [ %621, %608 ], [ %604, %603 ]
%610 = getelementptr inbounds i64, i64* %22, i64 %609
store i64 0, i64* %610
%611 = getelementptr inbounds i64, i64* %14, i64 %609
%612 = load i64, i64* %611
%613 = add nsw i64 %609, %3
%614 = getelementptr inbounds i64, i64* %22, i64 %613
store i64 %612, i64* %614
%615 = add nuw nsw i64 %609, 1
%616 = getelementptr inbounds i64, i64* %22, i64 %615
store i64 0, i64* %616
%617 = getelementptr inbounds i64, i64* %14, i64 %615
%618 = load i64, i64* %617
%619 = add nsw i64 %615, %3
%620 = getelementptr inbounds i64, i64* %22, i64 %619
store i64 %618, i64* %620
%621 = add nuw nsw i64 %609, 2
%622 = icmp eq i64 %621, %104
br i1 %622, label %623, label %608
623: ; preds = %603, %608, %592
%624 = load i64, i64* %94
store i64 %624, i64* %96
%625 = tail call i32 @mpn_tdiv_qr(i64* %25, i64* %27, i32 0, i64* %22, i32 %97, i64* %17, i32 %0)
br i1 %93, label %626, label %732
626: ; preds = %623
%627 = select i1 %206, i1 true, i1 %209
br i1 %627, label %697, label %628
628: ; preds = %626
br i1 %212, label %678, label %629
629: ; preds = %628, %629
%630 = phi i64 [ %675, %629 ], [ 0, %628 ]
%631 = phi i64 [ %676, %629 ], [ 0, %628 ]
%632 = getelementptr inbounds i64, i64* %27, i64 %630
%633 = bitcast i64* %632 to <2 x i64>*
%634 = load <2 x i64>, <2 x i64>* %633
%635 = getelementptr inbounds i64, i64* %632, i64 2
%636 = bitcast i64* %635 to <2 x i64>*
%637 = load <2 x i64>, <2 x i64>* %636
%638 = getelementptr inbounds i64, i64* %14, i64 %630
%639 = bitcast i64* %638 to <2 x i64>*
store <2 x i64> %634, <2 x i64>* %639
%640 = getelementptr inbounds i64, i64* %638, i64 2
%641 = bitcast i64* %640 to <2 x i64>*
store <2 x i64> %637, <2 x i64>* %641
%642 = or i64 %630, 4
%643 = getelementptr inbounds i64, i64* %27, i64 %642
%644 = bitcast i64* %643 to <2 x i64>*
%645 = load <2 x i64>, <2 x i64>* %644
%646 = getelementptr inbounds i64, i64* %643, i64 2
%647 = bitcast i64* %646 to <2 x i64>*
%648 = load <2 x i64>, <2 x i64>* %647
%649 = getelementptr inbounds i64, i64* %14, i64 %642
%650 = bitcast i64* %649 to <2 x i64>*
store <2 x i64> %645, <2 x i64>* %650
%651 = getelementptr inbounds i64, i64* %649, i64 2
%652 = bitcast i64* %651 to <2 x i64>*
store <2 x i64> %648, <2 x i64>* %652
%653 = or i64 %630, 8
%654 = getelementptr inbounds i64, i64* %27, i64 %653
%655 = bitcast i64* %654 to <2 x i64>*
%656 = load <2 x i64>, <2 x i64>* %655
%657 = getelementptr inbounds i64, i64* %654, i64 2
%658 = bitcast i64* %657 to <2 x i64>*
%659 = load <2 x i64>, <2 x i64>* %658
%660 = getelementptr inbounds i64, i64* %14, i64 %653
%661 = bitcast i64* %660 to <2 x i64>*
store <2 x i64> %656, <2 x i64>* %661
%662 = getelementptr inbounds i64, i64* %660, i64 2
%663 = bitcast i64* %662 to <2 x i64>*
store <2 x i64> %659, <2 x i64>* %663
%664 = or i64 %630, 12
%665 = getelementptr inbounds i64, i64* %27, i64 %664
%666 = bitcast i64* %665 to <2 x i64>*
%667 = load <2 x i64>, <2 x i64>* %666
%668 = getelementptr inbounds i64, i64* %665, i64 2
%669 = bitcast i64* %668 to <2 x i64>*
%670 = load <2 x i64>, <2 x i64>* %669
%671 = getelementptr inbounds i64, i64* %14, i64 %664
%672 = bitcast i64* %671 to <2 x i64>*
store <2 x i64> %667, <2 x i64>* %672
%673 = getelementptr inbounds i64, i64* %671, i64 2
%674 = bitcast i64* %673 to <2 x i64>*
store <2 x i64> %670, <2 x i64>* %674
%675 = add nuw i64 %630, 16
%676 = add nuw i64 %631, 4
%677 = icmp eq i64 %676, %213
br i1 %677, label %678, label %629
678: ; preds = %629, %628
%679 = phi i64 [ 0, %628 ], [ %675, %629 ]
br i1 %214, label %696, label %680
680: ; preds = %678, %680
%681 = phi i64 [ %693, %680 ], [ %679, %678 ]
%682 = phi i64 [ %694, %680 ], [ 0, %678 ]
%683 = getelementptr inbounds i64, i64* %27, i64 %681
%684 = bitcast i64* %683 to <2 x i64>*
%685 = load <2 x i64>, <2 x i64>* %684
%686 = getelementptr inbounds i64, i64* %683, i64 2
%687 = bitcast i64* %686 to <2 x i64>*
%688 = load <2 x i64>, <2 x i64>* %687
%689 = getelementptr inbounds i64, i64* %14, i64 %681
%690 = bitcast i64* %689 to <2 x i64>*
store <2 x i64> %685, <2 x i64>* %690
%691 = getelementptr inbounds i64, i64* %689, i64 2
%692 = bitcast i64* %691 to <2 x i64>*
store <2 x i64> %688, <2 x i64>* %692
%693 = add nuw i64 %681, 4
%694 = add i64 %682, 1
%695 = icmp eq i64 %694, %211
br i1 %695, label %696, label %680
696: ; preds = %680, %678
br i1 %215, label %732, label %697
697: ; preds = %626, %696
%698 = phi i64 [ 0, %626 ], [ %210, %696 ]
%699 = xor i64 %698, -1
%700 = add nsw i64 %699, %101
br i1 %217, label %710, label %701
701: ; preds = %697, %701
%702 = phi i64 [ %707, %701 ], [ %698, %697 ]
%703 = phi i64 [ %708, %701 ], [ 0, %697 ]
%704 = getelementptr inbounds i64, i64* %27, i64 %702
%705 = load i64, i64* %704
%706 = getelementptr inbounds i64, i64* %14, i64 %702
store i64 %705, i64* %706
%707 = add nuw nsw i64 %702, 1
%708 = add i64 %703, 1
%709 = icmp eq i64 %708, %216
br i1 %709, label %710, label %701
710: ; preds = %701, %697
%711 = phi i64 [ %698, %697 ], [ %707, %701 ]
%712 = icmp ult i64 %700, 3
br i1 %712, label %732, label %713
713: ; preds = %710, %713
%714 = phi i64 [ %730, %713 ], [ %711, %710 ]
%715 = getelementptr inbounds i64, i64* %27, i64 %714
%716 = load i64, i64* %715
%717 = getelementptr inbounds i64, i64* %14, i64 %714
store i64 %716, i64* %717
%718 = add nuw nsw i64 %714, 1
%719 = getelementptr inbounds i64, i64* %27, i64 %718
%720 = load i64, i64* %719
%721 = getelementptr inbounds i64, i64* %14, i64 %718
store i64 %720, i64* %721
%722 = add nuw nsw i64 %714, 2
%723 = getelementptr inbounds i64, i64* %27, i64 %722
%724 = load i64, i64* %723
%725 = getelementptr inbounds i64, i64* %14, i64 %722
store i64 %724, i64* %725
%726 = add nuw nsw i64 %714, 3
%727 = getelementptr inbounds i64, i64* %27, i64 %726
%728 = load i64, i64* %727
%729 = getelementptr inbounds i64, i64* %14, i64 %726
store i64 %728, i64* %729
%730 = add nuw nsw i64 %714, 4
%731 = icmp eq i64 %730, %105
br i1 %731, label %732, label %713
732: ; preds = %710, %713, %696, %606, %623
%733 = tail call i32 @mpn_mul_n(i64* %22, i64* %6, i64* %528, i32 %0)
%734 = tail call i32 @mpn_tdiv_qr(i64* %25, i64* %27, i32 0, i64* %22, i32 %18, i64* %17, i32 %0)
%735 = tail call i64 @mpn_cmp(i64* %14, i64* %27, i32 %0)
%736 = icmp eq i64 %735, 0
%737 = zext i1 %736 to i32
%738 = tail call i32 @assert(i32 %737)
%739 = load i64, i64* %6
%740 = tail call i64 @call_mulredc1(i32 %0, i64* %14, i64 %739, i64* %528, i64* %17, i64 %86)
store i64 %740, i64* %94
store i64 0, i64* %22
br i1 %98, label %852, label %741
741: ; preds = %732
%742 = select i1 %218, i1 true, i1 %221
br i1 %742, label %817, label %743
743: ; preds = %741
br i1 %224, label %797, label %744
744: ; preds = %743, %744
%745 = phi i64 [ %794, %744 ], [ 0, %743 ]
%746 = phi i64 [ %795, %744 ], [ 0, %743 ]
%747 = getelementptr inbounds i64, i64* %14, i64 %745
%748 = bitcast i64* %747 to <2 x i64>*
%749 = load <2 x i64>, <2 x i64>* %748
%750 = getelementptr inbounds i64, i64* %747, i64 2
%751 = bitcast i64* %750 to <2 x i64>*
%752 = load <2 x i64>, <2 x i64>* %751
%753 = or i64 %745, 1
%754 = getelementptr inbounds i64, i64* %22, i64 %753
%755 = bitcast i64* %754 to <2 x i64>*
store <2 x i64> %749, <2 x i64>* %755
%756 = getelementptr inbounds i64, i64* %754, i64 2
%757 = bitcast i64* %756 to <2 x i64>*
store <2 x i64> %752, <2 x i64>* %757
%758 = or i64 %745, 4
%759 = getelementptr inbounds i64, i64* %14, i64 %758
%760 = bitcast i64* %759 to <2 x i64>*
%761 = load <2 x i64>, <2 x i64>* %760
%762 = getelementptr inbounds i64, i64* %759, i64 2
%763 = bitcast i64* %762 to <2 x i64>*
%764 = load <2 x i64>, <2 x i64>* %763
%765 = or i64 %745, 5
%766 = getelementptr inbounds i64, i64* %22, i64 %765
%767 = bitcast i64* %766 to <2 x i64>*
store <2 x i64> %761, <2 x i64>* %767
%768 = getelementptr inbounds i64, i64* %766, i64 2
%769 = bitcast i64* %768 to <2 x i64>*
store <2 x i64> %764, <2 x i64>* %769
%770 = or i64 %745, 8
%771 = getelementptr inbounds i64, i64* %14, i64 %770
%772 = bitcast i64* %771 to <2 x i64>*
%773 = load <2 x i64>, <2 x i64>* %772
%774 = getelementptr inbounds i64, i64* %771, i64 2
%775 = bitcast i64* %774 to <2 x i64>*
%776 = load <2 x i64>, <2 x i64>* %775
%777 = or i64 %745, 9
%778 = getelementptr inbounds i64, i64* %22, i64 %777
%779 = bitcast i64* %778 to <2 x i64>*
store <2 x i64> %773, <2 x i64>* %779
%780 = getelementptr inbounds i64, i64* %778, i64 2
%781 = bitcast i64* %780 to <2 x i64>*
store <2 x i64> %776, <2 x i64>* %781
%782 = or i64 %745, 12
%783 = getelementptr inbounds i64, i64* %14, i64 %782
%784 = bitcast i64* %783 to <2 x i64>*
%785 = load <2 x i64>, <2 x i64>* %784
%786 = getelementptr inbounds i64, i64* %783, i64 2
%787 = bitcast i64* %786 to <2 x i64>*
%788 = load <2 x i64>, <2 x i64>* %787
%789 = or i64 %745, 13
%790 = getelementptr inbounds i64, i64* %22, i64 %789
%791 = bitcast i64* %790 to <2 x i64>*
store <2 x i64> %785, <2 x i64>* %791
%792 = getelementptr inbounds i64, i64* %790, i64 2
%793 = bitcast i64* %792 to <2 x i64>*
store <2 x i64> %788, <2 x i64>* %793
%794 = add nuw i64 %745, 16
%795 = add nuw i64 %746, 4
%796 = icmp eq i64 %795, %225
br i1 %796, label %797, label %744
797: ; preds = %744, %743
%798 = phi i64 [ 0, %743 ], [ %794, %744 ]
br i1 %226, label %816, label %799
799: ; preds = %797, %799
%800 = phi i64 [ %813, %799 ], [ %798, %797 ]
%801 = phi i64 [ %814, %799 ], [ 0, %797 ]
%802 = getelementptr inbounds i64, i64* %14, i64 %800
%803 = bitcast i64* %802 to <2 x i64>*
%804 = load <2 x i64>, <2 x i64>* %803
%805 = getelementptr inbounds i64, i64* %802, i64 2
%806 = bitcast i64* %805 to <2 x i64>*
%807 = load <2 x i64>, <2 x i64>* %806
%808 = or i64 %800, 1
%809 = getelementptr inbounds i64, i64* %22, i64 %808
%810 = bitcast i64* %809 to <2 x i64>*
store <2 x i64> %804, <2 x i64>* %810
%811 = getelementptr inbounds i64, i64* %809, i64 2
%812 = bitcast i64* %811 to <2 x i64>*
store <2 x i64> %807, <2 x i64>* %812
%813 = add nuw i64 %800, 4
%814 = add i64 %801, 1
%815 = icmp eq i64 %814, %223
br i1 %815, label %816, label %799
816: ; preds = %799, %797
br i1 %227, label %852, label %817
817: ; preds = %741, %816
%818 = phi i64 [ 0, %741 ], [ %222, %816 ]
%819 = xor i64 %818, -1
%820 = add nsw i64 %819, %106
br i1 %229, label %830, label %821
821: ; preds = %817, %821
%822 = phi i64 [ %826, %821 ], [ %818, %817 ]
%823 = phi i64 [ %828, %821 ], [ 0, %817 ]
%824 = getelementptr inbounds i64, i64* %14, i64 %822
%825 = load i64, i64* %824
%826 = add nuw nsw i64 %822, 1
%827 = getelementptr inbounds i64, i64* %22, i64 %826
store i64 %825, i64* %827
%828 = add i64 %823, 1
%829 = icmp eq i64 %828, %228
br i1 %829, label %830, label %821
830: ; preds = %821, %817
%831 = phi i64 [ %818, %817 ], [ %826, %821 ]
%832 = icmp ult i64 %820, 3
br i1 %832, label %852, label %833
833: ; preds = %830, %833
%834 = phi i64 [ %849, %833 ], [ %831, %830 ]
%835 = getelementptr inbounds i64, i64* %14, i64 %834
%836 = load i64, i64* %835
%837 = add nuw nsw i64 %834, 1
%838 = getelementptr inbounds i64, i64* %22, i64 %837
store i64 %836, i64* %838
%839 = getelementptr inbounds i64, i64* %14, i64 %837
%840 = load i64, i64* %839
%841 = add nuw nsw i64 %834, 2
%842 = getelementptr inbounds i64, i64* %22, i64 %841
store i64 %840, i64* %842
%843 = getelementptr inbounds i64, i64* %14, i64 %841
%844 = load i64, i64* %843
%845 = add nuw nsw i64 %834, 3
%846 = getelementptr inbounds i64, i64* %22, i64 %845
store i64 %844, i64* %846
%847 = getelementptr inbounds i64, i64* %14, i64 %845
%848 = load i64, i64* %847
%849 = add nuw nsw i64 %834, 4
%850 = getelementptr inbounds i64, i64* %22, i64 %849
store i64 %848, i64* %850
%851 = icmp eq i64 %849, %106
br i1 %851, label %852, label %833
852: ; preds = %830, %833, %816, %732
%853 = tail call i32 @mpn_tdiv_qr(i64* %25, i64* %27, i32 0, i64* %22, i32 %99, i64* %17, i32 %0)
br i1 %93, label %854, label %960
854: ; preds = %852
%855 = select i1 %230, i1 true, i1 %233
br i1 %855, label %925, label %856
856: ; preds = %854
br i1 %236, label %906, label %857
857: ; preds = %856, %857
%858 = phi i64 [ %903, %857 ], [ 0, %856 ]
%859 = phi i64 [ %904, %857 ], [ 0, %856 ]
%860 = getelementptr inbounds i64, i64* %27, i64 %858
%861 = bitcast i64* %860 to <2 x i64>*
%862 = load <2 x i64>, <2 x i64>* %861
%863 = getelementptr inbounds i64, i64* %860, i64 2
%864 = bitcast i64* %863 to <2 x i64>*
%865 = load <2 x i64>, <2 x i64>* %864
%866 = getelementptr inbounds i64, i64* %14, i64 %858
%867 = bitcast i64* %866 to <2 x i64>*
store <2 x i64> %862, <2 x i64>* %867
%868 = getelementptr inbounds i64, i64* %866, i64 2
%869 = bitcast i64* %868 to <2 x i64>*
store <2 x i64> %865, <2 x i64>* %869
%870 = or i64 %858, 4
%871 = getelementptr inbounds i64, i64* %27, i64 %870
%872 = bitcast i64* %871 to <2 x i64>*
%873 = load <2 x i64>, <2 x i64>* %872
%874 = getelementptr inbounds i64, i64* %871, i64 2
%875 = bitcast i64* %874 to <2 x i64>*
%876 = load <2 x i64>, <2 x i64>* %875
%877 = getelementptr inbounds i64, i64* %14, i64 %870
%878 = bitcast i64* %877 to <2 x i64>*
store <2 x i64> %873, <2 x i64>* %878
%879 = getelementptr inbounds i64, i64* %877, i64 2
%880 = bitcast i64* %879 to <2 x i64>*
store <2 x i64> %876, <2 x i64>* %880
%881 = or i64 %858, 8
%882 = getelementptr inbounds i64, i64* %27, i64 %881
%883 = bitcast i64* %882 to <2 x i64>*
%884 = load <2 x i64>, <2 x i64>* %883
%885 = getelementptr inbounds i64, i64* %882, i64 2
%886 = bitcast i64* %885 to <2 x i64>*
%887 = load <2 x i64>, <2 x i64>* %886
%888 = getelementptr inbounds i64, i64* %14, i64 %881
%889 = bitcast i64* %888 to <2 x i64>*
store <2 x i64> %884, <2 x i64>* %889
%890 = getelementptr inbounds i64, i64* %888, i64 2
%891 = bitcast i64* %890 to <2 x i64>*
store <2 x i64> %887, <2 x i64>* %891
%892 = or i64 %858, 12
%893 = getelementptr inbounds i64, i64* %27, i64 %892
%894 = bitcast i64* %893 to <2 x i64>*
%895 = load <2 x i64>, <2 x i64>* %894
%896 = getelementptr inbounds i64, i64* %893, i64 2
%897 = bitcast i64* %896 to <2 x i64>*
%898 = load <2 x i64>, <2 x i64>* %897
%899 = getelementptr inbounds i64, i64* %14, i64 %892
%900 = bitcast i64* %899 to <2 x i64>*
store <2 x i64> %895, <2 x i64>* %900
%901 = getelementptr inbounds i64, i64* %899, i64 2
%902 = bitcast i64* %901 to <2 x i64>*
store <2 x i64> %898, <2 x i64>* %902
%903 = add nuw i64 %858, 16
%904 = add nuw i64 %859, 4
%905 = icmp eq i64 %904, %237
br i1 %905, label %906, label %857
906: ; preds = %857, %856
%907 = phi i64 [ 0, %856 ], [ %903, %857 ]
br i1 %238, label %924, label %908
908: ; preds = %906, %908
%909 = phi i64 [ %921, %908 ], [ %907, %906 ]
%910 = phi i64 [ %922, %908 ], [ 0, %906 ]
%911 = getelementptr inbounds i64, i64* %27, i64 %909
%912 = bitcast i64* %911 to <2 x i64>*
%913 = load <2 x i64>, <2 x i64>* %912
%914 = getelementptr inbounds i64, i64* %911, i64 2
%915 = bitcast i64* %914 to <2 x i64>*
%916 = load <2 x i64>, <2 x i64>* %915
%917 = getelementptr inbounds i64, i64* %14, i64 %909
%918 = bitcast i64* %917 to <2 x i64>*
store <2 x i64> %913, <2 x i64>* %918
%919 = getelementptr inbounds i64, i64* %917, i64 2
%920 = bitcast i64* %919 to <2 x i64>*
store <2 x i64> %916, <2 x i64>* %920
%921 = add nuw i64 %909, 4
%922 = add i64 %910, 1
%923 = icmp eq i64 %922, %235
br i1 %923, label %924, label %908
924: ; preds = %908, %906
br i1 %239, label %960, label %925
925: ; preds = %854, %924
%926 = phi i64 [ 0, %854 ], [ %234, %924 ]
%927 = xor i64 %926, -1
%928 = add nsw i64 %927, %101
br i1 %241, label %938, label %929
929: ; preds = %925, %929
%930 = phi i64 [ %935, %929 ], [ %926, %925 ]
%931 = phi i64 [ %936, %929 ], [ 0, %925 ]
%932 = getelementptr inbounds i64, i64* %27, i64 %930
%933 = load i64, i64* %932
%934 = getelementptr inbounds i64, i64* %14, i64 %930
store i64 %933, i64* %934
%935 = add nuw nsw i64 %930, 1
%936 = add i64 %931, 1
%937 = icmp eq i64 %936, %240
br i1 %937, label %938, label %929
938: ; preds = %929, %925
%939 = phi i64 [ %926, %925 ], [ %935, %929 ]
%940 = icmp ult i64 %928, 3
br i1 %940, label %960, label %941
941: ; preds = %938, %941
%942 = phi i64 [ %958, %941 ], [ %939, %938 ]
%943 = getelementptr inbounds i64, i64* %27, i64 %942
%944 = load i64, i64* %943
%945 = getelementptr inbounds i64, i64* %14, i64 %942
store i64 %944, i64* %945
%946 = add nuw nsw i64 %942, 1
%947 = getelementptr inbounds i64, i64* %27, i64 %946
%948 = load i64, i64* %947
%949 = getelementptr inbounds i64, i64* %14, i64 %946
store i64 %948, i64* %949
%950 = add nuw nsw i64 %942, 2
%951 = getelementptr inbounds i64, i64* %27, i64 %950
%952 = load i64, i64* %951
%953 = getelementptr inbounds i64, i64* %14, i64 %950
store i64 %952, i64* %953
%954 = add nuw nsw i64 %942, 3
%955 = getelementptr inbounds i64, i64* %27, i64 %954
%956 = load i64, i64* %955
%957 = getelementptr inbounds i64, i64* %14, i64 %954
store i64 %956, i64* %957
%958 = add nuw nsw i64 %942, 4
%959 = icmp eq i64 %958, %107
br i1 %959, label %960, label %941
960: ; preds = %938, %941, %924, %852
%961 = load i64, i64* %6
%962 = tail call i64 @mpn_mul_1(i64* %22, i64* %528, i32 %0, i64 %961)
store i64 %962, i64* %100
%963 = tail call i32 @mpn_tdiv_qr(i64* %25, i64* %27, i32 0, i64* %22, i32 %11, i64* %17, i32 %0)
%964 = tail call i64 @mpn_cmp(i64* %14, i64* %27, i32 %0)
%965 = icmp eq i64 %964, 0
%966 = zext i1 %965 to i32
%967 = tail call i32 @assert(i32 %966)
%968 = add nuw nsw i32 %243, 1
%969 = icmp eq i32 %968, %1
br i1 %969, label %970, label %242
970: ; preds = %960, %57
%971 = tail call i32 @free(i64* %22)
%972 = tail call i32 @free(i64* %25)
%973 = tail call i32 @free(i64* %27)
%974 = tail call i32 @free(i64* %6)
%975 = tail call i32 @free(i64* %9)
%976 = tail call i32 @free(i64* %14)
%977 = tail call i32 @free(i64* %17)
ret void
}