#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 */
int /*<<< orphan*/ assert(int);
int stb__find_qstring(char *, char *, int, int);
scalar_t__ stb__match_qstring(char *, char *, int, int);
scalar_t__ tolower(char);
int stb__wildmatch_raw2(char *expr, char *candidate, int search,
                        int insensitive) {
  int where = 0;
  int start = -1;
  if (!search) {
    if (*expr != '*')
      start = 0;
    while (*expr != '*') {
      if (!*expr)
        return *candidate == 0 ? 0 : -1;
      if (*expr == '?') {
        if (!*candidate)
          return -1;
      } else {
        if (insensitive) {
          if (tolower(*candidate) != tolower(*expr))
            return -1;
        } else if (*candidate != *expr)
          return -1;
      }
      ++candidate, ++expr, ++where;
    }
  } else {
    if (!*expr)
      return 0;
  }
  assert(search || *expr == '*');
  if (!search)
    ++expr;
  while (*expr) {
    int o = 0;
    while (expr[0] == '*')
      ++expr;
    if (!expr[0])
      return start >= 0 ? start : 0;
    o = 0;
    while (expr[o] != '*') {
      if (expr[o] == 0)
        break;
      ++o;
    }
    if (expr[o] == 0 && !search) {
      int z;
      for (z = 0; z < o; ++z)
        if (candidate[z] == 0)
          return -1;
      while (candidate[z])
        ++z;
      if (stb__match_qstring(candidate + z - o, expr, o, insensitive))
        return start >= 0 ? start : 0;
      return -1;
    } else {
      int n = stb__find_qstring(candidate, expr, o, insensitive);
      if (n < 0)
        return -1;
      if (start < 0)
        start = where + n;
      expr += o;
      candidate += n + o;
    }
    if (*expr == 0) {
      assert(search);
      return start;
    }
    assert(*expr == '*');
    ++expr;
  }
  return start >= 0 ? start : 0;
}


