#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 scalar_t__ uint32_t;

/* Variables and functions */
int ULONG_MAX;
int /*<<< orphan*/ copy_eliminate_sequences(char **, int, char **, char);
int /*<<< orphan*/ memcmp(char *, char *, size_t);
scalar_t__ score_strings(char *, size_t, char *, size_t, unsigned long);
int sscanf(char const *, char *, unsigned long *);
char *strchr(char const *, char);
int fuzzy_compare(const char *str1, const char *str2) {
  unsigned long block_size1, block_size2;
  uint32_t score = 0;
  size_t s1b1len, s1b2len, s2b1len, s2b2len;
  char s1b1[64], s1b2[64];
  char s2b1[64], s2b2[64];
  char *s1p, *s2p, *tmp;
  if (NULL == str1 || NULL == str2)
    return -1;
  if (sscanf(str1, "%lu:", &block_size1) != 1 ||
      sscanf(str2, "%lu:", &block_size2) != 1) {
    return -1;
  }
  if (block_size1 != block_size2 &&
      (block_size1 > ULONG_MAX / 2 || block_size1 * 2 != block_size2) &&
      (block_size1 % 2 == 1 || block_size1 / 2 != block_size2)) {
    return 0;
  }
  s1p = strchr(str1, ':');
  s2p = strchr(str2, ':');
  if (!s1p || !s2p) {
    return -1;
  }
  ++s1p;
  tmp = s1b1;
  if (!copy_eliminate_sequences(&tmp, 64, &s1p, ':'))
    return -1;
  s1b1len = tmp - s1b1;
  if (!*s1p++) {
    return -1;
  }
  tmp = s1b2;
  if (!copy_eliminate_sequences(&tmp, 64, &s1p, ','))
    return -1;
  s1b2len = tmp - s1b2;
  ++s2p;
  tmp = s2b1;
  if (!copy_eliminate_sequences(&tmp, 64, &s2p, ':'))
    return -1;
  s2b1len = tmp - s2b1;
  if (!*s2p++) {
    return -1;
  }
  tmp = s2b2;
  if (!copy_eliminate_sequences(&tmp, 64, &s2p, ','))
    return -1;
  s2b2len = tmp - s2b2;
  if (block_size1 == block_size2 && s1b1len == s2b1len && s1b2len == s2b2len) {
    if (!memcmp(s1b1, s2b1, s1b1len) && !memcmp(s1b2, s2b2, s1b2len)) {
      return 100;
    }
  }
  if (block_size1 <= ULONG_MAX / 2) {
    if (block_size1 == block_size2) {
      uint32_t score1, score2;
      score1 = score_strings(s1b1, s1b1len, s2b1, s2b1len, block_size1);
      score2 = score_strings(s1b2, s1b2len, s2b2, s2b2len, block_size1 * 2);
      score = ((score1) > (score2) ? (score1) : (score2));
    } else if (block_size1 * 2 == block_size2) {
      score = score_strings(s2b1, s2b1len, s1b2, s1b2len, block_size2);
    } else {
      score = score_strings(s1b1, s1b1len, s2b2, s2b2len, block_size1);
    }
  } else {
    if (block_size1 == block_size2) {
      score = score_strings(s1b1, s1b1len, s2b1, s2b1len, block_size1);
    } else if (block_size1 % 2 == 0 && block_size1 / 2 == block_size2) {
      score = score_strings(s1b1, s1b1len, s2b2, s2b2len, block_size1);
    } else {
      score = 0;
    }
  }
  return (int)score;
}


