void lsubber(unsigned *pla, unsigned *plb, unsigned *plc, int alen, int blen,
             int *clen) {
  int i;
  unsigned c, nextc;
  unsigned lai;
  i = 0;
  c = nextc = 0;
  while (i < blen) {
    lai = *pla;
    if (lai < (*plb + c)) {
      lai += 4096;
      nextc = 1;
    }
    *plc = lai - (*plb + c);
    c = nextc;
    nextc = 0;
    pla++;
    plb++;
    plc++;
    i++;
  }
  while ((c == 1) && (i < alen)) {
    lai = *pla;
    if (lai == 0) {
      lai = 4096;
      nextc = 1;
    }
    *plc = lai - c;
    c = nextc;
    nextc = 0;
    pla++;
    plc++;
    i++;
  }
  while (i < alen) {
    *plc = *pla;
    plc++;
    pla++;
    i++;
  }
  do {
    i--;
    plc--;
  } while ((i >= 0) && (*plc == 0));
  *clen = i + 1;
}


x86 assembly (clang, -O0):
<lsubber>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11be <lsubber+0xbe>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jae    116b <lsubber+0x6b>
mov    -0x38(%rbp),%eax
add    $0x1000,%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    -0x30(%rbp),%eax
sub    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1130 <lsubber+0x30>
jmp    11c3 <lsubber+0xc3>
xor    %eax,%eax
cmpl   $0x1,-0x30(%rbp)
mov    %al,-0x39(%rbp)
jne    11de <lsubber+0xde>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    11ee <lsubber+0xee>
jmp    124e <lsubber+0x14e>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jne    120f <lsubber+0x10f>
movl   $0x1000,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x38(%rbp),%ecx
sub    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c3 <lsubber+0xc3>
jmp    1253 <lsubber+0x153>
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1291 <lsubber+0x191>
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1253 <lsubber+0x153>
jmp    1296 <lsubber+0x196>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x3a(%rbp)
jl     12c7 <lsubber+0x1c7>
mov    -0x18(%rbp),%rax
cmpl   $0x0,(%rax)
sete   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    1296 <lsubber+0x196>
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<lsubber>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %r8d,%r8d
jle    1124 <lsubber+0x24>
cmp    $0x1,%r8d
jne    112c <lsubber+0x2c>
xor    %eax,%eax
test   $0x1,%r8b
jne    11a5 <lsubber+0xa5>
jmp    11c4 <lsubber+0xc4>
xor    %r8d,%r8d
jmp    11fd <lsubber+0xfd>
mov    %r8d,%r11d
and    $0xfffffffe,%r11d
xor    %ebx,%ebx
xor    %r14d,%r14d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rbx,4),%r10d
add    (%rsi,%rbx,4),%eax
lea    0x1000(%r10),%ebp
cmp    %eax,%r10d
cmovae %r10d,%ebp
sub    %eax,%ebp
cmp    %eax,%r10d
mov    %ebp,(%rdx,%rbx,4)
mov    0x4(%rsi,%rbx,4),%r12d
adc    $0x0,%r12d
mov    0x4(%rdi,%rbx,4),%r15d
lea    0x1000(%r15),%ebp
xor    %eax,%eax
cmp    %r12d,%r15d
setb   %r10b
mov    %r10b,%al
cmovae %r15d,%ebp
sub    %r12d,%ebp
mov    %ebp,0x4(%rdx,%rbx,4)
add    $0xfffffffffffffff8,%r14
add    $0x2,%rbx
cmp    %ebx,%r11d
jne    1140 <lsubber+0x40>
sub    %r14,%rdi
sub    %r14,%rsi
sub    %r14,%rdx
test   $0x1,%r8b
je     11c4 <lsubber+0xc4>
mov    (%rdi),%ebx
add    (%rsi),%eax
lea    0x1000(%rbx),%esi
cmp    %eax,%ebx
setb   %r10b
cmovae %ebx,%esi
sub    %eax,%esi
mov    %esi,(%rdx)
add    $0x4,%rdi
add    $0x4,%rdx
test   $0x1,%r10b
je     11fd <lsubber+0xfd>
cmp    %ecx,%r8d
jge    11fd <lsubber+0xfd>
mov    $0xfff,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi),%esi
add    $0x4,%rdi
add    $0x1,%r8d
sub    $0x1,%esi
cmovb  %eax,%esi
mov    %esi,(%rdx)
lea    0x4(%rdx),%rdx
jae    11fd <lsubber+0xfd>
cmp    %ecx,%r8d
jl     11e0 <lsubber+0xe0>
cmp    %ecx,%r8d
jge    125e <lsubber+0x15e>
mov    %r8d,%r11d
not    %r11d
add    %ecx,%r11d
cmp    $0x7,%r11d
jb     131f <lsubber+0x21f>
lea    (%rdi,%r11,4),%rax
add    $0x4,%rax
cmp    %rax,%rdx
jae    1233 <lsubber+0x133>
lea    (%rdx,%r11,4),%rax
add    $0x4,%rax
cmp    %rax,%rdi
jb     131f <lsubber+0x21f>
add    $0x1,%r11
mov    %r11,%r10
and    $0xfffffffffffffff8,%r10
lea    -0x8(%r10),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r14d
and    $0x3,%r14d
cmp    $0x18,%rax
jae    1266 <lsubber+0x166>
xor    %eax,%eax
jmp    12c8 <lsubber+0x1c8>
mov    %r8d,%ecx
jmp    13b2 <lsubber+0x2b2>
and    $0xfffffffffffffffc,%rsi
xor    %eax,%eax
nopl   0x0(%rax)
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rdi,%rax,4),%xmm0
movups 0x50(%rdi,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rdi,%rax,4),%xmm0
movups 0x70(%rdi,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rsi
jne    1270 <lsubber+0x170>
test   %r14,%r14
je     130b <lsubber+0x20b>
lea    (%rdx,%rax,4),%rsi
add    $0x10,%rsi
lea    (%rdi,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movups %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    12f0 <lsubber+0x1f0>
lea    (%rdx,%r10,4),%rdx
cmp    %r10,%r11
je     13b2 <lsubber+0x2b2>
add    %r10d,%r8d
lea    (%rdi,%r10,4),%rdi
mov    %ecx,%esi
sub    %r8d,%esi
mov    %r8d,%eax
not    %eax
add    %ecx,%eax
and    $0x7,%esi
je     1356 <lsubber+0x256>
neg    %esi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi),%ebp
mov    %ebp,(%rdx)
add    $0x4,%rdx
add    $0x4,%rdi
add    $0xffffffff,%ebx
cmp    %ebx,%esi
jne    1340 <lsubber+0x240>
sub    %ebx,%r8d
cmp    $0x7,%eax
jb     13b2 <lsubber+0x2b2>
mov    %ecx,%eax
sub    %r8d,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rsi,4),%ebp
mov    %ebp,(%rdx)
mov    0x4(%rdi,%rsi,4),%ebp
mov    %ebp,0x4(%rdx)
mov    0x8(%rdi,%rsi,4),%ebp
mov    %ebp,0x8(%rdx)
mov    0xc(%rdi,%rsi,4),%ebp
mov    %ebp,0xc(%rdx)
mov    0x10(%rdi,%rsi,4),%ebp
mov    %ebp,0x10(%rdx)
mov    0x14(%rdi,%rsi,4),%ebp
mov    %ebp,0x14(%rdx)
mov    0x18(%rdi,%rsi,4),%ebp
mov    %ebp,0x18(%rdx)
mov    0x1c(%rdi,%rsi,4),%ebp
mov    %ebp,0x1c(%rdx)
add    $0x20,%rdx
add    $0x8,%rsi
cmp    %esi,%eax
jne    1370 <lsubber+0x270>
xor    %eax,%eax
test   %ecx,%ecx
cmovs  %ecx,%eax
add    $0xfffffffffffffffc,%rdx
nopl   (%rax)
test   %ecx,%ecx
jle    13d5 <lsubber+0x2d5>
add    $0xffffffff,%ecx
cmpl   $0x0,(%rdx)
lea    -0x4(%rdx),%rdx
je     13c0 <lsubber+0x2c0>
add    $0x1,%ecx
mov    %ecx,%eax
mov    %eax,(%r9)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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