#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 *);
void plus(char *s, char *s1, char *s2) {
  int a1[10000] = {0}, a2[10000] = {0}, sum[10000] = {0};
  int i = 0, j, k, l1, l2, l, maxline;
  l1 = strlen(s1);
  l2 = strlen(s2);
  for (i = 0; i < l1; i++)
    a1[l1 - 1 - i] = s1[i] - '0';
  for (i = 0; i < l2; i++)
    a2[l2 - 1 - i] = s2[i] - '0';
  l = l1 > l2 ? l1 : l2;
  for (i = 0; i < l; i++) {
    sum[i] += a1[i] + a2[i];
    if (sum[i] >= 10) {
      sum[i] -= 10;
      sum[i + 1] += 1;
    }
  }
  if (sum[l] != 0)
    maxline = l;
  else
    maxline = l - 1;
  for (i = maxline; i >= 0; i--)
    s[maxline - i] = sum[i] + '0';
  s[i] = '\0';
}


x86 assembly (clang, -O0):
<plus>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d500,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x9c60(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x138a0(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
lea    -0x1d4e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x9c40,%edx
call   1040 <memset@plt>
movl   $0x0,-0x1d4e4(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1d4f0(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x1d4f4(%rbp)
movl   $0x0,-0x1d4e4(%rbp)
mov    -0x1d4e4(%rbp),%eax
cmp    -0x1d4f0(%rbp),%eax
jge    11f2 <plus+0xd2>
mov    -0x10(%rbp),%rax
movslq -0x1d4e4(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x1d4f0(%rbp),%eax
sub    $0x1,%eax
sub    -0x1d4e4(%rbp),%eax
cltq
mov    %ecx,-0x9c60(%rbp,%rax,4)
mov    -0x1d4e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4e4(%rbp)
jmp    11a2 <plus+0x82>
movl   $0x0,-0x1d4e4(%rbp)
mov    -0x1d4e4(%rbp),%eax
cmp    -0x1d4f4(%rbp),%eax
jge    124c <plus+0x12c>
mov    -0x18(%rbp),%rax
movslq -0x1d4e4(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x1d4f4(%rbp),%eax
sub    $0x1,%eax
sub    -0x1d4e4(%rbp),%eax
cltq
mov    %ecx,-0x138a0(%rbp,%rax,4)
mov    -0x1d4e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4e4(%rbp)
jmp    11fc <plus+0xdc>
mov    -0x1d4f0(%rbp),%eax
cmp    -0x1d4f4(%rbp),%eax
jle    126f <plus+0x14f>
mov    -0x1d4f0(%rbp),%eax
mov    %eax,-0x1d500(%rbp)
jmp    127b <plus+0x15b>
mov    -0x1d4f4(%rbp),%eax
mov    %eax,-0x1d500(%rbp)
mov    -0x1d500(%rbp),%eax
mov    %eax,-0x1d4f8(%rbp)
movl   $0x0,-0x1d4e4(%rbp)
mov    -0x1d4e4(%rbp),%eax
cmp    -0x1d4f8(%rbp),%eax
jge    1336 <plus+0x216>
movslq -0x1d4e4(%rbp),%rax
mov    -0x9c60(%rbp,%rax,4),%ecx
movslq -0x1d4e4(%rbp),%rax
add    -0x138a0(%rbp,%rax,4),%ecx
movslq -0x1d4e4(%rbp),%rax
add    -0x1d4e0(%rbp,%rax,4),%ecx
mov    %ecx,-0x1d4e0(%rbp,%rax,4)
movslq -0x1d4e4(%rbp),%rax
cmpl   $0xa,-0x1d4e0(%rbp,%rax,4)
0a
jl     131d <plus+0x1fd>
movslq -0x1d4e4(%rbp),%rax
mov    -0x1d4e0(%rbp,%rax,4),%ecx
sub    $0xa,%ecx
mov    %ecx,-0x1d4e0(%rbp,%rax,4)
mov    -0x1d4e4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x1d4e0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1d4e0(%rbp,%rax,4)
jmp    1322 <plus+0x202>
mov    -0x1d4e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4e4(%rbp)
jmp    1291 <plus+0x171>
movslq -0x1d4f8(%rbp),%rax
cmpl   $0x0,-0x1d4e0(%rbp,%rax,4)
je     135c <plus+0x23c>
mov    -0x1d4f8(%rbp),%eax
mov    %eax,-0x1d4fc(%rbp)
jmp    136b <plus+0x24b>
mov    -0x1d4f8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1d4fc(%rbp)
mov    -0x1d4fc(%rbp),%eax
mov    %eax,-0x1d4e4(%rbp)
cmpl   $0x0,-0x1d4e4(%rbp)
jl     13c1 <plus+0x2a1>
movslq -0x1d4e4(%rbp),%rax
mov    -0x1d4e0(%rbp,%rax,4),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x1d4fc(%rbp),%ecx
sub    -0x1d4e4(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1d4e4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1d4e4(%rbp)
jmp    1377 <plus+0x257>
mov    -0x8(%rbp),%rax
movslq -0x1d4e4(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1d500,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<plus>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x1d4c8,%rsp
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r12
lea    0x13880(%rsp),%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x9c40(%rsp),%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rsp,%rdi
mov    $0x9c40,%edx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %rbx,%rdi
call   1030 <strlen@plt>
mov    %eax,%r14d
mov    %r15,%rdi
call   1030 <strlen@plt>
test   %r14d,%r14d
jle    12b1 <plus+0x191>
mov    %r14d,%r9d
cmp    $0x8,%r14d
jae    1217 <plus+0xf7>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r9b
je     11c4 <plus+0xa4>
movsbl (%rbx,%rdx,1),%r8d
add    $0xffffffd0,%r8d
mov    %edx,%edi
not    %edi
add    %r14d,%edi
movslq %edi,%rdi
mov    %r8d,0x13880(%rsp,%rdi,4)
or     $0x1,%rdx
add    %r9,%rsi
je     12b1 <plus+0x191>
sub    %rdx,%r9
mov    %edx,%esi
not    %esi
add    %r14d,%esi
add    %rbx,%rdx
add    $0x1,%rdx
xor    %edi,%edi
movsbl -0x1(%rdx,%rdi,1),%ebx
add    $0xffffffd0,%ebx
movslq %esi,%rsi
mov    %ebx,0x13880(%rsp,%rsi,4)
movsbl (%rdx,%rdi,1),%ebx
add    $0xffffffd0,%ebx
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
mov    %ebx,0x13880(%rsp,%rcx,4)
add    $0x2,%rdi
add    $0xfffffffe,%esi
cmp    %rdi,%r9
jne    11e0 <plus+0xc0>
jmp    12b1 <plus+0x191>
lea    -0x1(%r9),%r8
lea    -0x1(%r14),%esi
mov    %esi,%edi
sub    %r8d,%edi
xor    %edx,%edx
cmp    %esi,%edi
jg     1199 <plus+0x79>
shr    $0x20,%r8
jne    1199 <plus+0x79>
mov    %r9d,%edx
and    $0xfffffff8,%edx
xor    %edi,%edi
movdqa 0xdb8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movd   (%rbx,%rdi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0x4(%rbx,%rdi,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm1
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movslq %esi,%rsi
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,0x13874(%rsp,%rsi,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,0x13864(%rsp,%rsi,4)
add    $0x8,%rdi
add    $0xfffffff8,%esi
cmp    %rdi,%rdx
jne    1250 <plus+0x130>
cmp    %r9,%rdx
jne    1199 <plus+0x79>
test   %eax,%eax
jle    13e3 <plus+0x2c3>
mov    %eax,%r8d
cmp    $0x8,%eax
jae    1347 <plus+0x227>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
test   $0x1,%r8b
je     12ef <plus+0x1cf>
movsbl (%r15,%rdx,1),%edi
add    $0xffffffd0,%edi
mov    %edx,%ebx
not    %ebx
add    %eax,%ebx
movslq %ebx,%rbx
mov    %edi,0x9c40(%rsp,%rbx,4)
or     $0x1,%rdx
add    %r8,%rsi
je     13e3 <plus+0x2c3>
sub    %rdx,%r8
mov    %edx,%esi
not    %esi
add    %eax,%esi
add    %r15,%rdx
add    $0x1,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsbl -0x1(%rdx,%rdi,1),%ebx
add    $0xffffffd0,%ebx
movslq %esi,%rsi
mov    %ebx,0x9c40(%rsp,%rsi,4)
movsbl (%rdx,%rdi,1),%ebx
add    $0xffffffd0,%ebx
lea    -0x1(%rsi),%ecx
movslq %ecx,%rcx
mov    %ebx,0x9c40(%rsp,%rcx,4)
add    $0x2,%rdi
add    $0xfffffffe,%esi
cmp    %rdi,%r8
jne    1310 <plus+0x1f0>
jmp    13e3 <plus+0x2c3>
lea    -0x1(%r8),%rdi
lea    -0x1(%rax),%esi
mov    %esi,%ebx
sub    %edi,%ebx
xor    %edx,%edx
cmp    %esi,%ebx
jg     12c7 <plus+0x1a7>
shr    $0x20,%rdi
jne    12c7 <plus+0x1a7>
mov    %r8d,%edx
and    $0xfffffff8,%edx
xor    %edi,%edi
movdqa 0xc8a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movd   (%r15,%rdi,1),%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0x4(%r15,%rdi,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm1
psrad  $0x18,%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movslq %esi,%rsi
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,0x9c34(%rsp,%rsi,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,0x9c24(%rsp,%rsi,4)
add    $0x8,%rdi
add    $0xfffffff8,%esi
cmp    %rdi,%rdx
jne    1380 <plus+0x260>
cmp    %r8,%rdx
jne    12c7 <plus+0x1a7>
cmp    %eax,%r14d
cmovg  %r14d,%eax
test   %eax,%eax
jle    142f <plus+0x30f>
mov    %eax,%ecx
xor    %edx,%edx
jmp    1409 <plus+0x2e9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %rcx,%rdx
je     142f <plus+0x30f>
mov    0x9c40(%rsp,%rdx,4),%esi
add    0x13880(%rsp,%rdx,4),%esi
add    (%rsp,%rdx,4),%esi
mov    %esi,(%rsp,%rdx,4)
cmp    $0x9,%esi
jle    1400 <plus+0x2e0>
add    $0xfffffff6,%esi
mov    %esi,(%rsp,%rdx,4)
addl   $0x1,0x4(%rsp,%rdx,4)
jmp    1400 <plus+0x2e0>
movslq %eax,%rcx
xor    %edx,%edx
cmpl   $0x0,(%rsp,%rcx,4)
sete   %dl
sub    %edx,%eax
js     1636 <plus+0x516>
mov    %eax,%esi
mov    %rsi,%rdi
cmp    $0x7,%eax
jb     15dc <plus+0x4bc>
lea    0x1(%rsi),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     164c <plus+0x52c>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %eax,%eax
movdqa 0xb8b(%rip),%xmm0
movdqa 0xb93(%rip),%xmm1
mov    %rsi,%rcx
mov    %ecx,%edx
movdqu -0x1c(%rsp,%rdx,4),%xmm2
movdqu -0xc(%rsp,%rdx,4),%xmm3
pand   %xmm0,%xmm3
pshuflw $0xe8,%xmm3,%xmm3
pshufhw $0xe8,%xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
packuswb %xmm3,%xmm3
pand   %xmm0,%xmm2
pshuflw $0xe8,%xmm2,%xmm2
pshufhw $0xe8,%xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm3
paddb  %xmm1,%xmm2
movd   %xmm3,(%r12,%rax,1)
movd   %xmm2,0x4(%r12,%rax,1)
lea    -0x8(%rcx),%edx
movdqu -0x1c(%rsp,%rdx,4),%xmm2
movdqu -0xc(%rsp,%rdx,4),%xmm3
pand   %xmm0,%xmm3
pshuflw $0xe8,%xmm3,%xmm3
pshufhw $0xe8,%xmm3,%xmm3
pshufd $0xe8,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
packuswb %xmm3,%xmm3
pand   %xmm0,%xmm2
pshuflw $0xe8,%xmm2,%xmm2
pshufhw $0xe8,%xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
packuswb %xmm2,%xmm2
paddb  %xmm1,%xmm3
paddb  %xmm1,%xmm2
movd   %xmm3,0x8(%r12,%rax,1)
movd   %xmm2,0xc(%r12,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1490 <plus+0x370>
test   $0x1,%bl
je     15cc <plus+0x4ac>
mov    %esi,%ecx
sub    %eax,%ecx
movdqu -0x1c(%rsp,%rcx,4),%xmm0
movdqu -0xc(%rsp,%rcx,4),%xmm1
movdqa 0xa99(%rip),%xmm2
pand   %xmm2,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   %xmm2,%xmm0
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa 0xa69(%rip),%xmm2
paddb  %xmm2,%xmm1
paddb  %xmm2,%xmm0
movd   %xmm1,(%r12,%rax,1)
movd   %xmm0,0x4(%r12,%rax,1)
mov    $0xffffffff,%eax
cmp    %r9,%r8
je     1636 <plus+0x516>
mov    %rsi,%rdi
sub    %r9,%rdi
mov    %rdi,%rcx
test   $0x1,%dil
jne    15fa <plus+0x4da>
mov    %edi,%eax
mov    (%rsp,%rax,4),%al
add    $0x30,%al
mov    %rsi,%rcx
sub    %rdi,%rcx
mov    %al,(%r12,%rcx,1)
lea    -0x1(%rdi),%rcx
mov    $0xffffffff,%eax
test   %rdi,%rdi
je     1636 <plus+0x516>
sub    %rcx,%rsi
lea    (%rsi,%r12,1),%rdx
add    $0x1,%rdx
nop
mov    %ecx,%esi
movzbl (%rsp,%rsi,4),%ebx
add    $0x30,%bl
mov    %bl,-0x1(%rdx)
lea    -0x1(%rcx),%esi
movzbl (%rsp,%rsi,4),%ebx
add    $0x30,%bl
mov    %bl,(%rdx)
add    $0xfffffffffffffffe,%rcx
add    $0x2,%rdx
cmp    $0xffffffffffffffff,%rcx
jne    1610 <plus+0x4f0>
cltq
movb   $0x0,(%r12,%rax,1)
add    $0x1d4c8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
xor    %eax,%eax
test   $0x1,%bl
jne    155f <plus+0x43f>
jmp    15cc <plus+0x4ac>

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

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