#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 /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
float log(int);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, char *, char *);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
int main(int argc, char *argv[]) {
  int arg_len = 1000;
  char species[arg_len];
  strcpy(species, argv[1]);
  char analysis[arg_len];
  strcpy(analysis, argv[2]);
  char base_dir[arg_len];
  strcpy(base_dir, argv[3]);
  char category[arg_len];
  strcpy(category, argv[4]);
  char category_file[arg_len];
  strcpy(category_file, argv[5]);
  char log_file_name[arg_len];
  strcpy(log_file_name, base_dir);
  strcat(log_file_name, "/Analysis/log.txt");
  FILE *log_file = fopen(log_file_name, "a");
  char output_file_name[arg_len];
  strcpy(output_file_name, base_dir);
  strcat(output_file_name, "/Analysis/");
  strcat(output_file_name, analysis);
  strcat(output_file_name, "/");
  strcat(output_file_name, species);
  strcat(output_file_name, "_");
  strcat(output_file_name, analysis);
  strcat(output_file_name, "/");
  strcat(output_file_name, species);
  strcat(output_file_name, "_");
  strcat(output_file_name, category_file);
  strcat(output_file_name, "_di.csv");
  FILE *output = fopen(output_file_name, "w");
  fprintf(output, "Isolate_1,Isolate_2,SNPs,Sites,Divergence\n");
  char isolates_file_name[arg_len];
  strcpy(isolates_file_name, base_dir);
  strcat(isolates_file_name, "/Analysis/Core_genome_alignment/");
  strcat(isolates_file_name, species);
  strcat(isolates_file_name, "_Core_genome_alignment/");
  strcat(isolates_file_name, species);
  strcat(isolates_file_name, "_isolates.txt");
  char isolate_name[arg_len];
  int isolate_count;
  isolate_count = 0;
  FILE *isolates_file = fopen(isolates_file_name, "r");
  if (isolates_file != NULL) {
    while (fgets(isolate_name, sizeof isolate_name, isolates_file) != NULL) {
      isolate_count++;
    }
    fclose(isolates_file);
  } else {
    perror(isolates_file_name);
  }
  char isolate_name_array[isolate_count][arg_len];
  char isolate_file_name_array[isolate_count][arg_len];
  isolate_count = 0;
  FILE *isolates_file_2 = fopen(isolates_file_name, "r");
  if (isolates_file_2 != NULL) {
    while (fgets(isolate_name, sizeof isolate_name, isolates_file_2) != NULL) {
      int isolate_name_len;
      isolate_name_len = strlen(isolate_name);
      if (isolate_name[(isolate_name_len - 1)] == '\n') {
        isolate_name[(isolate_name_len - 1)] = '\0';
      }
      strcpy(isolate_name_array[isolate_count], isolate_name);
      strcpy(isolate_file_name_array[isolate_count], base_dir);
      strcat(isolate_file_name_array[isolate_count], "/Analysis/");
      strcat(isolate_file_name_array[isolate_count], analysis);
      strcat(isolate_file_name_array[isolate_count], "/");
      strcat(isolate_file_name_array[isolate_count], species);
      strcat(isolate_file_name_array[isolate_count], "_");
      strcat(isolate_file_name_array[isolate_count], analysis);
      strcat(isolate_file_name_array[isolate_count], "/Intergenic_");
      strcat(isolate_file_name_array[isolate_count], category_file);
      strcat(isolate_file_name_array[isolate_count], "_files/");
      strcat(isolate_file_name_array[isolate_count], isolate_name);
      strcat(isolate_file_name_array[isolate_count], ".fasta");
      isolate_count++;
    }
    fclose(isolates_file_2);
  } else {
    perror(isolates_file_name);
  }
  int a;
  int b;
  int i;
  int genome_max = 1000000;
  char genome1[genome_max];
  char genome2[genome_max];
  int count;
  count = 0;
  for (a = 0; a < isolate_count; a++) {
    FILE *file1 = fopen(isolate_file_name_array[a], "r");
    if (file1 != NULL) {
      char line1[genome_max];
      while (fgets(line1, sizeof line1, file1) != NULL) {
        if (line1[0] != '>') {
          int line1_len = strlen(line1);
          line1_len = (line1_len - 1);
          if (line1[line1_len] == '\n') {
            line1[line1_len] = '\0';
          }
          strcpy(genome1, line1);
          fclose(file1);
        }
      }
    } else {
      perror(isolate_file_name_array[a]);
    }
    for (b = 0; b < isolate_count; b++) {
      if (a > b) {
        FILE *file2 = fopen(isolate_file_name_array[b], "r");
        if (file2 != NULL) {
          char line2[genome_max];
          while (fgets(line2, sizeof line2, file2) != NULL) {
            if (line2[0] != '>') {
              int line2_len = strlen(line2);
              line2_len = (line2_len - 1);
              if (line2[line2_len] == '\n') {
                line2[line2_len] = '\0';
              }
              strcpy(genome2, line2);
              fclose(file2);
            }
          }
        } else {
          perror(isolate_file_name_array[b]);
        }
        int genome_len;
        genome_len = strlen(genome1);
        int snp;
        snp = 0;
        int n;
        n = 0;
        for (i = 0; i < genome_len; i++) {
          if (genome1[i] == 'N' || genome2[i] == 'N') {
            n++;
          } else {
            if (genome1[i] != genome2[i]) {
              snp++;
            }
          }
        }
        int sites;
        sites = (genome_len - n);
        float div;
        div = ((float)snp / sites);
        float JC_div;
        JC_div = (((float)-3 / 4) * (log(1 - (((float)4 / 3) * div))));
        fprintf(output, "%s,%s,%i,%i,%0.6f\n", isolate_name_array[a],
                isolate_name_array[b], snp, sites, JC_div);
        count++;
      }
    }
  }
  printf("%s intergenic annotation %s di calculated.\n", species,
         category_file);
  fprintf(log_file, "%s intergenic annotation %s di calculated.\n", species,
          category_file);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1e0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x3e8,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x20(%rbp)
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x158(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
call   1030 <strcpy@plt>
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x188(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rsi
call   1030 <strcpy@plt>
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x160(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rsi
call   1030 <strcpy@plt>
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rsi
call   1030 <strcpy@plt>
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x170(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rsi
call   1030 <strcpy@plt>
mov    -0x160(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x190(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x50(%rbp)
call   1030 <strcpy@plt>
mov    -0x190(%rbp),%rdi
lea    0xd25(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x190(%rbp),%rdi
lea    0xdc7(%rip),%rsi
call   10a0 <fopen@plt>
mov    -0x160(%rbp),%rsi
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x168(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x60(%rbp)
call   1030 <strcpy@plt>
mov    -0x168(%rbp),%rdi
lea    0xcdf(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x188(%rbp),%rsi
mov    -0x168(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
lea    0xd55(%rip),%rsi
mov    %rsi,-0x180(%rbp)
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
mov    -0x158(%rbp),%rsi
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
lea    0xd20(%rip),%rsi
mov    %rsi,-0x178(%rbp)
call   10c0 <strcat@plt>
mov    -0x188(%rbp),%rsi
mov    -0x168(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x180(%rbp),%rsi
mov    -0x168(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
mov    -0x158(%rbp),%rsi
call   10c0 <strcat@plt>
mov    -0x178(%rbp),%rsi
mov    -0x168(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x170(%rbp),%rsi
mov    -0x168(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
lea    0xc1e(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x168(%rbp),%rdi
lea    0xc13(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rdi
lea    0xc01(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    -0x160(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x150(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x70(%rbp)
call   1030 <strcpy@plt>
mov    -0x150(%rbp),%rdi
lea    0xbe9(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x158(%rbp),%rsi
mov    -0x150(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x150(%rbp),%rdi
lea    0xbe4(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x158(%rbp),%rsi
mov    -0x150(%rbp),%rdi
call   10c0 <strcat@plt>
mov    -0x150(%rbp),%rdi
lea    0xbd6(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x150(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    %rax,-0x148(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x140(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
lea    0xba1(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
je     1568 <main+0x3c8>
jmp    1523 <main+0x383>
mov    -0x140(%rbp),%rdi
mov    -0x148(%rbp),%rax
mov    %eax,%esi
mov    -0x88(%rbp),%rdx
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     1557 <main+0x3b7>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1523 <main+0x383>
mov    -0x88(%rbp),%rdi
call   1040 <fclose@plt>
jmp    1574 <main+0x3d4>
mov    -0x150(%rbp),%rdi
call   10b0 <perror@plt>
mov    -0x150(%rbp),%rdi
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
mov    -0x14(%rbp),%eax
mov    %rax,-0x1b0(%rbp)
mov    %rcx,%rsi
imul   %rax,%rsi
add    $0xf,%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x1a8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x90(%rbp)
mov    %rax,-0x98(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
mov    -0x14(%rbp),%eax
mov    %rax,-0x1a0(%rbp)
mov    %rcx,%rsi
imul   %rax,%rsi
add    $0xf,%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x198(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0xa0(%rbp)
mov    %rax,-0xa8(%rbp)
movl   $0x0,-0x7c(%rbp)
lea    0xaa4(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0xb0(%rbp)
cmpq   $0x0,-0xb0(%rbp)
je     1891 <main+0x6f1>
jmp    1620 <main+0x480>
mov    -0x140(%rbp),%rdi
mov    -0x148(%rbp),%rax
mov    %eax,%esi
mov    -0xb0(%rbp),%rdx
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     1880 <main+0x6e0>
mov    -0x140(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
mov    %ecx,-0xb4(%rbp)
mov    -0xb4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1691 <main+0x4f1>
mov    -0x140(%rbp),%rax
mov    -0xb4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x140(%rbp),%rsi
mov    -0x1a8(%rbp),%rdi
mov    -0x1b0(%rbp),%rcx
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   1030 <strcpy@plt>
mov    -0x160(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   1030 <strcpy@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x923(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x188(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10c0 <strcat@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x975(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x158(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10c0 <strcat@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x923(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x188(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10c0 <strcat@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x8ce(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x170(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10c0 <strcat@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x891(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x140(%rbp),%rsi
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10c0 <strcat@plt>
mov    -0x1a0(%rbp),%rcx
mov    -0x198(%rbp),%rdi
movslq -0x7c(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x84f(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1620 <main+0x480>
mov    -0xb0(%rbp),%rdi
call   1040 <fclose@plt>
jmp    189d <main+0x6fd>
mov    -0x150(%rbp),%rdi
call   10b0 <perror@plt>
movl   $0xf4240,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd0(%rbp)
mov    -0xc4(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd8(%rbp)
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1dd8 <main+0xc38>
mov    -0x198(%rbp),%rdi
mov    -0x1a0(%rbp),%rcx
movslq -0xb8(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x768(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0xe8(%rbp)
cmpq   $0x0,-0xe8(%rbp)
je     1a4c <main+0x8ac>
mov    -0xc4(%rbp),%eax
mov    %rax,-0x1d0(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0x1c8(%rbp),%rdi
mov    -0x1d0(%rbp),%rax
mov    %eax,%esi
mov    -0xe8(%rbp),%rdx
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     1a3d <main+0x89d>
mov    -0x1c8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
je     1a38 <main+0x898>
mov    -0x1c8(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1c8(%rbp),%rax
mov    %ecx,-0xfc(%rbp)
mov    -0xfc(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,-0xfc(%rbp)
movslq -0xfc(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1a19 <main+0x879>
mov    -0x1c8(%rbp),%rax
movslq -0xfc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c8(%rbp),%rsi
mov    -0x1c0(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0xe8(%rbp),%rdi
call   1040 <fclose@plt>
jmp    1990 <main+0x7f0>
mov    -0xf0(%rbp),%rax
mov    %rax,%rsp
jmp    1a6d <main+0x8cd>
mov    -0x198(%rbp),%rdi
mov    -0x1a0(%rbp),%rcx
movslq -0xb8(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10b0 <perror@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1dbf <main+0xc1f>
mov    -0xb8(%rbp),%eax
cmp    -0xbc(%rbp),%eax
jle    1da6 <main+0xc06>
mov    -0x198(%rbp),%rdi
mov    -0x1a0(%rbp),%rcx
movslq -0xbc(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
lea    0x5ea(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x108(%rbp)
cmpq   $0x0,-0x108(%rbp)
je     1bca <main+0xa2a>
mov    -0xc4(%rbp),%eax
mov    %rax,-0x1e0(%rbp)
mov    %rsp,%rcx
mov    %rcx,-0x110(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x118(%rbp)
mov    -0x1d8(%rbp),%rdi
mov    -0x1e0(%rbp),%rax
mov    %eax,%esi
mov    -0x108(%rbp),%rdx
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     1bbb <main+0xa1b>
mov    -0x1d8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3e,%eax
je     1bb6 <main+0xa16>
mov    -0x1d8(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1d8(%rbp),%rax
mov    %ecx,-0x11c(%rbp)
mov    -0x11c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,-0x11c(%rbp)
movslq -0x11c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1b97 <main+0x9f7>
mov    -0x1d8(%rbp),%rax
movslq -0x11c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1d8(%rbp),%rsi
mov    -0x1b8(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0x108(%rbp),%rdi
call   1040 <fclose@plt>
jmp    1b0e <main+0x96e>
mov    -0x110(%rbp),%rax
mov    %rax,%rsp
jmp    1beb <main+0xa4b>
mov    -0x198(%rbp),%rdi
mov    -0x1a0(%rbp),%rcx
movslq -0xbc(%rbp),%rax
imul   %rcx,%rax
add    %rax,%rdi
call   10b0 <perror@plt>
mov    -0x1c0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x120(%rbp)
movl   $0x0,-0x124(%rbp)
movl   $0x0,-0x128(%rbp)
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
cmp    -0x120(%rbp),%eax
jge    1cd0 <main+0xb30>
mov    -0x1c0(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
je     1c63 <main+0xac3>
mov    -0x1b8(%rbp),%rax
movslq -0xc0(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x4e,%eax
jne    1c77 <main+0xad7>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1cb7 <main+0xb17>
mov    -0x1b8(%rbp),%rcx
mov    -0x1c0(%rbp),%rax
movslq -0xc0(%rbp),%rdx
movsbl (%rax,%rdx,1),%eax
movslq -0xc0(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1cb2 <main+0xb12>
mov    -0x124(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
jmp    1cb7 <main+0xb17>
jmp    1cbc <main+0xb1c>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1c1b <main+0xa7b>
mov    -0x120(%rbp),%eax
sub    -0x128(%rbp),%eax
mov    %eax,-0x12c(%rbp)
cvtsi2ssl -0x124(%rbp),%xmm0
ff
cvtsi2ssl -0x12c(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
movss  0x2f6(%rip),%xmm1
mulss  %xmm1,%xmm0
movss  0x2ee(%rip),%xmm1
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1090 <log@plt>
mov    -0x1b0(%rbp),%rsi
mov    -0x1a8(%rbp),%rcx
movaps %xmm0,%xmm1
movss  0x2c0(%rip),%xmm0
mulss  %xmm1,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
mov    -0x68(%rbp),%rdi
movslq -0xb8(%rbp),%rax
imul   %rsi,%rax
mov    %rcx,%rdx
add    %rax,%rdx
movslq -0xbc(%rbp),%rax
imul   %rsi,%rax
add    %rax,%rcx
mov    -0x124(%rbp),%r8d
mov    -0x12c(%rbp),%r9d
movss  -0x134(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0x333(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1dab <main+0xc0b>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1a77 <main+0x8d7>
jmp    1dc4 <main+0xc24>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    190b <main+0x76b>
mov    -0x170(%rbp),%rdx
mov    -0x158(%rbp),%rsi
lea    0x2e9(%rip),%rdi
call   1060 <printf@plt>
mov    -0x158(%rbp),%rdx
mov    -0x170(%rbp),%rcx
mov    -0x58(%rbp),%rdi
lea    0x2cb(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x23b8,%rsp
mov    %rsi,%rbx
mov    0x8(%rsi),%rsi
lea    -0x1420(%rbp),%r14
mov    %r14,%rdi
call   1030 <strcpy@plt>
mov    0x10(%rbx),%rsi
lea    -0x1810(%rbp),%r13
mov    %r13,%rdi
call   1030 <strcpy@plt>
mov    0x18(%rbx),%rsi
lea    -0x1030(%rbp),%r15
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    0x20(%rbx),%rsi
lea    -0x23e0(%rbp),%rdi
call   1030 <strcpy@plt>
mov    0x28(%rbx),%rsi
lea    -0x850(%rbp),%rdi
call   1030 <strcpy@plt>
lea    -0x1ff0(%rbp),%rbx
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <strcpy@plt>
lea    0xdd3(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
lea    0xe79(%rip),%rsi
mov    %rbx,%rdi
call   10a0 <fopen@plt>
mov    %rax,-0x58(%rbp)
lea    -0x1c00(%rbp),%rbx
mov    %rbx,%rdi
mov    %r15,%rsi
call   1030 <strcpy@plt>
lea    0xdb1(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   10c0 <strcat@plt>
lea    0xe33(%rip),%r12
mov    %rbx,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <strcat@plt>
lea    0xe0e(%rip),%r15
mov    %rbx,%rdi
mov    %r15,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
lea    -0x850(%rbp),%rsi
call   10c0 <strcat@plt>
lea    0xd38(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
lea    0xd31(%rip),%rsi
mov    %rbx,%rdi
call   10a0 <fopen@plt>
lea    0xd24(%rip),%rdi
mov    $0x2a,%esi
mov    $0x1,%edx
mov    %rax,-0x60(%rbp)
mov    %rax,%rcx
call   10d0 <fwrite@plt>
lea    -0x460(%rbp),%rbx
mov    %rbx,%rdi
lea    -0x1030(%rbp),%rsi
call   1030 <strcpy@plt>
lea    0xd1c(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <strcat@plt>
lea    0xd23(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   10c0 <strcat@plt>
lea    0xd21(%rip),%rsi
mov    %rbx,%rdi
call   10c0 <strcat@plt>
lea    0xd20(%rip),%rsi
mov    %rbx,%rdi
call   10a0 <fopen@plt>
test   %rax,%rax
je     1868 <main+0x6b8>
mov    %rax,%r15
mov    $0xffffffff,%ebx
lea    -0xc40(%rbp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %r15,%rdx
call   1070 <fgets@plt>
add    $0x1,%ebx
test   %rax,%rax
jne    13b0 <main+0x200>
mov    %r15,%rdi
call   1040 <fclose@plt>
mov    %ebx,%eax
imul   $0x3e8,%rax,%rax
mov    %rsp,%rcx
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x40(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
lea    0xca3(%rip),%rsi
lea    -0x460(%rbp),%rdi
call   10a0 <fopen@plt>
test   %rax,%rax
je     187b <main+0x6cb>
lea    -0xc40(%rbp),%rbx
mov    %rbx,%rdi
mov    $0x3e8,%esi
mov    %rax,-0x30(%rbp)
mov    %rax,%rdx
call   1070 <fgets@plt>
xor    %r14d,%r14d
test   %rax,%rax
je     155d <main+0x3ad>
lea    -0x1810(%rbp),%r13
mov    -0x40(%rbp),%r12
mov    -0x38(%rbp),%r15
jmp    153b <main+0x38b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %r15,%rdi
lea    -0x1030(%rbp),%rsi
call   1030 <strcpy@plt>
mov    %r15,%rdi
lea    0xb9a(%rip),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
mov    %r13,%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    0xc1c(%rip),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    -0x1420(%rbp),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    0xbf6(%rip),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
mov    %r13,%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    0xbd1(%rip),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    -0x850(%rbp),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    0xbc0(%rip),%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
lea    0xbae(%rip),%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
mov    $0x3e8,%esi
mov    -0x30(%rbp),%rdx
call   1070 <fgets@plt>
add    $0x3e8,%r15
add    $0x3e8,%r12
add    $0x1,%r14d
test   %rax,%rax
je     155d <main+0x3ad>
mov    %rbx,%rdi
call   1050 <strlen@plt>
cltq
cmpb   $0xa,-0x1(%rax,%rbx,1)
jne    1460 <main+0x2b0>
movb   $0x0,-0xc41(%rbp,%rax,1)
jmp    1460 <main+0x2b0>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
mov    %rsp,%r13
add    $0xfffffffffff0bdc0,%r13
mov    %r13,%rsp
mov    %rsp,%r12
add    $0xfffffffffff0bdc0,%r12
mov    %r12,%rsp
test   %r14d,%r14d
je     1887 <main+0x6d7>
mov    %r14d,%eax
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
jmp    15ae <main+0x3fe>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    -0x30(%rbp),%rax
je     1887 <main+0x6d7>
mov    %rax,-0x48(%rbp)
imul   $0x3e8,%rax,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x50(%rbp)
lea    (%rax,%rcx,1),%rbx
mov    %rbx,%rdi
lea    0xad6(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     185b <main+0x6ab>
mov    %rax,%r14
mov    %rsp,%r15
mov    %rsp,%rbx
add    $0xfffffffffff0bdc0,%rbx
mov    %rbx,%rsp
jmp    1613 <main+0x463>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %r14,%rdi
call   1040 <fclose@plt>
mov    %rbx,%rdi
mov    $0xf4240,%esi
mov    %r14,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     1650 <main+0x4a0>
cmpb   $0x3e,(%rbx)
je     1613 <main+0x463>
mov    %rbx,%rdi
call   1050 <strlen@plt>
cltq
cmpb   $0xa,-0x1(%rax,%rbx,1)
jne    1600 <main+0x450>
movb   $0x0,-0x1(%rbx,%rax,1)
jmp    1600 <main+0x450>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rsp
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    %rcx,-0x50(%rbp)
xor    %r15d,%r15d
jmp    16df <main+0x52f>
xor    %r14d,%r14d
xor    %esi,%esi
sub    %esi,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
mulss  0x976(%rip),%xmm0
addss  0x972(%rip),%xmm0
cvttss2si %xmm0,%edi
mov    %eax,%ebx
call   1090 <log@plt>
mulss  0x963(%rip),%xmm0
mov    -0x70(%rbp),%rcx
add    -0x40(%rbp),%rcx
cvtss2sd %xmm0,%xmm0
mov    -0x60(%rbp),%rdi
lea    0xa07(%rip),%rsi
mov    -0x50(%rbp),%rdx
mov    %r14d,%r8d
mov    %ebx,%r9d
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x48(%rbp),%rax
add    $0x1,%r15
cmp    -0x30(%rbp),%r15
je     15a0 <main+0x3f0>
cmp    %r15,%rax
jbe    16d1 <main+0x521>
imul   $0x3e8,%r15,%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,-0x70(%rbp)
lea    (%rax,%rcx,1),%rbx
mov    %rbx,%rdi
lea    0x9a4(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     184e <main+0x69e>
mov    %rax,%r14
mov    %rsp,-0x68(%rbp)
mov    %rsp,%rbx
add    $0xfffffffffff0bdc0,%rbx
mov    %rbx,%rsp
jmp    1743 <main+0x593>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %r14,%rdi
call   1040 <fclose@plt>
mov    %rbx,%rdi
mov    $0xf4240,%esi
mov    %r14,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     1780 <main+0x5d0>
cmpb   $0x3e,(%rbx)
je     1743 <main+0x593>
mov    %rbx,%rdi
call   1050 <strlen@plt>
cltq
cmpb   $0xa,-0x1(%rax,%rbx,1)
jne    1730 <main+0x580>
movb   $0x0,-0x1(%rbx,%rax,1)
jmp    1730 <main+0x580>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x68(%rbp),%rsp
mov    %r13,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
jle    1668 <main+0x4b8>
mov    %eax,%r8d
cmp    $0x1,%eax
jne    17c8 <main+0x618>
xor    %ecx,%ecx
xor    %esi,%esi
xor    %r14d,%r14d
test   $0x1,%r8b
je     166d <main+0x4bd>
mov    0x0(%r13,%rcx,1),%dl
cmp    $0x4e,%dl
je     17c0 <main+0x610>
mov    (%r12,%rcx,1),%cl
cmp    $0x4e,%cl
jne    183e <main+0x68e>
add    $0x1,%esi
jmp    166d <main+0x4bd>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %ecx,%ecx
xor    %esi,%esi
xor    %r14d,%r14d
jmp    17ec <main+0x63c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
add    $0x2,%rcx
cmp    %rcx,%r9
je     17a3 <main+0x5f3>
movzbl 0x0(%r13,%rcx,1),%edx
cmp    $0x4e,%dl
je     1801 <main+0x651>
movzbl (%r12,%rcx,1),%ebx
cmp    $0x4e,%bl
jne    1810 <main+0x660>
add    $0x1,%esi
jmp    181b <main+0x66b>
cs nopw 0x0(%rax,%rax,1)
xor    %edi,%edi
cmp    %bl,%dl
setne  %dil
add    %edi,%r14d
movzbl 0x1(%r13,%rcx,1),%edx
cmp    $0x4e,%dl
je     17e0 <main+0x630>
movzbl 0x1(%r12,%rcx,1),%ebx
cmp    $0x4e,%bl
je     17e0 <main+0x630>
xor    %edi,%edi
cmp    %bl,%dl
setne  %dil
add    %edi,%r14d
jmp    17e3 <main+0x633>
xor    %edi,%edi
cmp    %cl,%dl
setne  %dil
add    %edi,%r14d
jmp    166d <main+0x4bd>
mov    %rbx,%rdi
call   10b0 <perror@plt>
jmp    1784 <main+0x5d4>
mov    %rbx,%rdi
call   10b0 <perror@plt>
jmp    1653 <main+0x4a3>
lea    -0x460(%rbp),%rdi
call   10b0 <perror@plt>
xor    %ebx,%ebx
jmp    13d0 <main+0x220>
lea    -0x460(%rbp),%rdi
call   10b0 <perror@plt>
lea    0x848(%rip),%rbx
lea    -0x1420(%rbp),%r14
lea    -0x850(%rbp),%r15
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
call   1060 <printf@plt>
mov    -0x58(%rbp),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %r15,%rcx
xor    %eax,%eax
call   1080 <fprintf@plt>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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