#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ strcmp(char const *, char const *);
scalar_t__ strncmp(char const *, char const *, int);
int match_glob(const char *file, const char *pattern) {
  const char *f, *g, *p, *q;
  f = file;
  p = pattern;
  while (1) {
    if ('\0' == *p)
      return '\0' == *f ? 0 : -1;
    while ('*' == *p)
      p++;
    for (q = p; '\0' != *q && '*' != *q; q++)
      ;
    if (pattern == p) {
      if (0 != strncmp(f, p, q - p))
        return -1;
      f += q - p;
      p = q;
      continue;
    }
    if ('\0' == *q) {
      for (g = f; '\0' != *g; g++)
        ;
      if (g - f < q - p)
        return -1;
      return 0 == strcmp(g - (q - p), p) ? 0 : -1;
    }
    while (1) {
      if ('\0' == *f)
        return -1;
      if (0 == strncmp(f, p, q - p)) {
        f += q - p;
        p = q;
        break;
      }
      f++;
    }
  }
}


x86 assembly (clang, -O0):
<match_glob>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    116c <match_glob+0x4c>
mov    -0x20(%rbp),%rax
movsbl (%rax),%edx
xor    %ecx,%ecx
mov    $0xffffffff,%eax
cmp    %edx,%ecx
cmove  %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1377 <match_glob+0x257>
jmp    1171 <match_glob+0x51>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x2a,%eax
cmp    %ecx,%eax
jne    1196 <match_glob+0x76>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1171 <match_glob+0x51>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movsbl (%rax),%edx
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x39(%rbp)
je     11c8 <match_glob+0xa8>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x2a,%eax
cmp    %ecx,%eax
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    11d8 <match_glob+0xb8>
jmp    11ee <match_glob+0xce>
jmp    11dd <match_glob+0xbd>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    119e <match_glob+0x7e>
mov    -0x18(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1250 <match_glob+0x130>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
je     1230 <match_glob+0x110>
movl   $0xffffffff,-0x4(%rbp)
jmp    1377 <match_glob+0x257>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1140 <match_glob+0x20>
mov    -0x38(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    12f7 <match_glob+0x1d7>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
je     1290 <match_glob+0x170>
jmp    127f <match_glob+0x15f>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1269 <match_glob+0x149>
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jge    12bb <match_glob+0x19b>
movl   $0xffffffff,-0x4(%rbp)
jmp    1377 <match_glob+0x257>
mov    -0x28(%rbp),%rdi
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rax,%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
call   1040 <strcmp@plt>
mov    %rax,%rsi
xor    %eax,%eax
mov    %eax,%edx
mov    $0xffffffff,%eax
xor    %ecx,%ecx
cmp    %rsi,%rdx
cmove  %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    1377 <match_glob+0x257>
jmp    12fc <match_glob+0x1dc>
mov    -0x20(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    1319 <match_glob+0x1f9>
movl   $0xffffffff,-0x4(%rbp)
jmp    1377 <match_glob+0x257>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <strncmp@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
jne    1361 <match_glob+0x241>
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1372 <match_glob+0x252>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    12fc <match_glob+0x1dc>
jmp    1140 <match_glob+0x20>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<match_glob>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
mov    (%rsi),%al
test   %al,%al
je     1214 <match_glob+0xf4>
mov    %rsi,%r13
mov    %rsi,%rbp
mov    %rsi,(%rsp)
mov    $0xffffffff,%r12d
mov    %rbp,%rbx
cmp    $0x2a,%al
jne    115c <match_glob+0x3c>
nop
movzbl 0x1(%rbx),%eax
add    $0x1,%rbx
cmp    $0x2a,%al
je     1150 <match_glob+0x30>
lea    -0x1(%r14),%rdi
mov    %r14,%r15
mov    %rbx,%rbp
test   %al,%al
je     1188 <match_glob+0x68>
nopw   0x0(%rax,%rax,1)
cmp    $0x2a,%al
je     1188 <match_glob+0x68>
movzbl 0x1(%rbp),%eax
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
add    $0x1,%r15
test   %al,%al
jne    1170 <match_glob+0x50>
cmp    %r13,%rbx
je     11e0 <match_glob+0xc0>
test   %al,%al
je     1231 <match_glob+0x111>
cmpb   $0x0,(%r14)
je     121f <match_glob+0xff>
mov    %ebp,%r13d
sub    %ebx,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdi
mov    %rbx,%rsi
mov    %r13d,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1200 <match_glob+0xe0>
add    $0x1,%r15
cmpb   $0x0,0x1(%r14)
lea    0x1(%r14),%r14
jne    11b0 <match_glob+0x90>
jmp    121f <match_glob+0xff>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbp,%rbx
sub    %r13,%rbx
mov    %r14,%rdi
mov    %r13,%rsi
mov    %ebx,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    126b <match_glob+0x14b>
add    %rbx,%r14
mov    %r14,%r15
jmp    1207 <match_glob+0xe7>
mov    %r15,%r14
mov    (%rsp),%r13
mov    0x0(%rbp),%al
test   %al,%al
jne    1148 <match_glob+0x28>
jmp    1217 <match_glob+0xf7>
mov    %r14,%r15
xor    %eax,%eax
cmp    (%r15),%al
sbb    %r12d,%r12d
mov    %r12d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffffffffffff,%rax
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
cmpb   $0x0,0x1(%r14,%rax,1)
lea    0x1(%rax),%rax
jne    1240 <match_glob+0x120>
sub    %rbx,%rbp
mov    $0xffffffff,%r12d
cmp    %rbp,%rax
jl     121f <match_glob+0xff>
mov    %rbx,%rsi
call   1040 <strcmp@plt>
neg    %rax
jmp    121c <match_glob+0xfc>
mov    $0xffffffff,%r12d
jmp    121f <match_glob+0xff>

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

LLVM IR (-O2):
define i32 @match_glob(i8* %0, i8* %1) {
%3 = load i8, i8* %1
%4 = icmp eq i8 %3, 0
br i1 %4, label %12, label %5
5: ; preds = %2
%6 = ptrtoint i8* %1 to i64
br label %7
7: ; preds = %5, %41
%8 = phi i8 [ %43, %41 ], [ %3, %5 ]
%9 = phi i8* [ %27, %41 ], [ %1, %5 ]
%10 = phi i8* [ %42, %41 ], [ %0, %5 ]
%11 = icmp eq i8 %8, 42
br i1 %11, label %20, label %17
12: ; preds = %41, %2
%13 = phi i8* [ %0, %2 ], [ %42, %41 ]
%14 = load i8, i8* %13
%15 = icmp ne i8 %14, 0
%16 = sext i1 %15 to i32
br label %84
17: ; preds = %20, %7
%18 = phi i8 [ %8, %7 ], [ %23, %20 ]
%19 = phi i8* [ %9, %7 ], [ %22, %20 ]
br label %25
20: ; preds = %7, %20
%21 = phi i8* [ %22, %20 ], [ %9, %7 ]
%22 = getelementptr inbounds i8, i8* %21, i64 1
%23 = load i8, i8* %22
%24 = icmp eq i8 %23, 42
br i1 %24, label %20, label %17
25: ; preds = %17, %28
%26 = phi i8 [ %30, %28 ], [ %18, %17 ]
%27 = phi i8* [ %29, %28 ], [ %19, %17 ]
switch i8 %26, label %28 [
i8 0, label %31
i8 42, label %31
]
28: ; preds = %25
%29 = getelementptr inbounds i8, i8* %27, i64 1
%30 = load i8, i8* %29
br label %25
31: ; preds = %25, %25
%32 = icmp eq i8* %19, %1
br i1 %32, label %33, label %45
33: ; preds = %31
%34 = ptrtoint i8* %27 to i64
%35 = sub i64 %34, %6
%36 = trunc i64 %35 to i32
%37 = tail call i64 @strncmp(i8* %10, i8* %1, i32 %36)
%38 = icmp eq i64 %37, 0
br i1 %38, label %39, label %84
39: ; preds = %33
%40 = getelementptr inbounds i8, i8* %10, i64 %35
br label %41
41: ; preds = %39, %78
%42 = phi i8* [ %40, %39 ], [ %79, %78 ]
%43 = load i8, i8* %27
%44 = icmp eq i8 %43, 0
br i1 %44, label %12, label %7
45: ; preds = %31
%46 = icmp eq i8 %26, 0
br i1 %46, label %55, label %47
47: ; preds = %45
%48 = load i8, i8* %10
%49 = icmp eq i8 %48, 0
br i1 %49, label %84, label %50
50: ; preds = %47
%51 = ptrtoint i8* %27 to i64
%52 = ptrtoint i8* %19 to i64
%53 = sub i64 %51, %52
%54 = trunc i64 %53 to i32
br label %74
55: ; preds = %45, %55
%56 = phi i8* [ %59, %55 ], [ %10, %45 ]
%57 = load i8, i8* %56
%58 = icmp eq i8 %57, 0
%59 = getelementptr inbounds i8, i8* %56, i64 1
br i1 %58, label %60, label %55
60: ; preds = %55
%61 = ptrtoint i8* %56 to i64
%62 = ptrtoint i8* %10 to i64
%63 = sub i64 %61, %62
%64 = ptrtoint i8* %27 to i64
%65 = ptrtoint i8* %19 to i64
%66 = sub i64 %64, %65
%67 = icmp slt i64 %63, %66
br i1 %67, label %84, label %68
68: ; preds = %60
%69 = sub i64 0, %66
%70 = getelementptr inbounds i8, i8* %56, i64 %69
%71 = tail call i64 @strcmp(i8* %70, i8* %19)
%72 = icmp ne i64 %71, 0
%73 = sext i1 %72 to i32
br label %84
74: ; preds = %50, %80
%75 = phi i8* [ %10, %50 ], [ %81, %80 ]
%76 = tail call i64 @strncmp(i8* %75, i8* %19, i32 %54)
%77 = icmp eq i64 %76, 0
br i1 %77, label %78, label %80
78: ; preds = %74
%79 = getelementptr inbounds i8, i8* %75, i64 %53
br label %41
80: ; preds = %74
%81 = getelementptr inbounds i8, i8* %75, i64 1
%82 = load i8, i8* %81
%83 = icmp eq i8 %82, 0
br i1 %83, label %84, label %74
84: ; preds = %33, %47, %80, %60, %68, %12
%85 = phi i32 [ %16, %12 ], [ %73, %68 ], [ -1, %60 ], [ -1, %80 ], [ -1, %47 ], [ -1, %33 ]
ret i32 %85
}