#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__ has_zero32(unsigned int);
scalar_t__ has_zero64(unsigned long long);
char *find_lf(char *next, char *end) {
  if (sizeof(long) == 4) {
    while (next < end && (((unsigned long)next) & 3) && *next != '\n')
      next++;
    while (next < end) {
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
      if (has_zero32(*(unsigned int *)next ^ 0x0A0A0A0A))
        break;
      next += 4;
    }
  } else {
    if (next <= end) {
      while ((((unsigned long)next) & 3) && *next != '\n')
        next++;
      if ((((unsigned long)next) & 4) &&
          !has_zero32(*(unsigned int *)next ^ 0x0A0A0A0AU))
        next += 4;
    }
    while (next <= (end - 68)) {
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
      if (has_zero64(*(unsigned long long *)next ^ 0x0A0A0A0A0A0A0A0AULL))
        break;
      next += 8;
    }
    if (!has_zero32(*(unsigned int *)next ^ 0x0A0A0A0AU))
      next += 4;
  }
  while (next < end) {
    if (*next == '\n')
      break;
    next++;
  }
  return next;
}


x86 assembly (clang, -O0):
<find_lf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     11c9 <find_lf+0xa9>
jmp    1143 <find_lf+0x23>
mov    -0x8(%rbp),%rcx
and    $0x3,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x11(%rbp)
je     116a <find_lf+0x4a>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
setne  %al
mov    %al,-0x11(%rbp)
mov    -0x11(%rbp),%al
test   $0x1,%al
jne    117a <find_lf+0x5a>
jmp    118b <find_lf+0x6b>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1143 <find_lf+0x23>
mov    -0x8(%rbp),%rax
and    $0x4,%rax
cmp    $0x0,%rax
je     11c4 <find_lf+0xa4>
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
xor    $0xa0a0a0a,%edi
call   1030 <has_zero32@plt>
cmp    $0x0,%rax
jne    11c4 <find_lf+0xa4>
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    11c9 <find_lf+0xa9>
jmp    11ce <find_lf+0xae>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    $0xffffffffffffffbc,%rcx
cmp    %rcx,%rax
ja     1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     1208 <find_lf+0xe8>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     1239 <find_lf+0x119>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     126a <find_lf+0x14a>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     129b <find_lf+0x17b>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     12cc <find_lf+0x1ac>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     12fd <find_lf+0x1dd>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     132e <find_lf+0x20e>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movabs $0xa0a0a0a0a0a0a0a,%rdi
0a 0a 0a
xor    (%rax),%rdi
call   1040 <has_zero64@plt>
cmp    $0x0,%rax
je     135f <find_lf+0x23f>
jmp    1370 <find_lf+0x250>
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
jmp    11ce <find_lf+0xae>
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
xor    $0xa0a0a0a,%edi
call   1030 <has_zero32@plt>
cmp    $0x0,%rax
jne    1397 <find_lf+0x277>
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    139c <find_lf+0x27c>
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    13d0 <find_lf+0x2b0>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    13bf <find_lf+0x29f>
jmp    13d0 <find_lf+0x2b0>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    139c <find_lf+0x27c>
mov    -0x8(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_lf>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
cmp    %rsi,%rdi
ja     1195 <find_lf+0x75>
test   $0x3,%bl
je     1142 <find_lf+0x22>
cmpb   $0xa,(%rbx)
jne    114b <find_lf+0x2b>
mov    %rbx,%rax
jmp    1176 <find_lf+0x56>
mov    %rbx,%rax
test   $0x4,%al
jne    117d <find_lf+0x5d>
jmp    1195 <find_lf+0x75>
lea    0x1(%rbx),%rax
test   $0x3,%al
je     1176 <find_lf+0x56>
cmpb   $0xa,(%rax)
je     1176 <find_lf+0x56>
lea    0x2(%rbx),%rax
test   $0x3,%al
je     1176 <find_lf+0x56>
cmpb   $0xa,(%rax)
je     1176 <find_lf+0x56>
lea    0x3(%rbx),%rax
test   $0x3,%al
je     1176 <find_lf+0x56>
cmpb   $0xa,(%rax)
jne    12bf <find_lf+0x19f>
mov    %rax,%rbx
test   $0x4,%al
je     1195 <find_lf+0x75>
mov    $0xa0a0a0a,%edi
xor    (%rbx),%edi
call   1030 <has_zero32@plt>
xor    %ecx,%ecx
test   %rax,%rax
sete   %cl
lea    (%rbx,%rcx,4),%rbx
lea    -0x44(%r14),%r15
cmp    %r15,%rbx
jbe    11dd <find_lf+0xbd>
mov    $0xa0a0a0a,%edi
xor    (%rbx),%edi
call   1030 <has_zero32@plt>
xor    %ecx,%ecx
test   %rax,%rax
sete   %cl
lea    (%rbx,%rcx,4),%rax
cmp    %r14,%rax
jae    11d1 <find_lf+0xb1>
nopl   0x0(%rax,%rax,1)
cmpb   $0xa,(%rax)
je     11d1 <find_lf+0xb1>
add    $0x1,%rax
cmp    %r14,%rax
jb     11c0 <find_lf+0xa0>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movabs $0xa0a0a0a0a0a0a0a,%r12
0a 0a 0a
mov    (%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    119e <find_lf+0x7e>
mov    0x8(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    1280 <find_lf+0x160>
mov    0x10(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    1289 <find_lf+0x169>
mov    0x18(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    1292 <find_lf+0x172>
mov    0x20(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    129b <find_lf+0x17b>
mov    0x28(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    12a4 <find_lf+0x184>
mov    0x30(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    12ad <find_lf+0x18d>
mov    0x38(%rbx),%rdi
xor    %r12,%rdi
call   1040 <has_zero64@plt>
test   %rax,%rax
jne    12b6 <find_lf+0x196>
add    $0x40,%rbx
cmp    %r15,%rbx
jbe    11e7 <find_lf+0xc7>
jmp    119e <find_lf+0x7e>
add    $0x8,%rbx
jmp    119e <find_lf+0x7e>
add    $0x10,%rbx
jmp    119e <find_lf+0x7e>
add    $0x18,%rbx
jmp    119e <find_lf+0x7e>
add    $0x20,%rbx
jmp    119e <find_lf+0x7e>
add    $0x28,%rbx
jmp    119e <find_lf+0x7e>
add    $0x30,%rbx
jmp    119e <find_lf+0x7e>
add    $0x38,%rbx
jmp    119e <find_lf+0x7e>
add    $0x4,%rbx
jmp    113d <find_lf+0x1d>

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

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