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

/* Forward declarations */

/* Type definitions */
typedef scalar_t__ int32_t;

/* Variables and functions */
scalar_t__ convertCharToInt(char const);
void *strlen(char const *);
void addCharNum(char *num1, const char *num2) {
  const size_t len1 = strlen(num1);
  const size_t len2 = strlen(num2);
  const size_t max_len = (len1 > len2 ? len1 : len2);
  if (len1 <= 0 || len2 <= 0 || (max_len + 1) >= 1024)
    return;
  char temp[1024] = {};
  temp[max_len] = temp[max_len + 1] = '\0';
  int32_t n1i = len1;
  int32_t n2i = len2;
  int32_t carry = 0;
  size_t idx = 0;
  for (idx = 0; idx < max_len; ++idx) {
    int32_t n1_val = --n1i >= 0 ? convertCharToInt(num1[n1i]) : 0;
    int32_t n2_val = --n2i >= 0 ? convertCharToInt(num2[n2i]) : 0;
    int32_t sum = n1_val + n2_val + carry;
    temp[idx] = (sum % 10) + '0';
    carry = sum / 10;
  }
  if (carry > 0) {
    temp[idx] = carry + '0';
  }
  size_t sum_len = strlen(temp);
  for (size_t i = 0; i < sum_len; ++i) {
    num1[i] = temp[sum_len - i - 1];
  }
  num1[sum_len] = '\0';
}


