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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ result;
typedef int /*<<< orphan*/ b;
typedef int /*<<< orphan*/ a;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memset(unsigned int *, int /*<<< orphan*/, int);
int strlen(char *);
char *multi(char *number_a, char *number_b) {
  assert(number_a && number_b);
  int i, j, negtive = 0, nLen_a = strlen(number_a), nLen_b = strlen(number_b);
  if (number_a[0] == '-' || number_a[0] == '+') {
    if (number_a[0] == '-')
      negtive = !negtive;
    nLen_a--;
    number_a++;
  }
  if (number_b[0] == '-' || number_b[0] == '+') {
    if (number_b[0] == '-')
      negtive = !negtive;
    nLen_b--;
    number_b++;
  }
  for (i = 0; i < nLen_a; i++)
    if (number_a[i] != 0)
      break;
  if (i == nLen_a)
    return "0";
  for (i = 0; i < nLen_b; i++)
    if (number_b[i] != 0)
      break;
  if (i == nLen_b)
    return "0";
  char m[nLen_a + nLen_b + 1];
  unsigned a[10000];
  unsigned b[10000];
  unsigned result[10000 * 2];
  memset(a, 0, sizeof(a));
  memset(b, 0, sizeof(b));
  memset(result, 0, sizeof(result));
  for (j = 0, i = nLen_a - 1; i >= 0; i--)
    a[j++] = number_a[i] - '0';
  for (j = 0, i = nLen_b - 1; i >= 0; i--)
    b[j++] = number_b[i] - '0';
  for (i = 0; i < nLen_b; i++)
    for (j = 0; j < nLen_a; j++)
      result[i + j] += b[i] * a[j];
  j = nLen_a + nLen_b;
  m[j--] = '\0';
  for (i = 0; result[i] != 0; i++) {
    if (result[i] >= 10)
      result[i + 1] += result[i] / 10;
    m[j--] = (result[i] % 10) + '0';
  }
  char *r;
  if (negtive) {
    r = (char *)malloc(i + 2);
    memcpy(r + 1, m + (nLen_a + nLen_b - i), i + 1);
    r[0] = '-';
  } else {
    r = (char *)malloc(i + 1);
    memcpy(r, m + (nLen_a + nLen_b - i), i + 1);
  }
  return r;
}


