#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 strlen(char *);
char *multiply(char a[], char b[]) {
  static char mul[10000];
  char c[10000];
  char temp[10000];
  int la, lb;
  int i, j, k = 0, x = 0, y;
  long int r = 0;
  long sum = 0;
  la = strlen(a) - 1;
  lb = strlen(b) - 1;
  for (i = 0; i <= la; i++) {
    a[i] = a[i] - 48;
  }
  for (i = 0; i <= lb; i++) {
    b[i] = b[i] - 48;
  }
  for (i = lb; i >= 0; i--) {
    r = 0;
    for (j = la; j >= 0; j--) {
      temp[k++] = (b[i] * a[j] + r) % 10;
      r = (b[i] * a[j] + r) / 10;
    }
    temp[k++] = r;
    x++;
    for (y = 0; y < x; y++) {
      temp[k++] = 0;
    }
  }
  k = 0;
  r = 0;
  for (i = 0; i < la + lb + 2; i++) {
    sum = 0;
    y = 0;
    for (j = 1; j <= lb + 1; j++) {
      if (i <= la + j) {
        sum = sum + temp[y + i];
      }
      y += j + la + 1;
    }
    c[k++] = (sum + r) % 10;
    r = (sum + r) / 10;
  }
  c[k] = r;
  j = 0;
  for (i = k - 1; i >= 0; i--) {
    mul[j++] = c[i] + 48;
  }
  mul[j] = '\0';
  return mul;
}


