#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 */
bool k_match(const char *s1, const char *q1, size_t len1, const char *s2,
             const char *q2, size_t len2, unsigned short min_match,
             unsigned short max_mismatch, char adj_q_cut) {
  size_t i;
  size_t mismatch = 0;
  size_t match = 0;
  for (i = 0; ((i < len1) && (i < len2)); i++) {
    if ((s1[i] == s2[i] && s1[i] != 'N') ||
        ((q1[i] >= adj_q_cut) && (q2[i] >= adj_q_cut))) {
      if (s1[i] != s2[i] || s1[i] == 'N') {
        mismatch++;
        if (mismatch > max_mismatch)
          return false;
      } else {
        match++;
      }
    }
  }
  if (match >= min_match)
    return true;
  return false;
}


x86 assembly (clang, -O0):
<k_match>:
push   %rbp
mov    %rsp,%rbp
mov    0x20(%rbp),%al
mov    0x18(%rbp),%ax
mov    0x10(%rbp),%ax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x20(%rbp),%rcx
mov    %al,-0x51(%rbp)
jae    1160 <k_match+0x60>
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
setb   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    1170 <k_match+0x70>
jmp    125f <k_match+0x15f>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    11a5 <k_match+0xa5>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    11d5 <k_match+0xd5>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl 0x20(%rbp),%ecx
cmp    %ecx,%eax
jl     1249 <k_match+0x149>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movsbl 0x20(%rbp),%ecx
cmp    %ecx,%eax
jl     1249 <k_match+0x149>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x40(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    120a <k_match+0x10a>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1238 <k_match+0x138>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
movzwl 0x18(%rbp),%ecx
cmp    %rcx,%rax
jbe    1233 <k_match+0x133>
movl   $0x0,-0x4(%rbp)
jmp    1283 <k_match+0x183>
jmp    1244 <k_match+0x144>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1249 <k_match+0x149>
jmp    124e <k_match+0x14e>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    113f <k_match+0x3f>
mov    -0x50(%rbp),%rax
movzwl 0x10(%rbp),%ecx
cmp    %rcx,%rax
jb     127c <k_match+0x17c>
movl   $0x1,-0x4(%rbp)
jmp    1283 <k_match+0x183>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<k_match>:
push   %rbp
push   %r14
push   %rbx
xor    %r10d,%r10d
test   %rdx,%rdx
je     1173 <k_match+0x73>
test   %r9,%r9
je     1173 <k_match+0x73>
mov    0x30(%rsp),%r14b
movzwl 0x28(%rsp),%r11d
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%r9
cmovb  %r9,%rdx
add    $0x1,%rdx
xor    %r10d,%r10d
xor    %ebp,%ebp
xor    %ebx,%ebx
jmp    114d <k_match+0x4d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x1,%rbx
cmp    %rbx,%rdx
je     1173 <k_match+0x73>
movzbl (%rdi,%rbx,1),%eax
cmp    $0x4e,%al
je     115a <k_match+0x5a>
cmp    (%rcx,%rbx,1),%al
je     1140 <k_match+0x40>
cmp    %r14b,(%rsi,%rbx,1)
jl     1144 <k_match+0x44>
cmp    %r14b,(%r8,%rbx,1)
jl     1144 <k_match+0x44>
add    $0x1,%rbp
cmp    %r11,%rbp
jbe    1144 <k_match+0x44>
xor    %eax,%eax
jmp    1180 <k_match+0x80>
movzwl 0x20(%rsp),%ecx
xor    %eax,%eax
cmp    %rcx,%r10
setae  %al
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @k_match(i8* nocapture %0, i8* nocapture %1, i64 %2, i8* nocapture %3, i8* nocapture %4, i64 %5, i16 zeroext %6, i16 zeroext %7, i8 signext %8) {
%10 = icmp ne i64 %2, 0
%11 = icmp ne i64 %5, 0
%12 = and i1 %10, %11
br i1 %12, label %13, label %47
13: ; preds = %9
%14 = zext i16 %7 to i64
%15 = add i64 %5, -1
%16 = add i64 %2, -1
%17 = call i64 @llvm.umin.i64(i64 %15, i64 %16)
br label %18
18: ; preds = %13, %42
%19 = phi i64 [ 0, %13 ], [ %44, %42 ]
%20 = phi i64 [ 0, %13 ], [ %43, %42 ]
%21 = phi i64 [ 0, %13 ], [ %45, %42 ]
%22 = getelementptr inbounds i8, i8* %0, i64 %21
%23 = load i8, i8* %22
%24 = getelementptr inbounds i8, i8* %3, i64 %21
%25 = load i8, i8* %24
%26 = icmp ne i8 %23, %25
%27 = icmp eq i8 %23, 78
%28 = or i1 %27, %26
br i1 %28, label %29, label %40
29: ; preds = %18
%30 = getelementptr inbounds i8, i8* %1, i64 %21
%31 = load i8, i8* %30
%32 = icmp slt i8 %31, %8
br i1 %32, label %42, label %33
33: ; preds = %29
%34 = getelementptr inbounds i8, i8* %4, i64 %21
%35 = load i8, i8* %34
%36 = icmp slt i8 %35, %8
br i1 %36, label %42, label %37
37: ; preds = %33
%38 = add i64 %20, 1
%39 = icmp ugt i64 %38, %14
br i1 %39, label %52, label %42
40: ; preds = %18
%41 = add i64 %19, 1
br label %42
42: ; preds = %29, %33, %37, %40
%43 = phi i64 [ %38, %37 ], [ %20, %40 ], [ %20, %33 ], [ %20, %29 ]
%44 = phi i64 [ %19, %37 ], [ %41, %40 ], [ %19, %33 ], [ %19, %29 ]
%45 = add nuw i64 %21, 1
%46 = icmp eq i64 %21, %17
br i1 %46, label %47, label %18
47: ; preds = %42, %9
%48 = phi i64 [ 0, %9 ], [ %44, %42 ]
%49 = zext i16 %6 to i64
%50 = icmp uge i64 %48, %49
%51 = zext i1 %50 to i32
br label %52
52: ; preds = %37, %47
%53 = phi i32 [ %51, %47 ], [ 0, %37 ]
ret i32 %53
}