int addition(unsigned char *a, int a_len, unsigned char *b, int b_len,
             unsigned char *addres) {
  int i, m = 0, k;
  unsigned int add[10];
  bzero(add, sizeof(add));
  bzero(addres, sizeof(addres));
  if (a_len > b_len)
    k = a_len;
  else
    k = b_len;
  for (i = 0; i <= k; i++)
    add[i] = a[i] + b[i];
  k++;
  for (i = 0; i <= k; i++) {
    add[i] += m;
    m = add[i] / 256;
    add[i] &= 0xff;
  }
  if (add[k] == 0)
    k--;
  for (i = 0; i <= k; i++) {
    addres[i] = add[i];
  }
  return k;
}


x86 assembly (clang, -O0):
<addition>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1030 <memset@plt>
mov    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1168 <addition+0x58>
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    116e <addition+0x5e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     11b1 <addition+0xa1>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
add    %eax,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1175 <addition+0x65>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     120a <addition+0xfa>
mov    -0x30(%rbp),%ecx
movslq -0x2c(%rbp),%rax
add    -0x60(%rbp,%rax,4),%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
movslq -0x2c(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
shr    $0x8,%eax
mov    %eax,-0x30(%rbp)
movslq -0x2c(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%ecx
and    $0xff,%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c1 <addition+0xb1>
movslq -0x34(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
jne    1222 <addition+0x112>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1258 <addition+0x148>
movslq -0x2c(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1229 <addition+0x119>
mov    -0x34(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<addition>:
push   %rbx
mov    %ecx,%eax
pxor   %xmm0,%xmm0
movdqa %xmm0,-0x20(%rsp)
movdqa %xmm0,-0x30(%rsp)
movq   $0x0,-0x10(%rsp)
movq   $0x0,(%r8)
cmp    %ecx,%esi
cmovg  %esi,%eax
lea    0x1(%rax),%r9d
test   %eax,%eax
js     1287 <addition+0x187>
mov    %r9d,%r10d
cmp    $0x8,%r9d
jae    1144 <addition+0x44>
xor    %esi,%esi
jmp    1270 <addition+0x170>
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1414 <addition+0x314>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
nop
movd   (%rdi,%rcx,1),%xmm1
movd   0x4(%rdi,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movd   (%rdx,%rcx,1),%xmm3
movd   0x4(%rdx,%rcx,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm1,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm2,%xmm4
movdqa %xmm3,-0x30(%rsp,%rcx,4)
movdqa %xmm4,-0x20(%rsp,%rcx,4)
movd   0x8(%rdi,%rcx,1),%xmm1
movd   0xc(%rdi,%rcx,1),%xmm2
punpcklbw %xmm0,%xmm1
punpcklwd %xmm0,%xmm1
punpcklbw %xmm0,%xmm2
punpcklwd %xmm0,%xmm2
movd   0x8(%rdx,%rcx,1),%xmm3
movd   0xc(%rdx,%rcx,1),%xmm4
punpcklbw %xmm0,%xmm3
punpcklwd %xmm0,%xmm3
paddd  %xmm1,%xmm3
punpcklbw %xmm0,%xmm4
punpcklwd %xmm0,%xmm4
paddd  %xmm2,%xmm4
movdqa %xmm3,-0x10(%rsp,%rcx,4)
movdqa %xmm4,(%rsp,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1170 <addition+0x70>
test   $0x1,%r11b
je     1267 <addition+0x167>
movd   (%rdi,%rcx,1),%xmm0
movd   0x4(%rdi,%rcx,1),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movd   (%rdx,%rcx,1),%xmm3
movd   0x4(%rdx,%rcx,1),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm1,%xmm4
movdqa %xmm3,-0x30(%rsp,%rcx,4)
movdqa %xmm4,-0x20(%rsp,%rcx,4)
cmp    %r10,%rsi
je     1287 <addition+0x187>
nopl   0x0(%rax)
movzbl (%rdi,%rsi,1),%ecx
movzbl (%rdx,%rsi,1),%ebx
add    %ecx,%ebx
mov    %ebx,-0x30(%rsp,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r10
jne    1270 <addition+0x170>
cmp    $0xffffffff,%eax
jl     12f5 <addition+0x1f5>
xor    %edx,%edx
test   %r9d,%r9d
mov    $0x0,%ecx
cmovg  %r9d,%ecx
add    $0x1,%ecx
cmp    $0x7ffffffe,%eax
jbe    12a8 <addition+0x1a8>
xor    %esi,%esi
jmp    12e5 <addition+0x1e5>
mov    %ecx,%edi
and    $0xfffffffe,%edi
xor    %esi,%esi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    -0x30(%rsp,%rsi,4),%edx
movzbl %dl,%ebx
shr    $0x8,%edx
mov    %ebx,-0x30(%rsp,%rsi,4)
add    -0x2c(%rsp,%rsi,4),%edx
movzbl %dl,%ebx
shr    $0x8,%edx
mov    %ebx,-0x2c(%rsp,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rdi
jne    12c0 <addition+0x1c0>
test   $0x1,%cl
je     12f5 <addition+0x1f5>
add    -0x30(%rsp,%rsi,4),%edx
movzbl %dl,%ecx
mov    %ecx,-0x30(%rsp,%rsi,4)
movslq %r9d,%rcx
cmpl   $0x0,-0x30(%rsp,%rcx,4)
cmovne %r9d,%eax
test   %eax,%eax
js     1412 <addition+0x312>
lea    0x1(%rax),%ecx
cmp    $0x7,%eax
jae    1318 <addition+0x218>
xor    %edx,%edx
jmp    1400 <addition+0x300>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1425 <addition+0x325>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movdqa 0xcba(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqa -0x30(%rsp,%rsi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movdqa -0x20(%rsp,%rsi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,(%r8,%rsi,1)
movd   %xmm2,0x4(%r8,%rsi,1)
movdqa -0x10(%rsp,%rsi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movdqa (%rsp,%rsi,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm1,0x8(%r8,%rsi,1)
movd   %xmm2,0xc(%r8,%rsi,1)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1350 <addition+0x250>
test   $0x1,%bl
je     13f6 <addition+0x2f6>
movdqa 0xc37(%rip),%xmm0
movdqa -0x30(%rsp,%rsi,4),%xmm1
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
pand   -0x20(%rsp,%rsi,4),%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movd   %xmm1,(%r8,%rsi,1)
movd   %xmm0,0x4(%r8,%rsi,1)
cmp    %rcx,%rdx
je     1412 <addition+0x312>
nopl   0x0(%rax,%rax,1)
movzbl -0x30(%rsp,%rdx,4),%ebx
mov    %bl,(%r8,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1400 <addition+0x300>
pop    %rbx
ret
xor    %ecx,%ecx
test   $0x1,%r11b
jne    1219 <addition+0x119>
jmp    1267 <addition+0x167>
xor    %esi,%esi
test   $0x1,%bl
jne    13c1 <addition+0x2c1>
jmp    13f6 <addition+0x2f6>

LLVM IR (-O0):
define i32 @addition(i8* %0, i32 %1, i8* %2, i32 %3, i8* %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [10 x i32]
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
store i8* %4, i8** %10
store i32 0, i32* %12
%15 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 0
%16 = bitcast i32* %15 to i8*
%17 = load i8*, i8** %10
%18 = load i32, i32* %7
%19 = load i32, i32* %9
%20 = icmp sgt i32 %18, %19
br i1 %20, label %21, label %23
21: ; preds = %5
%22 = load i32, i32* %7
store i32 %22, i32* %13
br label %25
23: ; preds = %5
%24 = load i32, i32* %9
store i32 %24, i32* %13
br label %25
25: ; preds = %23, %21
store i32 0, i32* %11
br label %26
26: ; preds = %47, %25
%27 = load i32, i32* %11
%28 = load i32, i32* %13
%29 = icmp sle i32 %27, %28
br i1 %29, label %30, label %50
30: ; preds = %26
%31 = load i8*, i8** %6
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = load i8*, i8** %8
%38 = load i32, i32* %11
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = zext i8 %41 to i32
%43 = add nsw i32 %36, %42
%44 = load i32, i32* %11
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %45
store i32 %43, i32* %46
br label %47
47: ; preds = %30
%48 = load i32, i32* %11
%49 = add nsw i32 %48, 1
store i32 %49, i32* %11
br label %26
50: ; preds = %26
%51 = load i32, i32* %13
%52 = add nsw i32 %51, 1
store i32 %52, i32* %13
store i32 0, i32* %11
br label %53
53: ; preds = %74, %50
%54 = load i32, i32* %11
%55 = load i32, i32* %13
%56 = icmp sle i32 %54, %55
br i1 %56, label %57, label %77
57: ; preds = %53
%58 = load i32, i32* %12
%59 = load i32, i32* %11
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %60
%62 = load i32, i32* %61
%63 = add i32 %62, %58
store i32 %63, i32* %61
%64 = load i32, i32* %11
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %65
%67 = load i32, i32* %66
%68 = udiv i32 %67, 256
store i32 %68, i32* %12
%69 = load i32, i32* %11
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %70
%72 = load i32, i32* %71
%73 = and i32 %72, 255
store i32 %73, i32* %71
br label %74
74: ; preds = %57
%75 = load i32, i32* %11
%76 = add nsw i32 %75, 1
store i32 %76, i32* %11
br label %53
77: ; preds = %53
%78 = load i32, i32* %13
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %79
%81 = load i32, i32* %80
%82 = icmp eq i32 %81, 0
br i1 %82, label %83, label %86
83: ; preds = %77
%84 = load i32, i32* %13
%85 = add nsw i32 %84, -1
store i32 %85, i32* %13
br label %86
86: ; preds = %83, %77
store i32 0, i32* %11
br label %87
87: ; preds = %101, %86
%88 = load i32, i32* %11
%89 = load i32, i32* %13
%90 = icmp sle i32 %88, %89
br i1 %90, label %91, label %104
91: ; preds = %87
%92 = load i32, i32* %11
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [10 x i32], [10 x i32]* %14, i64 0, i64 %93
%95 = load i32, i32* %94
%96 = trunc i32 %95 to i8
%97 = load i8*, i8** %10
%98 = load i32, i32* %11
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i8, i8* %97, i64 %99
store i8 %96, i8* %100
br label %101
101: ; preds = %91
%102 = load i32, i32* %11
%103 = add nsw i32 %102, 1
store i32 %103, i32* %11
br label %87
104: ; preds = %87
%105 = load i32, i32* %13
ret i32 %105
}

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