#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memset(unsigned short *, char, int);
long mp_add(unsigned short *, unsigned short *, unsigned short *, long,
            unsigned long);
unsigned short *mp_calloc(int, int);
int /*<<< orphan*/ mp_free(unsigned short *);
void *mp_lshift(unsigned short *, unsigned short *, unsigned long, int);
unsigned short *mp_malloc(int);
unsigned long mp_mul(unsigned short *, unsigned short *, unsigned short *,
                     unsigned long, unsigned long);
unsigned long mp_rshift(unsigned short *, unsigned short *, unsigned long, int);
void *mp_sub(unsigned short *, unsigned short *, unsigned short *,
             unsigned long, long);
long mp_toom_mul(unsigned short *rop, unsigned short *op1, unsigned short *op2,
                 unsigned long len1, unsigned long len2) {
  long size, xsize, i;
  unsigned long value;
  unsigned short carry;
  unsigned long x;
  unsigned long l1, l2;
  unsigned long al, bl, cl, dl, el, Ul[3], Vl[3];
  unsigned short *a, *b, *c, *d, *e, *U[3], *V[3];
  x = (len1 + len2 + 4) / 6;
  l1 = len1 - (x << 1);
  l2 = len2 - (x << 1);
  U[0] = mp_malloc(sizeof(unsigned short) * (x + 2));
  V[0] = mp_malloc(sizeof(unsigned short) * (x + 2));
  U[1] = mp_malloc(sizeof(unsigned short) * (x + 1));
  V[1] = mp_malloc(sizeof(unsigned short) * (x + 1));
  U[2] = mp_malloc(sizeof(unsigned short) * (x + 2));
  V[2] = mp_malloc(sizeof(unsigned short) * (x + 2));
  Ul[1] = mp_lshift(U[1], op1 + x, x, 1);
  Ul[0] = mp_lshift(U[0], op1, x, 2);
  Ul[0] = mp_add(U[0], U[0], U[1], Ul[0], Ul[1]);
  Ul[0] = mp_add(U[0], U[0], op1 + x + x, Ul[0], l1);
  Ul[2] = mp_lshift(U[2], op1 + x + x, l1, 2);
  Ul[2] = mp_add(U[2], U[2], U[1], Ul[2], Ul[1]);
  Ul[2] = mp_add(U[2], U[2], op1, Ul[2], x);
  Ul[1] = mp_add(U[1], op1, op1 + x, x, x);
  Ul[1] = mp_add(U[1], U[1], op1 + x + x, Ul[1], l1);
  Vl[1] = mp_lshift(V[1], op2 + x, x, 1);
  Vl[0] = mp_lshift(V[0], op2, x, 2);
  Vl[0] = mp_add(V[0], V[0], V[1], Vl[0], Vl[1]);
  Vl[0] = mp_add(V[0], V[0], op2 + x + x, Vl[0], l2);
  Vl[2] = mp_lshift(V[2], op2 + x + x, l2, 2);
  Vl[2] = mp_add(V[2], V[2], V[1], Vl[2], Vl[1]);
  Vl[2] = mp_add(V[2], V[2], op2, Vl[2], x);
  Vl[1] = mp_add(V[1], op2, op2 + x, x, x);
  Vl[1] = mp_add(V[1], V[1], op2 + x + x, Vl[1], l2);
  b = mp_calloc(1, sizeof(unsigned short) * (Ul[0] * Vl[0]));
  bl = mp_mul(b, U[0], V[0], Ul[0], Vl[0]);
  mp_free(U[0]);
  mp_free(V[0]);
  c = mp_calloc(1, sizeof(unsigned short) * (Ul[1] * Vl[1]));
  cl = mp_mul(c, U[1], V[1], Ul[1], Vl[1]);
  mp_free(U[1]);
  mp_free(V[1]);
  d = mp_calloc(1, sizeof(unsigned short) * (Ul[2] * Vl[2]));
  dl = mp_mul(d, U[2], V[2], Ul[2], Vl[2]);
  mp_free(U[2]);
  mp_free(V[2]);
  a = mp_calloc(1, sizeof(unsigned short) * (x + x));
  al = mp_mul(a, op1, op2, x, x);
  e = mp_calloc(1, sizeof(unsigned short) * (l1 + l2));
  el = mp_mul(e, op1 + x + x, op2 + x + x, l1, l2);
  size = mp_lshift(rop, a, al, 4);
  bl = mp_sub(b, b, rop, bl, size);
  bl = mp_sub(b, b, e, bl, el);
  cl = mp_sub(c, c, a, cl, al);
  cl = mp_sub(c, c, e, cl, el);
  dl = mp_sub(d, d, a, dl, al);
  size = mp_lshift(rop, e, el, 4);
  dl = mp_sub(d, d, rop, dl, size);
  size = mp_add(rop, b, d, bl, dl);
  xsize = mp_lshift(rop + size, c, cl, 3);
  size = mp_sub(rop, rop, rop + size, size, xsize);
  xsize = mp_lshift(rop + size, c, cl, 1);
  size = mp_sub(rop, rop + size, rop, xsize, size);
  bl = mp_rshift(b, b, bl, 1);
  bl = mp_sub(b, b, c, bl, cl);
  cl = mp_rshift(c, rop, size, 1);
  bl = mp_sub(b, b, c, bl, cl);
  i = bl - 1;
  value = b[i];
  b[i] = value / 3;
  for (--i; i >= 0; i--) {
    carry = value % 3;
    value = ((unsigned long)carry << 16) + b[i];
    b[i] = (unsigned short)(value / 3);
  }
  dl = mp_rshift(d, d, dl, 1);
  dl = mp_sub(d, d, b, dl, bl);
  dl = mp_sub(d, d, rop, dl, size);
  dl = mp_rshift(d, d, dl, 2);
  memset(rop, '\0', sizeof(unsigned short) * (len1 + len2));
  i = x * 4;
  xsize = (len1 + len2) - i;
  size = mp_add(rop + i, rop + i, e, xsize, el) + i;
  i = x * 3;
  xsize = size - i;
  size = mp_add(rop + i, rop + i, d, xsize, dl) + i;
  i = x * 2;
  xsize = size - i;
  size = mp_add(rop + i, rop + i, c, xsize, cl) + i;
  i = x;
  xsize = size - i;
  size = mp_add(rop + i, rop + i, b, xsize, bl) + i;
  size = mp_add(rop, rop, a, size, al);
  mp_free(e);
  mp_free(d);
  mp_free(c);
  mp_free(b);
  mp_free(a);
  if (size > 1 && rop[size - 1] == 0)
    --size;
  return (size);
}


