#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 */
struct partime {
  int dummy;
};

/* Variables and functions */
scalar_t__ isalnum(unsigned char);
char *parse_pattern_letter(char const *, unsigned char, struct partime *);
int /*<<< orphan*/ undefine(struct partime *);
char const *parse_prefix(char const *str, char const **patterns,
                         struct partime *t) {
  char const *pat = *patterns;
  unsigned char c;
  if (!pat)
    return 0;
  while (!(((unsigned)(c = *str) <= 0177) && isalnum(c = *str)) && c != '-' &&
         c != '+') {
    if (!c) {
      undefine(t);
      *patterns = 0;
      return str;
    }
    str++;
  }
  while (*pat) {
    char const *s = str;
    undefine(t);
    do {
      if (!(c = *pat++)) {
        *patterns = pat;
        return s;
      }
    } while ((s = parse_pattern_letter(s, c, t)) != 0);
    while (*pat++)
      continue;
  }
  return 0;
}


x86 assembly (clang, -O0):
<parse_prefix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    1167 <parse_prefix+0x37>
movq   $0x0,-0x8(%rbp)
jmp    12bb <parse_prefix+0x18b>
jmp    116c <parse_prefix+0x3c>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
movzbl %al,%eax
cmp    $0x7f,%eax
ja     11a4 <parse_prefix+0x74>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
movzbl %al,%edi
call   1030 <isalnum@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x39(%rbp)
jne    11c3 <parse_prefix+0x93>
movzbl -0x29(%rbp),%ecx
xor    %eax,%eax
cmp    $0x2d,%ecx
mov    %al,-0x39(%rbp)
je     11c3 <parse_prefix+0x93>
movzbl -0x29(%rbp),%eax
cmp    $0x2b,%eax
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    11d3 <parse_prefix+0xa3>
jmp    120f <parse_prefix+0xdf>
cmpb   $0x0,-0x29(%rbp)
jne    11fe <parse_prefix+0xce>
mov    -0x20(%rbp),%rdi
call   1040 <undefine@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12bb <parse_prefix+0x18b>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    116c <parse_prefix+0x3c>
jmp    1214 <parse_prefix+0xe4>
mov    -0x28(%rbp),%rax
cmpb   $0x0,(%rax)
je     12b3 <parse_prefix+0x183>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <undefine@plt>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x29(%rbp)
cmp    $0x0,%al
jne    1266 <parse_prefix+0x136>
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12bb <parse_prefix+0x18b>
jmp    126b <parse_prefix+0x13b>
mov    -0x38(%rbp),%rdi
mov    -0x29(%rbp),%al
mov    -0x20(%rbp),%rdx
movzbl %al,%esi
call   1050 <parse_pattern_letter@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1232 <parse_prefix+0x102>
jmp    1291 <parse_prefix+0x161>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
cmpb   $0x0,(%rax)
je     12ae <parse_prefix+0x17e>
jmp    1291 <parse_prefix+0x161>
jmp    1214 <parse_prefix+0xe4>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse_prefix>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    (%rsi),%rbx
test   %rbx,%rbx
je     11c0 <parse_prefix+0x90>
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%r13
jmp    1154 <parse_prefix+0x24>
xchg   %ax,%ax
add    $0x1,%r13
movzbl 0x0(%r13),%ebp
test   %bpl,%bpl
js     1150 <parse_prefix+0x20>
movzbl %bpl,%edi
call   1030 <isalnum@plt>
test   %rax,%rax
jne    117d <parse_prefix+0x4d>
test   %bpl,%bpl
je     11ca <parse_prefix+0x9a>
cmp    $0x2d,%bpl
je     117d <parse_prefix+0x4d>
cmp    $0x2b,%bpl
jne    1150 <parse_prefix+0x20>
cmpb   $0x0,(%rbx)
je     11c0 <parse_prefix+0x90>
xor    %r12d,%r12d
mov    %r15,%rdi
call   1040 <undefine@plt>
mov    %r13,%rax
movzbl (%rbx),%ecx
add    $0x1,%rbx
test   %cl,%cl
je     11c5 <parse_prefix+0x95>
movzbl %cl,%esi
mov    %rax,%rdi
mov    %r15,%rdx
call   1050 <parse_pattern_letter@plt>
test   %rax,%rax
jne    1190 <parse_prefix+0x60>
xchg   %ax,%ax
cmpb   $0x0,(%rbx)
lea    0x1(%rbx),%rbx
jne    11b0 <parse_prefix+0x80>
cmpb   $0x0,(%rbx)
jne    1185 <parse_prefix+0x55>
jmp    11da <parse_prefix+0xaa>
xor    %r12d,%r12d
jmp    11da <parse_prefix+0xaa>
mov    %rax,%r13
jmp    11d4 <parse_prefix+0xa4>
mov    %r15,%rdi
call   1040 <undefine@plt>
xor    %ebx,%ebx
mov    %rbx,(%r14)
mov    %r13,%r12
mov    %r12,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.partime = type { i32 }
define i8* @parse_prefix(i8* %0, i8** %1, %struct.partime* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8**
%7 = alloca %struct.partime*
%8 = alloca i8*
%9 = alloca i8
%10 = alloca i8*
store i8* %0, i8** %5
store i8** %1, i8*** %6
store %struct.partime* %2, %struct.partime** %7
%11 = load i8**, i8*** %6
%12 = load i8*, i8** %11
store i8* %12, i8** %8
%13 = load i8*, i8** %8
%14 = icmp ne i8* %13, null
br i1 %14, label %16, label %15
15: ; preds = %3
store i8* null, i8** %4
br label %82
16: ; preds = %3
br label %17
17: ; preds = %45, %16
%18 = load i8*, i8** %5
%19 = load i8, i8* %18
store i8 %19, i8* %9
%20 = zext i8 %19 to i32
%21 = icmp ule i32 %20, 127
br i1 %21, label %22, label %27
22: ; preds = %17
%23 = load i8*, i8** %5
%24 = load i8, i8* %23
store i8 %24, i8* %9
%25 = call i64 @isalnum(i8 zeroext %24)
%26 = icmp ne i64 %25, 0
br i1 %26, label %35, label %27
27: ; preds = %22, %17
%28 = load i8, i8* %9
%29 = zext i8 %28 to i32
%30 = icmp ne i32 %29, 45
br i1 %30, label %31, label %35
31: ; preds = %27
%32 = load i8, i8* %9
%33 = zext i8 %32 to i32
%34 = icmp ne i32 %33, 43
br label %35
35: ; preds = %31, %27, %22
%36 = phi i1 [ false, %27 ], [ false, %22 ], [ %34, %31 ]
br i1 %36, label %37, label %48
37: ; preds = %35
%38 = load i8, i8* %9
%39 = icmp ne i8 %38, 0
br i1 %39, label %45, label %40
40: ; preds = %37
%41 = load %struct.partime*, %struct.partime** %7
%42 = call i32 @undefine(%struct.partime* %41)
%43 = load i8**, i8*** %6
store i8* null, i8** %43
%44 = load i8*, i8** %5
store i8* %44, i8** %4
br label %82
45: ; preds = %37
%46 = load i8*, i8** %5
%47 = getelementptr inbounds i8, i8* %46, i32 1
store i8* %47, i8** %5
br label %17
48: ; preds = %35
br label %49
49: ; preds = %80, %48
%50 = load i8*, i8** %8
%51 = load i8, i8* %50
%52 = icmp ne i8 %51, 0
br i1 %52, label %53, label %81
53: ; preds = %49
%54 = load i8*, i8** %5
store i8* %54, i8** %10
%55 = load %struct.partime*, %struct.partime** %7
%56 = call i32 @undefine(%struct.partime* %55)
br label %57
57: ; preds = %67, %53
%58 = load i8*, i8** %8
%59 = getelementptr inbounds i8, i8* %58, i32 1
store i8* %59, i8** %8
%60 = load i8, i8* %58
store i8 %60, i8* %9
%61 = icmp ne i8 %60, 0
br i1 %61, label %66, label %62
62: ; preds = %57
%63 = load i8*, i8** %8
%64 = load i8**, i8*** %6
store i8* %63, i8** %64
%65 = load i8*, i8** %10
store i8* %65, i8** %4
br label %82
66: ; preds = %57
br label %67
67: ; preds = %66
%68 = load i8*, i8** %10
%69 = load i8, i8* %9
%70 = load %struct.partime*, %struct.partime** %7
%71 = call i8* @parse_pattern_letter(i8* %68, i8 zeroext %69, %struct.partime* %70)
store i8* %71, i8** %10
%72 = icmp ne i8* %71, null
br i1 %72, label %57, label %73
73: ; preds = %67
br label %74
74: ; preds = %79, %73
%75 = load i8*, i8** %8
%76 = getelementptr inbounds i8, i8* %75, i32 1
store i8* %76, i8** %8
%77 = load i8, i8* %75
%78 = icmp ne i8 %77, 0
br i1 %78, label %79, label %80
79: ; preds = %74
br label %74
80: ; preds = %74
br label %49
81: ; preds = %49
store i8* null, i8** %4
br label %82
82: ; preds = %81, %62, %40, %15
%83 = load i8*, i8** %4
ret i8* %83
}

