#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 *add(int *, int, int *, int, int, int *);
int *big_multiply(int *, int, int *, int, int *);
scalar_t__ malloc(int);
int *sub(int *, int, int *, int, int *);
int *karatsuba(int *a, int sizeA, int *b, int sizeB, int *resultSize) {
  if (sizeA < sizeB) {
    return karatsuba(b, sizeB, a, sizeA, resultSize);
  }
  if (sizeA == 0 || sizeB == 0) {
    return NULL;
  }
  if (sizeA <= 50) {
    return big_multiply(a, sizeA, b, sizeB, resultSize);
  }
  int mid = sizeA / 2;
  int i = 0;
  int *a0 = (int *)malloc(sizeof(int) * mid);
  int *a1 = (int *)malloc(sizeof(int) * (sizeA - mid));
  for (i = 0; i < mid; i++) {
    a0[i] = a[i];
  }
  for (i = 0; i < sizeA - mid; i++) {
    a1[i] = a[mid + i];
  }
  int *ret = NULL;
  int ret_size = 0;
  if (mid < sizeB) {
    int *b0 = (int *)malloc(sizeof(int) * mid);
    int *b1 = (int *)malloc(sizeof(int) * (sizeB - mid));
    for (i = 0; i < mid; i++) {
      b0[i] = b[i];
    }
    for (i = 0; i < sizeB - mid; i++) {
      b1[i] = b[mid + i];
    }
    int z2_size = 0;
    int z0_size = 0;
    int *z2 = karatsuba(a1, sizeA - mid, b1, sizeB - mid, &z2_size);
    int *z0 = karatsuba(a0, mid, b0, mid, &z0_size);
    int a0_size = 0;
    int b0_size = 0;
    a0 = add(a0, mid, a1, sizeA - mid, 0, &a0_size);
    b0 = add(b0, mid, b1, sizeB - mid, 0, &b0_size);
    int z1_size = 0;
    int *z1 = karatsuba(a0, a0_size, b0, b0_size, &z1_size);
    z1 = sub(z1, z1_size, z0, z0_size, &z1_size);
    z1 = sub(z1, z1_size, z2, z2_size, &z1_size);
    ret = add(ret, 0, z0, z0_size, 0, &ret_size);
    ret = add(ret, ret_size, z1, z1_size, mid, &ret_size);
    ret = add(ret, ret_size, z2, z2_size, mid + mid, &ret_size);
  } else {
    int z3_size = 0;
    int z4_size = 0;
    int *z3 = karatsuba(a0, mid, b, sizeB, &z3_size);
    int *z4 = karatsuba(a1, sizeA - mid, b, sizeB, &z4_size);
    ret = add(ret, 0, z3, z3_size, 0, &ret_size);
    ret = add(ret, ret_size, z4, z4_size, mid, &ret_size);
  }
  *resultSize = ret_size;
  return ret;
}