x86 assembly (clang, -O0):
<fuzzy_compare>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x10(%rbp),%rax
je     1183 <fuzzy_compare+0x33>
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
jne    118f <fuzzy_compare+0x3f>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x10(%rbp),%rdi
lea    0xe66(%rip),%rsi
lea    -0x20(%rbp),%rdx
call   1070 <sscanf@plt>
cmp    $0x1,%eax
jne    11c9 <fuzzy_compare+0x79>
mov    -0x18(%rbp),%rdi
lea    0xe49(%rip),%rsi
lea    -0x28(%rbp),%rdx
call   1070 <sscanf@plt>
cmp    $0x1,%eax
je     11d5 <fuzzy_compare+0x85>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
je     1256 <fuzzy_compare+0x106>
mov    -0x20(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    0x2de3(%rip),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x180(%rbp),%rax
movslq %ecx,%rcx
cmp    %rcx,%rax
ja     1226 <fuzzy_compare+0xd6>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
cmp    -0x28(%rbp),%rax
je     1256 <fuzzy_compare+0x106>
mov    -0x20(%rbp),%rax
and    $0x1,%rax
cmp    $0x1,%rax
je     124a <fuzzy_compare+0xfa>
mov    -0x20(%rbp),%rax
shr    $0x1,%rax
cmp    -0x28(%rbp),%rax
je     1256 <fuzzy_compare+0x106>
movl   $0x0,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x10(%rbp),%rdi
mov    $0x3a,%esi
call   1050 <strchr@plt>
mov    %rax,-0x158(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x3a,%esi
call   1050 <strchr@plt>
mov    %rax,-0x160(%rbp)
cmpq   $0x0,-0x158(%rbp)
je     129c <fuzzy_compare+0x14c>
cmpq   $0x0,-0x160(%rbp)
jne    12a8 <fuzzy_compare+0x158>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
lea    -0x90(%rbp),%rax
mov    %rax,-0x168(%rbp)
lea    -0x168(%rbp),%rdi
mov    $0x40,%esi
lea    -0x158(%rbp),%rdx
mov    $0x3a,%ecx
call   1030 <copy_eliminate_sequences@plt>
cmp    $0x0,%eax
jne    12fa <fuzzy_compare+0x1aa>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x168(%rbp),%rax
lea    -0x90(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x158(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x158(%rbp)
cmpb   $0x0,(%rax)
jne    1339 <fuzzy_compare+0x1e9>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
lea    -0xd0(%rbp),%rax
mov    %rax,-0x168(%rbp)
lea    -0x168(%rbp),%rdi
mov    $0x40,%esi
lea    -0x158(%rbp),%rdx
mov    $0x2c,%ecx
call   1030 <copy_eliminate_sequences@plt>
cmp    $0x0,%eax
jne    1379 <fuzzy_compare+0x229>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x168(%rbp),%rax
lea    -0xd0(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
lea    -0x110(%rbp),%rax
mov    %rax,-0x168(%rbp)
lea    -0x168(%rbp),%rdi
mov    $0x40,%esi
lea    -0x160(%rbp),%rdx
mov    $0x3a,%ecx
call   1030 <copy_eliminate_sequences@plt>
cmp    $0x0,%eax
jne    13e0 <fuzzy_compare+0x290>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x168(%rbp),%rax
lea    -0x110(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x160(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x160(%rbp)
cmpb   $0x0,(%rax)
jne    141f <fuzzy_compare+0x2cf>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
lea    -0x150(%rbp),%rax
mov    %rax,-0x168(%rbp)
lea    -0x168(%rbp),%rdi
mov    $0x40,%esi
lea    -0x160(%rbp),%rdx
mov    $0x2c,%ecx
call   1030 <copy_eliminate_sequences@plt>
cmp    $0x0,%eax
jne    145f <fuzzy_compare+0x30f>
movl   $0xffffffff,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
mov    -0x168(%rbp),%rax
lea    -0x150(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jne    14ef <fuzzy_compare+0x39f>
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    14ef <fuzzy_compare+0x39f>
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    14ef <fuzzy_compare+0x39f>
lea    -0x90(%rbp),%rdi
lea    -0x110(%rbp),%rsi
mov    -0x38(%rbp),%rdx
call   1060 <memcmp@plt>
cmp    $0x0,%eax
jne    14ea <fuzzy_compare+0x39a>
lea    -0xd0(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1060 <memcmp@plt>
cmp    $0x0,%eax
jne    14ea <fuzzy_compare+0x39a>
movl   $0x64,-0x4(%rbp)
jmp    16c5 <fuzzy_compare+0x575>
jmp    14ef <fuzzy_compare+0x39f>
mov    -0x20(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    0x2ad7(%rip),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x188(%rbp),%rax
movslq %ecx,%rcx
cmp    %rcx,%rax
ja     162a <fuzzy_compare+0x4da>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jne    15c3 <fuzzy_compare+0x473>
lea    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%rsi
lea    -0x110(%rbp),%rdx
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%r8
call   1040 <score_strings@plt>
mov    %rax,-0x170(%rbp)
lea    -0xd0(%rbp),%rdi
mov    -0x40(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0x20(%rbp),%r8
shl    $0x1,%r8
call   1040 <score_strings@plt>
mov    %rax,-0x178(%rbp)
mov    -0x170(%rbp),%rax
cmp    -0x178(%rbp),%rax
jle    15a5 <fuzzy_compare+0x455>
mov    -0x170(%rbp),%rax
mov    %rax,-0x190(%rbp)
jmp    15b3 <fuzzy_compare+0x463>
mov    -0x178(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x190(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1625 <fuzzy_compare+0x4d5>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
cmp    -0x28(%rbp),%rax
jne    15fd <fuzzy_compare+0x4ad>
lea    -0x110(%rbp),%rdi
mov    -0x48(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%r8
call   1040 <score_strings@plt>
mov    %rax,-0x30(%rbp)
jmp    1620 <fuzzy_compare+0x4d0>
lea    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0x20(%rbp),%r8
call   1040 <score_strings@plt>
mov    %rax,-0x30(%rbp)
jmp    1625 <fuzzy_compare+0x4d5>
jmp    16be <fuzzy_compare+0x56e>
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jne    1660 <fuzzy_compare+0x510>
lea    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%rsi
lea    -0x110(%rbp),%rdx
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%r8
call   1040 <score_strings@plt>
mov    %rax,-0x30(%rbp)
jmp    16b9 <fuzzy_compare+0x569>
mov    -0x20(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    16ac <fuzzy_compare+0x55c>
mov    -0x20(%rbp),%rax
shr    $0x1,%rax
cmp    -0x28(%rbp),%rax
jne    16ac <fuzzy_compare+0x55c>
lea    -0x90(%rbp),%rdi
mov    -0x38(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    -0x50(%rbp),%rcx
mov    -0x20(%rbp),%r8
call   1040 <score_strings@plt>
mov    %rax,-0x30(%rbp)
jmp    16b4 <fuzzy_compare+0x564>
movq   $0x0,-0x30(%rbp)
jmp    16b9 <fuzzy_compare+0x569>
jmp    16be <fuzzy_compare+0x56e>
mov    -0x30(%rbp),%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fuzzy_compare>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
test   %rdi,%rdi
je     13cf <fuzzy_compare+0x27f>
mov    %rsi,%rbx
test   %rsi,%rsi
je     13cf <fuzzy_compare+0x27f>
mov    %rdi,%rbp
lea    0xe80(%rip),%rsi
lea    0x20(%rsp),%rdx
call   1060 <sscanf@plt>
cmp    $0x1,%eax
jne    13cf <fuzzy_compare+0x27f>
lea    0xe66(%rip),%rsi
lea    0x28(%rsp),%rdx
mov    %rbx,%rdi
call   1060 <sscanf@plt>
cmp    $0x1,%eax
jne    13cf <fuzzy_compare+0x27f>
mov    0x20(%rsp),%rcx
mov    0x28(%rsp),%rdx
cmp    %rdx,%rcx
je     11f9 <fuzzy_compare+0xa9>
mov    0x2e12(%rip),%rax
mov    (%rax),%eax
mov    %eax,%esi
shr    $0x1f,%esi
add    %eax,%esi
sar    %esi
movslq %esi,%rax
cmp    %rax,%rcx
ja     11e2 <fuzzy_compare+0x92>
lea    (%rcx,%rcx,1),%rax
cmp    %rdx,%rax
je     11f9 <fuzzy_compare+0xa9>
xor    %eax,%eax
test   $0x1,%cl
jne    13d4 <fuzzy_compare+0x284>
shr    %rcx
cmp    %rdx,%rcx
jne    13d4 <fuzzy_compare+0x284>
mov    %rbp,%rdi
mov    $0x3a,%esi
call   1050 <strchr@plt>
mov    %rax,%rbp
mov    %rbx,%rdi
mov    $0x3a,%esi
call   1050 <strchr@plt>
test   %rbp,%rbp
je     13cf <fuzzy_compare+0x27f>
mov    %rax,%rbx
test   %rax,%rax
je     13cf <fuzzy_compare+0x27f>
add    $0x1,%rbp
mov    %rbp,0x18(%rsp)
lea    0x70(%rsp),%rbp
mov    %rbp,0x8(%rsp)
lea    0x8(%rsp),%rdi
lea    0x18(%rsp),%rdx
mov    $0x40,%esi
mov    $0x3a,%ecx
call   1030 <copy_eliminate_sequences@plt>
test   %eax,%eax
je     13cf <fuzzy_compare+0x27f>
mov    0x8(%rsp),%r12
mov    0x18(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x18(%rsp)
cmpb   $0x0,(%rax)
je     13cf <fuzzy_compare+0x27f>
lea    0xf0(%rsp),%r13
mov    %r13,0x8(%rsp)
lea    0x8(%rsp),%rdi
lea    0x18(%rsp),%rdx
mov    $0x40,%esi
mov    $0x2c,%ecx
call   1030 <copy_eliminate_sequences@plt>
test   %eax,%eax
je     13cf <fuzzy_compare+0x27f>
mov    0x8(%rsp),%r14
add    $0x1,%rbx
mov    %rbx,0x10(%rsp)
lea    0xb0(%rsp),%rbx
mov    %rbx,0x8(%rsp)
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rdx
mov    $0x40,%esi
mov    $0x3a,%ecx
call   1030 <copy_eliminate_sequences@plt>
test   %eax,%eax
je     13cf <fuzzy_compare+0x27f>
mov    0x8(%rsp),%r15
mov    0x10(%rsp),%rax
lea    0x1(%rax),%rcx
mov    %rcx,0x10(%rsp)
cmpb   $0x0,(%rax)
je     13cf <fuzzy_compare+0x27f>
lea    0x30(%rsp),%rax
mov    %rax,0x8(%rsp)
lea    0x8(%rsp),%rdi
lea    0x10(%rsp),%rdx
mov    $0x40,%esi
mov    $0x2c,%ecx
call   1030 <copy_eliminate_sequences@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
test   %ecx,%ecx
je     13d4 <fuzzy_compare+0x284>
sub    %rbp,%r12
sub    %r13,%r14
sub    %rbx,%r15
mov    0x8(%rsp),%rbx
lea    0x30(%rsp),%rax
sub    %rax,%rbx
mov    0x20(%rsp),%r13
mov    0x28(%rsp),%rbp
cmp    %rbp,%r13
jne    1398 <fuzzy_compare+0x248>
cmp    %r15,%r12
jne    1398 <fuzzy_compare+0x248>
cmp    %rbx,%r14
jne    1398 <fuzzy_compare+0x248>
lea    0x70(%rsp),%rdi
lea    0xb0(%rsp),%rsi
mov    %r12,%rdx
call   1070 <bcmp@plt>
test   %eax,%eax
jne    1398 <fuzzy_compare+0x248>
lea    0xf0(%rsp),%rdi
lea    0x30(%rsp),%rsi
mov    %r14,%rdx
call   1070 <bcmp@plt>
test   %eax,%eax
je     148a <fuzzy_compare+0x33a>
mov    0x2c39(%rip),%rax
mov    (%rax),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
cmp    %rax,%r13
jbe    13e6 <fuzzy_compare+0x296>
cmp    %rbp,%r13
jne    1432 <fuzzy_compare+0x2e2>
lea    0x70(%rsp),%rdi
lea    0xb0(%rsp),%rdx
mov    %r12,%rsi
mov    %r15,%rcx
jmp    147d <fuzzy_compare+0x32d>
mov    $0xffffffff,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %rbp,%r13
jne    1447 <fuzzy_compare+0x2f7>
lea    0x70(%rsp),%rdi
lea    0xb0(%rsp),%rdx
mov    %r12,%rsi
mov    %r15,%rcx
mov    %r13,%r8
call   1040 <score_strings@plt>
mov    %rax,%rbp
mov    0x20(%rsp),%r8
add    %r8,%r8
lea    0xf0(%rsp),%rdi
lea    0x30(%rsp),%rdx
mov    %r14,%rsi
mov    %rbx,%rcx
call   1040 <score_strings@plt>
cmp    %rax,%rbp
cmovg  %rbp,%rax
jmp    13d4 <fuzzy_compare+0x284>
xor    %eax,%eax
test   $0x1,%r13b
jne    13d4 <fuzzy_compare+0x284>
mov    %r13,%rcx
shr    %rcx
cmp    %rbp,%rcx
je     146d <fuzzy_compare+0x31d>
jmp    13d4 <fuzzy_compare+0x284>
mov    %r13,%rax
add    %r13,%rax
cmp    %rbp,%rax
jne    146d <fuzzy_compare+0x31d>
lea    0xb0(%rsp),%rdi
lea    0xf0(%rsp),%rdx
mov    %r15,%rsi
mov    %r14,%rcx
mov    %rbp,%r8
jmp    1480 <fuzzy_compare+0x330>
lea    0x70(%rsp),%rdi
lea    0x30(%rsp),%rdx
mov    %r12,%rsi
mov    %rbx,%rcx
mov    %r13,%r8
call   1040 <score_strings@plt>
jmp    13d4 <fuzzy_compare+0x284>
mov    $0x64,%eax
jmp    13d4 <fuzzy_compare+0x284>

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

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