#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(char *, char *, int);
int strlen(char *);
int /*<<< orphan*/ turnaround(char *);
char *multiply(char *multiplier, char *multiplicand) {
  int num1_length = strlen(multiplier);
  int num2_length = strlen(multiplicand);
  char *num1 = (char *)malloc(sizeof(char) * (num1_length + 1));
  char *num2 = (char *)malloc(sizeof(char) * (num2_length + 1));
  char *result = (char *)calloc(sizeof(char), num1_length + num2_length + 1);
  memcpy(num1, multiplier, num1_length + 1);
  memcpy(num2, multiplicand, num2_length + 1);
  turnaround(num1);
  turnaround(num2);
  int i, j, carry = 0, tem_num1, tem_num2;
  for (i = 0; i < num2_length; i++) {
    for (j = 0; j < num1_length; j++) {
      tem_num1 = num1[j] - '0';
      tem_num2 = num2[i] - '0';
      result[j + i] += (tem_num2 * tem_num1) % 10 + carry;
      carry = tem_num2 * tem_num1 > 9 ? tem_num2 * tem_num1 / 10 : 0;
      while (result[j + i] > 9) {
        carry += 1;
        result[j + i] -= 10;
      }
    }
    int e = 0;
    while (carry) {
      result[j + i + e] += carry;
      if (result[j + i + e] > 9) {
        result[j + i + e] -= 10;
        carry = 1;
      } else
        carry = 0;
      e += 1;
    }
  }
  for (i = 0; i < num1_length + num2_length; i++)
    result[i] += '0';
  char *p2mymulend = result + strlen(result) - 1;
  while (*p2mymulend == '0') {
    *p2mymulend-- = 0x00;
    if (p2mymulend - result == 0)
      break;
  }
  if (num1)
    free(num1);
  if (num2)
    free(num2);
  turnaround(result);
  return result;
}