x86 assembly (clang, -O0):
<stb__wildmatch_raw2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0xffffffff,-0x28(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    128f <stb__wildmatch_raw2+0x14f>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
je     1185 <stb__wildmatch_raw2+0x45>
movl   $0x0,-0x28(%rbp)
jmp    118a <stb__wildmatch_raw2+0x4a>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
je     128a <stb__wildmatch_raw2+0x14a>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11c3 <stb__wildmatch_raw2+0x83>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edx
mov    $0xffffffff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
jne    11f1 <stb__wildmatch_raw2+0xb1>
mov    -0x18(%rbp),%rax
cmpb   $0x0,(%rax)
jne    11ec <stb__wildmatch_raw2+0xac>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
jmp    1264 <stb__wildmatch_raw2+0x124>
cmpl   $0x0,-0x20(%rbp)
je     1238 <stb__wildmatch_raw2+0xf8>
mov    -0x18(%rbp),%rax
movsbl (%rax),%edi
call   1060 <tolower@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%edi
call   1060 <tolower@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
je     1233 <stb__wildmatch_raw2+0xf3>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
jmp    125f <stb__wildmatch_raw2+0x11f>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     125a <stb__wildmatch_raw2+0x11a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
jmp    125f <stb__wildmatch_raw2+0x11f>
jmp    1264 <stb__wildmatch_raw2+0x124>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    118a <stb__wildmatch_raw2+0x4a>
jmp    12ad <stb__wildmatch_raw2+0x16d>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    12a8 <stb__wildmatch_raw2+0x168>
movl   $0x0,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
jmp    12ad <stb__wildmatch_raw2+0x16d>
mov    $0x1,%al
cmpl   $0x0,-0x1c(%rbp)
mov    %al,-0x41(%rbp)
jne    12cc <stb__wildmatch_raw2+0x18c>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
sete   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
cmpl   $0x0,-0x1c(%rbp)
jne    12ef <stb__wildmatch_raw2+0x1af>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12f4 <stb__wildmatch_raw2+0x1b4>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
je     1544 <stb__wildmatch_raw2+0x404>
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
jne    1329 <stb__wildmatch_raw2+0x1e9>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1308 <stb__wildmatch_raw2+0x1c8>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1360 <stb__wildmatch_raw2+0x220>
cmpl   $0x0,-0x28(%rbp)
jl     134b <stb__wildmatch_raw2+0x20b>
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1355 <stb__wildmatch_raw2+0x215>
xor    %eax,%eax
mov    %eax,-0x48(%rbp)
jmp    1355 <stb__wildmatch_raw2+0x215>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2a,%eax
je     13a4 <stb__wildmatch_raw2+0x264>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1396 <stb__wildmatch_raw2+0x256>
jmp    13a4 <stb__wildmatch_raw2+0x264>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1367 <stb__wildmatch_raw2+0x227>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1495 <stb__wildmatch_raw2+0x355>
cmpl   $0x0,-0x1c(%rbp)
jne    1495 <stb__wildmatch_raw2+0x355>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    140a <stb__wildmatch_raw2+0x2ca>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    13f7 <stb__wildmatch_raw2+0x2b7>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
jmp    13fc <stb__wildmatch_raw2+0x2bc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13ca <stb__wildmatch_raw2+0x28a>
jmp    140f <stb__wildmatch_raw2+0x2cf>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     142f <stb__wildmatch_raw2+0x2ef>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    140f <stb__wildmatch_raw2+0x2cf>
mov    -0x18(%rbp),%rdi
movslq -0x30(%rbp),%rax
add    %rax,%rdi
movslq -0x2c(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%ecx
call   1030 <stb__match_qstring@plt>
cmp    $0x0,%rax
je     1489 <stb__wildmatch_raw2+0x349>
cmpl   $0x0,-0x28(%rbp)
jl     1474 <stb__wildmatch_raw2+0x334>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    147e <stb__wildmatch_raw2+0x33e>
xor    %eax,%eax
mov    %eax,-0x4c(%rbp)
jmp    147e <stb__wildmatch_raw2+0x33e>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%ecx
call   1040 <stb__find_qstring@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jge    14c1 <stb__wildmatch_raw2+0x381>
movl   $0xffffffff,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
cmpl   $0x0,-0x28(%rbp)
jge    14d4 <stb__wildmatch_raw2+0x394>
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x34(%rbp),%ecx
add    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    151c <stb__wildmatch_raw2+0x3dc>
mov    -0x1c(%rbp),%edi
call   1050 <assert@plt>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1569 <stb__wildmatch_raw2+0x429>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2a,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    12f4 <stb__wildmatch_raw2+0x1b4>
cmpl   $0x0,-0x28(%rbp)
jl     1559 <stb__wildmatch_raw2+0x419>
mov    -0x28(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1563 <stb__wildmatch_raw2+0x423>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    1563 <stb__wildmatch_raw2+0x423>
mov    -0x50(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stb__wildmatch_raw2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r13d
mov    %rsi,%r12
mov    %rdi,%rbx
mov    (%rdi),%al
mov    %edx,0x4(%rsp)
test   %edx,%edx
je     1240 <stb__wildmatch_raw2+0x100>
mov    $0xffffffff,%r14d
xor    %r15d,%r15d
test   %al,%al
je     12c3 <stb__wildmatch_raw2+0x183>
mov    $0x1,%edi
call   1050 <assert@plt>
cmpl   $0x1,0x4(%rsp)
adc    $0x0,%rbx
mov    (%rbx),%al
test   %al,%al
jne    11a2 <stb__wildmatch_raw2+0x62>
xor    %r15d,%r15d
test   %r14d,%r14d
cmovns %r14d,%r15d
jmp    12c3 <stb__wildmatch_raw2+0x183>
nopl   0x0(%rax,%rax,1)
mov    (%rbx),%al
add    $0x1,%rbx
cmp    $0x2a,%al
je     11a0 <stb__wildmatch_raw2+0x60>
test   %al,%al
je     118c <stb__wildmatch_raw2+0x4c>
mov    %r13d,(%rsp)
lea    -0x1(%rbx),%rsi
xor    %r13d,%r13d
test   %al,%al
je     11d1 <stb__wildmatch_raw2+0x91>
nopl   (%rax)
cmp    $0x2a,%al
je     11d1 <stb__wildmatch_raw2+0x91>
movzbl (%rbx,%r13,1),%eax
add    $0x1,%r13
test   %al,%al
jne    11c0 <stb__wildmatch_raw2+0x80>
mov    %r13d,%ebp
cmpl   $0x0,0x4(%rsp)
jne    11e3 <stb__wildmatch_raw2+0xa3>
test   %al,%al
je     12d5 <stb__wildmatch_raw2+0x195>
mov    %r12,%rdi
mov    %r13d,%edx
mov    (%rsp),%ecx
call   1040 <stb__find_qstring@plt>
test   %eax,%eax
js     12a7 <stb__wildmatch_raw2+0x167>
lea    (%rax,%r15,1),%ecx
test   %r14d,%r14d
cmovs  %ecx,%r14d
mov    -0x1(%rbx,%rbp,1),%cl
test   %cl,%cl
je     12f4 <stb__wildmatch_raw2+0x1b4>
add    %r13d,%eax
cltq
add    %rax,%r12
xor    %edi,%edi
cmp    $0x2a,%cl
sete   %dil
call   1050 <assert@plt>
mov    %r13d,%ecx
mov    (%rbx,%rcx,1),%al
add    %rcx,%rbx
test   %al,%al
mov    (%rsp),%r13d
jne    11a2 <stb__wildmatch_raw2+0x62>
jmp    118c <stb__wildmatch_raw2+0x4c>
xor    %r14d,%r14d
cmp    $0x2a,%al
sete   %r14b
neg    %r14d
xor    %r15d,%r15d
jmp    1271 <stb__wildmatch_raw2+0x131>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,(%r12,%r15,1)
je     12a7 <stb__wildmatch_raw2+0x167>
movzbl 0x1(%rbx,%r15,1),%eax
add    $0x1,%r15
cmp    $0x3f,%al
je     1260 <stb__wildmatch_raw2+0x120>
cmp    $0x2a,%al
je     12af <stb__wildmatch_raw2+0x16f>
test   %al,%al
je     12ba <stb__wildmatch_raw2+0x17a>
movzbl (%r12,%r15,1),%ecx
test   %r13d,%r13d
je     12a3 <stb__wildmatch_raw2+0x163>
movsbl %cl,%edi
call   1060 <tolower@plt>
mov    %rax,%rbp
movsbl (%rbx,%r15,1),%edi
call   1060 <tolower@plt>
cmp    %rax,%rbp
je     1267 <stb__wildmatch_raw2+0x127>
jmp    12a7 <stb__wildmatch_raw2+0x167>
cmp    %al,%cl
je     1267 <stb__wildmatch_raw2+0x127>
mov    $0xffffffff,%r15d
jmp    12c3 <stb__wildmatch_raw2+0x183>
add    %r15,%r12
add    %r15,%rbx
jmp    1173 <stb__wildmatch_raw2+0x33>
xor    %eax,%eax
cmp    (%r12,%r15,1),%al
sbb    %r15d,%r15d
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r13d,%r13d
je     1302 <stb__wildmatch_raw2+0x1c2>
mov    %r13d,%eax
xor    %ecx,%ecx
cmpb   $0x0,(%r12,%rcx,1)
je     12a7 <stb__wildmatch_raw2+0x167>
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12df <stb__wildmatch_raw2+0x19f>
mov    %r13d,%eax
jmp    1304 <stb__wildmatch_raw2+0x1c4>
mov    0x4(%rsp),%edi
call   1050 <assert@plt>
mov    %r14d,%r15d
jmp    12c3 <stb__wildmatch_raw2+0x183>
xor    %eax,%eax
add    $0xffffffffffffffff,%rax
cmpb   $0x0,0x1(%r12,%rax,1)
lea    0x1(%rax),%rax
jne    1308 <stb__wildmatch_raw2+0x1c8>
mov    %eax,%eax
add    %rax,%r12
sub    %rbp,%r12
mov    %r12,%rdi
mov    %r13d,%edx
mov    (%rsp),%ecx
call   1030 <stb__match_qstring@plt>
test   %rax,%rax
jne    118c <stb__wildmatch_raw2+0x4c>
jmp    12a7 <stb__wildmatch_raw2+0x167>

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

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