#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 ascii2hex(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int optind;
int /*<<< orphan*/ parse_opts(int, char **);
int /*<<< orphan*/ recurse(char *, unsigned char *, unsigned char *, int);
int /*<<< orphan*/ searchfile(char *, int /*<<< orphan*/, unsigned char *,
                              unsigned char *, int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ usage(char **);
int main(int argc, char **argv) {
  unsigned char value[0x100], mask[0x100];
  int len = 0;
  if (argc < 2) {
    usage(argv);
    return 1;
  }
  parse_opts(argc, argv);
  argv += optind - 1;
  argc -= optind - 1;
  char *h = argv[1];
  enum { MODE_HEX, MODE_TXT, MODE_TXT_ESC } parse_mode = MODE_HEX;
  while (*h && (parse_mode != MODE_HEX || h[1]) && len < 0x100) {
    int on_quote = (h[0] == '"');
    int on_esc = (h[0] == '\\');
    switch (parse_mode) {
    case MODE_HEX:
      if (on_quote) {
        parse_mode = MODE_TXT;
        h++;
        continue;
      }
      break;
    case MODE_TXT:
      if (on_quote) {
        parse_mode = MODE_HEX;
        h++;
        continue;
      }
      if (on_esc) {
        parse_mode = MODE_TXT_ESC;
        h++;
        continue;
      }
      value[len] = h[0];
      mask[len++] = 0xff;
      h++;
      continue;
    case MODE_TXT_ESC:
      value[len] = h[0];
      mask[len++] = 0xff;
      parse_mode = MODE_TXT;
      h++;
      continue;
    }
    if (h[0] == '?' && h[1] == '?') {
      value[len] = mask[len] = 0;
      len++;
      h += 2;
    } else if (h[0] == ' ') {
      h++;
    } else {
      int v0 = ascii2hex(*h++);
      int v1 = ascii2hex(*h++);
      if ((v0 == -1) || (v1 == -1)) {
        fprintf(stderr, "invalid hex string!\n");
        return 2;
      }
      value[len] = (v0 << 4) | v1;
      mask[len++] = 0xFF;
    }
  }
  if (!len || *h) {
    fprintf(stderr, "invalid/empty search string\n");
    return 2;
  }
  if (argc < 3)
    searchfile("stdin", 0, value, mask, len);
  else {
    int c = 2;
    while (c < argc)
      recurse(argv[c++], value, mask, len);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x214(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11a2 <main+0x42>
mov    -0x10(%rbp),%rdi
call   1070 <usage@plt>
movl   $0x1,-0x4(%rbp)
jmp    1629 <main+0x4c9>
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1040 <parse_opts@plt>
mov    0x2e33(%rip),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    0x2e15(%rip),%rax
mov    (%rax),%ecx
sub    $0x1,%ecx
mov    -0x8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x220(%rbp)
movl   $0x0,-0x224(%rbp)
mov    -0x220(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x239(%rbp)
je     1250 <main+0xf0>
cmpl   $0x0,-0x224(%rbp)
jne    123d <main+0xdd>
mov    -0x220(%rbp),%rax
movsbl 0x1(%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x239(%rbp)
je     1250 <main+0xf0>
cmpl   $0x100,-0x214(%rbp)
setl   %al
mov    %al,-0x239(%rbp)
mov    -0x239(%rbp),%al
test   $0x1,%al
jne    1263 <main+0x103>
jmp    1557 <main+0x3f7>
mov    -0x220(%rbp),%rax
mov    (%rax),%al
sub    $0x22,%al
sete   %al
movzbl %al,%eax
mov    %eax,-0x228(%rbp)
mov    -0x220(%rbp),%rax
mov    (%rax),%al
sub    $0x5c,%al
sete   %al
movzbl %al,%eax
mov    %eax,-0x22c(%rbp)
mov    -0x224(%rbp),%eax
mov    %eax,-0x240(%rbp)
test   %eax,%eax
je     12d2 <main+0x172>
jmp    12aa <main+0x14a>
mov    -0x240(%rbp),%eax
sub    $0x1,%eax
je     1305 <main+0x1a5>
jmp    12be <main+0x15e>
mov    -0x240(%rbp),%eax
sub    $0x2,%eax
je     13aa <main+0x24a>
jmp    13fd <main+0x29d>
cmpl   $0x0,-0x228(%rbp)
je     1300 <main+0x1a0>
movl   $0x1,-0x224(%rbp)
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    11f9 <main+0x99>
jmp    13fd <main+0x29d>
cmpl   $0x0,-0x228(%rbp)
je     1333 <main+0x1d3>
movl   $0x0,-0x224(%rbp)
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    11f9 <main+0x99>
cmpl   $0x0,-0x22c(%rbp)
je     1361 <main+0x201>
movl   $0x2,-0x224(%rbp)
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    11f9 <main+0x99>
mov    -0x220(%rbp),%rax
mov    (%rax),%cl
movslq -0x214(%rbp),%rax
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x214(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x214(%rbp)
cltq
movb   $0xff,-0x210(%rbp,%rax,1)
ff
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    11f9 <main+0x99>
mov    -0x220(%rbp),%rax
mov    (%rax),%cl
movslq -0x214(%rbp),%rax
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x214(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x214(%rbp)
cltq
movb   $0xff,-0x210(%rbp,%rax,1)
ff
movl   $0x1,-0x224(%rbp)
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    11f9 <main+0x99>
mov    -0x220(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3f,%eax
jne    1468 <main+0x308>
mov    -0x220(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3f,%eax
jne    1468 <main+0x308>
movslq -0x214(%rbp),%rax
movb   $0x0,-0x210(%rbp,%rax,1)
movslq -0x214(%rbp),%rax
movb   $0x0,-0x110(%rbp,%rax,1)
mov    -0x214(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x214(%rbp)
mov    -0x220(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x220(%rbp)
jmp    1552 <main+0x3f2>
mov    -0x220(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    1492 <main+0x332>
mov    -0x220(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x220(%rbp)
jmp    154d <main+0x3ed>
mov    -0x220(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x220(%rbp)
movsbl (%rax),%edi
call   1060 <ascii2hex@plt>
mov    %eax,-0x230(%rbp)
mov    -0x220(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x220(%rbp)
movsbl (%rax),%edi
call   1060 <ascii2hex@plt>
mov    %eax,-0x234(%rbp)
cmpl   $0xffffffff,-0x230(%rbp)
je     14f2 <main+0x392>
cmpl   $0xffffffff,-0x234(%rbp)
jne    1513 <main+0x3b3>
mov    0x2adf(%rip),%rax
mov    (%rax),%edi
lea    0xafe(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x2,-0x4(%rbp)
jmp    1629 <main+0x4c9>
mov    -0x230(%rbp),%eax
shl    $0x4,%eax
or     -0x234(%rbp),%eax
mov    %al,%cl
movslq -0x214(%rbp),%rax
mov    %cl,-0x110(%rbp,%rax,1)
mov    -0x214(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x214(%rbp)
cltq
movb   $0xff,-0x210(%rbp,%rax,1)
ff
jmp    1552 <main+0x3f2>
jmp    11f9 <main+0x99>
cmpl   $0x0,-0x214(%rbp)
je     1577 <main+0x417>
mov    -0x220(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1598 <main+0x438>
mov    0x2a5a(%rip),%rax
mov    (%rax),%edi
lea    0xa8e(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x2,-0x4(%rbp)
jmp    1629 <main+0x4c9>
cmpl   $0x3,-0x8(%rbp)
jge    15ca <main+0x46a>
lea    -0x110(%rbp),%rdx
lea    -0x210(%rbp),%rcx
mov    -0x214(%rbp),%r8d
lea    0xa74(%rip),%rdi
xor    %esi,%esi
call   1080 <searchfile@plt>
jmp    1622 <main+0x4c2>
movl   $0x2,-0x238(%rbp)
mov    -0x238(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    161d <main+0x4bd>
mov    -0x10(%rbp),%rax
mov    -0x238(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x238(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x110(%rbp),%rsi
lea    -0x210(%rbp),%rdx
mov    -0x214(%rbp),%ecx
call   1030 <recurse@plt>
jmp    15d4 <main+0x474>
jmp    1622 <main+0x4c2>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %rsi,%r14
cmp    $0x1,%edi
jg     118c <main+0x2c>
mov    %r14,%rdi
call   1070 <usage@plt>
mov    $0x1,%r12d
jmp    1366 <main+0x206>
mov    %edi,%r15d
mov    %r14,%rsi
call   1040 <parse_opts@plt>
mov    0x2e4a(%rip),%rax
movslq (%rax),%rax
mov    %rax,%rcx
mov    (%r14,%rax,8),%rbx
mov    (%rbx),%al
test   %al,%al
je     134b <main+0x1eb>
mov    %rcx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
sub    %edx,%r15d
xor    %r13d,%r13d
xor    %r12d,%r12d
nopw   0x0(%rax,%rax,1)
test   %r12d,%r12d
je     1210 <main+0xb0>
cmp    $0xff,%r13d
jg     134b <main+0x1eb>
cmp    $0x2,%r12d
je     1250 <main+0xf0>
cmp    $0x1,%r12d
jne    1280 <main+0x120>
cmp    $0x5c,%al
je     1305 <main+0x1a5>
cmp    $0x22,%al
jne    1250 <main+0xf0>
add    $0x1,%rbx
xor    %r12d,%r12d
jmp    1310 <main+0x1b0>
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%rbx),%ecx
test   %cl,%cl
je     134b <main+0x1eb>
cmp    $0xff,%r13d
jg     134b <main+0x1eb>
cmp    $0x20,%al
je     12f3 <main+0x193>
cmp    $0x22,%al
je     12f9 <main+0x199>
cmp    $0x3f,%al
jne    12b0 <main+0x150>
cmp    $0x3f,%cl
je     1291 <main+0x131>
jmp    12b0 <main+0x150>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %r13d,%rcx
mov    %al,0x110(%rsp,%rcx,1)
add    $0x1,%r13d
movb   $0xff,0x10(%rsp,%rcx,1)
add    $0x1,%rbx
mov    $0x1,%r12d
jmp    1310 <main+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x20,%al
je     12f3 <main+0x193>
cmp    $0x3f,%al
jne    12b0 <main+0x150>
movzbl 0x1(%rbx),%ecx
cmp    $0x3f,%cl
jne    12b0 <main+0x150>
movslq %r13d,%rax
movb   $0x0,0x10(%rsp,%rax,1)
movb   $0x0,0x110(%rsp,%rax,1)
add    $0x1,%r13d
add    $0x2,%rbx
jmp    1310 <main+0x1b0>
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1060 <ascii2hex@plt>
mov    %eax,%ebp
movsbl 0x1(%rbx),%edi
call   1060 <ascii2hex@plt>
cmp    $0xffffffff,%ebp
je     13c3 <main+0x263>
cmp    $0xffffffff,%eax
je     13c3 <main+0x263>
add    $0x2,%rbx
shl    $0x4,%ebp
or     %ebp,%eax
movslq %r13d,%rcx
mov    %al,0x110(%rsp,%rcx,1)
add    $0x1,%r13d
movb   $0xff,0x10(%rsp,%rcx,1)
jmp    1310 <main+0x1b0>
add    $0x1,%rbx
jmp    1310 <main+0x1b0>
add    $0x1,%rbx
mov    $0x1,%r12d
jmp    1313 <main+0x1b3>
add    $0x1,%rbx
mov    $0x2,%r12d
nop
movzbl (%rbx),%ecx
mov    %ecx,%eax
test   %cl,%cl
jne    11d0 <main+0x70>
test   %r13d,%r13d
je     134b <main+0x1eb>
cmp    $0x3,%r15d
jge    137b <main+0x21b>
lea    0xd03(%rip),%rdi
xor    %r12d,%r12d
lea    0x110(%rsp),%rdx
lea    0x10(%rsp),%rcx
xor    %esi,%esi
mov    %r13d,%r8d
call   1080 <searchfile@plt>
jmp    1366 <main+0x206>
mov    0x2c86(%rip),%rax
mov    (%rax),%edi
lea    0xcba(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x2,%r12d
mov    %r12d,%eax
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15d,%ebx
mov    0x8(%rsp),%rax
lea    (%r14,%rax,8),%rbp
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rbx
xor    %r12d,%r12d
lea    0x10(%rsp),%r15
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%r14,8),%rdi
lea    0x110(%rsp),%rsi
mov    %r15,%rdx
mov    %r13d,%ecx
call   1030 <recurse@plt>
add    $0x1,%r14
cmp    %r14,%rbx
jne    13a0 <main+0x240>
jmp    1366 <main+0x206>
mov    0x2c0e(%rip),%rax
mov    (%rax),%edi
lea    0xc2d(%rip),%rsi
jmp    135b <main+0x1fb>

LLVM IR (-O0):
@optind = global i32 0
@stderr = global i32 0
@.str = [21 x i8] c"invalid hex string!\0A\00"
@.str.1 = [29 x i8] c"invalid/empty search string\0A\00"
@.str.2 = [6 x i8] c"stdin\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [256 x i8]
%7 = alloca [256 x i8]
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %8
%16 = load i32, i32* %4
%17 = icmp slt i32 %16, 2
br i1 %17, label %18, label %21
18: ; preds = %2
%19 = load i8**, i8*** %5
%20 = call i32 @usage(i8** %19)
store i32 1, i32* %3
br label %218
21: ; preds = %2
%22 = load i32, i32* %4
%23 = load i8**, i8*** %5
%24 = call i32 @parse_opts(i32 %22, i8** %23)
%25 = load i32, i32* @optind
%26 = sub nsw i32 %25, 1
%27 = load i8**, i8*** %5
%28 = sext i32 %26 to i64
%29 = getelementptr inbounds i8*, i8** %27, i64 %28
store i8** %29, i8*** %5
%30 = load i32, i32* @optind
%31 = sub nsw i32 %30, 1
%32 = load i32, i32* %4
%33 = sub nsw i32 %32, %31
store i32 %33, i32* %4
%34 = load i8**, i8*** %5
%35 = getelementptr inbounds i8*, i8** %34, i64 1
%36 = load i8*, i8** %35
store i8* %36, i8** %9
store i32 0, i32* %10
br label %37
37: ; preds = %180, %102, %89, %86, %80, %73, %21
%38 = load i8*, i8** %9
%39 = load i8, i8* %38
%40 = sext i8 %39 to i32
%41 = icmp ne i32 %40, 0
br i1 %41, label %42, label %54
42: ; preds = %37
%43 = load i32, i32* %10
%44 = icmp ne i32 %43, 0
br i1 %44, label %51, label %45
45: ; preds = %42
%46 = load i8*, i8** %9
%47 = getelementptr inbounds i8, i8* %46, i64 1
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = icmp ne i32 %49, 0
br i1 %50, label %51, label %54
51: ; preds = %45, %42
%52 = load i32, i32* %8
%53 = icmp slt i32 %52, 256
br label %54
54: ; preds = %51, %45, %37
%55 = phi i1 [ false, %45 ], [ false, %37 ], [ %53, %51 ]
br i1 %55, label %56, label %181
56: ; preds = %54
%57 = load i8*, i8** %9
%58 = getelementptr inbounds i8, i8* %57, i64 0
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp eq i32 %60, 34
%62 = zext i1 %61 to i32
store i32 %62, i32* %11
%63 = load i8*, i8** %9
%64 = getelementptr inbounds i8, i8* %63, i64 0
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = icmp eq i32 %66, 92
%68 = zext i1 %67 to i32
store i32 %68, i32* %12
%69 = load i32, i32* %10
switch i32 %69, label %115 [
i32 0, label %70
i32 1, label %77
i32 2, label %102
]
70: ; preds = %56
%71 = load i32, i32* %11
%72 = icmp ne i32 %71, 0
br i1 %72, label %73, label %76
73: ; preds = %70
store i32 1, i32* %10
%74 = load i8*, i8** %9
%75 = getelementptr inbounds i8, i8* %74, i32 1
store i8* %75, i8** %9
br label %37
76: ; preds = %70
br label %115
77: ; preds = %56
%78 = load i32, i32* %11
%79 = icmp ne i32 %78, 0
br i1 %79, label %80, label %83
80: ; preds = %77
store i32 0, i32* %10
%81 = load i8*, i8** %9
%82 = getelementptr inbounds i8, i8* %81, i32 1
store i8* %82, i8** %9
br label %37
83: ; preds = %77
%84 = load i32, i32* %12
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %89
86: ; preds = %83
store i32 2, i32* %10
%87 = load i8*, i8** %9
%88 = getelementptr inbounds i8, i8* %87, i32 1
store i8* %88, i8** %9
br label %37
89: ; preds = %83
%90 = load i8*, i8** %9
%91 = getelementptr inbounds i8, i8* %90, i64 0
%92 = load i8, i8* %91
%93 = load i32, i32* %8
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %94
store i8 %92, i8* %95
%96 = load i32, i32* %8
%97 = add nsw i32 %96, 1
store i32 %97, i32* %8
%98 = sext i32 %96 to i64
%99 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %98
store i8 -1, i8* %99
%100 = load i8*, i8** %9
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %9
br label %37
102: ; preds = %56
%103 = load i8*, i8** %9
%104 = getelementptr inbounds i8, i8* %103, i64 0
%105 = load i8, i8* %104
%106 = load i32, i32* %8
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %107
store i8 %105, i8* %108
%109 = load i32, i32* %8
%110 = add nsw i32 %109, 1
store i32 %110, i32* %8
%111 = sext i32 %109 to i64
%112 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %111
store i8 -1, i8* %112
store i32 1, i32* %10
%113 = load i8*, i8** %9
%114 = getelementptr inbounds i8, i8* %113, i32 1
store i8* %114, i8** %9
br label %37
115: ; preds = %56, %76
%116 = load i8*, i8** %9
%117 = getelementptr inbounds i8, i8* %116, i64 0
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = icmp eq i32 %119, 63
br i1 %120, label %121, label %138
121: ; preds = %115
%122 = load i8*, i8** %9
%123 = getelementptr inbounds i8, i8* %122, i64 1
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = icmp eq i32 %125, 63
br i1 %126, label %127, label %138
127: ; preds = %121
%128 = load i32, i32* %8
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %129
store i8 0, i8* %130
%131 = load i32, i32* %8
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %132
store i8 0, i8* %133
%134 = load i32, i32* %8
%135 = add nsw i32 %134, 1
store i32 %135, i32* %8
%136 = load i8*, i8** %9
%137 = getelementptr inbounds i8, i8* %136, i64 2
store i8* %137, i8** %9
br label %180
138: ; preds = %121, %115
%139 = load i8*, i8** %9
%140 = getelementptr inbounds i8, i8* %139, i64 0
%141 = load i8, i8* %140
%142 = sext i8 %141 to i32
%143 = icmp eq i32 %142, 32
br i1 %143, label %144, label %147
144: ; preds = %138
%145 = load i8*, i8** %9
%146 = getelementptr inbounds i8, i8* %145, i32 1
store i8* %146, i8** %9
br label %179
147: ; preds = %138
%148 = load i8*, i8** %9
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %9
%150 = load i8, i8* %148
%151 = sext i8 %150 to i32
%152 = call i32 @ascii2hex(i32 %151)
store i32 %152, i32* %13
%153 = load i8*, i8** %9
%154 = getelementptr inbounds i8, i8* %153, i32 1
store i8* %154, i8** %9
%155 = load i8, i8* %153
%156 = sext i8 %155 to i32
%157 = call i32 @ascii2hex(i32 %156)
store i32 %157, i32* %14
%158 = load i32, i32* %13
%159 = icmp eq i32 %158, -1
br i1 %159, label %163, label %160
160: ; preds = %147
%161 = load i32, i32* %14
%162 = icmp eq i32 %161, -1
br i1 %162, label %163, label %166
163: ; preds = %160, %147
%164 = load i32, i32* @stderr
%165 = call i32 @fprintf(i32 %164, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
store i32 2, i32* %3
br label %218
166: ; preds = %160
%167 = load i32, i32* %13
%168 = shl i32 %167, 4
%169 = load i32, i32* %14
%170 = or i32 %168, %169
%171 = trunc i32 %170 to i8
%172 = load i32, i32* %8
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %173
store i8 %171, i8* %174
%175 = load i32, i32* %8
%176 = add nsw i32 %175, 1
store i32 %176, i32* %8
%177 = sext i32 %175 to i64
%178 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %177
store i8 -1, i8* %178
br label %179
179: ; preds = %166, %144
br label %180
180: ; preds = %179, %127
br label %37
181: ; preds = %54
%182 = load i32, i32* %8
%183 = icmp ne i32 %182, 0
br i1 %183, label %184, label %189
184: ; preds = %181
%185 = load i8*, i8** %9
%186 = load i8, i8* %185
%187 = sext i8 %186 to i32
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %192
189: ; preds = %184, %181
%190 = load i32, i32* @stderr
%191 = call i32 @fprintf(i32 %190, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
store i32 2, i32* %3
br label %218
192: ; preds = %184
%193 = load i32, i32* %4
%194 = icmp slt i32 %193, 3
br i1 %194, label %195, label %200
195: ; preds = %192
%196 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%197 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%198 = load i32, i32* %8
%199 = call i32 @searchfile(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 0, i8* %196, i8* %197, i32 %198)
br label %217
200: ; preds = %192
store i32 2, i32* %15
br label %201
201: ; preds = %205, %200
%202 = load i32, i32* %15
%203 = load i32, i32* %4
%204 = icmp slt i32 %202, %203
br i1 %204, label %205, label %216
205: ; preds = %201
%206 = load i8**, i8*** %5
%207 = load i32, i32* %15
%208 = add nsw i32 %207, 1
store i32 %208, i32* %15
%209 = sext i32 %207 to i64
%210 = getelementptr inbounds i8*, i8** %206, i64 %209
%211 = load i8*, i8** %210
%212 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%213 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%214 = load i32, i32* %8
%215 = call i32 @recurse(i8* %211, i8* %212, i8* %213, i32 %214)
br label %201
216: ; preds = %201
br label %217
217: ; preds = %216, %195
store i32 0, i32* %3
br label %218
218: ; preds = %217, %189, %163, %18
%219 = load i32, i32* %3
ret i32 %219
}

LLVM IR (-O2):
@optind = global i32 0
@stderr = global i32 0
@.str = [21 x i8] c"invalid hex string!\0A\00"
@.str.1 = [29 x i8] c"invalid/empty search string\0A\00"
@.str.2 = [6 x i8] c"stdin\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca [256 x i8]
%4 = alloca [256 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%7 = icmp slt i32 %0, 2
br i1 %7, label %8, label %10
8: ; preds = %2
%9 = tail call i32 @usage(i8** %1)
br label %120
10: ; preds = %2
%11 = tail call i32 @parse_opts(i32 %0, i8** %1)
%12 = load i32, i32* @optind
%13 = add nsw i32 %12, -1
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i8*, i8** %1, i64 %14
%16 = sub i32 %0, %13
%17 = getelementptr inbounds i8*, i8** %15, i64 1
%18 = load i8*, i8** %17
%19 = load i8, i8* %18
%20 = icmp eq i8 %19, 0
br i1 %20, label %104, label %21
21: ; preds = %10, %96
%22 = phi i8 [ %97, %96 ], [ %19, %10 ]
%23 = phi i32 [ %100, %96 ], [ 0, %10 ]
%24 = phi i32 [ %99, %96 ], [ 0, %10 ]
%25 = phi i8* [ %98, %96 ], [ %18, %10 ]
%26 = icmp eq i32 %24, 0
br i1 %26, label %27, label %34
27: ; preds = %21
%28 = getelementptr inbounds i8, i8* %25, i64 1
%29 = load i8, i8* %28
%30 = icmp ne i8 %29, 0
%31 = icmp slt i32 %23, 256
%32 = select i1 %30, i1 %31, i1 false
br i1 %32, label %33, label %104
33: ; preds = %27
switch i8 %22, label %69 [
i8 34, label %96
i8 63, label %58
i8 32, label %67
]
34: ; preds = %21
%35 = icmp slt i32 %23, 256
br i1 %35, label %36, label %104
36: ; preds = %34
switch i32 %24, label %54 [
i32 2, label %48
i32 1, label %37
]
37: ; preds = %36
switch i8 %22, label %42 [
i8 34, label %38
i8 92, label %40
]
38: ; preds = %37
%39 = getelementptr inbounds i8, i8* %25, i64 1
br label %91
40: ; preds = %37
%41 = getelementptr inbounds i8, i8* %25, i64 1
br label %91
42: ; preds = %37
%43 = sext i32 %23 to i64
%44 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %43
store i8 %22, i8* %44
%45 = add nsw i32 %23, 1
%46 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %43
store i8 -1, i8* %46
%47 = getelementptr inbounds i8, i8* %25, i64 1
br label %91
48: ; preds = %36
%49 = sext i32 %23 to i64
%50 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %49
store i8 %22, i8* %50
%51 = add nsw i32 %23, 1
%52 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %49
store i8 -1, i8* %52
%53 = getelementptr inbounds i8, i8* %25, i64 1
br label %91
54: ; preds = %36
switch i8 %22, label %69 [
i8 63, label %55
i8 32, label %67
]
55: ; preds = %54
%56 = getelementptr inbounds i8, i8* %25, i64 1
%57 = load i8, i8* %56
br label %58
58: ; preds = %55, %33
%59 = phi i8 [ %57, %55 ], [ %29, %33 ]
%60 = icmp eq i8 %59, 63
br i1 %60, label %61, label %69
61: ; preds = %58
%62 = sext i32 %23 to i64
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %62
store i8 0, i8* %63
%64 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %62
store i8 0, i8* %64
%65 = add nsw i32 %23, 1
%66 = getelementptr inbounds i8, i8* %25, i64 2
br label %91
67: ; preds = %33, %54
%68 = getelementptr inbounds i8, i8* %25, i64 1
br label %91
69: ; preds = %33, %54, %58
%70 = sext i8 %22 to i32
%71 = getelementptr inbounds i8, i8* %25, i64 1
%72 = tail call i32 @ascii2hex(i32 %70)
%73 = load i8, i8* %71
%74 = sext i8 %73 to i32
%75 = tail call i32 @ascii2hex(i32 %74)
%76 = icmp eq i32 %72, -1
%77 = icmp eq i32 %75, -1
%78 = select i1 %76, i1 true, i1 %77
br i1 %78, label %79, label %82
79: ; preds = %69
%80 = load i32, i32* @stderr
%81 = tail call i32 @fprintf(i32 %80, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
br label %120
82: ; preds = %69
%83 = getelementptr inbounds i8, i8* %25, i64 2
%84 = shl i32 %72, 4
%85 = or i32 %75, %84
%86 = trunc i32 %85 to i8
%87 = sext i32 %23 to i64
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %87
store i8 %86, i8* %88
%89 = add nsw i32 %23, 1
%90 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %87
store i8 -1, i8* %90
br label %91
91: ; preds = %38, %40, %42, %48, %82, %67, %61
%92 = phi i8* [ %83, %82 ], [ %68, %67 ], [ %66, %61 ], [ %47, %42 ], [ %41, %40 ], [ %39, %38 ], [ %53, %48 ]
%93 = phi i32 [ %24, %82 ], [ %24, %67 ], [ %24, %61 ], [ 1, %42 ], [ 2, %40 ], [ 0, %38 ], [ 1, %48 ]
%94 = phi i32 [ %89, %82 ], [ %23, %67 ], [ %65, %61 ], [ %45, %42 ], [ %23, %40 ], [ %23, %38 ], [ %51, %48 ]
%95 = load i8, i8* %92
br label %96
96: ; preds = %91, %33
%97 = phi i8 [ %95, %91 ], [ %29, %33 ]
%98 = phi i8* [ %92, %91 ], [ %28, %33 ]
%99 = phi i32 [ %93, %91 ], [ 1, %33 ]
%100 = phi i32 [ %94, %91 ], [ %23, %33 ]
%101 = icmp eq i8 %97, 0
br i1 %101, label %102, label %21
102: ; preds = %96
%103 = icmp eq i32 %100, 0
br i1 %103, label %104, label %107
104: ; preds = %27, %34, %10, %102
%105 = load i32, i32* @stderr
%106 = tail call i32 @fprintf(i32 %105, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.1, i64 0, i64 0))
br label %120
107: ; preds = %102
%108 = icmp slt i32 %16, 3
br i1 %108, label %111, label %109
109: ; preds = %107
%110 = zext i32 %16 to i64
br label %113
111: ; preds = %107
%112 = call i32 @searchfile(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 0, i8* %5, i8* %6, i32 %100)
br label %120
113: ; preds = %109, %113
%114 = phi i64 [ 2, %109 ], [ %115, %113 ]
%115 = add nuw nsw i64 %114, 1
%116 = getelementptr inbounds i8*, i8** %15, i64 %114
%117 = load i8*, i8** %116
%118 = call i32 @recurse(i8* %117, i8* %5, i8* %6, i32 %100)
%119 = icmp eq i64 %115, %110
br i1 %119, label %120, label %113
120: ; preds = %113, %79, %104, %111, %8
%121 = phi i32 [ 1, %8 ], [ 2, %104 ], [ 0, %111 ], [ 2, %79 ], [ 0, %113 ]
ret i32 %121
}