#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*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, int);
int *multi(int a[], int b[]) {
  int lena = 0;
  int lenb = 0;
  while (a[lena])
    lena++;
  while (b[lenb])
    lenb++;
  int total = lena + lenb;
  int *c = (int *)malloc(sizeof(int) * total);
  int *d = (int *)malloc(sizeof(int) * total);
  int c_num = 0;
  for (; c_num < total; c_num++) {
    *(c + c_num) = 0;
  }
  int i, j;
  for (i = 0; i < lena; i++) {
    for (j = 0; j < lenb; j++) {
      c[i + j] += a[i] * b[j];
    }
  }
  for (i = 0; i < 3; i++) {
    printf("%d\n", c[i]);
  }
  for (i = 0; i < total - 1; i++) {
    c[i + 1] += c[i] / 10;
    c[i] = c[i] % 10;
    printf("%d\n", c[i]);
  }
  int mid_num;
  if (c[total - 1] == 0 && c[total - 2] == 0) {
    d[0] = 0;
    free(c);
    return d;
  }
  if (c[total - 1] == 0) {
    for (i = total - 2, j = 0; i >= 0; i--, j++) {
      d[j] = c[i];
    }
  } else {
    for (i = total - 1, j = 0; i >= 0; i--, j++) {
      d[j] = c[i];
    }
  }
  free(c);
  return d;
}


