#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 */
size_t UCHAR_MAX;
size_t strlen(char const *);
size_t strlcpy(char *d, const char *s, size_t n) {
  char *d0 = d;
  size_t *wd;
  const size_t *ws;
  if (!n--)
    goto finish;
  if (((uintptr_t)s & (sizeof(size_t) - 1)) !=
      ((uintptr_t)d & (sizeof(size_t) - 1))) {
    for (; ((uintptr_t)s & (sizeof(size_t) - 1)) && n && (*d = *s);
         n--, s++, d++)
      ;
    if (n && *s) {
      wd = (void *)d;
      ws = (const void *)s;
      for (; n >= sizeof(size_t) &&
             !((*ws) - ((size_t)-1 / UCHAR_MAX) & ~(*ws) &
               (((size_t)-1 / UCHAR_MAX) * (UCHAR_MAX / 2 + 1)));
           n -= sizeof(size_t), ws++, wd++)
        *wd = *ws;
      d = (void *)wd;
      s = (const void *)ws;
    }
  }
  for (; n && (*d = *s); n--, s++, d++)
    ;
  *d = 0;
finish:
  return d - d0 + strlen(s);
}


x86 assembly (clang, -O0):
<strlcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jne    114a <strlcpy+0x3a>
jmp    1367 <strlcpy+0x257>
mov    -0x10(%rbp),%rax
and    $0x7,%rax
mov    -0x8(%rbp),%rcx
and    $0x7,%rcx
cmp    %rcx,%rax
je     12f5 <strlcpy+0x1e5>
jmp    1168 <strlcpy+0x58>
mov    -0x10(%rbp),%rcx
and    $0x7,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x31(%rbp)
je     11a7 <strlcpy+0x97>
xor    %eax,%eax
cmpq   $0x0,-0x18(%rbp)
mov    %al,-0x31(%rbp)
je     11a7 <strlcpy+0x97>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    -0x8(%rbp),%rcx
mov    %al,(%rcx)
movsbl %al,%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11b7 <strlcpy+0xa7>
jmp    11e5 <strlcpy+0xd5>
jmp    11bc <strlcpy+0xac>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1168 <strlcpy+0x58>
cmpq   $0x0,-0x18(%rbp)
je     12f0 <strlcpy+0x1e0>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     12f0 <strlcpy+0x1e0>
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmpq   $0x8,-0x18(%rbp)
mov    %al,-0x32(%rbp)
jb     1299 <strlcpy+0x189>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    $0xffffffffffffffff,%rax
mov    0x2db7(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
sub    %rcx,%rax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%rcx
xor    $0xffffffffffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    $0xffffffffffffffff,%rax
mov    0x2d88(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
mov    0x2d75(%rip),%rdx
mov    (%rdx),%rdx
shr    $0x1,%rdx
add    $0x1,%rdx
imul   %rdx,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    12a9 <strlcpy+0x199>
jmp    12e0 <strlcpy+0x1d0>
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
jmp    1210 <strlcpy+0x100>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    12f5 <strlcpy+0x1e5>
jmp    12fa <strlcpy+0x1ea>
xor    %eax,%eax
cmpq   $0x0,-0x18(%rbp)
mov    %al,-0x49(%rbp)
je     1322 <strlcpy+0x212>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    -0x8(%rbp),%rcx
mov    %al,(%rcx)
movsbl %al,%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    1332 <strlcpy+0x222>
jmp    1360 <strlcpy+0x250>
jmp    1337 <strlcpy+0x227>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    12fa <strlcpy+0x1ea>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
add    %rcx,%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strlcpy>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r10
mov    %rdx,%r9
sub    $0x1,%r9
jae    1128 <strlcpy+0x18>
mov    %rdi,%r14
jmp    137d <strlcpy+0x26d>
mov    %r10d,%eax
xor    %edi,%eax
test   $0x7,%al
je     12b0 <strlcpy+0x1a0>
test   %r9,%r9
setne  %r8b
test   $0x7,%r10b
je     12c1 <strlcpy+0x1b1>
test   %r9,%r9
je     12c1 <strlcpy+0x1b1>
mov    (%r10),%al
mov    %al,(%rdi)
test   %al,%al
je     1342 <strlcpy+0x232>
lea    0x1(%r10),%rax
lea    0x1(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffffe,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x2(%r10),%rax
lea    0x2(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffffd,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x3(%r10),%rax
lea    0x3(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffffc,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x4(%r10),%rax
lea    0x4(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffffb,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x5(%r10),%rax
lea    0x5(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffffa,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x6(%r10),%rax
lea    0x6(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffff9,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
lea    0x7(%r10),%rax
lea    0x7(%rdi),%r14
mov    %rdx,%r9
add    $0xfffffffffffffff8,%r9
setne  %r8b
test   $0x7,%al
je     12c6 <strlcpy+0x1b6>
test   %r9,%r9
je     12c6 <strlcpy+0x1b6>
mov    (%rax),%cl
mov    %cl,(%r14)
test   %cl,%cl
je     12d5 <strlcpy+0x1c5>
add    $0x8,%r10
lea    0x8(%rdi),%r14
add    $0xfffffffffffffff7,%rdx
setne  %r8b
mov    %rdx,%r9
jmp    12c9 <strlcpy+0x1b9>
mov    %rdi,%r14
test   %r9,%r9
jne    1360 <strlcpy+0x250>
jmp    1379 <strlcpy+0x269>
mov    %rdi,%r14
jmp    12c9 <strlcpy+0x1b9>
mov    %rax,%r10
mov    %r10,%rax
test   %r8b,%r8b
je     1379 <strlcpy+0x269>
cmpb   $0x0,(%rax)
je     134d <strlcpy+0x23d>
cmp    $0x8,%r9
jb     1338 <strlcpy+0x228>
mov    0x2d09(%rip),%r8
mov    %rax,%r10
nopw   0x0(%rax,%rax,1)
mov    (%r10),%rbx
mov    (%r8),%rsi
mov    $0xffffffffffffffff,%rax
xor    %edx,%edx
div    %rsi
mov    %rbx,%rdx
sub    %rax,%rdx
mov    %rbx,%rcx
not    %rcx
and    %rdx,%rcx
shr    %rsi
add    $0x1,%rsi
imul   %rax,%rsi
test   %rsi,%rcx
jne    1350 <strlcpy+0x240>
mov    %rbx,(%r14)
add    $0xfffffffffffffff8,%r9
add    $0x8,%r10
add    $0x8,%r14
cmp    $0x7,%r9
ja     12f0 <strlcpy+0x1e0>
jmp    1350 <strlcpy+0x240>
mov    %rax,%r10
test   %r9,%r9
jne    1360 <strlcpy+0x250>
jmp    1379 <strlcpy+0x269>
mov    %rdi,%r14
mov    %r10,%rax
cmpb   $0x0,(%rax)
jne    12da <strlcpy+0x1ca>
mov    %rax,%r10
test   %r9,%r9
je     1379 <strlcpy+0x269>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r10),%eax
mov    %al,(%r14)
test   %al,%al
je     1379 <strlcpy+0x269>
add    $0x1,%r10
add    $0x1,%r14
add    $0xffffffffffffffff,%r9
jne    1360 <strlcpy+0x250>
movb   $0x0,(%r14)
sub    %rdi,%r14
mov    %r10,%rdi
call   1030 <strlen@plt>
add    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
@UCHAR_MAX = global i64 0
define i64 @strlcpy(i8* %0, i8* %1, i64 %2) {
%4 = add i64 %2, -1
%5 = icmp eq i64 %2, 0
br i1 %5, label %6, label %8
6: ; preds = %3
%7 = ptrtoint i8* %0 to i64
br label %172
8: ; preds = %3
%9 = ptrtoint i8* %1 to i64
%10 = ptrtoint i8* %0 to i64
%11 = xor i64 %9, %10
%12 = and i64 %11, 7
%13 = icmp eq i64 %12, 0
br i1 %13, label %152, label %14
14: ; preds = %8
%15 = and i64 %9, 7
%16 = icmp ne i64 %15, 0
%17 = icmp ne i64 %4, 0
%18 = and i1 %16, %17
br i1 %18, label %19, label %111
19: ; preds = %14
%20 = load i8, i8* %1
store i8 %20, i8* %0
%21 = icmp eq i8 %20, 0
br i1 %21, label %116, label %22
22: ; preds = %19
%23 = add i64 %2, -2
%24 = getelementptr inbounds i8, i8* %1, i64 1
%25 = getelementptr inbounds i8, i8* %0, i64 1
%26 = ptrtoint i8* %24 to i64
%27 = and i64 %26, 7
%28 = icmp ne i64 %27, 0
%29 = icmp ne i64 %23, 0
%30 = and i1 %28, %29
br i1 %30, label %31, label %111
31: ; preds = %22
%32 = load i8, i8* %24
store i8 %32, i8* %25
%33 = icmp eq i8 %32, 0
br i1 %33, label %116, label %34
34: ; preds = %31
%35 = add i64 %2, -3
%36 = getelementptr inbounds i8, i8* %1, i64 2
%37 = getelementptr inbounds i8, i8* %0, i64 2
%38 = ptrtoint i8* %36 to i64
%39 = and i64 %38, 7
%40 = icmp ne i64 %39, 0
%41 = icmp ne i64 %35, 0
%42 = and i1 %40, %41
br i1 %42, label %43, label %111
43: ; preds = %34
%44 = load i8, i8* %36
store i8 %44, i8* %37
%45 = icmp eq i8 %44, 0
br i1 %45, label %116, label %46
46: ; preds = %43
%47 = add i64 %2, -4
%48 = getelementptr inbounds i8, i8* %1, i64 3
%49 = getelementptr inbounds i8, i8* %0, i64 3
%50 = ptrtoint i8* %48 to i64
%51 = and i64 %50, 7
%52 = icmp ne i64 %51, 0
%53 = icmp ne i64 %47, 0
%54 = and i1 %52, %53
br i1 %54, label %55, label %111
55: ; preds = %46
%56 = load i8, i8* %48
store i8 %56, i8* %49
%57 = icmp eq i8 %56, 0
br i1 %57, label %116, label %58
58: ; preds = %55
%59 = add i64 %2, -5
%60 = getelementptr inbounds i8, i8* %1, i64 4
%61 = getelementptr inbounds i8, i8* %0, i64 4
%62 = ptrtoint i8* %60 to i64
%63 = and i64 %62, 7
%64 = icmp ne i64 %63, 0
%65 = icmp ne i64 %59, 0
%66 = and i1 %64, %65
br i1 %66, label %67, label %111
67: ; preds = %58
%68 = load i8, i8* %60
store i8 %68, i8* %61
%69 = icmp eq i8 %68, 0
br i1 %69, label %116, label %70
70: ; preds = %67
%71 = add i64 %2, -6
%72 = getelementptr inbounds i8, i8* %1, i64 5
%73 = getelementptr inbounds i8, i8* %0, i64 5
%74 = ptrtoint i8* %72 to i64
%75 = and i64 %74, 7
%76 = icmp ne i64 %75, 0
%77 = icmp ne i64 %71, 0
%78 = and i1 %76, %77
br i1 %78, label %79, label %111
79: ; preds = %70
%80 = load i8, i8* %72
store i8 %80, i8* %73
%81 = icmp eq i8 %80, 0
br i1 %81, label %116, label %82
82: ; preds = %79
%83 = add i64 %2, -7
%84 = getelementptr inbounds i8, i8* %1, i64 6
%85 = getelementptr inbounds i8, i8* %0, i64 6
%86 = ptrtoint i8* %84 to i64
%87 = and i64 %86, 7
%88 = icmp ne i64 %87, 0
%89 = icmp ne i64 %83, 0
%90 = and i1 %88, %89
br i1 %90, label %91, label %111
91: ; preds = %82
%92 = load i8, i8* %84
store i8 %92, i8* %85
%93 = icmp eq i8 %92, 0
br i1 %93, label %116, label %94
94: ; preds = %91
%95 = add i64 %2, -8
%96 = getelementptr inbounds i8, i8* %1, i64 7
%97 = getelementptr inbounds i8, i8* %0, i64 7
%98 = ptrtoint i8* %96 to i64
%99 = and i64 %98, 7
%100 = icmp ne i64 %99, 0
%101 = icmp ne i64 %95, 0
%102 = and i1 %100, %101
br i1 %102, label %103, label %111
103: ; preds = %94
%104 = load i8, i8* %96
store i8 %104, i8* %97
%105 = icmp eq i8 %104, 0
br i1 %105, label %116, label %106
106: ; preds = %103
%107 = add i64 %2, -9
%108 = getelementptr inbounds i8, i8* %1, i64 8
%109 = getelementptr inbounds i8, i8* %0, i64 8
%110 = icmp ne i64 %107, 0
br label %111
111: ; preds = %22, %34, %46, %58, %70, %82, %94, %106, %14
%112 = phi i8* [ %1, %14 ], [ %24, %22 ], [ %36, %34 ], [ %48, %46 ], [ %60, %58 ], [ %72, %70 ], [ %84, %82 ], [ %96, %94 ], [ %108, %106 ]
%113 = phi i64 [ %4, %14 ], [ %23, %22 ], [ %35, %34 ], [ %47, %46 ], [ %59, %58 ], [ %71, %70 ], [ %83, %82 ], [ %95, %94 ], [ %107, %106 ]
%114 = phi i8* [ %0, %14 ], [ %25, %22 ], [ %37, %34 ], [ %49, %46 ], [ %61, %58 ], [ %73, %70 ], [ %85, %82 ], [ %97, %94 ], [ %109, %106 ]
%115 = phi i1 [ %17, %14 ], [ %29, %22 ], [ %41, %34 ], [ %53, %46 ], [ %65, %58 ], [ %77, %70 ], [ %89, %82 ], [ %101, %94 ], [ %110, %106 ]
br i1 %115, label %116, label %168
116: ; preds = %19, %31, %43, %55, %67, %79, %91, %103, %111
%117 = phi i8* [ %114, %111 ], [ %0, %19 ], [ %25, %31 ], [ %37, %43 ], [ %49, %55 ], [ %61, %67 ], [ %73, %79 ], [ %85, %91 ], [ %97, %103 ]
%118 = phi i64 [ %113, %111 ], [ %4, %19 ], [ %23, %31 ], [ %35, %43 ], [ %47, %55 ], [ %59, %67 ], [ %71, %79 ], [ %83, %91 ], [ %95, %103 ]
%119 = phi i8* [ %112, %111 ], [ %1, %19 ], [ %24, %31 ], [ %36, %43 ], [ %48, %55 ], [ %60, %67 ], [ %72, %79 ], [ %84, %91 ], [ %96, %103 ]
%120 = load i8, i8* %119
%121 = icmp eq i8 %120, 0
br i1 %121, label %152, label %122
122: ; preds = %116
%123 = bitcast i8* %117 to i64*
%124 = bitcast i8* %119 to i64*
%125 = icmp ugt i64 %118, 7
br i1 %125, label %126, label %146
126: ; preds = %122, %141
%127 = phi i64* [ %143, %141 ], [ %124, %122 ]
%128 = phi i64* [ %144, %141 ], [ %123, %122 ]
%129 = phi i64 [ %142, %141 ], [ %118, %122 ]
%130 = load i64, i64* %127
%131 = load i64, i64* @UCHAR_MAX
%132 = udiv i64 -1, %131
%133 = sub i64 %130, %132
%134 = xor i64 %130, -1
%135 = and i64 %133, %134
%136 = lshr i64 %131, 1
%137 = add nuw i64 %136, 1
%138 = mul i64 %137, %132
%139 = and i64 %135, %138
%140 = icmp eq i64 %139, 0
br i1 %140, label %141, label %146
141: ; preds = %126
store i64 %130, i64* %128
%142 = add i64 %129, -8
%143 = getelementptr inbounds i64, i64* %127, i64 1
%144 = getelementptr inbounds i64, i64* %128, i64 1
%145 = icmp ugt i64 %142, 7
br i1 %145, label %126, label %146
146: ; preds = %126, %141, %122
%147 = phi i64 [ %118, %122 ], [ %142, %141 ], [ %129, %126 ]
%148 = phi i64* [ %123, %122 ], [ %144, %141 ], [ %128, %126 ]
%149 = phi i64* [ %124, %122 ], [ %143, %141 ], [ %127, %126 ]
%150 = bitcast i64* %148 to i8*
%151 = bitcast i64* %149 to i8*
br label %152
152: ; preds = %116, %146, %8
%153 = phi i8* [ %151, %146 ], [ %119, %116 ], [ %1, %8 ]
%154 = phi i64 [ %147, %146 ], [ %118, %116 ], [ %4, %8 ]
%155 = phi i8* [ %150, %146 ], [ %117, %116 ], [ %0, %8 ]
%156 = icmp eq i64 %154, 0
br i1 %156, label %168, label %157
157: ; preds = %152, %163
%158 = phi i8* [ %166, %163 ], [ %155, %152 ]
%159 = phi i64 [ %164, %163 ], [ %154, %152 ]
%160 = phi i8* [ %165, %163 ], [ %153, %152 ]
%161 = load i8, i8* %160
store i8 %161, i8* %158
%162 = icmp eq i8 %161, 0
br i1 %162, label %168, label %163
163: ; preds = %157
%164 = add i64 %159, -1
%165 = getelementptr inbounds i8, i8* %160, i64 1
%166 = getelementptr inbounds i8, i8* %158, i64 1
%167 = icmp eq i64 %164, 0
br i1 %167, label %168, label %157
168: ; preds = %157, %163, %111, %152
%169 = phi i8* [ %153, %152 ], [ %112, %111 ], [ %165, %163 ], [ %160, %157 ]
%170 = phi i8* [ %155, %152 ], [ %114, %111 ], [ %166, %163 ], [ %158, %157 ]
store i8 0, i8* %170
%171 = ptrtoint i8* %170 to i64
br label %172
172: ; preds = %6, %168
%173 = phi i64 [ %7, %6 ], [ %171, %168 ]
%174 = phi i64 [ %7, %6 ], [ %10, %168 ]
%175 = phi i8* [ %1, %6 ], [ %169, %168 ]
%176 = sub i64 %173, %174
%177 = tail call i64 @strlen(i8* dereferenceable(1) %175)
%178 = add i64 %176, %177
ret i64 %178
}