x86 assembly (clang, -O0):
<karatsuba>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1199 <karatsuba+0x49>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x14(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0x8(%rbp)
jmp    159b <karatsuba+0x44b>
cmpl   $0x0,-0x14(%rbp)
je     11ad <karatsuba+0x5d>
cmpl   $0x0,-0x24(%rbp)
jne    11ba <karatsuba+0x6a>
movq   $0x0,-0x8(%rbp)
jmp    159b <karatsuba+0x44b>
cmpl   $0x32,-0x14(%rbp)
jg     11e4 <karatsuba+0x94>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
call   1060 <big_multiply@plt>
mov    %rax,-0x8(%rbp)
jmp    159b <karatsuba+0x44b>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    125a <karatsuba+0x10a>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    122a <karatsuba+0xda>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    129b <karatsuba+0x14b>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1261 <karatsuba+0x111>
movq   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14e8 <karatsuba+0x398>
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x24(%rbp),%eax
sub    -0x34(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1317 <karatsuba+0x1c7>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e7 <karatsuba+0x197>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1358 <karatsuba+0x208>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    131e <karatsuba+0x1ce>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
sub    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x24(%rbp),%ecx
sub    -0x34(%rbp),%ecx
lea    -0x6c(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0x78(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x34(%rbp),%ecx
lea    -0x70(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x48(%rbp),%rdx
mov    -0x14(%rbp),%ecx
sub    -0x34(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x84(%rbp),%r9
call   1040 <add@plt>
mov    %rax,-0x40(%rbp)
mov    -0x60(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x24(%rbp),%ecx
sub    -0x34(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x88(%rbp),%r9
call   1040 <add@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x84(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    -0x88(%rbp),%ecx
lea    -0x8c(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rdi
mov    -0x8c(%rbp),%esi
mov    -0x80(%rbp),%rdx
mov    -0x70(%rbp),%ecx
lea    -0x8c(%rbp),%r8
call   1070 <sub@plt>
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rdi
mov    -0x8c(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x6c(%rbp),%ecx
lea    -0x8c(%rbp),%r8
call   1070 <sub@plt>
mov    %rax,-0x98(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x80(%rbp),%rdx
mov    -0x70(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x54(%rbp),%r9
mov    %r8d,%esi
call   1040 <add@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x98(%rbp),%rdx
mov    -0x8c(%rbp),%ecx
mov    -0x34(%rbp),%r8d
lea    -0x54(%rbp),%r9
call   1040 <add@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0x78(%rbp),%rdx
mov    -0x6c(%rbp),%ecx
mov    -0x34(%rbp),%r8d
add    -0x34(%rbp),%r8d
lea    -0x54(%rbp),%r9
call   1040 <add@plt>
mov    %rax,-0x50(%rbp)
jmp    158a <karatsuba+0x43a>
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0xa0(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
lea    -0x9c(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%esi
sub    -0x34(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
lea    -0xa0(%rbp),%r8
call   1030 <karatsuba@plt>
mov    %rax,-0xb0(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
mov    -0x9c(%rbp),%ecx
xor    %r8d,%r8d
lea    -0x54(%rbp),%r9
mov    %r8d,%esi
call   1040 <add@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x54(%rbp),%esi
mov    -0xb0(%rbp),%rdx
mov    -0xa0(%rbp),%ecx
mov    -0x34(%rbp),%r8d
lea    -0x54(%rbp),%r9
call   1040 <add@plt>
mov    %rax,-0x50(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<karatsuba>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%r15d
mov    %rdx,%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r15d,%ebp
mov    %rbx,%r12
mov    %esi,%r15d
mov    %rdi,%rbx
mov    %r12,%rdi
mov    %ebp,%esi
cmp    %ebp,%r15d
jl     1170 <karatsuba+0x20>
xor    %eax,%eax
test   %r15d,%r15d
je     1a0d <karatsuba+0x8bd>
test   %ebp,%ebp
je     1a0d <karatsuba+0x8bd>
cmp    $0x32,%r15d
jg     11bd <karatsuba+0x6d>
mov    %rbx,%rdi
mov    %r15d,%esi
mov    %r12,%rdx
mov    %ebp,%ecx
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <big_multiply@plt>
mov    %r8,0x30(%rsp)
mov    %r15d,%r13d
shr    %r13d
lea    0x0(,%r13,4),%edi
mov    %edi,0x10(%rsp)
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %r15d,%eax
sub    %r13d,%eax
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,4),%edi
call   1050 <malloc@plt>
mov    %r13,%rsi
mov    %rax,%r13
cmp    $0x2,%esi
mov    $0x1,%r11d
cmovae %esi,%r11d
cmp    $0x8,%r11d
jb     121e <karatsuba+0xce>
lea    (%rbx,%r11,4),%rax
cmp    %rax,%r14
jae    1290 <karatsuba+0x140>
lea    (%r14,%r11,4),%rax
cmp    %rax,%rbx
jae    1290 <karatsuba+0x140>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r11,%rcx
mov    %r11,%rdx
and    $0x3,%rdx
je     1251 <karatsuba+0x101>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rax,4),%edi
mov    %edi,(%r14,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1240 <karatsuba+0xf0>
cmp    $0x3,%rcx
jb     1364 <karatsuba+0x214>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%ecx
mov    %ecx,(%r14,%rax,4)
mov    0x4(%rbx,%rax,4),%ecx
mov    %ecx,0x4(%r14,%rax,4)
mov    0x8(%rbx,%rax,4),%ecx
mov    %ecx,0x8(%r14,%rax,4)
mov    0xc(%rbx,%rax,4),%ecx
mov    %ecx,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1260 <karatsuba+0x110>
jmp    1364 <karatsuba+0x214>
mov    %r11d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdi
jae    12b6 <karatsuba+0x166>
xor    %edi,%edi
jmp    1320 <karatsuba+0x1d0>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%r14,%rdi,4)
movups %xmm1,0x50(%r14,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%r14,%rdi,4)
movups %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rdx
jne    12c0 <karatsuba+0x170>
test   %r8,%r8
je     135b <karatsuba+0x20b>
lea    (%r14,%rdi,4),%rdx
add    $0x10,%rdx
lea    (%rbx,%rdi,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1340 <karatsuba+0x1f0>
cmp    %r11,%rax
jne    1220 <karatsuba+0xd0>
cmpl   $0x0,0x18(%rsp)
jle    1514 <karatsuba+0x3c4>
mov    %esi,%r8d
mov    0x18(%rsp),%rax
mov    %eax,%r10d
cmp    $0x8,%eax
jb     13a8 <karatsuba+0x258>
lea    (%r8,%r10,1),%rcx
lea    (%rbx,%rcx,4),%rcx
cmp    %rcx,%r13
jae    1421 <karatsuba+0x2d1>
lea    0x0(,%r10,4),%rcx
add    %r13,%rcx
lea    (%rbx,%r8,4),%rdx
cmp    %rcx,%rdx
jae    1421 <karatsuba+0x2d1>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r10,%r9
mov    %r10,%rcx
and    $0x3,%rcx
je     13d2 <karatsuba+0x282>
lea    (%rbx,%r8,4),%rdi
mov    (%rdi,%rdx,4),%eax
mov    %eax,0x0(%r13,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    13c0 <karatsuba+0x270>
cmp    $0x3,%r9
jb     1514 <karatsuba+0x3c4>
lea    (%rbx,%r8,4),%rcx
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0xc(%rcx,%rdx,4),%eax
mov    %eax,0x0(%r13,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%eax
mov    %eax,0x4(%r13,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%eax
mov    %eax,0x8(%r13,%rdx,4)
mov    (%rcx,%rdx,4),%eax
mov    %eax,0xc(%r13,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    13f0 <karatsuba+0x2a0>
jmp    1514 <karatsuba+0x3c4>
mov    %r10d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    1447 <karatsuba+0x2f7>
xor    %ecx,%ecx
jmp    14c1 <karatsuba+0x371>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,4),%rax
add    $0x70,%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rax,%rcx,4),%xmm0
movups -0x60(%rax,%rcx,4),%xmm1
movups %xmm0,0x0(%r13,%rcx,4)
movups %xmm1,0x10(%r13,%rcx,4)
movups -0x50(%rax,%rcx,4),%xmm0
movups -0x40(%rax,%rcx,4),%xmm1
movups %xmm0,0x20(%r13,%rcx,4)
movups %xmm1,0x30(%r13,%rcx,4)
movups -0x30(%rax,%rcx,4),%xmm0
movups -0x20(%rax,%rcx,4),%xmm1
movups %xmm0,0x40(%r13,%rcx,4)
movups %xmm1,0x50(%r13,%rcx,4)
movups -0x10(%rax,%rcx,4),%xmm0
movups (%rax,%rcx,4),%xmm1
movups %xmm0,0x60(%r13,%rcx,4)
movups %xmm1,0x70(%r13,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1460 <karatsuba+0x310>
test   %r9,%r9
je     150b <karatsuba+0x3bb>
lea    0x10(,%rcx,4),%rax
add    %r13,%rax
add    %r8,%rcx
lea    (%rbx,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    14f0 <karatsuba+0x3a0>
cmp    %r10,%rdx
jne    13aa <karatsuba+0x25a>
movl   $0x0,0x8(%rsp)
mov    %ebp,%ebx
sub    %esi,%ebx
jle    15f1 <karatsuba+0x4a1>
mov    %rsi,0x40(%rsp)
mov    0x10(%rsp),%edi
mov    %r11,0x10(%rsp)
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,0x28(%rsp)
lea    0x0(,%rbx,4),%edi
call   1050 <malloc@plt>
mov    0x10(%rsp),%r8
mov    %rax,%rbx
cmp    $0x2,%r15d
jb     1734 <karatsuba+0x5e4>
cmp    $0x8,%r8d
jb     1586 <karatsuba+0x436>
lea    (%r12,%r8,4),%rax
cmp    %rax,%rbp
jae    1660 <karatsuba+0x510>
lea    0x0(,%r8,4),%rax
add    %rbp,%rax
cmp    %rax,%r12
jae    1660 <karatsuba+0x510>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r8,%rcx
mov    %r8,%rdx
and    $0x3,%rdx
je     15b2 <karatsuba+0x462>
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rax,4),%esi
mov    %esi,0x0(%rbp,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    15a0 <karatsuba+0x450>
cmp    $0x3,%rcx
jb     1734 <karatsuba+0x5e4>
nopl   0x0(%rax)
mov    (%r12,%rax,4),%ecx
mov    %ecx,0x0(%rbp,%rax,4)
mov    0x4(%r12,%rax,4),%ecx
mov    %ecx,0x4(%rbp,%rax,4)
mov    0x8(%r12,%rax,4),%ecx
mov    %ecx,0x8(%rbp,%rax,4)
mov    0xc(%r12,%rax,4),%ecx
mov    %ecx,0xc(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r8
jne    15c0 <karatsuba+0x470>
jmp    1734 <karatsuba+0x5e4>
movl   $0x0,0x4(%rsp)
movl   $0x0,(%rsp)
lea    0x4(%rsp),%r8
mov    %r14,%rdi
mov    %r12,%rdx
mov    %ebp,%ecx
mov    %rsi,%r15
call   1030 <karatsuba@plt>
mov    %rax,%rbx
mov    %rsp,%r8
mov    %r13,%rdi
mov    0x18(%rsp),%rsi
mov    %r12,%rdx
mov    %ebp,%ecx
call   1030 <karatsuba@plt>
mov    %rax,%rbp
mov    0x4(%rsp),%ecx
lea    0x8(%rsp),%r14
xor    %edi,%edi
xor    %esi,%esi
mov    %rbx,%rdx
xor    %r8d,%r8d
mov    %r14,%r9
call   1040 <add@plt>
mov    0x8(%rsp),%esi
mov    (%rsp),%ecx
mov    %rax,%rdi
mov    %rbp,%rdx
mov    %r15d,%r8d
jmp    19fa <karatsuba+0x8aa>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1684 <karatsuba+0x534>
xor    %esi,%esi
jmp    16f1 <karatsuba+0x5a1>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%r12,%rsi,4),%xmm0
movups 0x10(%r12,%rsi,4),%xmm1
movups %xmm0,0x0(%rbp,%rsi,4)
movups %xmm1,0x10(%rbp,%rsi,4)
movups 0x20(%r12,%rsi,4),%xmm0
movups 0x30(%r12,%rsi,4),%xmm1
movups %xmm0,0x20(%rbp,%rsi,4)
movups %xmm1,0x30(%rbp,%rsi,4)
movups 0x40(%r12,%rsi,4),%xmm0
movups 0x50(%r12,%rsi,4),%xmm1
movups %xmm0,0x40(%rbp,%rsi,4)
movups %xmm1,0x50(%rbp,%rsi,4)
movups 0x60(%r12,%rsi,4),%xmm0
movups 0x70(%r12,%rsi,4),%xmm1
movups %xmm0,0x60(%rbp,%rsi,4)
movups %xmm1,0x70(%rbp,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1690 <karatsuba+0x540>
test   %rcx,%rcx
je     172b <karatsuba+0x5db>
lea    0x10(,%rsi,4),%rdx
add    %rbp,%rdx
lea    (%r12,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nop
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1710 <karatsuba+0x5c0>
cmp    %r8,%rax
jne    1588 <karatsuba+0x438>
mov    0x28(%rsp),%rcx
test   %ecx,%ecx
mov    0x40(%rsp),%r11
jle    18c9 <karatsuba+0x779>
mov    %r11d,%r8d
mov    %ecx,%r10d
cmp    $0x8,%ecx
jb     1773 <karatsuba+0x623>
lea    (%r8,%r10,1),%rax
lea    (%r12,%rax,4),%rax
cmp    %rax,%rbx
jae    17ec <karatsuba+0x69c>
lea    (%rbx,%r10,4),%rax
lea    (%r12,%r8,4),%rdx
cmp    %rax,%rdx
jae    17ec <karatsuba+0x69c>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r10,%r9
mov    %r10,%rsi
and    $0x3,%rsi
je     17a0 <karatsuba+0x650>
lea    (%r12,%r8,4),%rdi
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rdx,4),%eax
mov    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1790 <karatsuba+0x640>
cmp    $0x3,%r9
jb     18c9 <karatsuba+0x779>
lea    (%r12,%r8,4),%rsi
add    $0xc,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0xc(%rsi,%rdx,4),%eax
mov    %eax,(%rbx,%rdx,4)
mov    -0x8(%rsi,%rdx,4),%eax
mov    %eax,0x4(%rbx,%rdx,4)
mov    -0x4(%rsi,%rdx,4),%eax
mov    %eax,0x8(%rbx,%rdx,4)
mov    (%rsi,%rdx,4),%eax
mov    %eax,0xc(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    17c0 <karatsuba+0x670>
jmp    18c9 <karatsuba+0x779>
mov    %r10d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    1812 <karatsuba+0x6c2>
xor    %ecx,%ecx
jmp    1878 <karatsuba+0x728>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%r8,4),%rsi
add    $0x70,%rsi
xor    %ecx,%ecx
movups -0x70(%rsi,%rcx,4),%xmm0
movups -0x60(%rsi,%rcx,4),%xmm1
movups %xmm0,(%rbx,%rcx,4)
movups %xmm1,0x10(%rbx,%rcx,4)
movups -0x50(%rsi,%rcx,4),%xmm0
movups -0x40(%rsi,%rcx,4),%xmm1
movups %xmm0,0x20(%rbx,%rcx,4)
movups %xmm1,0x30(%rbx,%rcx,4)
movups -0x30(%rsi,%rcx,4),%xmm0
movups -0x20(%rsi,%rcx,4),%xmm1
movups %xmm0,0x40(%rbx,%rcx,4)
movups %xmm1,0x50(%rbx,%rcx,4)
movups -0x10(%rsi,%rcx,4),%xmm0
movups (%rsi,%rcx,4),%xmm1
movups %xmm0,0x60(%rbx,%rcx,4)
movups %xmm1,0x70(%rbx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1820 <karatsuba+0x6d0>
test   %r9,%r9
je     18bb <karatsuba+0x76b>
lea    (%rbx,%rcx,4),%rsi
add    $0x10,%rsi
add    %r8,%rcx
lea    (%r12,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    18a0 <karatsuba+0x750>
cmp    %r10,%rdx
mov    0x28(%rsp),%rcx
jne    1775 <karatsuba+0x625>
movl   $0x0,0x4(%rsp)
movl   $0x0,(%rsp)
lea    0x4(%rsp),%r8
mov    %r13,%rdi
mov    0x18(%rsp),%rsi
mov    %rbx,%rdx
mov    %r11,%r12
call   1030 <karatsuba@plt>
mov    %rax,0x10(%rsp)
mov    %rsp,%r8
mov    %r14,%rdi
mov    %r12d,%esi
mov    %rbp,%rdx
mov    %r12d,%ecx
call   1030 <karatsuba@plt>
mov    %rax,0x38(%rsp)
movl   $0x0,0x24(%rsp)
movl   $0x0,0x20(%rsp)
lea    0x24(%rsp),%r9
mov    %r14,%rdi
mov    %r12d,%esi
mov    %r13,%rdx
mov    0x18(%rsp),%rcx
xor    %r8d,%r8d
call   1040 <add@plt>
mov    %rax,%r14
lea    0x20(%rsp),%r9
mov    %rbp,%rdi
mov    %r12d,%esi
mov    %rbx,%rdx
mov    0x28(%rsp),%rcx
xor    %r8d,%r8d
call   1040 <add@plt>
movl   $0x0,0xc(%rsp)
mov    0x24(%rsp),%esi
mov    0x20(%rsp),%ecx
lea    0xc(%rsp),%r13
mov    %r14,%rdi
mov    %rax,%rdx
mov    %r13,%r8
call   1030 <karatsuba@plt>
mov    0xc(%rsp),%esi
mov    (%rsp),%ecx
mov    %rax,%rdi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    %r13,%r8
call   1070 <sub@plt>
mov    0xc(%rsp),%esi
mov    0x4(%rsp),%ecx
mov    %rax,%rdi
mov    0x10(%rsp),%rbx
mov    %rbx,%rdx
mov    %r13,%r8
call   1070 <sub@plt>
mov    %rax,%r13
mov    (%rsp),%ecx
lea    0x8(%rsp),%r14
xor    %edi,%edi
xor    %esi,%esi
mov    %rbp,%rdx
xor    %r8d,%r8d
mov    %r14,%r9
call   1040 <add@plt>
mov    0x8(%rsp),%esi
mov    0xc(%rsp),%ecx
mov    %rax,%rdi
mov    %r13,%rdx
mov    %r12d,%r8d
mov    %r14,%r9
call   1040 <add@plt>
mov    0x8(%rsp),%esi
mov    0x4(%rsp),%ecx
and    $0xfffffffe,%r15d
mov    %rax,%rdi
mov    %rbx,%rdx
mov    %r15d,%r8d
mov    %r14,%r9
call   1040 <add@plt>
mov    0x30(%rsp),%rdx
mov    0x8(%rsp),%ecx
mov    %ecx,(%rdx)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32* @karatsuba(i32* %0, i32 %1, i32* %2, i32 %3, i32* %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32*
%23 = alloca i32*
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32*
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32*
%31 = alloca i32*
store i32* %0, i32** %7
store i32 %1, i32* %8
store i32* %2, i32** %9
store i32 %3, i32* %10
store i32* %4, i32** %11
%32 = load i32, i32* %8
%33 = load i32, i32* %10
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %42
35: ; preds = %5
%36 = load i32*, i32** %9
%37 = load i32, i32* %10
%38 = load i32*, i32** %7
%39 = load i32, i32* %8
%40 = load i32*, i32** %11
%41 = call i32* @karatsuba(i32* %36, i32 %37, i32* %38, i32 %39, i32* %40)
store i32* %41, i32** %6
br label %262
42: ; preds = %5
%43 = load i32, i32* %8
%44 = icmp eq i32 %43, 0
br i1 %44, label %48, label %45
45: ; preds = %42
%46 = load i32, i32* %10
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %49
48: ; preds = %45, %42
store i32* null, i32** %6
br label %262
49: ; preds = %45
%50 = load i32, i32* %8
%51 = icmp sle i32 %50, 50
br i1 %51, label %52, label %59
52: ; preds = %49
%53 = load i32*, i32** %7
%54 = load i32, i32* %8
%55 = load i32*, i32** %9
%56 = load i32, i32* %10
%57 = load i32*, i32** %11
%58 = call i32* @big_multiply(i32* %53, i32 %54, i32* %55, i32 %56, i32* %57)
store i32* %58, i32** %6
br label %262
59: ; preds = %49
%60 = load i32, i32* %8
%61 = sdiv i32 %60, 2
store i32 %61, i32* %12
store i32 0, i32* %13
%62 = load i32, i32* %12
%63 = sext i32 %62 to i64
%64 = mul i64 4, %63
%65 = trunc i64 %64 to i32
%66 = call i64 @malloc(i32 %65)
%67 = inttoptr i64 %66 to i32*
store i32* %67, i32** %14
%68 = load i32, i32* %8
%69 = load i32, i32* %12
%70 = sub nsw i32 %68, %69
%71 = sext i32 %70 to i64
%72 = mul i64 4, %71
%73 = trunc i64 %72 to i32
%74 = call i64 @malloc(i32 %73)
%75 = inttoptr i64 %74 to i32*
store i32* %75, i32** %15
store i32 0, i32* %13
br label %76
76: ; preds = %90, %59
%77 = load i32, i32* %13
%78 = load i32, i32* %12
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %93
80: ; preds = %76
%81 = load i32*, i32** %7
%82 = load i32, i32* %13
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %81, i64 %83
%85 = load i32, i32* %84
%86 = load i32*, i32** %14
%87 = load i32, i32* %13
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %86, i64 %88
store i32 %85, i32* %89
br label %90
90: ; preds = %80
%91 = load i32, i32* %13
%92 = add nsw i32 %91, 1
store i32 %92, i32* %13
br label %76
93: ; preds = %76
store i32 0, i32* %13
br label %94
94: ; preds = %112, %93
%95 = load i32, i32* %13
%96 = load i32, i32* %8
%97 = load i32, i32* %12
%98 = sub nsw i32 %96, %97
%99 = icmp slt i32 %95, %98
br i1 %99, label %100, label %115
100: ; preds = %94
%101 = load i32*, i32** %7
%102 = load i32, i32* %12
%103 = load i32, i32* %13
%104 = add nsw i32 %102, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %101, i64 %105
%107 = load i32, i32* %106
%108 = load i32*, i32** %15
%109 = load i32, i32* %13
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
store i32 %107, i32* %111
br label %112
112: ; preds = %100
%113 = load i32, i32* %13
%114 = add nsw i32 %113, 1
store i32 %114, i32* %13
br label %94
115: ; preds = %94
store i32* null, i32** %16
store i32 0, i32* %17
%116 = load i32, i32* %12
%117 = load i32, i32* %10
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %235
119: ; preds = %115
%120 = load i32, i32* %12
%121 = sext i32 %120 to i64
%122 = mul i64 4, %121
%123 = trunc i64 %122 to i32
%124 = call i64 @malloc(i32 %123)
%125 = inttoptr i64 %124 to i32*
store i32* %125, i32** %18
%126 = load i32, i32* %10
%127 = load i32, i32* %12
%128 = sub nsw i32 %126, %127
%129 = sext i32 %128 to i64
%130 = mul i64 4, %129
%131 = trunc i64 %130 to i32
%132 = call i64 @malloc(i32 %131)
%133 = inttoptr i64 %132 to i32*
store i32* %133, i32** %19
store i32 0, i32* %13
br label %134
134: ; preds = %148, %119
%135 = load i32, i32* %13
%136 = load i32, i32* %12
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %151
138: ; preds = %134
%139 = load i32*, i32** %9
%140 = load i32, i32* %13
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = load i32*, i32** %18
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %144, i64 %146
store i32 %143, i32* %147
br label %148
148: ; preds = %138
%149 = load i32, i32* %13
%150 = add nsw i32 %149, 1
store i32 %150, i32* %13
br label %134
151: ; preds = %134
store i32 0, i32* %13
br label %152
152: ; preds = %170, %151
%153 = load i32, i32* %13
%154 = load i32, i32* %10
%155 = load i32, i32* %12
%156 = sub nsw i32 %154, %155
%157 = icmp slt i32 %153, %156
br i1 %157, label %158, label %173
158: ; preds = %152
%159 = load i32*, i32** %9
%160 = load i32, i32* %12
%161 = load i32, i32* %13
%162 = add nsw i32 %160, %161
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %159, i64 %163
%165 = load i32, i32* %164
%166 = load i32*, i32** %19
%167 = load i32, i32* %13
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %166, i64 %168
store i32 %165, i32* %169
br label %170
170: ; preds = %158
%171 = load i32, i32* %13
%172 = add nsw i32 %171, 1
store i32 %172, i32* %13
br label %152
173: ; preds = %152
store i32 0, i32* %20
store i32 0, i32* %21
%174 = load i32*, i32** %15
%175 = load i32, i32* %8
%176 = load i32, i32* %12
%177 = sub nsw i32 %175, %176
%178 = load i32*, i32** %19
%179 = load i32, i32* %10
%180 = load i32, i32* %12
%181 = sub nsw i32 %179, %180
%182 = call i32* @karatsuba(i32* %174, i32 %177, i32* %178, i32 %181, i32* %20)
store i32* %182, i32** %22
%183 = load i32*, i32** %14
%184 = load i32, i32* %12
%185 = load i32*, i32** %18
%186 = load i32, i32* %12
%187 = call i32* @karatsuba(i32* %183, i32 %184, i32* %185, i32 %186, i32* %21)
store i32* %187, i32** %23
store i32 0, i32* %24
store i32 0, i32* %25
%188 = load i32*, i32** %14
%189 = load i32, i32* %12
%190 = load i32*, i32** %15
%191 = load i32, i32* %8
%192 = load i32, i32* %12
%193 = sub nsw i32 %191, %192
%194 = call i32* @add(i32* %188, i32 %189, i32* %190, i32 %193, i32 0, i32* %24)
store i32* %194, i32** %14
%195 = load i32*, i32** %18
%196 = load i32, i32* %12
%197 = load i32*, i32** %19
%198 = load i32, i32* %10
%199 = load i32, i32* %12
%200 = sub nsw i32 %198, %199
%201 = call i32* @add(i32* %195, i32 %196, i32* %197, i32 %200, i32 0, i32* %25)
store i32* %201, i32** %18
store i32 0, i32* %26
%202 = load i32*, i32** %14
%203 = load i32, i32* %24
%204 = load i32*, i32** %18
%205 = load i32, i32* %25
%206 = call i32* @karatsuba(i32* %202, i32 %203, i32* %204, i32 %205, i32* %26)
store i32* %206, i32** %27
%207 = load i32*, i32** %27
%208 = load i32, i32* %26
%209 = load i32*, i32** %23
%210 = load i32, i32* %21
%211 = call i32* @sub(i32* %207, i32 %208, i32* %209, i32 %210, i32* %26)
store i32* %211, i32** %27
%212 = load i32*, i32** %27
%213 = load i32, i32* %26
%214 = load i32*, i32** %22
%215 = load i32, i32* %20
%216 = call i32* @sub(i32* %212, i32 %213, i32* %214, i32 %215, i32* %26)
store i32* %216, i32** %27
%217 = load i32*, i32** %16
%218 = load i32*, i32** %23
%219 = load i32, i32* %21
%220 = call i32* @add(i32* %217, i32 0, i32* %218, i32 %219, i32 0, i32* %17)
store i32* %220, i32** %16
%221 = load i32*, i32** %16
%222 = load i32, i32* %17
%223 = load i32*, i32** %27
%224 = load i32, i32* %26
%225 = load i32, i32* %12
%226 = call i32* @add(i32* %221, i32 %222, i32* %223, i32 %224, i32 %225, i32* %17)
store i32* %226, i32** %16
%227 = load i32*, i32** %16
%228 = load i32, i32* %17
%229 = load i32*, i32** %22
%230 = load i32, i32* %20
%231 = load i32, i32* %12
%232 = load i32, i32* %12
%233 = add nsw i32 %231, %232
%234 = call i32* @add(i32* %227, i32 %228, i32* %229, i32 %230, i32 %233, i32* %17)
store i32* %234, i32** %16
br label %258
235: ; preds = %115
store i32 0, i32* %28
store i32 0, i32* %29
%236 = load i32*, i32** %14
%237 = load i32, i32* %12
%238 = load i32*, i32** %9
%239 = load i32, i32* %10
%240 = call i32* @karatsuba(i32* %236, i32 %237, i32* %238, i32 %239, i32* %28)
store i32* %240, i32** %30
%241 = load i32*, i32** %15
%242 = load i32, i32* %8
%243 = load i32, i32* %12
%244 = sub nsw i32 %242, %243
%245 = load i32*, i32** %9
%246 = load i32, i32* %10
%247 = call i32* @karatsuba(i32* %241, i32 %244, i32* %245, i32 %246, i32* %29)
store i32* %247, i32** %31
%248 = load i32*, i32** %16
%249 = load i32*, i32** %30
%250 = load i32, i32* %28
%251 = call i32* @add(i32* %248, i32 0, i32* %249, i32 %250, i32 0, i32* %17)
store i32* %251, i32** %16
%252 = load i32*, i32** %16
%253 = load i32, i32* %17
%254 = load i32*, i32** %31
%255 = load i32, i32* %29
%256 = load i32, i32* %12
%257 = call i32* @add(i32* %252, i32 %253, i32* %254, i32 %255, i32 %256, i32* %17)
store i32* %257, i32** %16
br label %258
258: ; preds = %235, %173
%259 = load i32, i32* %17
%260 = load i32*, i32** %11
store i32 %259, i32* %260
%261 = load i32*, i32** %16
store i32* %261, i32** %6
br label %262
262: ; preds = %258, %52, %48, %35
%263 = load i32*, i32** %6
ret i32* %263
}

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