x86 assembly (clang, -O0):
<multi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     116e <multi+0x3e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    114e <multi+0x1e>
jmp    1173 <multi+0x43>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1193 <multi+0x63>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1173 <multi+0x43>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11f2 <multi+0xc2>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c9 <multi+0x99>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1263 <multi+0x133>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1250 <multi+0x120>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    120c <multi+0xdc>
jmp    1255 <multi+0x125>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11f9 <multi+0xc9>
movl   $0x0,-0x40(%rbp)
cmpl   $0x3,-0x40(%rbp)
jge    1299 <multi+0x169>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xd7a(%rip),%rdi
call   1040 <printf@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    126a <multi+0x13a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    131c <multi+0x1ec>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xcf7(%rip),%rdi
call   1040 <printf@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12a0 <multi+0x170>
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    136a <multi+0x23a>
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    136a <multi+0x23a>
mov    -0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    142a <multi+0x2fa>
mov    -0x30(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    13cd <multi+0x29d>
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     13c8 <multi+0x298>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1391 <multi+0x261>
jmp    1419 <multi+0x2e9>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1414 <multi+0x2e4>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13dd <multi+0x2ad>
jmp    1419 <multi+0x2e9>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rsi,%rbx
mov    %rdi,%r12
mov    $0xfffffff8,%ebp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
add    $0x4,%ebp
cmpl   $0x0,(%r12,%rax,4)
lea    0x1(%rax),%rax
jne    1160 <multi+0x20>
lea    -0x4(%rax),%r15d
lea    -0x3(%rax),%r13d
mov    %rax,0x8(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r13d
add    $0x1,%r15d
add    $0x4,%ebp
cmpl   $0x0,(%rbx,%r14,4)
lea    0x1(%r14),%r14
jne    1190 <multi+0x50>
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %ebp,%edi
mov    %rax,%rbp
call   1060 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r14,1),%ecx
add    $0xfffffffe,%ecx
mov    %ecx,0x14(%rsp)
je     11eb <multi+0xab>
add    %r14d,%eax
add    $0xfffffffd,%eax
lea    0x4(,%rax,4),%rdx
mov    %rbp,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    0x8(%rsp),%rax
cmp    $0x1,%eax
mov    %rbp,%r10
jne    1448 <multi+0x308>
mov    (%r10),%esi
lea    0xdff(%rip),%rbp
mov    %rbp,%rdi
mov    %r10,%rbx
call   1040 <printf@plt>
mov    0x4(%rbx),%esi
mov    %rbp,%rdi
call   1040 <printf@plt>
mov    0x8(%rbx),%esi
mov    %rbp,%rdi
call   1040 <printf@plt>
mov    0x8(%rsp),%rax
add    %r14d,%eax
add    $0xfffffffe,%eax
mov    %eax,(%rsp)
cmp    $0x1,%eax
jbe    128e <multi+0x14e>
mov    0x8(%rsp),%rax
add    %r14d,%eax
add    $0xfffffffd,%eax
cmp    $0x2,%eax
mov    $0x1,%ebp
cmovge %eax,%ebp
xor    %eax,%eax
nopl   (%rax)
movslq (%rbx,%rax,4),%rsi
lea    0x1(%rax),%r12
imul   $0x66666667,%rsi,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x22,%rcx
add    %edx,%ecx
add    %ecx,0x4(%rbx,%rax,4)
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %ecx,%esi
mov    %esi,(%rbx,%rax,4)
lea    0xd7f(%rip),%rdi
call   1040 <printf@plt>
mov    %r12,%rax
cmp    %r12,%rbp
jne    1250 <multi+0x110>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r14,1),%eax
add    $0xfffffffd,%eax
cltq
cmpl   $0x0,(%rbx,%rax,4)
mov    %rbx,%rdi
je     163a <multi+0x4fa>
cmpl   $0x0,0x14(%rsp)
mov    0x18(%rsp),%r12
je     17ed <multi+0x6ad>
lea    (%rcx,%r14,1),%r10d
add    $0xfffffffd,%r10d
xor    %r8d,%r8d
test   %r13d,%r13d
mov    $0x0,%edx
cmovs  %r13d,%edx
neg    %edx
add    %ecx,%edx
add    $0xfffffffd,%edx
add    %r14,%rdx
cmp    $0x7,%edx
jb     141b <multi+0x2db>
test   %r13d,%r13d
mov    $0x0,%esi
cmovs  %r13d,%esi
lea    (%rdi,%r10,4),%rax
add    $0x4,%rax
cmp    %rax,%r12
jae    1322 <multi+0x1e2>
mov    %ecx,%eax
sub    %esi,%eax
lea    (%rax,%r14,1),%esi
add    $0xfffffffd,%esi
lea    (%r12,%rsi,4),%rbp
add    $0x4,%rbp
mov    %r10,%rax
sub    %rsi,%rax
lea    (%rdi,%rax,4),%rax
cmp    %rbp,%rax
jb     141b <multi+0x2db>
mov    %edx,%r9d
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
xor    %esi,%esi
test   %rax,%rax
je     13e1 <multi+0x2a1>
lea    (%rcx,%r14,1),%eax
add    $0xfffffffd,%eax
lea    (%rdi,%rax,4),%rbp
add    $0xfffffffffffffff4,%rbp
test   %r13d,%r13d
cmovns %esi,%r13d
sub    %r13d,%ecx
lea    (%r14,%rcx,1),%ebx
add    $0xfffffffd,%ebx
add    $0x1,%rbx
and    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rbp),%xmm0
movdqu 0x0(%rbp),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%r12,%rsi,4)
movdqu %xmm0,0x10(%r12,%rsi,4)
movdqu -0x30(%rbp),%xmm0
movdqu -0x20(%rbp),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,0x20(%r12,%rsi,4)
movdqu %xmm0,0x30(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1390 <multi+0x250>
test   $0x1,%dl
je     140f <multi+0x2cf>
mov    %r10,%rax
sub    %rsi,%rax
movdqu -0x1c(%rdi,%rax,4),%xmm0
movdqu -0xc(%rdi,%rax,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%r12,%rsi,4)
movdqu %xmm0,0x10(%r12,%rsi,4)
cmp    %r8,%r9
je     17ed <multi+0x6ad>
sub    %r8,%r10
lea    0x1(%r10),%edx
lea    (%rdi,%r10,4),%rax
lea    (%r12,%r8,4),%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rax),%esi
mov    %esi,(%rcx)
add    $0xffffffff,%edx
add    $0xfffffffffffffffc,%rax
add    $0x4,%rcx
test   %edx,%edx
jg     1430 <multi+0x2f0>
jmp    17ed <multi+0x6ad>
lea    -0x1(%r14),%rax
mov    (%rsp),%r11d
mov    %eax,%esi
lea    (%rbx,%rsi,4),%rcx
mov    %rcx,0x40(%rsp)
and    $0x7,%eax
mov    %rsi,%rcx
sub    %rax,%rcx
mov    %rcx,0x30(%rsp)
lea    0x10(%r10),%rbp
lea    -0x1(%r14),%edi
mov    %rdi,%r9
mov    %rax,0x38(%rsp)
sub    %rax,%r9
lea    0x4(%r10),%rax
xor    %ecx,%ecx
mov    %rsi,(%rsp)
mov    %r10,0x28(%rsp)
mov    %r11,0x20(%rsp)
jmp    14b5 <multi+0x375>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
add    $0x4,%rbp
add    $0x4,%rax
cmp    %r11,%rcx
je     11f7 <multi+0xb7>
cmp    $0x1,%r14d
je     14a0 <multi+0x360>
cmp    $0x8,%esi
jae    14d0 <multi+0x390>
xor    %r8d,%r8d
jmp    15d0 <multi+0x490>
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rcx,1),%r8
lea    (%r10,%rcx,4),%rdx
lea    (%r10,%r8,4),%r8
lea    (%r12,%rcx,4),%r10
lea    (%r12,%rcx,4),%r11
add    $0x4,%r11
cmp    %r11,%rdx
setb   %r11b
cmp    %r8,%r10
setb   %sil
cmp    0x40(%rsp),%rdx
setb   %dl
cmp    %rbx,%r8
seta   %r10b
test   %sil,%r11b
jne    15c1 <multi+0x481>
mov    $0x0,%r8d
and    %r10b,%dl
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%r11
mov    (%rsp),%rsi
jne    15d0 <multi+0x490>
movd   (%r12,%rcx,4),%xmm0
pshufd $0x0,%xmm0,%xmm0
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,4),%xmm1
movdqu 0x10(%rbx,%rdx,4),%xmm2
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm0,%xmm4
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm4,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
movdqu -0x10(%rbp,%rdx,4),%xmm3
paddd  %xmm1,%xmm3
movdqu 0x0(%rbp,%rdx,4),%xmm1
paddd  %xmm2,%xmm1
movdqu %xmm3,-0x10(%rbp,%rdx,4)
movdqu %xmm1,0x0(%rbp,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1540 <multi+0x400>
mov    0x30(%rsp),%r8
cmpq   $0x0,0x38(%rsp)
jne    15d0 <multi+0x490>
jmp    14a0 <multi+0x360>
xor    %r8d,%r8d
mov    0x28(%rsp),%r10
mov    0x20(%rsp),%r11
xchg   %ax,%ax
mov    %r8d,%esi
not    %esi
add    %r14d,%esi
lea    0x1(%r8),%rdx
test   $0x1,%sil
je     15f5 <multi+0x4b5>
mov    (%rbx,%r8,4),%esi
imul   (%r12,%rcx,4),%esi
add    %rcx,%r8
add    %esi,(%r10,%r8,4)
mov    %rdx,%r8
mov    (%rsp),%rsi
cmp    %rdx,%rsi
je     14a0 <multi+0x360>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%r8,4),%edx
imul   (%r12,%rcx,4),%edx
add    %edx,-0x4(%rax,%r8,4)
mov    0x4(%rbx,%r8,4),%edx
imul   (%r12,%rcx,4),%edx
add    %edx,(%rax,%r8,4)
add    $0x2,%r8
cmp    %r8,%rdi
jne    1610 <multi+0x4d0>
jmp    14a0 <multi+0x360>
lea    (%rcx,%r14,1),%eax
add    $0xfffffffc,%eax
cltq
cmpl   $0x0,(%rdi,%rax,4)
mov    0x18(%rsp),%r12
je     17e5 <multi+0x6a5>
cmpl   $0x2,(%rsp)
jb     17ed <multi+0x6ad>
lea    (%rcx,%r14,1),%r10d
add    $0xfffffffc,%r10d
xor    %r8d,%r8d
test   %r15d,%r15d
mov    $0x0,%edx
cmovs  %r15d,%edx
neg    %edx
add    %ecx,%edx
add    $0xfffffffc,%edx
add    %r14,%rdx
cmp    $0x7,%edx
jb     17b7 <multi+0x677>
test   %r15d,%r15d
mov    $0x0,%esi
cmovs  %r15d,%esi
lea    (%rdi,%r10,4),%rax
add    $0x4,%rax
cmp    %rax,%r12
jae    16c5 <multi+0x585>
mov    %ecx,%eax
sub    %esi,%eax
lea    (%rax,%r14,1),%esi
add    $0xfffffffc,%esi
lea    (%r12,%rsi,4),%rbp
add    $0x4,%rbp
mov    %r10,%rax
sub    %rsi,%rax
lea    (%rdi,%rax,4),%rax
cmp    %rbp,%rax
jb     17b7 <multi+0x677>
mov    %edx,%r9d
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
xor    %esi,%esi
test   %rax,%rax
je     1781 <multi+0x641>
lea    (%rcx,%r14,1),%eax
add    $0xfffffffc,%eax
lea    (%rdi,%rax,4),%rbp
add    $0xfffffffffffffff4,%rbp
test   %r15d,%r15d
cmovns %esi,%r15d
sub    %r15d,%ecx
lea    (%r14,%rcx,1),%ebx
add    $0xfffffffc,%ebx
add    $0x1,%rbx
and    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rbp),%xmm0
movdqu 0x0(%rbp),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%r12,%rsi,4)
movdqu %xmm0,0x10(%r12,%rsi,4)
movdqu -0x30(%rbp),%xmm0
movdqu -0x20(%rbp),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,0x20(%r12,%rsi,4)
movdqu %xmm0,0x30(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1730 <multi+0x5f0>
test   $0x1,%dl
je     17af <multi+0x66f>
mov    %r10,%rax
sub    %rsi,%rax
movdqu -0x1c(%rdi,%rax,4),%xmm0
movdqu -0xc(%rdi,%rax,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%r12,%rsi,4)
movdqu %xmm0,0x10(%r12,%rsi,4)
cmp    %r8,%r9
je     17ed <multi+0x6ad>
sub    %r8,%r10
lea    0x1(%r10),%edx
lea    (%rdi,%r10,4),%rax
lea    (%r12,%r8,4),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax),%esi
mov    %esi,(%rcx)
add    $0xffffffff,%edx
add    $0xfffffffffffffffc,%rax
add    $0x4,%rcx
test   %edx,%edx
jg     17d0 <multi+0x690>
jmp    17ed <multi+0x6ad>
movl   $0x0,(%r12)
call   1030 <free@plt>
mov    %r12,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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