#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*/ FILE;

/* Variables and functions */
int f_outputLine(int /*<<< orphan*/ *, char *);
int /*<<< orphan*/ fatal(char *, ...);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
scalar_t__ strncmp(char *, char *, int);
char *strstr(char *, char *);
int main(int argc, char *argv[]) {
  char acLineIn[256];
  char acLineOut[256];
  char *pcTerm;
  int iThisChar;
  int iStart;
  int iTarget;
  int iTranslateQuotes;
  int iQuoteCount;
  int iPrevLineContinues = 0;
  int iEchoLevel = 0;
  FILE *pfTestoIn;
  FILE *pfTestoOut;
  if (argc < 2) {
    fatal("MkWinTesto"
          ": needs a single parameter, the (testo) file to convert\n");
  }
  pfTestoIn = fopen(argv[1], "rb");
  if (pfTestoIn == NULL) {
    fatal("MkWinTesto"
          ": %s for reading\n",
          argv[1]);
  } else {
    pfTestoOut = fopen("wintesto.cmd", "wb");
    if (pfTestoOut == NULL) {
      fatal("MkWinTesto"
            ": wintesto.cmd for writing\n");
    } else {
      f_outputLine(pfTestoOut, "@echo off");
      f_outputLine(pfTestoOut, "REM");
      f_outputLine(pfTestoOut, "REM Simple Windows NT/2000/XP .cmd version of "
                               "GPSBabel testo script");
      f_outputLine(pfTestoOut, "REM");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "SET GPSBABEL_FREEZE_TIME=y");
      f_outputLine(pfTestoOut, "SET TMPDIR=%TEMP%\\WINTESTO");
      f_outputLine(pfTestoOut, "MKDIR %TMPDIR% 2>NUL:");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "GOTO :REALSTART");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "REM ==================================");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, ":CommonCOMPARE");
      f_outputLine(pfTestoOut, "SET PARAM1=%2");
      f_outputLine(pfTestoOut, "SET PARAM2=%3");
      f_outputLine(pfTestoOut, "REM Test if param3 was a dir rather than a "
                               "file, if so add a \\* to make fc work");
      f_outputLine(
          pfTestoOut,
          "FOR %%A IN (%3) DO IF \"d--------\"==\"%%~aA\" SET PARAM2=%3\\*");
      f_outputLine(pfTestoOut,
                   "FOR /f \"delims=\" %%a IN ('fc %PARAM1% %PARAM2%') DO IF "
                   "\"x%%a\"==\"xFC: no differences encountered\" GOTO :EOF");
      f_outputLine(pfTestoOut, "REM Show the first 5 lines of difference");
      f_outputLine(pfTestoOut, "fc %1 /LB5 %PARAM1% %PARAM2%");
      f_outputLine(pfTestoOut,
                   "if errorlevel 1 ECHO %* are not the same (first 5 "
                   "differences above) - pausing. ^C to quit if required");
      f_outputLine(pfTestoOut, "if errorlevel 1 PAUSE");
      f_outputLine(pfTestoOut, "GOTO :EOF");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "REM ==================================");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, ":COMPARE");
      f_outputLine(pfTestoOut, "CALL :CommonCOMPARE /L %1 %2");
      f_outputLine(pfTestoOut, "GOTO :EOF");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "REM ==================================");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, ":BINCOMPARE");
      f_outputLine(pfTestoOut, "CALL :CommonCOMPARE /B %1 %2");
      f_outputLine(pfTestoOut, "GOTO :EOF");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "REM ==================================");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, ":SORTandCOMPARE");
      f_outputLine(pfTestoOut, "SORT <%1 >%TMPDIR%\\s1");
      f_outputLine(pfTestoOut, "SORT <%2 >%TMPDIR%\\s2");
      f_outputLine(pfTestoOut, "CALL :COMPARE %TMPDIR%\\s1 %TMPDIR%\\s2");
      f_outputLine(pfTestoOut, "GOTO :EOF");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, "REM ==================================");
      f_outputLine(pfTestoOut, "");
      f_outputLine(pfTestoOut, ":REALSTART");
      f_outputLine(pfTestoOut, "");
      while (!feof(pfTestoIn)) {
        fgets(acLineIn, 256 - 1, pfTestoIn);
        if (acLineIn == NULL)
          break;
        if (acLineIn[0] == '#') {
          acLineOut[0] = '\0';
          strcat(acLineOut, "REM");
          iTarget = 3;
          if (acLineIn[1] != ' ') {
            strcat(acLineOut, " ");
            iTarget++;
          }
          for (iThisChar = 1; iThisChar < 256; iThisChar++) {
            if ((acLineIn[iThisChar] == '\0') ||
                (acLineIn[iThisChar] == '\n') ||
                ((acLineIn[iThisChar] == '\r') &&
                 (acLineIn[iThisChar + 1] == '\n'))) {
              acLineOut[iThisChar + iTarget - 1] = '\0';
              break;
            }
            acLineOut[iThisChar + iTarget - 1] = acLineIn[iThisChar];
          }
          if (iEchoLevel > 0) {
            f_outputLine(pfTestoOut, "@echo off");
            f_outputLine(pfTestoOut, "@echo.");
            iEchoLevel = 0;
          }
          iPrevLineContinues = f_outputLine(pfTestoOut, acLineOut);
        } else if (strncmp("PNAME=${PNAME:-", acLineIn, 15) == 0) {
          acLineOut[0] = '\0';
          strcat(acLineOut, "SET PNAME=");
          for (iThisChar = 15; iThisChar < 256; iThisChar++) {
            if ((acLineIn[iThisChar] == '}') || (acLineIn[iThisChar] == '\0') ||
                (acLineIn[iThisChar] == '\n') ||
                ((acLineIn[iThisChar] == '\r') &&
                 (acLineIn[iThisChar + 1] == '\n'))) {
              acLineOut[iThisChar - 5] = '\0';
              break;
            }
            if (acLineIn[iThisChar] == '/') {
              acLineOut[iThisChar - 5] = '\\';
            } else {
              acLineOut[iThisChar - 5] = acLineIn[iThisChar];
            }
          }
          if (iEchoLevel > 0) {
            f_outputLine(pfTestoOut, "@echo off");
            f_outputLine(pfTestoOut, "@echo.");
            iEchoLevel = 0;
          }
          iPrevLineContinues = f_outputLine(pfTestoOut, acLineOut);
          if (iPrevLineContinues == 1)
            f_outputLine(pfTestoOut, "");
          iPrevLineContinues = f_outputLine(
              pfTestoOut,
              "IF NOT EXIST %PNAME%.EXE ECHO Can't find %PNAME%&& GOTO :EOF");
        } else {
          iStart = 0;
          iTarget = 0;
          iTranslateQuotes = 0;
          iQuoteCount = 0;
          acLineOut[0] = '\0';
          if (strncmp("rm -f ", acLineIn, 6) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 6;
            strcat(acLineOut, "DEL ");
            iTarget = 4;
          }
          if (strncmp("${PNAME} ", acLineIn, 9) == 0) {
            iStart = 9;
            iEchoLevel++;
            strcat(acLineOut, "%PNAME% ");
            iTarget = 8;
          }
          if (strncmp("compare ", acLineIn, 8) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 8;
            strcat(acLineOut, "CALL :COMPARE ");
            iTarget = 14;
          }
          if (strncmp("bincompare ", acLineIn, 11) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 11;
            strcat(acLineOut, "CALL :BINCOMPARE ");
            iTarget = 17;
          }
          if (strncmp("sort_and_compare ", acLineIn, 17) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 17;
            strcat(acLineOut, "CALL :SORTandCOMPARE ");
            iTarget = 21;
          }
          if (strncmp("echo \"", acLineIn, 6) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 6;
            strcat(acLineOut, "ECHO ");
            iTarget = 5;
            iTranslateQuotes = 1;
            iQuoteCount = 1;
          }
          if (strncmp("cat ", acLineIn, 4) == 0) {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            iStart = 4;
            strcat(acLineOut, "TYPE ");
            iTarget = 5;
          }
          if (strncmp("sed '/", acLineIn, 6) == 0) {
            pcTerm = strstr(acLineIn + 6, "/d'");
            if ((pcTerm != NULL) && ((pcTerm - acLineIn) < 256)) {
              if (iEchoLevel > 0) {
                f_outputLine(pfTestoOut, "@echo off");
                f_outputLine(pfTestoOut, "@echo.");
                iEchoLevel = 0;
              }
              iStart = 6;
              strcat(acLineOut, "FINDSTR /V /R /C:\"");
              iTarget = 18;
              for (iThisChar = 6; iThisChar < (pcTerm - acLineIn);
                   iThisChar++) {
                acLineOut[iTarget++] = acLineIn[iStart++];
              }
              acLineOut[iTarget++] = (char)0;
              strcat(acLineOut, "\"");
              iStart += 3;
            }
          }
          if ((iStart > 0) || (iPrevLineContinues == 1)) {
            if (iStart == 0) {
              for (iThisChar = 0; iThisChar < 256; iThisChar++) {
                if ((acLineIn[iThisChar] == '\0') ||
                    (acLineIn[iThisChar] == '\n') ||
                    ((acLineIn[iThisChar] == '\r') &&
                     (acLineIn[iThisChar + 1] == '\n'))) {
                  iStart = iThisChar;
                  break;
                }
                if ((acLineIn[iThisChar] != ' ') &&
                    (acLineIn[iThisChar] != '\t')) {
                  iStart = iThisChar;
                  break;
                }
              }
            }
            for (iThisChar = iStart; iThisChar < 256; iThisChar++) {
              if ((acLineIn[iThisChar] == '\0') ||
                  (acLineIn[iThisChar] == '\n') ||
                  ((acLineIn[iThisChar] == '\r') &&
                   (acLineIn[iThisChar + 1] == '\n'))) {
                acLineOut[iTarget + iThisChar - iStart] = '\0';
                break;
              }
              if (acLineIn[iThisChar] == '"') {
                iQuoteCount = (iQuoteCount > 0) ? 0 : 1;
                iTarget--;
                continue;
              }
              if (acLineIn[iThisChar] == '%') {
                if (iQuoteCount == 1) {
                  acLineOut[iTarget + iThisChar - iStart] = '%';
                  iTarget++;
                }
                acLineOut[iTarget + iThisChar - iStart] = '%';
                continue;
              }
              if (acLineIn[iThisChar] == '>') {
                if (acLineIn[iThisChar - 1] == ' ') {
                  iTarget--;
                }
                acLineOut[iTarget + iThisChar - iStart] = '>';
                continue;
              }
              if (strncmp("${TMPDIR}", acLineIn + iThisChar, 9) == 0) {
                strcpy(acLineOut + iTarget + iThisChar - iStart, "%TMPDIR%");
                iTarget--;
                iThisChar += 8;
              } else if (strncmp("${PNAME} ", acLineIn + iThisChar, 9) == 0) {
                strcpy(acLineOut + iTarget + iThisChar - iStart, "%PNAME% ");
                iTarget--;
                iThisChar += 8;
              } else if (acLineIn[iThisChar] == '/') {
                acLineOut[iTarget + iThisChar - iStart] = '\\';
              } else {
                acLineOut[iTarget + iThisChar - iStart] = acLineIn[iThisChar];
              }
            }
            if ((iEchoLevel == 1) && (iPrevLineContinues != 1)) {
              f_outputLine(pfTestoOut, "@echo on");
              f_outputLine(pfTestoOut, "@echo Testing...");
            }
            iPrevLineContinues = f_outputLine(pfTestoOut, acLineOut);
          } else {
            if (iEchoLevel > 0) {
              f_outputLine(pfTestoOut, "@echo off");
              f_outputLine(pfTestoOut, "@echo.");
              iEchoLevel = 0;
            }
            if ((acLineIn[0] == '\n') || (acLineIn[0] == '\0') ||
                ((acLineIn[0] == '\r') && (acLineIn[1] == '\n') &&
                 (acLineIn[2] == '\0'))) {
              iPrevLineContinues = f_outputLine(pfTestoOut, "");
            }
          }
        }
      }
      fclose(pfTestoIn);
      fclose(pfTestoOut);
    }
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x230(%rbp)
movl   $0x0,-0x234(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    11e5 <main+0x45>
lea    0x1e22(%rip),%rdi
mov    $0x0,%al
call   10b0 <fatal@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0x1e4f(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x240(%rbp)
cmpq   $0x0,-0x240(%rbp)
jne    1229 <main+0x89>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
lea    0x1e29(%rip),%rdi
mov    $0x0,%al
call   10b0 <fatal@plt>
jmp    2495 <main+0x12f5>
lea    0x1e32(%rip),%rdi
lea    0x1e38(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x248(%rbp)
cmpq   $0x0,-0x248(%rbp)
jne    1264 <main+0xc4>
lea    0x1e1a(%rip),%rdi
mov    $0x0,%al
call   10b0 <fatal@plt>
jmp    2490 <main+0x12f0>
mov    -0x248(%rbp),%rdi
lea    0x1e26(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e1d(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e0e(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1df7(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1da3(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e19(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e21(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e29(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1d57(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e19(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1d31(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e03(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1d0b(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e04(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e00(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1dfb(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1df6(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e33(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e5b(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1eb3(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1ec9(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1ed3(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1f27(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e5d(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1c27(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1cf9(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1c01(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1ede(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1ed4(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1deb(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1bb5(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1c87(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1b8f(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e92(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e8b(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1d79(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1b43(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1c15(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1b1d(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e49(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e46(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e49(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1e4c(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1ce1(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1aab(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1b7d(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1a85(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1b4c(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1a5f(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x240(%rbp),%rdi
call   1070 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1628 <main+0x488>
jmp    2478 <main+0x12d8>
lea    -0x110(%rbp),%rdi
mov    -0x240(%rbp),%rdx
mov    $0xff,%esi
call   1060 <fgets@plt>
movsbl -0x110(%rbp),%eax
cmp    $0x23,%eax
jne    17d7 <main+0x637>
movb   $0x0,-0x210(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1a3d(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x3,-0x224(%rbp)
movsbl -0x10f(%rbp),%eax
cmp    $0x20,%eax
je     16a6 <main+0x506>
lea    -0x210(%rbp),%rdi
lea    0x1dec(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
movl   $0x1,-0x21c(%rbp)
cmpl   $0x100,-0x21c(%rbp)
jge    177c <main+0x5dc>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1724 <main+0x584>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     1724 <main+0x584>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
jne    1742 <main+0x5a2>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    1742 <main+0x5a2>
mov    -0x21c(%rbp),%eax
add    -0x224(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x210(%rbp,%rax,1)
jmp    177c <main+0x5dc>
movslq -0x21c(%rbp),%rax
mov    -0x110(%rbp,%rax,1),%cl
mov    -0x21c(%rbp),%eax
add    -0x224(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0x210(%rbp,%rax,1)
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    16b0 <main+0x510>
cmpl   $0x0,-0x234(%rbp)
jle    17b9 <main+0x619>
mov    -0x248(%rbp),%rdi
lea    0x1901(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1c58(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
mov    -0x248(%rbp),%rdi
lea    -0x210(%rbp),%rsi
call   1080 <f_outputLine@plt>
mov    %eax,-0x230(%rbp)
jmp    2473 <main+0x12d3>
lea    -0x110(%rbp),%rsi
lea    0x1c24(%rip),%rdi
mov    $0xf,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    19be <main+0x81e>
movb   $0x0,-0x210(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1c0b(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0xf,-0x21c(%rbp)
cmpl   $0x100,-0x21c(%rbp)
jge    192a <main+0x78a>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x7d,%eax
je     18a9 <main+0x709>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     18a9 <main+0x709>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     18a9 <main+0x709>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
jne    18c1 <main+0x721>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    18c1 <main+0x721>
mov    -0x21c(%rbp),%eax
sub    $0x5,%eax
cltq
movb   $0x0,-0x210(%rbp,%rax,1)
jmp    192a <main+0x78a>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
jne    18f1 <main+0x751>
mov    -0x21c(%rbp),%eax
sub    $0x5,%eax
cltq
movb   $0x5c,-0x210(%rbp,%rax,1)
5c
jmp    1911 <main+0x771>
movslq -0x21c(%rbp),%rax
mov    -0x110(%rbp,%rax,1),%cl
mov    -0x21c(%rbp),%eax
sub    $0x5,%eax
cltq
mov    %cl,-0x210(%rbp,%rax,1)
jmp    1916 <main+0x776>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    181d <main+0x67d>
cmpl   $0x0,-0x234(%rbp)
jle    1967 <main+0x7c7>
mov    -0x248(%rbp),%rdi
lea    0x1753(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1aaa(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
mov    -0x248(%rbp),%rdi
lea    -0x210(%rbp),%rsi
call   1080 <f_outputLine@plt>
mov    %eax,-0x230(%rbp)
cmpl   $0x1,-0x230(%rbp)
jne    19a0 <main+0x800>
mov    -0x248(%rbp),%rdi
lea    0x16c6(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1a76(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %eax,-0x230(%rbp)
jmp    246e <main+0x12ce>
movl   $0x0,-0x220(%rbp)
movl   $0x0,-0x224(%rbp)
movl   $0x0,-0x228(%rbp)
movl   $0x0,-0x22c(%rbp)
movb   $0x0,-0x210(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x1a66(%rip),%rdi
mov    $0x6,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1a73 <main+0x8d3>
cmpl   $0x0,-0x234(%rbp)
jle    1a4c <main+0x8ac>
mov    -0x248(%rbp),%rdi
lea    0x166e(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x19c5(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x6,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1a04(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x4,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x19ec(%rip),%rdi
mov    $0x9,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1acb <main+0x92b>
movl   $0x9,-0x220(%rbp)
mov    -0x234(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x234(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x19bb(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x8,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x19dd(%rip),%rdi
mov    $0x8,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1b51 <main+0x9b1>
cmpl   $0x0,-0x234(%rbp)
jle    1b2a <main+0x98a>
mov    -0x248(%rbp),%rdi
lea    0x1590(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x18e7(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x8,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x193e(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0xe,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x1930(%rip),%rdi
mov    $0xb,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1bd7 <main+0xa37>
cmpl   $0x0,-0x234(%rbp)
jle    1bb0 <main+0xa10>
mov    -0x248(%rbp),%rdi
lea    0x150a(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1861(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0xb,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x18d3(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x11,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x18c8(%rip),%rdi
mov    $0x11,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1c5d <main+0xabd>
cmpl   $0x0,-0x234(%rbp)
jle    1c36 <main+0xa96>
mov    -0x248(%rbp),%rdi
lea    0x1484(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x17db(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x11,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1871(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x15,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x186a(%rip),%rdi
mov    $0x6,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1cf7 <main+0xb57>
cmpl   $0x0,-0x234(%rbp)
jle    1cbc <main+0xb1c>
mov    -0x248(%rbp),%rdi
lea    0x13fe(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1755(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x6,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1808(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x5,-0x224(%rbp)
movl   $0x1,-0x228(%rbp)
movl   $0x1,-0x22c(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x17dd(%rip),%rdi
mov    $0x4,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1d7d <main+0xbdd>
cmpl   $0x0,-0x234(%rbp)
jle    1d56 <main+0xbb6>
mov    -0x248(%rbp),%rdi
lea    0x1364(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x16bb(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x4,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x1779(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x5,-0x224(%rbp)
lea    -0x110(%rbp),%rsi
lea    0x1762(%rip),%rdi
mov    $0x6,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1f01 <main+0xd61>
lea    -0x110(%rbp),%rdi
add    $0x6,%rdi
lea    0x1743(%rip),%rsi
call   10c0 <strstr@plt>
mov    %rax,-0x218(%rbp)
cmpq   $0x0,-0x218(%rbp)
je     1efc <main+0xd5c>
mov    -0x218(%rbp),%rax
lea    -0x110(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x100,%rax
jge    1efc <main+0xd5c>
cmpl   $0x0,-0x234(%rbp)
jle    1e25 <main+0xc85>
mov    -0x248(%rbp),%rdi
lea    0x1295(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x15ec(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movl   $0x6,-0x220(%rbp)
lea    -0x210(%rbp),%rdi
lea    0x16bb(%rip),%rsi
call   10a0 <strcat@plt>
movl   $0x12,-0x224(%rbp)
movl   $0x6,-0x21c(%rbp)
movslq -0x21c(%rbp),%rax
mov    -0x218(%rbp),%rcx
lea    -0x110(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jge    1ebf <main+0xd1f>
mov    -0x220(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x220(%rbp)
cltq
mov    -0x110(%rbp,%rax,1),%cl
mov    -0x224(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x224(%rbp)
cltq
mov    %cl,-0x210(%rbp,%rax,1)
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1e56 <main+0xcb6>
mov    -0x224(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x224(%rbp)
cltq
movb   $0x0,-0x210(%rbp,%rax,1)
lea    -0x210(%rbp),%rdi
lea    0x15f2(%rip),%rsi
call   10a0 <strcat@plt>
mov    -0x220(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x220(%rbp)
jmp    1f01 <main+0xd61>
cmpl   $0x0,-0x220(%rbp)
jg     1f1b <main+0xd7b>
cmpl   $0x1,-0x230(%rbp)
jne    23be <main+0x121e>
cmpl   $0x0,-0x220(%rbp)
jne    2016 <main+0xe76>
movl   $0x0,-0x21c(%rbp)
cmpl   $0x100,-0x21c(%rbp)
jge    2011 <main+0xe71>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     1fa6 <main+0xe06>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     1fa6 <main+0xe06>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
jne    1fb7 <main+0xe17>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    1fb7 <main+0xe17>
mov    -0x21c(%rbp),%eax
mov    %eax,-0x220(%rbp)
jmp    2011 <main+0xe71>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     1ff8 <main+0xe58>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x9,%eax
je     1ff8 <main+0xe58>
mov    -0x21c(%rbp),%eax
mov    %eax,-0x220(%rbp)
jmp    2011 <main+0xe71>
jmp    1ffd <main+0xe5d>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    1f32 <main+0xd92>
jmp    2016 <main+0xe76>
mov    -0x220(%rbp),%eax
mov    %eax,-0x21c(%rbp)
cmpl   $0x100,-0x21c(%rbp)
jge    2360 <main+0x11c0>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     2096 <main+0xef6>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     2096 <main+0xef6>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
jne    20b7 <main+0xf17>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    20b7 <main+0xf17>
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
movb   $0x0,-0x210(%rbp,%rax,1)
jmp    2360 <main+0x11c0>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x22,%eax
jne    20fc <main+0xf5c>
mov    -0x22c(%rbp),%edx
mov    $0x1,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovg  %ecx,%eax
mov    %eax,-0x22c(%rbp)
mov    -0x224(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x224(%rbp)
jmp    234c <main+0x11ac>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x25,%eax
jne    216d <main+0xfcd>
cmpl   $0x1,-0x22c(%rbp)
jne    214c <main+0xfac>
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
movb   $0x25,-0x210(%rbp,%rax,1)
25
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
movb   $0x25,-0x210(%rbp,%rax,1)
25
jmp    234c <main+0x11ac>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x3e,%eax
jne    21d1 <main+0x1031>
mov    -0x21c(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    21b0 <main+0x1010>
mov    -0x224(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x224(%rbp)
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
movb   $0x3e,-0x210(%rbp,%rax,1)
3e
jmp    234c <main+0x11ac>
lea    -0x110(%rbp),%rsi
movslq -0x21c(%rbp),%rax
add    %rax,%rsi
lea    0x1322(%rip),%rdi
mov    $0x9,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    2256 <main+0x10b6>
lea    -0x210(%rbp),%rdi
movslq -0x224(%rbp),%rax
add    %rax,%rdi
movslq -0x21c(%rbp),%rax
add    %rax,%rdi
movslq -0x220(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
lea    0x12e7(%rip),%rsi
call   1040 <strcpy@plt>
mov    -0x224(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x224(%rbp)
mov    -0x21c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x21c(%rbp)
jmp    2347 <main+0x11a7>
lea    -0x110(%rbp),%rsi
movslq -0x21c(%rbp),%rax
add    %rax,%rsi
lea    0x11ff(%rip),%rdi
mov    $0x9,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    22db <main+0x113b>
lea    -0x210(%rbp),%rdi
movslq -0x224(%rbp),%rax
add    %rax,%rdi
movslq -0x21c(%rbp),%rax
add    %rax,%rdi
movslq -0x220(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
add    %rax,%rdi
lea    0x11c4(%rip),%rsi
call   1040 <strcpy@plt>
mov    -0x224(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x224(%rbp)
mov    -0x21c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x21c(%rbp)
jmp    2342 <main+0x11a2>
movslq -0x21c(%rbp),%rax
movsbl -0x110(%rbp,%rax,1),%eax
ff
cmp    $0x2f,%eax
jne    2314 <main+0x1174>
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
movb   $0x5c,-0x210(%rbp,%rax,1)
5c
jmp    233d <main+0x119d>
movslq -0x21c(%rbp),%rax
mov    -0x110(%rbp,%rax,1),%cl
mov    -0x224(%rbp),%eax
add    -0x21c(%rbp),%eax
sub    -0x220(%rbp),%eax
cltq
mov    %cl,-0x210(%rbp,%rax,1)
jmp    2342 <main+0x11a2>
jmp    2347 <main+0x11a7>
jmp    234c <main+0x11ac>
mov    -0x21c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x21c(%rbp)
jmp    2022 <main+0xe82>
cmpl   $0x1,-0x234(%rbp)
jne    23a0 <main+0x1200>
cmpl   $0x1,-0x230(%rbp)
je     23a0 <main+0x1200>
mov    -0x248(%rbp),%rdi
lea    0x1196(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x118c(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    -0x210(%rbp),%rsi
call   1080 <f_outputLine@plt>
mov    %eax,-0x230(%rbp)
jmp    2469 <main+0x12c9>
cmpl   $0x0,-0x234(%rbp)
jle    23fb <main+0x125b>
mov    -0x248(%rbp),%rdi
lea    0xcbf(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    -0x248(%rbp),%rdi
lea    0x1016(%rip),%rsi
call   1080 <f_outputLine@plt>
movl   $0x0,-0x234(%rbp)
movsbl -0x110(%rbp),%eax
cmp    $0xa,%eax
je     244b <main+0x12ab>
movsbl -0x110(%rbp),%eax
cmp    $0x0,%eax
je     244b <main+0x12ab>
movsbl -0x110(%rbp),%eax
cmp    $0xd,%eax
jne    2464 <main+0x12c4>
movsbl -0x10f(%rbp),%eax
cmp    $0xa,%eax
jne    2464 <main+0x12c4>
movsbl -0x10e(%rbp),%eax
cmp    $0x0,%eax
jne    2464 <main+0x12c4>
mov    -0x248(%rbp),%rdi
lea    0xc08(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %eax,-0x230(%rbp)
jmp    2469 <main+0x12c9>
jmp    246e <main+0x12ce>
jmp    2473 <main+0x12d3>
jmp    1607 <main+0x467>
mov    -0x240(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x248(%rbp),%rdi
call   1050 <fclose@plt>
jmp    2495 <main+0x12f5>
mov    -0x4(%rbp),%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
mov    %rsi,%rbx
cmp    $0x1,%edi
jg     11d7 <main+0x27>
lea    0xec8(%rip),%rdi
xor    %eax,%eax
call   10c0 <fatal@plt>
mov    0x8(%rbx),%rdi
lea    0xef9(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     14cb <main+0x31b>
mov    %rax,%r13
lea    0xf00(%rip),%rdi
lea    0xf06(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     14df <main+0x32f>
mov    %rax,%r14
lea    0xf17(%rip),%rsi
mov    %rax,%rdi
call   1080 <f_outputLine@plt>
lea    0xf12(%rip),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xf04(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xea5(%rip),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xf1c(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf28(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf34(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xf30(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xf26(%rip),%r15
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xf30(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf30(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf2f(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf2e(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf6f(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xf9b(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xff7(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1011(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x101f(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1077(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0xfb1(%rip),%r12
mov    %r14,%rdi
mov    %r12,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0x104b(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1045(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r12,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0x1027(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1024(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r12,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0x1006(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1007(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x100e(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
lea    0x1015(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r12,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
lea    0xd39(%rip),%rsi
mov    %r14,%rdi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1080 <f_outputLine@plt>
mov    %r13,%rdi
call   1070 <feof@plt>
test   %eax,%eax
je     1501 <main+0x351>
mov    %r13,%rdi
call   1050 <fclose@plt>
mov    %r14,%rdi
call   1050 <fclose@plt>
jmp    14ed <main+0x33d>
mov    0x8(%rbx),%rsi
lea    0xc08(%rip),%rdi
xor    %eax,%eax
call   10c0 <fatal@plt>
jmp    14ed <main+0x33d>
lea    0xc24(%rip),%rdi
xor    %eax,%eax
call   10c0 <fatal@plt>
xor    %eax,%eax
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x30(%rsp),%rbp
mov    %rbp,%rax
xor    $0xfffffffffffffffa,%rax
mov    %rax,0x28(%rsp)
mov    $0xc,%eax
sub    %rbp,%rax
mov    %rax,0x20(%rsp)
xor    %r12d,%r12d
lea    0x130(%rsp),%r15
xor    %ebx,%ebx
mov    %r13,0x10(%rsp)
mov    %r14,0x18(%rsp)
jmp    155d <main+0x3ad>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %eax,%ebx
mov    %r13,%rdi
call   1070 <feof@plt>
test   %eax,%eax
jne    14b9 <main+0x309>
mov    %rbp,%rdi
mov    $0xff,%esi
mov    %r13,%rdx
call   1060 <fgets@plt>
cmpb   $0x23,0x30(%rsp)
jne    1630 <main+0x480>
movb   $0x0,0x130(%rsp)
mov    %r15,%rdi
lea    0xbb0(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x2,%eax
cmpb   $0x20,0x31(%rsp)
je     15af <main+0x3ff>
mov    %r15,%rdi
lea    0xf71(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x3,%eax
mov    %eax,%eax
mov    $0x1,%ecx
jmp    15e1 <main+0x431>
nopl   0x0(%rax,%rax,1)
cmpb   $0xa,0x31(%rsp,%rcx,1)
je     15f4 <main+0x444>
lea    0x1(%rcx),%rsi
add    %rax,%rcx
mov    %dl,0x130(%rsp,%rcx,1)
mov    %rsi,%rcx
cmp    $0x100,%rsi
je     1601 <main+0x451>
movzbl 0x30(%rsp,%rcx,1),%edx
cmp    $0xd,%dl
je     15c0 <main+0x410>
test   %dl,%dl
je     15f4 <main+0x444>
cmp    $0xa,%dl
jne    15c7 <main+0x417>
add    %eax,%ecx
movslq %ecx,%rax
movb   $0x0,0x130(%rsp,%rax,1)
test   %r12d,%r12d
jle    1540 <main+0x390>
mov    %r14,%rdi
lea    0xb1c(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xe77(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %r12d,%r12d
jmp    1540 <main+0x390>
lea    0xe6a(%rip),%rdi
mov    %rbp,%rsi
mov    $0xf,%edx
call   1030 <strncmp@plt>
movb   $0x0,0x130(%rsp)
test   %rax,%rax
je     167d <main+0x4cd>
mov    %r12,(%rsp)
lea    0xe9d(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
xor    %r12d,%r12d
test   %rax,%rax
je     1754 <main+0x5a4>
xor    %r15d,%r15d
jmp    179b <main+0x5eb>
mov    %r15,%rdi
lea    0xe2a(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0xf,%ecx
xor    %eax,%eax
jmp    16c5 <main+0x515>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0xd,%bl
jne    173e <main+0x58e>
cmpb   $0xa,0x41(%rsp,%rax,1)
je     1e4a <main+0xc9a>
mov    %ebx,%edx
mov    %dl,0x13b(%rsp,%rax,1)
add    $0x2,%rcx
add    $0x2,%rax
movzbl 0x3f(%rsp,%rax,1),%edx
cmp    $0x2e,%dl
jg     16e0 <main+0x530>
cmp    $0xd,%dl
jne    16f1 <main+0x541>
cmpb   $0xa,0x40(%rsp,%rax,1)
jne    1702 <main+0x552>
jmp    1e45 <main+0xc95>
mov    $0x5c,%bl
cmp    $0x2f,%dl
je     1704 <main+0x554>
cmp    $0x7d,%dl
jne    1702 <main+0x552>
jmp    1bfd <main+0xa4d>
test   %dl,%dl
je     1bfd <main+0xa4d>
cmp    $0xa,%dl
je     1bfd <main+0xa4d>
mov    %edx,%ebx
mov    %bl,0x13a(%rsp,%rax,1)
cmp    $0xf0,%rax
je     1e5f <main+0xcaf>
lea    0x1(%rcx),%rsi
movzbl 0x40(%rsp,%rax,1),%ebx
cmp    $0x2e,%bl
jle    16a0 <main+0x4f0>
mov    $0x5c,%dl
cmp    $0x2f,%bl
je     16b6 <main+0x506>
cmp    $0x7d,%bl
jne    16b4 <main+0x504>
jmp    1e51 <main+0xca1>
test   %bl,%bl
je     1e51 <main+0xca1>
cmp    $0xa,%bl
jne    16b4 <main+0x504>
jmp    1e51 <main+0xca1>
mov    (%rsp),%rax
test   %eax,%eax
jle    177c <main+0x5cc>
mov    %r14,%rdi
lea    0x9ca(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xd25(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
mov    %r15,%rdi
lea    0xd76(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x6,%r15d
mov    $0x4,%r12d
lea    0xd63(%rip),%rdi
mov    %rbp,%rsi
mov    $0x9,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    17df <main+0x62f>
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xd41(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x9,%r15d
mov    $0x8,%r12d
lea    0xd68(%rip),%rdi
mov    %rbp,%rsi
mov    $0x8,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    1844 <main+0x694>
mov    (%rsp),%rax
test   %eax,%eax
jle    1820 <main+0x670>
mov    %r14,%rdi
lea    0x926(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xc81(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xce5(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x8,%r15d
mov    $0xe,%r12d
lea    0xcdc(%rip),%rdi
mov    %rbp,%rsi
mov    $0xb,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    18a9 <main+0x6f9>
mov    (%rsp),%rax
test   %eax,%eax
jle    1885 <main+0x6d5>
mov    %r14,%rdi
lea    0x8c1(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xc1c(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xc9b(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0xb,%r15d
mov    $0x11,%r12d
lea    0xc95(%rip),%rdi
mov    %rbp,%rsi
mov    $0x11,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    190e <main+0x75e>
mov    (%rsp),%rax
test   %eax,%eax
jle    18ea <main+0x73a>
mov    %r14,%rdi
lea    0x85c(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xbb7(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xc5a(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x11,%r15d
mov    $0x15,%r12d
lea    0xc58(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
movl   $0x0,0xc(%rsp)
test   %rax,%rax
jne    1983 <main+0x7d3>
mov    (%rsp),%rax
test   %eax,%eax
jle    1957 <main+0x7a7>
mov    %r14,%rdi
lea    0x7ef(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xb4a(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xc0a(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x6,%r15d
movl   $0x1,0xc(%rsp)
mov    $0x5,%r12d
lea    0xbf0(%rip),%rdi
mov    %rbp,%rsi
mov    $0x4,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
mov    %ebx,0x8(%rsp)
jne    19ec <main+0x83c>
mov    (%rsp),%rax
test   %eax,%eax
jle    19c8 <main+0x818>
mov    %r14,%rdi
lea    0x77e(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xad9(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0xba4(%rip),%rsi
call   10b0 <strcat@plt>
mov    $0x4,%r15d
mov    $0x5,%r12d
lea    0xb92(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1b5a <main+0x9aa>
test   %r15d,%r15d
mov    0x8(%rsp),%ebx
jne    1a8c <main+0x8dc>
cmp    $0x1,%ebx
je     1a8c <main+0x8dc>
mov    (%rsp),%r12
test   %r12d,%r12d
jle    1a41 <main+0x891>
mov    %r14,%rdi
lea    0x706(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0xa61(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %r12d,%r12d
mov    0x30(%rsp),%al
test   %al,%al
lea    0x30(%rsp),%rbp
mov    0x10(%rsp),%r13
lea    0x130(%rsp),%r15
je     1a7d <main+0x8cd>
cmp    $0xa,%al
je     1a7d <main+0x8cd>
cmp    $0xd,%al
jne    154d <main+0x39d>
cmpb   $0xa,0x31(%rsp)
jne    154d <main+0x39d>
cmpb   $0x0,0x32(%rsp)
jne    154d <main+0x39d>
mov    %r14,%rdi
lea    0x672(%rip),%rsi
jmp    1546 <main+0x396>
test   %r15d,%r15d
jne    1c4f <main+0xa9f>
mov    $0x7,%r15d
mov    0x10(%rsp),%r13
jmp    1ac1 <main+0x911>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x8,%r15
cmp    $0x107,%r15
je     1eb3 <main+0xd03>
movzbl 0x29(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1ad3 <main+0x923>
cmp    $0x9,%al
jne    1ebb <main+0xd0b>
movzbl 0x2a(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1ae5 <main+0x935>
cmp    $0x9,%al
jne    1ec4 <main+0xd14>
movzbl 0x2b(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1af7 <main+0x947>
cmp    $0x9,%al
jne    1ecd <main+0xd1d>
movzbl 0x2c(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1b09 <main+0x959>
cmp    $0x9,%al
jne    1ed6 <main+0xd26>
movzbl 0x2d(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1b1b <main+0x96b>
cmp    $0x9,%al
jne    1edf <main+0xd2f>
movzbl 0x2e(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1b2d <main+0x97d>
cmp    $0x9,%al
jne    1ee8 <main+0xd38>
movzbl 0x2f(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1b3f <main+0x98f>
cmp    $0x9,%al
jne    1ef1 <main+0xd41>
movzbl 0x30(%rsp,%r15,1),%eax
cmp    $0x20,%al
je     1ab0 <main+0x900>
cmp    $0x9,%al
je     1ab0 <main+0x900>
jmp    1c42 <main+0xa92>
lea    0x36(%rsp),%rdi
lea    0xa26(%rip),%rsi
call   10d0 <strstr@plt>
test   %rax,%rax
je     1a09 <main+0x859>
mov    %rax,%r13
mov    %rax,%rbx
lea    0x30(%rsp),%rax
sub    %rax,%rbx
cmp    $0xff,%rbx
jg     1a09 <main+0x859>
mov    (%rsp),%rax
test   %eax,%eax
jle    1bb7 <main+0xa07>
mov    %r14,%rdi
lea    0x58f(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0x8ea(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %eax,%eax
mov    %rax,(%rsp)
lea    0x130(%rsp),%rdi
lea    0x9c6(%rip),%rsi
call   10b0 <strcat@plt>
cmp    $0x7,%rbx
jl     1c06 <main+0xa56>
mov    %r13,%rdx
add    0x28(%rsp),%rdx
lea    0x142(%rsp),%rdi
lea    0x36(%rsp),%rsi
call   1090 <memcpy@plt>
mov    0x20(%rsp),%rax
lea    (%rax,%r13,1),%r12d
mov    %ebx,%r15d
jmp    1c12 <main+0xa62>
add    $0xf,%rax
jmp    1e4e <main+0xc9e>
mov    $0x6,%r15d
mov    $0x12,%r12d
mov    0x10(%rsp),%r13
mov    0x8(%rsp),%ebx
mov    %r12d,%eax
add    $0x1,%r12d
movb   $0x0,0x130(%rsp,%rax,1)
lea    0x130(%rsp),%rdi
lea    0x939(%rip),%rsi
call   10b0 <strcat@plt>
add    $0x3,%r15d
cmp    $0xff,%r15d
jg     1df9 <main+0xc49>
movslq %r15d,%r13
neg    %r13
mov    %r15d,%r14d
jmp    1c86 <main+0xad6>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
cmpl   $0x0,0xc(%rsp)
setle  %al
add    $0xffffffff,%r12d
mov    %eax,0xc(%rsp)
lea    0x1(%r14),%eax
cmp    $0xff,%r14d
mov    %eax,%r14d
jge    1deb <main+0xc3b>
movslq %r14d,%rbx
movzbl 0x30(%rsp,%rbx,1),%eax
cmp    $0x25,%rax
ja     1cc0 <main+0xb10>
lea    0x365(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x30(%rsp),%rax
cmpb   $0xa,0x1(%rbx,%rax,1)
jne    1cf0 <main+0xb40>
jmp    1dda <main+0xc2a>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x3e,%al
jne    1cf0 <main+0xb40>
xor    %eax,%eax
lea    0x30(%rsp),%rcx
cmpb   $0x20,-0x1(%rbx,%rcx,1)
sete   %al
sub    %eax,%r12d
sub    %r15d,%ebx
add    %r12d,%ebx
movslq %ebx,%rax
movb   $0x3e,0x130(%rsp,%rax,1)
3e
jmp    1c72 <main+0xac2>
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rbp
add    $0x30,%rbp
lea    0x8a4(%rip),%rdi
mov    %rbp,%rsi
mov    $0x9,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1d84 <main+0xbd4>
lea    0x7ed(%rip),%rdi
mov    %rbp,%rsi
mov    $0x9,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1da1 <main+0xbf1>
movzbl 0x0(%rbp),%eax
lea    (%r14,%r12,1),%ecx
sub    %r15d,%ecx
movslq %ecx,%rcx
cmp    $0x2f,%al
jne    1dce <main+0xc1e>
movb   $0x5c,0x130(%rsp,%rcx,1)
5c
jmp    1c72 <main+0xac2>
nopl   (%rax)
cmpl   $0x1,0xc(%rsp)
jne    1d6c <main+0xbbc>
lea    (%r14,%r12,1),%eax
sub    %r15d,%eax
cltq
movb   $0x25,0x130(%rsp,%rax,1)
25
add    $0x1,%r12d
mov    %r14d,%eax
sub    %r15d,%eax
add    %r12d,%eax
cltq
movb   $0x25,0x130(%rsp,%rax,1)
25
jmp    1c72 <main+0xac2>
movslq %r12d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x130,%rdi
add    %r13,%rdi
add    %rbx,%rdi
lea    0x80e(%rip),%rsi
jmp    1dbc <main+0xc0c>
movslq %r12d,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x130,%rdi
add    %r13,%rdi
add    %rbx,%rdi
lea    0x753(%rip),%rsi
call   1040 <strcpy@plt>
add    $0xffffffff,%r12d
add    $0x8,%r14d
jmp    1c72 <main+0xac2>
mov    %al,0x130(%rsp,%rcx,1)
jmp    1c72 <main+0xac2>
add    %r12d,%r14d
sub    %r15d,%r14d
movslq %r14d,%rax
movb   $0x0,0x130(%rsp,%rax,1)
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x8(%rsp),%ebx
mov    (%rsp),%r12
cmp    $0x1,%r12d
jne    1e26 <main+0xc76>
cmp    $0x1,%ebx
je     1e26 <main+0xc76>
mov    %r14,%rdi
lea    0x7a4(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0x79e(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0x130(%rsp),%r15
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
mov    %eax,%ebx
lea    0x30(%rsp),%rbp
jmp    154d <main+0x39d>
mov    %rcx,%rsi
jmp    1e51 <main+0xca1>
add    $0x10,%rax
mov    %rax,%rsi
add    $0xfffffffb,%esi
movslq %esi,%rax
movb   $0x0,0x130(%rsp,%rax,1)
test   %r12d,%r12d
jle    1e85 <main+0xcd5>
mov    %r14,%rdi
lea    0x2c2(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0x61d(%rip),%rsi
call   1080 <f_outputLine@plt>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r15,%rsi
call   1080 <f_outputLine@plt>
cmp    $0x1,%eax
jne    1ea4 <main+0xcf4>
mov    %r14,%rdi
lea    0x25a(%rip),%rsi
call   1080 <f_outputLine@plt>
mov    %r14,%rdi
lea    0x60e(%rip),%rsi
jmp    1546 <main+0x396>
xor    %r15d,%r15d
jmp    1c4f <main+0xa9f>
add    $0xfffffffffffffff9,%r15
jmp    1c42 <main+0xa92>
add    $0xfffffffffffffffa,%r15
jmp    1c42 <main+0xa92>
add    $0xfffffffffffffffb,%r15
jmp    1c42 <main+0xa92>
add    $0xfffffffffffffffc,%r15
jmp    1c42 <main+0xa92>
add    $0xfffffffffffffffd,%r15
jmp    1c42 <main+0xa92>
add    $0xfffffffffffffffe,%r15
jmp    1c42 <main+0xa92>
add    $0xffffffffffffffff,%r15
jmp    1c42 <main+0xa92>

LLVM IR (-O0):
@.str = [67 x i8] c"MkWinTesto: needs a single parameter, the (testo) file to convert\0A\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [28 x i8] c"MkWinTesto: %s for reading\0A\00"
@.str.3 = [13 x i8] c"wintesto.cmd\00"
@.str.4 = [3 x i8] c"wb\00"
@.str.5 = [38 x i8] c"MkWinTesto: wintesto.cmd for writing\0A\00"
@.str.6 = [10 x i8] c"@echo off\00"
@.str.7 = [4 x i8] c"REM\00"
@.str.8 = [68 x i8] c"REM Simple Windows NT/2000/XP .cmd version of GPSBabel testo script\00"
@.str.9 = [1 x i8] zeroinitializer
@.str.10 = [27 x i8] c"SET GPSBABEL_FREEZE_TIME=y\00"
@.str.11 = [27 x i8] c"SET TMPDIR=%TEMP%\\WINTESTO\00"
@.str.12 = [22 x i8] c"MKDIR %TMPDIR% 2>NUL:\00"
@.str.13 = [16 x i8] c"GOTO :REALSTART\00"
@.str.14 = [39 x i8] c"REM ==================================\00"
@.str.15 = [15 x i8] c":CommonCOMPARE\00"
@.str.16 = [14 x i8] c"SET PARAM1=%2\00"
@.str.17 = [14 x i8] c"SET PARAM2=%3\00"
@.str.18 = [80 x i8] c"REM Test if param3 was a dir rather than a file, if so add a \\* to make fc work\00"
@.str.19 = [59 x i8] c"FOR %%A IN (%3) DO IF \22d--------\22==\22%%~aA\22 SET PARAM2=%3\\*\00"
@.str.20 = [107 x i8] c"FOR /f \22delims=\22 %%a IN ('fc %PARAM1% %PARAM2%') DO IF \22x%%a\22==\22xFC: no differences encountered\22 GOTO :EOF\00"
@.str.21 = [41 x i8] c"REM Show the first 5 lines of difference\00"
@.str.22 = [29 x i8] c"fc %1 /LB5 %PARAM1% %PARAM2%\00"
@.str.23 = [103 x i8] c"if errorlevel 1 ECHO %* are not the same (first 5 differences above) - pausing. ^C to quit if required\00"
@.str.24 = [22 x i8] c"if errorlevel 1 PAUSE\00"
@.str.25 = [10 x i8] c"GOTO :EOF\00"
@.str.26 = [9 x i8] c":COMPARE\00"
@.str.27 = [29 x i8] c"CALL :CommonCOMPARE /L %1 %2\00"
@.str.28 = [12 x i8] c":BINCOMPARE\00"
@.str.29 = [29 x i8] c"CALL :CommonCOMPARE /B %1 %2\00"
@.str.30 = [16 x i8] c":SORTandCOMPARE\00"
@.str.31 = [22 x i8] c"SORT <%1 >%TMPDIR%\\s1\00"
@.str.32 = [22 x i8] c"SORT <%2 >%TMPDIR%\\s2\00"
@.str.33 = [38 x i8] c"CALL :COMPARE %TMPDIR%\\s1 %TMPDIR%\\s2\00"
@.str.34 = [11 x i8] c":REALSTART\00"
@.str.35 = [2 x i8] c" \00"
@.str.36 = [7 x i8] c"@echo.\00"
@.str.37 = [16 x i8] c"PNAME=${PNAME:-\00"
@.str.38 = [11 x i8] c"SET PNAME=\00"
@.str.39 = [61 x i8] c"IF NOT EXIST %PNAME%.EXE ECHO Can't find %PNAME%&& GOTO :EOF\00"
@.str.40 = [7 x i8] c"rm -f \00"
@.str.41 = [5 x i8] c"DEL \00"
@.str.42 = [10 x i8] c"${PNAME} \00"
@.str.43 = [9 x i8] c"%PNAME% \00"
@.str.44 = [9 x i8] c"compare \00"
@.str.45 = [15 x i8] c"CALL :COMPARE \00"
@.str.46 = [12 x i8] c"bincompare \00"
@.str.47 = [18 x i8] c"CALL :BINCOMPARE \00"
@.str.48 = [18 x i8] c"sort_and_compare \00"
@.str.49 = [22 x i8] c"CALL :SORTandCOMPARE \00"
@.str.50 = [7 x i8] c"echo \22\00"
@.str.51 = [6 x i8] c"ECHO \00"
@.str.52 = [5 x i8] c"cat \00"
@.str.53 = [6 x i8] c"TYPE \00"
@.str.54 = [7 x i8] c"sed '/\00"
@.str.55 = [4 x i8] c"/d'\00"
@.str.56 = [19 x i8] c"FINDSTR /V /R /C:\22\00"
@.str.57 = [2 x i8] c"\22\00"
@.str.58 = [10 x i8] c"${TMPDIR}\00"
@.str.59 = [9 x i8] c"%TMPDIR%\00"
@.str.60 = [9 x i8] c"@echo on\00"
@.str.61 = [17 x i8] c"@echo Testing...\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [256 x i8]
%7 = alloca [256 x i8]
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32*
%17 = alloca i32*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %14
store i32 0, i32* %15
%18 = load i32, i32* %4
%19 = icmp slt i32 %18, 2
br i1 %19, label %20, label %22
20: ; preds = %2
%21 = call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str, i64 0, i64 0))
br label %22
22: ; preds = %20, %2
%23 = load i8**, i8*** %5
%24 = getelementptr inbounds i8*, i8** %23, i64 1
%25 = load i8*, i8** %24
%26 = call i32* @fopen(i8* %25, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %26, i32** %16
%27 = load i32*, i32** %16
%28 = icmp eq i32* %27, null
br i1 %28, label %29, label %34
29: ; preds = %22
%30 = load i8**, i8*** %5
%31 = getelementptr inbounds i8*, i8** %30, i64 1
%32 = load i8*, i8** %31
%33 = call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0), i8* %32)
br label %805
34: ; preds = %22
%35 = call i32* @fopen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
store i32* %35, i32** %17
%36 = load i32*, i32** %17
%37 = icmp eq i32* %36, null
br i1 %37, label %38, label %40
38: ; preds = %34
%39 = call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0))
br label %804
40: ; preds = %34
%41 = load i32*, i32** %17
%42 = call i32 @f_outputLine(i32* %41, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%43 = load i32*, i32** %17
%44 = call i32 @f_outputLine(i32* %43, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%45 = load i32*, i32** %17
%46 = call i32 @f_outputLine(i32* %45, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0))
%47 = load i32*, i32** %17
%48 = call i32 @f_outputLine(i32* %47, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%49 = load i32*, i32** %17
%50 = call i32 @f_outputLine(i32* %49, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%51 = load i32*, i32** %17
%52 = call i32 @f_outputLine(i32* %51, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0))
%53 = load i32*, i32** %17
%54 = call i32 @f_outputLine(i32* %53, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0))
%55 = load i32*, i32** %17
%56 = call i32 @f_outputLine(i32* %55, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%57 = load i32*, i32** %17
%58 = call i32 @f_outputLine(i32* %57, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%59 = load i32*, i32** %17
%60 = call i32 @f_outputLine(i32* %59, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.13, i64 0, i64 0))
%61 = load i32*, i32** %17
%62 = call i32 @f_outputLine(i32* %61, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%63 = load i32*, i32** %17
%64 = call i32 @f_outputLine(i32* %63, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%65 = load i32*, i32** %17
%66 = call i32 @f_outputLine(i32* %65, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%67 = load i32*, i32** %17
%68 = call i32 @f_outputLine(i32* %67, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.15, i64 0, i64 0))
%69 = load i32*, i32** %17
%70 = call i32 @f_outputLine(i32* %69, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.16, i64 0, i64 0))
%71 = load i32*, i32** %17
%72 = call i32 @f_outputLine(i32* %71, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.17, i64 0, i64 0))
%73 = load i32*, i32** %17
%74 = call i32 @f_outputLine(i32* %73, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.18, i64 0, i64 0))
%75 = load i32*, i32** %17
%76 = call i32 @f_outputLine(i32* %75, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.19, i64 0, i64 0))
%77 = load i32*, i32** %17
%78 = call i32 @f_outputLine(i32* %77, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.20, i64 0, i64 0))
%79 = load i32*, i32** %17
%80 = call i32 @f_outputLine(i32* %79, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0))
%81 = load i32*, i32** %17
%82 = call i32 @f_outputLine(i32* %81, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.22, i64 0, i64 0))
%83 = load i32*, i32** %17
%84 = call i32 @f_outputLine(i32* %83, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.23, i64 0, i64 0))
%85 = load i32*, i32** %17
%86 = call i32 @f_outputLine(i32* %85, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.24, i64 0, i64 0))
%87 = load i32*, i32** %17
%88 = call i32 @f_outputLine(i32* %87, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%89 = load i32*, i32** %17
%90 = call i32 @f_outputLine(i32* %89, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%91 = load i32*, i32** %17
%92 = call i32 @f_outputLine(i32* %91, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%93 = load i32*, i32** %17
%94 = call i32 @f_outputLine(i32* %93, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%95 = load i32*, i32** %17
%96 = call i32 @f_outputLine(i32* %95, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.26, i64 0, i64 0))
%97 = load i32*, i32** %17
%98 = call i32 @f_outputLine(i32* %97, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.27, i64 0, i64 0))
%99 = load i32*, i32** %17
%100 = call i32 @f_outputLine(i32* %99, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%101 = load i32*, i32** %17
%102 = call i32 @f_outputLine(i32* %101, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%103 = load i32*, i32** %17
%104 = call i32 @f_outputLine(i32* %103, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%105 = load i32*, i32** %17
%106 = call i32 @f_outputLine(i32* %105, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%107 = load i32*, i32** %17
%108 = call i32 @f_outputLine(i32* %107, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.28, i64 0, i64 0))
%109 = load i32*, i32** %17
%110 = call i32 @f_outputLine(i32* %109, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.29, i64 0, i64 0))
%111 = load i32*, i32** %17
%112 = call i32 @f_outputLine(i32* %111, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%113 = load i32*, i32** %17
%114 = call i32 @f_outputLine(i32* %113, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%115 = load i32*, i32** %17
%116 = call i32 @f_outputLine(i32* %115, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%117 = load i32*, i32** %17
%118 = call i32 @f_outputLine(i32* %117, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%119 = load i32*, i32** %17
%120 = call i32 @f_outputLine(i32* %119, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.30, i64 0, i64 0))
%121 = load i32*, i32** %17
%122 = call i32 @f_outputLine(i32* %121, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.31, i64 0, i64 0))
%123 = load i32*, i32** %17
%124 = call i32 @f_outputLine(i32* %123, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.32, i64 0, i64 0))
%125 = load i32*, i32** %17
%126 = call i32 @f_outputLine(i32* %125, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.33, i64 0, i64 0))
%127 = load i32*, i32** %17
%128 = call i32 @f_outputLine(i32* %127, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%129 = load i32*, i32** %17
%130 = call i32 @f_outputLine(i32* %129, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%131 = load i32*, i32** %17
%132 = call i32 @f_outputLine(i32* %131, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%133 = load i32*, i32** %17
%134 = call i32 @f_outputLine(i32* %133, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%135 = load i32*, i32** %17
%136 = call i32 @f_outputLine(i32* %135, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.34, i64 0, i64 0))
%137 = load i32*, i32** %17
%138 = call i32 @f_outputLine(i32* %137, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
br label %139
139: ; preds = %798, %40
%140 = load i32*, i32** %16
%141 = call i32 @feof(i32* %140)
%142 = icmp ne i32 %141, 0
%143 = xor i1 %142, true
br i1 %143, label %144, label %799
144: ; preds = %139
%145 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%146 = load i32*, i32** %16
%147 = call i32 @fgets(i8* %145, i32 255, i32* %146)
%148 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%149 = load i8, i8* %148
%150 = sext i8 %149 to i32
%151 = icmp eq i32 %150, 35
br i1 %151, label %152, label %231
152: ; preds = %144
%153 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
store i8 0, i8* %153
%154 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%155 = call i32 @strcat(i8* %154, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
store i32 3, i32* %11
%156 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 1
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
%159 = icmp ne i32 %158, 32
br i1 %159, label %160, label %165
160: ; preds = %152
%161 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%162 = call i32 @strcat(i8* %161, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.35, i64 0, i64 0))
%163 = load i32, i32* %11
%164 = add nsw i32 %163, 1
store i32 %164, i32* %11
br label %165
165: ; preds = %160, %152
store i32 1, i32* %9
br label %166
166: ; preds = %216, %165
%167 = load i32, i32* %9
%168 = icmp slt i32 %167, 256
br i1 %168, label %169, label %219
169: ; preds = %166
%170 = load i32, i32* %9
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %171
%173 = load i8, i8* %172
%174 = sext i8 %173 to i32
%175 = icmp eq i32 %174, 0
br i1 %175, label %198, label %176
176: ; preds = %169
%177 = load i32, i32* %9
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %178
%180 = load i8, i8* %179
%181 = sext i8 %180 to i32
%182 = icmp eq i32 %181, 10
br i1 %182, label %198, label %183
183: ; preds = %176
%184 = load i32, i32* %9
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %185
%187 = load i8, i8* %186
%188 = sext i8 %187 to i32
%189 = icmp eq i32 %188, 13
br i1 %189, label %190, label %205
190: ; preds = %183
%191 = load i32, i32* %9
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %193
%195 = load i8, i8* %194
%196 = sext i8 %195 to i32
%197 = icmp eq i32 %196, 10
br i1 %197, label %198, label %205
198: ; preds = %190, %176, %169
%199 = load i32, i32* %9
%200 = load i32, i32* %11
%201 = add nsw i32 %199, %200
%202 = sub nsw i32 %201, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %203
store i8 0, i8* %204
br label %219
205: ; preds = %190, %183
%206 = load i32, i32* %9
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %207
%209 = load i8, i8* %208
%210 = load i32, i32* %9
%211 = load i32, i32* %11
%212 = add nsw i32 %210, %211
%213 = sub nsw i32 %212, 1
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %214
store i8 %209, i8* %215
br label %216
216: ; preds = %205
%217 = load i32, i32* %9
%218 = add nsw i32 %217, 1
store i32 %218, i32* %9
br label %166
219: ; preds = %198, %166
%220 = load i32, i32* %15
%221 = icmp sgt i32 %220, 0
br i1 %221, label %222, label %227
222: ; preds = %219
%223 = load i32*, i32** %17
%224 = call i32 @f_outputLine(i32* %223, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%225 = load i32*, i32** %17
%226 = call i32 @f_outputLine(i32* %225, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %227
227: ; preds = %222, %219
%228 = load i32*, i32** %17
%229 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%230 = call i32 @f_outputLine(i32* %228, i8* %229)
store i32 %230, i32* %14
br label %798
231: ; preds = %144
%232 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%233 = call i64 @strncmp(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.37, i64 0, i64 0), i8* %232, i32 15)
%234 = icmp eq i64 %233, 0
br i1 %234, label %235, label %328
235: ; preds = %231
%236 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
store i8 0, i8* %236
%237 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%238 = call i32 @strcat(i8* %237, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.38, i64 0, i64 0))
store i32 15, i32* %9
br label %239
239: ; preds = %305, %235
%240 = load i32, i32* %9
%241 = icmp slt i32 %240, 256
br i1 %241, label %242, label %308
242: ; preds = %239
%243 = load i32, i32* %9
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %244
%246 = load i8, i8* %245
%247 = sext i8 %246 to i32
%248 = icmp eq i32 %247, 125
br i1 %248, label %278, label %249
249: ; preds = %242
%250 = load i32, i32* %9
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %251
%253 = load i8, i8* %252
%254 = sext i8 %253 to i32
%255 = icmp eq i32 %254, 0
br i1 %255, label %278, label %256
256: ; preds = %249
%257 = load i32, i32* %9
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %258
%260 = load i8, i8* %259
%261 = sext i8 %260 to i32
%262 = icmp eq i32 %261, 10
br i1 %262, label %278, label %263
263: ; preds = %256
%264 = load i32, i32* %9
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %265
%267 = load i8, i8* %266
%268 = sext i8 %267 to i32
%269 = icmp eq i32 %268, 13
br i1 %269, label %270, label %283
270: ; preds = %263
%271 = load i32, i32* %9
%272 = add nsw i32 %271, 1
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %273
%275 = load i8, i8* %274
%276 = sext i8 %275 to i32
%277 = icmp eq i32 %276, 10
br i1 %277, label %278, label %283
278: ; preds = %270, %256, %249, %242
%279 = load i32, i32* %9
%280 = sub nsw i32 %279, 5
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %281
store i8 0, i8* %282
br label %308
283: ; preds = %270, %263
%284 = load i32, i32* %9
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %285
%287 = load i8, i8* %286
%288 = sext i8 %287 to i32
%289 = icmp eq i32 %288, 47
br i1 %289, label %290, label %295
290: ; preds = %283
%291 = load i32, i32* %9
%292 = sub nsw i32 %291, 5
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %293
store i8 92, i8* %294
br label %304
295: ; preds = %283
%296 = load i32, i32* %9
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %297
%299 = load i8, i8* %298
%300 = load i32, i32* %9
%301 = sub nsw i32 %300, 5
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %302
store i8 %299, i8* %303
br label %304
304: ; preds = %295, %290
br label %305
305: ; preds = %304
%306 = load i32, i32* %9
%307 = add nsw i32 %306, 1
store i32 %307, i32* %9
br label %239
308: ; preds = %278, %239
%309 = load i32, i32* %15
%310 = icmp sgt i32 %309, 0
br i1 %310, label %311, label %316
311: ; preds = %308
%312 = load i32*, i32** %17
%313 = call i32 @f_outputLine(i32* %312, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%314 = load i32*, i32** %17
%315 = call i32 @f_outputLine(i32* %314, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %316
316: ; preds = %311, %308
%317 = load i32*, i32** %17
%318 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%319 = call i32 @f_outputLine(i32* %317, i8* %318)
store i32 %319, i32* %14
%320 = load i32, i32* %14
%321 = icmp eq i32 %320, 1
br i1 %321, label %322, label %325
322: ; preds = %316
%323 = load i32*, i32** %17
%324 = call i32 @f_outputLine(i32* %323, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
br label %325
325: ; preds = %322, %316
%326 = load i32*, i32** %17
%327 = call i32 @f_outputLine(i32* %326, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.39, i64 0, i64 0))
store i32 %327, i32* %14
br label %797
328: ; preds = %231
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %13
%329 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
store i8 0, i8* %329
%330 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%331 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.40, i64 0, i64 0), i8* %330, i32 6)
%332 = icmp eq i64 %331, 0
br i1 %332, label %333, label %344
333: ; preds = %328
%334 = load i32, i32* %15
%335 = icmp sgt i32 %334, 0
br i1 %335, label %336, label %341
336: ; preds = %333
%337 = load i32*, i32** %17
%338 = call i32 @f_outputLine(i32* %337, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%339 = load i32*, i32** %17
%340 = call i32 @f_outputLine(i32* %339, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %341
341: ; preds = %336, %333
store i32 6, i32* %10
%342 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%343 = call i32 @strcat(i8* %342, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.41, i64 0, i64 0))
store i32 4, i32* %11
br label %344
344: ; preds = %341, %328
%345 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%346 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.42, i64 0, i64 0), i8* %345, i32 9)
%347 = icmp eq i64 %346, 0
br i1 %347, label %348, label %353
348: ; preds = %344
store i32 9, i32* %10
%349 = load i32, i32* %15
%350 = add nsw i32 %349, 1
store i32 %350, i32* %15
%351 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%352 = call i32 @strcat(i8* %351, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
store i32 8, i32* %11
br label %353
353: ; preds = %348, %344
%354 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%355 = call i64 @strncmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.44, i64 0, i64 0), i8* %354, i32 8)
%356 = icmp eq i64 %355, 0
br i1 %356, label %357, label %368
357: ; preds = %353
%358 = load i32, i32* %15
%359 = icmp sgt i32 %358, 0
br i1 %359, label %360, label %365
360: ; preds = %357
%361 = load i32*, i32** %17
%362 = call i32 @f_outputLine(i32* %361, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%363 = load i32*, i32** %17
%364 = call i32 @f_outputLine(i32* %363, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %365
365: ; preds = %360, %357
store i32 8, i32* %10
%366 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%367 = call i32 @strcat(i8* %366, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.45, i64 0, i64 0))
store i32 14, i32* %11
br label %368
368: ; preds = %365, %353
%369 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%370 = call i64 @strncmp(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.46, i64 0, i64 0), i8* %369, i32 11)
%371 = icmp eq i64 %370, 0
br i1 %371, label %372, label %383
372: ; preds = %368
%373 = load i32, i32* %15
%374 = icmp sgt i32 %373, 0
br i1 %374, label %375, label %380
375: ; preds = %372
%376 = load i32*, i32** %17
%377 = call i32 @f_outputLine(i32* %376, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%378 = load i32*, i32** %17
%379 = call i32 @f_outputLine(i32* %378, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %380
380: ; preds = %375, %372
store i32 11, i32* %10
%381 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%382 = call i32 @strcat(i8* %381, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.47, i64 0, i64 0))
store i32 17, i32* %11
br label %383
383: ; preds = %380, %368
%384 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%385 = call i64 @strncmp(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.48, i64 0, i64 0), i8* %384, i32 17)
%386 = icmp eq i64 %385, 0
br i1 %386, label %387, label %398
387: ; preds = %383
%388 = load i32, i32* %15
%389 = icmp sgt i32 %388, 0
br i1 %389, label %390, label %395
390: ; preds = %387
%391 = load i32*, i32** %17
%392 = call i32 @f_outputLine(i32* %391, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%393 = load i32*, i32** %17
%394 = call i32 @f_outputLine(i32* %393, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %395
395: ; preds = %390, %387
store i32 17, i32* %10
%396 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%397 = call i32 @strcat(i8* %396, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.49, i64 0, i64 0))
store i32 21, i32* %11
br label %398
398: ; preds = %395, %383
%399 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%400 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.50, i64 0, i64 0), i8* %399, i32 6)
%401 = icmp eq i64 %400, 0
br i1 %401, label %402, label %413
402: ; preds = %398
%403 = load i32, i32* %15
%404 = icmp sgt i32 %403, 0
br i1 %404, label %405, label %410
405: ; preds = %402
%406 = load i32*, i32** %17
%407 = call i32 @f_outputLine(i32* %406, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%408 = load i32*, i32** %17
%409 = call i32 @f_outputLine(i32* %408, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %410
410: ; preds = %405, %402
store i32 6, i32* %10
%411 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%412 = call i32 @strcat(i8* %411, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.51, i64 0, i64 0))
store i32 5, i32* %11
store i32 1, i32* %12
store i32 1, i32* %13
br label %413
413: ; preds = %410, %398
%414 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%415 = call i64 @strncmp(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0), i8* %414, i32 4)
%416 = icmp eq i64 %415, 0
br i1 %416, label %417, label %428
417: ; preds = %413
%418 = load i32, i32* %15
%419 = icmp sgt i32 %418, 0
br i1 %419, label %420, label %425
420: ; preds = %417
%421 = load i32*, i32** %17
%422 = call i32 @f_outputLine(i32* %421, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%423 = load i32*, i32** %17
%424 = call i32 @f_outputLine(i32* %423, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %425
425: ; preds = %420, %417
store i32 4, i32* %10
%426 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%427 = call i32 @strcat(i8* %426, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0))
store i32 5, i32* %11
br label %428
428: ; preds = %425, %413
%429 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%430 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.54, i64 0, i64 0), i8* %429, i32 6)
%431 = icmp eq i64 %430, 0
br i1 %431, label %432, label %488
432: ; preds = %428
%433 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%434 = getelementptr inbounds i8, i8* %433, i64 6
%435 = call i8* @strstr(i8* %434, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0))
store i8* %435, i8** %8
%436 = load i8*, i8** %8
%437 = icmp ne i8* %436, null
br i1 %437, label %438, label %487
438: ; preds = %432
%439 = load i8*, i8** %8
%440 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%441 = ptrtoint i8* %439 to i64
%442 = ptrtoint i8* %440 to i64
%443 = sub i64 %441, %442
%444 = icmp slt i64 %443, 256
br i1 %444, label %445, label %487
445: ; preds = %438
%446 = load i32, i32* %15
%447 = icmp sgt i32 %446, 0
br i1 %447, label %448, label %453
448: ; preds = %445
%449 = load i32*, i32** %17
%450 = call i32 @f_outputLine(i32* %449, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%451 = load i32*, i32** %17
%452 = call i32 @f_outputLine(i32* %451, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %453
453: ; preds = %448, %445
store i32 6, i32* %10
%454 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%455 = call i32 @strcat(i8* %454, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.56, i64 0, i64 0))
store i32 18, i32* %11
store i32 6, i32* %9
br label %456
456: ; preds = %475, %453
%457 = load i32, i32* %9
%458 = sext i32 %457 to i64
%459 = load i8*, i8** %8
%460 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%461 = ptrtoint i8* %459 to i64
%462 = ptrtoint i8* %460 to i64
%463 = sub i64 %461, %462
%464 = icmp slt i64 %458, %463
br i1 %464, label %465, label %478
465: ; preds = %456
%466 = load i32, i32* %10
%467 = add nsw i32 %466, 1
store i32 %467, i32* %10
%468 = sext i32 %466 to i64
%469 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %468
%470 = load i8, i8* %469
%471 = load i32, i32* %11
%472 = add nsw i32 %471, 1
store i32 %472, i32* %11
%473 = sext i32 %471 to i64
%474 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %473
store i8 %470, i8* %474
br label %475
475: ; preds = %465
%476 = load i32, i32* %9
%477 = add nsw i32 %476, 1
store i32 %477, i32* %9
br label %456
478: ; preds = %456
%479 = load i32, i32* %11
%480 = add nsw i32 %479, 1
store i32 %480, i32* %11
%481 = sext i32 %479 to i64
%482 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %481
store i8 0, i8* %482
%483 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%484 = call i32 @strcat(i8* %483, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%485 = load i32, i32* %10
%486 = add nsw i32 %485, 3
store i32 %486, i32* %10
br label %487
487: ; preds = %478, %438, %432
br label %488
488: ; preds = %487, %428
%489 = load i32, i32* %10
%490 = icmp sgt i32 %489, 0
br i1 %490, label %494, label %491
491: ; preds = %488
%492 = load i32, i32* %14
%493 = icmp eq i32 %492, 1
br i1 %493, label %494, label %759
494: ; preds = %491, %488
%495 = load i32, i32* %10
%496 = icmp eq i32 %495, 0
br i1 %496, label %497, label %553
497: ; preds = %494
store i32 0, i32* %9
br label %498
498: ; preds = %549, %497
%499 = load i32, i32* %9
%500 = icmp slt i32 %499, 256
br i1 %500, label %501, label %552
501: ; preds = %498
%502 = load i32, i32* %9
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %503
%505 = load i8, i8* %504
%506 = sext i8 %505 to i32
%507 = icmp eq i32 %506, 0
br i1 %507, label %530, label %508
508: ; preds = %501
%509 = load i32, i32* %9
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %510
%512 = load i8, i8* %511
%513 = sext i8 %512 to i32
%514 = icmp eq i32 %513, 10
br i1 %514, label %530, label %515
515: ; preds = %508
%516 = load i32, i32* %9
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %517
%519 = load i8, i8* %518
%520 = sext i8 %519 to i32
%521 = icmp eq i32 %520, 13
br i1 %521, label %522, label %532
522: ; preds = %515
%523 = load i32, i32* %9
%524 = add nsw i32 %523, 1
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %525
%527 = load i8, i8* %526
%528 = sext i8 %527 to i32
%529 = icmp eq i32 %528, 10
br i1 %529, label %530, label %532
530: ; preds = %522, %508, %501
%531 = load i32, i32* %9
store i32 %531, i32* %10
br label %552
532: ; preds = %522, %515
%533 = load i32, i32* %9
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %534
%536 = load i8, i8* %535
%537 = sext i8 %536 to i32
%538 = icmp ne i32 %537, 32
br i1 %538, label %539, label %548
539: ; preds = %532
%540 = load i32, i32* %9
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %541
%543 = load i8, i8* %542
%544 = sext i8 %543 to i32
%545 = icmp ne i32 %544, 9
br i1 %545, label %546, label %548
546: ; preds = %539
%547 = load i32, i32* %9
store i32 %547, i32* %10
br label %552
548: ; preds = %539, %532
br label %549
549: ; preds = %548
%550 = load i32, i32* %9
%551 = add nsw i32 %550, 1
store i32 %551, i32* %9
br label %498
552: ; preds = %546, %530, %498
br label %553
553: ; preds = %552, %494
%554 = load i32, i32* %10
store i32 %554, i32* %9
br label %555
555: ; preds = %741, %553
%556 = load i32, i32* %9
%557 = icmp slt i32 %556, 256
br i1 %557, label %558, label %744
558: ; preds = %555
%559 = load i32, i32* %9
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %560
%562 = load i8, i8* %561
%563 = sext i8 %562 to i32
%564 = icmp eq i32 %563, 0
br i1 %564, label %587, label %565
565: ; preds = %558
%566 = load i32, i32* %9
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %567
%569 = load i8, i8* %568
%570 = sext i8 %569 to i32
%571 = icmp eq i32 %570, 10
br i1 %571, label %587, label %572
572: ; preds = %565
%573 = load i32, i32* %9
%574 = sext i32 %573 to i64
%575 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %574
%576 = load i8, i8* %575
%577 = sext i8 %576 to i32
%578 = icmp eq i32 %577, 13
br i1 %578, label %579, label %595
579: ; preds = %572
%580 = load i32, i32* %9
%581 = add nsw i32 %580, 1
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %582
%584 = load i8, i8* %583
%585 = sext i8 %584 to i32
%586 = icmp eq i32 %585, 10
br i1 %586, label %587, label %595
587: ; preds = %579, %565, %558
%588 = load i32, i32* %11
%589 = load i32, i32* %9
%590 = add nsw i32 %588, %589
%591 = load i32, i32* %10
%592 = sub nsw i32 %590, %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %593
store i8 0, i8* %594
br label %744
595: ; preds = %579, %572
%596 = load i32, i32* %9
%597 = sext i32 %596 to i64
%598 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %597
%599 = load i8, i8* %598
%600 = sext i8 %599 to i32
%601 = icmp eq i32 %600, 34
br i1 %601, label %602, label %609
602: ; preds = %595
%603 = load i32, i32* %13
%604 = icmp sgt i32 %603, 0
%605 = zext i1 %604 to i64
%606 = select i1 %604, i32 0, i32 1
store i32 %606, i32* %13
%607 = load i32, i32* %11
%608 = add nsw i32 %607, -1
store i32 %608, i32* %11
br label %741
609: ; preds = %595
%610 = load i32, i32* %9
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %611
%613 = load i8, i8* %612
%614 = sext i8 %613 to i32
%615 = icmp eq i32 %614, 37
br i1 %615, label %616, label %637
616: ; preds = %609
%617 = load i32, i32* %13
%618 = icmp eq i32 %617, 1
br i1 %618, label %619, label %629
619: ; preds = %616
%620 = load i32, i32* %11
%621 = load i32, i32* %9
%622 = add nsw i32 %620, %621
%623 = load i32, i32* %10
%624 = sub nsw i32 %622, %623
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %625
store i8 37, i8* %626
%627 = load i32, i32* %11
%628 = add nsw i32 %627, 1
store i32 %628, i32* %11
br label %629
629: ; preds = %619, %616
%630 = load i32, i32* %11
%631 = load i32, i32* %9
%632 = add nsw i32 %630, %631
%633 = load i32, i32* %10
%634 = sub nsw i32 %632, %633
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %635
store i8 37, i8* %636
br label %741
637: ; preds = %609
%638 = load i32, i32* %9
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %639
%641 = load i8, i8* %640
%642 = sext i8 %641 to i32
%643 = icmp eq i32 %642, 62
br i1 %643, label %644, label %663
644: ; preds = %637
%645 = load i32, i32* %9
%646 = sub nsw i32 %645, 1
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %647
%649 = load i8, i8* %648
%650 = sext i8 %649 to i32
%651 = icmp eq i32 %650, 32
br i1 %651, label %652, label %655
652: ; preds = %644
%653 = load i32, i32* %11
%654 = add nsw i32 %653, -1
store i32 %654, i32* %11
br label %655
655: ; preds = %652, %644
%656 = load i32, i32* %11
%657 = load i32, i32* %9
%658 = add nsw i32 %656, %657
%659 = load i32, i32* %10
%660 = sub nsw i32 %658, %659
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %661
store i8 62, i8* %662
br label %741
663: ; preds = %637
%664 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%665 = load i32, i32* %9
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i8, i8* %664, i64 %666
%668 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.58, i64 0, i64 0), i8* %667, i32 9)
%669 = icmp eq i64 %668, 0
br i1 %669, label %670, label %687
670: ; preds = %663
%671 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%672 = load i32, i32* %11
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds i8, i8* %671, i64 %673
%675 = load i32, i32* %9
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds i8, i8* %674, i64 %676
%678 = load i32, i32* %10
%679 = sext i32 %678 to i64
%680 = sub i64 0, %679
%681 = getelementptr inbounds i8, i8* %677, i64 %680
%682 = call i32 @strcpy(i8* %681, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.59, i64 0, i64 0))
%683 = load i32, i32* %11
%684 = add nsw i32 %683, -1
store i32 %684, i32* %11
%685 = load i32, i32* %9
%686 = add nsw i32 %685, 8
store i32 %686, i32* %9
br label %740
687: ; preds = %663
%688 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%689 = load i32, i32* %9
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds i8, i8* %688, i64 %690
%692 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.42, i64 0, i64 0), i8* %691, i32 9)
%693 = icmp eq i64 %692, 0
br i1 %693, label %694, label %711
694: ; preds = %687
%695 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%696 = load i32, i32* %11
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds i8, i8* %695, i64 %697
%699 = load i32, i32* %9
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i8, i8* %698, i64 %700
%702 = load i32, i32* %10
%703 = sext i32 %702 to i64
%704 = sub i64 0, %703
%705 = getelementptr inbounds i8, i8* %701, i64 %704
%706 = call i32 @strcpy(i8* %705, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
%707 = load i32, i32* %11
%708 = add nsw i32 %707, -1
store i32 %708, i32* %11
%709 = load i32, i32* %9
%710 = add nsw i32 %709, 8
store i32 %710, i32* %9
br label %739
711: ; preds = %687
%712 = load i32, i32* %9
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %713
%715 = load i8, i8* %714
%716 = sext i8 %715 to i32
%717 = icmp eq i32 %716, 47
br i1 %717, label %718, label %726
718: ; preds = %711
%719 = load i32, i32* %11
%720 = load i32, i32* %9
%721 = add nsw i32 %719, %720
%722 = load i32, i32* %10
%723 = sub nsw i32 %721, %722
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %724
store i8 92, i8* %725
br label %738
726: ; preds = %711
%727 = load i32, i32* %9
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %728
%730 = load i8, i8* %729
%731 = load i32, i32* %11
%732 = load i32, i32* %9
%733 = add nsw i32 %731, %732
%734 = load i32, i32* %10
%735 = sub nsw i32 %733, %734
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 %736
store i8 %730, i8* %737
br label %738
738: ; preds = %726, %718
br label %739
739: ; preds = %738, %694
br label %740
740: ; preds = %739, %670
br label %741
741: ; preds = %740, %655, %629, %602
%742 = load i32, i32* %9
%743 = add nsw i32 %742, 1
store i32 %743, i32* %9
br label %555
744: ; preds = %587, %555
%745 = load i32, i32* %15
%746 = icmp eq i32 %745, 1
br i1 %746, label %747, label %755
747: ; preds = %744
%748 = load i32, i32* %14
%749 = icmp ne i32 %748, 1
br i1 %749, label %750, label %755
750: ; preds = %747
%751 = load i32*, i32** %17
%752 = call i32 @f_outputLine(i32* %751, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.60, i64 0, i64 0))
%753 = load i32*, i32** %17
%754 = call i32 @f_outputLine(i32* %753, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.61, i64 0, i64 0))
br label %755
755: ; preds = %750, %747, %744
%756 = load i32*, i32** %17
%757 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%758 = call i32 @f_outputLine(i32* %756, i8* %757)
store i32 %758, i32* %14
br label %796
759: ; preds = %491
%760 = load i32, i32* %15
%761 = icmp sgt i32 %760, 0
br i1 %761, label %762, label %767
762: ; preds = %759
%763 = load i32*, i32** %17
%764 = call i32 @f_outputLine(i32* %763, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%765 = load i32*, i32** %17
%766 = call i32 @f_outputLine(i32* %765, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %15
br label %767
767: ; preds = %762, %759
%768 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%769 = load i8, i8* %768
%770 = sext i8 %769 to i32
%771 = icmp eq i32 %770, 10
br i1 %771, label %792, label %772
772: ; preds = %767
%773 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%774 = load i8, i8* %773
%775 = sext i8 %774 to i32
%776 = icmp eq i32 %775, 0
br i1 %776, label %792, label %777
777: ; preds = %772
%778 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%779 = load i8, i8* %778
%780 = sext i8 %779 to i32
%781 = icmp eq i32 %780, 13
br i1 %781, label %782, label %795
782: ; preds = %777
%783 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 1
%784 = load i8, i8* %783
%785 = sext i8 %784 to i32
%786 = icmp eq i32 %785, 10
br i1 %786, label %787, label %795
787: ; preds = %782
%788 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 2
%789 = load i8, i8* %788
%790 = sext i8 %789 to i32
%791 = icmp eq i32 %790, 0
br i1 %791, label %792, label %795
792: ; preds = %787, %772, %767
%793 = load i32*, i32** %17
%794 = call i32 @f_outputLine(i32* %793, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
store i32 %794, i32* %14
br label %795
795: ; preds = %792, %787, %782, %777
br label %796
796: ; preds = %795, %755
br label %797
797: ; preds = %796, %325
br label %798
798: ; preds = %797, %227
br label %139
799: ; preds = %139
%800 = load i32*, i32** %16
%801 = call i32 @fclose(i32* %800)
%802 = load i32*, i32** %17
%803 = call i32 @fclose(i32* %802)
br label %804
804: ; preds = %799, %38
br label %805
805: ; preds = %804, %29
%806 = load i32, i32* %3
ret i32 %806
}

LLVM IR (-O2):
@.str = [67 x i8] c"MkWinTesto: needs a single parameter, the (testo) file to convert\0A\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [28 x i8] c"MkWinTesto: %s for reading\0A\00"
@.str.3 = [13 x i8] c"wintesto.cmd\00"
@.str.4 = [3 x i8] c"wb\00"
@.str.5 = [38 x i8] c"MkWinTesto: wintesto.cmd for writing\0A\00"
@.str.6 = [10 x i8] c"@echo off\00"
@.str.7 = [4 x i8] c"REM\00"
@.str.8 = [68 x i8] c"REM Simple Windows NT/2000/XP .cmd version of GPSBabel testo script\00"
@.str.9 = [1 x i8] zeroinitializer
@.str.10 = [27 x i8] c"SET GPSBABEL_FREEZE_TIME=y\00"
@.str.11 = [27 x i8] c"SET TMPDIR=%TEMP%\\WINTESTO\00"
@.str.12 = [22 x i8] c"MKDIR %TMPDIR% 2>NUL:\00"
@.str.13 = [16 x i8] c"GOTO :REALSTART\00"
@.str.14 = [39 x i8] c"REM ==================================\00"
@.str.15 = [15 x i8] c":CommonCOMPARE\00"
@.str.16 = [14 x i8] c"SET PARAM1=%2\00"
@.str.17 = [14 x i8] c"SET PARAM2=%3\00"
@.str.18 = [80 x i8] c"REM Test if param3 was a dir rather than a file, if so add a \\* to make fc work\00"
@.str.19 = [59 x i8] c"FOR %%A IN (%3) DO IF \22d--------\22==\22%%~aA\22 SET PARAM2=%3\\*\00"
@.str.20 = [107 x i8] c"FOR /f \22delims=\22 %%a IN ('fc %PARAM1% %PARAM2%') DO IF \22x%%a\22==\22xFC: no differences encountered\22 GOTO :EOF\00"
@.str.21 = [41 x i8] c"REM Show the first 5 lines of difference\00"
@.str.22 = [29 x i8] c"fc %1 /LB5 %PARAM1% %PARAM2%\00"
@.str.23 = [103 x i8] c"if errorlevel 1 ECHO %* are not the same (first 5 differences above) - pausing. ^C to quit if required\00"
@.str.24 = [22 x i8] c"if errorlevel 1 PAUSE\00"
@.str.25 = [10 x i8] c"GOTO :EOF\00"
@.str.26 = [9 x i8] c":COMPARE\00"
@.str.27 = [29 x i8] c"CALL :CommonCOMPARE /L %1 %2\00"
@.str.28 = [12 x i8] c":BINCOMPARE\00"
@.str.29 = [29 x i8] c"CALL :CommonCOMPARE /B %1 %2\00"
@.str.30 = [16 x i8] c":SORTandCOMPARE\00"
@.str.31 = [22 x i8] c"SORT <%1 >%TMPDIR%\\s1\00"
@.str.32 = [22 x i8] c"SORT <%2 >%TMPDIR%\\s2\00"
@.str.33 = [38 x i8] c"CALL :COMPARE %TMPDIR%\\s1 %TMPDIR%\\s2\00"
@.str.34 = [11 x i8] c":REALSTART\00"
@.str.35 = [2 x i8] c" \00"
@.str.36 = [7 x i8] c"@echo.\00"
@.str.37 = [16 x i8] c"PNAME=${PNAME:-\00"
@.str.38 = [11 x i8] c"SET PNAME=\00"
@.str.39 = [61 x i8] c"IF NOT EXIST %PNAME%.EXE ECHO Can't find %PNAME%&& GOTO :EOF\00"
@.str.40 = [7 x i8] c"rm -f \00"
@.str.41 = [5 x i8] c"DEL \00"
@.str.42 = [10 x i8] c"${PNAME} \00"
@.str.43 = [9 x i8] c"%PNAME% \00"
@.str.44 = [9 x i8] c"compare \00"
@.str.45 = [15 x i8] c"CALL :COMPARE \00"
@.str.46 = [12 x i8] c"bincompare \00"
@.str.47 = [18 x i8] c"CALL :BINCOMPARE \00"
@.str.48 = [18 x i8] c"sort_and_compare \00"
@.str.49 = [22 x i8] c"CALL :SORTandCOMPARE \00"
@.str.50 = [7 x i8] c"echo \22\00"
@.str.51 = [6 x i8] c"ECHO \00"
@.str.52 = [5 x i8] c"cat \00"
@.str.53 = [6 x i8] c"TYPE \00"
@.str.54 = [7 x i8] c"sed '/\00"
@.str.55 = [4 x i8] c"/d'\00"
@.str.56 = [19 x i8] c"FINDSTR /V /R /C:\22\00"
@.str.57 = [2 x i8] c"\22\00"
@.str.58 = [10 x i8] c"${TMPDIR}\00"
@.str.59 = [9 x i8] c"%TMPDIR%\00"
@.str.60 = [9 x i8] c"@echo on\00"
@.str.61 = [17 x i8] c"@echo Testing...\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [256 x i8]
%4 = alloca [256 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%6 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 0
%7 = icmp slt i32 %0, 2
br i1 %7, label %8, label %10
8: ; preds = %2
%9 = tail call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str, i64 0, i64 0))
br label %10
10: ; preds = %8, %2
%11 = getelementptr inbounds i8*, i8** %1, i64 1
%12 = load i8*, i8** %11
%13 = tail call i32* @fopen(i8* %12, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%14 = icmp eq i32* %13, null
br i1 %14, label %15, label %18
15: ; preds = %10
%16 = load i8*, i8** %11
%17 = tail call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.2, i64 0, i64 0), i8* %16)
br label %483
18: ; preds = %10
%19 = tail call i32* @fopen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0))
%20 = icmp eq i32* %19, null
br i1 %20, label %21, label %23
21: ; preds = %18
%22 = tail call i32 (i8*, ...) @fatal(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0))
br label %483
23: ; preds = %18
%24 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%25 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%26 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0))
%27 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%28 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%29 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0))
%30 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.11, i64 0, i64 0))
%31 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0))
%32 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%33 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.13, i64 0, i64 0))
%34 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%35 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%36 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%37 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.15, i64 0, i64 0))
%38 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.16, i64 0, i64 0))
%39 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.17, i64 0, i64 0))
%40 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.18, i64 0, i64 0))
%41 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.19, i64 0, i64 0))
%42 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.20, i64 0, i64 0))
%43 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0))
%44 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.22, i64 0, i64 0))
%45 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([103 x i8], [103 x i8]* @.str.23, i64 0, i64 0))
%46 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.24, i64 0, i64 0))
%47 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%48 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%49 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%50 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%51 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.26, i64 0, i64 0))
%52 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.27, i64 0, i64 0))
%53 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%54 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%55 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%56 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%57 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.28, i64 0, i64 0))
%58 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.29, i64 0, i64 0))
%59 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%60 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%61 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%62 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%63 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.30, i64 0, i64 0))
%64 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.31, i64 0, i64 0))
%65 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.32, i64 0, i64 0))
%66 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.33, i64 0, i64 0))
%67 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0))
%68 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%69 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
%70 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%71 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.34, i64 0, i64 0))
%72 = tail call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
%73 = call i32 @feof(i32* %13)
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %480
75: ; preds = %23
%76 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 6
%77 = ptrtoint [256 x i8]* %3 to i64
%78 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 1
%79 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 2
%80 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 18
%81 = sub nuw nsw i64 -6, %77
%82 = sub i64 12, %77
br label %83
83: ; preds = %75, %475
%84 = phi i32 [ 0, %75 ], [ %477, %475 ]
%85 = phi i32 [ 0, %75 ], [ %476, %475 ]
%86 = call i32 @fgets(i8* %5, i32 255, i32* %13)
%87 = load i8, i8* %5
%88 = icmp eq i8 %87, 35
br i1 %88, label %89, label %127
89: ; preds = %83
store i8 0, i8* %6
%90 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%91 = load i8, i8* %78
%92 = icmp eq i8 %91, 32
br i1 %92, label %95, label %93
93: ; preds = %89
%94 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.35, i64 0, i64 0))
br label %95
95: ; preds = %93, %89
%96 = phi i32 [ 3, %93 ], [ 2, %89 ]
%97 = zext i32 %96 to i64
br label %98
98: ; preds = %95, %114
%99 = phi i64 [ 1, %95 ], [ %115, %114 ]
%100 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %99
%101 = load i8, i8* %100
switch i8 %101, label %102 [
i8 0, label %109
i8 10, label %109
i8 13, label %104
]
102: ; preds = %98
%103 = add nuw nsw i64 %99, 1
br label %114
104: ; preds = %98
%105 = add nuw nsw i64 %99, 1
%106 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %105
%107 = load i8, i8* %106
%108 = icmp eq i8 %107, 10
br i1 %108, label %109, label %114
109: ; preds = %98, %98, %104
%110 = trunc i64 %99 to i32
%111 = add nuw i32 %96, %110
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %112
store i8 0, i8* %113
br label %119
114: ; preds = %102, %104
%115 = phi i64 [ %103, %102 ], [ %105, %104 ]
%116 = add nuw nsw i64 %99, %97
%117 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %116
store i8 %101, i8* %117
%118 = icmp eq i64 %115, 256
br i1 %118, label %119, label %98
119: ; preds = %114, %109
%120 = icmp sgt i32 %84, 0
br i1 %120, label %121, label %124
121: ; preds = %119
%122 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%123 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %124
124: ; preds = %121, %119
%125 = phi i32 [ 0, %121 ], [ %84, %119 ]
%126 = call i32 @f_outputLine(i32* %19, i8* %6)
br label %475
127: ; preds = %83
%128 = call i64 @strncmp(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.37, i64 0, i64 0), i8* %5, i32 15)
%129 = icmp eq i64 %128, 0
store i8 0, i8* %6
br i1 %129, label %130, label %181
130: ; preds = %127
%131 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.38, i64 0, i64 0))
br label %132
132: ; preds = %163, %130
%133 = phi i64 [ 15, %130 ], [ %167, %163 ]
%134 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %133
%135 = load i8, i8* %134
switch i8 %135, label %147 [
i8 125, label %141
i8 0, label %141
i8 10, label %141
i8 13, label %136
i8 47, label %148
]
136: ; preds = %132
%137 = add nuw nsw i64 %133, 1
%138 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %137
%139 = load i8, i8* %138
%140 = icmp eq i8 %139, 10
br i1 %140, label %141, label %147
141: ; preds = %157, %154, %154, %154, %132, %132, %132, %136
%142 = phi i64 [ %133, %132 ], [ %133, %132 ], [ %133, %132 ], [ %133, %136 ], [ %152, %154 ], [ %152, %154 ], [ %152, %154 ], [ %152, %157 ]
%143 = shl i64 %142, 32
%144 = add i64 %143, -21474836480
%145 = ashr exact i64 %144, 32
%146 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %145
store i8 0, i8* %146
br label %168
147: ; preds = %132, %136
br label %148
148: ; preds = %132, %147
%149 = phi i8 [ %135, %147 ], [ 92, %132 ]
%150 = add nsw i64 %133, -5
%151 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %150
store i8 %149, i8* %151
%152 = add nuw nsw i64 %133, 1
%153 = icmp eq i64 %152, 256
br i1 %153, label %168, label %154
154: ; preds = %148
%155 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %152
%156 = load i8, i8* %155
switch i8 %156, label %162 [
i8 125, label %141
i8 0, label %141
i8 10, label %141
i8 13, label %157
i8 47, label %163
]
157: ; preds = %154
%158 = add nuw nsw i64 %133, 2
%159 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %158
%160 = load i8, i8* %159
%161 = icmp eq i8 %160, 10
br i1 %161, label %141, label %162
162: ; preds = %157, %154
br label %163
163: ; preds = %162, %154
%164 = phi i8 [ %156, %162 ], [ 92, %154 ]
%165 = add nsw i64 %133, -4
%166 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %165
store i8 %164, i8* %166
%167 = add nuw nsw i64 %133, 2
br label %132
168: ; preds = %148, %141
%169 = icmp sgt i32 %84, 0
br i1 %169, label %170, label %173
170: ; preds = %168
%171 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%172 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %173
173: ; preds = %170, %168
%174 = phi i32 [ 0, %170 ], [ %84, %168 ]
%175 = call i32 @f_outputLine(i32* %19, i8* %6)
%176 = icmp eq i32 %175, 1
br i1 %176, label %177, label %179
177: ; preds = %173
%178 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
br label %179
179: ; preds = %177, %173
%180 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.39, i64 0, i64 0))
br label %475
181: ; preds = %127
%182 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.40, i64 0, i64 0), i8* %5, i32 6)
%183 = icmp eq i64 %182, 0
br i1 %183, label %184, label %192
184: ; preds = %181
%185 = icmp sgt i32 %84, 0
br i1 %185, label %186, label %189
186: ; preds = %184
%187 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%188 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %189
189: ; preds = %186, %184
%190 = phi i32 [ 0, %186 ], [ %84, %184 ]
%191 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.41, i64 0, i64 0))
br label %192
192: ; preds = %189, %181
%193 = phi i32 [ 4, %189 ], [ 0, %181 ]
%194 = phi i32 [ %190, %189 ], [ %84, %181 ]
%195 = phi i32 [ 6, %189 ], [ 0, %181 ]
%196 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.42, i64 0, i64 0), i8* %5, i32 9)
%197 = icmp eq i64 %196, 0
br i1 %197, label %198, label %201
198: ; preds = %192
%199 = add nsw i32 %194, 1
%200 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
br label %201
201: ; preds = %198, %192
%202 = phi i32 [ 8, %198 ], [ %193, %192 ]
%203 = phi i32 [ %199, %198 ], [ %194, %192 ]
%204 = phi i32 [ 9, %198 ], [ %195, %192 ]
%205 = call i64 @strncmp(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.44, i64 0, i64 0), i8* %5, i32 8)
%206 = icmp eq i64 %205, 0
br i1 %206, label %207, label %215
207: ; preds = %201
%208 = icmp sgt i32 %203, 0
br i1 %208, label %209, label %212
209: ; preds = %207
%210 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%211 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %212
212: ; preds = %209, %207
%213 = phi i32 [ 0, %209 ], [ %203, %207 ]
%214 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.45, i64 0, i64 0))
br label %215
215: ; preds = %212, %201
%216 = phi i32 [ 14, %212 ], [ %202, %201 ]
%217 = phi i32 [ %213, %212 ], [ %203, %201 ]
%218 = phi i32 [ 8, %212 ], [ %204, %201 ]
%219 = call i64 @strncmp(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.46, i64 0, i64 0), i8* %5, i32 11)
%220 = icmp eq i64 %219, 0
br i1 %220, label %221, label %229
221: ; preds = %215
%222 = icmp sgt i32 %217, 0
br i1 %222, label %223, label %226
223: ; preds = %221
%224 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%225 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %226
226: ; preds = %223, %221
%227 = phi i32 [ 0, %223 ], [ %217, %221 ]
%228 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.47, i64 0, i64 0))
br label %229
229: ; preds = %226, %215
%230 = phi i32 [ 17, %226 ], [ %216, %215 ]
%231 = phi i32 [ %227, %226 ], [ %217, %215 ]
%232 = phi i32 [ 11, %226 ], [ %218, %215 ]
%233 = call i64 @strncmp(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.48, i64 0, i64 0), i8* %5, i32 17)
%234 = icmp eq i64 %233, 0
br i1 %234, label %235, label %243
235: ; preds = %229
%236 = icmp sgt i32 %231, 0
br i1 %236, label %237, label %240
237: ; preds = %235
%238 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%239 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %240
240: ; preds = %237, %235
%241 = phi i32 [ 0, %237 ], [ %231, %235 ]
%242 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.49, i64 0, i64 0))
br label %243
243: ; preds = %240, %229
%244 = phi i32 [ 21, %240 ], [ %230, %229 ]
%245 = phi i32 [ %241, %240 ], [ %231, %229 ]
%246 = phi i32 [ 17, %240 ], [ %232, %229 ]
%247 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.50, i64 0, i64 0), i8* %5, i32 6)
%248 = icmp eq i64 %247, 0
br i1 %248, label %249, label %257
249: ; preds = %243
%250 = icmp sgt i32 %245, 0
br i1 %250, label %251, label %254
251: ; preds = %249
%252 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%253 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %254
254: ; preds = %251, %249
%255 = phi i32 [ 0, %251 ], [ %245, %249 ]
%256 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.51, i64 0, i64 0))
br label %257
257: ; preds = %254, %243
%258 = phi i32 [ 5, %254 ], [ %244, %243 ]
%259 = phi i32 [ 1, %254 ], [ 0, %243 ]
%260 = phi i32 [ %255, %254 ], [ %245, %243 ]
%261 = phi i32 [ 6, %254 ], [ %246, %243 ]
%262 = call i64 @strncmp(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0), i8* %5, i32 4)
%263 = icmp eq i64 %262, 0
br i1 %263, label %264, label %272
264: ; preds = %257
%265 = icmp sgt i32 %260, 0
br i1 %265, label %266, label %269
266: ; preds = %264
%267 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%268 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %269
269: ; preds = %266, %264
%270 = phi i32 [ 0, %266 ], [ %260, %264 ]
%271 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0))
br label %272
272: ; preds = %269, %257
%273 = phi i32 [ 5, %269 ], [ %258, %257 ]
%274 = phi i32 [ %270, %269 ], [ %260, %257 ]
%275 = phi i32 [ 4, %269 ], [ %261, %257 ]
%276 = call i64 @strncmp(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.54, i64 0, i64 0), i8* %5, i32 6)
%277 = icmp eq i64 %276, 0
br i1 %277, label %278, label %307
278: ; preds = %272
%279 = call i8* @strstr(i8* %76, i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0))
%280 = icmp eq i8* %279, null
br i1 %280, label %307, label %281
281: ; preds = %278
%282 = ptrtoint i8* %279 to i64
%283 = sub i64 %282, %77
%284 = icmp slt i64 %283, 256
br i1 %284, label %285, label %307
285: ; preds = %281
%286 = icmp sgt i32 %274, 0
br i1 %286, label %287, label %290
287: ; preds = %285
%288 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%289 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %290
290: ; preds = %287, %285
%291 = phi i32 [ 0, %287 ], [ %274, %285 ]
%292 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.56, i64 0, i64 0))
%293 = icmp sgt i64 %283, 6
br i1 %293, label %294, label %299
294: ; preds = %290
%295 = add i64 %81, %282
%296 = add i64 %82, %282
%297 = trunc i64 %296 to i32
%298 = trunc i64 %283 to i32
br label %299
299: ; preds = %294, %290
%300 = phi i32 [ 18, %290 ], [ %297, %294 ]
%301 = phi i32 [ 6, %290 ], [ %298, %294 ]
%302 = add nuw nsw i32 %300, 1
%303 = zext i32 %300 to i64
%304 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %303
store i8 0, i8* %304
%305 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%306 = add nuw nsw i32 %301, 3
br label %351
307: ; preds = %278, %281, %272
%308 = icmp ne i32 %275, 0
%309 = icmp eq i32 %85, 1
%310 = select i1 %308, i1 true, i1 %309
br i1 %310, label %311, label %457
311: ; preds = %307
%312 = icmp eq i32 %275, 0
br i1 %312, label %313, label %356
313: ; preds = %311, %345
%314 = phi i64 [ %346, %345 ], [ 0, %311 ]
%315 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %314
%316 = load i8, i8* %315
switch i8 %316, label %348 [
i8 9, label %317
i8 32, label %317
]
317: ; preds = %313, %313
%318 = or i64 %314, 1
%319 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %318
%320 = load i8, i8* %319
switch i8 %320, label %348 [
i8 9, label %321
i8 32, label %321
]
321: ; preds = %317, %317
%322 = or i64 %314, 2
%323 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %322
%324 = load i8, i8* %323
switch i8 %324, label %348 [
i8 9, label %325
i8 32, label %325
]
325: ; preds = %321, %321
%326 = or i64 %314, 3
%327 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %326
%328 = load i8, i8* %327
switch i8 %328, label %348 [
i8 9, label %329
i8 32, label %329
]
329: ; preds = %325, %325
%330 = or i64 %314, 4
%331 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %330
%332 = load i8, i8* %331
switch i8 %332, label %348 [
i8 9, label %333
i8 32, label %333
]
333: ; preds = %329, %329
%334 = or i64 %314, 5
%335 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %334
%336 = load i8, i8* %335
switch i8 %336, label %348 [
i8 9, label %337
i8 32, label %337
]
337: ; preds = %333, %333
%338 = or i64 %314, 6
%339 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %338
%340 = load i8, i8* %339
switch i8 %340, label %348 [
i8 9, label %341
i8 32, label %341
]
341: ; preds = %337, %337
%342 = or i64 %314, 7
%343 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %342
%344 = load i8, i8* %343
switch i8 %344, label %348 [
i8 9, label %345
i8 32, label %345
]
345: ; preds = %341, %341
%346 = add nuw nsw i64 %314, 8
%347 = icmp eq i64 %346, 256
br i1 %347, label %356, label %313
348: ; preds = %341, %337, %333, %329, %325, %321, %317, %313
%349 = phi i64 [ %314, %313 ], [ %318, %317 ], [ %322, %321 ], [ %326, %325 ], [ %330, %329 ], [ %334, %333 ], [ %338, %337 ], [ %342, %341 ]
%350 = trunc i64 %349 to i32
br label %351
351: ; preds = %348, %299
%352 = phi i32 [ %302, %299 ], [ %273, %348 ]
%353 = phi i32 [ %291, %299 ], [ %274, %348 ]
%354 = phi i32 [ %306, %299 ], [ %350, %348 ]
%355 = icmp slt i32 %354, 256
br i1 %355, label %356, label %447
356: ; preds = %345, %311, %351
%357 = phi i32 [ %354, %351 ], [ %275, %311 ], [ 0, %345 ]
%358 = phi i32 [ %353, %351 ], [ %274, %311 ], [ %274, %345 ]
%359 = phi i32 [ %352, %351 ], [ %273, %311 ], [ %273, %345 ]
%360 = sext i32 %357 to i64
%361 = sub nsw i64 0, %360
br label %362
362: ; preds = %356, %441
%363 = phi i32 [ %357, %356 ], [ %445, %441 ]
%364 = phi i32 [ %259, %356 ], [ %443, %441 ]
%365 = phi i32 [ %359, %356 ], [ %442, %441 ]
%366 = sext i32 %363 to i64
%367 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %366
%368 = load i8, i8* %367
switch i8 %368, label %410 [
i8 0, label %375
i8 10, label %375
i8 13, label %369
i8 34, label %380
i8 37, label %384
i8 62, label %398
]
369: ; preds = %362
%370 = add nsw i32 %363, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %371
%373 = load i8, i8* %372
%374 = icmp eq i8 %373, 10
br i1 %374, label %375, label %410
375: ; preds = %362, %362, %369
%376 = add nsw i32 %363, %365
%377 = sub i32 %376, %357
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %378
store i8 0, i8* %379
br label %447
380: ; preds = %362
%381 = icmp slt i32 %364, 1
%382 = zext i1 %381 to i32
%383 = add nsw i32 %365, -1
br label %441
384: ; preds = %362
%385 = icmp eq i32 %364, 1
br i1 %385, label %386, label %392
386: ; preds = %384
%387 = add nsw i32 %363, %365
%388 = sub i32 %387, %357
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %389
store i8 37, i8* %390
%391 = add nsw i32 %365, 1
br label %392
392: ; preds = %386, %384
%393 = phi i32 [ %391, %386 ], [ %365, %384 ]
%394 = sub i32 %363, %357
%395 = add i32 %394, %393
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %396
store i8 37, i8* %397
br label %441
398: ; preds = %362
%399 = add nsw i32 %363, -1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 %400
%402 = load i8, i8* %401
%403 = icmp eq i8 %402, 32
%404 = sext i1 %403 to i32
%405 = add nsw i32 %365, %404
%406 = sub i32 %363, %357
%407 = add i32 %406, %405
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %408
store i8 62, i8* %409
br label %441
410: ; preds = %362, %369
%411 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.58, i64 0, i64 0), i8* %367, i32 9)
%412 = icmp eq i64 %411, 0
br i1 %412, label %413, label %421
413: ; preds = %410
%414 = sext i32 %365 to i64
%415 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %414
%416 = getelementptr inbounds i8, i8* %415, i64 %361
%417 = getelementptr inbounds i8, i8* %416, i64 %366
%418 = call i32 @strcpy(i8* %417, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.59, i64 0, i64 0))
%419 = add nsw i32 %365, -1
%420 = add nsw i32 %363, 8
br label %441
421: ; preds = %410
%422 = call i64 @strncmp(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.42, i64 0, i64 0), i8* %367, i32 9)
%423 = icmp eq i64 %422, 0
br i1 %423, label %424, label %432
424: ; preds = %421
%425 = sext i32 %365 to i64
%426 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %425
%427 = getelementptr inbounds i8, i8* %426, i64 %361
%428 = getelementptr inbounds i8, i8* %427, i64 %366
%429 = call i32 @strcpy(i8* %428, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
%430 = add nsw i32 %365, -1
%431 = add nsw i32 %363, 8
br label %441
432: ; preds = %421
%433 = load i8, i8* %367
%434 = icmp eq i8 %433, 47
%435 = add nsw i32 %363, %365
%436 = sub i32 %435, %357
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [256 x i8], [256 x i8]* %4, i64 0, i64 %437
br i1 %434, label %439, label %440
439: ; preds = %432
store i8 92, i8* %438
br label %441
440: ; preds = %432
store i8 %433, i8* %438
br label %441
441: ; preds = %413, %439, %440, %424, %398, %392, %380
%442 = phi i32 [ %383, %380 ], [ %393, %392 ], [ %405, %398 ], [ %419, %413 ], [ %430, %424 ], [ %365, %439 ], [ %365, %440 ]
%443 = phi i32 [ %382, %380 ], [ %364, %392 ], [ %364, %398 ], [ %364, %413 ], [ %364, %424 ], [ %364, %439 ], [ %364, %440 ]
%444 = phi i32 [ %363, %380 ], [ %363, %392 ], [ %363, %398 ], [ %420, %413 ], [ %431, %424 ], [ %363, %439 ], [ %363, %440 ]
%445 = add nsw i32 %444, 1
%446 = icmp slt i32 %444, 255
br i1 %446, label %362, label %447
447: ; preds = %441, %351, %375
%448 = phi i32 [ %353, %351 ], [ %358, %375 ], [ %358, %441 ]
%449 = icmp eq i32 %448, 1
%450 = icmp ne i32 %85, 1
%451 = select i1 %449, i1 %450, i1 false
br i1 %451, label %452, label %455
452: ; preds = %447
%453 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.60, i64 0, i64 0))
%454 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.61, i64 0, i64 0))
br label %455
455: ; preds = %452, %447
%456 = call i32 @f_outputLine(i32* %19, i8* %6)
br label %475
457: ; preds = %307
%458 = icmp sgt i32 %274, 0
br i1 %458, label %459, label %462
459: ; preds = %457
%460 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%461 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.36, i64 0, i64 0))
br label %462
462: ; preds = %459, %457
%463 = phi i32 [ 0, %459 ], [ %274, %457 ]
%464 = load i8, i8* %5
switch i8 %464, label %465 [
i8 10, label %473
i8 0, label %473
]
465: ; preds = %462
%466 = icmp eq i8 %464, 13
%467 = load i8, i8* %78
%468 = icmp eq i8 %467, 10
%469 = select i1 %466, i1 %468, i1 false
%470 = load i8, i8* %79
%471 = icmp eq i8 %470, 0
%472 = select i1 %469, i1 %471, i1 false
br i1 %472, label %473, label %475
473: ; preds = %462, %462, %465
%474 = call i32 @f_outputLine(i32* %19, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.9, i64 0, i64 0))
br label %475
475: ; preds = %179, %465, %473, %455, %124
%476 = phi i32 [ %126, %124 ], [ %180, %179 ], [ %456, %455 ], [ %474, %473 ], [ %85, %465 ]
%477 = phi i32 [ %125, %124 ], [ %174, %179 ], [ %448, %455 ], [ %463, %473 ], [ %463, %465 ]
%478 = call i32 @feof(i32* %13)
%479 = icmp eq i32 %478, 0
br i1 %479, label %83, label %480
480: ; preds = %475, %23
%481 = call i32 @fclose(i32* %13)
%482 = call i32 @fclose(i32* %19)
br label %483
483: ; preds = %21, %480, %15
ret i32 0
}