#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 */
typedef int /*<<< orphan*/ abLine;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
scalar_t__ ferror(int /*<<< orphan*/ *);
int /*<<< orphan*/ fflush(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
size_t fread(unsigned char *, int, size_t, int /*<<< orphan*/ *);
size_t fsize(int /*<<< orphan*/ *);
scalar_t__ isprint(unsigned char);
int /*<<< orphan*/ remove(char *);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strcmp(char *, char *);
long strtol(char *, int /*<<< orphan*/ *, int /*<<< orphan*/);
int strtoul(char *, int /*<<< orphan*/ *, int /*<<< orphan*/);
int usage(char *);
int main(int argc, char *argv[]) {
  FILE *pFileIn;
  FILE *pFileOut;
  int iArg;
  size_t cbMin = 0;
  size_t cbMax = ~0U;
  size_t uMask = 0;
  int fAscii = 0;
  int fExport = 0;
  long iBreakEvery = -1;
  unsigned char abLine[32];
  size_t cbLine = 16;
  size_t off;
  size_t cbRead;
  size_t cbBin;
  int rc = 1;
  if (argc < 2)
    return usage(argv[0]);
  for (iArg = 1; iArg < argc; iArg++) {
    if (!strcmp(argv[iArg], "-min")) {
      if (++iArg >= argc)
        return usage(argv[0]);
      cbMin = 1024 * strtoul(argv[iArg], NULL, 0);
    } else if (!strcmp(argv[iArg], "-max")) {
      if (++iArg >= argc)
        return usage(argv[0]);
      cbMax = 1024 * strtoul(argv[iArg], NULL, 0);
    } else if (!strcmp(argv[iArg], "-mask")) {
      if (++iArg >= argc)
        return usage(argv[0]);
      uMask = strtoul(argv[iArg], NULL, 0);
    } else if (!strcmp(argv[iArg], "-ascii")) {
      fAscii = 1;
    } else if (!strcmp(argv[iArg], "-export")) {
      fExport = 1;
    } else if (!strcmp(argv[iArg], "-width")) {
      if (++iArg >= argc)
        return usage(argv[0]);
      cbLine = strtoul(argv[iArg], NULL, 0);
      if (cbLine == 0 || cbLine > sizeof(abLine)) {
        fprintf(stderr, "%s: '%s' is too wide, max %u\n", argv[0], argv[iArg],
                (unsigned)sizeof(abLine));
        return 1;
      }
    } else if (!strcmp(argv[iArg], "-break")) {
      if (++iArg >= argc)
        return usage(argv[0]);
      iBreakEvery = strtol(argv[iArg], NULL, 0);
      if (iBreakEvery <= 0 && iBreakEvery != -1) {
        fprintf(stderr, "%s: -break value '%s' is not >= 1 or -1.\n", argv[0],
                argv[iArg]);
        return 1;
      }
    } else if (iArg == argc - 3)
      break;
    else {
      fprintf(stderr, "%s: syntax error: Unknown argument '%s'\n", argv[0],
              argv[iArg]);
      return usage(argv[0]);
    }
  }
  pFileIn = fopen(argv[iArg + 1], "rb");
  if (!pFileIn) {
    fprintf(stderr, "Error: failed to open input file '%s'!\n", argv[iArg + 1]);
    return 1;
  }
  pFileOut = fopen(argv[iArg + 2], "wb");
  if (!pFileOut) {
    fprintf(stderr, "Error: failed to open output file '%s'!\n",
            argv[iArg + 2]);
    fclose(pFileIn);
    return 1;
  }
  cbBin = fsize(pFileIn);
  fprintf(pFileOut,
          "/*\n"
          " * This file was automatically generated\n"
          " * from %s\n"
          " * by %s.\n"
          " */\n"
          "\n"
          "#include <iprt/cdefs.h>\n"
          "\n"
          "%sconst unsigned char%s g_ab%s[] =\n"
          "{\n",
          argv[iArg + 1], argv[0], fExport ? "DECLEXPORT(" : "",
          fExport ? ")" : "", argv[iArg]);
  if (uMask && (cbBin & uMask))
    fprintf(stderr, "%s: size=%ld - Not aligned!\n", argv[0], (long)cbBin);
  else if (cbBin < cbMin || cbBin > cbMax)
    fprintf(stderr, "%s: size=%ld - Not %ld-%ldb in size!\n", argv[0],
            (long)cbBin, (long)cbMin, (long)cbMax);
  else {
    off = 0;
    while ((cbRead = fread(&abLine[0], 1, cbLine, pFileIn)) > 0) {
      size_t j;
      if (iBreakEvery > 0 && off && (off / cbLine) % iBreakEvery == 0)
        fprintf(pFileOut, "\n");
      fprintf(pFileOut, "   ");
      for (j = 0; j < cbRead; j++)
        fprintf(pFileOut, " 0x%02x,", abLine[j]);
      for (; j < cbLine; j++)
        fprintf(pFileOut, "      ");
      if (fAscii) {
        fprintf(pFileOut, " /* 0x%08lx: ", (long)off);
        for (j = 0; j < cbRead; j++)
          fprintf(pFileOut, "%c",
                  isprint(abLine[j]) && abLine[j] != '/' ? abLine[j] : '.');
        for (; j < cbLine; j++)
          fprintf(pFileOut, " ");
        fprintf(pFileOut, " */");
      }
      fprintf(pFileOut, "\n");
      off += cbRead;
    }
    if (ferror(pFileIn) && !feof(pFileIn))
      fprintf(stderr, "%s: read error\n", argv[0]);
    else if (off != cbBin)
      fprintf(stderr, "%s: read error off=%ld cbBin=%ld\n", argv[0], (long)off,
              (long)cbBin);
    else {
      fprintf(pFileOut,
              "};\n"
              "\n"
              "%sconst unsigned%s g_cb%s = sizeof(g_ab%s);\n"
              "/* end of file */\n",
              fExport ? "DECLEXPORT(" : "", fExport ? ")" : "", argv[iArg],
              argv[iArg]);
      fflush(pFileOut);
      if (ferror(pFileOut))
        fprintf(stderr, "%s: write error\n", argv[0]);
      else
        rc = 0;
    }
  }
  fclose(pFileOut);
  fclose(pFileIn);
  if (rc)
    remove(argv[iArg + 2]);
  return rc;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x30(%rbp)
mov    $0xffffffff,%eax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movq   $0xffffffffffffffff,-0x50(%rbp)
ff
movq   $0x10,-0x78(%rbp)
movl   $0x1,-0x94(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    1258 <main+0x78>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15f9 <main+0x419>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd82(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    12d7 <main+0xf7>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    -0x8(%rbp),%eax
jl     12b2 <main+0xd2>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
shl    $0xa,%eax
cltq
mov    %rax,-0x30(%rbp)
jmp    15e6 <main+0x406>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xd1b(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1343 <main+0x163>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    -0x8(%rbp),%eax
jl     131e <main+0x13e>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
shl    $0xa,%eax
cltq
mov    %rax,-0x38(%rbp)
jmp    15e1 <main+0x401>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xcb4(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    13ac <main+0x1cc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    -0x8(%rbp),%eax
jl     138a <main+0x1aa>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
cltq
mov    %rax,-0x40(%rbp)
jmp    15dc <main+0x3fc>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc51(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    13d9 <main+0x1f9>
movl   $0x1,-0x44(%rbp)
jmp    15d7 <main+0x3f7>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc2b(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1406 <main+0x226>
movl   $0x1,-0x48(%rbp)
jmp    15d2 <main+0x3f2>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xc06(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    14c1 <main+0x2e1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    -0x8(%rbp),%eax
jl     144d <main+0x26d>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
cltq
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     1480 <main+0x2a0>
cmpq   $0x20,-0x78(%rbp)
jbe    14bc <main+0x2dc>
mov    0x2b59(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xb83(%rip),%rsi
mov    $0x20,%r8d
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
jmp    15cd <main+0x3ed>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xb70(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1574 <main+0x394>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmp    -0x8(%rbp),%eax
jl     1508 <main+0x328>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   10a0 <strtol@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jg     156f <main+0x38f>
cmpq   $0xffffffffffffffff,-0x50(%rbp)
je     156f <main+0x38f>
mov    0x2aa0(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xaef(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
jmp    15c8 <main+0x3e8>
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jne    158a <main+0x3aa>
jmp    15f9 <main+0x419>
mov    0x2a4f(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
lea    0xac8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   10c0 <usage@plt>
mov    %eax,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
jmp    15cd <main+0x3ed>
jmp    15d2 <main+0x3f2>
jmp    15d7 <main+0x3f7>
jmp    15dc <main+0x3fc>
jmp    15e1 <main+0x401>
jmp    15e6 <main+0x406>
jmp    15eb <main+0x40b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    125f <main+0x7f>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa8d(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1659 <main+0x479>
mov    0x29b4(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xa5b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xa58(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    16c2 <main+0x4e2>
mov    0x2954(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xa26(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
movl   $0x1,-0x4(%rbp)
jmp    1bcc <main+0x9ec>
mov    -0x18(%rbp),%rdi
call   10e0 <fsize@plt>
mov    %rax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
mov    %eax,%edi
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%rbp),%esi
lea    0x9ce(%rip),%r8
lea    0xa79(%rip),%rax
cmp    $0x0,%esi
cmovne %rax,%r8
mov    -0x48(%rbp),%esi
lea    0x9b6(%rip),%r9
lea    0xa6d(%rip),%rax
cmp    $0x0,%esi
cmovne %rax,%r9
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rsi
mov    (%rax,%rsi,8),%rax
lea    0x9c2(%rip),%rsi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpq   $0x0,-0x40(%rbp)
je     1788 <main+0x5a8>
mov    -0x90(%rbp),%rax
and    -0x40(%rbp),%rax
cmp    $0x0,%rax
je     1788 <main+0x5a8>
mov    0x287b(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x90(%rbp),%rcx
lea    0xa0c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1b8e <main+0x9ae>
mov    -0x90(%rbp),%rax
cmp    -0x30(%rbp),%rax
jb     17aa <main+0x5ca>
mov    -0x90(%rbp),%rax
cmp    -0x38(%rbp),%rax
jbe    17dc <main+0x5fc>
mov    0x282f(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x90(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    -0x38(%rbp),%r9
lea    0x9d5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1b89 <main+0x9a9>
movq   $0x0,-0x80(%rbp)
lea    -0x70(%rbp),%rdi
mov    -0x78(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    $0x1,%esi
call   1050 <fread@plt>
mov    %rax,-0x88(%rbp)
cmp    $0x0,%rax
jbe    1a4e <main+0x86e>
cmpq   $0x0,-0x50(%rbp)
jle    1853 <main+0x673>
cmpq   $0x0,-0x80(%rbp)
je     1853 <main+0x673>
mov    -0x80(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x78(%rbp)
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x50(%rbp)
cmp    $0x0,%rdx
jne    1853 <main+0x673>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x87b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x977(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movq   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
cmp    -0x88(%rbp),%rax
jae    18bd <main+0x6dd>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
mov    -0xa0(%rbp),%rax
movzbl -0x70(%rbp,%rax,1),%edx
lea    0x92c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    1872 <main+0x692>
jmp    18c2 <main+0x6e2>
mov    -0xa0(%rbp),%rax
cmp    -0x78(%rbp),%rax
jae    18fe <main+0x71e>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x8f4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    18c2 <main+0x6e2>
cmpl   $0x0,-0x44(%rbp)
je     1a26 <main+0x846>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
mov    -0x80(%rbp),%rdx
lea    0x8c2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movq   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
cmp    -0x88(%rbp),%rax
jae    19d1 <main+0x7f1>
mov    -0x20(%rbp),%rax
mov    %eax,-0xa4(%rbp)
mov    -0xa0(%rbp),%rax
movzbl -0x70(%rbp,%rax,1),%edi
call   10d0 <isprint@plt>
cmp    $0x0,%rax
je     1990 <main+0x7b0>
mov    -0xa0(%rbp),%rax
movzbl -0x70(%rbp,%rax,1),%eax
cmp    $0x2f,%eax
je     1990 <main+0x7b0>
mov    -0xa0(%rbp),%rax
movzbl -0x70(%rbp,%rax,1),%eax
mov    %eax,-0xa8(%rbp)
jmp    19a0 <main+0x7c0>
mov    $0x2e,%eax
mov    %eax,-0xa8(%rbp)
jmp    19a0 <main+0x7c0>
mov    -0xa4(%rbp),%edi
mov    -0xa8(%rbp),%edx
lea    0x836(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    192b <main+0x74b>
jmp    19d6 <main+0x7f6>
mov    -0xa0(%rbp),%rax
cmp    -0x78(%rbp),%rax
jae    1a12 <main+0x832>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x7e5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0xa0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    19d6 <main+0x7f6>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x7cd(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
lea    0x694(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x88(%rbp),%rax
add    -0x80(%rbp),%rax
mov    %rax,-0x80(%rbp)
jmp    17e4 <main+0x604>
mov    -0x18(%rbp),%rdi
call   1040 <ferror@plt>
cmp    $0x0,%rax
je     1a96 <main+0x8b6>
mov    -0x18(%rbp),%rdi
call   1090 <feof@plt>
cmp    $0x0,%eax
jne    1a96 <main+0x8b6>
mov    0x2566(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0x766(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1b84 <main+0x9a4>
mov    -0x80(%rbp),%rax
cmp    -0x90(%rbp),%rax
je     1ad5 <main+0x8f5>
mov    0x2532(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
mov    -0x80(%rbp),%rcx
mov    -0x90(%rbp),%r8
lea    0x737(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1b7f <main+0x99f>
mov    -0x20(%rbp),%rax
mov    %eax,%edi
mov    -0x48(%rbp),%ecx
lea    0x5e3(%rip),%rdx
lea    0x68e(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rdx
mov    -0x48(%rbp),%esi
lea    0x5cb(%rip),%rcx
lea    0x682(%rip),%rax
cmp    $0x0,%esi
cmovne %rax,%rcx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rsi
mov    (%rax,%rsi,8),%r8
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rsi
mov    (%rax,%rsi,8),%r9
lea    0x6f8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x20(%rbp),%rdi
call   10b0 <fflush@plt>
mov    -0x20(%rbp),%rdi
call   1040 <ferror@plt>
cmp    $0x0,%rax
je     1b70 <main+0x990>
mov    0x248c(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0x701(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1b7a <main+0x99a>
movl   $0x0,-0x94(%rbp)
jmp    1b7f <main+0x99f>
jmp    1b84 <main+0x9a4>
jmp    1b89 <main+0x9a9>
jmp    1b8e <main+0x9ae>
mov    -0x20(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x18(%rbp),%rdi
call   1060 <fclose@plt>
cmpl   $0x0,-0x94(%rbp)
je     1bc3 <main+0x9e3>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <remove@plt>
mov    -0x94(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,%r13
cmp    $0x2,%edi
jge    1213 <main+0x33>
mov    0x0(%r13),%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    10c0 <usage@plt>
mov    %edi,%ebx
mov    $0xffffffff,%eax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
movq   $0xffffffffffffffff,0x30(%rsp)
ff ff
mov    $0x10,%eax
mov    %rax,0x10(%rsp)
mov    $0x1,%r15d
lea    0xdba(%rip),%r14
movl   $0x0,0x1c(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
xor    %r12d,%r12d
jmp    127d <main+0x9d>
movl   $0x1,0x1c(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    1438 <main+0x258>
movslq %r15d,%rax
mov    0x0(%r13,%rax,8),%rbp
mov    %rbp,%rdi
mov    %r14,%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1360 <main+0x180>
mov    %rbp,%rdi
lea    0xd63(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     1390 <main+0x1b0>
mov    %rbp,%rdi
lea    0xd51(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     13bd <main+0x1dd>
mov    %rbp,%rdi
lea    0xd40(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     125a <main+0x7a>
mov    %rbp,%rdi
lea    0xd34(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     13e7 <main+0x207>
mov    %rbp,%rdi
lea    0xd25(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
je     13f6 <main+0x216>
mov    %rbp,%rdi
lea    0xd33(%rip),%rsi
call   1070 <strcmp@plt>
test   %eax,%eax
jne    142c <main+0x24c>
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    11f9 <main+0x19>
movslq %r15d,%rbp
mov    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   10a0 <strtol@plt>
test   %rax,%rax
mov    %rax,0x30(%rsp)
jg     1270 <main+0x90>
cmp    $0xffffffffffffffff,%rax
je     1270 <main+0x90>
jmp    17f0 <main+0x610>
nopl   0x0(%rax)
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    11f9 <main+0x19>
movslq %r15d,%rax
mov    0x0(%r13,%rax,8),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
shl    $0xa,%eax
movslq %eax,%r12
jmp    1270 <main+0x90>
nopl   0x0(%rax)
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    11f9 <main+0x19>
movslq %r15d,%rax
mov    0x0(%r13,%rax,8),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
shl    $0xa,%eax
cltq
mov    %rax,0x8(%rsp)
jmp    1270 <main+0x90>
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    11f9 <main+0x19>
movslq %r15d,%rax
mov    0x0(%r13,%rax,8),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
cltq
mov    %rax,0x38(%rsp)
jmp    1270 <main+0x90>
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
jmp    1270 <main+0x90>
add    $0x1,%r15d
cmp    %ebx,%r15d
jge    11f9 <main+0x19>
movslq %r15d,%rbp
mov    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1100 <strtoul@plt>
lea    -0x21(%rax),%ecx
cmp    $0xffffffdf,%ecx
jbe    18ce <main+0x6ee>
cltq
mov    %rax,0x10(%rsp)
jmp    1270 <main+0x90>
add    $0xfffffffd,%ebx
cmp    %ebx,%r15d
jne    18fb <main+0x71b>
movslq %r15d,%rbx
lea    0x1(%rbx),%r14
mov    0x8(%r13,%rbx,8),%rdi
lea    0xc53(%rip),%rsi
call   10f0 <fopen@plt>
test   %rax,%rax
je     1523 <main+0x343>
mov    %rax,%rbp
mov    %r14,0x40(%rsp)
lea    0x2(%rbx),%r14
mov    0x10(%r13,%rbx,8),%rdi
lea    0xc58(%rip),%rsi
call   10f0 <fopen@plt>
test   %rax,%rax
je     1549 <main+0x369>
mov    %rax,%r15
mov    %r14,0x50(%rsp)
mov    %rbp,0x20(%rsp)
mov    %rbp,%rdi
call   10e0 <fsize@plt>
mov    %rax,%r14
mov    0x40(%rsp),%rax
mov    0x0(%r13,%rax,8),%rdx
mov    0x0(%r13),%rcx
cmpl   $0x0,0x28(%rsp)
lea    0xc17(%rip),%rax
lea    0xcc2(%rip),%rbp
cmove  %rax,%rbp
lea    0xcc3(%rip),%r9
cmove  %rax,%r9
mov    %rbx,0x28(%rsp)
mov    0x0(%r13,%rbx,8),%rax
mov    %rax,(%rsp)
lea    0xc19(%rip),%rsi
mov    %r15d,%edi
mov    %rbp,%r8
mov    %r9,0x40(%rsp)
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    %r14,%rcx
mov    0x38(%rsp),%rax
test   %rax,%rax
je     1577 <main+0x397>
and    %rcx,%rax
je     1577 <main+0x397>
mov    0x2ad9(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0xc74(%rip),%rsi
xor    %r14d,%r14d
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    193c <main+0x75c>
mov    0x2ab6(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13,%r14,8),%rdx
lea    0xb69(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%ebp
jmp    1967 <main+0x787>
mov    0x2a90(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13,%r14,8),%rdx
lea    0xb6e(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    %rbp,%rdi
call   1060 <fclose@plt>
mov    $0x1,%ebp
jmp    1967 <main+0x787>
cmp    %r12,%rcx
mov    0x8(%rsp),%r9
jb     17ca <main+0x5ea>
cmp    %r9,%rcx
ja     17ca <main+0x5ea>
mov    %rbp,0x48(%rsp)
mov    %rcx,0x38(%rsp)
lea    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    0x10(%rsp),%rbx
mov    %rbx,%rdx
mov    0x20(%rsp),%rcx
call   1050 <fread@plt>
test   %rax,%rax
je     181a <main+0x63a>
mov    %rax,%rbp
lea    0xc04(%rip),%r14
mov    $0x2e,%r12d
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x30(%rsp),%rsi
mov    %r13,0x58(%rsp)
mov    %rsi,0x30(%rsp)
jmp    1650 <main+0x470>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15d,%edi
lea    0xbf2(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    0x58(%rsp),%r13
mov    %r15d,%edi
lea    0xab7(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
add    %rbp,0x8(%rsp)
lea    0x60(%rsp),%rdi
mov    $0x1,%esi
mov    0x10(%rsp),%rbx
mov    %rbx,%rdx
mov    0x20(%rsp),%rcx
call   1050 <fread@plt>
mov    %rax,%rbp
test   %rax,%rax
lea    0xb86(%rip),%r14
mov    0x30(%rsp),%rsi
je     1821 <main+0x641>
test   %rsi,%rsi
mov    0x8(%rsp),%rax
jle    16b0 <main+0x4d0>
test   %rax,%rax
je     16b0 <main+0x4d0>
mov    %rax,%rcx
or     %rbx,%rcx
shr    $0x20,%rcx
je     1672 <main+0x492>
xor    %edx,%edx
div    %rbx
jmp    1676 <main+0x496>
xor    %edx,%edx
div    %ebx
mov    %rax,%rcx
or     %rsi,%rcx
shr    $0x20,%rcx
je     17b8 <main+0x5d8>
xor    %edx,%edx
div    %rsi
test   %rdx,%rdx
jne    16b0 <main+0x4d0>
mov    %r15d,%edi
lea    0xa2d(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
lea    0xb23(%rip),%r14
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edi
lea    0xb1d(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x60(%rsp,%rbx,1),%edx
mov    %r15d,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    16d0 <main+0x4f0>
cmp    0x10(%rsp),%rbp
lea    0xadd(%rip),%r14
jae    1723 <main+0x543>
mov    0x10(%rsp),%rbx
sub    %rbp,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
add    $0xffffffffffffffff,%rbx
jne    1710 <main+0x530>
cmpl   $0x0,0x1c(%rsp)
je     1606 <main+0x426>
mov    %r15d,%edi
lea    0xaa3(%rip),%rsi
mov    0x8(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
xor    %r13d,%r13d
lea    0xa9b(%rip),%rbx
xchg   %ax,%ax
movzbl 0x60(%rsp,%r13,1),%r14d
mov    %r14d,%edi
call   10d0 <isprint@plt>
cmp    $0x2f,%r14d
cmove  %r12d,%r14d
test   %rax,%rax
cmove  %r12d,%r14d
mov    %r15d,%edi
mov    %rbx,%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1080 <fprintf@plt>
add    $0x1,%r13
cmp    %r13,%rbp
jne    1750 <main+0x570>
cmp    0x10(%rsp),%rbp
lea    0xa47(%rip),%r14
jae    15f0 <main+0x410>
mov    0x10(%rsp),%rbx
sub    %rbp,%rbx
mov    %r15d,%edi
mov    %r14,%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
add    $0xffffffffffffffff,%rbx
jne    17a0 <main+0x5c0>
jmp    15f0 <main+0x410>
xor    %edx,%edx
div    %esi
test   %rdx,%rdx
jne    16b0 <main+0x4d0>
jmp    1690 <main+0x4b0>
mov    0x280f(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0x9c7(%rip),%rsi
xor    %r14d,%r14d
mov    %r12,%r8
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    193c <main+0x75c>
mov    0x27e9(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
mov    0x0(%r13,%rbp,8),%rcx
lea    0x842(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%ebp
jmp    1967 <main+0x787>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <ferror@plt>
test   %rax,%rax
je     1843 <main+0x663>
mov    %rbx,%rdi
call   1090 <feof@plt>
test   %eax,%eax
je     191e <main+0x73e>
mov    0x38(%rsp),%r8
mov    0x8(%rsp),%rcx
cmp    %r8,%rcx
jne    18ae <main+0x6ce>
mov    0x28(%rsp),%rax
mov    0x0(%r13,%rax,8),%r8
lea    0x9bf(%rip),%rsi
xor    %ebp,%ebp
mov    %r15d,%edi
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%rcx
mov    %r8,%r9
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    %r15,%rdi
call   10b0 <fflush@plt>
mov    %r15,%rdi
call   1040 <ferror@plt>
test   %rax,%rax
je     197b <main+0x79b>
mov    0x2744(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0x9bc(%rip),%rsi
jmp    1932 <main+0x752>
mov    0x272b(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0x93e(%rip),%rsi
xor    %r14d,%r14d
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    193c <main+0x75c>
mov    0x270b(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
mov    0x0(%r13,%rbp,8),%rcx
lea    0x73f(%rip),%rsi
mov    $0x20,%r8d
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%ebp
jmp    1967 <main+0x787>
mov    0x26de(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0x766(%rip),%rsi
mov    %rbp,%rcx
xor    %eax,%eax
call   1080 <fprintf@plt>
jmp    11f9 <main+0x19>
mov    0x26bb(%rip),%rax
mov    (%rax),%edi
mov    0x0(%r13),%rdx
lea    0x8be(%rip),%rsi
xor    %r14d,%r14d
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0x1,%ebp
mov    %r15,%rdi
call   1060 <fclose@plt>
mov    0x20(%rsp),%rdi
call   1060 <fclose@plt>
test   %r14b,%r14b
jne    1967 <main+0x787>
mov    0x50(%rsp),%rax
mov    0x0(%r13,%rax,8),%rdi
call   1030 <remove@plt>
mov    %ebp,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%r14b
jmp    1941 <main+0x761>

LLVM IR (-O0):
@.str = [5 x i8] c"-min\00"
@.str.1 = [5 x i8] c"-max\00"
@.str.2 = [6 x i8] c"-mask\00"
@.str.3 = [7 x i8] c"-ascii\00"
@.str.4 = [8 x i8] c"-export\00"
@.str.5 = [7 x i8] c"-width\00"
@stderr = global i32 0
@.str.6 = [30 x i8] c"%s: '%s' is too wide, max %u\0A\00"
@.str.7 = [7 x i8] c"-break\00"
@.str.8 = [42 x i8] c"%s: -break value '%s' is not >= 1 or -1.\0A\00"
@.str.9 = [41 x i8] c"%s: syntax error: Unknown argument '%s'\0A\00"
@.str.10 = [3 x i8] c"rb\00"
@.str.11 = [40 x i8] c"Error: failed to open input file '%s'!\0A\00"
@.str.12 = [3 x i8] c"wb\00"
@.str.13 = [41 x i8] c"Error: failed to open output file '%s'!\0A\00"
@.str.14 = [133 x i8] c"/*\0A * This file was automatically generated\0A * from %s\0A * by %s.\0A */\0A\0A#include <iprt/cdefs.h>\0A\0A%sconst unsigned char%s g_ab%s[] =\0A{\0A\00"
@.str.15 = [12 x i8] c"DECLEXPORT(\00"
@.str.16 = [1 x i8] zeroinitializer
@.str.17 = [2 x i8] c")\00"
@.str.18 = [29 x i8] c"%s: size=%ld - Not aligned!\0A\00"
@.str.19 = [38 x i8] c"%s: size=%ld - Not %ld-%ldb in size!\0A\00"
@.str.20 = [2 x i8] c"\0A\00"
@.str.21 = [4 x i8] c" \00"
@.str.22 = [9 x i8] c" 0x%02x,\00"
@.str.23 = [7 x i8] c" \00"
@.str.24 = [14 x i8] c" /* 0x%08lx: \00"
@.str.25 = [3 x i8] c"%c\00"
@.str.26 = [2 x i8] c" \00"
@.str.27 = [4 x i8] c" */\00"
@.str.28 = [16 x i8] c"%s: read error\0A\00"
@.str.29 = [34 x i8] c"%s: read error off=%ld cbBin=%ld\0A\00"
@.str.30 = [67 x i8] c"};\0A\0A%sconst unsigned%s g_cb%s = sizeof(g_ab%s);\0A/* end of file */\0A\00"
@.str.31 = [17 x i8] c"%s: write error\0A\00"
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 i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i64
%15 = alloca [32 x i8]
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i32
%21 = alloca i64
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i64 0, i64* %9
store i64 4294967295, i64* %10
store i64 0, i64* %11
store i32 0, i32* %12
store i32 0, i32* %13
store i64 -1, i64* %14
store i64 16, i64* %16
store i32 1, i32* %20
%22 = load i32, i32* %4
%23 = icmp slt i32 %22, 2
br i1 %23, label %24, label %29
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 0
%27 = load i8*, i8** %26
%28 = call i32 @usage(i8* %27)
store i32 %28, i32* %3
br label %544
29: ; preds = %2
store i32 1, i32* %8
br label %30
30: ; preds = %245, %29
%31 = load i32, i32* %8
%32 = load i32, i32* %4
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %248
34: ; preds = %30
%35 = load i8**, i8*** %5
%36 = load i32, i32* %8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8*, i8** %35, i64 %37
%39 = load i8*, i8** %38
%40 = call i32 @strcmp(i8* %39, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%41 = icmp ne i32 %40, 0
br i1 %41, label %61, label %42
42: ; preds = %34
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
%45 = load i32, i32* %4
%46 = icmp sge i32 %44, %45
br i1 %46, label %47, label %52
47: ; preds = %42
%48 = load i8**, i8*** %5
%49 = getelementptr inbounds i8*, i8** %48, i64 0
%50 = load i8*, i8** %49
%51 = call i32 @usage(i8* %50)
store i32 %51, i32* %3
br label %544
52: ; preds = %42
%53 = load i8**, i8*** %5
%54 = load i32, i32* %8
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8*, i8** %53, i64 %55
%57 = load i8*, i8** %56
%58 = call i32 @strtoul(i8* %57, i32* null, i32 0)
%59 = mul nsw i32 1024, %58
%60 = sext i32 %59 to i64
store i64 %60, i64* %9
br label %244
61: ; preds = %34
%62 = load i8**, i8*** %5
%63 = load i32, i32* %8
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8*, i8** %62, i64 %64
%66 = load i8*, i8** %65
%67 = call i32 @strcmp(i8* %66, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%68 = icmp ne i32 %67, 0
br i1 %68, label %88, label %69
69: ; preds = %61
%70 = load i32, i32* %8
%71 = add nsw i32 %70, 1
store i32 %71, i32* %8
%72 = load i32, i32* %4
%73 = icmp sge i32 %71, %72
br i1 %73, label %74, label %79
74: ; preds = %69
%75 = load i8**, i8*** %5
%76 = getelementptr inbounds i8*, i8** %75, i64 0
%77 = load i8*, i8** %76
%78 = call i32 @usage(i8* %77)
store i32 %78, i32* %3
br label %544
79: ; preds = %69
%80 = load i8**, i8*** %5
%81 = load i32, i32* %8
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8*, i8** %80, i64 %82
%84 = load i8*, i8** %83
%85 = call i32 @strtoul(i8* %84, i32* null, i32 0)
%86 = mul nsw i32 1024, %85
%87 = sext i32 %86 to i64
store i64 %87, i64* %10
br label %243
88: ; preds = %61
%89 = load i8**, i8*** %5
%90 = load i32, i32* %8
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8*, i8** %89, i64 %91
%93 = load i8*, i8** %92
%94 = call i32 @strcmp(i8* %93, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
%95 = icmp ne i32 %94, 0
br i1 %95, label %114, label %96
96: ; preds = %88
%97 = load i32, i32* %8
%98 = add nsw i32 %97, 1
store i32 %98, i32* %8
%99 = load i32, i32* %4
%100 = icmp sge i32 %98, %99
br i1 %100, label %101, label %106
101: ; preds = %96
%102 = load i8**, i8*** %5
%103 = getelementptr inbounds i8*, i8** %102, i64 0
%104 = load i8*, i8** %103
%105 = call i32 @usage(i8* %104)
store i32 %105, i32* %3
br label %544
106: ; preds = %96
%107 = load i8**, i8*** %5
%108 = load i32, i32* %8
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i8*, i8** %107, i64 %109
%111 = load i8*, i8** %110
%112 = call i32 @strtoul(i8* %111, i32* null, i32 0)
%113 = sext i32 %112 to i64
store i64 %113, i64* %11
br label %242
114: ; preds = %88
%115 = load i8**, i8*** %5
%116 = load i32, i32* %8
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8*, i8** %115, i64 %117
%119 = load i8*, i8** %118
%120 = call i32 @strcmp(i8* %119, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0))
%121 = icmp ne i32 %120, 0
br i1 %121, label %123, label %122
122: ; preds = %114
store i32 1, i32* %12
br label %241
123: ; preds = %114
%124 = load i8**, i8*** %5
%125 = load i32, i32* %8
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i8*, i8** %124, i64 %126
%128 = load i8*, i8** %127
%129 = call i32 @strcmp(i8* %128, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%130 = icmp ne i32 %129, 0
br i1 %130, label %132, label %131
131: ; preds = %123
store i32 1, i32* %13
br label %240
132: ; preds = %123
%133 = load i8**, i8*** %5
%134 = load i32, i32* %8
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i8*, i8** %133, i64 %135
%137 = load i8*, i8** %136
%138 = call i32 @strcmp(i8* %137, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%139 = icmp ne i32 %138, 0
br i1 %139, label %175, label %140
140: ; preds = %132
%141 = load i32, i32* %8
%142 = add nsw i32 %141, 1
store i32 %142, i32* %8
%143 = load i32, i32* %4
%144 = icmp sge i32 %142, %143
br i1 %144, label %145, label %150
145: ; preds = %140
%146 = load i8**, i8*** %5
%147 = getelementptr inbounds i8*, i8** %146, i64 0
%148 = load i8*, i8** %147
%149 = call i32 @usage(i8* %148)
store i32 %149, i32* %3
br label %544
150: ; preds = %140
%151 = load i8**, i8*** %5
%152 = load i32, i32* %8
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8*, i8** %151, i64 %153
%155 = load i8*, i8** %154
%156 = call i32 @strtoul(i8* %155, i32* null, i32 0)
%157 = sext i32 %156 to i64
store i64 %157, i64* %16
%158 = load i64, i64* %16
%159 = icmp eq i64 %158, 0
br i1 %159, label %163, label %160
160: ; preds = %150
%161 = load i64, i64* %16
%162 = icmp ugt i64 %161, 32
br i1 %162, label %163, label %174
163: ; preds = %160, %150
%164 = load i32, i32* @stderr
%165 = load i8**, i8*** %5
%166 = getelementptr inbounds i8*, i8** %165, i64 0
%167 = load i8*, i8** %166
%168 = load i8**, i8*** %5
%169 = load i32, i32* %8
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8*, i8** %168, i64 %170
%172 = load i8*, i8** %171
%173 = call i32 (i32, i8*, ...) @fprintf(i32 %164, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0), i8* %167, i8* %172, i32 32)
store i32 1, i32* %3
br label %544
174: ; preds = %160
br label %239
175: ; preds = %132
%176 = load i8**, i8*** %5
%177 = load i32, i32* %8
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds i8*, i8** %176, i64 %178
%180 = load i8*, i8** %179
%181 = call i32 @strcmp(i8* %180, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%182 = icmp ne i32 %181, 0
br i1 %182, label %217, label %183
183: ; preds = %175
%184 = load i32, i32* %8
%185 = add nsw i32 %184, 1
store i32 %185, i32* %8
%186 = load i32, i32* %4
%187 = icmp sge i32 %185, %186
br i1 %187, label %188, label %193
188: ; preds = %183
%189 = load i8**, i8*** %5
%190 = getelementptr inbounds i8*, i8** %189, i64 0
%191 = load i8*, i8** %190
%192 = call i32 @usage(i8* %191)
store i32 %192, i32* %3
br label %544
193: ; preds = %183
%194 = load i8**, i8*** %5
%195 = load i32, i32* %8
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i8*, i8** %194, i64 %196
%198 = load i8*, i8** %197
%199 = call i64 @strtol(i8* %198, i32* null, i32 0)
store i64 %199, i64* %14
%200 = load i64, i64* %14
%201 = icmp sle i64 %200, 0
br i1 %201, label %202, label %216
202: ; preds = %193
%203 = load i64, i64* %14
%204 = icmp ne i64 %203, -1
br i1 %204, label %205, label %216
205: ; preds = %202
%206 = load i32, i32* @stderr
%207 = load i8**, i8*** %5
%208 = getelementptr inbounds i8*, i8** %207, i64 0
%209 = load i8*, i8** %208
%210 = load i8**, i8*** %5
%211 = load i32, i32* %8
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8*, i8** %210, i64 %212
%214 = load i8*, i8** %213
%215 = call i32 (i32, i8*, ...) @fprintf(i32 %206, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0), i8* %209, i8* %214)
store i32 1, i32* %3
br label %544
216: ; preds = %202, %193
br label %238
217: ; preds = %175
%218 = load i32, i32* %8
%219 = load i32, i32* %4
%220 = sub nsw i32 %219, 3
%221 = icmp eq i32 %218, %220
br i1 %221, label %222, label %223
222: ; preds = %217
br label %248
223: ; preds = %217
%224 = load i32, i32* @stderr
%225 = load i8**, i8*** %5
%226 = getelementptr inbounds i8*, i8** %225, i64 0
%227 = load i8*, i8** %226
%228 = load i8**, i8*** %5
%229 = load i32, i32* %8
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i8*, i8** %228, i64 %230
%232 = load i8*, i8** %231
%233 = call i32 (i32, i8*, ...) @fprintf(i32 %224, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0), i8* %227, i8* %232)
%234 = load i8**, i8*** %5
%235 = getelementptr inbounds i8*, i8** %234, i64 0
%236 = load i8*, i8** %235
%237 = call i32 @usage(i8* %236)
store i32 %237, i32* %3
br label %544
238: ; preds = %216
br label %239
239: ; preds = %238, %174
br label %240
240: ; preds = %239, %131
br label %241
241: ; preds = %240, %122
br label %242
242: ; preds = %241, %106
br label %243
243: ; preds = %242, %79
br label %244
244: ; preds = %243, %52
br label %245
245: ; preds = %244
%246 = load i32, i32* %8
%247 = add nsw i32 %246, 1
store i32 %247, i32* %8
br label %30
248: ; preds = %222, %30
%249 = load i8**, i8*** %5
%250 = load i32, i32* %8
%251 = add nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8*, i8** %249, i64 %252
%254 = load i8*, i8** %253
%255 = call i32* @fopen(i8* %254, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
store i32* %255, i32** %6
%256 = load i32*, i32** %6
%257 = icmp ne i32* %256, null
br i1 %257, label %267, label %258
258: ; preds = %248
%259 = load i32, i32* @stderr
%260 = load i8**, i8*** %5
%261 = load i32, i32* %8
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8*, i8** %260, i64 %263
%265 = load i8*, i8** %264
%266 = call i32 (i32, i8*, ...) @fprintf(i32 %259, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.11, i64 0, i64 0), i8* %265)
store i32 1, i32* %3
br label %544
267: ; preds = %248
%268 = load i8**, i8*** %5
%269 = load i32, i32* %8
%270 = add nsw i32 %269, 2
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8*, i8** %268, i64 %271
%273 = load i8*, i8** %272
%274 = call i32* @fopen(i8* %273, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
store i32* %274, i32** %7
%275 = load i32*, i32** %7
%276 = icmp ne i32* %275, null
br i1 %276, label %288, label %277
277: ; preds = %267
%278 = load i32, i32* @stderr
%279 = load i8**, i8*** %5
%280 = load i32, i32* %8
%281 = add nsw i32 %280, 2
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8*, i8** %279, i64 %282
%284 = load i8*, i8** %283
%285 = call i32 (i32, i8*, ...) @fprintf(i32 %278, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.13, i64 0, i64 0), i8* %284)
%286 = load i32*, i32** %6
%287 = call i32 @fclose(i32* %286)
store i32 1, i32* %3
br label %544
288: ; preds = %267
%289 = load i32*, i32** %6
%290 = call i64 @fsize(i32* %289)
store i64 %290, i64* %19
%291 = load i32*, i32** %7
%292 = ptrtoint i32* %291 to i32
%293 = load i8**, i8*** %5
%294 = load i32, i32* %8
%295 = add nsw i32 %294, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds i8*, i8** %293, i64 %296
%298 = load i8*, i8** %297
%299 = load i8**, i8*** %5
%300 = getelementptr inbounds i8*, i8** %299, i64 0
%301 = load i8*, i8** %300
%302 = load i32, i32* %13
%303 = icmp ne i32 %302, 0
%304 = zext i1 %303 to i64
%305 = select i1 %303, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0)
%306 = load i32, i32* %13
%307 = icmp ne i32 %306, 0
%308 = zext i1 %307 to i64
%309 = select i1 %307, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0)
%310 = load i8**, i8*** %5
%311 = load i32, i32* %8
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds i8*, i8** %310, i64 %312
%314 = load i8*, i8** %313
%315 = call i32 (i32, i8*, ...) @fprintf(i32 %292, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.14, i64 0, i64 0), i8* %298, i8* %301, i8* %305, i8* %309, i8* %314)
%316 = load i64, i64* %11
%317 = icmp ne i64 %316, 0
br i1 %317, label %318, label %330
318: ; preds = %288
%319 = load i64, i64* %19
%320 = load i64, i64* %11
%321 = and i64 %319, %320
%322 = icmp ne i64 %321, 0
br i1 %322, label %323, label %330
323: ; preds = %318
%324 = load i32, i32* @stderr
%325 = load i8**, i8*** %5
%326 = getelementptr inbounds i8*, i8** %325, i64 0
%327 = load i8*, i8** %326
%328 = load i64, i64* %19
%329 = call i32 (i32, i8*, ...) @fprintf(i32 %324, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i8* %327, i64 %328)
br label %527
330: ; preds = %318, %288
%331 = load i64, i64* %19
%332 = load i64, i64* %9
%333 = icmp ult i64 %331, %332
br i1 %333, label %338, label %334
334: ; preds = %330
%335 = load i64, i64* %19
%336 = load i64, i64* %10
%337 = icmp ugt i64 %335, %336
br i1 %337, label %338, label %347
338: ; preds = %334, %330
%339 = load i32, i32* @stderr
%340 = load i8**, i8*** %5
%341 = getelementptr inbounds i8*, i8** %340, i64 0
%342 = load i8*, i8** %341
%343 = load i64, i64* %19
%344 = load i64, i64* %9
%345 = load i64, i64* %10
%346 = call i32 (i32, i8*, ...) @fprintf(i32 %339, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.19, i64 0, i64 0), i8* %342, i64 %343, i64 %344, i64 %345)
br label %526
347: ; preds = %334
store i64 0, i64* %17
br label %348
348: ; preds = %456, %347
%349 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 0
%350 = load i64, i64* %16
%351 = load i32*, i32** %6
%352 = call i64 @fread(i8* %349, i32 1, i64 %350, i32* %351)
store i64 %352, i64* %18
%353 = icmp ugt i64 %352, 0
br i1 %353, label %354, label %463
354: ; preds = %348
%355 = load i64, i64* %14
%356 = icmp sgt i64 %355, 0
br i1 %356, label %357, label %371
357: ; preds = %354
%358 = load i64, i64* %17
%359 = icmp ne i64 %358, 0
br i1 %359, label %360, label %371
360: ; preds = %357
%361 = load i64, i64* %17
%362 = load i64, i64* %16
%363 = udiv i64 %361, %362
%364 = load i64, i64* %14
%365 = urem i64 %363, %364
%366 = icmp eq i64 %365, 0
br i1 %366, label %367, label %371
367: ; preds = %360
%368 = load i32*, i32** %7
%369 = ptrtoint i32* %368 to i32
%370 = call i32 (i32, i8*, ...) @fprintf(i32 %369, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %371
371: ; preds = %367, %360, %357, %354
%372 = load i32*, i32** %7
%373 = ptrtoint i32* %372 to i32
%374 = call i32 (i32, i8*, ...) @fprintf(i32 %373, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0))
store i64 0, i64* %21
br label %375
375: ; preds = %387, %371
%376 = load i64, i64* %21
%377 = load i64, i64* %18
%378 = icmp ult i64 %376, %377
br i1 %378, label %379, label %390
379: ; preds = %375
%380 = load i32*, i32** %7
%381 = ptrtoint i32* %380 to i32
%382 = load i64, i64* %21
%383 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 %382
%384 = load i8, i8* %383
%385 = zext i8 %384 to i32
%386 = call i32 (i32, i8*, ...) @fprintf(i32 %381, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i64 0, i64 0), i32 %385)
br label %387
387: ; preds = %379
%388 = load i64, i64* %21
%389 = add i64 %388, 1
store i64 %389, i64* %21
br label %375
390: ; preds = %375
br label %391
391: ; preds = %399, %390
%392 = load i64, i64* %21
%393 = load i64, i64* %16
%394 = icmp ult i64 %392, %393
br i1 %394, label %395, label %402
395: ; preds = %391
%396 = load i32*, i32** %7
%397 = ptrtoint i32* %396 to i32
%398 = call i32 (i32, i8*, ...) @fprintf(i32 %397, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0))
br label %399
399: ; preds = %395
%400 = load i64, i64* %21
%401 = add i64 %400, 1
store i64 %401, i64* %21
br label %391
402: ; preds = %391
%403 = load i32, i32* %12
%404 = icmp ne i32 %403, 0
br i1 %404, label %405, label %456
405: ; preds = %402
%406 = load i32*, i32** %7
%407 = ptrtoint i32* %406 to i32
%408 = load i64, i64* %17
%409 = call i32 (i32, i8*, ...) @fprintf(i32 %407, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.24, i64 0, i64 0), i64 %408)
store i64 0, i64* %21
br label %410
410: ; preds = %437, %405
%411 = load i64, i64* %21
%412 = load i64, i64* %18
%413 = icmp ult i64 %411, %412
br i1 %413, label %414, label %440
414: ; preds = %410
%415 = load i32*, i32** %7
%416 = ptrtoint i32* %415 to i32
%417 = load i64, i64* %21
%418 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 %417
%419 = load i8, i8* %418
%420 = call i64 @isprint(i8 zeroext %419)
%421 = icmp ne i64 %420, 0
br i1 %421, label %422, label %433
422: ; preds = %414
%423 = load i64, i64* %21
%424 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 %423
%425 = load i8, i8* %424
%426 = zext i8 %425 to i32
%427 = icmp ne i32 %426, 47
br i1 %427, label %428, label %433
428: ; preds = %422
%429 = load i64, i64* %21
%430 = getelementptr inbounds [32 x i8], [32 x i8]* %15, i64 0, i64 %429
%431 = load i8, i8* %430
%432 = zext i8 %431 to i32
br label %434
433: ; preds = %422, %414
br label %434
434: ; preds = %433, %428
%435 = phi i32 [ %432, %428 ], [ 46, %433 ]
%436 = call i32 (i32, i8*, ...) @fprintf(i32 %416, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32 %435)
br label %437
437: ; preds = %434
%438 = load i64, i64* %21
%439 = add i64 %438, 1
store i64 %439, i64* %21
br label %410
440: ; preds = %410
br label %441
441: ; preds = %449, %440
%442 = load i64, i64* %21
%443 = load i64, i64* %16
%444 = icmp ult i64 %442, %443
br i1 %444, label %445, label %452
445: ; preds = %441
%446 = load i32*, i32** %7
%447 = ptrtoint i32* %446 to i32
%448 = call i32 (i32, i8*, ...) @fprintf(i32 %447, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0))
br label %449
449: ; preds = %445
%450 = load i64, i64* %21
%451 = add i64 %450, 1
store i64 %451, i64* %21
br label %441
452: ; preds = %441
%453 = load i32*, i32** %7
%454 = ptrtoint i32* %453 to i32
%455 = call i32 (i32, i8*, ...) @fprintf(i32 %454, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.27, i64 0, i64 0))
br label %456
456: ; preds = %452, %402
%457 = load i32*, i32** %7
%458 = ptrtoint i32* %457 to i32
%459 = call i32 (i32, i8*, ...) @fprintf(i32 %458, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
%460 = load i64, i64* %18
%461 = load i64, i64* %17
%462 = add i64 %461, %460
store i64 %462, i64* %17
br label %348
463: ; preds = %348
%464 = load i32*, i32** %6
%465 = call i64 @ferror(i32* %464)
%466 = icmp ne i64 %465, 0
br i1 %466, label %467, label %477
467: ; preds = %463
%468 = load i32*, i32** %6
%469 = call i32 @feof(i32* %468)
%470 = icmp ne i32 %469, 0
br i1 %470, label %477, label %471
471: ; preds = %467
%472 = load i32, i32* @stderr
%473 = load i8**, i8*** %5
%474 = getelementptr inbounds i8*, i8** %473, i64 0
%475 = load i8*, i8** %474
%476 = call i32 (i32, i8*, ...) @fprintf(i32 %472, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i8* %475)
br label %525
477: ; preds = %467, %463
%478 = load i64, i64* %17
%479 = load i64, i64* %19
%480 = icmp ne i64 %478, %479
br i1 %480, label %481, label %489
481: ; preds = %477
%482 = load i32, i32* @stderr
%483 = load i8**, i8*** %5
%484 = getelementptr inbounds i8*, i8** %483, i64 0
%485 = load i8*, i8** %484
%486 = load i64, i64* %17
%487 = load i64, i64* %19
%488 = call i32 (i32, i8*, ...) @fprintf(i32 %482, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.29, i64 0, i64 0), i8* %485, i64 %486, i64 %487)
br label %524
489: ; preds = %477
%490 = load i32*, i32** %7
%491 = ptrtoint i32* %490 to i32
%492 = load i32, i32* %13
%493 = icmp ne i32 %492, 0
%494 = zext i1 %493 to i64
%495 = select i1 %493, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0)
%496 = load i32, i32* %13
%497 = icmp ne i32 %496, 0
%498 = zext i1 %497 to i64
%499 = select i1 %497, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0)
%500 = load i8**, i8*** %5
%501 = load i32, i32* %8
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds i8*, i8** %500, i64 %502
%504 = load i8*, i8** %503
%505 = load i8**, i8*** %5
%506 = load i32, i32* %8
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds i8*, i8** %505, i64 %507
%509 = load i8*, i8** %508
%510 = call i32 (i32, i8*, ...) @fprintf(i32 %491, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.30, i64 0, i64 0), i8* %495, i8* %499, i8* %504, i8* %509)
%511 = load i32*, i32** %7
%512 = call i32 @fflush(i32* %511)
%513 = load i32*, i32** %7
%514 = call i64 @ferror(i32* %513)
%515 = icmp ne i64 %514, 0
br i1 %515, label %516, label %522
516: ; preds = %489
%517 = load i32, i32* @stderr
%518 = load i8**, i8*** %5
%519 = getelementptr inbounds i8*, i8** %518, i64 0
%520 = load i8*, i8** %519
%521 = call i32 (i32, i8*, ...) @fprintf(i32 %517, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i64 0, i64 0), i8* %520)
br label %523
522: ; preds = %489
store i32 0, i32* %20
br label %523
523: ; preds = %522, %516
br label %524
524: ; preds = %523, %481
br label %525
525: ; preds = %524, %471
br label %526
526: ; preds = %525, %338
br label %527
527: ; preds = %526, %323
%528 = load i32*, i32** %7
%529 = call i32 @fclose(i32* %528)
%530 = load i32*, i32** %6
%531 = call i32 @fclose(i32* %530)
%532 = load i32, i32* %20
%533 = icmp ne i32 %532, 0
br i1 %533, label %534, label %542
534: ; preds = %527
%535 = load i8**, i8*** %5
%536 = load i32, i32* %8
%537 = add nsw i32 %536, 2
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i8*, i8** %535, i64 %538
%540 = load i8*, i8** %539
%541 = call i32 @remove(i8* %540)
br label %542
542: ; preds = %534, %527
%543 = load i32, i32* %20
store i32 %543, i32* %3
br label %544
544: ; preds = %542, %277, %258, %223, %205, %188, %163, %145, %101, %74, %47, %24
%545 = load i32, i32* %3
ret i32 %545
}

LLVM IR (-O2):
@.str = [5 x i8] c"-min\00"
@.str.1 = [5 x i8] c"-max\00"
@.str.2 = [6 x i8] c"-mask\00"
@.str.3 = [7 x i8] c"-ascii\00"
@.str.4 = [8 x i8] c"-export\00"
@.str.5 = [7 x i8] c"-width\00"
@stderr = global i32 0
@.str.6 = [30 x i8] c"%s: '%s' is too wide, max %u\0A\00"
@.str.7 = [7 x i8] c"-break\00"
@.str.8 = [42 x i8] c"%s: -break value '%s' is not >= 1 or -1.\0A\00"
@.str.9 = [41 x i8] c"%s: syntax error: Unknown argument '%s'\0A\00"
@.str.10 = [3 x i8] c"rb\00"
@.str.11 = [40 x i8] c"Error: failed to open input file '%s'!\0A\00"
@.str.12 = [3 x i8] c"wb\00"
@.str.13 = [41 x i8] c"Error: failed to open output file '%s'!\0A\00"
@.str.14 = [133 x i8] c"/*\0A * This file was automatically generated\0A * from %s\0A * by %s.\0A */\0A\0A#include <iprt/cdefs.h>\0A\0A%sconst unsigned char%s g_ab%s[] =\0A{\0A\00"
@.str.15 = [12 x i8] c"DECLEXPORT(\00"
@.str.16 = [1 x i8] zeroinitializer
@.str.17 = [2 x i8] c")\00"
@.str.18 = [29 x i8] c"%s: size=%ld - Not aligned!\0A\00"
@.str.19 = [38 x i8] c"%s: size=%ld - Not %ld-%ldb in size!\0A\00"
@.str.20 = [2 x i8] c"\0A\00"
@.str.21 = [4 x i8] c" \00"
@.str.22 = [9 x i8] c" 0x%02x,\00"
@.str.23 = [7 x i8] c" \00"
@.str.24 = [14 x i8] c" /* 0x%08lx: \00"
@.str.25 = [3 x i8] c"%c\00"
@.str.26 = [2 x i8] c" \00"
@.str.27 = [4 x i8] c" */\00"
@.str.28 = [16 x i8] c"%s: read error\0A\00"
@.str.29 = [34 x i8] c"%s: read error off=%ld cbBin=%ld\0A\00"
@.str.30 = [67 x i8] c"};\0A\0A%sconst unsigned%s g_cb%s = sizeof(g_ab%s);\0A/* end of file */\0A\00"
@.str.31 = [17 x i8] c"%s: write error\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca [32 x i8]
%4 = getelementptr inbounds [32 x i8], [32 x i8]* %3, i64 0, i64 0
%5 = icmp slt i32 %0, 2
br i1 %5, label %6, label %9
6: ; preds = %2
%7 = load i8*, i8** %1
%8 = tail call i32 @usage(i8* %7)
br label %297
9: ; preds = %2, %128
%10 = phi i32 [ %137, %128 ], [ 1, %2 ]
%11 = phi i64 [ %135, %128 ], [ 16, %2 ]
%12 = phi i64 [ %134, %128 ], [ -1, %2 ]
%13 = phi i32 [ %133, %128 ], [ 0, %2 ]
%14 = phi i32 [ %132, %128 ], [ 0, %2 ]
%15 = phi i64 [ %131, %128 ], [ 0, %2 ]
%16 = phi i64 [ %130, %128 ], [ 4294967295, %2 ]
%17 = phi i64 [ %129, %128 ], [ 0, %2 ]
%18 = sext i32 %10 to i64
%19 = getelementptr inbounds i8*, i8** %1, i64 %18
%20 = load i8*, i8** %19
%21 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%22 = icmp eq i32 %21, 0
br i1 %22, label %23, label %36
23: ; preds = %9
%24 = add nsw i32 %10, 1
%25 = icmp slt i32 %24, %0
br i1 %25, label %29, label %26
26: ; preds = %23
%27 = load i8*, i8** %1
%28 = tail call i32 @usage(i8* %27)
br label %297
29: ; preds = %23
%30 = sext i32 %24 to i64
%31 = getelementptr inbounds i8*, i8** %1, i64 %30
%32 = load i8*, i8** %31
%33 = tail call i32 @strtoul(i8* nocapture %32, i32* null, i32 0)
%34 = shl nsw i32 %33, 10
%35 = sext i32 %34 to i64
br label %128
36: ; preds = %9
%37 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0))
%38 = icmp eq i32 %37, 0
br i1 %38, label %39, label %52
39: ; preds = %36
%40 = add nsw i32 %10, 1
%41 = icmp slt i32 %40, %0
br i1 %41, label %45, label %42
42: ; preds = %39
%43 = load i8*, i8** %1
%44 = tail call i32 @usage(i8* %43)
br label %297
45: ; preds = %39
%46 = sext i32 %40 to i64
%47 = getelementptr inbounds i8*, i8** %1, i64 %46
%48 = load i8*, i8** %47
%49 = tail call i32 @strtoul(i8* nocapture %48, i32* null, i32 0)
%50 = shl nsw i32 %49, 10
%51 = sext i32 %50 to i64
br label %128
52: ; preds = %36
%53 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
%54 = icmp eq i32 %53, 0
br i1 %54, label %55, label %67
55: ; preds = %52
%56 = add nsw i32 %10, 1
%57 = icmp slt i32 %56, %0
br i1 %57, label %61, label %58
58: ; preds = %55
%59 = load i8*, i8** %1
%60 = tail call i32 @usage(i8* %59)
br label %297
61: ; preds = %55
%62 = sext i32 %56 to i64
%63 = getelementptr inbounds i8*, i8** %1, i64 %62
%64 = load i8*, i8** %63
%65 = tail call i32 @strtoul(i8* nocapture %64, i32* null, i32 0)
%66 = sext i32 %65 to i64
br label %128
67: ; preds = %52
%68 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.3, i64 0, i64 0))
%69 = icmp eq i32 %68, 0
br i1 %69, label %128, label %70
70: ; preds = %67
%71 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.4, i64 0, i64 0))
%72 = icmp eq i32 %71, 0
br i1 %72, label %128, label %73
73: ; preds = %70
%74 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%75 = icmp eq i32 %74, 0
br i1 %75, label %76, label %96
76: ; preds = %73
%77 = add nsw i32 %10, 1
%78 = icmp slt i32 %77, %0
br i1 %78, label %82, label %79
79: ; preds = %76
%80 = load i8*, i8** %1
%81 = tail call i32 @usage(i8* %80)
br label %297
82: ; preds = %76
%83 = sext i32 %77 to i64
%84 = getelementptr inbounds i8*, i8** %1, i64 %83
%85 = load i8*, i8** %84
%86 = tail call i32 @strtoul(i8* nocapture %85, i32* null, i32 0)
%87 = sext i32 %86 to i64
%88 = add i32 %86, -33
%89 = icmp ult i32 %88, -32
br i1 %89, label %90, label %128
90: ; preds = %82
%91 = getelementptr inbounds i8*, i8** %1, i64 %83
%92 = load i32, i32* @stderr
%93 = load i8*, i8** %1
%94 = load i8*, i8** %91
%95 = tail call i32 (i32, i8*, ...) @fprintf(i32 %92, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.6, i64 0, i64 0), i8* %93, i8* %94, i32 32)
br label %297
96: ; preds = %73
%97 = tail call i32 @strcmp(i8* dereferenceable(1) %20, i8* dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.7, i64 0, i64 0))
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %119
99: ; preds = %96
%100 = add nsw i32 %10, 1
%101 = icmp slt i32 %100, %0
br i1 %101, label %105, label %102
102: ; preds = %99
%103 = load i8*, i8** %1
%104 = tail call i32 @usage(i8* %103)
br label %297
105: ; preds = %99
%106 = sext i32 %100 to i64
%107 = getelementptr inbounds i8*, i8** %1, i64 %106
%108 = load i8*, i8** %107
%109 = tail call i64 @strtol(i8* nocapture %108, i32* null, i32 0)
%110 = icmp slt i64 %109, 1
%111 = icmp ne i64 %109, -1
%112 = and i1 %110, %111
br i1 %112, label %113, label %128
113: ; preds = %105
%114 = getelementptr inbounds i8*, i8** %1, i64 %106
%115 = load i32, i32* @stderr
%116 = load i8*, i8** %1
%117 = load i8*, i8** %114
%118 = tail call i32 (i32, i8*, ...) @fprintf(i32 %115, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.8, i64 0, i64 0), i8* %116, i8* %117)
br label %297
119: ; preds = %96
%120 = add nsw i32 %0, -3
%121 = icmp eq i32 %10, %120
br i1 %121, label %139, label %122
122: ; preds = %119
%123 = load i32, i32* @stderr
%124 = load i8*, i8** %1
%125 = tail call i32 (i32, i8*, ...) @fprintf(i32 %123, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.9, i64 0, i64 0), i8* %124, i8* %20)
%126 = load i8*, i8** %1
%127 = tail call i32 @usage(i8* %126)
br label %297
128: ; preds = %70, %67, %29, %61, %105, %82, %45
%129 = phi i64 [ %17, %105 ], [ %17, %82 ], [ %17, %61 ], [ %17, %45 ], [ %35, %29 ], [ %17, %67 ], [ %17, %70 ]
%130 = phi i64 [ %16, %105 ], [ %16, %82 ], [ %16, %61 ], [ %51, %45 ], [ %16, %29 ], [ %16, %67 ], [ %16, %70 ]
%131 = phi i64 [ %15, %105 ], [ %15, %82 ], [ %66, %61 ], [ %15, %45 ], [ %15, %29 ], [ %15, %67 ], [ %15, %70 ]
%132 = phi i32 [ %14, %105 ], [ %14, %82 ], [ %14, %61 ], [ %14, %45 ], [ %14, %29 ], [ 1, %67 ], [ %14, %70 ]
%133 = phi i32 [ %13, %105 ], [ %13, %82 ], [ %13, %61 ], [ %13, %45 ], [ %13, %29 ], [ %13, %67 ], [ 1, %70 ]
%134 = phi i64 [ %109, %105 ], [ %12, %82 ], [ %12, %61 ], [ %12, %45 ], [ %12, %29 ], [ %12, %67 ], [ %12, %70 ]
%135 = phi i64 [ %11, %105 ], [ %87, %82 ], [ %11, %61 ], [ %11, %45 ], [ %11, %29 ], [ %11, %67 ], [ %11, %70 ]
%136 = phi i32 [ %100, %105 ], [ %77, %82 ], [ %56, %61 ], [ %40, %45 ], [ %24, %29 ], [ %10, %67 ], [ %10, %70 ]
%137 = add nsw i32 %136, 1
%138 = icmp slt i32 %137, %0
br i1 %138, label %9, label %139
139: ; preds = %128, %119
%140 = phi i64 [ %17, %119 ], [ %129, %128 ]
%141 = phi i64 [ %16, %119 ], [ %130, %128 ]
%142 = phi i64 [ %15, %119 ], [ %131, %128 ]
%143 = phi i32 [ %14, %119 ], [ %132, %128 ]
%144 = phi i32 [ %13, %119 ], [ %133, %128 ]
%145 = phi i64 [ %12, %119 ], [ %134, %128 ]
%146 = phi i64 [ %11, %119 ], [ %135, %128 ]
%147 = phi i32 [ %10, %119 ], [ %137, %128 ]
%148 = add nsw i32 %147, 1
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8*, i8** %1, i64 %149
%151 = load i8*, i8** %150
%152 = tail call i32* @fopen(i8* %151, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i64 0, i64 0))
%153 = icmp eq i32* %152, null
br i1 %153, label %154, label %158
154: ; preds = %139
%155 = load i32, i32* @stderr
%156 = load i8*, i8** %150
%157 = tail call i32 (i32, i8*, ...) @fprintf(i32 %155, i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.11, i64 0, i64 0), i8* %156)
br label %297
158: ; preds = %139
%159 = add nsw i32 %147, 2
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i8*, i8** %1, i64 %160
%162 = load i8*, i8** %161
%163 = tail call i32* @fopen(i8* %162, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0))
%164 = icmp eq i32* %163, null
br i1 %164, label %165, label %170
165: ; preds = %158
%166 = load i32, i32* @stderr
%167 = load i8*, i8** %161
%168 = tail call i32 (i32, i8*, ...) @fprintf(i32 %166, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.13, i64 0, i64 0), i8* %167)
%169 = tail call i32 @fclose(i32* %152)
br label %297
170: ; preds = %158
%171 = tail call i64 @fsize(i32* %152)
%172 = ptrtoint i32* %163 to i64
%173 = trunc i64 %172 to i32
%174 = load i8*, i8** %150
%175 = load i8*, i8** %1
%176 = icmp eq i32 %144, 0
%177 = select i1 %176, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.15, i64 0, i64 0)
%178 = select i1 %176, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0)
%179 = sext i32 %147 to i64
%180 = getelementptr inbounds i8*, i8** %1, i64 %179
%181 = load i8*, i8** %180
%182 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([133 x i8], [133 x i8]* @.str.14, i64 0, i64 0), i8* %174, i8* %175, i8* %177, i8* %178, i8* %181)
%183 = icmp eq i64 %142, 0
%184 = and i64 %171, %142
%185 = icmp eq i64 %184, 0
%186 = select i1 %183, i1 true, i1 %185
br i1 %186, label %191, label %187
187: ; preds = %170
%188 = load i32, i32* @stderr
%189 = load i8*, i8** %1
%190 = tail call i32 (i32, i8*, ...) @fprintf(i32 %188, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.18, i64 0, i64 0), i8* %189, i64 %171)
br label %289
191: ; preds = %170
%192 = icmp ult i64 %171, %140
%193 = icmp ugt i64 %171, %141
%194 = select i1 %192, i1 true, i1 %193
br i1 %194, label %201, label %195
195: ; preds = %191
%196 = call i64 @fread(i8* %4, i32 1, i64 %146, i32* %152)
%197 = icmp eq i64 %196, 0
br i1 %197, label %262, label %198
198: ; preds = %195
%199 = icmp sgt i64 %145, 0
%200 = icmp eq i32 %143, 0
br label %205
201: ; preds = %191
%202 = load i32, i32* @stderr
%203 = load i8*, i8** %1
%204 = tail call i32 (i32, i8*, ...) @fprintf(i32 %202, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.19, i64 0, i64 0), i8* %203, i64 %171, i64 %140, i64 %141)
br label %289
205: ; preds = %198, %257
%206 = phi i64 [ %196, %198 ], [ %260, %257 ]
%207 = phi i64 [ 0, %198 ], [ %259, %257 ]
%208 = icmp ne i64 %207, 0
%209 = select i1 %199, i1 %208, i1 false
br i1 %209, label %210, label %216
210: ; preds = %205
%211 = udiv i64 %207, %146
%212 = urem i64 %211, %145
%213 = icmp eq i64 %212, 0
br i1 %213, label %214, label %216
214: ; preds = %210
%215 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
br label %216
216: ; preds = %214, %210, %205
%217 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0))
br label %220
218: ; preds = %220
%219 = icmp ult i64 %206, %146
br i1 %219, label %228, label %233
220: ; preds = %216, %220
%221 = phi i64 [ 0, %216 ], [ %226, %220 ]
%222 = getelementptr inbounds [32 x i8], [32 x i8]* %3, i64 0, i64 %221
%223 = load i8, i8* %222
%224 = zext i8 %223 to i32
%225 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i64 0, i64 0), i32 %224)
%226 = add nuw i64 %221, 1
%227 = icmp eq i64 %226, %206
br i1 %227, label %218, label %220
228: ; preds = %218, %228
%229 = phi i64 [ %231, %228 ], [ %206, %218 ]
%230 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.23, i64 0, i64 0))
%231 = add i64 %229, 1
%232 = icmp eq i64 %231, %146
br i1 %232, label %233, label %228
233: ; preds = %228, %218
br i1 %200, label %257, label %234
234: ; preds = %233
%235 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.24, i64 0, i64 0), i64 %207)
br label %237
236: ; preds = %237
br i1 %219, label %250, label %255
237: ; preds = %234, %237
%238 = phi i64 [ 0, %234 ], [ %248, %237 ]
%239 = getelementptr inbounds [32 x i8], [32 x i8]* %3, i64 0, i64 %238
%240 = load i8, i8* %239
%241 = tail call i64 @isprint(i8 zeroext %240)
%242 = icmp eq i64 %241, 0
%243 = icmp eq i8 %240, 47
%244 = select i1 %243, i8 46, i8 %240
%245 = zext i8 %244 to i32
%246 = select i1 %242, i32 46, i32 %245
%247 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i64 0, i64 0), i32 %246)
%248 = add nuw i64 %238, 1
%249 = icmp eq i64 %248, %206
br i1 %249, label %236, label %237
250: ; preds = %236, %250
%251 = phi i64 [ %253, %250 ], [ %206, %236 ]
%252 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.26, i64 0, i64 0))
%253 = add i64 %251, 1
%254 = icmp eq i64 %253, %146
br i1 %254, label %255, label %250
255: ; preds = %250, %236
%256 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.27, i64 0, i64 0))
br label %257
257: ; preds = %255, %233
%258 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0))
%259 = add i64 %206, %207
%260 = call i64 @fread(i8* %4, i32 1, i64 %146, i32* %152)
%261 = icmp eq i64 %260, 0
br i1 %261, label %262, label %205
262: ; preds = %257, %195
%263 = phi i64 [ 0, %195 ], [ %259, %257 ]
%264 = tail call i64 @ferror(i32* %152)
%265 = icmp eq i64 %264, 0
br i1 %265, label %273, label %266
266: ; preds = %262
%267 = tail call i32 @feof(i32* %152)
%268 = icmp eq i32 %267, 0
br i1 %268, label %269, label %273
269: ; preds = %266
%270 = load i32, i32* @stderr
%271 = load i8*, i8** %1
%272 = tail call i32 (i32, i8*, ...) @fprintf(i32 %270, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i8* %271)
br label %289
273: ; preds = %266, %262
%274 = icmp eq i64 %263, %171
br i1 %274, label %279, label %275
275: ; preds = %273
%276 = load i32, i32* @stderr
%277 = load i8*, i8** %1
%278 = tail call i32 (i32, i8*, ...) @fprintf(i32 %276, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.29, i64 0, i64 0), i8* %277, i64 %263, i64 %171)
br label %289
279: ; preds = %273
%280 = load i8*, i8** %180
%281 = tail call i32 (i32, i8*, ...) @fprintf(i32 %173, i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.30, i64 0, i64 0), i8* %177, i8* %178, i8* %280, i8* %280)
%282 = tail call i32 @fflush(i32* %163)
%283 = tail call i64 @ferror(i32* %163)
%284 = icmp eq i64 %283, 0
br i1 %284, label %289, label %285
285: ; preds = %279
%286 = load i32, i32* @stderr
%287 = load i8*, i8** %1
%288 = tail call i32 (i32, i8*, ...) @fprintf(i32 %286, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.31, i64 0, i64 0), i8* %287)
br label %289
289: ; preds = %279, %201, %275, %285, %269, %187
%290 = phi i1 [ false, %201 ], [ false, %275 ], [ false, %285 ], [ false, %269 ], [ false, %187 ], [ true, %279 ]
%291 = phi i32 [ 1, %201 ], [ 1, %275 ], [ 1, %285 ], [ 1, %269 ], [ 1, %187 ], [ 0, %279 ]
%292 = tail call i32 @fclose(i32* %163)
%293 = tail call i32 @fclose(i32* %152)
br i1 %290, label %297, label %294
294: ; preds = %289
%295 = load i8*, i8** %161
%296 = tail call i32 @remove(i8* %295)
br label %297
297: ; preds = %289, %294, %165, %154, %122, %113, %102, %90, %79, %58, %42, %26, %6
%298 = phi i32 [ %8, %6 ], [ 1, %165 ], [ 1, %154 ], [ %127, %122 ], [ %104, %102 ], [ 1, %113 ], [ %81, %79 ], [ 1, %90 ], [ %60, %58 ], [ %44, %42 ], [ %28, %26 ], [ %291, %294 ], [ %291, %289 ]
ret i32 %298
}