#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 */
typedef int uint64_t;

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int getBit64(int *, int);
int /*<<< orphan*/ printf(char *);
int getLCPInBits(uint64_t *startData1, uint64_t *startData2,
                 unsigned short len1, unsigned short len2,
                 char *firstBitAfterLCP) {
  int lcp = 0;
  int i;
  int bit;
  int differenceFound = 0;
  int minLength = 2 * ((len1) <= (len2) ? (len1) : (len2));
  int howManyLongsToCompare = minLength / 64;
  int minLengthInLastLong = minLength % 64;
  if (minLengthInLastLong > 0)
    howManyLongsToCompare++;
  else
    minLengthInLastLong = 64;
  i = 0;
  while (i < howManyLongsToCompare - 1 && !differenceFound) {
    if (startData1[i] == startData2[i]) {
      lcp += 64;
      i++;
    } else
      differenceFound = 1;
  }
  if (differenceFound) {
    int equals = 0;
    int shiftCount = 0;
    while (!equals && shiftCount <= 64) {
      shiftCount++;
      if ((startData1[i] >> shiftCount) == (startData2[i] >> shiftCount)) {
        equals = 1;
        lcp += (64 - shiftCount);
      }
    }
    return lcp;
  } else {
    if (startData1[i] == startData2[i]) {
      lcp += minLengthInLastLong;
      if (len1 == len2)
        *firstBitAfterLCP = -1;
      else if (len1 < len2) {
        if (minLengthInLastLong < 64) {
          bit = getBit64(&startData2[i], minLengthInLastLong);
          if (bit == 0)
            *firstBitAfterLCP = 0;
        } else {
          if (i + 1 >= 4) {
            printf("Unexpected error while extracting lcp from bit sequence. "
                   "Trying to access more than 4 longs\n");
            exit(1);
          }
          bit = getBit64(&startData2[i + 1], 0);
          if (bit == 0)
            *firstBitAfterLCP = 0;
        }
      } else {
        *firstBitAfterLCP = -1;
      }
    } else {
      uint64_t prefix1 = (startData1[i] >> (64 - minLengthInLastLong));
      uint64_t prefix2 = (startData2[i] >> (64 - minLengthInLastLong));
      int equals = 0;
      int shiftCount = 0;
      while (shiftCount < minLengthInLastLong && !equals) {
        if ((prefix1 >> shiftCount) == (prefix2 >> shiftCount)) {
          equals = 1;
          lcp += (minLengthInLastLong - shiftCount);
          if (shiftCount == 0) {
            if (len1 == len2)
              *firstBitAfterLCP = -1;
            else if (len1 < len2) {
              if (minLengthInLastLong < 64) {
                bit = getBit64(&startData2[i], minLengthInLastLong);
                if (bit == 0)
                  *firstBitAfterLCP = 0;
              } else {
                if (i + 1 >= 4) {
                  printf("Unexpected error while extracting lcp from bit "
                         "sequence. Trying to access more than 4 longs\n");
                  exit(1);
                }
                bit = getBit64(&startData2[i + 1], 0);
                if (bit == 0)
                  *firstBitAfterLCP = 0;
              }
            } else {
              *firstBitAfterLCP = -1;
            }
          }
        }
        shiftCount++;
      }
    }
  }
  return lcp;
}