x86 assembly (clang, -O0):
<mp_toom_mul>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    -0x28(%rbp),%rax
add    $0x4,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
shl    $0x1,%rcx
sub    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x110(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x130(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x108(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x128(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x100(%rbp)
mov    -0x58(%rbp),%rax
add    $0x2,%rax
shl    $0x1,%rax
mov    %eax,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,-0x120(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x110(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x110(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    -0x108(%rbp),%rdx
mov    -0xb0(%rbp),%rcx
mov    -0xa8(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x110(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0xb0(%rbp),%rcx
mov    -0x60(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x100(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x60(%rbp),%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x100(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    -0x108(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0xa8(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x100(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xa0(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x108(%rbp),%rdi
mov    -0x108(%rbp),%rsi
mov    -0x10(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0xa8(%rbp),%rcx
mov    -0x60(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x130(%rbp),%rsi
mov    -0x128(%rbp),%rdx
mov    -0xd0(%rbp),%rcx
mov    -0xc8(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x130(%rbp),%rdi
mov    -0x130(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0xd0(%rbp),%rcx
mov    -0x68(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xd0(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x68(%rbp),%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x120(%rbp),%rsi
mov    -0x128(%rbp),%rdx
mov    -0xc0(%rbp),%rcx
mov    -0xc8(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x120(%rbp),%rdi
mov    -0x120(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0xc0(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xc0(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xc8(%rbp)
mov    -0x128(%rbp),%rdi
mov    -0x128(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0xc8(%rbp),%rcx
mov    -0x68(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0xc8(%rbp)
mov    -0xb0(%rbp),%rax
imul   -0xd0(%rbp),%rax
ff
shl    $0x1,%rax
mov    %eax,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0x110(%rbp),%rsi
mov    -0x130(%rbp),%rdx
mov    -0xb0(%rbp),%rcx
mov    -0xd0(%rbp),%r8
call   10b0 <mp_mul@plt>
mov    %rax,-0x78(%rbp)
mov    -0x110(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0x130(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xa8(%rbp),%rax
imul   -0xc8(%rbp),%rax
ff
shl    $0x1,%rax
mov    %eax,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0x108(%rbp),%rsi
mov    -0x128(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
mov    -0xc8(%rbp),%r8
call   10b0 <mp_mul@plt>
mov    %rax,-0x80(%rbp)
mov    -0x108(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0x128(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xa0(%rbp),%rax
imul   -0xc0(%rbp),%rax
ff
shl    $0x1,%rax
mov    %eax,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0x100(%rbp),%rsi
mov    -0x120(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
mov    -0xc0(%rbp),%r8
call   10b0 <mp_mul@plt>
mov    %rax,-0x88(%rbp)
mov    -0x100(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0x120(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0x58(%rbp),%rax
add    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x58(%rbp),%r8
call   10b0 <mp_mul@plt>
mov    %rax,-0x70(%rbp)
mov    -0x60(%rbp),%rax
add    -0x68(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,-0xf8(%rbp)
mov    -0xf8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x18(%rbp),%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x60(%rbp),%rcx
mov    -0x68(%rbp),%r8
call   10b0 <mp_mul@plt>
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xd8(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    $0x4,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0x30(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0x8(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x78(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x90(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x78(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0x80(%rbp),%rcx
mov    -0x70(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x80(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x80(%rbp),%rcx
mov    -0x90(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x80(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x70(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xf8(%rbp),%rsi
mov    -0x90(%rbp),%rdx
mov    $0x4,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0x30(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x8(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0xf0(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x88(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0xe8(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    $0x3,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x8(%rbp),%rdx
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0xe8(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0x8(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x30(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %rax,-0x78(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x78(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %rax,-0x80(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe0(%rbp),%rsi
mov    -0xe8(%rbp),%rdx
mov    -0x78(%rbp),%rcx
mov    -0x80(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0xe0(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzwl (%rax,%rcx,2),%eax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x3,%ecx
xor    %edx,%edx
div    %rcx
mov    %ax,%dx
mov    -0xe0(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jl     1b17 <mp_toom_mul+0x987>
mov    -0x48(%rbp),%rax
mov    $0x3,%ecx
xor    %edx,%edx
div    %rcx
mov    %dx,%ax
mov    %ax,-0x4a(%rbp)
movzwl -0x4a(%rbp),%eax
shl    $0x10,%rax
mov    -0xe0(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movzwl (%rcx,%rdx,2),%ecx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    $0x3,%ecx
xor    %edx,%edx
div    %rcx
mov    %ax,%dx
mov    -0xe0(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1aa8 <mp_toom_mul+0x918>
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %rax,-0x88(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0xe0(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x78(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x88(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x8(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    -0x30(%rbp),%r8
call   1070 <mp_sub@plt>
mov    %rax,-0x88(%rbp)
mov    -0xf0(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    $0x2,%ecx
call   1030 <mp_rshift@plt>
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rax
add    -0x28(%rbp),%rax
shl    $0x1,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1060 <memset@plt>
mov    -0x58(%rbp),%rax
shl    $0x2,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    -0x28(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x90(%rbp),%r8
call   1050 <mp_add@plt>
add    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
imul   $0x3,-0x58(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0xf0(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x88(%rbp),%r8
call   1050 <mp_add@plt>
add    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0xe8(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x80(%rbp),%r8
call   1050 <mp_add@plt>
add    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    %rax,%rsi
mov    -0xe0(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x78(%rbp),%r8
call   1050 <mp_add@plt>
add    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0xd8(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    -0x70(%rbp),%r8
call   1050 <mp_add@plt>
mov    %rax,-0x30(%rbp)
mov    -0xf8(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xf0(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xe8(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xe0(%rbp),%rdi
call   1080 <mp_free@plt>
mov    -0xd8(%rbp),%rdi
call   1080 <mp_free@plt>
cmpq   $0x1,-0x30(%rbp)
jle    1da8 <mp_toom_mul+0xc18>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x1,%rcx
movzwl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1da8 <mp_toom_mul+0xc18>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mp_toom_mul>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %rdx,0x18(%rsp)
mov    %rsi,%r14
mov    %rdi,0x58(%rsp)
lea    (%r8,%rcx,1),%rax
mov    %rax,0x98(%rsp)
lea    (%r8,%rcx,1),%rax
add    $0x4,%rax
mov    %rcx,%rsi
movabs $0xaaaaaaaaaaaaaaab,%rcx
aa aa aa
mul    %rcx
mov    %rdx,%r12
shr    $0x2,%r12
lea    (%r12,%r12,1),%rcx
sub    %rcx,%rsi
mov    %rsi,0x10(%rsp)
mov    %rcx,0xa0(%rsp)
sub    %rcx,%r8
mov    %r8,0x20(%rsp)
lea    (%r12,%r12,1),%ebx
add    $0x4,%ebx
mov    %ebx,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,0x30(%rsp)
mov    %ebx,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,0x8(%rsp)
lea    (%r12,%r12,1),%ebp
add    $0x2,%ebp
mov    %ebp,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebx,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebx,%edi
call   10a0 <mp_malloc@plt>
mov    %rax,0x48(%rsp)
mov    %r14,0x50(%rsp)
lea    (%r14,%r12,2),%rbp
mov    %r13,%rbx
mov    %r13,0x38(%rsp)
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %rbp,0x78(%rsp)
mov    %r12,%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,%r15
mov    %rax,0x80(%rsp)
mov    0x30(%rsp),%r13
mov    %r13,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %r13,%rdi
mov    %r13,%rsi
mov    %rbx,%rdx
mov    %rax,%rcx
mov    %r15,%r8
call   1050 <mp_add@plt>
lea    0x0(,%r12,2),%rbx
add    %rbp,%rbx
mov    %r13,%rdi
mov    %r13,%rsi
mov    %rbx,%rdx
mov    %rbx,(%rsp)
mov    %rax,%rcx
mov    0x10(%rsp),%r14
mov    %r14,%r8
call   1050 <mp_add@plt>
mov    %rax,0x70(%rsp)
mov    0x28(%rsp),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %r15,%rdi
mov    %r15,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    %rax,%rcx
mov    0x80(%rsp),%r8
call   1050 <mp_add@plt>
mov    %r15,%rdi
mov    %r15,%rsi
mov    0x50(%rsp),%rbx
mov    %rbx,%rdx
mov    %rax,%rcx
mov    %r12,%r8
call   1050 <mp_add@plt>
mov    %rax,0x80(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    0x78(%rsp),%rdx
mov    %r12,%rcx
mov    %r12,%r8
call   1050 <mp_add@plt>
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    (%rsp),%rdx
mov    %rax,%rcx
mov    %r14,%r8
call   1050 <mp_add@plt>
mov    %rax,0x90(%rsp)
mov    0x18(%rsp),%rbp
lea    0x0(,%r12,2),%rsi
add    %rbp,%rsi
mov    0x40(%rsp),%r14
mov    %r14,%rdi
mov    %rsi,%r15
mov    %rsi,0x60(%rsp)
mov    %r12,%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %rax,%r13
mov    %rax,0x68(%rsp)
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %rax,%rcx
mov    %r13,%r8
call   1050 <mp_add@plt>
lea    (%r15,%r12,2),%rbp
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %rax,%rcx
mov    0x20(%rsp),%rbx
mov    %rbx,%r8
call   1050 <mp_add@plt>
mov    %rax,0x88(%rsp)
mov    0x48(%rsp),%r13
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %rbp,0x78(%rsp)
mov    %rbx,%rdx
mov    $0x2,%ecx
call   1090 <mp_lshift@plt>
mov    %r13,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    %rax,%rcx
mov    0x68(%rsp),%r8
call   1050 <mp_add@plt>
mov    %r13,%rdi
mov    %r13,%rsi
mov    0x18(%rsp),%rbx
mov    %rbx,%rdx
mov    %rax,%rcx
mov    %r12,%r8
call   1050 <mp_add@plt>
mov    %rax,0x68(%rsp)
mov    %r14,%rdi
mov    %rbx,%rsi
mov    0x60(%rsp),%rdx
mov    %r12,%rcx
mov    %r12,%r8
call   1050 <mp_add@plt>
mov    %r14,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    %rax,%rcx
mov    0x20(%rsp),%r8
call   1050 <mp_add@plt>
mov    %rax,0x60(%rsp)
mov    0x88(%rsp),%r14
mov    %r14d,%esi
mov    0x70(%rsp),%r15
imul   %r15d,%esi
add    %esi,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    0x30(%rsp),%rbp
mov    %rbp,%rsi
mov    0x8(%rsp),%r13
mov    %r13,%rdx
mov    %r15,%rcx
mov    %r14,%r8
call   10b0 <mp_mul@plt>
mov    %rax,0x70(%rsp)
mov    %rbp,%rdi
call   1080 <mp_free@plt>
mov    %r13,%rdi
call   1080 <mp_free@plt>
mov    0x60(%rsp),%r14
mov    %r14d,%esi
mov    0x90(%rsp),%r15
imul   %r15d,%esi
add    %esi,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,0x30(%rsp)
mov    %rax,%rdi
mov    0x38(%rsp),%rbp
mov    %rbp,%rsi
mov    0x40(%rsp),%r13
mov    %r13,%rdx
mov    %r15,%rcx
mov    %r14,%r8
call   10b0 <mp_mul@plt>
mov    %rax,0x8(%rsp)
mov    %rbp,%rdi
call   1080 <mp_free@plt>
mov    %r13,%rdi
call   1080 <mp_free@plt>
mov    0x68(%rsp),%r13
mov    %r13d,%esi
mov    0x80(%rsp),%r14
imul   %r14d,%esi
add    %esi,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,0x38(%rsp)
mov    %rax,%rdi
mov    0x28(%rsp),%rbp
mov    %rbp,%rsi
mov    0x48(%rsp),%r15
mov    %r15,%rdx
mov    %r14,%rcx
mov    %r13,%r8
call   10b0 <mp_mul@plt>
mov    %rax,0x40(%rsp)
mov    %rbp,%rdi
call   1080 <mp_free@plt>
mov    %r15,%rdi
call   1080 <mp_free@plt>
lea    0x0(,%r12,4),%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,0x28(%rsp)
mov    %rax,%rdi
mov    0x50(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r12,%rcx
mov    %r12,0x48(%rsp)
mov    %r12,%r8
call   10b0 <mp_mul@plt>
mov    %rax,0x18(%rsp)
mov    0x10(%rsp),%rbp
mov    0x20(%rsp),%r15
lea    (%r15,%rbp,1),%esi
add    %esi,%esi
mov    $0x1,%edi
call   1040 <mp_calloc@plt>
mov    %rax,%r14
mov    %rax,%rdi
mov    (%rsp),%rsi
mov    0x78(%rsp),%rdx
mov    %rbp,%rcx
mov    %r15,%r8
call   10b0 <mp_mul@plt>
mov    %rax,%r13
mov    0x58(%rsp),%rbp
mov    %rbp,%rdi
mov    0x28(%rsp),%r12
mov    %r12,%rsi
mov    0x18(%rsp),%r15
mov    %r15,%rdx
mov    $0x4,%ecx
call   1090 <mp_lshift@plt>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    0x70(%rsp),%rcx
mov    %rax,%r8
call   1070 <mp_sub@plt>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %rax,%rcx
mov    %r13,%r8
call   1070 <mp_sub@plt>
mov    %rax,(%rsp)
mov    0x30(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    0x8(%rsp),%rcx
mov    %r15,%r8
call   1070 <mp_sub@plt>
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %rax,%rcx
mov    %r13,%r8
call   1070 <mp_sub@plt>
mov    %rax,0x8(%rsp)
mov    0x38(%rsp),%r12
mov    %r12,%rdi
mov    %r12,%rsi
mov    0x28(%rsp),%rdx
mov    0x40(%rsp),%rcx
mov    %r15,%r8
call   1070 <mp_sub@plt>
mov    %rax,%r15
mov    0x58(%rsp),%rbp
mov    %rbp,%rdi
mov    %r14,0x20(%rsp)
mov    %r14,%rsi
mov    %r13,0x50(%rsp)
mov    %r13,%rdx
mov    $0x4,%ecx
call   1090 <mp_lshift@plt>
mov    %r12,%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
mov    %r15,%rcx
mov    %rax,%r8
call   1070 <mp_sub@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
mov    (%rsp),%rcx
mov    %rax,0x10(%rsp)
mov    %rax,%r8
call   1050 <mp_add@plt>
mov    %rax,%r12
lea    0x0(,%rax,2),%r14
add    %rbp,%r14
mov    %rbp,%r15
mov    %r14,%rdi
mov    0x30(%rsp),%rbp
mov    %rbp,%rsi
mov    0x8(%rsp),%r13
mov    %r13,%rdx
mov    $0x3,%ecx
call   1090 <mp_lshift@plt>
mov    %r15,%rdi
mov    %r15,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
mov    %rax,%r8
call   1070 <mp_sub@plt>
mov    %rax,%r14
lea    (%r15,%rax,2),%r12
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
mov    $0x1,%ecx
call   1090 <mp_lshift@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r15,%rdx
mov    %rax,%rcx
mov    %r14,%r8
call   1070 <mp_sub@plt>
mov    %rax,%r12
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    (%rsp),%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %rax,%rcx
mov    %r13,%r8
call   1070 <mp_sub@plt>
mov    %rax,%r14
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r14,%rcx
mov    %rax,(%rsp)
mov    %rax,%r8
call   1070 <mp_sub@plt>
movabs $0xaaaaaaaaaaaaaaab,%rbp
aa aa aa
mov    %rax,%r15
movzwl -0x2(%rbx,%rax,2),%ecx
imul   $0xaaab,%ecx,%eax
shr    $0x11,%eax
mov    %ax,-0x2(%rbx,%r15,2)
mov    %r15,%rax
add    $0xfffffffffffffffe,%rax
js     1806 <mp_toom_mul+0x676>
mov    $0xaaaaaaab,%esi
mov    %r15,%rdi
nopl   (%rax)
mov    %rcx,%rax
mul    %rbp
shr    %rdx
lea    (%rdx,%rdx,2),%rax
sub    %rax,%rcx
shl    $0x10,%rcx
movzwl -0x4(%rbx,%rdi,2),%eax
or     %rax,%rcx
mov    %rcx,%rax
imul   %rsi,%rax
shr    $0x21,%rax
mov    %ax,-0x4(%rbx,%rdi,2)
add    $0xffffffffffffffff,%rdi
cmp    $0x1,%rdi
jne    17d0 <mp_toom_mul+0x640>
mov    0x38(%rsp),%r14
mov    %r14,%rdi
mov    %r14,%rsi
mov    0x10(%rsp),%rdx
mov    $0x1,%ecx
call   1030 <mp_rshift@plt>
mov    %r14,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
mov    %rax,%rcx
mov    %r15,%r8
call   1070 <mp_sub@plt>
mov    %r14,%rdi
mov    %r14,%rsi
mov    %r15,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    %r15,%rdx
mov    %rax,%rcx
mov    %r12,%r8
call   1070 <mp_sub@plt>
mov    %r14,%rdi
mov    %r14,%rsi
mov    %rax,%rdx
mov    $0x2,%ecx
call   1030 <mp_rshift@plt>
mov    %rax,%r13
mov    0x98(%rsp),%r12
lea    (%r12,%r12,1),%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    0x48(%rsp),%rbp
lea    0x0(,%rbp,4),%rax
sub    %rax,%r12
lea    (%r15,%rbp,8),%rdi
mov    %rdi,%rsi
mov    0x20(%rsp),%rdx
mov    %r12,%rcx
mov    0x50(%rsp),%r8
call   1050 <mp_add@plt>
lea    (%rax,%rbp,1),%rcx
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
lea    (%r15,%rax,2),%rdi
mov    %rdi,%rsi
mov    %r14,%rdx
mov    %r13,%r8
call   1050 <mp_add@plt>
lea    (%rax,%rbp,1),%rcx
mov    0xa0(%rsp),%rax
lea    (%r15,%rax,2),%rdi
mov    %rdi,%rsi
mov    0x30(%rsp),%r13
mov    %r13,%rdx
mov    (%rsp),%r8
call   1050 <mp_add@plt>
lea    (%rax,%rbp,1),%rcx
lea    (%r15,%rbp,2),%rdi
mov    %rdi,%rsi
mov    %rbx,%rdx
mov    0x10(%rsp),%r8
call   1050 <mp_add@plt>
add    %rax,%rbp
mov    %r15,%rdi
mov    %r15,%rsi
mov    0x28(%rsp),%r15
mov    %r15,%rdx
mov    %rbp,%rcx
mov    0x18(%rsp),%r8
call   1050 <mp_add@plt>
mov    %rax,%rbp
mov    0x20(%rsp),%rdi
call   1080 <mp_free@plt>
mov    %r14,%rdi
call   1080 <mp_free@plt>
mov    %r13,%rdi
call   1080 <mp_free@plt>
mov    %rbx,%rdi
call   1080 <mp_free@plt>
mov    %r15,%rdi
call   1080 <mp_free@plt>
cmp    $0x2,%rbp
jl     1968 <mp_toom_mul+0x7d8>
lea    -0x1(%rbp),%rax
mov    0x58(%rsp),%rcx
cmpw   $0x0,-0x2(%rcx,%rbp,2)
cmove  %rax,%rbp
mov    %rbp,%rax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @mp_toom_mul(i16* %0, i16* %1, i16* %2, i64 %3, i64 %4) {
%6 = add i64 %4, %3
%7 = add i64 %6, 4
%8 = udiv i64 %7, 6
%9 = shl nuw nsw i64 %8, 1
%10 = sub i64 %3, %9
%11 = sub i64 %4, %9
%12 = trunc i64 %8 to i32
%13 = shl i32 %12, 1
%14 = add i32 %13, 4
%15 = tail call i16* @mp_malloc(i32 %14)
%16 = tail call i16* @mp_malloc(i32 %14)
%17 = add i32 %13, 2
%18 = tail call i16* @mp_malloc(i32 %17)
%19 = tail call i16* @mp_malloc(i32 %17)
%20 = tail call i16* @mp_malloc(i32 %14)
%21 = tail call i16* @mp_malloc(i32 %14)
%22 = getelementptr inbounds i16, i16* %1, i64 %8
%23 = tail call i8* @mp_lshift(i16* %18, i16* %22, i64 %8, i32 1)
%24 = ptrtoint i8* %23 to i64
%25 = tail call i8* @mp_lshift(i16* %15, i16* %1, i64 %8, i32 2)
%26 = ptrtoint i8* %25 to i64
%27 = tail call i64 @mp_add(i16* %15, i16* %15, i16* %18, i64 %26, i64 %24)
%28 = getelementptr inbounds i16, i16* %22, i64 %8
%29 = tail call i64 @mp_add(i16* %15, i16* %15, i16* %28, i64 %27, i64 %10)
%30 = tail call i8* @mp_lshift(i16* %20, i16* %28, i64 %10, i32 2)
%31 = ptrtoint i8* %30 to i64
%32 = tail call i64 @mp_add(i16* %20, i16* %20, i16* %18, i64 %31, i64 %24)
%33 = tail call i64 @mp_add(i16* %20, i16* %20, i16* %1, i64 %32, i64 %8)
%34 = tail call i64 @mp_add(i16* %18, i16* %1, i16* %22, i64 %8, i64 %8)
%35 = tail call i64 @mp_add(i16* %18, i16* %18, i16* %28, i64 %34, i64 %10)
%36 = getelementptr inbounds i16, i16* %2, i64 %8
%37 = tail call i8* @mp_lshift(i16* %19, i16* %36, i64 %8, i32 1)
%38 = ptrtoint i8* %37 to i64
%39 = tail call i8* @mp_lshift(i16* %16, i16* %2, i64 %8, i32 2)
%40 = ptrtoint i8* %39 to i64
%41 = tail call i64 @mp_add(i16* %16, i16* %16, i16* %19, i64 %40, i64 %38)
%42 = getelementptr inbounds i16, i16* %36, i64 %8
%43 = tail call i64 @mp_add(i16* %16, i16* %16, i16* %42, i64 %41, i64 %11)
%44 = tail call i8* @mp_lshift(i16* %21, i16* %42, i64 %11, i32 2)
%45 = ptrtoint i8* %44 to i64
%46 = tail call i64 @mp_add(i16* %21, i16* %21, i16* %19, i64 %45, i64 %38)
%47 = tail call i64 @mp_add(i16* %21, i16* %21, i16* %2, i64 %46, i64 %8)
%48 = tail call i64 @mp_add(i16* %19, i16* %2, i16* %36, i64 %8, i64 %8)
%49 = tail call i64 @mp_add(i16* %19, i16* %19, i16* %42, i64 %48, i64 %11)
%50 = mul i64 %43, %29
%51 = trunc i64 %50 to i32
%52 = shl i32 %51, 1
%53 = tail call i16* @mp_calloc(i32 1, i32 %52)
%54 = tail call i64 @mp_mul(i16* %53, i16* %15, i16* %16, i64 %29, i64 %43)
%55 = tail call i32 @mp_free(i16* %15)
%56 = tail call i32 @mp_free(i16* %16)
%57 = mul i64 %49, %35
%58 = trunc i64 %57 to i32
%59 = shl i32 %58, 1
%60 = tail call i16* @mp_calloc(i32 1, i32 %59)
%61 = tail call i64 @mp_mul(i16* %60, i16* %18, i16* %19, i64 %35, i64 %49)
%62 = tail call i32 @mp_free(i16* %18)
%63 = tail call i32 @mp_free(i16* %19)
%64 = mul i64 %47, %33
%65 = trunc i64 %64 to i32
%66 = shl i32 %65, 1
%67 = tail call i16* @mp_calloc(i32 1, i32 %66)
%68 = tail call i64 @mp_mul(i16* %67, i16* %20, i16* %21, i64 %33, i64 %47)
%69 = tail call i32 @mp_free(i16* %20)
%70 = tail call i32 @mp_free(i16* %21)
%71 = shl i32 %12, 2
%72 = tail call i16* @mp_calloc(i32 1, i32 %71)
%73 = tail call i64 @mp_mul(i16* %72, i16* %1, i16* %2, i64 %8, i64 %8)
%74 = add i64 %10, %11
%75 = trunc i64 %74 to i32
%76 = shl i32 %75, 1
%77 = tail call i16* @mp_calloc(i32 1, i32 %76)
%78 = tail call i64 @mp_mul(i16* %77, i16* %28, i16* %42, i64 %10, i64 %11)
%79 = tail call i8* @mp_lshift(i16* %0, i16* %72, i64 %73, i32 4)
%80 = ptrtoint i8* %79 to i64
%81 = tail call i8* @mp_sub(i16* %53, i16* %53, i16* %0, i64 %54, i64 %80)
%82 = ptrtoint i8* %81 to i64
%83 = tail call i8* @mp_sub(i16* %53, i16* %53, i16* %77, i64 %82, i64 %78)
%84 = ptrtoint i8* %83 to i64
%85 = tail call i8* @mp_sub(i16* %60, i16* %60, i16* %72, i64 %61, i64 %73)
%86 = ptrtoint i8* %85 to i64
%87 = tail call i8* @mp_sub(i16* %60, i16* %60, i16* %77, i64 %86, i64 %78)
%88 = ptrtoint i8* %87 to i64
%89 = tail call i8* @mp_sub(i16* %67, i16* %67, i16* %72, i64 %68, i64 %73)
%90 = ptrtoint i8* %89 to i64
%91 = tail call i8* @mp_lshift(i16* %0, i16* %77, i64 %78, i32 4)
%92 = ptrtoint i8* %91 to i64
%93 = tail call i8* @mp_sub(i16* %67, i16* %67, i16* %0, i64 %90, i64 %92)
%94 = ptrtoint i8* %93 to i64
%95 = tail call i64 @mp_add(i16* %0, i16* %53, i16* %67, i64 %84, i64 %94)
%96 = getelementptr inbounds i16, i16* %0, i64 %95
%97 = tail call i8* @mp_lshift(i16* %96, i16* %60, i64 %88, i32 3)
%98 = ptrtoint i8* %97 to i64
%99 = tail call i8* @mp_sub(i16* %0, i16* %0, i16* %96, i64 %95, i64 %98)
%100 = ptrtoint i8* %99 to i64
%101 = getelementptr inbounds i16, i16* %0, i64 %100
%102 = tail call i8* @mp_lshift(i16* %101, i16* %60, i64 %88, i32 1)
%103 = ptrtoint i8* %102 to i64
%104 = tail call i8* @mp_sub(i16* %0, i16* %101, i16* %0, i64 %103, i64 %100)
%105 = ptrtoint i8* %104 to i64
%106 = tail call i64 @mp_rshift(i16* %53, i16* %53, i64 %84, i32 1)
%107 = tail call i8* @mp_sub(i16* %53, i16* %53, i16* %60, i64 %106, i64 %88)
%108 = ptrtoint i8* %107 to i64
%109 = tail call i64 @mp_rshift(i16* %60, i16* %0, i64 %105, i32 1)
%110 = tail call i8* @mp_sub(i16* %53, i16* %53, i16* %60, i64 %108, i64 %109)
%111 = ptrtoint i8* %110 to i64
%112 = add i64 %111, -1
%113 = getelementptr inbounds i16, i16* %53, i64 %112
%114 = load i16, i16* %113
%115 = udiv i16 %114, 3
store i16 %115, i16* %113
%116 = add i64 %111, -2
%117 = icmp sgt i64 %116, -1
br i1 %117, label %118, label %133
118: ; preds = %5
%119 = zext i16 %114 to i64
br label %120
120: ; preds = %118, %120
%121 = phi i64 [ %131, %120 ], [ %116, %118 ]
%122 = phi i64 [ %128, %120 ], [ %119, %118 ]
%123 = urem i64 %122, 3
%124 = shl nuw nsw i64 %123, 16
%125 = getelementptr inbounds i16, i16* %53, i64 %121
%126 = load i16, i16* %125
%127 = zext i16 %126 to i64
%128 = or i64 %124, %127
%129 = udiv i64 %128, 3
%130 = trunc i64 %129 to i16
store i16 %130, i16* %125
%131 = add nsw i64 %121, -1
%132 = icmp eq i64 %121, 0
br i1 %132, label %133, label %120
133: ; preds = %120, %5
%134 = tail call i64 @mp_rshift(i16* %67, i16* %67, i64 %94, i32 1)
%135 = tail call i8* @mp_sub(i16* %67, i16* %67, i16* %53, i64 %134, i64 %111)
%136 = ptrtoint i8* %135 to i64
%137 = tail call i8* @mp_sub(i16* %67, i16* %67, i16* %0, i64 %136, i64 %105)
%138 = ptrtoint i8* %137 to i64
%139 = tail call i64 @mp_rshift(i16* %67, i16* %67, i64 %138, i32 2)
%140 = trunc i64 %6 to i32
%141 = shl i32 %140, 1
%142 = tail call i32 @memset(i16* %0, i8 signext 0, i32 %141)
%143 = shl nuw i64 %8, 2
%144 = sub i64 %6, %143
%145 = getelementptr inbounds i16, i16* %0, i64 %143
%146 = tail call i64 @mp_add(i16* %145, i16* %145, i16* %77, i64 %144, i64 %78)
%147 = mul nuw i64 %8, 3
%148 = add i64 %8, %146
%149 = getelementptr inbounds i16, i16* %0, i64 %147
%150 = tail call i64 @mp_add(i16* %149, i16* %149, i16* %67, i64 %148, i64 %139)
%151 = add i64 %8, %150
%152 = getelementptr inbounds i16, i16* %0, i64 %9
%153 = tail call i64 @mp_add(i16* %152, i16* %152, i16* %60, i64 %151, i64 %109)
%154 = add i64 %8, %153
%155 = getelementptr inbounds i16, i16* %0, i64 %8
%156 = tail call i64 @mp_add(i16* %155, i16* %155, i16* %53, i64 %154, i64 %111)
%157 = add nsw i64 %156, %8
%158 = tail call i64 @mp_add(i16* %0, i16* %0, i16* %72, i64 %157, i64 %73)
%159 = tail call i32 @mp_free(i16* %77)
%160 = tail call i32 @mp_free(i16* %67)
%161 = tail call i32 @mp_free(i16* %60)
%162 = tail call i32 @mp_free(i16* %53)
%163 = tail call i32 @mp_free(i16* %72)
%164 = icmp sgt i64 %158, 1
br i1 %164, label %165, label %171
165: ; preds = %133
%166 = add nsw i64 %158, -1
%167 = getelementptr inbounds i16, i16* %0, i64 %166
%168 = load i16, i16* %167
%169 = icmp eq i16 %168, 0
%170 = select i1 %169, i64 %166, i64 %158
br label %171
171: ; preds = %165, %133
%172 = phi i64 [ %158, %133 ], [ %170, %165 ]
ret i64 %172
}