LLVM IR (-O2):
%struct.partime = type { i32 }
define i8* @parse_prefix(i8* %0, i8** nocapture %1, %struct.partime* %2) {
%4 = load i8*, i8** %1
%5 = icmp eq i8* %4, null
br i1 %5, label %45, label %6
6: ; preds = %3, %20
%7 = phi i8* [ %21, %20 ], [ %0, %3 ]
%8 = load i8, i8* %7
%9 = icmp sgt i8 %8, -1
br i1 %9, label %10, label %20
10: ; preds = %6
%11 = tail call i64 @isalnum(i8 zeroext %8)
%12 = freeze i64 %11
%13 = icmp eq i64 %12, 0
br i1 %13, label %14, label %15
14: ; preds = %10
switch i8 %8, label %20 [
i8 45, label %15
i8 43, label %15
i8 0, label %18
]
15: ; preds = %10, %14, %14
%16 = load i8, i8* %4
%17 = icmp eq i8 %16, 0
br i1 %17, label %45, label %25
18: ; preds = %14
%19 = tail call i32 @undefine(%struct.partime* %2)
br label %42
20: ; preds = %14, %6
%21 = getelementptr inbounds i8, i8* %7, i64 1
br label %6
22: ; preds = %37
%23 = load i8, i8* %39
%24 = icmp eq i8 %23, 0
br i1 %24, label %45, label %25
25: ; preds = %15, %22
%26 = phi i8* [ %39, %22 ], [ %4, %15 ]
%27 = tail call i32 @undefine(%struct.partime* %2)
br label %28
28: ; preds = %34, %25
%29 = phi i8* [ %26, %25 ], [ %31, %34 ]
%30 = phi i8* [ %7, %25 ], [ %35, %34 ]
%31 = getelementptr inbounds i8, i8* %29, i64 1
%32 = load i8, i8* %29
%33 = icmp eq i8 %32, 0
br i1 %33, label %42, label %34
34: ; preds = %28
%35 = tail call i8* @parse_pattern_letter(i8* %30, i8 zeroext %32, %struct.partime* %2)
%36 = icmp eq i8* %35, null
br i1 %36, label %37, label %28
37: ; preds = %34, %37
%38 = phi i8* [ %39, %37 ], [ %31, %34 ]
%39 = getelementptr inbounds i8, i8* %38, i64 1
%40 = load i8, i8* %38
%41 = icmp eq i8 %40, 0
br i1 %41, label %22, label %37
42: ; preds = %28, %18
%43 = phi i8* [ null, %18 ], [ %31, %28 ]
%44 = phi i8* [ %7, %18 ], [ %30, %28 ]
store i8* %43, i8** %1
br label %45
45: ; preds = %22, %15, %42, %3
%46 = phi i8* [ null, %3 ], [ %44, %42 ], [ null, %15 ], [ null, %22 ]
ret i8* %46
}