x86 assembly (clang, -O0):
<getLCPInBits>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %cx,%ax
mov    %dx,%cx
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %cx,-0x1a(%rbp)
mov    %ax,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
movzwl -0x1a(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     117c <getLCPInBits+0x4c>
movzwl -0x1a(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1183 <getLCPInBits+0x53>
movzwl -0x1c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    %edx,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    11c0 <getLCPInBits+0x90>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11c7 <getLCPInBits+0x97>
movl   $0x40,-0x44(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%ecx
mov    -0x40(%rbp),%edx
sub    $0x1,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x61(%rbp)
jge    11f0 <getLCPInBits+0xc0>
cmpl   $0x0,-0x38(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1200 <getLCPInBits+0xd0>
jmp    123f <getLCPInBits+0x10f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1233 <getLCPInBits+0x103>
mov    -0x2c(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123a <getLCPInBits+0x10a>
movl   $0x1,-0x38(%rbp)
jmp    11ce <getLCPInBits+0x9e>
cmpl   $0x0,-0x38(%rbp)
je     12d8 <getLCPInBits+0x1a8>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x48(%rbp)
mov    %al,-0x62(%rbp)
jne    1270 <getLCPInBits+0x140>
cmpl   $0x40,-0x4c(%rbp)
setle  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    1280 <getLCPInBits+0x150>
jmp    12cd <getLCPInBits+0x19d>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x4c(%rbp),%ecx
sar    %cl,%eax
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
mov    -0x4c(%rbp),%ecx
sar    %cl,%edx
mov    %edx,%ecx
cmp    %ecx,%eax
jne    12c8 <getLCPInBits+0x198>
movl   $0x1,-0x48(%rbp)
mov    $0x40,%eax
sub    -0x4c(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1257 <getLCPInBits+0x127>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    156a <getLCPInBits+0x43a>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    13d1 <getLCPInBits+0x2a1>
mov    -0x44(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movzwl -0x1a(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jne    1319 <getLCPInBits+0x1e9>
mov    -0x28(%rbp),%rax
movb   $0xff,(%rax)
jmp    13cc <getLCPInBits+0x29c>
movzwl -0x1a(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    13c0 <getLCPInBits+0x290>
cmpl   $0x40,-0x44(%rbp)
jge    1363 <getLCPInBits+0x233>
mov    -0x18(%rbp),%rdi
movslq -0x30(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x44(%rbp),%esi
call   1040 <getBit64@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    135e <getLCPInBits+0x22e>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    13bb <getLCPInBits+0x28b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cmp    $0x4,%eax
jl     1388 <getLCPInBits+0x258>
lea    0xc87(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
xor    %esi,%esi
call   1040 <getBit64@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    13b6 <getLCPInBits+0x286>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    13bb <getLCPInBits+0x28b>
jmp    13c7 <getLCPInBits+0x297>
mov    -0x28(%rbp),%rax
movb   $0xff,(%rax)
jmp    13cc <getLCPInBits+0x29c>
jmp    155f <getLCPInBits+0x42f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x40,%ecx
sub    -0x44(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x40,%ecx
sub    -0x44(%rbp),%ecx
sar    %cl,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x44(%rbp),%ecx
mov    %al,-0x63(%rbp)
jge    142c <getLCPInBits+0x2fc>
cmpl   $0x0,-0x58(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    143c <getLCPInBits+0x30c>
jmp    155a <getLCPInBits+0x42a>
mov    -0x50(%rbp),%eax
mov    -0x5c(%rbp),%ecx
sar    %cl,%eax
mov    -0x54(%rbp),%edx
mov    -0x5c(%rbp),%ecx
sar    %cl,%edx
mov    %edx,%ecx
cmp    %ecx,%eax
jne    154c <getLCPInBits+0x41c>
movl   $0x1,-0x58(%rbp)
mov    -0x44(%rbp),%eax
sub    -0x5c(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jne    1547 <getLCPInBits+0x417>
movzwl -0x1a(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jne    148f <getLCPInBits+0x35f>
mov    -0x28(%rbp),%rax
movb   $0xff,(%rax)
jmp    1542 <getLCPInBits+0x412>
movzwl -0x1a(%rbp),%eax
movzwl -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1536 <getLCPInBits+0x406>
cmpl   $0x40,-0x44(%rbp)
jge    14d9 <getLCPInBits+0x3a9>
mov    -0x18(%rbp),%rdi
movslq -0x30(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x44(%rbp),%esi
call   1040 <getBit64@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    14d4 <getLCPInBits+0x3a4>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    1531 <getLCPInBits+0x401>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cmp    $0x4,%eax
jl     14fe <getLCPInBits+0x3ce>
lea    0xb11(%rip),%rdi
call   1030 <printf@plt>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
xor    %esi,%esi
call   1040 <getBit64@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jne    152c <getLCPInBits+0x3fc>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    1531 <getLCPInBits+0x401>
jmp    153d <getLCPInBits+0x40d>
mov    -0x28(%rbp),%rax
movb   $0xff,(%rax)
jmp    1542 <getLCPInBits+0x412>
jmp    1547 <getLCPInBits+0x417>
jmp    154c <getLCPInBits+0x41c>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    140f <getLCPInBits+0x2df>
jmp    155f <getLCPInBits+0x42f>
jmp    1564 <getLCPInBits+0x434>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getLCPInBits>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %ecx,%r9d
cmp    %ecx,%edx
mov    %edx,%eax
cmova  %ecx,%eax
mov    %r8,%r14
mov    %rsi,%r8
lea    (%rax,%rax,1),%ecx
shr    $0x5,%eax
xor    %ebp,%ebp
and    $0x3e,%ecx
setne  %bpl
mov    $0x40,%esi
cmovne %ecx,%esi
lea    (%rax,%rbp,1),%r10d
add    $0xffffffff,%r10d
test   %r10d,%r10d
jle    11a7 <getLCPInBits+0x77>
xor    %ecx,%ecx
xor    %eax,%eax
mov    %eax,%r12d
mov    %ecx,%r15d
mov    %eax,%eax
mov    (%rdi,%rax,4),%ebp
mov    (%r8,%rax,4),%ebx
lea    0x40(%r15),%r11d
xor    %eax,%eax
cmp    %ebx,%ebp
sete   %al
cmove  %r11d,%ecx
add    %r12d,%eax
cmp    %r10d,%eax
jge    119a <getLCPInBits+0x6a>
cmp    %ebx,%ebp
je     1170 <getLCPInBits+0x40>
cmp    %ebx,%ebp
jne    1223 <getLCPInBits+0xf3>
mov    %r11d,%r15d
jmp    11ac <getLCPInBits+0x7c>
xor    %r15d,%r15d
xor    %eax,%eax
mov    %eax,%r10d
mov    (%rdi,%r10,4),%r11d
lea    (%r8,%r10,4),%rdi
mov    (%r8,%r10,4),%ebp
cmp    %ebp,%r11d
jne    11e5 <getLCPInBits+0xb5>
add    %esi,%r15d
cmp    %r9w,%dx
je     121d <getLCPInBits+0xed>
jae    121d <getLCPInBits+0xed>
cmp    $0x3f,%esi
jbe    1207 <getLCPInBits+0xd7>
cmp    $0x3,%eax
jae    12b3 <getLCPInBits+0x183>
lea    (%r8,%r10,4),%rdi
add    $0x4,%rdi
xor    %esi,%esi
jmp    1207 <getLCPInBits+0xd7>
mov    %esi,%ecx
neg    %cl
sar    %cl,%r11d
sar    %cl,%ebp
cmp    %ebp,%r11d
jne    126e <getLCPInBits+0x13e>
add    %esi,%r15d
cmp    %r9w,%dx
je     121d <getLCPInBits+0xed>
jae    121d <getLCPInBits+0xed>
cmp    $0x40,%esi
jae    12aa <getLCPInBits+0x17a>
call   1040 <getBit64@plt>
test   %eax,%eax
jne    129e <getLCPInBits+0x16e>
movb   $0x0,(%r14)
jmp    129e <getLCPInBits+0x16e>
movb   $0xff,(%r14)
jmp    129e <getLCPInBits+0x16e>
mov    %eax,%ecx
mov    (%rdi,%rcx,4),%r9d
mov    (%r8,%rcx,4),%ebx
xor    %edi,%edi
mov    $0x3f,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdi),%ecx
mov    %r9d,%eax
sar    %cl,%eax
mov    %ebx,%edx
sar    %cl,%edx
mov    %r15d,%ebp
cmp    %edx,%eax
mov    $0x0,%r15d
cmove  %esi,%r15d
add    %ebp,%r15d
cmp    %edx,%eax
je     129e <getLCPInBits+0x16e>
add    $0xffffffff,%esi
cmp    $0x40,%edi
mov    %ecx,%edi
jb     1240 <getLCPInBits+0x110>
jmp    129e <getLCPInBits+0x16e>
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11d,%eax
sar    %cl,%eax
mov    %ebp,%edx
sar    %cl,%edx
cmp    %edx,%eax
je     1296 <getLCPInBits+0x166>
add    $0x1,%ecx
cmp    %ecx,%esi
ja     1280 <getLCPInBits+0x150>
jmp    129e <getLCPInBits+0x16e>
add    %r15d,%esi
sub    %ecx,%esi
mov    %esi,%r15d
mov    %r15d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x2,%eax
jbe    11d9 <getLCPInBits+0xa9>
lea    0xd46(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%edi
call   1050 <exit@plt>

LLVM IR (-O0):
@.str = [93 x i8] c"Unexpected error while extracting lcp from bit sequence. Trying to access more than 4 longs\0A\00"
define i32 @getLCPInBits(i32* %0, i32* %1, i16 zeroext %2, i16 zeroext %3, i8* %4) {
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i16
%10 = alloca i16
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
store i32* %0, i32** %7
store i32* %1, i32** %8
store i16 %2, i16* %9
store i16 %3, i16* %10
store i8* %4, i8** %11
store i32 0, i32* %12
store i32 0, i32* %15
%25 = load i16, i16* %9
%26 = zext i16 %25 to i32
%27 = load i16, i16* %10
%28 = zext i16 %27 to i32
%29 = icmp sle i32 %26, %28
br i1 %29, label %30, label %33
30: ; preds = %5
%31 = load i16, i16* %9
%32 = zext i16 %31 to i32
br label %36
33: ; preds = %5
%34 = load i16, i16* %10
%35 = zext i16 %34 to i32
br label %36
36: ; preds = %33, %30
%37 = phi i32 [ %32, %30 ], [ %35, %33 ]
%38 = mul nsw i32 2, %37
store i32 %38, i32* %16
%39 = load i32, i32* %16
%40 = sdiv i32 %39, 64
store i32 %40, i32* %17
%41 = load i32, i32* %16
%42 = srem i32 %41, 64
store i32 %42, i32* %18
%43 = load i32, i32* %18
%44 = icmp sgt i32 %43, 0
br i1 %44, label %45, label %48
45: ; preds = %36
%46 = load i32, i32* %17
%47 = add nsw i32 %46, 1
store i32 %47, i32* %17
br label %49
48: ; preds = %36
store i32 64, i32* %18
br label %49
49: ; preds = %48, %45
store i32 0, i32* %13
br label %50
50: ; preds = %79, %49
%51 = load i32, i32* %13
%52 = load i32, i32* %17
%53 = sub nsw i32 %52, 1
%54 = icmp slt i32 %51, %53
br i1 %54, label %55, label %59
55: ; preds = %50
%56 = load i32, i32* %15
%57 = icmp ne i32 %56, 0
%58 = xor i1 %57, true
br label %59
59: ; preds = %55, %50
%60 = phi i1 [ false, %50 ], [ %58, %55 ]
br i1 %60, label %61, label %80
61: ; preds = %59
%62 = load i32*, i32** %7
%63 = load i32, i32* %13
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i32, i32* %62, i64 %64
%66 = load i32, i32* %65
%67 = load i32*, i32** %8
%68 = load i32, i32* %13
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %67, i64 %69
%71 = load i32, i32* %70
%72 = icmp eq i32 %66, %71
br i1 %72, label %73, label %78
73: ; preds = %61
%74 = load i32, i32* %12
%75 = add nsw i32 %74, 64
store i32 %75, i32* %12
%76 = load i32, i32* %13
%77 = add nsw i32 %76, 1
store i32 %77, i32* %13
br label %79
78: ; preds = %61
store i32 1, i32* %15
br label %79
79: ; preds = %78, %73
br label %50
80: ; preds = %59
%81 = load i32, i32* %15
%82 = icmp ne i32 %81, 0
br i1 %82, label %83, label %118
83: ; preds = %80
store i32 0, i32* %19
store i32 0, i32* %20
br label %84
84: ; preds = %115, %83
%85 = load i32, i32* %19
%86 = icmp ne i32 %85, 0
br i1 %86, label %90, label %87
87: ; preds = %84
%88 = load i32, i32* %20
%89 = icmp sle i32 %88, 64
br label %90
90: ; preds = %87, %84
%91 = phi i1 [ false, %84 ], [ %89, %87 ]
br i1 %91, label %92, label %116
92: ; preds = %90
%93 = load i32, i32* %20
%94 = add nsw i32 %93, 1
store i32 %94, i32* %20
%95 = load i32*, i32** %7
%96 = load i32, i32* %13
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %95, i64 %97
%99 = load i32, i32* %98
%100 = load i32, i32* %20
%101 = ashr i32 %99, %100
%102 = load i32*, i32** %8
%103 = load i32, i32* %13
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %102, i64 %104
%106 = load i32, i32* %105
%107 = load i32, i32* %20
%108 = ashr i32 %106, %107
%109 = icmp eq i32 %101, %108
br i1 %109, label %110, label %115
110: ; preds = %92
store i32 1, i32* %19
%111 = load i32, i32* %20
%112 = sub nsw i32 64, %111
%113 = load i32, i32* %12
%114 = add nsw i32 %113, %112
store i32 %114, i32* %12
br label %115
115: ; preds = %110, %92
br label %84
116: ; preds = %90
%117 = load i32, i32* %12
store i32 %117, i32* %6
br label %290
118: ; preds = %80
%119 = load i32*, i32** %7
%120 = load i32, i32* %13
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %119, i64 %121
%123 = load i32, i32* %122
%124 = load i32*, i32** %8
%125 = load i32, i32* %13
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %124, i64 %126
%128 = load i32, i32* %127
%129 = icmp eq i32 %123, %128
br i1 %129, label %130, label %186
130: ; preds = %118
%131 = load i32, i32* %18
%132 = load i32, i32* %12
%133 = add nsw i32 %132, %131
store i32 %133, i32* %12
%134 = load i16, i16* %9
%135 = zext i16 %134 to i32
%136 = load i16, i16* %10
%137 = zext i16 %136 to i32
%138 = icmp eq i32 %135, %137
br i1 %138, label %139, label %141
139: ; preds = %130
%140 = load i8*, i8** %11
store i8 -1, i8* %140
br label %185
141: ; preds = %130
%142 = load i16, i16* %9
%143 = zext i16 %142 to i32
%144 = load i16, i16* %10
%145 = zext i16 %144 to i32
%146 = icmp slt i32 %143, %145
br i1 %146, label %147, label %182
147: ; preds = %141
%148 = load i32, i32* %18
%149 = icmp slt i32 %148, 64
br i1 %149, label %150, label %162
150: ; preds = %147
%151 = load i32*, i32** %8
%152 = load i32, i32* %13
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i32, i32* %151, i64 %153
%155 = load i32, i32* %18
%156 = call i32 @getBit64(i32* %154, i32 %155)
store i32 %156, i32* %14
%157 = load i32, i32* %14
%158 = icmp eq i32 %157, 0
br i1 %158, label %159, label %161
159: ; preds = %150
%160 = load i8*, i8** %11
store i8 0, i8* %160
br label %161
161: ; preds = %159, %150
br label %181
162: ; preds = %147
%163 = load i32, i32* %13
%164 = add nsw i32 %163, 1
%165 = icmp sge i32 %164, 4
br i1 %165, label %166, label %169
166: ; preds = %162
%167 = call i32 @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str, i64 0, i64 0))
%168 = call i32 @exit(i32 1)
unreachable
169: ; preds = %162
%170 = load i32*, i32** %8
%171 = load i32, i32* %13
%172 = add nsw i32 %171, 1
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32, i32* %170, i64 %173
%175 = call i32 @getBit64(i32* %174, i32 0)
store i32 %175, i32* %14
%176 = load i32, i32* %14
%177 = icmp eq i32 %176, 0
br i1 %177, label %178, label %180
178: ; preds = %169
%179 = load i8*, i8** %11
store i8 0, i8* %179
br label %180
180: ; preds = %178, %169
br label %181
181: ; preds = %180, %161
br label %184
182: ; preds = %141
%183 = load i8*, i8** %11
store i8 -1, i8* %183
br label %184
184: ; preds = %182, %181
br label %185
185: ; preds = %184, %139
br label %287
186: ; preds = %118
%187 = load i32*, i32** %7
%188 = load i32, i32* %13
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds i32, i32* %187, i64 %189
%191 = load i32, i32* %190
%192 = load i32, i32* %18
%193 = sub nsw i32 64, %192
%194 = ashr i32 %191, %193
store i32 %194, i32* %21
%195 = load i32*, i32** %8
%196 = load i32, i32* %13
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
%200 = load i32, i32* %18
%201 = sub nsw i32 64, %200
%202 = ashr i32 %199, %201
store i32 %202, i32* %22
store i32 0, i32* %23
store i32 0, i32* %24
br label %203
203: ; preds = %283, %186
%204 = load i32, i32* %24
%205 = load i32, i32* %18
%206 = icmp slt i32 %204, %205
br i1 %206, label %207, label %211
207: ; preds = %203
%208 = load i32, i32* %23
%209 = icmp ne i32 %208, 0
%210 = xor i1 %209, true
br label %211
211: ; preds = %207, %203
%212 = phi i1 [ false, %203 ], [ %210, %207 ]
br i1 %212, label %213, label %286
213: ; preds = %211
%214 = load i32, i32* %21
%215 = load i32, i32* %24
%216 = ashr i32 %214, %215
%217 = load i32, i32* %22
%218 = load i32, i32* %24
%219 = ashr i32 %217, %218
%220 = icmp eq i32 %216, %219
br i1 %220, label %221, label %283
221: ; preds = %213
store i32 1, i32* %23
%222 = load i32, i32* %18
%223 = load i32, i32* %24
%224 = sub nsw i32 %222, %223
%225 = load i32, i32* %12
%226 = add nsw i32 %225, %224
store i32 %226, i32* %12
%227 = load i32, i32* %24
%228 = icmp eq i32 %227, 0
br i1 %228, label %229, label %282
229: ; preds = %221
%230 = load i16, i16* %9
%231 = zext i16 %230 to i32
%232 = load i16, i16* %10
%233 = zext i16 %232 to i32
%234 = icmp eq i32 %231, %233
br i1 %234, label %235, label %237
235: ; preds = %229
%236 = load i8*, i8** %11
store i8 -1, i8* %236
br label %281
237: ; preds = %229
%238 = load i16, i16* %9
%239 = zext i16 %238 to i32
%240 = load i16, i16* %10
%241 = zext i16 %240 to i32
%242 = icmp slt i32 %239, %241
br i1 %242, label %243, label %278
243: ; preds = %237
%244 = load i32, i32* %18
%245 = icmp slt i32 %244, 64
br i1 %245, label %246, label %258
246: ; preds = %243
%247 = load i32*, i32** %8
%248 = load i32, i32* %13
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
%251 = load i32, i32* %18
%252 = call i32 @getBit64(i32* %250, i32 %251)
store i32 %252, i32* %14
%253 = load i32, i32* %14
%254 = icmp eq i32 %253, 0
br i1 %254, label %255, label %257
255: ; preds = %246
%256 = load i8*, i8** %11
store i8 0, i8* %256
br label %257
257: ; preds = %255, %246
br label %277
258: ; preds = %243
%259 = load i32, i32* %13
%260 = add nsw i32 %259, 1
%261 = icmp sge i32 %260, 4
br i1 %261, label %262, label %265
262: ; preds = %258
%263 = call i32 @printf(i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str, i64 0, i64 0))
%264 = call i32 @exit(i32 1)
unreachable
265: ; preds = %258
%266 = load i32*, i32** %8
%267 = load i32, i32* %13
%268 = add nsw i32 %267, 1
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32, i32* %266, i64 %269
%271 = call i32 @getBit64(i32* %270, i32 0)
store i32 %271, i32* %14
%272 = load i32, i32* %14
%273 = icmp eq i32 %272, 0
br i1 %273, label %274, label %276
274: ; preds = %265
%275 = load i8*, i8** %11
store i8 0, i8* %275
br label %276
276: ; preds = %274, %265
br label %277
277: ; preds = %276, %257
br label %280
278: ; preds = %237
%279 = load i8*, i8** %11
store i8 -1, i8* %279
br label %280
280: ; preds = %278, %277
br label %281
281: ; preds = %280, %235
br label %282
282: ; preds = %281, %221
br label %283
283: ; preds = %282, %213
%284 = load i32, i32* %24
%285 = add nsw i32 %284, 1
store i32 %285, i32* %24
br label %203
286: ; preds = %211
br label %287
287: ; preds = %286, %185
br label %288
288: ; preds = %287
%289 = load i32, i32* %12
store i32 %289, i32* %6
br label %290
290: ; preds = %288, %116
%291 = load i32, i32* %6
ret i32 %291
}

LLVM IR (-O2):
@str.1 = [92 x i8] c"Unexpected error while extracting lcp from bit sequence. Trying to access more than 4 longs\00"
define i32 @getLCPInBits(i32* nocapture %0, i32* %1, i16 zeroext %2, i16 zeroext %3, i8* nocapture writeonly %4) {
%6 = zext i16 %2 to i32
%7 = zext i16 %3 to i32
%8 = icmp ugt i32 %6, %7
%9 = select i1 %8, i32 %7, i32 %6
%10 = shl nuw nsw i32 %9, 1
%11 = lshr i32 %9, 5
%12 = and i32 %10, 62
%13 = icmp eq i32 %12, 0
%14 = xor i1 %13, true
%15 = zext i1 %14 to i32
%16 = select i1 %13, i32 64, i32 %12
%17 = add nsw i32 %11, -1
%18 = add nsw i32 %17, %15
%19 = icmp sgt i32 %18, 0
br i1 %19, label %20, label %55
20: ; preds = %5, %20
%21 = phi i32 [ %32, %20 ], [ 0, %5 ]
%22 = phi i32 [ %31, %20 ], [ 0, %5 ]
%23 = zext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %0, i64 %23
%25 = load i32, i32* %24
%26 = getelementptr inbounds i32, i32* %1, i64 %23
%27 = load i32, i32* %26
%28 = icmp eq i32 %25, %27
%29 = add nsw i32 %21, 64
%30 = zext i1 %28 to i32
%31 = add nuw nsw i32 %22, %30
%32 = select i1 %28, i32 %29, i32 %21
%33 = icmp slt i32 %31, %18
%34 = select i1 %33, i1 %28, i1 false
br i1 %34, label %20, label %35
35: ; preds = %20
br i1 %28, label %55, label %36
36: ; preds = %35
%37 = zext i32 %31 to i64
%38 = getelementptr inbounds i32, i32* %0, i64 %37
%39 = load i32, i32* %38
%40 = getelementptr inbounds i32, i32* %1, i64 %37
%41 = load i32, i32* %40
br label %42
42: ; preds = %36, %42
%43 = phi i32 [ %21, %36 ], [ %51, %42 ]
%44 = phi i32 [ 0, %36 ], [ %45, %42 ]
%45 = add nuw nsw i32 %44, 1
%46 = ashr i32 %39, %45
%47 = ashr i32 %41, %45
%48 = icmp eq i32 %46, %47
%49 = sub nsw i32 63, %44
%50 = select i1 %48, i32 %49, i32 0
%51 = add nsw i32 %50, %43
%52 = xor i1 %48, true
%53 = icmp ult i32 %44, 64
%54 = select i1 %52, i1 %53, i1 false
br i1 %54, label %42, label %130
55: ; preds = %5, %35
%56 = phi i32 [ %29, %35 ], [ 0, %5 ]
%57 = phi i32 [ %31, %35 ], [ 0, %5 ]
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %0, i64 %58
%60 = load i32, i32* %59
%61 = getelementptr inbounds i32, i32* %1, i64 %58
%62 = load i32, i32* %61
%63 = icmp eq i32 %60, %62
br i1 %63, label %64, label %89
64: ; preds = %55
%65 = add nsw i32 %56, %16
%66 = icmp eq i16 %2, %3
br i1 %66, label %67, label %68
67: ; preds = %64
store i8 -1, i8* %4
br label %130
68: ; preds = %64
%69 = icmp ult i16 %2, %3
br i1 %69, label %70, label %88
70: ; preds = %68
%71 = icmp ult i32 %16, 64
br i1 %71, label %72, label %76
72: ; preds = %70
%73 = tail call i32 @getBit64(i32* %61, i32 %16)
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %130
75: ; preds = %72
store i8 0, i8* %4
br label %130
76: ; preds = %70
%77 = icmp ugt i32 %57, 2
br i1 %77, label %78, label %81
78: ; preds = %76
%79 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.1, i64 0, i64 0))
%80 = tail call i32 @exit(i32 1)
unreachable
81: ; preds = %76
%82 = add nuw nsw i32 %57, 1
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %1, i64 %83
%85 = tail call i32 @getBit64(i32* %84, i32 0)
%86 = icmp eq i32 %85, 0
br i1 %86, label %87, label %130
87: ; preds = %81
store i8 0, i8* %4
br label %130
88: ; preds = %68
store i8 -1, i8* %4
br label %130
89: ; preds = %55
%90 = sub nsw i32 64, %16
%91 = ashr i32 %60, %90
%92 = ashr i32 %62, %90
%93 = icmp ult i16 %2, %3
%94 = icmp ult i32 %16, 64
%95 = icmp ugt i32 %57, 2
%96 = add nuw nsw i32 %57, 1
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %1, i64 %97
%99 = icmp eq i32 %91, %92
br i1 %99, label %100, label %116
100: ; preds = %89
%101 = icmp eq i16 %2, %3
%102 = add nsw i32 %16, %56
br i1 %101, label %115, label %103
103: ; preds = %100
br i1 %93, label %105, label %104
104: ; preds = %103
store i8 -1, i8* %4
br label %130
105: ; preds = %103
br i1 %94, label %111, label %106
106: ; preds = %105
br i1 %95, label %124, label %107
107: ; preds = %106
%108 = tail call i32 @getBit64(i32* %98, i32 0)
%109 = icmp eq i32 %108, 0
br i1 %109, label %110, label %130
110: ; preds = %107
store i8 0, i8* %4
br label %130
111: ; preds = %105
%112 = tail call i32 @getBit64(i32* %61, i32 %16)
%113 = icmp eq i32 %112, 0
br i1 %113, label %114, label %130
114: ; preds = %111
store i8 0, i8* %4
br label %130
115: ; preds = %100
store i8 -1, i8* %4
br label %130
116: ; preds = %89, %127
%117 = phi i32 [ %128, %127 ], [ 1, %89 ]
%118 = ashr i32 %91, %117
%119 = ashr i32 %92, %117
%120 = icmp eq i32 %118, %119
br i1 %120, label %121, label %127
121: ; preds = %116
%122 = sub nsw i32 %16, %117
%123 = add nsw i32 %122, %56
br label %130
124: ; preds = %106
%125 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([92 x i8], [92 x i8]* @str.1, i64 0, i64 0))
%126 = tail call i32 @exit(i32 1)
unreachable
127: ; preds = %116
%128 = add nuw nsw i32 %117, 1
%129 = icmp ugt i32 %16, %128
br i1 %129, label %116, label %130
130: ; preds = %42, %127, %104, %107, %110, %111, %114, %115, %121, %67, %75, %72, %87, %81, %88
%131 = phi i32 [ %65, %67 ], [ %65, %75 ], [ %65, %72 ], [ %65, %87 ], [ %65, %81 ], [ %65, %88 ], [ %123, %121 ], [ %102, %115 ], [ %102, %114 ], [ %102, %111 ], [ %102, %110 ], [ %102, %107 ], [ %102, %104 ], [ %56, %127 ], [ %51, %42 ]
ret i32 %131
}