#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 */
char *calloc(int, int);
int /*<<< orphan*/ free(char *);
char *rev_str(char *, int);
int strlen(char *);
char *multiply(char *num1, char *num2) {
  if (!num1 || !num2)
    return (0);
  int l1, l2, i, j, t, c, max;
  char *num1_r, *num2_r, *res_r;
  if (!(l1 = strlen(num1)) || !(l2 = strlen(num2)))
    return (0);
  num1_r = rev_str(num1, l1);
  num2_r = rev_str(num2, l2);
  res_r = calloc(l1 + l2, sizeof(char));
  c = 0;
  max = 0;
  for (i = 0; i < l1; i++) {
    for (j = 0; j < l2; j++) {
      t = (num1_r[i] - '0') * (num2_r[j] - '0');
      t += c;
      res_r[i + j] += t;
      c = res_r[i + j] / 10;
      res_r[i + j] %= 10;
    }
    if (c) {
      max = i + j;
      res_r[max] += c;
      c = 0;
    } else {
      max = i + j - 1;
    }
  }
  free(num1_r);
  free(num2_r);
  num1_r = calloc(max + 2, sizeof(char));
  i = max;
  j = 0;
  while (i >= 0)
    num1_r[j++] = res_r[i--] + '0';
  free(res_r);
  if (num1_r[0] == '0')
    num1_r[1] = 0;
  return (num1_r);
}