x86 assembly (clang, -O0):
<multiply>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x4e44(%rbp)
movl   $0x0,-0x4e48(%rbp)
movq   $0x0,-0x4e58(%rbp)
movq   $0x0,-0x4e60(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
sub    $0x1,%eax
mov    %eax,-0x4e34(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
sub    $0x1,%eax
mov    %eax,-0x4e38(%rbp)
movl   $0x0,-0x4e3c(%rbp)
mov    -0x4e3c(%rbp),%eax
cmp    -0x4e34(%rbp),%eax
jg     11c3 <multiply+0xb3>
mov    -0x8(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x4e3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e3c(%rbp)
jmp    117b <multiply+0x6b>
movl   $0x0,-0x4e3c(%rbp)
mov    -0x4e3c(%rbp),%eax
cmp    -0x4e38(%rbp),%eax
jg     1215 <multiply+0x105>
mov    -0x10(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x4e3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e3c(%rbp)
jmp    11cd <multiply+0xbd>
mov    -0x4e38(%rbp),%eax
mov    %eax,-0x4e3c(%rbp)
cmpl   $0x0,-0x4e3c(%rbp)
jl     1387 <multiply+0x277>
movq   $0x0,-0x4e58(%rbp)
mov    -0x4e34(%rbp),%eax
mov    %eax,-0x4e40(%rbp)
cmpl   $0x0,-0x4e40(%rbp)
jl     12f1 <multiply+0x1e1>
mov    -0x10(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x4e40(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
cltq
add    -0x4e58(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %dl,%cl
mov    -0x4e44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x4e44(%rbp)
cltq
mov    %cl,-0x4e30(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
movslq -0x4e3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x4e40(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
cltq
add    -0x4e58(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x4e58(%rbp)
mov    -0x4e40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4e40(%rbp)
jmp    1245 <multiply+0x135>
mov    -0x4e58(%rbp),%rax
mov    %al,%cl
mov    -0x4e44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x4e44(%rbp)
cltq
mov    %cl,-0x4e30(%rbp,%rax,1)
mov    -0x4e48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e48(%rbp)
movl   $0x0,-0x4e4c(%rbp)
mov    -0x4e4c(%rbp),%eax
cmp    -0x4e48(%rbp),%eax
jge    136e <multiply+0x25e>
mov    -0x4e44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x4e44(%rbp)
cltq
movb   $0x0,-0x4e30(%rbp,%rax,1)
mov    -0x4e4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e4c(%rbp)
jmp    132d <multiply+0x21d>
jmp    1373 <multiply+0x263>
mov    -0x4e3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4e3c(%rbp)
jmp    1221 <multiply+0x111>
movl   $0x0,-0x4e44(%rbp)
movq   $0x0,-0x4e58(%rbp)
movl   $0x0,-0x4e3c(%rbp)
mov    -0x4e3c(%rbp),%eax
mov    -0x4e34(%rbp),%ecx
add    -0x4e38(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    14d2 <multiply+0x3c2>
movq   $0x0,-0x4e60(%rbp)
movl   $0x0,-0x4e4c(%rbp)
movl   $0x1,-0x4e40(%rbp)
mov    -0x4e40(%rbp),%eax
mov    -0x4e38(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     146b <multiply+0x35b>
mov    -0x4e3c(%rbp),%eax
mov    -0x4e34(%rbp),%ecx
add    -0x4e40(%rbp),%ecx
cmp    %ecx,%eax
jg     143c <multiply+0x32c>
mov    -0x4e60(%rbp),%rax
mov    -0x4e4c(%rbp),%ecx
add    -0x4e3c(%rbp),%ecx
movslq %ecx,%rcx
movsbq -0x4e30(%rbp,%rcx,1),%rcx
ff ff
add    %rcx,%rax
mov    %rax,-0x4e60(%rbp)
mov    -0x4e40(%rbp),%eax
add    -0x4e34(%rbp),%eax
add    $0x1,%eax
add    -0x4e4c(%rbp),%eax
mov    %eax,-0x4e4c(%rbp)
mov    -0x4e40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e40(%rbp)
jmp    13e2 <multiply+0x2d2>
mov    -0x4e60(%rbp),%rax
add    -0x4e58(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %dl,%cl
mov    -0x4e44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x4e44(%rbp)
cltq
mov    %cl,-0x2720(%rbp,%rax,1)
mov    -0x4e60(%rbp),%rax
add    -0x4e58(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x4e58(%rbp)
mov    -0x4e3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e3c(%rbp)
jmp    13a6 <multiply+0x296>
mov    -0x4e58(%rbp),%rax
mov    %al,%cl
movslq -0x4e44(%rbp),%rax
mov    %cl,-0x2720(%rbp,%rax,1)
movl   $0x0,-0x4e40(%rbp)
mov    -0x4e44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4e3c(%rbp)
cmpl   $0x0,-0x4e3c(%rbp)
jl     1555 <multiply+0x445>
movslq -0x4e3c(%rbp),%rax
movsbl -0x2720(%rbp,%rax,1),%eax
ff
add    $0x30,%eax
mov    %al,%dl
mov    -0x4e40(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x4e40(%rbp)
movslq %eax,%rcx
lea    0x2b02(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x4e3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4e3c(%rbp)
jmp    1502 <multiply+0x3f2>
movslq -0x4e40(%rbp),%rcx
lea    0x2add(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2ad2(%rip),%rax
add    $0x4e60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e68,%rsp
mov    %rsi,%r15
mov    %rdi,%r14
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %r15,%rdi
call   1030 <strlen@plt>
mov    %rbx,%r11
mov    %eax,%r10d
test   %r11d,%r11d
jle    126e <multiply+0x14e>
mov    %r11d,%eax
cmp    $0x8,%r11d
jae    1165 <multiply+0x45>
xor    %ecx,%ecx
jmp    1260 <multiply+0x140>
cmp    $0x20,%r11d
jae    1172 <multiply+0x52>
xor    %ecx,%ecx
jmp    1229 <multiply+0x109>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1758 <multiply+0x638>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xe60(%rip),%xmm0
movdqu (%r14,%rdx,1),%xmm1
movdqu 0x10(%r14,%rdx,1),%xmm2
movdqu 0x20(%r14,%rdx,1),%xmm3
movdqu 0x30(%r14,%rdx,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%r14,%rdx,1)
movdqu %xmm2,0x10(%r14,%rdx,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%r14,%rdx,1)
movdqu %xmm4,0x30(%r14,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rdi
jne    11a0 <multiply+0x80>
test   $0x1,%sil
je     1220 <multiply+0x100>
movdqu (%r14,%rdx,1),%xmm0
movdqu 0x10(%r14,%rdx,1),%xmm1
movdqa 0xdf5(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,(%r14,%rdx,1)
movdqu %xmm1,0x10(%r14,%rdx,1)
cmp    %rax,%rcx
je     126e <multiply+0x14e>
test   $0x18,%al
je     1260 <multiply+0x140>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movdqa 0xdd7(%rip),%xmm0
nopl   0x0(%rax)
movq   (%r14,%rdx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%r14,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1240 <multiply+0x120>
cmp    %rax,%rcx
je     126e <multiply+0x14e>
xchg   %ax,%ax
addb   $0xd0,(%r14,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1260 <multiply+0x140>
mov    %r15,0x8(%rsp)
lea    -0x1(%r11),%eax
mov    %eax,0x14(%rsp)
movabs $0x6666666666666667,%r12
66 66 66
test   %r10d,%r10d
mov    %r10,0x38(%rsp)
jle    148e <multiply+0x36e>
mov    %r10d,%edx
cmp    $0x8,%r10d
jae    12a8 <multiply+0x188>
xor    %eax,%eax
mov    0x8(%rsp),%rdi
jmp    13a0 <multiply+0x280>
cmp    $0x20,%r10d
jae    12ba <multiply+0x19a>
xor    %eax,%eax
mov    0x8(%rsp),%rdi
jmp    136e <multiply+0x24e>
mov    %edx,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
mov    0x8(%rsp),%rdi
je     1769 <multiply+0x649>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
movdqa 0xd13(%rip),%xmm0
nopl   (%rax)
movdqu (%rdi,%rcx,1),%xmm1
movdqu 0x10(%rdi,%rcx,1),%xmm2
movdqu 0x20(%rdi,%rcx,1),%xmm3
movdqu 0x30(%rdi,%rcx,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%rdi,%rcx,1)
movdqu %xmm2,0x10(%rdi,%rcx,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%rdi,%rcx,1)
movdqu %xmm4,0x30(%rdi,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12f0 <multiply+0x1d0>
test   $0x1,%r8b
je     1364 <multiply+0x244>
movdqu (%rdi,%rcx,1),%xmm0
movdqu 0x10(%rdi,%rcx,1),%xmm1
movdqa 0xcaf(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,(%rdi,%rcx,1)
movdqu %xmm1,0x10(%rdi,%rcx,1)
cmp    %rdx,%rax
je     13ad <multiply+0x28d>
test   $0x18,%dl
je     13a0 <multiply+0x280>
mov    %rax,%rcx
mov    %edx,%eax
and    $0xfffffff8,%eax
movdqa 0xc92(%rip),%xmm0
xchg   %ax,%ax
movq   (%rdi,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1380 <multiply+0x260>
cmp    %rdx,%rax
je     13ad <multiply+0x28d>
nopl   0x0(%rax)
addb   $0xd0,(%rdi,%rax,1)
add    $0x1,%rax
cmp    %rax,%rdx
jne    13a0 <multiply+0x280>
test   %r10d,%r10d
jle    148e <multiply+0x36e>
mov    0x14(%rsp),%eax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
xor    %r13d,%r13d
mov    $0x1,%r15d
mov    %rdx,%rcx
xor    %esi,%esi
mov    %r11,0x28(%rsp)
mov    %rdx,0x20(%rsp)
jmp    1421 <multiply+0x301>
nopl   (%rax)
xor    %edx,%edx
movslq %esi,%rbx
mov    %dl,0x40(%rsp,%rbx,1)
lea    0x1(%rbx),%eax
cltq
lea    (%rsp,%rax,1),%rdi
add    $0x40,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1040 <memset@plt>
lea    (%rbx,%r15,1),%esi
add    $0x1,%esi
add    $0x1,%r15
cmp    0x20(%rsp),%r13
mov    0x28(%rsp),%r11
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%rcx
je     148e <multiply+0x36e>
add    $0x1,%r13
add    $0xffffffffffffffff,%rcx
test   %r11d,%r11d
mov    %rcx,0x30(%rsp)
jle    13e0 <multiply+0x2c0>
mov    0x8(%rsp),%rax
movsbq (%rax,%rcx,1),%rdi
movslq %esi,%rax
lea    (%rsp,%rax,1),%rbp
add    $0x40,%rbp
mov    0x18(%rsp),%rbx
xor    %edx,%edx
nop
movsbq -0x1(%r14,%rbx,1),%rcx
imul   %rdi,%rcx
add    %rdx,%rcx
mov    %rcx,%rax
imul   %r12
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x2,%rdx
add    %rax,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%ecx
mov    %cl,0x0(%rbp)
add    $0x1,%rbp
add    $0x1,%esi
add    $0xffffffffffffffff,%rbx
jg     1450 <multiply+0x330>
jmp    13e2 <multiply+0x2c2>
lea    (%r11,%r10,1),%eax
test   %eax,%eax
jle    160b <multiply+0x4eb>
movslq 0x14(%rsp),%rcx
lea    0x1(%r10),%r9d
mov    %eax,0x18(%rsp)
mov    %eax,%r8d
lea    -0x1(%r9),%r15
mov    %r15,%r13
and    $0xfffffffffffffffe,%r13
lea    0x1(%rcx),%rax
mov    %rax,0x20(%rsp)
add    $0x2,%r11d
mov    %rcx,0x30(%rsp)
lea    0x2(%rcx),%rax
mov    %rax,0x8(%rsp)
xor    %edi,%edi
xor    %edx,%edx
mov    %r8,0x28(%rsp)
jmp    1513 <multiply+0x3f3>
nopl   0x0(%rax,%rax,1)
add    %rdx,%rcx
mov    %rcx,%rax
imul   %r12
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x2,%rdx
add    %rax,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%ecx
mov    %cl,0x2750(%rsp,%rdi,1)
add    $0x1,%rdi
cmp    %r8,%rdi
je     15ec <multiply+0x4cc>
xor    %ecx,%ecx
test   %r10d,%r10d
jle    14e0 <multiply+0x3c0>
cmp    $0x2,%r9d
jne    1540 <multiply+0x420>
mov    $0x1,%eax
xor    %esi,%esi
test   $0x1,%r15b
je     14e0 <multiply+0x3c0>
jmp    15ca <multiply+0x4aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xffffffffffffffff,%rax
mov    0x8(%rsp),%rbp
mov    %r11,%r10
mov    %r11,%rbx
mov    %ebx,%r8d
mov    0x20(%rsp),%r11
xor    %esi,%esi
jmp    1581 <multiply+0x461>
xchg   %ax,%ax
add    %r8d,%esi
add    $0x2,%r11
add    $0x2,%rbp
add    $0x2,%r8d
lea    (%rax,%r13,1),%rbx
add    $0xfffffffffffffffe,%rbx
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rbx
je     15b0 <multiply+0x490>
cmp    %r11,%rdi
jg     1595 <multiply+0x475>
movslq %esi,%r14
add    %rdi,%r14
movsbq 0x40(%rsp,%r14,1),%rbx
add    %rbx,%rcx
add    %ebp,%esi
cmp    %rbp,%rdi
jg     1560 <multiply+0x440>
movslq %esi,%rbx
add    %rdi,%rbx
movsbq 0x40(%rsp,%rbx,1),%rbx
add    %rbx,%rcx
jmp    1560 <multiply+0x440>
nopl   (%rax)
neg    %rax
mov    %r10,%r11
mov    0x38(%rsp),%r10
mov    0x28(%rsp),%r8
test   $0x1,%r15b
je     14e0 <multiply+0x3c0>
add    0x30(%rsp),%rax
cmp    %rax,%rdi
jg     14e0 <multiply+0x3c0>
movslq %esi,%rax
add    %rdi,%rax
movsbq 0x40(%rsp,%rax,1),%rax
add    %rax,%rcx
jmp    14e0 <multiply+0x3c0>
mov    %dl,0x2750(%rsp,%r8,1)
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    160b <multiply+0x4eb>
cmp    $0x8,%eax
jae    1613 <multiply+0x4f3>
xor    %eax,%eax
mov    %r8,%rcx
jmp    1780 <multiply+0x660>
xor    %r8d,%r8d
jmp    17b6 <multiply+0x696>
cmp    $0x20,%eax
jae    161f <multiply+0x4ff>
xor    %eax,%eax
jmp    16ec <multiply+0x5cc>
mov    %r8d,%eax
and    $0xffffffe0,%eax
lea    0x2750(%rsp),%rcx
add    %r8,%rcx
add    $0xfffffffffffffff0,%rcx
xor    %edx,%edx
movdqa 0x9e2(%rip),%xmm0
pxor   %xmm1,%xmm1
lea    0x29f7(%rip),%rsi
nopl   0x0(%rax)
movdqu -0x10(%rcx),%xmm2
movdqu (%rcx),%xmm3
paddb  %xmm0,%xmm3
movdqa %xmm3,%xmm4
punpcklbw %xmm1,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
punpckhbw %xmm1,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
packuswb %xmm4,%xmm3
paddb  %xmm0,%xmm2
movdqa %xmm2,%xmm4
punpcklbw %xmm1,%xmm4
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
punpckhbw %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm4,%xmm2
movdqa %xmm3,(%rdx,%rsi,1)
movdqa %xmm2,0x10(%rdx,%rsi,1)
add    $0x20,%rdx
add    $0xffffffffffffffe0,%rcx
cmp    %rdx,%rax
jne    1650 <multiply+0x530>
cmp    %r8,%rax
je     17b6 <multiply+0x696>
test   $0x18,%r8b
je     177a <multiply+0x65a>
mov    %rax,%rdx
mov    %r8d,%eax
and    $0xfffffff8,%eax
mov    %r8,%rcx
sub    %rax,%rcx
mov    %r8,%rsi
sub    %rdx,%rsi
add    %rsp,%rsi
add    $0x2748,%rsi
movdqa 0x91d(%rip),%xmm0
pxor   %xmm1,%xmm1
lea    0x2922(%rip),%rdi
xchg   %ax,%ax
movq   (%rsi),%xmm2
paddb  %xmm0,%xmm2
punpcklbw %xmm1,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
movq   %xmm2,(%rdx,%rdi,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rax
jne    1720 <multiply+0x600>
cmp    %r8,%rax
jne    1780 <multiply+0x660>
jmp    17b6 <multiply+0x696>
xor    %edx,%edx
test   $0x1,%sil
jne    11f6 <multiply+0xd6>
jmp    1220 <multiply+0x100>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    133e <multiply+0x21e>
jmp    1364 <multiply+0x244>
mov    %r8,%rcx
sub    %rax,%rcx
lea    0x2750(%rsp),%rdx
add    %rdx,%rcx
add    $0xffffffffffffffff,%rcx
lea    0x28aa(%rip),%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rcx),%ebx
add    $0x30,%bl
mov    %bl,(%rax,%rdx,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
cmp    %rax,%r8
jne    17a0 <multiply+0x680>
lea    0x2883(%rip),%rax
movb   $0x0,(%r8,%rax,1)
add    $0x4e68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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