#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 addition(unsigned char *a, int a_len, unsigned char *b, int b_len,
             unsigned char *addres) {
  int i, j, m = 0, k;
  unsigned int *add =
      (unsigned int *)calloc(a_len + b_len, sizeof(unsigned int));
  if (a_len > b_len) {
    for (i = a_len, j = b_len; j >= 0; i--, j--)
      add[i] = a[i] + b[j];
    for (i = i; i >= 0; i--)
      add[i] = a[i];
    k = a_len;
  } else {
    for (i = a_len, j = b_len; i >= 0; i--, j--)
      add[j] = a[i] + b[j];
    for (i = j; i >= 0; i--)
      add[i] = b[i];
    k = b_len;
  }
  k++;
  for (i = 20 - 1; i >= 20 - 1 - k; i--) {
    add[i] += m;
    m = add[i] / 256;
    add[i] &= 0xff;
  }
  if (add[20 - 1 - k] <= 0) {
    add[20 - 1 - k] = 0;
    k--;
  }
  for (i = 20 - 1; i >= 20 - 1 - k; i--)
    addres[i] = add[i];
  return k;
}


x86 assembly (clang, -O0):
<addition>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0xc(%rbp),%edi
add    -0x1c(%rbp),%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    11e3 <addition+0xd3>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     11a3 <addition+0x93>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
add    %eax,%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    115d <addition+0x4d>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     11d8 <addition+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a9 <addition+0x99>
mov    -0xc(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1270 <addition+0x160>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1235 <addition+0x125>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
add    %eax,%edx
mov    -0x40(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    11ef <addition+0xdf>
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     126a <addition+0x15a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    123b <addition+0x12b>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x13,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x13,%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jl     12d7 <addition+0x1c7>
mov    -0x34(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shr    $0x8,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
and    $0xff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1280 <addition+0x170>
mov    -0x40(%rbp),%rax
mov    $0x13,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
ja     130f <addition+0x1ff>
mov    -0x40(%rbp),%rax
mov    $0x13,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movl   $0x13,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x13,%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jl     134f <addition+0x23f>
mov    -0x40(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1316 <addition+0x206>
mov    -0x38(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<addition>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,%r15
mov    %ecx,%r14d
mov    %rdx,%r12
mov    %esi,%r13d
mov    %rdi,%rbx
lea    (%r14,%r13,1),%edi
mov    $0x4,%esi
call   1030 <calloc@plt>
cmp    %r14d,%r13d
jle    1171 <addition+0x61>
mov    %r13d,%ecx
test   %r14d,%r14d
js     148d <addition+0x37d>
movslq %r13d,%rdx
mov    %r14d,%r10d
cmp    $0x7,%r14d
jae    11ab <addition+0x9b>
mov    %rdx,%rcx
test   $0x1,%r10b
je     143a <addition+0x32a>
mov    %r10,%rdx
test   %r10,%r10
jne    1460 <addition+0x350>
jmp    148d <addition+0x37d>
mov    %r14d,%ecx
test   %r13d,%r13d
js     162d <addition+0x51d>
mov    %r13d,%r10d
movslq %r14d,%rsi
cmp    $0x7,%r13d
jae    12ec <addition+0x1dc>
mov    %rsi,%rcx
test   $0x1,%r10b
je     15d5 <addition+0x4c5>
mov    %r10,%rdx
test   %r10,%r10
jne    1600 <addition+0x4f0>
jmp    162d <addition+0x51d>
mov    %rdx,%rcx
sub    %r10,%rcx
lea    (%rax,%rcx,4),%rsi
lea    (%rax,%rdx,4),%rdi
add    $0x4,%rdi
add    %rbx,%rcx
lea    (%rbx,%rdx,1),%r8
add    $0x1,%r8
lea    (%r10,%r12,1),%r9
add    $0x1,%r9
cmp    %rsi,%r8
seta   %r8b
cmp    %rdi,%rcx
setb   %r11b
cmp    %rsi,%r9
seta   %cl
cmp    %r12,%rdi
seta   %sil
test   %r11b,%r8b
jne    142d <addition+0x31d>
and    %sil,%cl
jne    1153 <addition+0x43>
lea    0x1(%r10),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
mov    %rdx,%rcx
sub    %r9,%rcx
mov    %r9,%r11
neg    %r11
lea    (%rbx,%rdx,1),%r14
add    $0xfffffffffffffffd,%r14
lea    (%rax,%rdx,4),%rdx
add    $0xfffffffffffffff4,%rdx
lea    (%r10,%r12,1),%rdi
add    $0xfffffffffffffffd,%rdi
sub    %r9,%r10
xor    %esi,%esi
movdqa 0xdc7(%rip),%xmm0
nopl   0x0(%rax)
movd   (%r14,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x4(%r14,%rsi,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pand   %xmm0,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xe7,%xmm2,%xmm2
pshufhw $0xc5,%xmm2,%xmm2
pand   %xmm0,%xmm2
movd   (%rdi,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
movd   -0x4(%rdi,%rsi,1),%xmm4
punpcklbw %xmm4,%xmm4
pshufd $0xc4,%xmm3,%xmm3
pshuflw $0xe7,%xmm3,%xmm3
pshufhw $0xc5,%xmm3,%xmm3
pand   %xmm0,%xmm3
paddd  %xmm1,%xmm3
pshufd $0xc4,%xmm4,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pand   %xmm0,%xmm1
paddd  %xmm2,%xmm1
pshufd $0x1b,%xmm3,%xmm2
movdqu %xmm2,(%rdx,%rsi,4)
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x10(%rdx,%rsi,4)
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%r11
jne    1240 <addition+0x130>
cmp    %r9,%r8
jne    1430 <addition+0x320>
jmp    148d <addition+0x37d>
mov    %rsi,%rdx
sub    %r10,%rdx
lea    (%rax,%rdx,4),%r11
lea    (%r10,%rbx,1),%rdi
add    $0x1,%rdi
add    %r12,%rdx
cmp    %r11,%rdi
seta   %r8b
lea    (%rax,%rsi,4),%rdi
add    $0x4,%rdi
cmp    %rbx,%rdi
seta   %r9b
lea    (%r12,%rsi,1),%rcx
add    $0x1,%rcx
cmp    %r11,%rcx
seta   %cl
cmp    %rdi,%rdx
setb   %dl
test   %r9b,%r8b
jne    15c8 <addition+0x4b8>
and    %dl,%cl
jne    118d <addition+0x7d>
lea    0x1(%r10),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
mov    %rsi,%rcx
sub    %r9,%rcx
mov    %r9,%r11
neg    %r11
lea    (%r10,%rbx,1),%r13
add    $0xfffffffffffffffd,%r13
sub    %r9,%r10
lea    (%r12,%rsi,1),%rdx
add    $0xfffffffffffffffd,%rdx
lea    (%rax,%rsi,4),%rdi
add    $0xfffffffffffffff4,%rdi
xor    %esi,%esi
movdqa 0xc88(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movd   0x0(%r13,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x4(%r13,%rsi,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pand   %xmm0,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xe7,%xmm2,%xmm2
pshufhw $0xc5,%xmm2,%xmm2
pand   %xmm0,%xmm2
movd   (%rdx,%rsi,1),%xmm3
punpcklbw %xmm3,%xmm3
movd   -0x4(%rdx,%rsi,1),%xmm4
punpcklbw %xmm4,%xmm4
pshufd $0xc4,%xmm3,%xmm3
pshuflw $0xe7,%xmm3,%xmm3
pshufhw $0xc5,%xmm3,%xmm3
pand   %xmm0,%xmm3
paddd  %xmm1,%xmm3
pshufd $0xc4,%xmm4,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pand   %xmm0,%xmm1
paddd  %xmm2,%xmm1
pshufd $0x1b,%xmm3,%xmm2
movdqu %xmm2,(%rdi,%rsi,4)
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x10(%rdi,%rsi,4)
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%r11
jne    1380 <addition+0x270>
cmp    %r9,%r8
jne    15cb <addition+0x4bb>
jmp    162d <addition+0x51d>
mov    %rdx,%rcx
test   $0x1,%r10b
jne    1160 <addition+0x50>
movzbl (%rbx,%rcx,1),%edx
movzbl (%r12,%r10,1),%esi
add    %edx,%esi
mov    %esi,(%rax,%rcx,4)
add    $0xffffffffffffffff,%rcx
lea    -0x1(%r10),%rdx
test   %r10,%r10
je     148d <addition+0x37d>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rcx,1),%esi
movzbl (%r12,%rdx,1),%edi
add    %esi,%edi
mov    %edi,(%rax,%rcx,4)
movzbl -0x1(%rbx,%rcx,1),%esi
movzbl -0x1(%r12,%rdx,1),%edi
add    %esi,%edi
mov    %edi,-0x4(%rax,%rcx,4)
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffffffffffe,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1460 <addition+0x350>
test   %ecx,%ecx
js     15c0 <addition+0x4b0>
mov    %ecx,%esi
cmp    $0x7,%ecx
jb     14b6 <addition+0x3a6>
lea    (%rbx,%rsi,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    1521 <addition+0x411>
lea    (%rax,%rsi,4),%rcx
add    $0x4,%rcx
cmp    %rbx,%rcx
jbe    1521 <addition+0x411>
mov    %rsi,%r10
lea    0x1(%r10),%ecx
mov    %r10,%rdx
and    $0x3,%rcx
je     14e1 <addition+0x3d1>
mov    %r10,%rdx
nopl   0x0(%rax)
movzbl (%rbx,%rdx,1),%esi
mov    %esi,(%rax,%rdx,4)
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rcx
jne    14d0 <addition+0x3c0>
cmp    $0x3,%r10
jb     15c0 <addition+0x4b0>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%ecx
mov    %ecx,(%rax,%rdx,4)
movzbl -0x1(%rbx,%rdx,1),%ecx
mov    %ecx,-0x4(%rax,%rdx,4)
movzbl -0x2(%rbx,%rdx,1),%ecx
mov    %ecx,-0x8(%rax,%rdx,4)
movzbl -0x3(%rbx,%rdx,1),%ecx
mov    %ecx,-0xc(%rax,%rdx,4)
add    $0xfffffffffffffffc,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    14f0 <addition+0x3e0>
jmp    15c0 <addition+0x4b0>
lea    0x1(%rsi),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
mov    %rsi,%r10
sub    %r9,%r10
mov    %r9,%rdi
neg    %rdi
lea    (%rbx,%rsi,1),%rdx
add    $0xfffffffffffffffd,%rdx
lea    (%rax,%rsi,4),%rsi
add    $0xfffffffffffffff4,%rsi
xor    %ecx,%ecx
movdqa 0xaae(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdx,%rcx,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x4(%rdx,%rcx,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xe7,%xmm2,%xmm2
pshufhw $0xc5,%xmm2,%xmm2
pshufd $0x1b,%xmm1,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,(%rsi,%rcx,4)
pshufd $0x1b,%xmm2,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,-0x10(%rsi,%rcx,4)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%rdi
jne    1560 <addition+0x450>
cmp    %r9,%r8
jne    14b9 <addition+0x3a9>
mov    %r13d,%r14d
jmp    1760 <addition+0x650>
mov    %rsi,%rcx
test   $0x1,%r10b
jne    119a <addition+0x8a>
movzbl (%rbx,%r10,1),%edx
movzbl (%r12,%rcx,1),%esi
add    %edx,%esi
mov    %esi,(%rax,%rcx,4)
lea    -0x1(%r10),%rdx
add    $0xffffffffffffffff,%rcx
test   %r10,%r10
je     162d <addition+0x51d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rdx,1),%esi
movzbl (%r12,%rcx,1),%edi
add    %esi,%edi
mov    %edi,(%rax,%rcx,4)
movzbl -0x1(%rbx,%rdx,1),%esi
movzbl -0x1(%r12,%rcx,1),%edi
add    %esi,%edi
mov    %edi,-0x4(%rax,%rcx,4)
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffffffffffe,%rcx
cmp    $0xffffffffffffffff,%rdx
jne    1600 <addition+0x4f0>
test   %ecx,%ecx
js     1760 <addition+0x650>
mov    %ecx,%edx
cmp    $0x7,%ecx
jb     1656 <addition+0x546>
lea    (%r12,%rdx,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    16c5 <addition+0x5b5>
lea    (%rax,%rdx,4),%rcx
add    $0x4,%rcx
cmp    %r12,%rcx
jbe    16c5 <addition+0x5b5>
mov    %rdx,%rcx
lea    0x1(%rcx),%esi
mov    %rcx,%rdx
and    $0x3,%rsi
je     1682 <addition+0x572>
mov    %rcx,%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rdx,1),%edi
mov    %edi,(%rax,%rdx,4)
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rsi
jne    1670 <addition+0x560>
cmp    $0x3,%rcx
jb     1760 <addition+0x650>
nopl   0x0(%rax)
movzbl (%r12,%rdx,1),%ecx
mov    %ecx,(%rax,%rdx,4)
movzbl -0x1(%r12,%rdx,1),%ecx
mov    %ecx,-0x4(%rax,%rdx,4)
movzbl -0x2(%r12,%rdx,1),%ecx
mov    %ecx,-0x8(%rax,%rdx,4)
movzbl -0x3(%r12,%rdx,1),%ecx
mov    %ecx,-0xc(%rax,%rdx,4)
add    $0xfffffffffffffffc,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1690 <addition+0x580>
jmp    1760 <addition+0x650>
lea    0x1(%rdx),%r8
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
mov    %rdx,%rcx
sub    %r9,%rcx
mov    %r9,%rdi
neg    %rdi
lea    (%r12,%rdx,1),%rbx
add    $0xfffffffffffffffd,%rbx
lea    (%rax,%rdx,4),%rdx
add    $0xfffffffffffffff4,%rdx
xor    %esi,%esi
movdqa 0x90a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movd   (%rbx,%rsi,1),%xmm1
punpcklbw %xmm1,%xmm1
movd   -0x4(%rbx,%rsi,1),%xmm2
punpcklbw %xmm2,%xmm2
pshufd $0xc4,%xmm1,%xmm1
pshuflw $0xe7,%xmm1,%xmm1
pshufhw $0xc5,%xmm1,%xmm1
pshufd $0xc4,%xmm2,%xmm2
pshuflw $0xe7,%xmm2,%xmm2
pshufhw $0xc5,%xmm2,%xmm2
pshufd $0x1b,%xmm1,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,(%rdx,%rsi,4)
pshufd $0x1b,%xmm2,%xmm1
pand   %xmm0,%xmm1
movdqu %xmm1,-0x10(%rdx,%rsi,4)
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rdi
jne    1700 <addition+0x5f0>
cmp    %r9,%r8
jne    1659 <addition+0x549>
mov    $0x12,%ecx
sub    %r14d,%ecx
cmp    $0x14,%ecx
jl     1772 <addition+0x662>
mov    %ecx,%r8d
jmp    17dd <addition+0x6cd>
movslq %ecx,%r8
mov    $0x14,%ebx
sub    %r8,%rbx
cmp    $0xffffffff,%r14d
je     18d0 <addition+0x7c0>
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %edi,%edi
mov    $0x13,%esi
cs nopw 0x0(%rax,%rax,1)
nop
add    (%rax,%rsi,4),%edi
movzbl %dil,%ecx
shr    $0x8,%edi
mov    %ecx,(%rax,%rsi,4)
add    -0x4(%rax,%rsi,4),%edi
movzbl %dil,%ecx
shr    $0x8,%edi
mov    %ecx,-0x4(%rax,%rsi,4)
lea    (%rdx,%rsi,1),%rcx
add    $0xfffffffffffffffe,%rcx
add    $0xfffffffffffffffe,%rsi
cmp    $0x13,%rcx
jne    17a0 <addition+0x690>
test   $0x1,%bl
je     17dd <addition+0x6cd>
add    (%rax,%rsi,4),%edi
movzbl %dil,%ecx
mov    %ecx,(%rax,%rsi,4)
cmpl   $0x0,(%rax,%r8,4)
je     17f2 <addition+0x6e2>
add    $0x1,%r14d
test   %r14d,%r14d
jns    1803 <addition+0x6f3>
jmp    18c3 <addition+0x7b3>
movl   $0x0,(%rax,%r8,4)
test   %r14d,%r14d
js     18c3 <addition+0x7b3>
mov    $0x13,%ecx
sub    %r14d,%ecx
movslq %ecx,%rcx
movslq %r14d,%rsi
add    $0x1,%rsi
mov    $0x13,%edx
cmp    $0x8,%rsi
jb     18a0 <addition+0x790>
lea    (%r15,%rcx,1),%rdi
lea    0x50(%rax),%rbx
cmp    %rbx,%rdi
jae    183e <addition+0x72e>
lea    0x14(%r15),%rdi
lea    (%rax,%rcx,4),%rbx
cmp    %rbx,%rdi
ja     18a0 <addition+0x790>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
mov    $0x13,%edx
sub    %r8,%rdx
mov    %r8,%rdi
neg    %rdi
xor    %ebx,%ebx
movdqa 0x7a3(%rip),%xmm0
nopl   (%rax)
movdqu 0x30(%rax,%rbx,4),%xmm1
movdqu 0x40(%rax,%rbx,4),%xmm2
pand   %xmm0,%xmm2
packuswb %xmm2,%xmm2
packuswb %xmm2,%xmm2
movd   %xmm2,0x10(%r15,%rbx,1)
pand   %xmm0,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm1,0xc(%r15,%rbx,1)
add    $0xfffffffffffffff8,%rbx
cmp    %rbx,%rdi
jne    1860 <addition+0x750>
cmp    %r8,%rsi
je     18c3 <addition+0x7b3>
add    $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x4(%rax,%rdx,4),%ebx
mov    %bl,-0x1(%r15,%rdx,1)
add    $0xffffffffffffffff,%rdx
cmp    %rcx,%rdx
jg     18b0 <addition+0x7a0>
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xor    %edi,%edi
mov    $0x13,%esi
test   $0x1,%bl
jne    17d3 <addition+0x6c3>
jmp    17dd <addition+0x6cd>

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 i32
%15 = alloca 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* %13
%16 = load i32, i32* %7
%17 = load i32, i32* %9
%18 = add nsw i32 %16, %17
%19 = call i64 @calloc(i32 %18, i32 4)
%20 = inttoptr i64 %19 to i32*
store i32* %20, i32** %15
%21 = load i32, i32* %7
%22 = load i32, i32* %9
%23 = icmp sgt i32 %21, %22
br i1 %23, label %24, label %74
24: ; preds = %5
%25 = load i32, i32* %7
store i32 %25, i32* %11
%26 = load i32, i32* %9
store i32 %26, i32* %12
br label %27
27: ; preds = %48, %24
%28 = load i32, i32* %12
%29 = icmp sge i32 %28, 0
br i1 %29, label %30, label %53
30: ; preds = %27
%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* %12
%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** %15
%45 = load i32, i32* %11
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i32, i32* %44, i64 %46
store i32 %43, i32* %47
br label %48
48: ; preds = %30
%49 = load i32, i32* %11
%50 = add nsw i32 %49, -1
store i32 %50, i32* %11
%51 = load i32, i32* %12
%52 = add nsw i32 %51, -1
store i32 %52, i32* %12
br label %27
53: ; preds = %27
%54 = load i32, i32* %11
store i32 %54, i32* %11
br label %55
55: ; preds = %69, %53
%56 = load i32, i32* %11
%57 = icmp sge i32 %56, 0
br i1 %57, label %58, label %72
58: ; preds = %55
%59 = load i8*, i8** %6
%60 = load i32, i32* %11
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %59, i64 %61
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = load i32*, i32** %15
%66 = load i32, i32* %11
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
store i32 %64, i32* %68
br label %69
69: ; preds = %58
%70 = load i32, i32* %11
%71 = add nsw i32 %70, -1
store i32 %71, i32* %11
br label %55
72: ; preds = %55
%73 = load i32, i32* %7
store i32 %73, i32* %14
br label %124
74: ; preds = %5
%75 = load i32, i32* %7
store i32 %75, i32* %11
%76 = load i32, i32* %9
store i32 %76, i32* %12
br label %77
77: ; preds = %98, %74
%78 = load i32, i32* %11
%79 = icmp sge i32 %78, 0
br i1 %79, label %80, label %103
80: ; preds = %77
%81 = load i8*, i8** %6
%82 = load i32, i32* %11
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i8, i8* %81, i64 %83
%85 = load i8, i8* %84
%86 = zext i8 %85 to i32
%87 = load i8*, i8** %8
%88 = load i32, i32* %12
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i8, i8* %87, i64 %89
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = add nsw i32 %86, %92
%94 = load i32*, i32** %15
%95 = load i32, i32* %12
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %94, i64 %96
store i32 %93, i32* %97
br label %98
98: ; preds = %80
%99 = load i32, i32* %11
%100 = add nsw i32 %99, -1
store i32 %100, i32* %11
%101 = load i32, i32* %12
%102 = add nsw i32 %101, -1
store i32 %102, i32* %12
br label %77
103: ; preds = %77
%104 = load i32, i32* %12
store i32 %104, i32* %11
br label %105
105: ; preds = %119, %103
%106 = load i32, i32* %11
%107 = icmp sge i32 %106, 0
br i1 %107, label %108, label %122
108: ; preds = %105
%109 = load i8*, i8** %8
%110 = load i32, i32* %11
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %109, i64 %111
%113 = load i8, i8* %112
%114 = zext i8 %113 to i32
%115 = load i32*, i32** %15
%116 = load i32, i32* %11
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %115, i64 %117
store i32 %114, i32* %118
br label %119
119: ; preds = %108
%120 = load i32, i32* %11
%121 = add nsw i32 %120, -1
store i32 %121, i32* %11
br label %105
122: ; preds = %105
%123 = load i32, i32* %9
store i32 %123, i32* %14
br label %124
124: ; preds = %122, %72
%125 = load i32, i32* %14
%126 = add nsw i32 %125, 1
store i32 %126, i32* %14
store i32 19, i32* %11
br label %127
127: ; preds = %152, %124
%128 = load i32, i32* %11
%129 = load i32, i32* %14
%130 = sub nsw i32 19, %129
%131 = icmp sge i32 %128, %130
br i1 %131, label %132, label %155
132: ; preds = %127
%133 = load i32, i32* %13
%134 = load i32*, i32** %15
%135 = load i32, i32* %11
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %134, i64 %136
%138 = load i32, i32* %137
%139 = add i32 %138, %133
store i32 %139, i32* %137
%140 = load i32*, i32** %15
%141 = load i32, i32* %11
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i32, i32* %140, i64 %142
%144 = load i32, i32* %143
%145 = udiv i32 %144, 256
store i32 %145, i32* %13
%146 = load i32*, i32** %15
%147 = load i32, i32* %11
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
%150 = load i32, i32* %149
%151 = and i32 %150, 255
store i32 %151, i32* %149
br label %152
152: ; preds = %132
%153 = load i32, i32* %11
%154 = add nsw i32 %153, -1
store i32 %154, i32* %11
br label %127
155: ; preds = %127
%156 = load i32*, i32** %15
%157 = load i32, i32* %14
%158 = sub nsw i32 19, %157
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %156, i64 %159
%161 = load i32, i32* %160
%162 = icmp ule i32 %161, 0
br i1 %162, label %163, label %171
163: ; preds = %155
%164 = load i32*, i32** %15
%165 = load i32, i32* %14
%166 = sub nsw i32 19, %165
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %164, i64 %167
store i32 0, i32* %168
%169 = load i32, i32* %14
%170 = add nsw i32 %169, -1
store i32 %170, i32* %14
br label %171
171: ; preds = %163, %155
store i32 19, i32* %11
br label %172
172: ; preds = %188, %171
%173 = load i32, i32* %11
%174 = load i32, i32* %14
%175 = sub nsw i32 19, %174
%176 = icmp sge i32 %173, %175
br i1 %176, label %177, label %191
177: ; preds = %172
%178 = load i32*, i32** %15
%179 = load i32, i32* %11
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %178, i64 %180
%182 = load i32, i32* %181
%183 = trunc i32 %182 to i8
%184 = load i8*, i8** %10
%185 = load i32, i32* %11
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %184, i64 %186
store i8 %183, i8* %187
br label %188
188: ; preds = %177
%189 = load i32, i32* %11
%190 = add nsw i32 %189, -1
store i32 %190, i32* %11
br label %172
191: ; preds = %172
%192 = load i32, i32* %14
ret i32 %192
}

LLVM IR (-O2):
define i32 @addition(i8* nocapture %0, i32 %1, i8* nocapture %2, i32 %3, i8* nocapture writeonly %4) {
%6 = add nsw i32 %3, %1
%7 = tail call i64 @calloc(i32 %6, i32 4)
%8 = inttoptr i64 %7 to i32*
%9 = inttoptr i64 %7 to i8*
%10 = icmp sgt i32 %1, %3
br i1 %10, label %103, label %11
11: ; preds = %5
%12 = icmp sgt i32 %1, -1
br i1 %12, label %13, label %311
13: ; preds = %11
%14 = zext i32 %1 to i64
%15 = sext i32 %3 to i64
%16 = add nuw nsw i64 %14, 1
%17 = icmp ult i32 %1, 7
br i1 %17, label %82, label %18
18: ; preds = %13
%19 = sub nsw i64 %15, %14
%20 = getelementptr i32, i32* %8, i64 %19
%21 = bitcast i32* %20 to i8*
%22 = add nsw i64 %15, 1
%23 = getelementptr i32, i32* %8, i64 %22
%24 = bitcast i32* %23 to i8*
%25 = add nuw nsw i64 %14, 1
%26 = getelementptr i8, i8* %0, i64 %25
%27 = getelementptr i8, i8* %2, i64 %19
%28 = getelementptr i8, i8* %2, i64 %22
%29 = icmp ugt i8* %26, %21
%30 = icmp ugt i8* %24, %0
%31 = and i1 %29, %30
%32 = icmp ugt i8* %28, %21
%33 = icmp ult i8* %27, %24
%34 = and i1 %32, %33
%35 = or i1 %31, %34
br i1 %35, label %82, label %36
36: ; preds = %18
%37 = and i64 %16, 8589934584
%38 = sub nsw i64 %15, %37
%39 = sub nsw i64 %14, %37
br label %40
40: ; preds = %40, %36
%41 = phi i64 [ 0, %36 ], [ %78, %40 ]
%42 = sub i64 %15, %41
%43 = sub i64 %14, %41
%44 = getelementptr inbounds i8, i8* %0, i64 %43
%45 = getelementptr inbounds i8, i8* %44, i64 -3
%46 = bitcast i8* %45 to <4 x i8>*
%47 = load <4 x i8>, <4 x i8>* %46
%48 = shufflevector <4 x i8> %47, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%49 = getelementptr inbounds i8, i8* %44, i64 -4
%50 = getelementptr inbounds i8, i8* %49, i64 -3
%51 = bitcast i8* %50 to <4 x i8>*
%52 = load <4 x i8>, <4 x i8>* %51
%53 = shufflevector <4 x i8> %52, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%54 = zext <4 x i8> %48 to <4 x i32>
%55 = zext <4 x i8> %53 to <4 x i32>
%56 = getelementptr inbounds i8, i8* %2, i64 %42
%57 = getelementptr inbounds i8, i8* %56, i64 -3
%58 = bitcast i8* %57 to <4 x i8>*
%59 = load <4 x i8>, <4 x i8>* %58
%60 = shufflevector <4 x i8> %59, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%61 = getelementptr inbounds i8, i8* %56, i64 -4
%62 = getelementptr inbounds i8, i8* %61, i64 -3
%63 = bitcast i8* %62 to <4 x i8>*
%64 = load <4 x i8>, <4 x i8>* %63
%65 = shufflevector <4 x i8> %64, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%66 = zext <4 x i8> %60 to <4 x i32>
%67 = zext <4 x i8> %65 to <4 x i32>
%68 = add nuw nsw <4 x i32> %66, %54
%69 = add nuw nsw <4 x i32> %67, %55
%70 = getelementptr inbounds i32, i32* %8, i64 %42
%71 = shufflevector <4 x i32> %68, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%72 = getelementptr inbounds i32, i32* %70, i64 -3
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %73
%74 = shufflevector <4 x i32> %69, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%75 = getelementptr inbounds i32, i32* %70, i64 -4
%76 = getelementptr inbounds i32, i32* %75, i64 -3
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> %74, <4 x i32>* %77
%78 = add nuw i64 %41, 8
%79 = icmp eq i64 %78, %37
br i1 %79, label %80, label %40
80: ; preds = %40
%81 = icmp eq i64 %16, %37
br i1 %81, label %308, label %82
82: ; preds = %18, %13, %80
%83 = phi i64 [ %15, %18 ], [ %15, %13 ], [ %38, %80 ]
%84 = phi i64 [ %14, %18 ], [ %14, %13 ], [ %39, %80 ]
%85 = and i64 %84, 1
%86 = icmp eq i64 %85, 0
br i1 %86, label %87, label %98
87: ; preds = %82
%88 = getelementptr inbounds i8, i8* %0, i64 %84
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = getelementptr inbounds i8, i8* %2, i64 %83
%92 = load i8, i8* %91
%93 = zext i8 %92 to i32
%94 = add nuw nsw i32 %93, %90
%95 = getelementptr inbounds i32, i32* %8, i64 %83
store i32 %94, i32* %95
%96 = add nsw i64 %84, -1
%97 = add nsw i64 %83, -1
br label %98
98: ; preds = %87, %82
%99 = phi i64 [ undef, %82 ], [ %97, %87 ]
%100 = phi i64 [ %83, %82 ], [ %97, %87 ]
%101 = phi i64 [ %84, %82 ], [ %96, %87 ]
%102 = icmp eq i64 %84, 0
br i1 %102, label %308, label %374
103: ; preds = %5
%104 = icmp sgt i32 %3, -1
br i1 %104, label %105, label %198
105: ; preds = %103
%106 = sext i32 %1 to i64
%107 = zext i32 %3 to i64
%108 = add nuw nsw i64 %107, 1
%109 = icmp ult i32 %3, 7
br i1 %109, label %174, label %110
110: ; preds = %105
%111 = sub nsw i64 %106, %107
%112 = getelementptr i32, i32* %8, i64 %111
%113 = bitcast i32* %112 to i8*
%114 = add nsw i64 %106, 1
%115 = getelementptr i32, i32* %8, i64 %114
%116 = bitcast i32* %115 to i8*
%117 = getelementptr i8, i8* %0, i64 %111
%118 = getelementptr i8, i8* %0, i64 %114
%119 = add nuw nsw i64 %107, 1
%120 = getelementptr i8, i8* %2, i64 %119
%121 = icmp ugt i8* %118, %113
%122 = icmp ult i8* %117, %116
%123 = and i1 %121, %122
%124 = icmp ugt i8* %120, %113
%125 = icmp ugt i8* %116, %2
%126 = and i1 %124, %125
%127 = or i1 %123, %126
br i1 %127, label %174, label %128
128: ; preds = %110
%129 = and i64 %108, 8589934584
%130 = sub nsw i64 %107, %129
%131 = sub nsw i64 %106, %129
br label %132
132: ; preds = %132, %128
%133 = phi i64 [ 0, %128 ], [ %170, %132 ]
%134 = sub i64 %107, %133
%135 = sub i64 %106, %133
%136 = getelementptr inbounds i8, i8* %0, i64 %135
%137 = getelementptr inbounds i8, i8* %136, i64 -3
%138 = bitcast i8* %137 to <4 x i8>*
%139 = load <4 x i8>, <4 x i8>* %138
%140 = shufflevector <4 x i8> %139, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%141 = getelementptr inbounds i8, i8* %136, i64 -4
%142 = getelementptr inbounds i8, i8* %141, i64 -3
%143 = bitcast i8* %142 to <4 x i8>*
%144 = load <4 x i8>, <4 x i8>* %143
%145 = shufflevector <4 x i8> %144, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%146 = zext <4 x i8> %140 to <4 x i32>
%147 = zext <4 x i8> %145 to <4 x i32>
%148 = getelementptr inbounds i8, i8* %2, i64 %134
%149 = getelementptr inbounds i8, i8* %148, i64 -3
%150 = bitcast i8* %149 to <4 x i8>*
%151 = load <4 x i8>, <4 x i8>* %150
%152 = shufflevector <4 x i8> %151, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%153 = getelementptr inbounds i8, i8* %148, i64 -4
%154 = getelementptr inbounds i8, i8* %153, i64 -3
%155 = bitcast i8* %154 to <4 x i8>*
%156 = load <4 x i8>, <4 x i8>* %155
%157 = shufflevector <4 x i8> %156, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%158 = zext <4 x i8> %152 to <4 x i32>
%159 = zext <4 x i8> %157 to <4 x i32>
%160 = add nuw nsw <4 x i32> %158, %146
%161 = add nuw nsw <4 x i32> %159, %147
%162 = getelementptr inbounds i32, i32* %8, i64 %135
%163 = shufflevector <4 x i32> %160, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%164 = getelementptr inbounds i32, i32* %162, i64 -3
%165 = bitcast i32* %164 to <4 x i32>*
store <4 x i32> %163, <4 x i32>* %165
%166 = shufflevector <4 x i32> %161, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%167 = getelementptr inbounds i32, i32* %162, i64 -4
%168 = getelementptr inbounds i32, i32* %167, i64 -3
%169 = bitcast i32* %168 to <4 x i32>*
store <4 x i32> %166, <4 x i32>* %169
%170 = add nuw i64 %133, 8
%171 = icmp eq i64 %170, %129
br i1 %171, label %172, label %132
172: ; preds = %132
%173 = icmp eq i64 %108, %129
br i1 %173, label %195, label %174
174: ; preds = %110, %105, %172
%175 = phi i64 [ %107, %110 ], [ %107, %105 ], [ %130, %172 ]
%176 = phi i64 [ %106, %110 ], [ %106, %105 ], [ %131, %172 ]
%177 = and i64 %175, 1
%178 = icmp eq i64 %177, 0
br i1 %178, label %179, label %190
179: ; preds = %174
%180 = getelementptr inbounds i8, i8* %0, i64 %176
%181 = load i8, i8* %180
%182 = zext i8 %181 to i32
%183 = getelementptr inbounds i8, i8* %2, i64 %175
%184 = load i8, i8* %183
%185 = zext i8 %184 to i32
%186 = add nuw nsw i32 %185, %182
%187 = getelementptr inbounds i32, i32* %8, i64 %176
store i32 %186, i32* %187
%188 = add nsw i64 %176, -1
%189 = add nsw i64 %175, -1
br label %190
190: ; preds = %179, %174
%191 = phi i64 [ undef, %174 ], [ %188, %179 ]
%192 = phi i64 [ %175, %174 ], [ %189, %179 ]
%193 = phi i64 [ %176, %174 ], [ %188, %179 ]
%194 = icmp eq i64 %175, 0
br i1 %194, label %195, label %261
195: ; preds = %190, %261, %172
%196 = phi i64 [ %131, %172 ], [ %191, %190 ], [ %282, %261 ]
%197 = trunc i64 %196 to i32
br label %198
198: ; preds = %195, %103
%199 = phi i32 [ %1, %103 ], [ %197, %195 ]
%200 = icmp sgt i32 %199, -1
br i1 %200, label %201, label %421
201: ; preds = %198
%202 = zext i32 %199 to i64
%203 = add nuw nsw i64 %202, 1
%204 = icmp ult i32 %199, 7
br i1 %204, label %243, label %205
205: ; preds = %201
%206 = add nuw nsw i64 %202, 1
%207 = getelementptr i32, i32* %8, i64 %206
%208 = bitcast i32* %207 to i8*
%209 = getelementptr i8, i8* %0, i64 %206
%210 = icmp ugt i8* %209, %9
%211 = icmp ugt i8* %208, %0
%212 = and i1 %210, %211
br i1 %212, label %243, label %213
213: ; preds = %205
%214 = and i64 %203, 8589934584
%215 = sub nsw i64 %202, %214
br label %216
216: ; preds = %216, %213
%217 = phi i64 [ 0, %213 ], [ %239, %216 ]
%218 = sub i64 %202, %217
%219 = getelementptr inbounds i8, i8* %0, i64 %218
%220 = getelementptr inbounds i8, i8* %219, i64 -3
%221 = bitcast i8* %220 to <4 x i8>*
%222 = load <4 x i8>, <4 x i8>* %221
%223 = shufflevector <4 x i8> %222, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%224 = getelementptr inbounds i8, i8* %219, i64 -4
%225 = getelementptr inbounds i8, i8* %224, i64 -3
%226 = bitcast i8* %225 to <4 x i8>*
%227 = load <4 x i8>, <4 x i8>* %226
%228 = shufflevector <4 x i8> %227, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%229 = zext <4 x i8> %223 to <4 x i32>
%230 = zext <4 x i8> %228 to <4 x i32>
%231 = getelementptr inbounds i32, i32* %8, i64 %218
%232 = shufflevector <4 x i32> %229, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%233 = getelementptr inbounds i32, i32* %231, i64 -3
%234 = bitcast i32* %233 to <4 x i32>*
store <4 x i32> %232, <4 x i32>* %234
%235 = shufflevector <4 x i32> %230, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%236 = getelementptr inbounds i32, i32* %231, i64 -4
%237 = getelementptr inbounds i32, i32* %236, i64 -3
%238 = bitcast i32* %237 to <4 x i32>*
store <4 x i32> %235, <4 x i32>* %238
%239 = add nuw i64 %217, 8
%240 = icmp eq i64 %239, %214
br i1 %240, label %241, label %216
241: ; preds = %216
%242 = icmp eq i64 %203, %214
br i1 %242, label %421, label %243
243: ; preds = %205, %201, %241
%244 = phi i64 [ %202, %205 ], [ %202, %201 ], [ %215, %241 ]
%245 = add nsw i64 %244, 1
%246 = and i64 %245, 3
%247 = icmp eq i64 %246, 0
br i1 %247, label %258, label %248
248: ; preds = %243, %248
%249 = phi i64 [ %255, %248 ], [ %244, %243 ]
%250 = phi i64 [ %256, %248 ], [ 0, %243 ]
%251 = getelementptr inbounds i8, i8* %0, i64 %249
%252 = load i8, i8* %251
%253 = zext i8 %252 to i32
%254 = getelementptr inbounds i32, i32* %8, i64 %249
store i32 %253, i32* %254
%255 = add nsw i64 %249, -1
%256 = add i64 %250, 1
%257 = icmp eq i64 %256, %246
br i1 %257, label %258, label %248
258: ; preds = %248, %243
%259 = phi i64 [ %244, %243 ], [ %255, %248 ]
%260 = icmp ult i64 %244, 3
br i1 %260, label %421, label %285
261: ; preds = %190, %261
%262 = phi i64 [ %283, %261 ], [ %192, %190 ]
%263 = phi i64 [ %282, %261 ], [ %193, %190 ]
%264 = getelementptr inbounds i8, i8* %0, i64 %263
%265 = load i8, i8* %264
%266 = zext i8 %265 to i32
%267 = getelementptr inbounds i8, i8* %2, i64 %262
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = add nuw nsw i32 %269, %266
%271 = getelementptr inbounds i32, i32* %8, i64 %263
store i32 %270, i32* %271
%272 = add nsw i64 %263, -1
%273 = add nsw i64 %262, -1
%274 = getelementptr inbounds i8, i8* %0, i64 %272
%275 = load i8, i8* %274
%276 = zext i8 %275 to i32
%277 = getelementptr inbounds i8, i8* %2, i64 %273
%278 = load i8, i8* %277
%279 = zext i8 %278 to i32
%280 = add nuw nsw i32 %279, %276
%281 = getelementptr inbounds i32, i32* %8, i64 %272
store i32 %280, i32* %281
%282 = add nsw i64 %263, -2
%283 = add nsw i64 %262, -2
%284 = icmp eq i64 %273, 0
br i1 %284, label %195, label %261
285: ; preds = %258, %285
%286 = phi i64 [ %306, %285 ], [ %259, %258 ]
%287 = getelementptr inbounds i8, i8* %0, i64 %286
%288 = load i8, i8* %287
%289 = zext i8 %288 to i32
%290 = getelementptr inbounds i32, i32* %8, i64 %286
store i32 %289, i32* %290
%291 = add nsw i64 %286, -1
%292 = getelementptr inbounds i8, i8* %0, i64 %291
%293 = load i8, i8* %292
%294 = zext i8 %293 to i32
%295 = getelementptr inbounds i32, i32* %8, i64 %291
store i32 %294, i32* %295
%296 = add nsw i64 %286, -2
%297 = getelementptr inbounds i8, i8* %0, i64 %296
%298 = load i8, i8* %297
%299 = zext i8 %298 to i32
%300 = getelementptr inbounds i32, i32* %8, i64 %296
store i32 %299, i32* %300
%301 = add nsw i64 %286, -3
%302 = getelementptr inbounds i8, i8* %0, i64 %301
%303 = load i8, i8* %302
%304 = zext i8 %303 to i32
%305 = getelementptr inbounds i32, i32* %8, i64 %301
store i32 %304, i32* %305
%306 = add nsw i64 %286, -4
%307 = icmp eq i64 %301, 0
br i1 %307, label %421, label %285
308: ; preds = %98, %374, %80
%309 = phi i64 [ %38, %80 ], [ %99, %98 ], [ %396, %374 ]
%310 = trunc i64 %309 to i32
br label %311
311: ; preds = %308, %11
%312 = phi i32 [ %3, %11 ], [ %310, %308 ]
%313 = icmp sgt i32 %312, -1
br i1 %313, label %314, label %421
314: ; preds = %311
%315 = zext i32 %312 to i64
%316 = add nuw nsw i64 %315, 1
%317 = icmp ult i32 %312, 7
br i1 %317, label %356, label %318
318: ; preds = %314
%319 = add nuw nsw i64 %315, 1
%320 = getelementptr i32, i32* %8, i64 %319
%321 = bitcast i32* %320 to i8*
%322 = getelementptr i8, i8* %2, i64 %319
%323 = icmp ugt i8* %322, %9
%324 = icmp ugt i8* %321, %2
%325 = and i1 %323, %324
br i1 %325, label %356, label %326
326: ; preds = %318
%327 = and i64 %316, 8589934584
%328 = sub nsw i64 %315, %327
br label %329
329: ; preds = %329, %326
%330 = phi i64 [ 0, %326 ], [ %352, %329 ]
%331 = sub i64 %315, %330
%332 = getelementptr inbounds i8, i8* %2, i64 %331
%333 = getelementptr inbounds i8, i8* %332, i64 -3
%334 = bitcast i8* %333 to <4 x i8>*
%335 = load <4 x i8>, <4 x i8>* %334
%336 = shufflevector <4 x i8> %335, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%337 = getelementptr inbounds i8, i8* %332, i64 -4
%338 = getelementptr inbounds i8, i8* %337, i64 -3
%339 = bitcast i8* %338 to <4 x i8>*
%340 = load <4 x i8>, <4 x i8>* %339
%341 = shufflevector <4 x i8> %340, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%342 = zext <4 x i8> %336 to <4 x i32>
%343 = zext <4 x i8> %341 to <4 x i32>
%344 = getelementptr inbounds i32, i32* %8, i64 %331
%345 = shufflevector <4 x i32> %342, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%346 = getelementptr inbounds i32, i32* %344, i64 -3
%347 = bitcast i32* %346 to <4 x i32>*
store <4 x i32> %345, <4 x i32>* %347
%348 = shufflevector <4 x i32> %343, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%349 = getelementptr inbounds i32, i32* %344, i64 -4
%350 = getelementptr inbounds i32, i32* %349, i64 -3
%351 = bitcast i32* %350 to <4 x i32>*
store <4 x i32> %348, <4 x i32>* %351
%352 = add nuw i64 %330, 8
%353 = icmp eq i64 %352, %327
br i1 %353, label %354, label %329
354: ; preds = %329
%355 = icmp eq i64 %316, %327
br i1 %355, label %421, label %356
356: ; preds = %318, %314, %354
%357 = phi i64 [ %315, %318 ], [ %315, %314 ], [ %328, %354 ]
%358 = add nsw i64 %357, 1
%359 = and i64 %358, 3
%360 = icmp eq i64 %359, 0
br i1 %360, label %371, label %361
361: ; preds = %356, %361
%362 = phi i64 [ %368, %361 ], [ %357, %356 ]
%363 = phi i64 [ %369, %361 ], [ 0, %356 ]
%364 = getelementptr inbounds i8, i8* %2, i64 %362
%365 = load i8, i8* %364
%366 = zext i8 %365 to i32
%367 = getelementptr inbounds i32, i32* %8, i64 %362
store i32 %366, i32* %367
%368 = add nsw i64 %362, -1
%369 = add i64 %363, 1
%370 = icmp eq i64 %369, %359
br i1 %370, label %371, label %361
371: ; preds = %361, %356
%372 = phi i64 [ %357, %356 ], [ %368, %361 ]
%373 = icmp ult i64 %357, 3
br i1 %373, label %421, label %398
374: ; preds = %98, %374
%375 = phi i64 [ %396, %374 ], [ %100, %98 ]
%376 = phi i64 [ %395, %374 ], [ %101, %98 ]
%377 = getelementptr inbounds i8, i8* %0, i64 %376
%378 = load i8, i8* %377
%379 = zext i8 %378 to i32
%380 = getelementptr inbounds i8, i8* %2, i64 %375
%381 = load i8, i8* %380
%382 = zext i8 %381 to i32
%383 = add nuw nsw i32 %382, %379
%384 = getelementptr inbounds i32, i32* %8, i64 %375
store i32 %383, i32* %384
%385 = add nsw i64 %376, -1
%386 = add nsw i64 %375, -1
%387 = getelementptr inbounds i8, i8* %0, i64 %385
%388 = load i8, i8* %387
%389 = zext i8 %388 to i32
%390 = getelementptr inbounds i8, i8* %2, i64 %386
%391 = load i8, i8* %390
%392 = zext i8 %391 to i32
%393 = add nuw nsw i32 %392, %389
%394 = getelementptr inbounds i32, i32* %8, i64 %386
store i32 %393, i32* %394
%395 = add nsw i64 %376, -2
%396 = add nsw i64 %375, -2
%397 = icmp eq i64 %385, 0
br i1 %397, label %308, label %374
398: ; preds = %371, %398
%399 = phi i64 [ %419, %398 ], [ %372, %371 ]
%400 = getelementptr inbounds i8, i8* %2, i64 %399
%401 = load i8, i8* %400
%402 = zext i8 %401 to i32
%403 = getelementptr inbounds i32, i32* %8, i64 %399
store i32 %402, i32* %403
%404 = add nsw i64 %399, -1
%405 = getelementptr inbounds i8, i8* %2, i64 %404
%406 = load i8, i8* %405
%407 = zext i8 %406 to i32
%408 = getelementptr inbounds i32, i32* %8, i64 %404
store i32 %407, i32* %408
%409 = add nsw i64 %399, -2
%410 = getelementptr inbounds i8, i8* %2, i64 %409
%411 = load i8, i8* %410
%412 = zext i8 %411 to i32
%413 = getelementptr inbounds i32, i32* %8, i64 %409
store i32 %412, i32* %413
%414 = add nsw i64 %399, -3
%415 = getelementptr inbounds i8, i8* %2, i64 %414
%416 = load i8, i8* %415
%417 = zext i8 %416 to i32
%418 = getelementptr inbounds i32, i32* %8, i64 %414
store i32 %417, i32* %418
%419 = add nsw i64 %399, -4
%420 = icmp eq i64 %414, 0
br i1 %420, label %421, label %398
421: ; preds = %371, %398, %258, %285, %354, %241, %311, %198
%422 = phi i32 [ %1, %198 ], [ %3, %311 ], [ %1, %241 ], [ %3, %354 ], [ %1, %285 ], [ %1, %258 ], [ %3, %398 ], [ %3, %371 ]
%423 = add nsw i32 %422, 1
%424 = sub i32 18, %422
%425 = icmp sgt i32 %424, 19
br i1 %425, label %426, label %428
426: ; preds = %421
%427 = zext i32 %424 to i64
br label %462
428: ; preds = %421
%429 = sext i32 %424 to i64
%430 = sub nsw i64 20, %429
%431 = and i64 %430, 1
%432 = icmp eq i32 %422, -1
br i1 %432, label %453, label %433
433: ; preds = %428
%434 = and i64 %430, -2
br label %435
435: ; preds = %435, %433
%436 = phi i64 [ 19, %433 ], [ %450, %435 ]
%437 = phi i32 [ 0, %433 ], [ %448, %435 ]
%438 = phi i64 [ 0, %433 ], [ %451, %435 ]
%439 = getelementptr inbounds i32, i32* %8, i64 %436
%440 = load i32, i32* %439
%441 = add i32 %440, %437
%442 = lshr i32 %441, 8
%443 = and i32 %441, 255
store i32 %443, i32* %439
%444 = add nsw i64 %436, -1
%445 = getelementptr inbounds i32, i32* %8, i64 %444
%446 = load i32, i32* %445
%447 = add i32 %446, %442
%448 = lshr i32 %447, 8
%449 = and i32 %447, 255
store i32 %449, i32* %445
%450 = add nsw i64 %436, -2
%451 = add i64 %438, 2
%452 = icmp eq i64 %451, %434
br i1 %452, label %453, label %435
453: ; preds = %435, %428
%454 = phi i64 [ 19, %428 ], [ %450, %435 ]
%455 = phi i32 [ 0, %428 ], [ %448, %435 ]
%456 = icmp eq i64 %431, 0
br i1 %456, label %462, label %457
457: ; preds = %453
%458 = getelementptr inbounds i32, i32* %8, i64 %454
%459 = load i32, i32* %458
%460 = add i32 %459, %455
%461 = and i32 %460, 255
store i32 %461, i32* %458
br label %462
462: ; preds = %457, %453, %426
%463 = phi i64 [ %427, %426 ], [ %429, %453 ], [ %429, %457 ]
%464 = getelementptr inbounds i32, i32* %8, i64 %463
%465 = load i32, i32* %464
%466 = icmp eq i32 %465, 0
br i1 %466, label %467, label %468
467: ; preds = %462
store i32 0, i32* %464
br label %468
468: ; preds = %467, %462
%469 = phi i32 [ %422, %467 ], [ %423, %462 ]
%470 = icmp slt i32 %469, 0
br i1 %470, label %527, label %471
471: ; preds = %468
%472 = sub nsw i32 19, %469
%473 = sext i32 %472 to i64
%474 = sext i32 %469 to i64
%475 = add nsw i64 %474, 1
%476 = icmp ult i64 %475, 8
br i1 %476, label %517, label %477
477: ; preds = %471
%478 = getelementptr i8, i8* %4, i64 %473
%479 = getelementptr i8, i8* %4, i64 20
%480 = getelementptr i32, i32* %8, i64 %473
%481 = bitcast i32* %480 to i8*
%482 = getelementptr i32, i32* %8, i64 20
%483 = bitcast i32* %482 to i8*
%484 = icmp ult i8* %478, %483
%485 = icmp ugt i8* %479, %481
%486 = and i1 %484, %485
br i1 %486, label %517, label %487
487: ; preds = %477
%488 = and i64 %475, -8
%489 = sub nsw i64 19, %488
br label %490
490: ; preds = %490, %487
%491 = phi i64 [ 0, %487 ], [ %513, %490 ]
%492 = sub i64 19, %491
%493 = getelementptr inbounds i32, i32* %8, i64 %492
%494 = getelementptr inbounds i32, i32* %493, i64 -3
%495 = bitcast i32* %494 to <4 x i32>*
%496 = load <4 x i32>, <4 x i32>* %495
%497 = shufflevector <4 x i32> %496, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%498 = getelementptr inbounds i32, i32* %493, i64 -4
%499 = getelementptr inbounds i32, i32* %498, i64 -3
%500 = bitcast i32* %499 to <4 x i32>*
%501 = load <4 x i32>, <4 x i32>* %500
%502 = shufflevector <4 x i32> %501, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%503 = trunc <4 x i32> %497 to <4 x i8>
%504 = trunc <4 x i32> %502 to <4 x i8>
%505 = getelementptr inbounds i8, i8* %4, i64 %492
%506 = shufflevector <4 x i8> %503, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%507 = getelementptr inbounds i8, i8* %505, i64 -3
%508 = bitcast i8* %507 to <4 x i8>*
store <4 x i8> %506, <4 x i8>* %508
%509 = shufflevector <4 x i8> %504, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%510 = getelementptr inbounds i8, i8* %505, i64 -4
%511 = getelementptr inbounds i8, i8* %510, i64 -3
%512 = bitcast i8* %511 to <4 x i8>*
store <4 x i8> %509, <4 x i8>* %512
%513 = add nuw i64 %491, 8
%514 = icmp eq i64 %513, %488
br i1 %514, label %515, label %490
515: ; preds = %490
%516 = icmp eq i64 %475, %488
br i1 %516, label %527, label %517
517: ; preds = %477, %471, %515
%518 = phi i64 [ 19, %477 ], [ 19, %471 ], [ %489, %515 ]
br label %519
519: ; preds = %517, %519
%520 = phi i64 [ %525, %519 ], [ %518, %517 ]
%521 = getelementptr inbounds i32, i32* %8, i64 %520
%522 = load i32, i32* %521
%523 = trunc i32 %522 to i8
%524 = getelementptr inbounds i8, i8* %4, i64 %520
store i8 %523, i8* %524
%525 = add nsw i64 %520, -1
%526 = icmp sgt i64 %520, %473
br i1 %526, label %519, label %527
527: ; preds = %519, %515, %468
ret i32 %469
}