x86 assembly (clang, -O0):
<multiply>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%esi
add    -0x18(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1060 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x14(%rbp),%edx
add    $0x1,%edx
call   1070 <memcpy@plt>
mov    -0x28(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%edx
add    $0x1,%edx
call   1070 <memcpy@plt>
mov    -0x20(%rbp),%rdi
call   1030 <turnaround@plt>
mov    -0x28(%rbp),%rdi
call   1030 <turnaround@plt>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13a1 <multiply+0x241>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1309 <multiply+0x1a9>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x40(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
add    -0x3c(%rbp),%esi
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
imul   -0x40(%rbp),%eax
cmp    $0x9,%eax
jle    12a7 <multiply+0x147>
mov    -0x44(%rbp),%eax
imul   -0x40(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x54(%rbp)
jmp    12b1 <multiply+0x151>
xor    %eax,%eax
mov    %eax,-0x54(%rbp)
jmp    12b1 <multiply+0x151>
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jle    12f6 <multiply+0x196>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
sub    $0xa,%edx
mov    %dl,(%rax,%rcx,1)
jmp    12b7 <multiply+0x157>
jmp    12fb <multiply+0x19b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1226 <multiply+0xc6>
movl   $0x0,-0x48(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     138e <multiply+0x22e>
mov    -0x3c(%rbp),%esi
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jle    1379 <multiply+0x219>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
sub    $0xa,%edx
mov    %dl,(%rax,%rcx,1)
movl   $0x1,-0x3c(%rbp)
jmp    1380 <multiply+0x220>
movl   $0x0,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1310 <multiply+0x1b0>
jmp    1393 <multiply+0x233>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1213 <multiply+0xb3>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    13d9 <multiply+0x279>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
add    $0x30,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a8 <multiply+0x248>
mov    -0x30(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x30(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    143f <multiply+0x2df>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x0,%rax
jne    143a <multiply+0x2da>
jmp    143f <multiply+0x2df>
jmp    13fe <multiply+0x29e>
cmpq   $0x0,-0x20(%rbp)
je     1453 <multiply+0x2f3>
mov    -0x20(%rbp),%rdi
call   1040 <free@plt>
cmpq   $0x0,-0x28(%rbp)
je     1467 <multiply+0x307>
mov    -0x28(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <turnaround@plt>
mov    -0x30(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<multiply>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r12
mov    %rdi,0x10(%rsp)
call   1050 <strlen@plt>
mov    %eax,%ebp
mov    %r12,%rdi
call   1050 <strlen@plt>
mov    %eax,%ebx
lea    0x1(%rbp),%edi
mov    %edi,0x8(%rsp)
call   1080 <malloc@plt>
mov    %rax,%r13
lea    0x1(%rbx),%r15d
mov    %r15d,%edi
call   1080 <malloc@plt>
mov    %rax,%r14
lea    (%rbx,%rbp,1),%eax
mov    %eax,0x1c(%rsp)
mov    %rbp,0x20(%rsp)
lea    (%rbx,%rbp,1),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1060 <calloc@plt>
mov    %rax,(%rsp)
mov    %r13,%rdi
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%edx
call   1070 <memcpy@plt>
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r15d,%edx
call   1070 <memcpy@plt>
mov    %r13,%rdi
call   1030 <turnaround@plt>
mov    %r14,%rdi
call   1030 <turnaround@plt>
test   %ebx,%ebx
jle    1368 <multiply+0x208>
mov    %ebx,%eax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%r9d
mov    (%rsp),%rbp
lea    (%r9,%rbp,1),%rdi
add    $0x1,%rdi
xor    %r11d,%r11d
xor    %eax,%eax
jmp    1237 <multiply+0xd7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    $0x1,%rbp
add    $0x1,%rdi
cmp    0x8(%rsp),%rax
je     1368 <multiply+0x208>
cmpl   $0x0,0x20(%rsp)
jle    1220 <multiply+0xc0>
mov    %rdi,0x10(%rsp)
xor    %edi,%edi
xor    %ebx,%ebx
jmp    12a5 <multiply+0x145>
nopl   0x0(%rax)
movzbl %r12b,%esi
cmp    $0x13,%r12b
mov    $0x13,%ecx
cmovge %ecx,%esi
add    %bl,%r10b
add    %r8b,%r10b
mov    %r10d,%ecx
sub    %sil,%cl
add    $0x9,%cl
movzbl %cl,%ecx
imul   $0xcd,%ecx,%esi
shr    $0xb,%esi
lea    (%rsi,%rsi,1),%ebx
lea    (%rbx,%rbx,4),%ebx
mov    %ecx,%r12d
sub    %bl,%r12b
sub    %cl,%r12b
lea    (%rdx,%rsi,1),%ebx
add    $0x1,%ebx
add    %r10b,%r12b
add    $0xf6,%r12b
mov    %r12b,0x0(%rbp,%rdi,1)
add    $0x1,%rdi
cmp    %rdi,%r9
je     1300 <multiply+0x1a0>
movsbl 0x0(%r13,%rdi,1),%ecx
add    $0xffffffd0,%ecx
movsbl (%r14,%rax,1),%r15d
add    $0xffffffd0,%r15d
imul   %ecx,%r15d
movswl %r15w,%ecx
imul   $0x6667,%ecx,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
sar    $0x12,%edx
add    %ecx,%edx
lea    (%rdx,%rdx,1),%ecx
lea    (%rcx,%rcx,4),%ecx
mov    %r15d,%r8d
sub    %ecx,%r8d
lea    (%rbx,%r8,1),%r12d
movzbl 0x0(%rbp,%rdi,1),%r10d
add    %r10b,%r12b
cmp    $0xa,%r15d
cmovl  %r11d,%edx
cmp    $0xa,%r12b
jge    1250 <multiply+0xf0>
mov    %edx,%ebx
jmp    1297 <multiply+0x137>
xchg   %ax,%ax
test   %ebx,%ebx
mov    0x10(%rsp),%rdi
je     1220 <multiply+0xc0>
lea    (%rax,%r9,1),%r10
mov    (%rsp),%rsi
add    (%rsi,%r10,1),%bl
lea    -0xa(%rbx),%ecx
movzbl %bl,%r8d
movzbl %cl,%edx
mov    %rdi,%rcx
cmp    $0xa,%bl
cmovl  %r8d,%edx
mov    %dl,(%rsi,%r10,1)
jl     1220 <multiply+0xc0>
nopw   0x0(%rax,%rax,1)
movzbl (%rcx),%edx
lea    0x1(%rdx),%esi
add    $0xf7,%dl
cmp    $0xa,%sil
movzbl %dl,%edx
movzbl %sil,%esi
cmovl  %esi,%edx
mov    %dl,(%rcx)
add    $0x1,%rcx
cmp    $0x9,%sil
jg     1340 <multiply+0x1e0>
jmp    1220 <multiply+0xc0>
mov    0x1c(%rsp),%ecx
test   %ecx,%ecx
mov    (%rsp),%rbx
jle    147d <multiply+0x31d>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    1386 <multiply+0x226>
xor    %ecx,%ecx
jmp    1470 <multiply+0x310>
cmp    $0x20,%ecx
jae    1392 <multiply+0x232>
xor    %ecx,%ecx
jmp    143d <multiply+0x2dd>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     14d4 <multiply+0x374>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
movdqa 0xc40(%rip),%xmm0
movdqu (%rbx,%rdx,1),%xmm1
movdqu 0x10(%rbx,%rdx,1),%xmm2
movdqu 0x20(%rbx,%rdx,1),%xmm3
movdqu 0x30(%rbx,%rdx,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdx,1)
movdqu %xmm2,0x10(%rbx,%rdx,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdx,1)
movdqu %xmm4,0x30(%rbx,%rdx,1)
add    $0x40,%rdx
add    $0xfffffffffffffffe,%rdi
jne    13c0 <multiply+0x260>
test   $0x1,%sil
je     1434 <multiply+0x2d4>
movdqu (%rbx,%rdx,1),%xmm0
movdqu 0x10(%rbx,%rdx,1),%xmm1
movdqa 0xbdf(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rdx,1)
movdqu %xmm1,0x10(%rbx,%rdx,1)
cmp    %rax,%rcx
je     147d <multiply+0x31d>
test   $0x18,%al
je     1470 <multiply+0x310>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movdqa 0xbc3(%rip),%xmm0
nopl   (%rax)
movq   (%rbx,%rdx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1450 <multiply+0x2f0>
cmp    %rax,%rcx
je     147d <multiply+0x31d>
nopl   0x0(%rax)
addb   $0x30,(%rbx,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1470 <multiply+0x310>
mov    %rbx,%rdi
call   1050 <strlen@plt>
cltq
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax,%rax,1)
cmpb   $0x30,(%rbx,%rax,1)
jne    14a0 <multiply+0x340>
movb   $0x0,(%rbx,%rax,1)
add    $0xffffffffffffffff,%rax
jne    1490 <multiply+0x330>
test   %r13,%r13
je     14ad <multiply+0x34d>
mov    %r13,%rdi
call   1040 <free@plt>
test   %r14,%r14
je     14ba <multiply+0x35a>
mov    %r14,%rdi
call   1040 <free@plt>
mov    %rbx,%rdi
call   1030 <turnaround@plt>
mov    %rbx,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    140e <multiply+0x2ae>
jmp    1434 <multiply+0x2d4>

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

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