x86 assembly (clang, -O0):
<multi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x27160,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x27149(%rbp)
je     1184 <multi+0x34>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x27149(%rbp)
mov    -0x27149(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
je     11d3 <multi+0x83>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    1209 <multi+0xb9>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    11f4 <multi+0xa4>
cmpl   $0x0,-0x24(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
je     1229 <multi+0xd9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2b,%eax
jne    125f <multi+0x10f>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    124a <multi+0xfa>
cmpl   $0x0,-0x24(%rbp)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    129f <multi+0x14f>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     128c <multi+0x13c>
jmp    129f <multi+0x14f>
jmp    1291 <multi+0x141>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1266 <multi+0x116>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    12bb <multi+0x16b>
lea    0xd4e(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    15e5 <multi+0x495>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12fb <multi+0x1ab>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     12e8 <multi+0x198>
jmp    12fb <multi+0x1ab>
jmp    12ed <multi+0x19d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12c2 <multi+0x172>
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    1317 <multi+0x1c7>
lea    0xcf2(%rip),%rax
mov    %rax,-0x8(%rbp)
jmp    15e5 <multi+0x495>
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
mov    %edx,%eax
lea    0x1(%rax,%rcx,1),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x27158(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
lea    -0x9c80(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x138c0(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x27140(%rbp),%rdi
xor    %esi,%esi
mov    $0x13880,%edx
call   1040 <memset@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     13cf <multi+0x27f>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
cltq
mov    %ecx,-0x9c80(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1394 <multi+0x244>
movl   $0x0,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     141a <multi+0x2ca>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x20(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
cltq
mov    %ecx,-0x138c0(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    13df <multi+0x28f>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    148e <multi+0x33e>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    147b <multi+0x32b>
movslq -0x1c(%rbp),%rax
mov    -0x138c0(%rbp,%rax,4),%ecx
movslq -0x20(%rbp),%rax
imul   -0x9c80(%rbp,%rax,4),%ecx
ff
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cltq
add    -0x27140(%rbp,%rax,4),%ecx
mov    %ecx,-0x27140(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1434 <multi+0x2e4>
jmp    1480 <multi+0x330>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1421 <multi+0x2d1>
mov    -0x27158(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmpl   $0x0,-0x27140(%rbp,%rax,4)
je     1544 <multi+0x3f4>
movslq -0x1c(%rbp),%rax
cmpl   $0xa,-0x27140(%rbp,%rax,4)
0a
jb     1507 <multi+0x3b7>
movslq -0x1c(%rbp),%rax
mov    -0x27140(%rbp,%rax,4),%eax
mov    $0xa,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cltq
add    -0x27140(%rbp,%rax,4),%ecx
mov    %ecx,-0x27140(%rbp,%rax,4)
movslq -0x1c(%rbp),%rax
mov    -0x27140(%rbp,%rax,4),%eax
mov    $0xa,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x27158(%rbp),%rax
add    $0x30,%edx
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    14b7 <multi+0x367>
cmpl   $0x0,-0x24(%rbp)
je     159a <multi+0x44a>
mov    -0x1c(%rbp),%edi
add    $0x2,%edi
call   1070 <malloc@plt>
mov    -0x27158(%rbp),%rsi
mov    %rax,-0x27148(%rbp)
mov    -0x27148(%rbp),%rdi
add    $0x1,%rdi
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
sub    -0x1c(%rbp),%eax
cltq
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
call   1060 <memcpy@plt>
mov    -0x27148(%rbp),%rax
movb   $0x2d,(%rax)
jmp    15d3 <multi+0x483>
mov    -0x1c(%rbp),%edi
add    $0x1,%edi
call   1070 <malloc@plt>
mov    -0x27158(%rbp),%rsi
mov    %rax,-0x27148(%rbp)
mov    -0x27148(%rbp),%rdi
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
sub    -0x1c(%rbp),%eax
cltq
add    %rax,%rsi
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
call   1060 <memcpy@plt>
mov    -0x27148(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    -0x8(%rbp),%rax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multi>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x27128,%rsp
mov    %rsi,%r12
mov    %rdi,%r14
test   %rdi,%rdi
setne  %al
test   %rsi,%rsi
setne  %cl
and    %al,%cl
movzbl %cl,%edi
call   1050 <assert@plt>
mov    %r14,%rdi
call   1030 <strlen@plt>
mov    %eax,%r15d
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    (%r14),%cl
cmp    $0x2d,%cl
je     11a0 <multi+0x50>
cmp    $0x2b,%cl
jne    11b2 <multi+0x62>
xor    %edx,%edx
cmp    $0x2d,%cl
sete   %dl
add    $0xffffffff,%r15d
add    $0x1,%r14
jmp    11b4 <multi+0x64>
xor    %edx,%edx
mov    (%r12),%bl
cmp    $0x2d,%bl
je     11c2 <multi+0x72>
cmp    $0x2b,%bl
jne    11d3 <multi+0x83>
xor    %ecx,%ecx
cmp    $0x2d,%bl
sete   %cl
xor    %ecx,%edx
add    $0xffffffff,%eax
add    $0x1,%r12
test   %r15d,%r15d
jle    1205 <multi+0xb5>
mov    %r15d,%ecx
xor    %esi,%esi
lea    0xe2c(%rip),%r13
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpb   $0x0,(%r14,%rsi,1)
jne    1207 <multi+0xb7>
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    11f0 <multi+0xa0>
jmp    1887 <multi+0x737>
xor    %esi,%esi
lea    0xe02(%rip),%r13
cmp    %r15d,%esi
je     1887 <multi+0x737>
test   %eax,%eax
jle    1235 <multi+0xe5>
mov    %eax,%ecx
xor    %esi,%esi
nop
cmpb   $0x0,(%r12,%rsi,1)
jne    1237 <multi+0xe7>
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1220 <multi+0xd0>
jmp    1887 <multi+0x737>
xor    %esi,%esi
cmp    %eax,%esi
je     1887 <multi+0x737>
mov    %edx,-0x2c(%rbp)
mov    %rsp,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
add    %r15d,%eax
add    $0x1,%eax
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
lea    -0x9c90(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x138d0(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x27150(%rbp),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x13880,%edx
call   1040 <memset@plt>
mov    %r15d,%r13d
test   %r15d,%r15d
jle    1400 <multi+0x2b0>
cmp    $0x8,%r15d
jae    133d <multi+0x1ed>
xor    %r9d,%r9d
mov    %r13,%r8
mov    %r9,%rax
not    %rax
test   $0x1,%r13b
je     12e4 <multi+0x194>
add    $0xffffffffffffffff,%r8
mov    %r8d,%edx
movsbl (%r14,%rdx,1),%edx
add    $0xffffffd0,%edx
mov    %edx,-0x9c90(%rbp,%r9,4)
ff
or     $0x1,%r9
add    %r13,%rax
je     1400 <multi+0x2b0>
lea    -0x9c8c(,%r9,4),%rax
ff
add    %rbp,%rax
sub    %r13,%r9
lea    -0x2(%r8),%rsi
mov    $0xffffffff,%edi
add    %r8,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
lea    (%rdi,%rdx,1),%ecx
movsbl (%r14,%rcx,1),%ecx
add    $0xffffffd0,%ecx
mov    %ecx,-0x4(%rax)
lea    (%rsi,%rdx,1),%ecx
movsbl (%r14,%rcx,1),%ecx
add    $0xffffffd0,%ecx
mov    %ecx,(%rax)
add    $0xfffffffffffffffe,%rdx
add    $0x8,%rax
cmp    %rdx,%r9
jne    1310 <multi+0x1c0>
jmp    1400 <multi+0x2b0>
lea    -0x1(%r13),%rax
lea    -0x1(%r15),%edx
xor    %r9d,%r9d
cmp    %eax,%edx
jb     12ba <multi+0x16a>
mov    %rax,%rdx
shr    $0x20,%rdx
mov    %r13,%r8
jne    12bd <multi+0x16d>
mov    %r13d,%r9d
and    $0xfffffff8,%r9d
mov    %r13d,%r8d
and    $0x7,%r8d
lea    0x0(,%r13,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
movdqa 0xc7c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%edx
movd   -0x3(%r14,%rdx,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x7(%r14,%rdx,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xac,%xmm1,%xmm1
pshufhw $0x24,%xmm1,%xmm1
psrad  $0x18,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xac,%xmm2,%xmm2
pshufhw $0x24,%xmm2,%xmm2
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqa %xmm1,-0x9c90(%rbp,%rdi,1)
ff ff
movdqa %xmm2,-0x9c80(%rbp,%rdi,1)
ff ff
add    $0xfffffffffffffff8,%rax
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1390 <multi+0x240>
cmp    %r13,%r9
jne    12bd <multi+0x16d>
mov    -0x40(%rbp),%r10
lea    (%r10,%r15,1),%eax
mov    %eax,-0x30(%rbp)
test   %r10d,%r10d
jle    1799 <multi+0x649>
mov    %r10d,%r11d
cmp    $0x8,%r10d
jae    14ad <multi+0x35d>
xor    %r9d,%r9d
mov    %r11,%r8
mov    %r9,%rax
not    %rax
test   $0x1,%r11b
je     144e <multi+0x2fe>
add    $0xffffffffffffffff,%r8
mov    %r8d,%ecx
movsbl (%r12,%rcx,1),%ecx
add    $0xffffffd0,%ecx
mov    %ecx,-0x138d0(%rbp,%r9,4)
ff
or     $0x1,%r9
add    %r11,%rax
je     1570 <multi+0x420>
lea    -0x138cc(,%r9,4),%rax
ff
add    %rbp,%rax
sub    %r11,%r9
lea    -0x2(%r8),%rsi
mov    $0xffffffff,%edi
add    %r8,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%rcx,1),%edx
movsbl (%r12,%rdx,1),%edx
add    $0xffffffd0,%edx
mov    %edx,-0x4(%rax)
lea    (%rsi,%rcx,1),%edx
movsbl (%r12,%rdx,1),%edx
add    $0xffffffd0,%edx
mov    %edx,(%rax)
add    $0xfffffffffffffffe,%rcx
add    $0x8,%rax
cmp    %rcx,%r9
jne    1480 <multi+0x330>
jmp    1570 <multi+0x420>
lea    -0x1(%r11),%rax
lea    -0x1(%r10),%ecx
xor    %r9d,%r9d
cmp    %eax,%ecx
jb     1424 <multi+0x2d4>
mov    %rax,%rcx
shr    $0x20,%rcx
mov    %r11,%r8
jne    1427 <multi+0x2d7>
mov    %r11d,%r9d
and    $0xfffffff8,%r9d
mov    %r11d,%r8d
and    $0x7,%r8d
lea    0x0(,%r11,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
movdqa 0xb0c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %eax,%ecx
movd   -0x3(%r12,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x7(%r12,%rcx,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xac,%xmm1,%xmm1
pshufhw $0x24,%xmm1,%xmm1
psrad  $0x18,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xac,%xmm2,%xmm2
pshufhw $0x24,%xmm2,%xmm2
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqa %xmm1,-0x138d0(%rbp,%rdi,1)
fe ff
movdqa %xmm2,-0x138c0(%rbp,%rdi,1)
fe ff
add    $0xfffffffffffffff8,%rax
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1500 <multi+0x3b0>
cmp    %r11,%r9
jne    1427 <multi+0x2d7>
test   %r10d,%r10d
jle    1799 <multi+0x649>
mov    %r13d,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
lea    -0x27120(%rbp),%rsi
xor    %edi,%edi
jmp    15c5 <multi+0x475>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x4,%rsi
add    $0x4,%rbx
cmp    %r11,%rdi
je     1799 <multi+0x649>
test   %r15d,%r15d
jle    15b0 <multi+0x460>
mov    -0x138d0(%rbp,%rdi,4),%ecx
cmp    $0x8,%r15d
jae    15e0 <multi+0x490>
xor    %eax,%eax
jmp    1770 <multi+0x620>
xchg   %ax,%ax
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm1
pshufd $0xf5,%xmm1,%xmm0
test   %r9,%r9
je     178b <multi+0x63b>
mov    %r8,%rax
xor    %edx,%edx
nopl   0x0(%rax)
movdqa -0x9c90(%rbp,%rdx,4),%xmm2
ff ff
movdqa -0x9c80(%rbp,%rdx,4),%xmm3
ff ff
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm2
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm3
movdqu -0x30(%rsi,%rdx,4),%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rsi,%rdx,4),%xmm2
paddd  %xmm3,%xmm2
movdqu -0x10(%rsi,%rdx,4),%xmm3
movdqu (%rsi,%rdx,4),%xmm5
movdqu %xmm4,-0x30(%rsi,%rdx,4)
movdqu %xmm2,-0x20(%rsi,%rdx,4)
movdqa -0x9c70(%rbp,%rdx,4),%xmm2
ff ff
movdqa -0x9c60(%rbp,%rdx,4),%xmm4
ff ff
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm0,%xmm6
pshufd $0xe8,%xmm6,%xmm6
punpckldq %xmm6,%xmm2
paddd  %xmm3,%xmm2
pshufd $0xf5,%xmm4,%xmm3
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm4
paddd  %xmm5,%xmm4
movdqu %xmm2,-0x10(%rsi,%rdx,4)
movdqu %xmm4,(%rsi,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rax
jne    1600 <multi+0x4b0>
test   $0x1,%r10b
je     1759 <multi+0x609>
movdqa -0x9c90(%rbp,%rdx,4),%xmm2
ff ff
movdqa -0x9c80(%rbp,%rdx,4),%xmm3
ff ff
pshufd $0xf5,%xmm2,%xmm4
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm2
pmuludq %xmm3,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshufd $0xf5,%xmm3,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xe8,%xmm3,%xmm0
punpckldq %xmm0,%xmm1
add    %rdi,%rdx
movdqu -0x27150(%rbp,%rdx,4),%xmm0
fd ff
paddd  %xmm2,%xmm0
movdqu -0x27140(%rbp,%rdx,4),%xmm2
fd ff
paddd  %xmm1,%xmm2
movdqu %xmm0,-0x27150(%rbp,%rdx,4)
fd ff
movdqu %xmm2,-0x27140(%rbp,%rdx,4)
fd ff
mov    %r14,%rax
cmp    %r13,%r14
je     15b0 <multi+0x460>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x9c90(%rbp,%rax,4),%edx
imul   %ecx,%edx
add    %edx,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r13
jne    1770 <multi+0x620>
jmp    15b0 <multi+0x460>
xor    %edx,%edx
test   $0x1,%r10b
jne    16e2 <multi+0x592>
jmp    1759 <multi+0x609>
mov    -0x30(%rbp),%r12d
movslq %r12d,%rax
mov    -0x48(%rbp),%r15
movb   $0x0,(%r15,%rax,1)
mov    -0x27150(%rbp),%edx
test   %edx,%edx
je     1825 <multi+0x6d5>
add    %r15,%rax
add    $0xffffffffffffffff,%rax
xor    %ebx,%ebx
mov    $0xcccccccd,%ecx
jmp    1813 <multi+0x6c3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edx,%esi
imul   %rcx,%rsi
shr    $0x23,%rsi
add    -0x2714c(%rbp,%rbx,4),%esi
mov    %esi,-0x2714c(%rbp,%rbx,4)
mov    -0x27150(%rbp,%rbx,4),%edx
add    $0x1,%rbx
mov    %edx,%edi
imul   %rcx,%rdi
shr    $0x23,%rdi
add    %edi,%edi
lea    (%rdi,%rdi,4),%edi
sub    %edi,%edx
or     $0x30,%dl
mov    %dl,(%rax)
add    $0xffffffffffffffff,%rax
mov    %esi,%edx
test   %esi,%esi
je     1827 <multi+0x6d7>
cmp    $0x9,%edx
ja     17d0 <multi+0x680>
mov    -0x2714c(%rbp,%rbx,4),%esi
add    $0x1,%rbx
jmp    17f3 <multi+0x6a3>
xor    %ebx,%ebx
mov    -0x2c(%rbp),%eax
test   %eax,%eax
je     185a <multi+0x70a>
lea    0x2(%rbx),%edi
call   1070 <malloc@plt>
mov    %rax,%r13
lea    0x1(%rax),%rdi
sub    %ebx,%r12d
movslq %r12d,%rax
add    %rax,%r15
add    $0x1,%ebx
mov    %r15,%rsi
mov    %ebx,%edx
call   1060 <memcpy@plt>
movb   $0x2d,0x0(%r13)
jmp    1880 <multi+0x730>
lea    0x1(%rbx),%r14d
mov    %r14d,%edi
call   1070 <malloc@plt>
mov    %rax,%r13
sub    %ebx,%r12d
movslq %r12d,%rax
add    %rax,%r15
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
call   1060 <memcpy@plt>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %r13,%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] c"0\00"
define i8* @multi(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
%12 = alloca i64
%13 = alloca [10000 x i32]
%14 = alloca [10000 x i32]
%15 = alloca [20000 x i32]
%16 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
%17 = load i8*, i8** %4
%18 = icmp ne i8* %17, null
br i1 %18, label %19, label %22
19: ; preds = %2
%20 = load i8*, i8** %5
%21 = icmp ne i8* %20, null
br label %22
22: ; preds = %19, %2
%23 = phi i1 [ false, %2 ], [ %21, %19 ]
%24 = zext i1 %23 to i32
%25 = call i32 @assert(i32 %24)
store i32 0, i32* %8
%26 = load i8*, i8** %4
%27 = call i32 @strlen(i8* %26)
store i32 %27, i32* %9
%28 = load i8*, i8** %5
%29 = call i32 @strlen(i8* %28)
store i32 %29, i32* %10
%30 = load i8*, i8** %4
%31 = getelementptr inbounds i8, i8* %30, i64 0
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = icmp eq i32 %33, 45
br i1 %34, label %41, label %35
35: ; preds = %22
%36 = load i8*, i8** %4
%37 = getelementptr inbounds i8, i8* %36, i64 0
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = icmp eq i32 %39, 43
br i1 %40, label %41, label %57
41: ; preds = %35, %22
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i64 0
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp eq i32 %45, 45
br i1 %46, label %47, label %52
47: ; preds = %41
%48 = load i32, i32* %8
%49 = icmp ne i32 %48, 0
%50 = xor i1 %49, true
%51 = zext i1 %50 to i32
store i32 %51, i32* %8
br label %52
52: ; preds = %47, %41
%53 = load i32, i32* %9
%54 = add nsw i32 %53, -1
store i32 %54, i32* %9
%55 = load i8*, i8** %4
%56 = getelementptr inbounds i8, i8* %55, i32 1
store i8* %56, i8** %4
br label %57
57: ; preds = %52, %35
%58 = load i8*, i8** %5
%59 = getelementptr inbounds i8, i8* %58, i64 0
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp eq i32 %61, 45
br i1 %62, label %69, label %63
63: ; preds = %57
%64 = load i8*, i8** %5
%65 = getelementptr inbounds i8, i8* %64, i64 0
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = icmp eq i32 %67, 43
br i1 %68, label %69, label %85
69: ; preds = %63, %57
%70 = load i8*, i8** %5
%71 = getelementptr inbounds i8, i8* %70, i64 0
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = icmp eq i32 %73, 45
br i1 %74, label %75, label %80
75: ; preds = %69
%76 = load i32, i32* %8
%77 = icmp ne i32 %76, 0
%78 = xor i1 %77, true
%79 = zext i1 %78 to i32
store i32 %79, i32* %8
br label %80
80: ; preds = %75, %69
%81 = load i32, i32* %10
%82 = add nsw i32 %81, -1
store i32 %82, i32* %10
%83 = load i8*, i8** %5
%84 = getelementptr inbounds i8, i8* %83, i32 1
store i8* %84, i8** %5
br label %85
85: ; preds = %80, %63
store i32 0, i32* %6
br label %86
86: ; preds = %100, %85
%87 = load i32, i32* %6
%88 = load i32, i32* %9
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %103
90: ; preds = %86
%91 = load i8*, i8** %4
%92 = load i32, i32* %6
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp ne i32 %96, 0
br i1 %97, label %98, label %99
98: ; preds = %90
br label %103
99: ; preds = %90
br label %100
100: ; preds = %99
%101 = load i32, i32* %6
%102 = add nsw i32 %101, 1
store i32 %102, i32* %6
br label %86
103: ; preds = %98, %86
%104 = load i32, i32* %6
%105 = load i32, i32* %9
%106 = icmp eq i32 %104, %105
br i1 %106, label %107, label %108
107: ; preds = %103
store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8** %3
br label %308
108: ; preds = %103
store i32 0, i32* %6
br label %109
109: ; preds = %123, %108
%110 = load i32, i32* %6
%111 = load i32, i32* %10
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %126
113: ; preds = %109
%114 = load i8*, i8** %5
%115 = load i32, i32* %6
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %114, i64 %116
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = icmp ne i32 %119, 0
br i1 %120, label %121, label %122
121: ; preds = %113
br label %126
122: ; preds = %113
br label %123
123: ; preds = %122
%124 = load i32, i32* %6
%125 = add nsw i32 %124, 1
store i32 %125, i32* %6
br label %109
126: ; preds = %121, %109
%127 = load i32, i32* %6
%128 = load i32, i32* %10
%129 = icmp eq i32 %127, %128
br i1 %129, label %130, label %131
130: ; preds = %126
store i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8** %3
br label %308
131: ; preds = %126
%132 = load i32, i32* %9
%133 = load i32, i32* %10
%134 = add nsw i32 %132, %133
%135 = add nsw i32 %134, 1
%136 = zext i32 %135 to i64
%137 = call i8* @llvm.stacksave()
store i8* %137, i8** %11
%138 = alloca i8, i64 %136
store i64 %136, i64* %12
%139 = getelementptr inbounds [10000 x i32], [10000 x i32]* %13, i64 0, i64 0
%140 = call i32 @memset(i32* %139, i32 0, i32 40000)
%141 = getelementptr inbounds [10000 x i32], [10000 x i32]* %14, i64 0, i64 0
%142 = call i32 @memset(i32* %141, i32 0, i32 40000)
%143 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 0
%144 = call i32 @memset(i32* %143, i32 0, i32 80000)
store i32 0, i32* %7
%145 = load i32, i32* %9
%146 = sub nsw i32 %145, 1
store i32 %146, i32* %6
br label %147
147: ; preds = %162, %131
%148 = load i32, i32* %6
%149 = icmp sge i32 %148, 0
br i1 %149, label %150, label %165
150: ; preds = %147
%151 = load i8*, i8** %4
%152 = load i32, i32* %6
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %151, i64 %153
%155 = load i8, i8* %154
%156 = sext i8 %155 to i32
%157 = sub nsw i32 %156, 48
%158 = load i32, i32* %7
%159 = add nsw i32 %158, 1
store i32 %159, i32* %7
%160 = sext i32 %158 to i64
%161 = getelementptr inbounds [10000 x i32], [10000 x i32]* %13, i64 0, i64 %160
store i32 %157, i32* %161
br label %162
162: ; preds = %150
%163 = load i32, i32* %6
%164 = add nsw i32 %163, -1
store i32 %164, i32* %6
br label %147
165: ; preds = %147
store i32 0, i32* %7
%166 = load i32, i32* %10
%167 = sub nsw i32 %166, 1
store i32 %167, i32* %6
br label %168
168: ; preds = %183, %165
%169 = load i32, i32* %6
%170 = icmp sge i32 %169, 0
br i1 %170, label %171, label %186
171: ; preds = %168
%172 = load i8*, i8** %5
%173 = load i32, i32* %6
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %172, i64 %174
%176 = load i8, i8* %175
%177 = sext i8 %176 to i32
%178 = sub nsw i32 %177, 48
%179 = load i32, i32* %7
%180 = add nsw i32 %179, 1
store i32 %180, i32* %7
%181 = sext i32 %179 to i64
%182 = getelementptr inbounds [10000 x i32], [10000 x i32]* %14, i64 0, i64 %181
store i32 %178, i32* %182
br label %183
183: ; preds = %171
%184 = load i32, i32* %6
%185 = add nsw i32 %184, -1
store i32 %185, i32* %6
br label %168
186: ; preds = %168
store i32 0, i32* %6
br label %187
187: ; preds = %217, %186
%188 = load i32, i32* %6
%189 = load i32, i32* %10
%190 = icmp slt i32 %188, %189
br i1 %190, label %191, label %220
191: ; preds = %187
store i32 0, i32* %7
br label %192
192: ; preds = %213, %191
%193 = load i32, i32* %7
%194 = load i32, i32* %9
%195 = icmp slt i32 %193, %194
br i1 %195, label %196, label %216
196: ; preds = %192
%197 = load i32, i32* %6
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [10000 x i32], [10000 x i32]* %14, i64 0, i64 %198
%200 = load i32, i32* %199
%201 = load i32, i32* %7
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [10000 x i32], [10000 x i32]* %13, i64 0, i64 %202
%204 = load i32, i32* %203
%205 = mul i32 %200, %204
%206 = load i32, i32* %6
%207 = load i32, i32* %7
%208 = add nsw i32 %206, %207
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %209
%211 = load i32, i32* %210
%212 = add i32 %211, %205
store i32 %212, i32* %210
br label %213
213: ; preds = %196
%214 = load i32, i32* %7
%215 = add nsw i32 %214, 1
store i32 %215, i32* %7
br label %192
216: ; preds = %192
br label %217
217: ; preds = %216
%218 = load i32, i32* %6
%219 = add nsw i32 %218, 1
store i32 %219, i32* %6
br label %187
220: ; preds = %187
%221 = load i32, i32* %9
%222 = load i32, i32* %10
%223 = add nsw i32 %221, %222
store i32 %223, i32* %7
%224 = load i32, i32* %7
%225 = add nsw i32 %224, -1
store i32 %225, i32* %7
%226 = sext i32 %224 to i64
%227 = getelementptr inbounds i8, i8* %138, i64 %226
store i8 0, i8* %227
store i32 0, i32* %6
br label %228
228: ; preds = %264, %220
%229 = load i32, i32* %6
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %230
%232 = load i32, i32* %231
%233 = icmp ne i32 %232, 0
br i1 %233, label %234, label %267
234: ; preds = %228
%235 = load i32, i32* %6
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %236
%238 = load i32, i32* %237
%239 = icmp uge i32 %238, 10
br i1 %239, label %240, label %252
240: ; preds = %234
%241 = load i32, i32* %6
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %242
%244 = load i32, i32* %243
%245 = udiv i32 %244, 10
%246 = load i32, i32* %6
%247 = add nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %248
%250 = load i32, i32* %249
%251 = add i32 %250, %245
store i32 %251, i32* %249
br label %252
252: ; preds = %240, %234
%253 = load i32, i32* %6
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds [20000 x i32], [20000 x i32]* %15, i64 0, i64 %254
%256 = load i32, i32* %255
%257 = urem i32 %256, 10
%258 = add i32 %257, 48
%259 = trunc i32 %258 to i8
%260 = load i32, i32* %7
%261 = add nsw i32 %260, -1
store i32 %261, i32* %7
%262 = sext i32 %260 to i64
%263 = getelementptr inbounds i8, i8* %138, i64 %262
store i8 %259, i8* %263
br label %264
264: ; preds = %252
%265 = load i32, i32* %6
%266 = add nsw i32 %265, 1
store i32 %266, i32* %6
br label %228
267: ; preds = %228
%268 = load i32, i32* %8
%269 = icmp ne i32 %268, 0
br i1 %269, label %270, label %289
270: ; preds = %267
%271 = load i32, i32* %6
%272 = add nsw i32 %271, 2
%273 = call i64 @malloc(i32 %272)
%274 = inttoptr i64 %273 to i8*
store i8* %274, i8** %16
%275 = load i8*, i8** %16
%276 = getelementptr inbounds i8, i8* %275, i64 1
%277 = load i32, i32* %9
%278 = load i32, i32* %10
%279 = add nsw i32 %277, %278
%280 = load i32, i32* %6
%281 = sub nsw i32 %279, %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8, i8* %138, i64 %282
%284 = load i32, i32* %6
%285 = add nsw i32 %284, 1
%286 = call i32 @memcpy(i8* %276, i8* %283, i32 %285)
%287 = load i8*, i8** %16
%288 = getelementptr inbounds i8, i8* %287, i64 0
store i8 45, i8* %288
br label %305
289: ; preds = %267
%290 = load i32, i32* %6
%291 = add nsw i32 %290, 1
%292 = call i64 @malloc(i32 %291)
%293 = inttoptr i64 %292 to i8*
store i8* %293, i8** %16
%294 = load i8*, i8** %16
%295 = load i32, i32* %9
%296 = load i32, i32* %10
%297 = add nsw i32 %295, %296
%298 = load i32, i32* %6
%299 = sub nsw i32 %297, %298
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i8, i8* %138, i64 %300
%302 = load i32, i32* %6
%303 = add nsw i32 %302, 1
%304 = call i32 @memcpy(i8* %294, i8* %301, i32 %303)
br label %305
305: ; preds = %289, %270
%306 = load i8*, i8** %16
store i8* %306, i8** %3
%307 = load i8*, i8** %11
br label %308
308: ; preds = %305, %130, %107
%309 = load i8*, i8** %3
ret i8* %309
}

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