x86 assembly (clang, -O0):
<multiply>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1166 <multiply+0x26>
cmpq   $0x0,-0x18(%rbp)
jne    1173 <multiply+0x33>
movq   $0x0,-0x8(%rbp)
jmp    1393 <multiply+0x253>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
je     119d <multiply+0x5d>
mov    -0x18(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    11aa <multiply+0x6a>
movq   $0x0,-0x8(%rbp)
jmp    1393 <multiply+0x253>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1050 <rev_str@plt>
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1050 <rev_str@plt>
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%edi
add    -0x20(%rbp),%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12f8 <multiply+0x1b8>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12a6 <multiply+0x166>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    -0x48(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
sub    $0x30,%ecx
imul   %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%esi
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x30(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    $0xa,%esi
cltd
idiv   %esi
mov    -0x58(%rbp),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1206 <multiply+0xc6>
cmpl   $0x0,-0x30(%rbp)
je     12d9 <multiply+0x199>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%esi
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x30(%rbp)
jmp    12e5 <multiply+0x1a5>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ea <multiply+0x1aa>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f3 <multiply+0xb3>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%edi
add    $0x2,%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     136a <multiply+0x22a>
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    132b <multiply+0x1eb>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jne    138b <multiply+0x24b>
mov    -0x40(%rbp),%rax
movb   $0x0,0x1(%rax)
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%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
push   %rax
xor    %r12d,%r12d
test   %rdi,%rdi
je     1260 <multiply+0x120>
mov    %rsi,%r14
test   %rsi,%rsi
je     1260 <multiply+0x120>
mov    %rdi,%rbx
call   1040 <strlen@plt>
test   %eax,%eax
je     125d <multiply+0x11d>
mov    %eax,%r13d
mov    %r14,%rdi
call   1040 <strlen@plt>
xor    %r15d,%r15d
test   %eax,%eax
je     125d <multiply+0x11d>
mov    %eax,%r12d
mov    %rbx,%rdi
mov    %r13d,%esi
call   1050 <rev_str@plt>
mov    %rax,(%rsp)
mov    %r14,%rdi
mov    %r12d,%esi
call   1050 <rev_str@plt>
mov    %rax,%r14
lea    (%r12,%r13,1),%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,%r11
test   %r13d,%r13d
jle    1272 <multiply+0x132>
mov    %r13d,%r8d
mov    %r12d,%r10d
xor    %r9d,%r9d
mov    %r11,%rdi
jmp    11f5 <multiply+0xb5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%r9,1),%r15d
add    $0xffffffff,%r15d
add    $0x1,%r9
add    $0x1,%rdi
cmp    %r8,%r9
je     1272 <multiply+0x132>
mov    $0x0,%ecx
test   %r12d,%r12d
jle    11e0 <multiply+0xa0>
mov    (%rsp),%rax
mov    (%rax,%r9,1),%cl
add    $0xd0,%cl
xor    %esi,%esi
xor    %ebp,%ebp
xchg   %ax,%ax
movzbl (%r14,%rsi,1),%eax
add    $0xd0,%al
mul    %cl
add    %bpl,%al
add    (%rdi,%rsi,1),%al
movsbl %al,%ebx
imul   $0x67,%ebx,%edx
movzwl %dx,%ebp
shr    $0xa,%edx
shr    $0xf,%ebp
add    %dl,%bpl
movzbl %bpl,%edx
add    %edx,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%bl
mov    %bl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1210 <multiply+0xd0>
add    $0x9,%al
mov    %r12d,%ecx
cmp    $0x13,%al
jb     11e0 <multiply+0xa0>
mov    %r9d,%r15d
add    %r10,%r15
add    %bpl,(%r11,%r15,1)
jmp    11e8 <multiply+0xa8>
xor    %r12d,%r12d
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r11,%rbx
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
lea    0x2(%r15),%edi
mov    $0x1,%esi
call   1060 <calloc@plt>
mov    %rax,%r12
test   %r15d,%r15d
js     12b3 <multiply+0x173>
mov    %r15d,%r8d
lea    0x1(%r15),%eax
cmp    $0x7,%r15d
jae    12bd <multiply+0x17d>
xor    %ecx,%ecx
mov    %rbx,%rdi
jmp    140b <multiply+0x2cb>
mov    %rbx,%rdi
call   1030 <free@plt>
jmp    1260 <multiply+0x120>
cmp    $0x1f,%r15d
mov    %rbx,%rdi
jae    12cd <multiply+0x18d>
xor    %ecx,%ecx
jmp    1397 <multiply+0x257>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    0x10(%r12),%rsi
mov    %rcx,%rdx
neg    %rdx
lea    (%r8,%rdi,1),%rbp
add    $0xfffffffffffffff1,%rbp
xor    %ebx,%ebx
movdqa 0xd11(%rip),%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rbp,%rbx,1),%xmm2
movdqu 0x0(%rbp,%rbx,1),%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
movdqu %xmm3,-0x10(%rsi)
movdqu %xmm2,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rdx
jne    1300 <multiply+0x1c0>
cmp    %rax,%rcx
je     1437 <multiply+0x2f7>
test   $0x18,%al
je     1408 <multiply+0x2c8>
mov    %rcx,%rsi
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %r12,%rdx
add    %rsi,%rdx
mov    %rcx,%rbp
neg    %rbp
neg    %rsi
lea    (%r8,%rdi,1),%rbx
add    $0xfffffffffffffff9,%rbx
sub    %rcx,%r8
movdqa 0xc4f(%rip),%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%rbx,%rsi,1),%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)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rbp
jne    13d0 <multiply+0x290>
cmp    %rax,%rcx
jne    140b <multiply+0x2cb>
jmp    1437 <multiply+0x2f7>
sub    %rcx,%r8
mov    %rdi,%rsi
add    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
add    $0x30,%dl
mov    %dl,(%r12,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
cmp    %rcx,%rax
jne    1420 <multiply+0x2e0>
mov    (%r12),%bl
call   1030 <free@plt>
cmp    $0x30,%bl
jne    1260 <multiply+0x120>
movb   $0x0,0x1(%r12)
jmp    1260 <multiply+0x120>

LLVM IR (-O0):
define i8* @multiply(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 i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i8*
%15 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
%16 = load i8*, i8** %4
%17 = icmp ne i8* %16, null
br i1 %17, label %18, label %21
18: ; preds = %2
%19 = load i8*, i8** %5
%20 = icmp ne i8* %19, null
br i1 %20, label %22, label %21
21: ; preds = %18, %2
store i8* null, i8** %3
br label %168
22: ; preds = %18
%23 = load i8*, i8** %4
%24 = call i32 @strlen(i8* %23)
store i32 %24, i32* %6
%25 = icmp ne i32 %24, 0
br i1 %25, label %26, label %30
26: ; preds = %22
%27 = load i8*, i8** %5
%28 = call i32 @strlen(i8* %27)
store i32 %28, i32* %7
%29 = icmp ne i32 %28, 0
br i1 %29, label %31, label %30
30: ; preds = %26, %22
store i8* null, i8** %3
br label %168
31: ; preds = %26
%32 = load i8*, i8** %4
%33 = load i32, i32* %6
%34 = call i8* @rev_str(i8* %32, i32 %33)
store i8* %34, i8** %13
%35 = load i8*, i8** %5
%36 = load i32, i32* %7
%37 = call i8* @rev_str(i8* %35, i32 %36)
store i8* %37, i8** %14
%38 = load i32, i32* %6
%39 = load i32, i32* %7
%40 = add nsw i32 %38, %39
%41 = call i8* @calloc(i32 %40, i32 1)
store i8* %41, i8** %15
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %8
br label %42
42: ; preds = %125, %31
%43 = load i32, i32* %8
%44 = load i32, i32* %6
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %128
46: ; preds = %42
store i32 0, i32* %9
br label %47
47: ; preds = %100, %46
%48 = load i32, i32* %9
%49 = load i32, i32* %7
%50 = icmp slt i32 %48, %49
br i1 %50, label %51, label %103
51: ; preds = %47
%52 = load i8*, i8** %13
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
%58 = sub nsw i32 %57, 48
%59 = load i8*, i8** %14
%60 = load i32, i32* %9
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = sub nsw i32 %64, 48
%66 = mul nsw i32 %58, %65
store i32 %66, i32* %10
%67 = load i32, i32* %11
%68 = load i32, i32* %10
%69 = add nsw i32 %68, %67
store i32 %69, i32* %10
%70 = load i32, i32* %10
%71 = load i8*, i8** %15
%72 = load i32, i32* %8
%73 = load i32, i32* %9
%74 = add nsw i32 %72, %73
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %71, i64 %75
%77 = load i8, i8* %76
%78 = sext i8 %77 to i32
%79 = add nsw i32 %78, %70
%80 = trunc i32 %79 to i8
store i8 %80, i8* %76
%81 = load i8*, i8** %15
%82 = load i32, i32* %8
%83 = load i32, i32* %9
%84 = add nsw i32 %82, %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %81, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = sdiv i32 %88, 10
store i32 %89, i32* %11
%90 = load i8*, i8** %15
%91 = load i32, i32* %8
%92 = load i32, i32* %9
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8, i8* %90, i64 %94
%96 = load i8, i8* %95
%97 = sext i8 %96 to i32
%98 = srem i32 %97, 10
%99 = trunc i32 %98 to i8
store i8 %99, i8* %95
br label %100
100: ; preds = %51
%101 = load i32, i32* %9
%102 = add nsw i32 %101, 1
store i32 %102, i32* %9
br label %47
103: ; preds = %47
%104 = load i32, i32* %11
%105 = icmp ne i32 %104, 0
br i1 %105, label %106, label %119
106: ; preds = %103
%107 = load i32, i32* %8
%108 = load i32, i32* %9
%109 = add nsw i32 %107, %108
store i32 %109, i32* %12
%110 = load i32, i32* %11
%111 = load i8*, i8** %15
%112 = load i32, i32* %12
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %111, i64 %113
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = add nsw i32 %116, %110
%118 = trunc i32 %117 to i8
store i8 %118, i8* %114
store i32 0, i32* %11
br label %124
119: ; preds = %103
%120 = load i32, i32* %8
%121 = load i32, i32* %9
%122 = add nsw i32 %120, %121
%123 = sub nsw i32 %122, 1
store i32 %123, i32* %12
br label %124
124: ; preds = %119, %106
br label %125
125: ; preds = %124
%126 = load i32, i32* %8
%127 = add nsw i32 %126, 1
store i32 %127, i32* %8
br label %42
128: ; preds = %42
%129 = load i8*, i8** %13
%130 = call i32 @free(i8* %129)
%131 = load i8*, i8** %14
%132 = call i32 @free(i8* %131)
%133 = load i32, i32* %12
%134 = add nsw i32 %133, 2
%135 = call i8* @calloc(i32 %134, i32 1)
store i8* %135, i8** %13
%136 = load i32, i32* %12
store i32 %136, i32* %8
store i32 0, i32* %9
br label %137
137: ; preds = %140, %128
%138 = load i32, i32* %8
%139 = icmp sge i32 %138, 0
br i1 %139, label %140, label %155
140: ; preds = %137
%141 = load i8*, i8** %15
%142 = load i32, i32* %8
%143 = add nsw i32 %142, -1
store i32 %143, i32* %8
%144 = sext i32 %142 to i64
%145 = getelementptr inbounds i8, i8* %141, i64 %144
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = add nsw i32 %147, 48
%149 = trunc i32 %148 to i8
%150 = load i8*, i8** %13
%151 = load i32, i32* %9
%152 = add nsw i32 %151, 1
store i32 %152, i32* %9
%153 = sext i32 %151 to i64
%154 = getelementptr inbounds i8, i8* %150, i64 %153
store i8 %149, i8* %154
br label %137
155: ; preds = %137
%156 = load i8*, i8** %15
%157 = call i32 @free(i8* %156)
%158 = load i8*, i8** %13
%159 = getelementptr inbounds i8, i8* %158, i64 0
%160 = load i8, i8* %159
%161 = sext i8 %160 to i32
%162 = icmp eq i32 %161, 48
br i1 %162, label %163, label %166
163: ; preds = %155
%164 = load i8*, i8** %13
%165 = getelementptr inbounds i8, i8* %164, i64 1
store i8 0, i8* %165
br label %166
166: ; preds = %163, %155
%167 = load i8*, i8** %13
store i8* %167, i8** %3
br label %168
168: ; preds = %166, %30, %21
%169 = load i8*, i8** %3
ret i8* %169
}

LLVM IR (-O2):
define noalias i8* @multiply(i8* %0, i8* %1) {
%3 = icmp ne i8* %0, null
%4 = icmp ne i8* %1, null
%5 = and i1 %3, %4
br i1 %5, label %6, label %146
6: ; preds = %2
%7 = tail call i32 @strlen(i8* %0)
%8 = icmp eq i32 %7, 0
br i1 %8, label %146, label %9
9: ; preds = %6
%10 = tail call i32 @strlen(i8* %1)
%11 = icmp eq i32 %10, 0
br i1 %11, label %146, label %12
12: ; preds = %9
%13 = tail call i8* @rev_str(i8* %0, i32 %7)
%14 = tail call i8* @rev_str(i8* %1, i32 %10)
%15 = add nsw i32 %10, %7
%16 = tail call i8* @calloc(i32 %15, i32 1)
%17 = icmp sgt i32 %7, 0
br i1 %17, label %18, label %63
18: ; preds = %12
%19 = icmp sgt i32 %10, 0
%20 = zext i32 %7 to i64
%21 = zext i32 %10 to i64
br label %22
22: ; preds = %18, %59
%23 = phi i64 [ 0, %18 ], [ %61, %59 ]
br i1 %19, label %24, label %54
24: ; preds = %22
%25 = getelementptr inbounds i8, i8* %13, i64 %23
%26 = load i8, i8* %25
%27 = add i8 %26, -48
br label %28
28: ; preds = %24, %28
%29 = phi i64 [ 0, %24 ], [ %42, %28 ]
%30 = phi i8 [ 0, %24 ], [ %40, %28 ]
%31 = getelementptr inbounds i8, i8* %14, i64 %29
%32 = load i8, i8* %31
%33 = add i8 %32, -48
%34 = mul i8 %33, %27
%35 = add i8 %34, %30
%36 = add nuw nsw i64 %29, %23
%37 = getelementptr inbounds i8, i8* %16, i64 %36
%38 = load i8, i8* %37
%39 = add i8 %35, %38
%40 = sdiv i8 %39, 10
%41 = srem i8 %39, 10
store i8 %41, i8* %37
%42 = add nuw nsw i64 %29, 1
%43 = icmp eq i64 %42, %21
br i1 %43, label %44, label %28
44: ; preds = %28
%45 = add i8 %39, 9
%46 = icmp ult i8 %45, 19
br i1 %46, label %54, label %47
47: ; preds = %44
%48 = trunc i64 %23 to i32
%49 = add nuw nsw i32 %10, %48
%50 = zext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %16, i64 %50
%52 = load i8, i8* %51
%53 = add i8 %52, %40
store i8 %53, i8* %51
br label %59
54: ; preds = %22, %44
%55 = phi i32 [ %10, %44 ], [ 0, %22 ]
%56 = trunc i64 %23 to i32
%57 = add nuw nsw i32 %55, %56
%58 = add nsw i32 %57, -1
br label %59
59: ; preds = %47, %54
%60 = phi i32 [ %49, %47 ], [ %58, %54 ]
%61 = add nuw nsw i64 %23, 1
%62 = icmp eq i64 %61, %20
br i1 %62, label %63, label %22
63: ; preds = %59, %12
%64 = phi i32 [ 0, %12 ], [ %60, %59 ]
%65 = tail call i32 @free(i8* %13)
%66 = tail call i32 @free(i8* %14)
%67 = add nsw i32 %64, 2
%68 = tail call i8* @calloc(i32 %67, i32 1)
%69 = icmp sgt i32 %64, -1
br i1 %69, label %72, label %70
70: ; preds = %63
%71 = tail call i32 @free(i8* %16)
br label %146
72: ; preds = %63
%73 = zext i32 %64 to i64
%74 = add nuw i32 %64, 1
%75 = zext i32 %74 to i64
%76 = icmp ult i32 %64, 7
br i1 %76, label %127, label %77
77: ; preds = %72
%78 = icmp ult i32 %64, 31
br i1 %78, label %108, label %79
79: ; preds = %77
%80 = and i64 %75, 4294967264
br label %81
81: ; preds = %81, %79
%82 = phi i64 [ 0, %79 ], [ %100, %81 ]
%83 = sub i64 %73, %82
%84 = getelementptr inbounds i8, i8* %16, i64 %83
%85 = getelementptr inbounds i8, i8* %84, i64 -15
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %84, i64 -16
%89 = getelementptr inbounds i8, i8* %88, i64 -15
%90 = bitcast i8* %89 to <16 x i8>*
%91 = load <16 x i8>, <16 x i8>* %90
%92 = add <16 x i8> %87, <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>
%93 = shufflevector <16 x i8> %92, <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>
%94 = add <16 x i8> %91, <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>
%95 = shufflevector <16 x i8> %94, <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>
%96 = getelementptr inbounds i8, i8* %68, i64 %82
%97 = bitcast i8* %96 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %97
%98 = getelementptr inbounds i8, i8* %96, i64 16
%99 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %95, <16 x i8>* %99
%100 = add nuw i64 %82, 32
%101 = icmp eq i64 %100, %80
br i1 %101, label %102, label %81
102: ; preds = %81
%103 = icmp eq i64 %80, %75
br i1 %103, label %140, label %104
104: ; preds = %102
%105 = sub nsw i64 %73, %80
%106 = and i64 %75, 24
%107 = icmp eq i64 %106, 0
br i1 %107, label %127, label %108
108: ; preds = %77, %104
%109 = phi i64 [ %80, %104 ], [ 0, %77 ]
%110 = and i64 %75, 4294967288
%111 = sub nsw i64 %73, %110
%112 = getelementptr inbounds i8, i8* %16, i64 -7
br label %113
113: ; preds = %113, %108
%114 = phi i64 [ %109, %108 ], [ %123, %113 ]
%115 = sub i64 %73, %114
%116 = getelementptr inbounds i8, i8* %112, i64 %115
%117 = bitcast i8* %116 to <8 x i8>*
%118 = load <8 x i8>, <8 x i8>* %117
%119 = add <8 x i8> %118, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%120 = shufflevector <8 x i8> %119, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%121 = getelementptr inbounds i8, i8* %68, i64 %114
%122 = bitcast i8* %121 to <8 x i8>*
store <8 x i8> %120, <8 x i8>* %122
%123 = add nuw i64 %114, 8
%124 = icmp eq i64 %123, %110
br i1 %124, label %125, label %113
125: ; preds = %113
%126 = icmp eq i64 %110, %75
br i1 %126, label %140, label %127
127: ; preds = %72, %104, %125
%128 = phi i64 [ 0, %72 ], [ %80, %104 ], [ %110, %125 ]
%129 = phi i64 [ %73, %72 ], [ %105, %104 ], [ %111, %125 ]
br label %130
130: ; preds = %127, %130
%131 = phi i64 [ %137, %130 ], [ %128, %127 ]
%132 = phi i64 [ %133, %130 ], [ %129, %127 ]
%133 = add nsw i64 %132, -1
%134 = getelementptr inbounds i8, i8* %16, i64 %132
%135 = load i8, i8* %134
%136 = add i8 %135, 48
%137 = add nuw nsw i64 %131, 1
%138 = getelementptr inbounds i8, i8* %68, i64 %131
store i8 %136, i8* %138
%139 = icmp eq i64 %137, %75
br i1 %139, label %140, label %130
140: ; preds = %130, %125, %102
%141 = load i8, i8* %68
%142 = icmp eq i8 %141, 48
%143 = tail call i32 @free(i8* %16)
br i1 %142, label %144, label %146
144: ; preds = %140
%145 = getelementptr inbounds i8, i8* %68, i64 1
store i8 0, i8* %145
br label %146
146: ; preds = %70, %9, %6, %144, %140, %2
%147 = phi i8* [ null, %2 ], [ null, %9 ], [ null, %6 ], [ %68, %144 ], [ %68, %140 ], [ %68, %70 ]
ret i8* %147
}