#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 EOF;
int /*<<< orphan*/ dump(int, char **, char const *, char const *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/);
int getopt(int, char **, char *);
void *malloc(int);
char *optarg;
int optind;
char *realloc(char *, int);
int /*<<< orphan*/ stdin;
char *strchr(char *, char);
int /*<<< orphan*/ strcmp(char *, char *);
char *strdup(char *);
int strlen(char const *);
char *strstr(char *, char const *);
int /*<<< orphan*/ usage();
int main(int argc, char *argv[]) {
  int i, arg, alloc, len = 0, record_len, *field_len;
  char *buffer = malloc(alloc = 4096), **fields;
  const char *record, *quote = "\"", *delimiter = ",";
  while (EOF != (arg = getopt(argc, argv, "q:d:")))
    switch (arg) {
    case 'q':
      quote = optarg;
      break;
    case 'd':
      delimiter = optarg;
      break;
    case '?':
      usage();
    }
  if (argc - optind < 2)
    usage();
  argv += optind;
  argc -= optind;
  record_len = strlen((record = argv[0]));
  ++argv;
  --argc;
  fields = malloc(argc * sizeof(*fields));
  field_len = malloc(argc * sizeof(*field_len));
  for (i = 0; i < argc; ++i) {
    field_len[i] = strlen(argv[i]);
    fields[i] = NULL;
  }
  while (NULL != fgets(buffer + len, alloc - len, stdin)) {
    char *eq, *find;
    if ('\0' == buffer[len])
      break;
    len += strlen(buffer + len);
    if ('\n' != buffer[len - 1]) {
      buffer = realloc(buffer, alloc *= 2);
      continue;
    }
    buffer[--len] = '\0';
    eq = strchr(buffer, '=');
    if (NULL != eq) {
      len = eq - buffer;
      *eq++ = '\0';
    }
    find = strstr(buffer, record);
    if (NULL == find || '/' != find[record_len] ||
        (buffer != find && '/' != find[-1])) {
      dump(argc, fields, quote, delimiter);
      continue;
    }
    for (i = 0; i < argc; ++i) {
      if (field_len[i] <= len &&
          !strcmp(buffer + len - field_len[i], argv[i]) &&
          (field_len[i] == len || '/' == buffer[len - field_len[i] - 1]))
        fields[i] = strdup(eq ? eq : "");
    }
    len = 0;
  }
  dump(argc, fields, quote, delimiter);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x1000,-0x1c(%rbp)
mov    $0x1000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
lea    0xe14(%rip),%rax
mov    %rax,-0x50(%rbp)
lea    0xe0b(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0x2dd6(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xdef(%rip),%rdx
call   10b0 <getopt@plt>
mov    %eax,%ecx
mov    -0x6c(%rbp),%eax
mov    %ecx,-0x18(%rbp)
cmp    %ecx,%eax
je     1292 <main+0xe2>
mov    -0x18(%rbp),%eax
mov    %eax,-0x70(%rbp)
sub    $0x3f,%eax
je     1286 <main+0xd6>
jmp    123e <main+0x8e>
mov    -0x70(%rbp),%eax
sub    $0x64,%eax
je     1273 <main+0xc3>
jmp    124f <main+0x9f>
mov    -0x70(%rbp),%eax
sub    $0x71,%eax
jne    128d <main+0xdd>
jmp    1260 <main+0xb0>
mov    0x2d91(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
jmp    128d <main+0xdd>
mov    0x2d7e(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
jmp    128d <main+0xdd>
mov    $0x0,%al
call   10a0 <usage@plt>
jmp    11fb <main+0x4b>
mov    -0x8(%rbp),%eax
mov    0x2d34(%rip),%rcx
sub    (%rcx),%eax
cmp    $0x2,%eax
jge    12ae <main+0xfe>
mov    $0x0,%al
call   10a0 <usage@plt>
mov    0x2d1b(%rip),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    0x2d00(%rip),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
mov    %rdi,-0x48(%rbp)
call   1030 <strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1377 <main+0x1c7>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    132f <main+0x17f>
jmp    137c <main+0x1cc>
mov    -0x38(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
mov    -0x1c(%rbp),%esi
sub    -0x20(%rbp),%esi
mov    0x2c4c(%rip),%rax
mov    (%rax),%edx
call   1060 <fgets@plt>
mov    %rax,%rcx
xor    %eax,%eax
cmp    %rcx,%rax
je     15d3 <main+0x423>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    13c4 <main+0x214>
jmp    15d3 <main+0x423>
mov    -0x38(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
call   1030 <strlen@plt>
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0xa,%eax
cmp    %ecx,%eax
je     1413 <main+0x263>
mov    -0x38(%rbp),%rdi
mov    -0x1c(%rbp),%esi
shl    $0x1,%esi
mov    %esi,-0x1c(%rbp)
call   1090 <realloc@plt>
mov    %rax,-0x38(%rbp)
jmp    137c <main+0x1cc>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rdi
mov    $0x3d,%esi
call   1040 <strchr@plt>
mov    %rax,-0x60(%rbp)
xor    %eax,%eax
cmp    -0x60(%rbp),%rax
je     1465 <main+0x2b5>
mov    -0x60(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x20(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x60(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   10d0 <strstr@plt>
mov    %rax,-0x68(%rbp)
xor    %eax,%eax
cmp    -0x68(%rbp),%rax
je     14be <main+0x30e>
mov    -0x68(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2f,%eax
cmp    %ecx,%eax
jne    14be <main+0x30e>
mov    -0x38(%rbp),%rax
cmp    -0x68(%rbp),%rax
je     14d7 <main+0x327>
mov    -0x68(%rbp),%rax
movsbl -0x1(%rax),%ecx
mov    $0x2f,%eax
cmp    %ecx,%eax
je     14d7 <main+0x327>
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
call   1050 <dump@plt>
jmp    137c <main+0x1cc>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15c7 <main+0x417>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
jg     15b4 <main+0x404>
mov    -0x38(%rbp),%rdi
movslq -0x20(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
movslq (%rax,%rcx,4),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    15b4 <main+0x404>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x20(%rbp),%eax
je     1574 <main+0x3c4>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    -0x30(%rbp),%rdx
movslq -0x14(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x2f,%eax
cmp    %ecx,%eax
jne    15b4 <main+0x404>
cmpq   $0x0,-0x60(%rbp)
je     158c <main+0x3dc>
mov    -0x60(%rbp),%rax
mov    %rax,-0x78(%rbp)
jmp    159c <main+0x3ec>
lea    0xa6e(%rip),%rax
mov    %rax,-0x78(%rbp)
jmp    159c <main+0x3ec>
mov    -0x78(%rbp),%rdi
call   10c0 <strdup@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    15b9 <main+0x409>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14de <main+0x32e>
movl   $0x0,-0x20(%rbp)
jmp    137c <main+0x1cc>
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
call   1050 <dump@plt>
xor    %eax,%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rsi,%rbp
mov    %edi,%r15d
mov    $0x1000,%edi
call   1080 <malloc@plt>
mov    %rax,%r12
mov    0x2e00(%rip),%rbx
mov    (%rbx),%r14d
lea    0xe22(%rip),%rdx
mov    %r15d,%edi
mov    %rbp,%rsi
call   10b0 <getopt@plt>
cmp    %eax,%r14d
jne    1495 <main+0x2e5>
lea    0xe05(%rip),%rax
mov    %rax,0x8(%rsp)
lea    0xdf7(%rip),%rax
mov    %rax,(%rsp)
mov    0x2dbc(%rip),%r14
mov    (%r14),%eax
mov    %r15d,%ecx
sub    %eax,%ecx
cmp    $0x1,%ecx
jg     122b <main+0x7b>
xor    %eax,%eax
call   10a0 <usage@plt>
mov    (%r14),%eax
movslq %eax,%rbx
mov    0x0(%rbp,%rbx,8),%rdi
mov    %rdi,0x38(%rsp)
call   1030 <strlen@plt>
mov    %eax,0x20(%rsp)
lea    0x8(%rbp,%rbx,8),%rbp
not    %ebx
add    %r15d,%ebx
mov    %rbp,%r15
lea    0x0(,%rbx,8),%edi
call   1080 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%rbx,4),%edi
call   1080 <malloc@plt>
mov    %rax,%r13
mov    %ebx,%ebp
mov    %rbx,0x10(%rsp)
test   %ebx,%ebx
jle    129f <main+0xef>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rdi
call   1030 <strlen@plt>
mov    %eax,0x0(%r13,%rbx,4)
movq   $0x0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1280 <main+0xd0>
mov    %rbp,0x48(%rsp)
mov    %r14,0x18(%rsp)
mov    %r15,0x40(%rsp)
mov    0x2d2b(%rip),%rax
mov    (%rax),%edx
mov    $0x1000,%r14d
mov    %r12,%rdi
mov    $0x1000,%esi
call   1060 <fgets@plt>
test   %rax,%rax
mov    %r13,0x50(%rsp)
je     146c <main+0x2bc>
movslq 0x20(%rsp),%rax
mov    %rax,0x30(%rsp)
xor    %ebx,%ebx
mov    %r12,%r15
jmp    132e <main+0x17e>
nopl   0x0(%rax)
mov    %r14d,%ebx
add    %r14d,%ebx
mov    %r15,%rdi
mov    %ebx,%esi
call   1090 <realloc@plt>
mov    %rax,%r15
movslq %r13d,%rax
lea    (%r15,%rax,1),%r12
mov    %ebx,%r14d
sub    %eax,%ebx
mov    0x2cca(%rip),%rax
mov    (%rax),%edx
mov    %r12,%rdi
mov    %ebx,%esi
call   1060 <fgets@plt>
mov    %r13d,%ebx
test   %rax,%rax
je     146c <main+0x2bc>
cmpb   $0x0,(%r12)
je     146c <main+0x2bc>
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    %eax,%r13d
add    %ebx,%r13d
movslq %r13d,%rbx
cmpb   $0xa,-0x1(%r15,%rbx,1)
jne    12f0 <main+0x140>
add    $0xffffffffffffffff,%rbx
movb   $0x0,(%r15,%rbx,1)
mov    %r15,%rdi
mov    $0x3d,%esi
call   1040 <strchr@plt>
test   %rax,%rax
je     137f <main+0x1cf>
mov    %eax,%r13d
sub    %r15d,%r13d
mov    %rax,%rbp
add    $0x1,%rbp
movb   $0x0,(%rax)
jmp    1384 <main+0x1d4>
mov    %ebx,%r13d
xor    %ebp,%ebp
mov    %r15,%rdi
mov    0x38(%rsp),%rsi
call   10d0 <strstr@plt>
test   %rax,%rax
mov    %r14d,%ebx
je     13e0 <main+0x230>
mov    0x30(%rsp),%rcx
cmpb   $0x2f,(%rax,%rcx,1)
jne    13e0 <main+0x230>
cmp    %rax,%r15
je     13af <main+0x1ff>
cmpb   $0x2f,-0x1(%rax)
jne    13e0 <main+0x230>
cmpl   $0x0,0x10(%rsp)
jle    1464 <main+0x2b4>
movslq %r13d,%rax
add    %r15,%rax
mov    %rax,0x20(%rsp)
test   %rbp,%rbp
lea    0xc32(%rip),%rax
cmove  %rax,%rbp
mov    %rbp,0x28(%rsp)
xor    %r12d,%r12d
jmp    141b <main+0x26b>
nopl   (%rax)
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    (%rsp),%rdx
mov    0x8(%rsp),%rcx
call   1050 <dump@plt>
jmp    1303 <main+0x153>
mov    0x28(%rsp),%rdi
call   10c0 <strdup@plt>
mov    0x18(%rsp),%rcx
mov    %rax,(%rcx,%r12,8)
add    $0x1,%r12
cmp    %r12,0x48(%rsp)
je     1459 <main+0x2a9>
mov    0x50(%rsp),%rax
movslq (%rax,%r12,4),%rbx
cmp    %ebx,%r13d
jl     1410 <main+0x260>
mov    0x20(%rsp),%rdi
sub    %rbx,%rdi
mov    0x40(%rsp),%rax
mov    (%rax,%r12,8),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
jne    1410 <main+0x260>
cmp    %ebx,%r13d
je     13fd <main+0x24d>
not    %ebx
add    %r13d,%ebx
movslq %ebx,%rax
cmpb   $0x2f,(%r15,%rax,1)
je     13fd <main+0x24d>
jmp    1410 <main+0x260>
xor    %r13d,%r13d
mov    %r14d,%ebx
jmp    1303 <main+0x153>
xor    %r13d,%r13d
jmp    1303 <main+0x153>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
mov    (%rsp),%rdx
mov    0x8(%rsp),%rcx
call   1050 <dump@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xb64(%rip),%rcx
mov    %rcx,(%rsp)
lea    0xb5b(%rip),%rcx
mov    %rcx,0x8(%rsp)
lea    0xb51(%rip),%r14
jmp    14e1 <main+0x331>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   10a0 <usage@plt>
mov    (%rbx),%r13d
mov    %r15d,%edi
mov    %rbp,%rsi
mov    %r14,%rdx
call   10b0 <getopt@plt>
cmp    %eax,%r13d
je     120d <main+0x5d>
cmp    $0x3f,%eax
je     14c0 <main+0x310>
cmp    $0x64,%eax
je     1500 <main+0x350>
cmp    $0x71,%eax
jne    14c7 <main+0x317>
mov    0x2b01(%rip),%rax
mov    (%rax),%rax
mov    %rax,(%rsp)
jmp    14c7 <main+0x317>
mov    0x2af1(%rip),%rax
mov    (%rax),%rax
mov    %rax,0x8(%rsp)
jmp    14c7 <main+0x317>

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

LLVM IR (-O2):
@.str = [2 x i8] c"\22\00"
@.str.1 = [2 x i8] c",\00"
@EOF = global i32 0
@.str.2 = [5 x i8] c"q:d:\00"
@optarg = global i8* null
@optind = global i32 0
@stdin = global i32 0
@.str.3 = [1 x i8] zeroinitializer
define i32 @main(i32 %0, i8** %1) {
%3 = tail call dereferenceable_or_null(4096) i8* @malloc(i32 4096)
%4 = load i32, i32* @EOF
%5 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%6 = icmp eq i32 %4, %5
br i1 %6, label %23, label %7
7: ; preds = %2, %17
%8 = phi i32 [ %21, %17 ], [ %5, %2 ]
%9 = phi i8* [ %19, %17 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), %2 ]
%10 = phi i8* [ %18, %17 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), %2 ]
switch i32 %8, label %17 [
i32 113, label %11
i32 100, label %13
i32 63, label %15
]
11: ; preds = %7
%12 = load i8*, i8** @optarg
br label %17
13: ; preds = %7
%14 = load i8*, i8** @optarg
br label %17
15: ; preds = %7
%16 = tail call i32 (...) @usage()
br label %17
17: ; preds = %15, %7, %13, %11
%18 = phi i8* [ %10, %7 ], [ %10, %15 ], [ %10, %13 ], [ %12, %11 ]
%19 = phi i8* [ %9, %7 ], [ %9, %15 ], [ %14, %13 ], [ %9, %11 ]
%20 = load i32, i32* @EOF
%21 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0))
%22 = icmp eq i32 %20, %21
br i1 %22, label %23, label %7
23: ; preds = %17, %2
%24 = phi i8* [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), %2 ], [ %18, %17 ]
%25 = phi i8* [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), %2 ], [ %19, %17 ]
%26 = load i32, i32* @optind
%27 = sub nsw i32 %0, %26
%28 = icmp slt i32 %27, 2
br i1 %28, label %29, label %32
29: ; preds = %23
%30 = tail call i32 (...) @usage()
%31 = load i32, i32* @optind
br label %32
32: ; preds = %29, %23
%33 = phi i32 [ %31, %29 ], [ %26, %23 ]
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8*, i8** %1, i64 %34
%36 = load i8*, i8** %35
%37 = tail call i32 @strlen(i8* %36)
%38 = getelementptr inbounds i8*, i8** %35, i64 1
%39 = xor i32 %33, -1
%40 = add i32 %39, %0
%41 = shl i32 %40, 3
%42 = tail call i8* @malloc(i32 %41)
%43 = bitcast i8* %42 to i8**
%44 = shl i32 %40, 2
%45 = tail call i8* @malloc(i32 %44)
%46 = bitcast i8* %45 to i32*
%47 = icmp sgt i32 %40, 0
br i1 %47, label %48, label %50
48: ; preds = %32
%49 = zext i32 %40 to i64
br label %57
50: ; preds = %57, %32
%51 = load i32, i32* @stdin
%52 = tail call i32* @fgets(i8* %3, i32 4096, i32 %51)
%53 = icmp eq i32* %52, null
br i1 %53, label %154, label %54
54: ; preds = %50
%55 = sext i32 %37 to i64
%56 = zext i32 %40 to i64
br label %66
57: ; preds = %48, %57
%58 = phi i64 [ 0, %48 ], [ %64, %57 ]
%59 = getelementptr inbounds i8*, i8** %38, i64 %58
%60 = load i8*, i8** %59
%61 = tail call i32 @strlen(i8* %60)
%62 = getelementptr inbounds i32, i32* %46, i64 %58
store i32 %61, i32* %62
%63 = getelementptr inbounds i8*, i8** %43, i64 %58
store i8* null, i8** %63
%64 = add nuw nsw i64 %58, 1
%65 = icmp eq i64 %64, %49
br i1 %65, label %50, label %57
66: ; preds = %54, %144
%67 = phi i8* [ %3, %54 ], [ %149, %144 ]
%68 = phi i8* [ %3, %54 ], [ %147, %144 ]
%69 = phi i32 [ 4096, %54 ], [ %146, %144 ]
%70 = phi i32 [ 0, %54 ], [ %145, %144 ]
%71 = load i8, i8* %67
%72 = icmp eq i8 %71, 0
br i1 %72, label %154, label %73
73: ; preds = %66
%74 = tail call i32 @strlen(i8* %67)
%75 = add nsw i32 %74, %70
%76 = add nsw i32 %75, -1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %68, i64 %77
%79 = load i8, i8* %78
%80 = icmp eq i8 %79, 10
br i1 %80, label %84, label %81
81: ; preds = %73
%82 = shl nsw i32 %69, 1
%83 = tail call i8* @realloc(i8* %68, i32 %82)
br label %144
84: ; preds = %73
store i8 0, i8* %78
%85 = tail call i8* @strchr(i8* dereferenceable(1) %68, i8 signext 61)
%86 = icmp eq i8* %85, null
br i1 %86, label %93, label %87
87: ; preds = %84
%88 = ptrtoint i8* %85 to i64
%89 = ptrtoint i8* %68 to i64
%90 = sub i64 %88, %89
%91 = trunc i64 %90 to i32
%92 = getelementptr inbounds i8, i8* %85, i64 1
store i8 0, i8* %85
br label %93
93: ; preds = %87, %84
%94 = phi i32 [ %91, %87 ], [ %76, %84 ]
%95 = phi i8* [ %92, %87 ], [ null, %84 ]
%96 = tail call i8* @strstr(i8* dereferenceable(1) %68, i8* dereferenceable(1) %36)
%97 = icmp eq i8* %96, null
br i1 %97, label %108, label %98
98: ; preds = %93
%99 = getelementptr inbounds i8, i8* %96, i64 %55
%100 = load i8, i8* %99
%101 = icmp eq i8 %100, 47
br i1 %101, label %102, label %108
102: ; preds = %98
%103 = icmp eq i8* %68, %96
br i1 %103, label %110, label %104
104: ; preds = %102
%105 = getelementptr inbounds i8, i8* %96, i64 -1
%106 = load i8, i8* %105
%107 = icmp eq i8 %106, 47
br i1 %107, label %110, label %108
108: ; preds = %104, %98, %93
%109 = tail call i32 @dump(i32 %40, i8** %43, i8* %24, i8* %25)
br label %144
110: ; preds = %104, %102
br i1 %47, label %111, label %144
111: ; preds = %110
%112 = sext i32 %94 to i64
%113 = getelementptr inbounds i8, i8* %68, i64 %112
%114 = icmp eq i8* %95, null
%115 = select i1 %114, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* %95
br label %116
116: ; preds = %111, %141
%117 = phi i64 [ 0, %111 ], [ %142, %141 ]
%118 = getelementptr inbounds i32, i32* %46, i64 %117
%119 = load i32, i32* %118
%120 = icmp slt i32 %94, %119
br i1 %120, label %141, label %121
121: ; preds = %116
%122 = sext i32 %119 to i64
%123 = sub nsw i64 0, %122
%124 = getelementptr inbounds i8, i8* %113, i64 %123
%125 = getelementptr inbounds i8*, i8** %38, i64 %117
%126 = load i8*, i8** %125
%127 = tail call i32 @strcmp(i8* dereferenceable(1) %124, i8* dereferenceable(1) %126)
%128 = icmp eq i32 %127, 0
br i1 %128, label %129, label %141
129: ; preds = %121
%130 = icmp eq i32 %94, %119
br i1 %130, label %138, label %131
131: ; preds = %129
%132 = xor i32 %119, -1
%133 = add i32 %94, %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i8, i8* %68, i64 %134
%136 = load i8, i8* %135
%137 = icmp eq i8 %136, 47
br i1 %137, label %138, label %141
138: ; preds = %131, %129
%139 = tail call i8* @strdup(i8* %115)
%140 = getelementptr inbounds i8*, i8** %43, i64 %117
store i8* %139, i8** %140
br label %141
141: ; preds = %116, %121, %131, %138
%142 = add nuw nsw i64 %117, 1
%143 = icmp eq i64 %142, %56
br i1 %143, label %144, label %116
144: ; preds = %141, %110, %108, %81
%145 = phi i32 [ %75, %81 ], [ %94, %108 ], [ 0, %110 ], [ 0, %141 ]
%146 = phi i32 [ %82, %81 ], [ %69, %108 ], [ %69, %110 ], [ %69, %141 ]
%147 = phi i8* [ %83, %81 ], [ %68, %108 ], [ %68, %110 ], [ %68, %141 ]
%148 = sext i32 %145 to i64
%149 = getelementptr inbounds i8, i8* %147, i64 %148
%150 = sub nsw i32 %146, %145
%151 = load i32, i32* @stdin
%152 = tail call i32* @fgets(i8* %149, i32 %150, i32 %151)
%153 = icmp eq i32* %152, null
br i1 %153, label %154, label %66
154: ; preds = %144, %66, %50
%155 = tail call i32 @dump(i32 %40, i8** %43, i8* %24, i8* %25)
ret i32 0
}