x86 assembly (clang, -O0):
<addCharNum>:
push   %rbp
mov    %rsp,%rbp
sub    $0x490,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    117b <addCharNum+0x4b>
mov    -0x18(%rbp),%rax
mov    %rax,-0x480(%rbp)
jmp    1186 <addCharNum+0x56>
mov    -0x20(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0x480(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
jbe    11bb <addCharNum+0x8b>
cmpq   $0x0,-0x20(%rbp)
jbe    11bb <addCharNum+0x8b>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
cmp    $0x400,%rax
jb     11c0 <addCharNum+0x90>
jmp    13fb <addCharNum+0x2cb>
lea    -0x430(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
mov    -0x28(%rbp),%rax
movb   $0x0,-0x42f(%rbp,%rax,1)
mov    -0x28(%rbp),%rax
movb   $0x0,-0x430(%rbp,%rax,1)
mov    -0x18(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x440(%rbp)
movq   $0x0,-0x448(%rbp)
movq   $0x0,-0x450(%rbp)
movq   $0x0,-0x450(%rbp)
mov    -0x450(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1353 <addCharNum+0x223>
mov    -0x438(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x438(%rbp)
cmp    $0x0,%rax
jl     126f <addCharNum+0x13f>
mov    -0x8(%rbp),%rax
mov    -0x438(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <convertCharToInt@plt>
mov    %rax,-0x488(%rbp)
jmp    127d <addCharNum+0x14d>
xor    %eax,%eax
mov    %rax,-0x488(%rbp)
jmp    127d <addCharNum+0x14d>
mov    -0x488(%rbp),%rax
mov    %rax,-0x458(%rbp)
mov    -0x440(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x440(%rbp)
cmp    $0x0,%rax
jl     12c7 <addCharNum+0x197>
mov    -0x10(%rbp),%rax
mov    -0x440(%rbp),%rcx
movsbl (%rax,%rcx,1),%edi
call   1050 <convertCharToInt@plt>
mov    %rax,-0x490(%rbp)
jmp    12d5 <addCharNum+0x1a5>
xor    %eax,%eax
mov    %rax,-0x490(%rbp)
jmp    12d5 <addCharNum+0x1a5>
mov    -0x490(%rbp),%rax
mov    %rax,-0x460(%rbp)
mov    -0x458(%rbp),%rax
add    -0x460(%rbp),%rax
add    -0x448(%rbp),%rax
mov    %rax,-0x468(%rbp)
mov    -0x468(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
add    $0x30,%rdx
mov    %dl,%cl
mov    -0x450(%rbp),%rax
mov    %cl,-0x430(%rbp,%rax,1)
mov    -0x468(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x448(%rbp)
mov    -0x450(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x450(%rbp)
jmp    1222 <addCharNum+0xf2>
cmpq   $0x0,-0x448(%rbp)
jle    137c <addCharNum+0x24c>
mov    -0x448(%rbp),%rax
add    $0x30,%rax
mov    %al,%cl
mov    -0x450(%rbp),%rax
mov    %cl,-0x430(%rbp,%rax,1)
lea    -0x430(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x470(%rbp)
movq   $0x0,-0x478(%rbp)
mov    -0x478(%rbp),%rax
cmp    -0x470(%rbp),%rax
jae    13ec <addCharNum+0x2bc>
mov    -0x470(%rbp),%rax
sub    -0x478(%rbp),%rax
sub    $0x1,%rax
mov    -0x430(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x478(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
jmp    139a <addCharNum+0x26a>
mov    -0x8(%rbp),%rax
mov    -0x470(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x490,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<addCharNum>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x418,%rsp
mov    %rsi,%rbx
mov    %rdi,%rbp
call   1030 <strlen@plt>
mov    %rax,%r12
mov    %rbx,0x8(%rsp)
mov    %rbx,%rdi
call   1030 <strlen@plt>
cmp    %rax,%r12
mov    %rax,%r14
cmova  %r12,%r14
test   %r12,%r12
je     13c9 <addCharNum+0x299>
mov    %rax,%r13
test   %rax,%rax
je     13c9 <addCharNum+0x299>
lea    -0x3ff(%r14),%rax
cmp    $0xfffffffffffffc00,%rax
jb     13c9 <addCharNum+0x299>
lea    0x10(%rsp),%rdi
mov    $0x400,%edx
xor    %esi,%esi
call   1040 <memset@plt>
test   %r14,%r14
je     1261 <addCharNum+0x131>
mov    %rbp,(%rsp)
xor    %ebx,%ebx
xor    %r15d,%r15d
jmp    121a <addCharNum+0xea>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%rax
movsbl -0x1(%rax,%r13,1),%edi
call   1050 <convertCharToInt@plt>
add    %rbx,%rbp
add    %rax,%rbp
mov    %rbp,%rax
movabs $0x6666666666666667,%rcx
66 66 66
imul   %rcx
mov    %rdx,%rbx
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x2,%rbx
add    %rax,%rbx
lea    (%rbx,%rbx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %ebp,%ecx
sub    %eax,%ecx
add    $0x30,%cl
mov    %cl,0x10(%rsp,%r15,1)
add    $0x1,%r15
add    $0xffffffffffffffff,%r12
add    $0xffffffffffffffff,%r13
cmp    %r15,%r14
je     124f <addCharNum+0x11f>
test   %r12,%r12
jle    1240 <addCharNum+0x110>
mov    (%rsp),%rax
movsbl -0x1(%rax,%r12,1),%edi
call   1050 <convertCharToInt@plt>
mov    %rax,%rbp
test   %r13,%r13
jg     11c0 <addCharNum+0x90>
jmp    124b <addCharNum+0x11b>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
test   %r13,%r13
jg     11c0 <addCharNum+0x90>
xor    %eax,%eax
jmp    11d0 <addCharNum+0xa0>
cmp    $0xa,%rbp
mov    (%rsp),%rbp
jl     1261 <addCharNum+0x131>
add    $0x30,%bl
mov    %bl,0x10(%rsp,%r14,1)
lea    0x10(%rsp),%r14
mov    %r14,%rdi
call   1030 <strlen@plt>
test   %rax,%rax
je     13c4 <addCharNum+0x294>
cmp    $0x2,%rax
mov    $0x1,%ecx
cmovae %rax,%rcx
cmp    $0x8,%rcx
jae    1291 <addCharNum+0x161>
xor    %edx,%edx
jmp    13a3 <addCharNum+0x273>
cmp    $0x20,%rcx
jae    129e <addCharNum+0x16e>
xor    %edx,%edx
jmp    134c <addCharNum+0x21c>
mov    %rcx,%rdx
and    $0xffffffffffffffe0,%rdx
lea    (%rax,%r14,1),%rsi
add    $0xfffffffffffffff0,%rsi
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rsi),%xmm1
movdqu (%rsi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,0x0(%rbp,%rdi,1)
movdqu %xmm1,0x10(%rbp,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%rdx
jne    12c0 <addCharNum+0x190>
cmp    %rdx,%rcx
je     13c4 <addCharNum+0x294>
test   $0x18,%cl
je     13a3 <addCharNum+0x273>
mov    %rdx,%rsi
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
mov    %rax,%rdi
sub    %rsi,%rdi
add    %r14,%rdi
add    $0xfffffffffffffff8,%rdi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movq   (%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x0(%rbp,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdi
cmp    %rsi,%rdx
jne    1370 <addCharNum+0x240>
cmp    %rdx,%rcx
je     13c4 <addCharNum+0x294>
mov    %rax,%rsi
sub    %rdx,%rsi
add    %r14,%rsi
add    $0xffffffffffffffff,%rsi
movzbl (%rsi),%ebx
mov    %bl,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %rdx,%rcx
jne    13b0 <addCharNum+0x280>
movb   $0x0,0x0(%rbp,%rax,1)
add    $0x418,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @addCharNum(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca [1024 x i8]
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
store i8* %0, i8** %3
store i8* %1, i8** %4
%18 = load i8*, i8** %3
%19 = call i8* @strlen(i8* %18)
%20 = ptrtoint i8* %19 to i64
store i64 %20, i64* %5
%21 = load i8*, i8** %4
%22 = call i8* @strlen(i8* %21)
%23 = ptrtoint i8* %22 to i64
store i64 %23, i64* %6
%24 = load i64, i64* %5
%25 = load i64, i64* %6
%26 = icmp ugt i64 %24, %25
br i1 %26, label %27, label %29
27: ; preds = %2
%28 = load i64, i64* %5
br label %31
29: ; preds = %2
%30 = load i64, i64* %6
br label %31
31: ; preds = %29, %27
%32 = phi i64 [ %28, %27 ], [ %30, %29 ]
store i64 %32, i64* %7
%33 = load i64, i64* %5
%34 = icmp ule i64 %33, 0
br i1 %34, label %42, label %35
35: ; preds = %31
%36 = load i64, i64* %6
%37 = icmp ule i64 %36, 0
br i1 %37, label %42, label %38
38: ; preds = %35
%39 = load i64, i64* %7
%40 = add i64 %39, 1
%41 = icmp uge i64 %40, 1024
br i1 %41, label %42, label %43
42: ; preds = %38, %35, %31
br label %131
43: ; preds = %38
%44 = bitcast [1024 x i8]* %8 to i8*
%45 = load i64, i64* %7
%46 = add i64 %45, 1
%47 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %46
store i8 0, i8* %47
%48 = load i64, i64* %7
%49 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %48
store i8 0, i8* %49
%50 = load i64, i64* %5
store i64 %50, i64* %9
%51 = load i64, i64* %6
store i64 %51, i64* %10
store i64 0, i64* %11
store i64 0, i64* %12
store i64 0, i64* %12
br label %52
52: ; preds = %94, %43
%53 = load i64, i64* %12
%54 = load i64, i64* %7
%55 = icmp ult i64 %53, %54
br i1 %55, label %56, label %97
56: ; preds = %52
%57 = load i64, i64* %9
%58 = add nsw i64 %57, -1
store i64 %58, i64* %9
%59 = icmp sge i64 %58, 0
br i1 %59, label %60, label %66
60: ; preds = %56
%61 = load i8*, i8** %3
%62 = load i64, i64* %9
%63 = getelementptr inbounds i8, i8* %61, i64 %62
%64 = load i8, i8* %63
%65 = call i64 @convertCharToInt(i8 signext %64)
br label %67
66: ; preds = %56
br label %67
67: ; preds = %66, %60
%68 = phi i64 [ %65, %60 ], [ 0, %66 ]
store i64 %68, i64* %13
%69 = load i64, i64* %10
%70 = add nsw i64 %69, -1
store i64 %70, i64* %10
%71 = icmp sge i64 %70, 0
br i1 %71, label %72, label %78
72: ; preds = %67
%73 = load i8*, i8** %4
%74 = load i64, i64* %10
%75 = getelementptr inbounds i8, i8* %73, i64 %74
%76 = load i8, i8* %75
%77 = call i64 @convertCharToInt(i8 signext %76)
br label %79
78: ; preds = %67
br label %79
79: ; preds = %78, %72
%80 = phi i64 [ %77, %72 ], [ 0, %78 ]
store i64 %80, i64* %14
%81 = load i64, i64* %13
%82 = load i64, i64* %14
%83 = add nsw i64 %81, %82
%84 = load i64, i64* %11
%85 = add nsw i64 %83, %84
store i64 %85, i64* %15
%86 = load i64, i64* %15
%87 = srem i64 %86, 10
%88 = add nsw i64 %87, 48
%89 = trunc i64 %88 to i8
%90 = load i64, i64* %12
%91 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %90
store i8 %89, i8* %91
%92 = load i64, i64* %15
%93 = sdiv i64 %92, 10
store i64 %93, i64* %11
br label %94
94: ; preds = %79
%95 = load i64, i64* %12
%96 = add i64 %95, 1
store i64 %96, i64* %12
br label %52
97: ; preds = %52
%98 = load i64, i64* %11
%99 = icmp sgt i64 %98, 0
br i1 %99, label %100, label %106
100: ; preds = %97
%101 = load i64, i64* %11
%102 = add nsw i64 %101, 48
%103 = trunc i64 %102 to i8
%104 = load i64, i64* %12
%105 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %104
store i8 %103, i8* %105
br label %106
106: ; preds = %100, %97
%107 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 0
%108 = call i8* @strlen(i8* %107)
%109 = ptrtoint i8* %108 to i64
store i64 %109, i64* %16
store i64 0, i64* %17
br label %110
110: ; preds = %124, %106
%111 = load i64, i64* %17
%112 = load i64, i64* %16
%113 = icmp ult i64 %111, %112
br i1 %113, label %114, label %127
114: ; preds = %110
%115 = load i64, i64* %16
%116 = load i64, i64* %17
%117 = sub i64 %115, %116
%118 = sub i64 %117, 1
%119 = getelementptr inbounds [1024 x i8], [1024 x i8]* %8, i64 0, i64 %118
%120 = load i8, i8* %119
%121 = load i8*, i8** %3
%122 = load i64, i64* %17
%123 = getelementptr inbounds i8, i8* %121, i64 %122
store i8 %120, i8* %123
br label %124
124: ; preds = %114
%125 = load i64, i64* %17
%126 = add i64 %125, 1
store i64 %126, i64* %17
br label %110
127: ; preds = %110
%128 = load i8*, i8** %3
%129 = load i64, i64* %16
%130 = getelementptr inbounds i8, i8* %128, i64 %129
store i8 0, i8* %130
br label %131
131: ; preds = %127, %42
ret void
}

LLVM IR (-O2):
define void @addCharNum(i8* %0, i8* %1) {
%3 = alloca [1024 x i8]
%4 = tail call i8* @strlen(i8* %0)
%5 = ptrtoint i8* %4 to i64
%6 = tail call i8* @strlen(i8* %1)
%7 = ptrtoint i8* %6 to i64
%8 = icmp ugt i64 %5, %7
%9 = select i1 %8, i64 %5, i64 %7
%10 = icmp eq i8* %4, null
%11 = icmp eq i8* %6, null
%12 = select i1 %10, i1 true, i1 %11
%13 = add i64 %9, -1023
%14 = icmp ult i64 %13, -1024
%15 = select i1 %12, i1 true, i1 %14
br i1 %15, label %121, label %16
16: ; preds = %2
%17 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 0
%18 = icmp eq i64 %9, 0
br i1 %18, label %55, label %19
19: ; preds = %16, %38
%20 = phi i64 [ %24, %38 ], [ %5, %16 ]
%21 = phi i64 [ %32, %38 ], [ %7, %16 ]
%22 = phi i64 [ %46, %38 ], [ 0, %16 ]
%23 = phi i64 [ %47, %38 ], [ 0, %16 ]
%24 = add nsw i64 %20, -1
%25 = icmp sgt i64 %20, 0
br i1 %25, label %26, label %30
26: ; preds = %19
%27 = getelementptr inbounds i8, i8* %0, i64 %24
%28 = load i8, i8* %27
%29 = tail call i64 @convertCharToInt(i8 signext %28)
br label %30
30: ; preds = %19, %26
%31 = phi i64 [ %29, %26 ], [ 0, %19 ]
%32 = add nsw i64 %21, -1
%33 = icmp sgt i64 %21, 0
br i1 %33, label %34, label %38
34: ; preds = %30
%35 = getelementptr inbounds i8, i8* %1, i64 %32
%36 = load i8, i8* %35
%37 = tail call i64 @convertCharToInt(i8 signext %36)
br label %38
38: ; preds = %30, %34
%39 = phi i64 [ %37, %34 ], [ 0, %30 ]
%40 = add i64 %31, %22
%41 = add i64 %40, %39
%42 = srem i64 %41, 10
%43 = trunc i64 %42 to i8
%44 = add nsw i8 %43, 48
%45 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %23
store i8 %44, i8* %45
%46 = sdiv i64 %41, 10
%47 = add nuw i64 %23, 1
%48 = icmp eq i64 %47, %9
br i1 %48, label %49, label %19
49: ; preds = %38
%50 = icmp sgt i64 %41, 9
br i1 %50, label %51, label %55
51: ; preds = %49
%52 = trunc i64 %46 to i8
%53 = add i8 %52, 48
%54 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %9
store i8 %53, i8* %54
br label %55
55: ; preds = %16, %51, %49
%56 = call i8* @strlen(i8* %17)
%57 = ptrtoint i8* %56 to i64
%58 = icmp eq i8* %56, null
br i1 %58, label %110, label %59
59: ; preds = %55
%60 = call i64 @llvm.umax.i64(i64 %57, i64 1)
%61 = icmp ult i64 %60, 8
br i1 %61, label %108, label %62
62: ; preds = %59
%63 = icmp ult i64 %60, 32
br i1 %63, label %90, label %64
64: ; preds = %62
%65 = and i64 %60, -32
br label %66
66: ; preds = %66, %64
%67 = phi i64 [ 0, %64 ], [ %83, %66 ]
%68 = xor i64 %67, -1
%69 = add i64 %68, %57
%70 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %69
%71 = getelementptr inbounds i8, i8* %70, i64 -15
%72 = bitcast i8* %71 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = shufflevector <16 x i8> %73, <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>
%75 = getelementptr inbounds i8, i8* %70, i64 -31
%76 = bitcast i8* %75 to <16 x i8>*
%77 = load <16 x i8>, <16 x i8>* %76
%78 = shufflevector <16 x i8> %77, <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>
%79 = getelementptr inbounds i8, i8* %0, i64 %67
%80 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %74, <16 x i8>* %80
%81 = getelementptr inbounds i8, i8* %79, i64 16
%82 = bitcast i8* %81 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %82
%83 = add nuw i64 %67, 32
%84 = icmp eq i64 %83, %65
br i1 %84, label %85, label %66
85: ; preds = %66
%86 = icmp eq i64 %60, %65
br i1 %86, label %110, label %87
87: ; preds = %85
%88 = and i64 %60, 24
%89 = icmp eq i64 %88, 0
br i1 %89, label %108, label %90
90: ; preds = %62, %87
%91 = phi i64 [ %65, %87 ], [ 0, %62 ]
%92 = and i64 %60, -8
br label %93
93: ; preds = %93, %90
%94 = phi i64 [ %91, %90 ], [ %104, %93 ]
%95 = xor i64 %94, -1
%96 = add i64 %95, %57
%97 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %96
%98 = getelementptr inbounds i8, i8* %97, i64 -7
%99 = bitcast i8* %98 to <8 x i8>*
%100 = load <8 x i8>, <8 x i8>* %99
%101 = shufflevector <8 x i8> %100, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%102 = getelementptr inbounds i8, i8* %0, i64 %94
%103 = bitcast i8* %102 to <8 x i8>*
store <8 x i8> %101, <8 x i8>* %103
%104 = add nuw i64 %94, 8
%105 = icmp eq i64 %104, %92
br i1 %105, label %106, label %93
106: ; preds = %93
%107 = icmp eq i64 %60, %92
br i1 %107, label %110, label %108
108: ; preds = %59, %87, %106
%109 = phi i64 [ 0, %59 ], [ %65, %87 ], [ %92, %106 ]
br label %112
110: ; preds = %112, %85, %106, %55
%111 = getelementptr inbounds i8, i8* %0, i64 %57
store i8 0, i8* %111
br label %121
112: ; preds = %108, %112
%113 = phi i64 [ %119, %112 ], [ %109, %108 ]
%114 = xor i64 %113, -1
%115 = add i64 %114, %57
%116 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = getelementptr inbounds i8, i8* %0, i64 %113
store i8 %117, i8* %118
%119 = add nuw i64 %113, 1
%120 = icmp eq i64 %119, %60
br i1 %120, label %110, label %112
121: ; preds = %2, %110
ret void
}