#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 */
char EOF;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ printf(char *, ...);
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
char *strtok(char *, char *);
int main() {
  char ch;
  int count = 0;
  FILE *fp, *fpTarget, *fpOut;
  char vocab[100][100];
  fp = fopen("corpus.txt", "r");
  fpTarget = fopen("targets.txt", "r");
  fpOut = fopen("matches.txt", "w");
  int i = 0, j = 0;
  while ((ch = fgetc(fp)) != '\n') {
    if (ch == ',') {
      vocab[i][j] = '\0';
      i++;
      j = 0;
    } else {
      vocab[i][j] = ch;
      j++;
    }
  }
  count = ++i;
  for (int i = 0; i < count; i++) {
  }
  ch = fgetc(fpTarget);
  char line[100][100];
  int t = 0, r = 0;
  while (ch != EOF) {
    t = 0;
    while (ch != '\n') {
      line[r][t] = ch;
      t++;
      ch = fgetc(fpTarget);
    }
    line[r][t] = '\0';
    r++;
    ch = fgetc(fpTarget);
  }
  for (int i = 0; i < r; i++) {
  }
  char cor[100][100];
  int f = 0, g = 0;
  ch = fgetc(fp);
  while (ch != EOF) {
    f = 0;
    while (ch != '\n') {
      cor[g][f] = ch;
      f++;
      ch = fgetc(fp);
    }
    cor[g][f] = '\0';
    g++;
    ch = fgetc(fp);
  }
  for (int i = 0; i < g; i++) {
  }
  char t_tokens[100][100], c_tokens[100][100], *ptr, dummy[100];
  double res[100][100];
  int un[100][100], in[100][100];
  int k, h, q;
  int n, m, l, rr, x, z;
  char *pt;
  double re;
  for (int j = 0; j < g; j++) {
    strcpy(dummy, cor[j]);
    ptr = strtok(dummy, ",");
    h = 0;
    while (ptr != NULL) {
      for (int y = 0; y < count; y++) {
        if (strcmp(ptr, vocab[y]) == 0) {
          strcpy(c_tokens[h], ptr);
          h++;
        }
      }
      ptr = strtok(NULL, ",");
    }
    for (int e = 0; e < h; e++) {
    }
    l = h;
    for (int w = 0; w < r; w++) {
      strcpy(dummy, line[w]);
      pt = strtok(dummy, ",");
      q = 0;
      while (pt != NULL) {
        strcpy(t_tokens[q], pt);
        q++;
        pt = strtok(NULL, ",");
      }
      for (int e = 0; e < q; e++) {
      }
      rr = 0;
      for (z = 0; z < q; z++) {
        for (x = 0; x < h; x++) {
          if (strcmp(t_tokens[z], c_tokens[x]) == 0) {
            rr++;
          }
        }
      }
      n = h + q - rr;
      re = (double)rr / (double)n;
      res[w][j] = re;
      un[w][j] = n;
      in[w][j] = rr;
    }
  }
  double value;
  int index;
  for (int w = 0; w < r; w++) {
    value = 0;
    for (int j = 0; j < g; j++) {
      if (res[w][j] > value) {
        value = res[w][j];
        index = j;
      }
    }
    printf("%s;%d/%d=%.2f;%s", line[w], in[w][index], un[w][index],
           res[w][index], cor[index]);
    printf("\n");
  }
  fclose(fpTarget);
  fclose(fpOut);
  fclose(fp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x33590,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0xc(%rbp)
lea    0xe70(%rip),%rdi
lea    0xe74(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x18(%rbp)
lea    0xe66(%rip),%rdi
lea    0xe5d(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x20(%rbp)
lea    0xe5b(%rip),%rdi
lea    0xe60(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2744(%rbp)
movl   $0x0,-0x2748(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
movsbl %al,%eax
cmp    $0xa,%eax
je     127b <main+0x10b>
movsbl -0x5(%rbp),%eax
cmp    $0x2c,%eax
jne    1245 <main+0xd5>
movslq -0x2744(%rbp),%rcx
lea    -0x2740(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x2748(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x2744(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2744(%rbp)
movl   $0x0,-0x2748(%rbp)
jmp    1276 <main+0x106>
mov    -0x5(%rbp),%dl
movslq -0x2744(%rbp),%rcx
lea    -0x2740(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x2748(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2748(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2748(%rbp)
jmp    11e2 <main+0x72>
mov    -0x2744(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2744(%rbp)
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x274c(%rbp)
mov    -0x274c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12bf <main+0x14f>
jmp    12ab <main+0x13b>
mov    -0x274c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x274c(%rbp)
jmp    1297 <main+0x127>
mov    -0x20(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
movl   $0x0,-0x4e64(%rbp)
movl   $0x0,-0x4e68(%rbp)
movsbl -0x5(%rbp),%eax
mov    0x2cfe(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     138e <main+0x21e>
movl   $0x0,-0x4e64(%rbp)
movsbl -0x5(%rbp),%eax
cmp    $0xa,%eax
je     134e <main+0x1de>
mov    -0x5(%rbp),%dl
movslq -0x4e68(%rbp),%rcx
lea    -0x4e60(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x4e64(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x4e64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e64(%rbp)
mov    -0x20(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
jmp    12ff <main+0x18f>
movslq -0x4e68(%rbp),%rcx
lea    -0x4e60(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x4e64(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x4e68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e68(%rbp)
mov    -0x20(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
jmp    12df <main+0x16f>
movl   $0x0,-0x4e6c(%rbp)
mov    -0x4e6c(%rbp),%eax
cmp    -0x4e68(%rbp),%eax
jge    13c3 <main+0x253>
jmp    13af <main+0x23f>
mov    -0x4e6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4e6c(%rbp)
jmp    1398 <main+0x228>
movl   $0x0,-0x7584(%rbp)
movl   $0x0,-0x7588(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
movsbl -0x5(%rbp),%eax
mov    0x2bfa(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     1492 <main+0x322>
movl   $0x0,-0x7584(%rbp)
movsbl -0x5(%rbp),%eax
cmp    $0xa,%eax
je     1452 <main+0x2e2>
mov    -0x5(%rbp),%dl
movslq -0x7588(%rbp),%rcx
lea    -0x7580(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x7584(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x7584(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7584(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
jmp    1403 <main+0x293>
movslq -0x7588(%rbp),%rcx
lea    -0x7580(%rbp),%rax
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x7584(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x7588(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7588(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %al,-0x5(%rbp)
jmp    13e3 <main+0x273>
movl   $0x0,-0x758c(%rbp)
mov    -0x758c(%rbp),%eax
cmp    -0x7588(%rbp),%eax
jge    14c7 <main+0x357>
jmp    14b3 <main+0x343>
mov    -0x758c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x758c(%rbp)
jmp    149c <main+0x32c>
movl   $0x0,-0x3355c(%rbp)
mov    -0x3355c(%rbp),%eax
cmp    -0x7588(%rbp),%eax
jge    18a9 <main+0x739>
lea    -0xc420(%rbp),%rdi
movslq -0x3355c(%rbp),%rax
lea    -0x7580(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
lea    -0xc420(%rbp),%rdi
lea    0xb15(%rip),%rsi
call   1090 <strtok@plt>
mov    %rax,-0xc3b8(%rbp)
movl   $0x0,-0x33528(%rbp)
cmpq   $0x0,-0xc3b8(%rbp)
je     15df <main+0x46f>
movl   $0x0,-0x33560(%rbp)
mov    -0x33560(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15c3 <main+0x453>
mov    -0xc3b8(%rbp),%rdi
movslq -0x33560(%rbp),%rax
lea    -0x2740(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%rax
jne    15aa <main+0x43a>
movslq -0x33528(%rbp),%rax
lea    -0xc3b0(%rbp),%rdi
imul   $0x64,%rax,%rax
add    %rax,%rdi
mov    -0xc3b8(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x33528(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33528(%rbp)
jmp    15af <main+0x43f>
mov    -0x33560(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33560(%rbp)
jmp    1540 <main+0x3d0>
xor    %eax,%eax
mov    %eax,%edi
lea    0xa59(%rip),%rsi
call   1090 <strtok@plt>
mov    %rax,-0xc3b8(%rbp)
jmp    1528 <main+0x3b8>
movl   $0x0,-0x33564(%rbp)
mov    -0x33564(%rbp),%eax
cmp    -0x33528(%rbp),%eax
jge    1614 <main+0x4a4>
jmp    1600 <main+0x490>
mov    -0x33564(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33564(%rbp)
jmp    15e9 <main+0x479>
mov    -0x33528(%rbp),%eax
mov    %eax,-0x33538(%rbp)
movl   $0x0,-0x33568(%rbp)
mov    -0x33568(%rbp),%eax
cmp    -0x4e68(%rbp),%eax
jge    1890 <main+0x720>
lea    -0xc420(%rbp),%rdi
movslq -0x33568(%rbp),%rax
lea    -0x4e60(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
lea    -0xc420(%rbp),%rdi
lea    0x9bc(%rip),%rsi
call   1090 <strtok@plt>
mov    %rax,-0x33550(%rbp)
movl   $0x0,-0x3352c(%rbp)
cmpq   $0x0,-0x33550(%rbp)
je     16db <main+0x56b>
movslq -0x3352c(%rbp),%rax
lea    -0x9ca0(%rbp),%rdi
imul   $0x64,%rax,%rax
add    %rax,%rdi
mov    -0x33550(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x3352c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3352c(%rbp)
xor    %eax,%eax
mov    %eax,%edi
lea    0x95d(%rip),%rsi
call   1090 <strtok@plt>
mov    %rax,-0x33550(%rbp)
jmp    1681 <main+0x511>
movl   $0x0,-0x3356c(%rbp)
mov    -0x3356c(%rbp),%eax
cmp    -0x3352c(%rbp),%eax
jge    1710 <main+0x5a0>
jmp    16fc <main+0x58c>
mov    -0x3356c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3356c(%rbp)
jmp    16e5 <main+0x575>
movl   $0x0,-0x3353c(%rbp)
movl   $0x0,-0x33544(%rbp)
mov    -0x33544(%rbp),%eax
cmp    -0x3352c(%rbp),%eax
jge    17cc <main+0x65c>
movl   $0x0,-0x33540(%rbp)
mov    -0x33540(%rbp),%eax
cmp    -0x33528(%rbp),%eax
jge    17b3 <main+0x643>
movslq -0x33544(%rbp),%rax
lea    -0x9ca0(%rbp),%rdi
imul   $0x64,%rax,%rax
add    %rax,%rdi
movslq -0x33540(%rbp),%rax
lea    -0xc3b0(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%rax
jne    179a <main+0x62a>
mov    -0x3353c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3353c(%rbp)
jmp    179f <main+0x62f>
mov    -0x33540(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33540(%rbp)
jmp    1740 <main+0x5d0>
jmp    17b8 <main+0x648>
mov    -0x33544(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33544(%rbp)
jmp    1724 <main+0x5b4>
mov    -0x33528(%rbp),%eax
add    -0x3352c(%rbp),%eax
sub    -0x3353c(%rbp),%eax
mov    %eax,-0x33530(%rbp)
cvtsi2sdl -0x3353c(%rbp),%xmm0
ff
cvtsi2sdl -0x33530(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x33558(%rbp)
ff
movsd  -0x33558(%rbp),%xmm0
ff
movslq -0x33568(%rbp),%rcx
lea    -0x1fca0(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x3355c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x33530(%rbp),%edx
movslq -0x33568(%rbp),%rcx
lea    -0x298e0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x3355c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3353c(%rbp),%edx
movslq -0x33568(%rbp),%rcx
lea    -0x33520(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x3355c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x33568(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33568(%rbp)
jmp    162a <main+0x4ba>
jmp    1895 <main+0x725>
mov    -0x3355c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3355c(%rbp)
jmp    14d1 <main+0x361>
movl   $0x0,-0x33580(%rbp)
mov    -0x33580(%rbp),%eax
cmp    -0x4e68(%rbp),%eax
jge    1a31 <main+0x8c1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x33578(%rbp)
ff
movl   $0x0,-0x33584(%rbp)
mov    -0x33584(%rbp),%eax
cmp    -0x7588(%rbp),%eax
jge    196f <main+0x7ff>
movslq -0x33580(%rbp),%rcx
lea    -0x1fca0(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x33584(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x33578(%rbp),%xmm0
ff
jbe    1956 <main+0x7e6>
movslq -0x33580(%rbp),%rcx
lea    -0x1fca0(%rbp),%rax
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x33584(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x33578(%rbp)
ff
mov    -0x33584(%rbp),%eax
mov    %eax,-0x3357c(%rbp)
jmp    195b <main+0x7eb>
mov    -0x33584(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33584(%rbp)
jmp    18da <main+0x76a>
movslq -0x33580(%rbp),%rax
lea    -0x4e60(%rbp),%rsi
imul   $0x64,%rax,%rax
add    %rax,%rsi
movslq -0x33580(%rbp),%rcx
lea    -0x33520(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x3357c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x33580(%rbp),%rcx
lea    -0x298e0(%rbp),%rax
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x3357c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x33580(%rbp),%rdi
lea    -0x1fca0(%rbp),%rax
imul   $0x320,%rdi,%rdi
add    %rdi,%rax
movslq -0x3357c(%rbp),%rdi
movsd  (%rax,%rdi,8),%xmm0
movslq -0x3357c(%rbp),%rax
lea    -0x7580(%rbp),%r8
imul   $0x64,%rax,%rax
add    %rax,%r8
lea    0x621(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
lea    0x624(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x33580(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x33580(%rbp)
jmp    18b3 <main+0x743>
mov    -0x20(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x28(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x18(%rbp),%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x33590,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x33538,%rsp
lea    0xe68(%rip),%rdi
lea    0xe6c(%rip),%rbx
mov    %rbx,%rsi
call   1090 <fopen@plt>
mov    %rax,%r15
lea    0xe5c(%rip),%rdi
mov    %rbx,%rsi
call   1090 <fopen@plt>
mov    %rax,%r12
lea    0xe56(%rip),%rdi
lea    0xe5b(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%r13d
lea    0x9d20(%rsp),%rbp
mov    %rbp,%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rdi
call   1070 <fgetc@plt>
cmp    $0x2c,%al
je     1210 <main+0x90>
cmp    $0xa,%al
je     121d <main+0x9d>
mov    %al,(%rbx)
add    $0x1,%rbx
jmp    11f0 <main+0x70>
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%rbx)
add    $0x1,%r13
add    $0x64,%rbp
jmp    11e2 <main+0x62>
mov    %r12,%rdi
call   1070 <fgetc@plt>
mov    0x2dbc(%rip),%rcx
xor    %r14d,%r14d
cmp    (%rcx),%al
jne    1269 <main+0xe9>
mov    %r15,%rdi
call   1070 <fgetc@plt>
mov    0x2da6(%rip),%rcx
cmp    (%rcx),%al
mov    %r15,0x38(%rsp)
mov    %r12,0x30(%rsp)
jne    12d6 <main+0x156>
movb   $0x1,0x7(%rsp)
xor    %ebp,%ebp
test   %r14d,%r14d
jne    1603 <main+0x483>
jmp    1795 <main+0x615>
lea    0x27f0(%rsp),%rbp
xor    %r14d,%r14d
jmp    12af <main+0x12f>
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%eax
imul   $0x64,%r14,%rcx
add    %rsp,%rcx
add    $0x27f0,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%r14
mov    %r12,%rdi
call   1070 <fgetc@plt>
add    $0x64,%rbp
mov    0x2d3d(%rip),%rcx
cmp    (%rcx),%al
je     1233 <main+0xb3>
xor    %ebx,%ebx
cmp    $0xa,%al
je     1280 <main+0x100>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
mov    %r12,%rdi
call   1070 <fgetc@plt>
cmp    $0xa,%al
jne    12c0 <main+0x140>
jmp    1280 <main+0x100>
mov    %r14,0x8(%rsp)
lea    0xe0(%rsp),%rbp
xor    %r14d,%r14d
jmp    131f <main+0x19f>
nopl   0x0(%rax,%rax,1)
mov    %ebx,%eax
imul   $0x64,%r14,%rcx
add    %rsp,%rcx
add    $0xe0,%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x1,%r14
mov    %r15,%rdi
call   1070 <fgetc@plt>
add    $0x64,%rbp
mov    0x2ccd(%rip),%rcx
cmp    (%rcx),%al
je     1346 <main+0x1c6>
xor    %ebx,%ebx
cmp    $0xa,%al
je     12f0 <main+0x170>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %al,0x0(%rbp,%rbx,1)
add    $0x1,%rbx
mov    %r15,%rdi
call   1070 <fgetc@plt>
cmp    $0xa,%al
jne    1330 <main+0x1b0>
jmp    12f0 <main+0x170>
test   %r14d,%r14d
sete   0x7(%rsp)
je     15ee <main+0x46e>
mov    %r14,0x20(%rsp)
mov    %r14d,%eax
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%eax
mov    %rax,0x50(%rsp)
xor    %r14d,%r14d
lea    0xcb3(%rip),%r15
mov    %r13,0x48(%rsp)
jmp    138f <main+0x20f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    0x40(%rsp),%r14
je     15e8 <main+0x468>
imul   $0x64,%r14,%rax
lea    (%rsp,%rax,1),%rsi
add    $0xe0,%rsi
lea    0x70(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strcpy@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
call   10a0 <strtok@plt>
mov    $0x0,%r12d
test   %rax,%rax
je     1440 <main+0x2c0>
mov    %rax,%rbp
xor    %r12d,%r12d
jmp    13e9 <main+0x269>
nopl   (%rax)
xor    %edi,%edi
lea    0xc4e(%rip),%r15
mov    %r15,%rsi
call   10a0 <strtok@plt>
mov    %rax,%rbp
test   %rax,%rax
je     1440 <main+0x2c0>
mov    %r13,%rbx
lea    0x9d20(%rsp),%r15
jmp    140a <main+0x28a>
cs nopw 0x0(%rax,%rax,1)
add    $0x64,%r15
add    $0xffffffffffffffff,%rbx
je     13d0 <main+0x250>
mov    %rbp,%rdi
mov    %r15,%rsi
call   1080 <strcmp@plt>
test   %rax,%rax
jne    1400 <main+0x280>
movslq %r12d,%r12
imul   $0x64,%r12,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x4f00,%rdi
mov    %rbp,%rsi
call   1040 <strcpy@plt>
add    $0x1,%r12d
jmp    1400 <main+0x280>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x8(%rsp)
je     1380 <main+0x200>
mov    %r12d,%eax
mov    %rax,0x68(%rsp)
xor    %ecx,%ecx
mov    %r14,0x58(%rsp)
mov    %r12,0x18(%rsp)
jmp    14ed <main+0x36d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14d,%ebx
mov    0x48(%rsp),%r13
add    %r12d,%ebx
sub    %r15d,%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %r15d,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd  %xmm1,%xmm0
mov    0x60(%rsp),%rdx
imul   $0x320,%rdx,%rax
add    %rsp,%rax
add    $0x1fcb0,%rax
mov    0x58(%rsp),%r14
movsd  %xmm0,(%rax,%r14,8)
imul   $0x190,%rdx,%rax
lea    (%rsp,%rax,1),%rcx
add    $0x16070,%rcx
mov    %ebx,(%rcx,%r14,4)
mov    %rdx,%rcx
add    %rsp,%rax
add    $0xc430,%rax
mov    %r15d,(%rax,%r14,4)
add    $0x1,%rcx
cmp    0x50(%rsp),%rcx
lea    0xb40(%rip),%r15
je     1380 <main+0x200>
mov    %rcx,0x60(%rsp)
imul   $0x64,%rcx,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x27f0,%rsi
lea    0x70(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <strcpy@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
call   10a0 <strtok@plt>
xor    %ebx,%ebx
test   %rax,%rax
je     15e0 <main+0x460>
lea    0x7610(%rsp),%rbp
xor    %r14d,%r14d
nop
mov    %rbp,%rdi
mov    %rax,%rsi
call   1040 <strcpy@plt>
add    $0x1,%r14
xor    %edi,%edi
mov    %r15,%rsi
call   10a0 <strtok@plt>
add    $0x64,%rbp
test   %rax,%rax
jne    1530 <main+0x3b0>
mov    $0x0,%r15d
test   %r14d,%r14d
je     1478 <main+0x2f8>
mov    %r14d,%eax
mov    %rax,0x10(%rsp)
xor    %r13d,%r13d
xor    %r15d,%r15d
jmp    1594 <main+0x414>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x10(%rsp),%r13
mov    0x18(%rsp),%r12
je     1470 <main+0x2f0>
test   %r12d,%r12d
jle    1580 <main+0x400>
imul   $0x64,%r13,%rax
lea    (%rsp,%rax,1),%rbp
add    $0x7610,%rbp
mov    0x68(%rsp),%r12
lea    0x4f00(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1080 <strcmp@plt>
cmp    $0x1,%rax
adc    $0x0,%r15d
add    $0x64,%rbx
add    $0xffffffffffffffff,%r12
jne    15c0 <main+0x440>
jmp    1580 <main+0x400>
nop
xor    %r15d,%r15d
jmp    1478 <main+0x2f8>
mov    0x20(%rsp),%ebp
jmp    15f5 <main+0x475>
xor    %ebp,%ebp
movb   $0x1,0x7(%rsp)
mov    0x8(%rsp),%r14
test   %r14d,%r14d
je     1795 <main+0x615>
mov    %r14d,%r13d
lea    -0x1(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    %ebp,%eax
and    $0x3,%eax
mov    %rax,0x10(%rsp)
and    $0xfffffffc,%ebp
lea    0x1fcc8(%rsp),%rbx
lea    0x1fcb0(%rsp),%r15
xor    %r14d,%r14d
jmp    16cc <main+0x54c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
imul   $0x64,%r14,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x27f0,%rsi
movslq %r12d,%rax
imul   $0x190,%r14,%rcx
lea    (%rsp,%rcx,1),%rdx
add    $0xc430,%rdx
mov    (%rdx,%rax,4),%edx
add    %rsp,%rcx
add    $0x16070,%rcx
mov    (%rcx,%rax,4),%ecx
imul   $0x320,%r14,%rdi
add    %rsp,%rdi
add    $0x1fcb0,%rdi
movsd  (%rdi,%rax,8),%xmm0
imul   $0x64,%rax,%rax
lea    (%rsp,%rax,1),%r8
add    $0xe0,%r8
lea    0x989(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r14
add    $0x320,%rbx
add    $0x320,%r15
cmp    %r13,%r14
je     1795 <main+0x615>
cmpb   $0x0,0x7(%rsp)
jne    1640 <main+0x4c0>
cmpq   $0x3,0x18(%rsp)
jae    16f0 <main+0x570>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1759 <main+0x5d9>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rbx,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %eax,%r12d
movsd  -0x10(%rbx,%rax,8),%xmm2
maxsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm2
lea    0x1(%rax),%ecx
cmovbe %r12d,%ecx
maxsd  %xmm1,%xmm2
movsd  -0x8(%rbx,%rax,8),%xmm1
ucomisd %xmm2,%xmm1
lea    0x2(%rax),%edx
cmovbe %ecx,%edx
maxsd  %xmm2,%xmm1
movsd  (%rbx,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
lea    0x3(%rax),%r12d
cmovbe %edx,%r12d
maxsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rbp,%rax
jne    1700 <main+0x580>
cmpq   $0x0,0x10(%rsp)
je     1640 <main+0x4c0>
mov    0x10(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %eax,%r12d
maxsd  %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1770 <main+0x5f0>
jmp    1640 <main+0x4c0>
mov    0x30(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x28(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x38(%rsp),%rdi
call   1050 <fclose@plt>
xor    %eax,%eax
add    $0x33538,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [11 x i8] c"corpus.txt\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [12 x i8] c"targets.txt\00"
@.str.3 = [12 x i8] c"matches.txt\00"
@.str.4 = [2 x i8] c"w\00"
@EOF = global i8 0
@.str.5 = [2 x i8] c",\00"
@.str.6 = [17 x i8] c"%s;%d/%d=%.2f;%s\00"
@.str.7 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i8
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca [100 x [100 x i8]]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [100 x [100 x i8]]
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca [100 x [100 x i8]]
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca [100 x [100 x i8]]
%20 = alloca [100 x [100 x i8]]
%21 = alloca i8*
%22 = alloca [100 x i8]
%23 = alloca [100 x [100 x double]]
%24 = alloca [100 x [100 x i32]]
%25 = alloca [100 x [100 x i32]]
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i8*
%36 = alloca double
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca double
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %3
%46 = call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %46, i32** %4
%47 = call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %47, i32** %5
%48 = call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32* %48, i32** %6
store i32 0, i32* %8
store i32 0, i32* %9
br label %49
49: ; preds = %77, %0
%50 = load i32*, i32** %4
%51 = call signext i8 @fgetc(i32* %50)
store i8 %51, i8* %2
%52 = sext i8 %51 to i32
%53 = icmp ne i32 %52, 10
br i1 %53, label %54, label %78
54: ; preds = %49
%55 = load i8, i8* %2
%56 = sext i8 %55 to i32
%57 = icmp eq i32 %56, 44
br i1 %57, label %58, label %67
58: ; preds = %54
%59 = load i32, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %7, i64 0, i64 %60
%62 = load i32, i32* %9
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [100 x i8], [100 x i8]* %61, i64 0, i64 %63
store i8 0, i8* %64
%65 = load i32, i32* %8
%66 = add nsw i32 %65, 1
store i32 %66, i32* %8
store i32 0, i32* %9
br label %77
67: ; preds = %54
%68 = load i8, i8* %2
%69 = load i32, i32* %8
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %7, i64 0, i64 %70
%72 = load i32, i32* %9
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [100 x i8], [100 x i8]* %71, i64 0, i64 %73
store i8 %68, i8* %74
%75 = load i32, i32* %9
%76 = add nsw i32 %75, 1
store i32 %76, i32* %9
br label %77
77: ; preds = %67, %58
br label %49
78: ; preds = %49
%79 = load i32, i32* %8
%80 = add nsw i32 %79, 1
store i32 %80, i32* %8
store i32 %80, i32* %3
store i32 0, i32* %10
br label %81
81: ; preds = %86, %78
%82 = load i32, i32* %10
%83 = load i32, i32* %3
%84 = icmp slt i32 %82, %83
br i1 %84, label %85, label %89
85: ; preds = %81
br label %86
86: ; preds = %85
%87 = load i32, i32* %10
%88 = add nsw i32 %87, 1
store i32 %88, i32* %10
br label %81
89: ; preds = %81
%90 = load i32*, i32** %5
%91 = call signext i8 @fgetc(i32* %90)
store i8 %91, i8* %2
store i32 0, i32* %12
store i32 0, i32* %13
br label %92
92: ; preds = %115, %89
%93 = load i8, i8* %2
%94 = sext i8 %93 to i32
%95 = load i8, i8* @EOF
%96 = sext i8 %95 to i32
%97 = icmp ne i32 %94, %96
br i1 %97, label %98, label %126
98: ; preds = %92
store i32 0, i32* %12
br label %99
99: ; preds = %103, %98
%100 = load i8, i8* %2
%101 = sext i8 %100 to i32
%102 = icmp ne i32 %101, 10
br i1 %102, label %103, label %115
103: ; preds = %99
%104 = load i8, i8* %2
%105 = load i32, i32* %13
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %11, i64 0, i64 %106
%108 = load i32, i32* %12
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [100 x i8], [100 x i8]* %107, i64 0, i64 %109
store i8 %104, i8* %110
%111 = load i32, i32* %12
%112 = add nsw i32 %111, 1
store i32 %112, i32* %12
%113 = load i32*, i32** %5
%114 = call signext i8 @fgetc(i32* %113)
store i8 %114, i8* %2
br label %99
115: ; preds = %99
%116 = load i32, i32* %13
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %11, i64 0, i64 %117
%119 = load i32, i32* %12
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [100 x i8], [100 x i8]* %118, i64 0, i64 %120
store i8 0, i8* %121
%122 = load i32, i32* %13
%123 = add nsw i32 %122, 1
store i32 %123, i32* %13
%124 = load i32*, i32** %5
%125 = call signext i8 @fgetc(i32* %124)
store i8 %125, i8* %2
br label %92
126: ; preds = %92
store i32 0, i32* %14
br label %127
127: ; preds = %132, %126
%128 = load i32, i32* %14
%129 = load i32, i32* %13
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %135
131: ; preds = %127
br label %132
132: ; preds = %131
%133 = load i32, i32* %14
%134 = add nsw i32 %133, 1
store i32 %134, i32* %14
br label %127
135: ; preds = %127
store i32 0, i32* %16
store i32 0, i32* %17
%136 = load i32*, i32** %4
%137 = call signext i8 @fgetc(i32* %136)
store i8 %137, i8* %2
br label %138
138: ; preds = %161, %135
%139 = load i8, i8* %2
%140 = sext i8 %139 to i32
%141 = load i8, i8* @EOF
%142 = sext i8 %141 to i32
%143 = icmp ne i32 %140, %142
br i1 %143, label %144, label %172
144: ; preds = %138
store i32 0, i32* %16
br label %145
145: ; preds = %149, %144
%146 = load i8, i8* %2
%147 = sext i8 %146 to i32
%148 = icmp ne i32 %147, 10
br i1 %148, label %149, label %161
149: ; preds = %145
%150 = load i8, i8* %2
%151 = load i32, i32* %17
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %15, i64 0, i64 %152
%154 = load i32, i32* %16
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [100 x i8], [100 x i8]* %153, i64 0, i64 %155
store i8 %150, i8* %156
%157 = load i32, i32* %16
%158 = add nsw i32 %157, 1
store i32 %158, i32* %16
%159 = load i32*, i32** %4
%160 = call signext i8 @fgetc(i32* %159)
store i8 %160, i8* %2
br label %145
161: ; preds = %145
%162 = load i32, i32* %17
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %15, i64 0, i64 %163
%165 = load i32, i32* %16
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds [100 x i8], [100 x i8]* %164, i64 0, i64 %166
store i8 0, i8* %167
%168 = load i32, i32* %17
%169 = add nsw i32 %168, 1
store i32 %169, i32* %17
%170 = load i32*, i32** %4
%171 = call signext i8 @fgetc(i32* %170)
store i8 %171, i8* %2
br label %138
172: ; preds = %138
store i32 0, i32* %18
br label %173
173: ; preds = %178, %172
%174 = load i32, i32* %18
%175 = load i32, i32* %17
%176 = icmp slt i32 %174, %175
br i1 %176, label %177, label %181
177: ; preds = %173
br label %178
178: ; preds = %177
%179 = load i32, i32* %18
%180 = add nsw i32 %179, 1
store i32 %180, i32* %18
br label %173
181: ; preds = %173
store i32 0, i32* %37
br label %182
182: ; preds = %340, %181
%183 = load i32, i32* %37
%184 = load i32, i32* %17
%185 = icmp slt i32 %183, %184
br i1 %185, label %186, label %343
186: ; preds = %182
%187 = getelementptr inbounds [100 x i8], [100 x i8]* %22, i64 0, i64 0
%188 = load i32, i32* %37
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %15, i64 0, i64 %189
%191 = getelementptr inbounds [100 x i8], [100 x i8]* %190, i64 0, i64 0
%192 = call i32 @strcpy(i8* %187, i8* %191)
%193 = getelementptr inbounds [100 x i8], [100 x i8]* %22, i64 0, i64 0
%194 = call i8* @strtok(i8* %193, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %194, i8** %21
store i32 0, i32* %27
br label %195
195: ; preds = %224, %186
%196 = load i8*, i8** %21
%197 = icmp ne i8* %196, null
br i1 %197, label %198, label %226
198: ; preds = %195
store i32 0, i32* %38
br label %199
199: ; preds = %221, %198
%200 = load i32, i32* %38
%201 = load i32, i32* %3
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %224
203: ; preds = %199
%204 = load i8*, i8** %21
%205 = load i32, i32* %38
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %7, i64 0, i64 %206
%208 = getelementptr inbounds [100 x i8], [100 x i8]* %207, i64 0, i64 0
%209 = call i64 @strcmp(i8* %204, i8* %208)
%210 = icmp eq i64 %209, 0
br i1 %210, label %211, label %220
211: ; preds = %203
%212 = load i32, i32* %27
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %20, i64 0, i64 %213
%215 = getelementptr inbounds [100 x i8], [100 x i8]* %214, i64 0, i64 0
%216 = load i8*, i8** %21
%217 = call i32 @strcpy(i8* %215, i8* %216)
%218 = load i32, i32* %27
%219 = add nsw i32 %218, 1
store i32 %219, i32* %27
br label %220
220: ; preds = %211, %203
br label %221
221: ; preds = %220
%222 = load i32, i32* %38
%223 = add nsw i32 %222, 1
store i32 %223, i32* %38
br label %199
224: ; preds = %199
%225 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %225, i8** %21
br label %195
226: ; preds = %195
store i32 0, i32* %39
br label %227
227: ; preds = %232, %226
%228 = load i32, i32* %39
%229 = load i32, i32* %27
%230 = icmp slt i32 %228, %229
br i1 %230, label %231, label %235
231: ; preds = %227
br label %232
232: ; preds = %231
%233 = load i32, i32* %39
%234 = add nsw i32 %233, 1
store i32 %234, i32* %39
br label %227
235: ; preds = %227
%236 = load i32, i32* %27
store i32 %236, i32* %31
store i32 0, i32* %40
br label %237
237: ; preds = %336, %235
%238 = load i32, i32* %40
%239 = load i32, i32* %13
%240 = icmp slt i32 %238, %239
br i1 %240, label %241, label %339
241: ; preds = %237
%242 = getelementptr inbounds [100 x i8], [100 x i8]* %22, i64 0, i64 0
%243 = load i32, i32* %40
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %11, i64 0, i64 %244
%246 = getelementptr inbounds [100 x i8], [100 x i8]* %245, i64 0, i64 0
%247 = call i32 @strcpy(i8* %242, i8* %246)
%248 = getelementptr inbounds [100 x i8], [100 x i8]* %22, i64 0, i64 0
%249 = call i8* @strtok(i8* %248, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %249, i8** %35
store i32 0, i32* %28
br label %250
250: ; preds = %253, %241
%251 = load i8*, i8** %35
%252 = icmp ne i8* %251, null
br i1 %252, label %253, label %263
253: ; preds = %250
%254 = load i32, i32* %28
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %19, i64 0, i64 %255
%257 = getelementptr inbounds [100 x i8], [100 x i8]* %256, i64 0, i64 0
%258 = load i8*, i8** %35
%259 = call i32 @strcpy(i8* %257, i8* %258)
%260 = load i32, i32* %28
%261 = add nsw i32 %260, 1
store i32 %261, i32* %28
%262 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i8* %262, i8** %35
br label %250
263: ; preds = %250
store i32 0, i32* %41
br label %264
264: ; preds = %269, %263
%265 = load i32, i32* %41
%266 = load i32, i32* %28
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %272
268: ; preds = %264
br label %269
269: ; preds = %268
%270 = load i32, i32* %41
%271 = add nsw i32 %270, 1
store i32 %271, i32* %41
br label %264
272: ; preds = %264
store i32 0, i32* %32
store i32 0, i32* %34
br label %273
273: ; preds = %301, %272
%274 = load i32, i32* %34
%275 = load i32, i32* %28
%276 = icmp slt i32 %274, %275
br i1 %276, label %277, label %304
277: ; preds = %273
store i32 0, i32* %33
br label %278
278: ; preds = %297, %277
%279 = load i32, i32* %33
%280 = load i32, i32* %27
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %300
282: ; preds = %278
%283 = load i32, i32* %34
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %19, i64 0, i64 %284
%286 = getelementptr inbounds [100 x i8], [100 x i8]* %285, i64 0, i64 0
%287 = load i32, i32* %33
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %20, i64 0, i64 %288
%290 = getelementptr inbounds [100 x i8], [100 x i8]* %289, i64 0, i64 0
%291 = call i64 @strcmp(i8* %286, i8* %290)
%292 = icmp eq i64 %291, 0
br i1 %292, label %293, label %296
293: ; preds = %282
%294 = load i32, i32* %32
%295 = add nsw i32 %294, 1
store i32 %295, i32* %32
br label %296
296: ; preds = %293, %282
br label %297
297: ; preds = %296
%298 = load i32, i32* %33
%299 = add nsw i32 %298, 1
store i32 %299, i32* %33
br label %278
300: ; preds = %278
br label %301
301: ; preds = %300
%302 = load i32, i32* %34
%303 = add nsw i32 %302, 1
store i32 %303, i32* %34
br label %273
304: ; preds = %273
%305 = load i32, i32* %27
%306 = load i32, i32* %28
%307 = add nsw i32 %305, %306
%308 = load i32, i32* %32
%309 = sub nsw i32 %307, %308
store i32 %309, i32* %29
%310 = load i32, i32* %32
%311 = sitofp i32 %310 to double
%312 = load i32, i32* %29
%313 = sitofp i32 %312 to double
%314 = fdiv double %311, %313
store double %314, double* %36
%315 = load double, double* %36
%316 = load i32, i32* %40
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %23, i64 0, i64 %317
%319 = load i32, i32* %37
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [100 x double], [100 x double]* %318, i64 0, i64 %320
store double %315, double* %321
%322 = load i32, i32* %29
%323 = load i32, i32* %40
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %24, i64 0, i64 %324
%326 = load i32, i32* %37
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [100 x i32], [100 x i32]* %325, i64 0, i64 %327
store i32 %322, i32* %328
%329 = load i32, i32* %32
%330 = load i32, i32* %40
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %25, i64 0, i64 %331
%333 = load i32, i32* %37
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [100 x i32], [100 x i32]* %332, i64 0, i64 %334
store i32 %329, i32* %335
br label %336
336: ; preds = %304
%337 = load i32, i32* %40
%338 = add nsw i32 %337, 1
store i32 %338, i32* %40
br label %237
339: ; preds = %237
br label %340
340: ; preds = %339
%341 = load i32, i32* %37
%342 = add nsw i32 %341, 1
store i32 %342, i32* %37
br label %182
343: ; preds = %182
store i32 0, i32* %44
br label %344
344: ; preds = %408, %343
%345 = load i32, i32* %44
%346 = load i32, i32* %13
%347 = icmp slt i32 %345, %346
br i1 %347, label %348, label %411
348: ; preds = %344
store double 0.000000e+00, double* %42
store i32 0, i32* %45
br label %349
349: ; preds = %373, %348
%350 = load i32, i32* %45
%351 = load i32, i32* %17
%352 = icmp slt i32 %350, %351
br i1 %352, label %353, label %376
353: ; preds = %349
%354 = load i32, i32* %44
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %23, i64 0, i64 %355
%357 = load i32, i32* %45
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds [100 x double], [100 x double]* %356, i64 0, i64 %358
%360 = load double, double* %359
%361 = load double, double* %42
%362 = fcmp ogt double %360, %361
br i1 %362, label %363, label %372
363: ; preds = %353
%364 = load i32, i32* %44
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %23, i64 0, i64 %365
%367 = load i32, i32* %45
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds [100 x double], [100 x double]* %366, i64 0, i64 %368
%370 = load double, double* %369
store double %370, double* %42
%371 = load i32, i32* %45
store i32 %371, i32* %43
br label %372
372: ; preds = %363, %353
br label %373
373: ; preds = %372
%374 = load i32, i32* %45
%375 = add nsw i32 %374, 1
store i32 %375, i32* %45
br label %349
376: ; preds = %349
%377 = load i32, i32* %44
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %11, i64 0, i64 %378
%380 = getelementptr inbounds [100 x i8], [100 x i8]* %379, i64 0, i64 0
%381 = load i32, i32* %44
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %25, i64 0, i64 %382
%384 = load i32, i32* %43
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds [100 x i32], [100 x i32]* %383, i64 0, i64 %385
%387 = load i32, i32* %386
%388 = load i32, i32* %44
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %24, i64 0, i64 %389
%391 = load i32, i32* %43
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds [100 x i32], [100 x i32]* %390, i64 0, i64 %392
%394 = load i32, i32* %393
%395 = load i32, i32* %44
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %23, i64 0, i64 %396
%398 = load i32, i32* %43
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds [100 x double], [100 x double]* %397, i64 0, i64 %399
%401 = load double, double* %400
%402 = load i32, i32* %43
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %15, i64 0, i64 %403
%405 = getelementptr inbounds [100 x i8], [100 x i8]* %404, i64 0, i64 0
%406 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), i8* %380, i32 %387, i32 %394, double %401, i8* %405)
%407 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %408
408: ; preds = %376
%409 = load i32, i32* %44
%410 = add nsw i32 %409, 1
store i32 %410, i32* %44
br label %344
411: ; preds = %344
%412 = load i32*, i32** %5
%413 = call i32 @fclose(i32* %412)
%414 = load i32*, i32** %6
%415 = call i32 @fclose(i32* %414)
%416 = load i32*, i32** %4
%417 = call i32 @fclose(i32* %416)
ret i32 0
}

LLVM IR (-O2):
@.str = [11 x i8] c"corpus.txt\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [12 x i8] c"targets.txt\00"
@.str.3 = [12 x i8] c"matches.txt\00"
@.str.4 = [2 x i8] c"w\00"
@EOF = global i8 0
@.str.5 = [2 x i8] c",\00"
@.str.6 = [17 x i8] c"%s;%d/%d=%.2f;%s\00"
define i32 @main() {
%1 = alloca [100 x [100 x i8]]
%2 = alloca [100 x [100 x i8]]
%3 = alloca [100 x [100 x i8]]
%4 = alloca [100 x [100 x i8]]
%5 = alloca [100 x [100 x i8]]
%6 = alloca [100 x i8]
%7 = alloca [100 x [100 x double]]
%8 = alloca [100 x [100 x i32]]
%9 = alloca [100 x [100 x i32]]
%10 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %1, i64 0, i64 0, i64 0
%11 = tail call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%12 = tail call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%13 = tail call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
br label %14
14: ; preds = %25, %0
%15 = phi i32 [ %29, %25 ], [ 0, %0 ]
%16 = zext i32 %15 to i64
br label %17
17: ; preds = %14, %30
%18 = phi i32 [ %33, %30 ], [ 0, %14 ]
%19 = tail call signext i8 @fgetc(i32* %11)
switch i8 %19, label %30 [
i8 10, label %20
i8 44, label %25
]
20: ; preds = %17
%21 = tail call signext i8 @fgetc(i32* %12)
%22 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %2, i64 0, i64 0, i64 0
%23 = load i8, i8* @EOF
%24 = icmp eq i8 %21, %23
br i1 %24, label %40, label %34
25: ; preds = %17
%26 = zext i32 %15 to i64
%27 = zext i32 %18 to i64
%28 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %1, i64 0, i64 %26, i64 %27
store i8 0, i8* %28
%29 = add nuw nsw i32 %15, 1
br label %14
30: ; preds = %17
%31 = zext i32 %18 to i64
%32 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %1, i64 0, i64 %16, i64 %31
store i8 %19, i8* %32
%33 = add nuw nsw i32 %18, 1
br label %17
34: ; preds = %20, %60
%35 = phi i64 [ %64, %60 ], [ 0, %20 ]
%36 = phi i8 [ %65, %60 ], [ %21, %20 ]
%37 = icmp eq i8 %36, 10
br i1 %37, label %60, label %53
38: ; preds = %60
%39 = trunc i64 %64 to i32
br label %40
40: ; preds = %38, %20
%41 = phi i32 [ 0, %20 ], [ %39, %38 ]
%42 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %3, i64 0, i64 0, i64 0
%43 = tail call signext i8 @fgetc(i32* %11)
%44 = load i8, i8* @EOF
%45 = icmp eq i8 %43, %44
br i1 %45, label %46, label %68
46: ; preds = %40
%47 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %4, i64 0, i64 0, i64 0
%48 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %5, i64 0, i64 0, i64 0
%49 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%50 = bitcast [100 x [100 x double]]* %7 to i8*
%51 = bitcast [100 x [100 x i32]]* %8 to i8*
%52 = bitcast [100 x [100 x i32]]* %9 to i8*
br label %104
53: ; preds = %34, %53
%54 = phi i64 [ %57, %53 ], [ 0, %34 ]
%55 = phi i8 [ %58, %53 ], [ %36, %34 ]
%56 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %2, i64 0, i64 %35, i64 %54
store i8 %55, i8* %56
%57 = add nuw i64 %54, 1
%58 = tail call signext i8 @fgetc(i32* %12)
%59 = icmp eq i8 %58, 10
br i1 %59, label %60, label %53
60: ; preds = %53, %34
%61 = phi i64 [ 0, %34 ], [ %57, %53 ]
%62 = and i64 %61, 4294967295
%63 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %2, i64 0, i64 %35, i64 %62
store i8 0, i8* %63
%64 = add nuw i64 %35, 1
%65 = tail call signext i8 @fgetc(i32* %12)
%66 = load i8, i8* @EOF
%67 = icmp eq i8 %65, %66
br i1 %67, label %38, label %34
68: ; preds = %40, %88
%69 = phi i64 [ %92, %88 ], [ 0, %40 ]
%70 = phi i8 [ %93, %88 ], [ %43, %40 ]
%71 = icmp eq i8 %70, 10
br i1 %71, label %88, label %81
72: ; preds = %88
%73 = trunc i64 %92 to i32
%74 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %4, i64 0, i64 0, i64 0
%75 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %5, i64 0, i64 0, i64 0
%76 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%77 = bitcast [100 x [100 x double]]* %7 to i8*
%78 = bitcast [100 x [100 x i32]]* %8 to i8*
%79 = bitcast [100 x [100 x i32]]* %9 to i8*
%80 = icmp eq i32 %73, 0
br i1 %80, label %104, label %96
81: ; preds = %68, %81
%82 = phi i64 [ %85, %81 ], [ 0, %68 ]
%83 = phi i8 [ %86, %81 ], [ %70, %68 ]
%84 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %3, i64 0, i64 %69, i64 %82
store i8 %83, i8* %84
%85 = add nuw i64 %82, 1
%86 = tail call signext i8 @fgetc(i32* %11)
%87 = icmp eq i8 %86, 10
br i1 %87, label %88, label %81
88: ; preds = %81, %68
%89 = phi i64 [ 0, %68 ], [ %85, %81 ]
%90 = and i64 %89, 4294967295
%91 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %3, i64 0, i64 %69, i64 %90
store i8 0, i8* %91
%92 = add nuw i64 %69, 1
%93 = tail call signext i8 @fgetc(i32* %11)
%94 = load i8, i8* @EOF
%95 = icmp eq i8 %93, %94
br i1 %95, label %72, label %68
96: ; preds = %72
%97 = icmp eq i32 %41, 0
%98 = add nuw nsw i32 %15, 1
%99 = and i64 %92, 4294967295
%100 = zext i32 %98 to i64
%101 = zext i32 %41 to i64
br label %115
102: ; preds = %147
%103 = and i64 %92, 4294967295
br label %104
104: ; preds = %102, %46, %72
%105 = phi i1 [ true, %46 ], [ true, %72 ], [ %80, %102 ]
%106 = phi i64 [ 0, %46 ], [ 0, %72 ], [ %103, %102 ]
%107 = icmp eq i32 %41, 0
br i1 %107, label %205, label %108
108: ; preds = %104
%109 = zext i32 %41 to i64
%110 = add nsw i64 %106, -1
%111 = and i64 %106, 3
%112 = icmp ult i64 %110, 3
%113 = and i64 %106, 4294967292
%114 = icmp eq i64 %111, 0
br label %201
115: ; preds = %96, %147
%116 = phi i64 [ 0, %96 ], [ %148, %147 ]
%117 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %3, i64 0, i64 %116, i64 0
%118 = call i32 @strcpy(i8* %76, i8* %117)
%119 = call i8* @strtok(i8* %76, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%120 = icmp eq i8* %119, null
br i1 %120, label %121, label %123
121: ; preds = %126, %115
%122 = phi i32 [ 0, %115 ], [ %141, %126 ]
br i1 %97, label %147, label %144
123: ; preds = %115, %126
%124 = phi i32 [ %141, %126 ], [ 0, %115 ]
%125 = phi i8* [ %127, %126 ], [ %119, %115 ]
br label %129
126: ; preds = %140
%127 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%128 = icmp eq i8* %127, null
br i1 %128, label %121, label %123
129: ; preds = %123, %140
%130 = phi i64 [ %142, %140 ], [ 0, %123 ]
%131 = phi i32 [ %141, %140 ], [ %124, %123 ]
%132 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %1, i64 0, i64 %130, i64 0
%133 = call i64 @strcmp(i8* %125, i8* %132)
%134 = icmp eq i64 %133, 0
br i1 %134, label %135, label %140
135: ; preds = %129
%136 = sext i32 %131 to i64
%137 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %5, i64 0, i64 %136, i64 0
%138 = call i32 @strcpy(i8* %137, i8* %125)
%139 = add nsw i32 %131, 1
br label %140
140: ; preds = %129, %135
%141 = phi i32 [ %139, %135 ], [ %131, %129 ]
%142 = add nuw nsw i64 %130, 1
%143 = icmp eq i64 %142, %100
br i1 %143, label %126, label %129
144: ; preds = %121
%145 = icmp sgt i32 %122, 0
%146 = zext i32 %122 to i64
br label %150
147: ; preds = %188, %121
%148 = add nuw nsw i64 %116, 1
%149 = icmp eq i64 %148, %99
br i1 %149, label %102, label %115
150: ; preds = %144, %188
%151 = phi i64 [ 0, %144 ], [ %199, %188 ]
%152 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %2, i64 0, i64 %151, i64 0
%153 = call i32 @strcpy(i8* %76, i8* %152)
%154 = call i8* @strtok(i8* %76, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%155 = icmp eq i8* %154, null
br i1 %155, label %188, label %159
156: ; preds = %159
%157 = trunc i64 %164 to i32
%158 = icmp eq i32 %157, 0
br i1 %158, label %188, label %167
159: ; preds = %150, %159
%160 = phi i64 [ %164, %159 ], [ 0, %150 ]
%161 = phi i8* [ %165, %159 ], [ %154, %150 ]
%162 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %4, i64 0, i64 %160, i64 0
%163 = call i32 @strcpy(i8* %162, i8* %161)
%164 = add nuw i64 %160, 1
%165 = call i8* @strtok(i8* null, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%166 = icmp eq i8* %165, null
br i1 %166, label %156, label %159
167: ; preds = %156
%168 = and i64 %164, 4294967295
br label %169
169: ; preds = %167, %184
%170 = phi i64 [ 0, %167 ], [ %186, %184 ]
%171 = phi i32 [ 0, %167 ], [ %185, %184 ]
br i1 %145, label %172, label %184
172: ; preds = %169
%173 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %4, i64 0, i64 %170, i64 0
br label %174
174: ; preds = %172, %174
%175 = phi i64 [ 0, %172 ], [ %182, %174 ]
%176 = phi i32 [ %171, %172 ], [ %181, %174 ]
%177 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %5, i64 0, i64 %175, i64 0
%178 = call i64 @strcmp(i8* %173, i8* %177)
%179 = icmp eq i64 %178, 0
%180 = zext i1 %179 to i32
%181 = add nsw i32 %176, %180
%182 = add nuw nsw i64 %175, 1
%183 = icmp eq i64 %182, %146
br i1 %183, label %184, label %174
184: ; preds = %174, %169
%185 = phi i32 [ %171, %169 ], [ %181, %174 ]
%186 = add nuw nsw i64 %170, 1
%187 = icmp eq i64 %186, %168
br i1 %187, label %188, label %169
188: ; preds = %184, %150, %156
%189 = phi i32 [ 0, %156 ], [ 0, %150 ], [ %157, %184 ]
%190 = phi i32 [ 0, %156 ], [ 0, %150 ], [ %185, %184 ]
%191 = add nsw i32 %189, %122
%192 = sub i32 %191, %190
%193 = sitofp i32 %190 to double
%194 = sitofp i32 %192 to double
%195 = fdiv double %193, %194
%196 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %151, i64 %116
store double %195, double* %196
%197 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %8, i64 0, i64 %151, i64 %116
store i32 %192, i32* %197
%198 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %9, i64 0, i64 %151, i64 %116
store i32 %190, i32* %198
%199 = add nuw nsw i64 %151, 1
%200 = icmp eq i64 %199, %101
br i1 %200, label %147, label %150
201: ; preds = %108, %234
%202 = phi i64 [ 0, %108 ], [ %247, %234 ]
%203 = phi i32 [ undef, %108 ], [ %235, %234 ]
br i1 %105, label %234, label %204
204: ; preds = %201
br i1 %112, label %215, label %249
205: ; preds = %234, %104
%206 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %4, i64 0, i64 0, i64 0
%207 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %5, i64 0, i64 0, i64 0
%208 = getelementptr inbounds [100 x i8], [100 x i8]* %6, i64 0, i64 0
%209 = bitcast [100 x [100 x double]]* %7 to i8*
%210 = bitcast [100 x [100 x i32]]* %8 to i8*
%211 = bitcast [100 x [100 x i32]]* %9 to i8*
%212 = call i32 @fclose(i32* %12)
%213 = call i32 @fclose(i32* %13)
%214 = call i32 @fclose(i32* %11)
ret i32 0
215: ; preds = %249, %204
%216 = phi i32 [ undef, %204 ], [ %280, %249 ]
%217 = phi i64 [ 0, %204 ], [ %281, %249 ]
%218 = phi i32 [ %203, %204 ], [ %280, %249 ]
%219 = phi double [ 0.000000e+00, %204 ], [ %278, %249 ]
br i1 %114, label %234, label %220
220: ; preds = %215, %220
%221 = phi i64 [ %231, %220 ], [ %217, %215 ]
%222 = phi i32 [ %230, %220 ], [ %218, %215 ]
%223 = phi double [ %228, %220 ], [ %219, %215 ]
%224 = phi i64 [ %232, %220 ], [ 0, %215 ]
%225 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %221
%226 = load double, double* %225
%227 = fcmp ogt double %226, %223
%228 = select i1 %227, double %226, double %223
%229 = trunc i64 %221 to i32
%230 = select i1 %227, i32 %229, i32 %222
%231 = add nuw nsw i64 %221, 1
%232 = add i64 %224, 1
%233 = icmp eq i64 %232, %111
br i1 %233, label %234, label %220
234: ; preds = %215, %220, %201
%235 = phi i32 [ %203, %201 ], [ %216, %215 ], [ %230, %220 ]
%236 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %2, i64 0, i64 %202, i64 0
%237 = sext i32 %235 to i64
%238 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %9, i64 0, i64 %202, i64 %237
%239 = load i32, i32* %238
%240 = getelementptr inbounds [100 x [100 x i32]], [100 x [100 x i32]]* %8, i64 0, i64 %202, i64 %237
%241 = load i32, i32* %240
%242 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %237
%243 = load double, double* %242
%244 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %3, i64 0, i64 %237, i64 0
%245 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.6, i64 0, i64 0), i8* %236, i32 %239, i32 %241, double %243, i8* %244)
%246 = call i32 @putchar(i32 10)
%247 = add nuw nsw i64 %202, 1
%248 = icmp eq i64 %247, %109
br i1 %248, label %205, label %201
249: ; preds = %204, %249
%250 = phi i64 [ %281, %249 ], [ 0, %204 ]
%251 = phi i32 [ %280, %249 ], [ %203, %204 ]
%252 = phi double [ %278, %249 ], [ 0.000000e+00, %204 ]
%253 = phi i64 [ %282, %249 ], [ 0, %204 ]
%254 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %250
%255 = load double, double* %254
%256 = fcmp ogt double %255, %252
%257 = select i1 %256, double %255, double %252
%258 = trunc i64 %250 to i32
%259 = select i1 %256, i32 %258, i32 %251
%260 = or i64 %250, 1
%261 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %260
%262 = load double, double* %261
%263 = fcmp ogt double %262, %257
%264 = select i1 %263, double %262, double %257
%265 = trunc i64 %260 to i32
%266 = select i1 %263, i32 %265, i32 %259
%267 = or i64 %250, 2
%268 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %267
%269 = load double, double* %268
%270 = fcmp ogt double %269, %264
%271 = select i1 %270, double %269, double %264
%272 = trunc i64 %267 to i32
%273 = select i1 %270, i32 %272, i32 %266
%274 = or i64 %250, 3
%275 = getelementptr inbounds [100 x [100 x double]], [100 x [100 x double]]* %7, i64 0, i64 %202, i64 %274
%276 = load double, double* %275
%277 = fcmp ogt double %276, %271
%278 = select i1 %277, double %276, double %271
%279 = trunc i64 %274 to i32
%280 = select i1 %277, i32 %279, i32 %273
%281 = add nuw nsw i64 %250, 4
%282 = add i64 %253, 4
%283 = icmp eq i64 %282, %113
br i1 %283, label %215, label %249
}