#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 atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
int fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ fputc(char, int /*<<< orphan*/ *);
int /*<<< orphan*/ fscanf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ getchar();
scalar_t__ malloc(int);
scalar_t__ max(scalar_t__, scalar_t__);
scalar_t__ min(scalar_t__, scalar_t__);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ rewind(int /*<<< orphan*/ *);
scalar_t__ strcmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
void combine(char *f1, char *f2, char *f3, char *f4, char *f5) {
  struct peak {
    char chr[50];
    int start;
    int end;
    int *ord;
  };
  struct peak *peakfile1;
  struct peak *peakfile2;
  struct peak *peakfile3;
  struct peak peaktemp;
  struct peak peak;
  FILE *p1;
  FILE *p2;
  FILE *p3;
  int cap1;
  int cap2;
  int temp1 = 0;
  int temp2 = 0;
  int tagstart = 0;
  int tagend = 0;
  int tagtemp = 0;
  int flag = 0;
  int flag2 = 0;
  int start;
  int end;
  int num = 0;
  int num2 = 1;
  int j;
  char mid;
  int i;
  int k;
  char c[50];
  char ch1;
  char ch2;
  int filenum;
  int fnum2;
  filenum = atoi(f4);
  fnum2 = atoi(f5);
  if ((p1 = fopen(f1, "r")) == NULL) {
    printf("\nerror occurred when opening the input file to combine peaks!");
    getchar();
    exit(1);
  }
  if ((p2 = fopen(f2, "r")) == NULL) {
    printf("\nerror occurred when opening the input file to combine peaks!");
    getchar();
    exit(1);
  }
  if ((p3 = fopen(f3, "wb")) == NULL) {
    printf("\ncreate output file error\n");
    getchar();
    exit(1);
  }
  ch1 = fgetc(p1);
  ch2 = fgetc(p2);
  rewind(p1);
  rewind(p2);
  if ((ch1 != EOF) || (ch2 != EOF))
    if (ch1 == EOF)
      while (!feof(p2)) {
        fscanf(p2, "%s\t%d\t%d\t%s\t%s\n", &peak.chr, &peak.start, &peak.end,
               &c, &c);
        fprintf(p3, "%s\t%d\t%d\tMACS_peak_order_%d\t", peak.chr, peak.start,
                peak.end, num2);
        num2++;
        for (i = 0; i <= (filenum * filenum - 1); i++)
          if (i == fnum2)
            fprintf(p3, "1");
          else
            fprintf(p3, "0");
        fprintf(p3, "\n");
      }
    else if (ch2 == EOF)
      while (!feof(p1)) {
        ch1 = fgetc(p1);
        if (ch1 != EOF)
          fputc(ch1, p3);
      }
    else {
      cap1 = 0;
      while (!feof(p1)) {
        mid = fgetc(p1);
        if (mid == '\n')
          cap1++;
      }
      cap1 = cap1 + 1;
      rewind(p1);
      cap2 = 0;
      while (!feof(p2)) {
        mid = fgetc(p2);
        if (mid == '\n')
          cap2++;
      }
      cap2 = cap2 + 1;
      rewind(p2);
      if ((peakfile1 = (struct peak *)malloc(sizeof(struct peak) * cap1)) ==
          NULL) {
        printf("Memory is not sufficent.Creating output file fails.");
        exit(0);
        getchar();
      }
      if ((peakfile2 = (struct peak *)malloc(sizeof(struct peak) * cap2)) ==
          NULL) {
        printf("Memory is not sufficent.Creating output file fails.");
        exit(0);
        getchar();
      }
      if ((peakfile3 = (struct peak *)malloc(sizeof(struct peak) *
                                             (cap1 + cap2))) == NULL) {
        printf("Memory is not sufficent.Creating output file fails.");
        exit(0);
        getchar();
      }
      cap1 = 0;
      cap2 = 0;
      while (!feof(p1)) {
        fscanf(p1, "%s\t%d\t%d\t%s\t", &peakfile1[cap1].chr,
               &peakfile1[cap1].start, &peakfile1[cap1].end, &c);
        if ((peakfile1[cap1].ord =
                 (int *)malloc(sizeof(int) * filenum * filenum)) == NULL) {
          printf("Memory is not sufficent.Creating order file fails.");
          exit(0);
          getchar();
        }
        for (i = 0; i <= (filenum * filenum - 1); i++)
          peakfile1[cap1].ord[i] = fgetc(p1) - 48;
        fscanf(p1, "\n");
        cap1++;
      }
      while (!feof(p2)) {
        fscanf(p2, "%s\t%d\t%d\t%s\t%s\n", &peakfile2[cap2].chr,
               &peakfile2[cap2].start, &peakfile2[cap2].end, &c, &c);
        if ((peakfile2[cap2].ord =
                 (int *)malloc(sizeof(int) * filenum * filenum)) == NULL) {
          printf("Memory is not sufficent.Creating order file fails.");
          exit(0);
          getchar();
        }
        for (i = 0; i <= (filenum * filenum - 1); i++)
          peakfile2[cap2].ord[i] = 0;
        peakfile2[cap2].ord[fnum2] = 1;
        cap2++;
      }
      num = 0;
      for (temp2 = 0; temp2 <= (cap2 - 1); temp2++) {
        if ((strcmp(peakfile2[temp2].chr, peakfile1[0].chr) < 0) ||
            (strcmp(peakfile2[temp2].chr, peakfile1[0].chr) == 0) &&
                (peakfile2[temp2].start < peakfile1[0].start)) {
          strcpy(peakfile3[num].chr, peakfile2[temp2].chr);
          peakfile3[num].start = peakfile2[temp2].start;
          peakfile3[num].end = peakfile2[temp2].end;
          peakfile3[num].ord = peakfile2[temp2].ord;
          num++;
        } else
          break;
      }
      for (temp1 = 0; temp1 <= (cap1 - 2); temp1++) {
        strcpy(peakfile3[num].chr, peakfile1[temp1].chr);
        peakfile3[num].start = peakfile1[temp1].start;
        peakfile3[num].end = peakfile1[temp1].end;
        peakfile3[num].ord = peakfile1[temp1].ord;
        num++;
        for (; temp2 <= (cap2 - 1); temp2++) {
          if ((strcmp(peakfile2[temp2].chr, peakfile1[temp1 + 1].chr) < 0) ||
              (strcmp(peakfile2[temp2].chr, peakfile1[temp1 + 1].chr) == 0) &&
                  (peakfile2[temp2].start < peakfile1[temp1 + 1].start)) {
            strcpy(peakfile3[num].chr, peakfile2[temp2].chr);
            peakfile3[num].start = peakfile2[temp2].start;
            peakfile3[num].end = peakfile2[temp2].end;
            peakfile3[num].ord = peakfile2[temp2].ord;
            num++;
          } else
            break;
        }
      }
      {
        strcpy(peakfile3[num].chr, peakfile1[temp1].chr);
        peakfile3[num].start = peakfile1[temp1].start;
        peakfile3[num].end = peakfile1[temp1].end;
        peakfile3[num].ord = peakfile1[temp1].ord;
        num++;
      }
      for (; temp2 <= (cap2 - 1); temp2++) {
        strcpy(peakfile3[num].chr, peakfile2[temp2].chr);
        peakfile3[num].start = peakfile2[temp2].start;
        peakfile3[num].end = peakfile2[temp2].end;
        peakfile3[num].ord = peakfile2[temp2].ord;
        num++;
      }
      num2 = 1;
      {
        strcpy(peaktemp.chr, peakfile3[0].chr);
        peaktemp.start = peakfile3[0].start;
        peaktemp.end = peakfile3[0].end;
        peaktemp.ord = peakfile3[0].ord;
      }
      for (i = 1; i <= (cap1 + cap2 - 1); i++) {
        if ((strcmp(peaktemp.chr, peakfile3[i].chr) == 0) &&
            (!((peaktemp.end < peakfile3[i].start) ||
               (peakfile3[i].end < peaktemp.start)))) {
          peaktemp.start = min(peakfile3[i].start, peaktemp.start);
          peaktemp.end = max(peakfile3[i].end, peaktemp.end);
          for (j = 0; j <= (filenum * filenum - 1); j++)
            peaktemp.ord[j] = peakfile3[i].ord[j] || peaktemp.ord[j];
        } else {
          if (strlen(peaktemp.chr) <= 6) {
            fprintf(p3, "%s\t%d\t%d\tMACS_peak_order_%d\t", peaktemp.chr,
                    peaktemp.start, peaktemp.end, num2);
            for (j = 0; j <= (filenum * filenum - 1); j++)
              fprintf(p3, "%d", peaktemp.ord[j]);
            fprintf(p3, "\n");
            num2++;
          }
          strcpy(peaktemp.chr, peakfile3[i].chr);
          peaktemp.start = peakfile3[i].start;
          peaktemp.end = peakfile3[i].end;
          peaktemp.ord = peakfile3[i].ord;
        }
      }
      fprintf(p3, "%s\t%d\t%d\tMACS_peak_order_%d\t", peaktemp.chr,
              peaktemp.start, peaktemp.end, num2);
      for (j = 0; j <= (filenum * filenum - 1); j++)
        fprintf(p3, "%d", peaktemp.ord[j]);
      fprintf(p3, "\n");
    }
  fclose(p1);
  fclose(p2);
  fclose(p3);
}


x86 assembly (clang, -O0):
<combine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0xf4(%rbp)
movl   $0x0,-0xf8(%rbp)
movl   $0x0,-0xfc(%rbp)
movl   $0x0,-0x100(%rbp)
movl   $0x0,-0x104(%rbp)
movl   $0x0,-0x108(%rbp)
movl   $0x0,-0x10c(%rbp)
movl   $0x0,-0x118(%rbp)
movl   $0x1,-0x11c(%rbp)
mov    -0x20(%rbp),%rdi
call   1130 <atoi@plt>
mov    %eax,-0x168(%rbp)
mov    -0x28(%rbp),%rdi
call   1130 <atoi@plt>
mov    %eax,-0x16c(%rbp)
mov    -0x8(%rbp),%rdi
lea    0x1d3e(%rip),%rsi
call   1120 <fopen@plt>
mov    %rax,-0xd8(%rbp)
cmp    $0x0,%rax
jne    12f5 <combine+0xd5>
lea    0x1d23(%rip),%rdi
call   1060 <printf@plt>
mov    $0x0,%al
call   10e0 <getchar@plt>
mov    $0x1,%edi
call   1140 <exit@plt>
mov    -0x10(%rbp),%rdi
lea    0x1d00(%rip),%rsi
call   1120 <fopen@plt>
mov    %rax,-0xe0(%rbp)
cmp    $0x0,%rax
jne    1333 <combine+0x113>
lea    0x1ce5(%rip),%rdi
call   1060 <printf@plt>
mov    $0x0,%al
call   10e0 <getchar@plt>
mov    $0x1,%edi
call   1140 <exit@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d02(%rip),%rsi
call   1120 <fopen@plt>
mov    %rax,-0xe8(%rbp)
cmp    $0x0,%rax
jne    1371 <combine+0x151>
lea    0x1ce8(%rip),%rdi
call   1060 <printf@plt>
mov    $0x0,%al
call   10e0 <getchar@plt>
mov    $0x1,%edi
call   1140 <exit@plt>
mov    -0xd8(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %al,-0x161(%rbp)
mov    -0xe0(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %al,-0x162(%rbp)
mov    -0xd8(%rbp),%rdi
call   1070 <rewind@plt>
mov    -0xe0(%rbp),%rdi
call   1070 <rewind@plt>
movsbl -0x161(%rbp),%eax
mov    0x3c2d(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    13df <combine+0x1bf>
movsbl -0x162(%rbp),%eax
mov    0x3c14(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     236c <combine+0x114c>
movsbl -0x161(%rbp),%eax
mov    0x3bfb(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    153e <combine+0x31e>
jmp    13fd <combine+0x1dd>
mov    -0xe0(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    141e <combine+0x1fe>
jmp    1539 <combine+0x319>
mov    -0xe0(%rbp),%rdi
lea    -0xd0(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
add    $0x34,%rcx
lea    -0xd0(%rbp),%r8
add    $0x38,%r8
lea    0x1c15(%rip),%rsi
lea    -0x160(%rbp),%rax
mov    %rax,%r9
mov    %rax,(%rsp)
mov    $0x0,%al
call   10a0 <fscanf@plt>
mov    -0xe8(%rbp),%rdi
lea    -0xd0(%rbp),%rdx
mov    -0x9c(%rbp),%ecx
mov    -0x98(%rbp),%r8d
mov    -0x11c(%rbp),%r9d
lea    0x1be7(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
movl   $0x0,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     151f <combine+0x2ff>
mov    -0x128(%rbp),%eax
cmp    -0x16c(%rbp),%eax
jne    14f1 <combine+0x2d1>
mov    -0xe8(%rbp),%rdi
lea    0x1ba6(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
jmp    1506 <combine+0x2e6>
mov    -0xe8(%rbp),%rdi
lea    0x1b8e(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
jmp    150b <combine+0x2eb>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    14a7 <combine+0x287>
mov    -0xe8(%rbp),%rdi
lea    0x1b2f(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
jmp    13fd <combine+0x1dd>
jmp    2367 <combine+0x1147>
movsbl -0x162(%rbp),%eax
mov    0x3a9c(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
jne    15c7 <combine+0x3a7>
jmp    155c <combine+0x33c>
mov    -0xd8(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    157d <combine+0x35d>
jmp    15c2 <combine+0x3a2>
mov    -0xd8(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %al,-0x161(%rbp)
movsbl -0x161(%rbp),%eax
mov    0x3a4b(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     15bd <combine+0x39d>
mov    -0x161(%rbp),%al
mov    -0xe8(%rbp),%rsi
movsbl %al,%edi
call   10c0 <fputc@plt>
jmp    155c <combine+0x33c>
jmp    2362 <combine+0x1142>
movl   $0x0,-0xec(%rbp)
mov    -0xd8(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    15f2 <combine+0x3d2>
jmp    1628 <combine+0x408>
mov    -0xd8(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %al,-0x121(%rbp)
movsbl -0x121(%rbp),%eax
cmp    $0xa,%eax
jne    1623 <combine+0x403>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    15d1 <combine+0x3b1>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
mov    -0xd8(%rbp),%rdi
call   1070 <rewind@plt>
movl   $0x0,-0xf0(%rbp)
mov    -0xe0(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    166e <combine+0x44e>
jmp    16a4 <combine+0x484>
mov    -0xe0(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %al,-0x121(%rbp)
movsbl -0x121(%rbp),%eax
cmp    $0xa,%eax
jne    169f <combine+0x47f>
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    164d <combine+0x42d>
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xe0(%rbp),%rdi
call   1070 <rewind@plt>
movslq -0xec(%rbp),%rax
imul   $0x48,%rax,%rax
mov    %eax,%edi
call   1110 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    16f2 <combine+0x4d2>
lea    0x19a9(%rip),%rdi
call   1060 <printf@plt>
xor    %edi,%edi
call   1140 <exit@plt>
movslq -0xf0(%rbp),%rax
imul   $0x48,%rax,%rax
mov    %eax,%edi
call   1110 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    1725 <combine+0x505>
lea    0x1976(%rip),%rdi
call   1060 <printf@plt>
xor    %edi,%edi
call   1140 <exit@plt>
mov    -0xec(%rbp),%eax
add    -0xf0(%rbp),%eax
cltq
imul   $0x48,%rax,%rax
mov    %eax,%edi
call   1110 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    175f <combine+0x53f>
lea    0x193c(%rip),%rdi
call   1060 <printf@plt>
xor    %edi,%edi
call   1140 <exit@plt>
movl   $0x0,-0xec(%rbp)
movl   $0x0,-0xf0(%rbp)
mov    -0xd8(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1794 <combine+0x574>
jmp    18d4 <combine+0x6b4>
mov    -0xd8(%rbp),%rdi
mov    -0x30(%rbp),%rdx
movslq -0xec(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdx
mov    -0x30(%rbp),%rcx
movslq -0xec(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rcx
add    $0x34,%rcx
mov    -0x30(%rbp),%r8
movslq -0xec(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%r8
add    $0x38,%r8
lea    0x18e3(%rip),%rsi
lea    -0x160(%rbp),%r9
mov    $0x0,%al
call   10a0 <fscanf@plt>
movslq -0x168(%rbp),%rax
shl    $0x2,%rax
movslq -0x168(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1110 <malloc@plt>
mov    -0x30(%rbp),%rcx
movslq -0xec(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rcx
mov    %rax,0x40(%rcx)
cmp    $0x0,%rax
jne    183e <combine+0x61e>
lea    0x189e(%rip),%rdi
call   1060 <printf@plt>
xor    %edi,%edi
call   1140 <exit@plt>
movl   $0x0,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     18ab <combine+0x68b>
mov    -0xd8(%rbp),%rdi
call   10b0 <fgetc@plt>
mov    %eax,%edx
sub    $0x30,%edx
mov    -0x30(%rbp),%rax
movslq -0xec(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rax
movslq -0x128(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    1848 <combine+0x628>
mov    -0xd8(%rbp),%rdi
lea    0x17a3(%rip),%rsi
mov    $0x0,%al
call   10a0 <fscanf@plt>
mov    -0xec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xec(%rbp)
jmp    1773 <combine+0x553>
jmp    18d9 <combine+0x6b9>
mov    -0xe0(%rbp),%rdi
call   1100 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    18fa <combine+0x6da>
jmp    1a43 <combine+0x823>
mov    -0xe0(%rbp),%rdi
mov    -0x38(%rbp),%rdx
movslq -0xf0(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdx
mov    -0x38(%rbp),%rcx
movslq -0xf0(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rcx
add    $0x34,%rcx
mov    -0x38(%rbp),%r8
movslq -0xf0(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%r8
add    $0x38,%r8
lea    0x1718(%rip),%rsi
lea    -0x160(%rbp),%rax
mov    %rax,%r9
mov    %rax,(%rsp)
mov    $0x0,%al
call   10a0 <fscanf@plt>
movslq -0x168(%rbp),%rax
shl    $0x2,%rax
movslq -0x168(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1110 <malloc@plt>
mov    -0x38(%rbp),%rcx
movslq -0xf0(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rcx
mov    %rax,0x40(%rcx)
cmp    $0x0,%rax
jne    19ab <combine+0x78b>
lea    0x1731(%rip),%rdi
call   1060 <printf@plt>
xor    %edi,%edi
call   1140 <exit@plt>
movl   $0x0,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1a0b <combine+0x7eb>
mov    -0x38(%rbp),%rax
movslq -0xf0(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rax
movslq -0x128(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    19b5 <combine+0x795>
mov    -0x38(%rbp),%rax
movslq -0xf0(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rax
movslq -0x16c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0xf0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf0(%rbp)
jmp    18d9 <combine+0x6b9>
movl   $0x0,-0x118(%rbp)
movl   $0x0,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0xf0(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1bb5 <combine+0x995>
mov    -0x38(%rbp),%rdi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jl     1ada <combine+0x8ba>
mov    -0x38(%rbp),%rdi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1b97 <combine+0x977>
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%eax
mov    -0x30(%rbp),%rcx
cmp    0x34(%rcx),%eax
jge    1b97 <combine+0x977>
mov    -0x40(%rbp),%rdi
movslq -0x118(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x34(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x38(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x40(%rax)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1b9c <combine+0x97c>
jmp    1bb5 <combine+0x995>
jmp    1ba1 <combine+0x981>
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    1a57 <combine+0x837>
movl   $0x0,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
mov    -0xec(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1e3c <combine+0xc1c>
mov    -0x40(%rbp),%rdi
movslq -0x118(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq -0xf4(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x34(%rax)
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x38(%rax)
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x40(%rax)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0xf0(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1e23 <combine+0xc03>
mov    -0x38(%rbp),%rdi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
cltq
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jl     1d48 <combine+0xb28>
mov    -0x38(%rbp),%rdi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
cltq
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1e05 <combine+0xbe5>
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%eax
mov    -0x30(%rbp),%rcx
mov    -0xf4(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rcx
cmp    0x34(%rcx),%eax
jge    1e05 <combine+0xbe5>
mov    -0x40(%rbp),%rdi
movslq -0x118(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x34(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x38(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x40(%rax)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1e0a <combine+0xbea>
jmp    1e23 <combine+0xc03>
jmp    1e0f <combine+0xbef>
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    1c8e <combine+0xa6e>
jmp    1e28 <combine+0xc08>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    1bbf <combine+0x99f>
mov    -0x40(%rbp),%rdi
movslq -0x118(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq -0xf4(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x34(%rax)
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x38(%rax)
mov    -0x30(%rbp),%rax
movslq -0xf4(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x40(%rax)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0xf0(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1fd7 <combine+0xdb7>
mov    -0x40(%rbp),%rdi
movslq -0x118(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rsi
movslq -0xf8(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x34(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%ecx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x38(%rax)
mov    -0x38(%rbp),%rax
movslq -0xf8(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
mov    -0x40(%rbp),%rax
movslq -0x118(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x40(%rax)
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    1ef4 <combine+0xcd4>
movl   $0x1,-0x11c(%rbp)
lea    -0x88(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x40(%rbp),%rax
mov    0x34(%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%rax
mov    0x38(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
mov    0x40(%rax),%rax
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     22c4 <combine+0x10a4>
lea    -0x88(%rbp),%rdi
mov    -0x40(%rbp),%rsi
movslq -0x128(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    2181 <combine+0xf61>
mov    -0x50(%rbp),%eax
mov    -0x40(%rbp),%rcx
movslq -0x128(%rbp),%rdx
imul   $0x48,%rdx,%rdx
add    %rdx,%rcx
cmp    0x34(%rcx),%eax
jl     2181 <combine+0xf61>
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%eax
cmp    -0x54(%rbp),%eax
jl     2181 <combine+0xf61>
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq 0x34(%rax),%rdi
movslq -0x54(%rbp),%rsi
call   1080 <min@plt>
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
movslq 0x38(%rax),%rdi
movslq -0x50(%rbp),%rsi
call   1090 <max@plt>
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     217c <combine+0xf5c>
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rcx
movslq -0x120(%rbp),%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x16d(%rbp)
jne    214f <combine+0xf2f>
mov    -0x48(%rbp),%rax
movslq -0x120(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setne  %al
mov    %al,-0x16d(%rbp)
mov    -0x16d(%rbp),%al
and    $0x1,%al
movzbl %al,%edx
mov    -0x48(%rbp),%rax
movslq -0x120(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    20ea <combine+0xeca>
jmp    22ab <combine+0x108b>
lea    -0x88(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x6,%eax
jg     2243 <combine+0x1023>
mov    -0xe8(%rbp),%rdi
lea    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%r8d
mov    -0x11c(%rbp),%r9d
lea    0xeb5(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     221f <combine+0xfff>
mov    -0xe8(%rbp),%rdi
mov    -0x48(%rbp),%rax
movslq -0x120(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xeff(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    21ca <combine+0xfaa>
mov    -0xe8(%rbp),%rdi
lea    0xe2f(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
lea    -0x88(%rbp),%rdi
mov    -0x40(%rbp),%rsi
movslq -0x128(%rbp),%rax
imul   $0x48,%rax,%rax
add    %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x34(%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x38(%rax),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x128(%rbp),%rcx
imul   $0x48,%rcx,%rcx
add    %rcx,%rax
mov    0x40(%rax),%rax
mov    %rax,-0x48(%rbp)
jmp    22b0 <combine+0x1090>
mov    -0x128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x128(%rbp)
jmp    201b <combine+0xdfb>
mov    -0xe8(%rbp),%rdi
lea    -0x88(%rbp),%rdx
mov    -0x54(%rbp),%ecx
mov    -0x50(%rbp),%r8d
mov    -0x11c(%rbp),%r9d
lea    0xd87(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    -0x168(%rbp),%ecx
imul   -0x168(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     234d <combine+0x112d>
mov    -0xe8(%rbp),%rdi
mov    -0x48(%rbp),%rax
movslq -0x120(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xdd1(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    22f8 <combine+0x10d8>
mov    -0xe8(%rbp),%rdi
lea    0xd01(%rip),%rsi
mov    $0x0,%al
call   10f0 <fprintf@plt>
jmp    2367 <combine+0x1147>
jmp    236c <combine+0x114c>
mov    -0xd8(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0xe0(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0xe8(%rbp),%rdi
call   1040 <fclose@plt>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<combine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r8,%rbx
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbp
mov    %rcx,%rdi
call   1150 <atoi@plt>
mov    %eax,0xc(%rsp)
mov    %rbx,%rdi
call   1150 <atoi@plt>
mov    %eax,%r14d
lea    0xe82(%rip),%rsi
mov    %rbp,%rdi
call   1140 <fopen@plt>
mov    %rax,0x58(%rsp)
test   %rax,%rax
je     1d25 <combine+0xae5>
lea    0xe65(%rip),%rsi
mov    %r13,%rdi
call   1140 <fopen@plt>
test   %rax,%rax
je     1d25 <combine+0xae5>
mov    %rax,0x30(%rsp)
lea    0xd89(%rip),%rsi
mov    %r12,%rdi
call   1140 <fopen@plt>
mov    %rax,0x48(%rsp)
test   %rax,%rax
mov    0x58(%rsp),%r13
je     1d33 <combine+0xaf3>
mov    %r13,%rdi
call   10d0 <fgetc@plt>
mov    %eax,%r15d
mov    0x30(%rsp),%rbx
mov    %rbx,%rdi
call   10d0 <fgetc@plt>
mov    %eax,%ebp
mov    %r13,%rdi
call   1080 <rewind@plt>
mov    %rbx,%rdi
call   1080 <rewind@plt>
movsbl %r15b,%eax
mov    0x2ce3(%rip),%r15
movsbl (%r15),%ebx
movsbl %bpl,%ebp
cmp    %ebx,%eax
jne    1401 <combine+0x1c1>
cmp    %eax,%ebp
mov    0x30(%rsp),%rbx
je     1b63 <combine+0x923>
mov    %rbx,%rdi
call   1120 <feof@plt>
test   %eax,%eax
jne    1b63 <combine+0x923>
mov    0xc(%rsp),%eax
imul   %eax,%eax
mov    %eax,0xc(%rsp)
mov    $0x1,%r12d
mov    0x48(%rsp),%rbp
mov    0xc(%rsp),%r15d
jmp    1376 <combine+0x136>
nop
add    $0x1,%r12d
mov    $0xa,%edi
mov    %rbp,%rsi
call   10e0 <fputc@plt>
mov    0x30(%rsp),%rbx
mov    %rbx,%rdi
call   1120 <feof@plt>
test   %eax,%eax
jne    1b63 <combine+0x923>
lea    0xd0(%rsp),%r9
mov    %r9,(%rsp)
mov    %rbx,%rdi
lea    0xcb5(%rip),%rsi
lea    0x70(%rsp),%rbx
mov    %rbx,%rdx
lea    0xa4(%rsp),%rcx
lea    0xa8(%rsp),%r8
xor    %eax,%eax
call   10c0 <fscanf@plt>
mov    0xa4(%rsp),%ecx
mov    0xa8(%rsp),%r8d
mov    %rbp,%rdi
lea    0xc8d(%rip),%rsi
mov    %rbx,%rdx
mov    %r12d,%r9d
xor    %eax,%eax
call   1110 <fprintf@plt>
test   %r15d,%r15d
je     1350 <combine+0x110>
xor    %ebx,%ebx
nopl   0x0(%rax)
xor    %edi,%edi
cmp    %ebx,%r14d
sete   %dil
or     $0x30,%edi
mov    %rbp,%rsi
call   10e0 <fputc@plt>
add    $0x1,%ebx
cmp    %ebx,%r15d
jne    13e0 <combine+0x1a0>
jmp    1350 <combine+0x110>
mov    %r13,%rdi
call   1120 <feof@plt>
cmp    %ebx,%ebp
jne    1452 <combine+0x212>
test   %eax,%eax
mov    0x30(%rsp),%rbx
jne    1b63 <combine+0x923>
jmp    1430 <combine+0x1f0>
nopl   0x0(%rax)
mov    %r13,%rdi
call   1120 <feof@plt>
test   %eax,%eax
jne    1b63 <combine+0x923>
mov    %r13,%rdi
call   10d0 <fgetc@plt>
movsbl %al,%ecx
movsbl (%r15),%edx
cmp    %edx,%ecx
je     1420 <combine+0x1e0>
movsbl %al,%edi
mov    0x48(%rsp),%rsi
call   10e0 <fputc@plt>
jmp    1420 <combine+0x1e0>
xor    %ebx,%ebx
mov    $0x0,%ebp
test   %eax,%eax
jne    147d <combine+0x23d>
xor    %ebp,%ebp
nop
mov    %r13,%rdi
call   10d0 <fgetc@plt>
xor    %ecx,%ecx
cmp    $0xa,%al
sete   %cl
add    %ecx,%ebp
mov    %r13,%rdi
call   1120 <feof@plt>
test   %eax,%eax
je     1460 <combine+0x220>
add    $0x1,%ebp
mov    %r13,%rdi
call   1080 <rewind@plt>
mov    0x30(%rsp),%r15
mov    %r15,%rdi
call   1120 <feof@plt>
test   %eax,%eax
jne    14bd <combine+0x27d>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   10d0 <fgetc@plt>
xor    %ecx,%ecx
cmp    $0xa,%al
sete   %cl
add    %ecx,%ebx
mov    %r15,%rdi
call   1120 <feof@plt>
test   %eax,%eax
je     14a0 <combine+0x260>
mov    %r15,%rdi
call   1080 <rewind@plt>
lea    0x0(,%rbp,8),%eax
lea    (%rax,%rax,8),%edi
call   1130 <malloc@plt>
test   %rax,%rax
je     1d50 <combine+0xb10>
mov    %rax,%r12
add    $0x1,%ebx
lea    0x0(,%rbx,8),%eax
lea    (%rax,%rax,8),%edi
call   1130 <malloc@plt>
mov    %rax,0x50(%rsp)
test   %rax,%rax
je     1d50 <combine+0xb10>
add    %ebp,%ebx
shl    $0x3,%ebx
lea    (%rbx,%rbx,8),%edi
call   1130 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
je     1d50 <combine+0xb10>
mov    %r13,%rdi
call   1120 <feof@plt>
mov    $0x0,%ebp
test   %eax,%eax
mov    0x30(%rsp),%rbx
mov    %r12,0x18(%rsp)
jne    161a <combine+0x3da>
mov    0xc(%rsp),%eax
mov    %eax,%r15d
imul   %r15d,%r15d
lea    0x0(,%r15,4),%eax
mov    %eax,0x38(%rsp)
xor    %ebp,%ebp
jmp    1588 <combine+0x348>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
lea    0xae5(%rip),%rsi
xor    %eax,%eax
call   10c0 <fscanf@plt>
mov    %r12,%rbp
add    $0x1,%rbp
mov    %r13,%rdi
call   1120 <feof@plt>
test   %eax,%eax
jne    1610 <combine+0x3d0>
mov    %rbp,%r12
lea    0x0(%rbp,%rbp,8),%rbp
mov    0x18(%rsp),%rbx
lea    (%rbx,%rbp,8),%rdx
lea    (%rbx,%rbp,8),%rcx
add    $0x34,%rcx
lea    0x38(%rbx,%rbp,8),%r8
mov    %r13,%rdi
lea    0xaf2(%rip),%rsi
lea    0xd0(%rsp),%r9
xor    %eax,%eax
call   10c0 <fscanf@plt>
mov    0x38(%rsp),%edi
call   1130 <malloc@plt>
mov    %rax,0x40(%rbx,%rbp,8)
test   %rax,%rax
je     1d12 <combine+0xad2>
test   %r15,%r15
je     1560 <combine+0x320>
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
add    $0x40,%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdi
call   10d0 <fgetc@plt>
add    $0xffffffd0,%eax
mov    0x0(%rbp),%rcx
mov    %eax,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    15f0 <combine+0x3b0>
jmp    1560 <combine+0x320>
mov    0x30(%rsp),%rbx
mov    0x18(%rsp),%r12
mov    %rbx,%rdi
call   1120 <feof@plt>
mov    $0x0,%r8d
test   %eax,%eax
mov    $0x0,%eax
mov    %rbp,0x40(%rsp)
je     1b8f <combine+0x94f>
cmp    $0x2,%ebp
mov    %rax,0x10(%rsp)
jge    1653 <combine+0x413>
xor    %ecx,%ecx
mov    %r8d,%r15d
mov    0x20(%rsp),%r14
jmp    17ea <combine+0x5aa>
cltq
lea    -0x1(%rbp),%ecx
neg    %rax
mov    %rax,0xc0(%rsp)
xor    %edx,%edx
mov    %r8d,%eax
mov    %r8d,0x28(%rsp)
mov    0x20(%rsp),%r14
mov    %rcx,0xc8(%rsp)
jmp    16b0 <combine+0x470>
nopl   0x0(%rax)
mov    0x10(%rsp),%rax
mov    %eax,0x28(%rsp)
mov    0x6c(%rsp),%eax
mov    %eax,%r8d
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x60(%rsp),%rdx
mov    0xc8(%rsp),%rcx
cmp    %rcx,%rdx
je     17e0 <combine+0x5a0>
movslq %r8d,%r8
lea    (%r8,%r8,8),%rbx
lea    (%r14,%rbx,8),%rdi
lea    (%rdx,%rdx,8),%rbp
lea    (%r12,%rbp,8),%rsi
mov    %r8,%r15
mov    %r12,%r13
mov    %rdx,%r12
call   1030 <strcpy@plt>
mov    %r12,%rdx
mov    %r13,%r12
mov    %r15,%r8
mov    0x34(%r13,%rbp,8),%eax
mov    %eax,0x34(%r14,%rbx,8)
mov    0x38(%r13,%rbp,8),%eax
mov    %eax,0x38(%r14,%rbx,8)
mov    0x40(%r13,%rbp,8),%rax
mov    %rax,0x40(%r14,%rbx,8)
add    $0x1,%r8d
add    $0x1,%rdx
mov    0x10(%rsp),%rcx
mov    0x28(%rsp),%esi
cmp    %ecx,%esi
jge    169f <combine+0x45f>
mov    %rdx,0x60(%rsp)
lea    (%rdx,%rdx,8),%rax
lea    (%r12,%rax,8),%rbp
movslq %r8d,%rax
movslq %esi,%rdi
mov    %r8,0xb8(%rsp)
add    %r8d,%ecx
sub    %esi,%ecx
mov    %ecx,0x6c(%rsp)
lea    (%rdi,%rdi,8),%rcx
mov    %r14,%rdx
mov    0x50(%rsp),%rsi
lea    (%rsi,%rcx,8),%r14
add    0xc0(%rsp),%rdi
mov    %rdi,0x38(%rsp)
lea    (%rax,%rax,8),%rax
lea    (%rdx,%rax,8),%r12
xor    %r15d,%r15d
xor    %r13d,%r13d
jmp    179d <combine+0x55d>
xchg   %ax,%ax
lea    (%r12,%r15,1),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    0x34(%r14,%r15,1),%eax
mov    %eax,0x34(%r12,%r15,1)
mov    0x38(%r14,%r15,1),%eax
mov    %eax,0x38(%r12,%r15,1)
mov    0x40(%r14,%r15,1),%rax
mov    %rax,0x40(%r12,%r15,1)
add    $0xffffffffffffffff,%r13
add    $0x48,%r15
cmp    %r13,0x38(%rsp)
je     1680 <combine+0x440>
lea    (%r14,%r15,1),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
call   10f0 <strcmp@plt>
test   %rax,%rax
js     1760 <combine+0x520>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   10f0 <strcmp@plt>
test   %rax,%rax
jne    17cb <combine+0x58b>
mov    0x34(%r14,%r15,1),%eax
cmp    0x34(%rbp),%eax
jl     1760 <combine+0x520>
mov    0xb8(%rsp),%r8
sub    %r13d,%r8d
sub    %r13d,0x28(%rsp)
jmp    1690 <combine+0x450>
mov    0x28(%rsp),%r15d
mov    0x58(%rsp),%r13
movslq %r8d,%rax
lea    (%rax,%rax,8),%rbp
lea    (%r14,%rbp,8),%rdi
lea    (%rcx,%rcx,8),%rbx
lea    (%r12,%rbx,8),%rsi
call   1030 <strcpy@plt>
mov    0x34(%r12,%rbx,8),%eax
mov    %eax,0x34(%r14,%rbp,8)
mov    0x38(%r12,%rbx,8),%eax
mov    %eax,0x38(%r14,%rbp,8)
mov    0x40(%r12,%rbx,8),%rax
mov    %rax,0x40(%r14,%rbp,8)
cmp    0x10(%rsp),%r15d
jge    187d <combine+0x63d>
movslq %r15d,%rax
lea    (%rax,%rax,8),%rax
mov    0x50(%rsp),%rcx
lea    (%rcx,%rax,8),%rbx
mov    0x10(%rsp),%rax
mov    %eax,%r14d
sub    %r15d,%r14d
mov    0x20(%rsp),%rax
lea    (%rax,%rbp,8),%rbp
add    $0x48,%rbp
nop
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    0x34(%rbx),%eax
mov    %eax,0x34(%rbp)
mov    0x38(%rbx),%eax
mov    %eax,0x38(%rbp)
mov    0x40(%rbx),%rax
mov    %rax,0x40(%rbp)
add    $0x48,%rbx
add    $0x48,%rbp
add    $0xffffffff,%r14d
jne    1850 <combine+0x610>
lea    0x70(%rsp),%rdi
mov    0x20(%rsp),%r14
mov    %r14,%rsi
call   1030 <strcpy@plt>
mov    0x34(%r14),%ecx
mov    %ecx,0xa4(%rsp)
mov    0x38(%r14),%r8d
mov    %r8d,0xa8(%rsp)
mov    0x40(%r14),%rax
mov    %rax,0xb0(%rsp)
mov    0x10(%rsp),%r15
add    0x40(%rsp),%r15d
mov    0xc(%rsp),%eax
imul   %eax,%eax
mov    $0x1,%r9d
mov    %eax,0xc(%rsp)
mov    %eax,%ebx
cmp    $0x2,%r15d
jb     1afd <combine+0x8bd>
mov    %r15d,%eax
mov    %rax,0x38(%rsp)
mov    %ebx,%eax
and    $0xfffffffe,%eax
mov    %rax,0x28(%rsp)
movl   $0x1,0x18(%rsp)
mov    $0x1,%r12d
lea    0x70(%rsp),%r13
jmp    1960 <combine+0x720>
mov    $0xa,%edi
mov    %r14,%rsi
call   10e0 <fputc@plt>
addl   $0x1,0x18(%rsp)
mov    0x20(%rsp),%r14
lea    0x70(%rsp),%r13
mov    0x10(%rsp),%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
mov    0x34(%r14,%r15,8),%eax
mov    %eax,0xa4(%rsp)
mov    0x38(%r14,%r15,8),%eax
mov    %eax,0xa8(%rsp)
mov    0x40(%r14,%r15,8),%rax
mov    %rax,0xb0(%rsp)
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     1ae4 <combine+0x8a4>
lea    (%r12,%r12,8),%r15
lea    (%r14,%r15,8),%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
call   10f0 <strcmp@plt>
test   %rax,%rax
jne    19a0 <combine+0x760>
movslq 0x34(%r14,%r15,8),%rdi
cmp    %edi,0xa8(%rsp)
jl     19a0 <combine+0x760>
movslq 0xa4(%rsp),%rsi
cmp    %esi,0x38(%r14,%r15,8)
jge    1a26 <combine+0x7e6>
nopl   0x0(%rax)
mov    %r13,%rdi
call   1060 <strlen@plt>
cmp    $0x6,%eax
jg     1921 <combine+0x6e1>
mov    %rbp,0x10(%rsp)
mov    0xa4(%rsp),%ecx
mov    0xa8(%rsp),%r8d
mov    0x48(%rsp),%r14
mov    %r14,%rdi
lea    0x67d(%rip),%rsi
mov    %r13,%rdx
mov    0x18(%rsp),%r9d
xor    %eax,%eax
call   1110 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
lea    0x6f3(%rip),%r13
je     1900 <combine+0x6c0>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rax
mov    (%rax,%rbp,4),%edx
mov    %r14,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1110 <fprintf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1a00 <combine+0x7c0>
jmp    1900 <combine+0x6c0>
lea    (%r14,%r15,8),%rbp
add    $0x38,%rbp
call   1090 <min@plt>
mov    %eax,0xa4(%rsp)
movslq 0x0(%rbp),%rdi
movslq 0xa8(%rsp),%rsi
call   10a0 <max@plt>
mov    %eax,0xa8(%rsp)
mov    0xc(%rsp),%eax
test   %eax,%eax
je     1ada <combine+0x89a>
mov    0x40(%r14,%r15,8),%rsi
mov    0xb0(%rsp),%rdi
xor    %ecx,%ecx
lea    0x70(%rsp),%r13
cmp    $0x1,%eax
jne    1ab2 <combine+0x872>
test   $0x1,%bl
je     1951 <combine+0x711>
mov    $0x1,%dl
cmpl   $0x0,(%rsi,%rcx,4)
jne    1a8f <combine+0x84f>
cmpl   $0x0,(%rdi,%rcx,4)
setne  %dl
movzbl %dl,%eax
mov    %eax,(%rdi,%rcx,4)
jmp    1951 <combine+0x711>
nopw   0x0(%rax,%rax,1)
movzbl %dl,%eax
mov    %eax,0x4(%rdi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,0x28(%rsp)
je     1a77 <combine+0x837>
mov    $0x1,%dl
cmpl   $0x0,(%rsi,%rcx,4)
mov    $0x1,%al
jne    1ac3 <combine+0x883>
cmpl   $0x0,(%rdi,%rcx,4)
setne  %al
movzbl %al,%eax
mov    %eax,(%rdi,%rcx,4)
cmpl   $0x0,0x4(%rsi,%rcx,4)
jne    1aa0 <combine+0x860>
cmpl   $0x0,0x4(%rdi,%rcx,4)
setne  %dl
jmp    1aa0 <combine+0x860>
lea    0x70(%rsp),%r13
jmp    1951 <combine+0x711>
mov    0xa4(%rsp),%ecx
mov    0xa8(%rsp),%r8d
mov    0x58(%rsp),%r13
mov    0x18(%rsp),%r9d
lea    0x54d(%rip),%rsi
lea    0x70(%rsp),%rdx
mov    0x48(%rsp),%r15
mov    %r15,%rdi
xor    %eax,%eax
call   1110 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
je     1b51 <combine+0x911>
lea    0x5bc(%rip),%r14
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rax
mov    (%rax,%rbp,4),%edx
mov    %r15,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1110 <fprintf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1b30 <combine+0x8f0>
mov    $0xa,%edi
mov    %r15,%rsi
call   10e0 <fputc@plt>
mov    0x30(%rsp),%rbx
mov    %r13,%rdi
call   1050 <fclose@plt>
mov    %rbx,%rdi
call   1050 <fclose@plt>
mov    0x48(%rsp),%rdi
call   1050 <fclose@plt>
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0xc(%rsp),%eax
mov    %eax,%r15d
imul   %r15d,%r15d
lea    0x0(,%r15,4),%eax
mov    %eax,0x38(%rsp)
movslq %r14d,%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%r15,4),%rax
mov    %rax,0x10(%rsp)
mov    0x50(%rsp),%rax
lea    0x34(%rax),%rbp
lea    0xd0(%rsp),%r14
xor    %r12d,%r12d
jmp    1c05 <combine+0x9c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rax
movl   $0x1,(%rbx,%rax,4)
mov    0x30(%rsp),%rbx
mov    %rbx,%rdi
call   1120 <feof@plt>
add    $0x1,%r12d
add    $0x48,%rbp
test   %eax,%eax
jne    1c57 <combine+0xa17>
lea    -0x34(%rbp),%rdx
lea    0x4(%rbp),%r8
mov    %r14,(%rsp)
mov    %rbx,%rdi
lea    0x426(%rip),%rsi
mov    %rbp,%rcx
mov    %r14,%r9
xor    %eax,%eax
call   10c0 <fscanf@plt>
mov    0x38(%rsp),%edi
call   1130 <malloc@plt>
mov    %rax,0xc(%rbp)
test   %rax,%rax
je     1d12 <combine+0xad2>
mov    %rax,%rbx
test   %r15d,%r15d
je     1be0 <combine+0x9a0>
mov    %rbx,%rdi
xor    %esi,%esi
mov    0x10(%rsp),%rdx
call   10b0 <memset@plt>
jmp    1be0 <combine+0x9a0>
test   %r12d,%r12d
je     1cec <combine+0xaac>
mov    %r12,0x10(%rsp)
mov    %r12d,%r15d
xor    %r14d,%r14d
mov    0x50(%rsp),%rbp
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r12
jmp    1cb0 <combine+0xa70>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
mov    0x34(%rbp),%eax
mov    %eax,0x34(%rbx)
mov    0x38(%rbp),%eax
mov    %eax,0x38(%rbx)
mov    0x40(%rbp),%rax
mov    %rax,0x40(%rbx)
add    $0x1,%r14
add    $0x48,%rbx
add    $0x48,%rbp
cmp    %r14,%r15
je     1d00 <combine+0xac0>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10f0 <strcmp@plt>
test   %rax,%rax
js     1c80 <combine+0xa40>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10f0 <strcmp@plt>
test   %rax,%rax
jne    1cda <combine+0xa9a>
mov    0x34(%rbp),%eax
cmp    0x34(%r12),%eax
jl     1c80 <combine+0xa40>
mov    0x40(%rsp),%rbp
mov    0x10(%rsp),%rax
mov    %r14,%r8
jmp    163a <combine+0x3fa>
xor    %eax,%eax
xor    %r8d,%r8d
mov    0x40(%rsp),%rbp
mov    0x18(%rsp),%r12
jmp    163a <combine+0x3fa>
mov    0x10(%rsp),%rax
mov    %eax,%r8d
mov    0x40(%rsp),%rbp
jmp    163a <combine+0x3fa>
lea    0x396(%rip),%rdi
call   1070 <printf@plt>
xor    %edi,%edi
call   1160 <exit@plt>
lea    0x2d4(%rip),%rdi
call   1070 <printf@plt>
jmp    1d3f <combine+0xaff>
lea    0x3ab(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
call   1100 <getchar@plt>
mov    $0x1,%edi
call   1160 <exit@plt>
lea    0x317(%rip),%rdi
jmp    1d19 <combine+0xad9>

LLVM IR (-O0):
%struct.peak = type { [50 x i8], i32, i32, i32* }
@.str = [2 x i8] c"r\00"
@.str.1 = [62 x i8] c"\0Aerror occurred when opening the input file to combine peaks!\00"
@.str.2 = [3 x i8] c"wb\00"
@.str.3 = [27 x i8] c"\0Acreate output file error\0A\00"
@EOF = global i8 0
@.str.4 = [16 x i8] c"%s\09%d\09%d\09%s\09%s\0A\00"
@.str.5 = [29 x i8] c"%s\09%d\09%d\09MACS_peak_order_%d\09\00"
@.str.6 = [2 x i8] c"1\00"
@.str.7 = [2 x i8] c"0\00"
@.str.8 = [2 x i8] c"\0A\00"
@.str.9 = [52 x i8] c"Memory is not sufficent.Creating output file fails.\00"
@.str.10 = [13 x i8] c"%s\09%d\09%d\09%s\09\00"
@.str.11 = [51 x i8] c"Memory is not sufficent.Creating order file fails.\00"
@.str.12 = [3 x i8] c"%d\00"
define void @combine(i8* %0, i8* %1, i8* %2, i8* %3, i8* %4) {
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca %struct.peak*
%12 = alloca %struct.peak*
%13 = alloca %struct.peak*
%14 = alloca %struct.peak
%15 = alloca %struct.peak
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i8
%34 = alloca i32
%35 = alloca i32
%36 = alloca [50 x i8]
%37 = alloca i8
%38 = alloca i8
%39 = alloca i32
%40 = alloca i32
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i8* %3, i8** %9
store i8* %4, i8** %10
store i32 0, i32* %21
store i32 0, i32* %22
store i32 0, i32* %23
store i32 0, i32* %24
store i32 0, i32* %25
store i32 0, i32* %26
store i32 0, i32* %27
store i32 0, i32* %30
store i32 1, i32* %31
%41 = load i8*, i8** %9
%42 = call i32 @atoi(i8* %41)
store i32 %42, i32* %39
%43 = load i8*, i8** %10
%44 = call i32 @atoi(i8* %43)
store i32 %44, i32* %40
%45 = load i8*, i8** %6
%46 = call i32* @fopen(i8* %45, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %46, i32** %16
%47 = icmp eq i32* %46, null
br i1 %47, label %48, label %52
48: ; preds = %5
%49 = call i32 @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0))
%50 = call i32 (...) @getchar()
%51 = call i32 @exit(i32 1)
unreachable
52: ; preds = %5
%53 = load i8*, i8** %7
%54 = call i32* @fopen(i8* %53, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %54, i32** %17
%55 = icmp eq i32* %54, null
br i1 %55, label %56, label %60
56: ; preds = %52
%57 = call i32 @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0))
%58 = call i32 (...) @getchar()
%59 = call i32 @exit(i32 1)
unreachable
60: ; preds = %52
%61 = load i8*, i8** %8
%62 = call i32* @fopen(i8* %61, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
store i32* %62, i32** %18
%63 = icmp eq i32* %62, null
br i1 %63, label %64, label %68
64: ; preds = %60
%65 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.3, i64 0, i64 0))
%66 = call i32 (...) @getchar()
%67 = call i32 @exit(i32 1)
unreachable
68: ; preds = %60
%69 = load i32*, i32** %16
%70 = call i32 @fgetc(i32* %69)
%71 = trunc i32 %70 to i8
store i8 %71, i8* %37
%72 = load i32*, i32** %17
%73 = call i32 @fgetc(i32* %72)
%74 = trunc i32 %73 to i8
store i8 %74, i8* %38
%75 = load i32*, i32** %16
%76 = call i32 @rewind(i32* %75)
%77 = load i32*, i32** %17
%78 = call i32 @rewind(i32* %77)
%79 = load i8, i8* %37
%80 = sext i8 %79 to i32
%81 = load i8, i8* @EOF
%82 = sext i8 %81 to i32
%83 = icmp ne i32 %80, %82
br i1 %83, label %90, label %84
84: ; preds = %68
%85 = load i8, i8* %38
%86 = sext i8 %85 to i32
%87 = load i8, i8* @EOF
%88 = sext i8 %87 to i32
%89 = icmp ne i32 %86, %88
br i1 %89, label %90, label %998
90: ; preds = %84, %68
%91 = load i8, i8* %37
%92 = sext i8 %91 to i32
%93 = load i8, i8* @EOF
%94 = sext i8 %93 to i32
%95 = icmp eq i32 %92, %94
br i1 %95, label %96, label %144
96: ; preds = %90
br label %97
97: ; preds = %140, %96
%98 = load i32*, i32** %17
%99 = call i32 @feof(i32* %98)
%100 = icmp ne i32 %99, 0
%101 = xor i1 %100, true
br i1 %101, label %102, label %143
102: ; preds = %97
%103 = load i32*, i32** %17
%104 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 0
%105 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 1
%106 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 2
%107 = call i32 (i32*, i8*, ...) @fscanf(i32* %103, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), [50 x i8]* %104, i32* %105, i32* %106, [50 x i8]* %36, [50 x i8]* %36)
%108 = load i32*, i32** %18
%109 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 0
%110 = getelementptr inbounds [50 x i8], [50 x i8]* %109, i64 0, i64 0
%111 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 1
%112 = load i32, i32* %111
%113 = getelementptr inbounds %struct.peak, %struct.peak* %15, i32 0, i32 2
%114 = load i32, i32* %113
%115 = load i32, i32* %31
%116 = call i32 (i32*, i8*, ...) @fprintf(i32* %108, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %110, i32 %112, i32 %114, i32 %115)
%117 = load i32, i32* %31
%118 = add nsw i32 %117, 1
store i32 %118, i32* %31
store i32 0, i32* %34
br label %119
119: ; preds = %137, %102
%120 = load i32, i32* %34
%121 = load i32, i32* %39
%122 = load i32, i32* %39
%123 = mul nsw i32 %121, %122
%124 = sub nsw i32 %123, 1
%125 = icmp sle i32 %120, %124
br i1 %125, label %126, label %140
126: ; preds = %119
%127 = load i32, i32* %34
%128 = load i32, i32* %40
%129 = icmp eq i32 %127, %128
br i1 %129, label %130, label %133
130: ; preds = %126
%131 = load i32*, i32** %18
%132 = call i32 (i32*, i8*, ...) @fprintf(i32* %131, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %136
133: ; preds = %126
%134 = load i32*, i32** %18
%135 = call i32 (i32*, i8*, ...) @fprintf(i32* %134, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
br label %136
136: ; preds = %133, %130
br label %137
137: ; preds = %136
%138 = load i32, i32* %34
%139 = add nsw i32 %138, 1
store i32 %139, i32* %34
br label %119
140: ; preds = %119
%141 = load i32*, i32** %18
%142 = call i32 (i32*, i8*, ...) @fprintf(i32* %141, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
br label %97
143: ; preds = %97
br label %997
144: ; preds = %90
%145 = load i8, i8* %38
%146 = sext i8 %145 to i32
%147 = load i8, i8* @EOF
%148 = sext i8 %147 to i32
%149 = icmp eq i32 %146, %148
br i1 %149, label %150, label %171
150: ; preds = %144
br label %151
151: ; preds = %169, %150
%152 = load i32*, i32** %16
%153 = call i32 @feof(i32* %152)
%154 = icmp ne i32 %153, 0
%155 = xor i1 %154, true
br i1 %155, label %156, label %170
156: ; preds = %151
%157 = load i32*, i32** %16
%158 = call i32 @fgetc(i32* %157)
%159 = trunc i32 %158 to i8
store i8 %159, i8* %37
%160 = load i8, i8* %37
%161 = sext i8 %160 to i32
%162 = load i8, i8* @EOF
%163 = sext i8 %162 to i32
%164 = icmp ne i32 %161, %163
br i1 %164, label %165, label %169
165: ; preds = %156
%166 = load i8, i8* %37
%167 = load i32*, i32** %18
%168 = call i32 @fputc(i8 signext %166, i32* %167)
br label %169
169: ; preds = %165, %156
br label %151
170: ; preds = %151
br label %996
171: ; preds = %144
store i32 0, i32* %19
br label %172
172: ; preds = %187, %171
%173 = load i32*, i32** %16
%174 = call i32 @feof(i32* %173)
%175 = icmp ne i32 %174, 0
%176 = xor i1 %175, true
br i1 %176, label %177, label %188
177: ; preds = %172
%178 = load i32*, i32** %16
%179 = call i32 @fgetc(i32* %178)
%180 = trunc i32 %179 to i8
store i8 %180, i8* %33
%181 = load i8, i8* %33
%182 = sext i8 %181 to i32
%183 = icmp eq i32 %182, 10
br i1 %183, label %184, label %187
184: ; preds = %177
%185 = load i32, i32* %19
%186 = add nsw i32 %185, 1
store i32 %186, i32* %19
br label %187
187: ; preds = %184, %177
br label %172
188: ; preds = %172
%189 = load i32, i32* %19
%190 = add nsw i32 %189, 1
store i32 %190, i32* %19
%191 = load i32*, i32** %16
%192 = call i32 @rewind(i32* %191)
store i32 0, i32* %20
br label %193
193: ; preds = %208, %188
%194 = load i32*, i32** %17
%195 = call i32 @feof(i32* %194)
%196 = icmp ne i32 %195, 0
%197 = xor i1 %196, true
br i1 %197, label %198, label %209
198: ; preds = %193
%199 = load i32*, i32** %17
%200 = call i32 @fgetc(i32* %199)
%201 = trunc i32 %200 to i8
store i8 %201, i8* %33
%202 = load i8, i8* %33
%203 = sext i8 %202 to i32
%204 = icmp eq i32 %203, 10
br i1 %204, label %205, label %208
205: ; preds = %198
%206 = load i32, i32* %20
%207 = add nsw i32 %206, 1
store i32 %207, i32* %20
br label %208
208: ; preds = %205, %198
br label %193
209: ; preds = %193
%210 = load i32, i32* %20
%211 = add nsw i32 %210, 1
store i32 %211, i32* %20
%212 = load i32*, i32** %17
%213 = call i32 @rewind(i32* %212)
%214 = load i32, i32* %19
%215 = sext i32 %214 to i64
%216 = mul i64 72, %215
%217 = trunc i64 %216 to i32
%218 = call i64 @malloc(i32 %217)
%219 = inttoptr i64 %218 to %struct.peak*
store %struct.peak* %219, %struct.peak** %11
%220 = icmp eq %struct.peak* %219, null
br i1 %220, label %221, label %224
221: ; preds = %209
%222 = call i32 @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%223 = call i32 @exit(i32 0)
unreachable
224: ; preds = %209
%225 = load i32, i32* %20
%226 = sext i32 %225 to i64
%227 = mul i64 72, %226
%228 = trunc i64 %227 to i32
%229 = call i64 @malloc(i32 %228)
%230 = inttoptr i64 %229 to %struct.peak*
store %struct.peak* %230, %struct.peak** %12
%231 = icmp eq %struct.peak* %230, null
br i1 %231, label %232, label %235
232: ; preds = %224
%233 = call i32 @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%234 = call i32 @exit(i32 0)
unreachable
235: ; preds = %224
%236 = load i32, i32* %19
%237 = load i32, i32* %20
%238 = add nsw i32 %236, %237
%239 = sext i32 %238 to i64
%240 = mul i64 72, %239
%241 = trunc i64 %240 to i32
%242 = call i64 @malloc(i32 %241)
%243 = inttoptr i64 %242 to %struct.peak*
store %struct.peak* %243, %struct.peak** %13
%244 = icmp eq %struct.peak* %243, null
br i1 %244, label %245, label %248
245: ; preds = %235
%246 = call i32 @printf(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%247 = call i32 @exit(i32 0)
unreachable
248: ; preds = %235
store i32 0, i32* %19
store i32 0, i32* %20
br label %249
249: ; preds = %314, %248
%250 = load i32*, i32** %16
%251 = call i32 @feof(i32* %250)
%252 = icmp ne i32 %251, 0
%253 = xor i1 %252, true
br i1 %253, label %254, label %319
254: ; preds = %249
%255 = load i32*, i32** %16
%256 = load %struct.peak*, %struct.peak** %11
%257 = load i32, i32* %19
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds %struct.peak, %struct.peak* %256, i64 %258
%260 = getelementptr inbounds %struct.peak, %struct.peak* %259, i32 0, i32 0
%261 = load %struct.peak*, %struct.peak** %11
%262 = load i32, i32* %19
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds %struct.peak, %struct.peak* %261, i64 %263
%265 = getelementptr inbounds %struct.peak, %struct.peak* %264, i32 0, i32 1
%266 = load %struct.peak*, %struct.peak** %11
%267 = load i32, i32* %19
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds %struct.peak, %struct.peak* %266, i64 %268
%270 = getelementptr inbounds %struct.peak, %struct.peak* %269, i32 0, i32 2
%271 = call i32 (i32*, i8*, ...) @fscanf(i32* %255, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i64 0, i64 0), [50 x i8]* %260, i32* %265, i32* %270, [50 x i8]* %36)
%272 = load i32, i32* %39
%273 = sext i32 %272 to i64
%274 = mul i64 4, %273
%275 = load i32, i32* %39
%276 = sext i32 %275 to i64
%277 = mul i64 %274, %276
%278 = trunc i64 %277 to i32
%279 = call i64 @malloc(i32 %278)
%280 = inttoptr i64 %279 to i32*
%281 = load %struct.peak*, %struct.peak** %11
%282 = load i32, i32* %19
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds %struct.peak, %struct.peak* %281, i64 %283
%285 = getelementptr inbounds %struct.peak, %struct.peak* %284, i32 0, i32 3
store i32* %280, i32** %285
%286 = icmp eq i32* %280, null
br i1 %286, label %287, label %290
287: ; preds = %254
%288 = call i32 @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.11, i64 0, i64 0))
%289 = call i32 @exit(i32 0)
unreachable
290: ; preds = %254
store i32 0, i32* %34
br label %291
291: ; preds = %311, %290
%292 = load i32, i32* %34
%293 = load i32, i32* %39
%294 = load i32, i32* %39
%295 = mul nsw i32 %293, %294
%296 = sub nsw i32 %295, 1
%297 = icmp sle i32 %292, %296
br i1 %297, label %298, label %314
298: ; preds = %291
%299 = load i32*, i32** %16
%300 = call i32 @fgetc(i32* %299)
%301 = sub nsw i32 %300, 48
%302 = load %struct.peak*, %struct.peak** %11
%303 = load i32, i32* %19
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds %struct.peak, %struct.peak* %302, i64 %304
%306 = getelementptr inbounds %struct.peak, %struct.peak* %305, i32 0, i32 3
%307 = load i32*, i32** %306
%308 = load i32, i32* %34
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %307, i64 %309
store i32 %301, i32* %310
br label %311
311: ; preds = %298
%312 = load i32, i32* %34
%313 = add nsw i32 %312, 1
store i32 %313, i32* %34
br label %291
314: ; preds = %291
%315 = load i32*, i32** %16
%316 = call i32 (i32*, i8*, ...) @fscanf(i32* %315, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%317 = load i32, i32* %19
%318 = add nsw i32 %317, 1
store i32 %318, i32* %19
br label %249
319: ; preds = %249
br label %320
320: ; preds = %382, %319
%321 = load i32*, i32** %17
%322 = call i32 @feof(i32* %321)
%323 = icmp ne i32 %322, 0
%324 = xor i1 %323, true
br i1 %324, label %325, label %394
325: ; preds = %320
%326 = load i32*, i32** %17
%327 = load %struct.peak*, %struct.peak** %12
%328 = load i32, i32* %20
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds %struct.peak, %struct.peak* %327, i64 %329
%331 = getelementptr inbounds %struct.peak, %struct.peak* %330, i32 0, i32 0
%332 = load %struct.peak*, %struct.peak** %12
%333 = load i32, i32* %20
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds %struct.peak, %struct.peak* %332, i64 %334
%336 = getelementptr inbounds %struct.peak, %struct.peak* %335, i32 0, i32 1
%337 = load %struct.peak*, %struct.peak** %12
%338 = load i32, i32* %20
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds %struct.peak, %struct.peak* %337, i64 %339
%341 = getelementptr inbounds %struct.peak, %struct.peak* %340, i32 0, i32 2
%342 = call i32 (i32*, i8*, ...) @fscanf(i32* %326, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), [50 x i8]* %331, i32* %336, i32* %341, [50 x i8]* %36, [50 x i8]* %36)
%343 = load i32, i32* %39
%344 = sext i32 %343 to i64
%345 = mul i64 4, %344
%346 = load i32, i32* %39
%347 = sext i32 %346 to i64
%348 = mul i64 %345, %347
%349 = trunc i64 %348 to i32
%350 = call i64 @malloc(i32 %349)
%351 = inttoptr i64 %350 to i32*
%352 = load %struct.peak*, %struct.peak** %12
%353 = load i32, i32* %20
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds %struct.peak, %struct.peak* %352, i64 %354
%356 = getelementptr inbounds %struct.peak, %struct.peak* %355, i32 0, i32 3
store i32* %351, i32** %356
%357 = icmp eq i32* %351, null
br i1 %357, label %358, label %361
358: ; preds = %325
%359 = call i32 @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.11, i64 0, i64 0))
%360 = call i32 @exit(i32 0)
unreachable
361: ; preds = %325
store i32 0, i32* %34
br label %362
362: ; preds = %379, %361
%363 = load i32, i32* %34
%364 = load i32, i32* %39
%365 = load i32, i32* %39
%366 = mul nsw i32 %364, %365
%367 = sub nsw i32 %366, 1
%368 = icmp sle i32 %363, %367
br i1 %368, label %369, label %382
369: ; preds = %362
%370 = load %struct.peak*, %struct.peak** %12
%371 = load i32, i32* %20
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds %struct.peak, %struct.peak* %370, i64 %372
%374 = getelementptr inbounds %struct.peak, %struct.peak* %373, i32 0, i32 3
%375 = load i32*, i32** %374
%376 = load i32, i32* %34
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds i32, i32* %375, i64 %377
store i32 0, i32* %378
br label %379
379: ; preds = %369
%380 = load i32, i32* %34
%381 = add nsw i32 %380, 1
store i32 %381, i32* %34
br label %362
382: ; preds = %362
%383 = load %struct.peak*, %struct.peak** %12
%384 = load i32, i32* %20
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds %struct.peak, %struct.peak* %383, i64 %385
%387 = getelementptr inbounds %struct.peak, %struct.peak* %386, i32 0, i32 3
%388 = load i32*, i32** %387
%389 = load i32, i32* %40
%390 = sext i32 %389 to i64
%391 = getelementptr inbounds i32, i32* %388, i64 %390
store i32 1, i32* %391
%392 = load i32, i32* %20
%393 = add nsw i32 %392, 1
store i32 %393, i32* %20
br label %320
394: ; preds = %320
store i32 0, i32* %30
store i32 0, i32* %22
br label %395
395: ; preds = %489, %394
%396 = load i32, i32* %22
%397 = load i32, i32* %20
%398 = sub nsw i32 %397, 1
%399 = icmp sle i32 %396, %398
br i1 %399, label %400, label %492
400: ; preds = %395
%401 = load %struct.peak*, %struct.peak** %12
%402 = load i32, i32* %22
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds %struct.peak, %struct.peak* %401, i64 %403
%405 = getelementptr inbounds %struct.peak, %struct.peak* %404, i32 0, i32 0
%406 = getelementptr inbounds [50 x i8], [50 x i8]* %405, i64 0, i64 0
%407 = load %struct.peak*, %struct.peak** %11
%408 = getelementptr inbounds %struct.peak, %struct.peak* %407, i64 0
%409 = getelementptr inbounds %struct.peak, %struct.peak* %408, i32 0, i32 0
%410 = getelementptr inbounds [50 x i8], [50 x i8]* %409, i64 0, i64 0
%411 = call i64 @strcmp(i8* %406, i8* %410)
%412 = icmp slt i64 %411, 0
br i1 %412, label %438, label %413
413: ; preds = %400
%414 = load %struct.peak*, %struct.peak** %12
%415 = load i32, i32* %22
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds %struct.peak, %struct.peak* %414, i64 %416
%418 = getelementptr inbounds %struct.peak, %struct.peak* %417, i32 0, i32 0
%419 = getelementptr inbounds [50 x i8], [50 x i8]* %418, i64 0, i64 0
%420 = load %struct.peak*, %struct.peak** %11
%421 = getelementptr inbounds %struct.peak, %struct.peak* %420, i64 0
%422 = getelementptr inbounds %struct.peak, %struct.peak* %421, i32 0, i32 0
%423 = getelementptr inbounds [50 x i8], [50 x i8]* %422, i64 0, i64 0
%424 = call i64 @strcmp(i8* %419, i8* %423)
%425 = icmp eq i64 %424, 0
br i1 %425, label %426, label %487
426: ; preds = %413
%427 = load %struct.peak*, %struct.peak** %12
%428 = load i32, i32* %22
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds %struct.peak, %struct.peak* %427, i64 %429
%431 = getelementptr inbounds %struct.peak, %struct.peak* %430, i32 0, i32 1
%432 = load i32, i32* %431
%433 = load %struct.peak*, %struct.peak** %11
%434 = getelementptr inbounds %struct.peak, %struct.peak* %433, i64 0
%435 = getelementptr inbounds %struct.peak, %struct.peak* %434, i32 0, i32 1
%436 = load i32, i32* %435
%437 = icmp slt i32 %432, %436
br i1 %437, label %438, label %487
438: ; preds = %426, %400
%439 = load %struct.peak*, %struct.peak** %13
%440 = load i32, i32* %30
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds %struct.peak, %struct.peak* %439, i64 %441
%443 = getelementptr inbounds %struct.peak, %struct.peak* %442, i32 0, i32 0
%444 = getelementptr inbounds [50 x i8], [50 x i8]* %443, i64 0, i64 0
%445 = load %struct.peak*, %struct.peak** %12
%446 = load i32, i32* %22
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds %struct.peak, %struct.peak* %445, i64 %447
%449 = getelementptr inbounds %struct.peak, %struct.peak* %448, i32 0, i32 0
%450 = getelementptr inbounds [50 x i8], [50 x i8]* %449, i64 0, i64 0
%451 = call i32 @strcpy(i8* %444, i8* %450)
%452 = load %struct.peak*, %struct.peak** %12
%453 = load i32, i32* %22
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds %struct.peak, %struct.peak* %452, i64 %454
%456 = getelementptr inbounds %struct.peak, %struct.peak* %455, i32 0, i32 1
%457 = load i32, i32* %456
%458 = load %struct.peak*, %struct.peak** %13
%459 = load i32, i32* %30
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds %struct.peak, %struct.peak* %458, i64 %460
%462 = getelementptr inbounds %struct.peak, %struct.peak* %461, i32 0, i32 1
store i32 %457, i32* %462
%463 = load %struct.peak*, %struct.peak** %12
%464 = load i32, i32* %22
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds %struct.peak, %struct.peak* %463, i64 %465
%467 = getelementptr inbounds %struct.peak, %struct.peak* %466, i32 0, i32 2
%468 = load i32, i32* %467
%469 = load %struct.peak*, %struct.peak** %13
%470 = load i32, i32* %30
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds %struct.peak, %struct.peak* %469, i64 %471
%473 = getelementptr inbounds %struct.peak, %struct.peak* %472, i32 0, i32 2
store i32 %468, i32* %473
%474 = load %struct.peak*, %struct.peak** %12
%475 = load i32, i32* %22
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds %struct.peak, %struct.peak* %474, i64 %476
%478 = getelementptr inbounds %struct.peak, %struct.peak* %477, i32 0, i32 3
%479 = load i32*, i32** %478
%480 = load %struct.peak*, %struct.peak** %13
%481 = load i32, i32* %30
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds %struct.peak, %struct.peak* %480, i64 %482
%484 = getelementptr inbounds %struct.peak, %struct.peak* %483, i32 0, i32 3
store i32* %479, i32** %484
%485 = load i32, i32* %30
%486 = add nsw i32 %485, 1
store i32 %486, i32* %30
br label %488
487: ; preds = %426, %413
br label %492
488: ; preds = %438
br label %489
489: ; preds = %488
%490 = load i32, i32* %22
%491 = add nsw i32 %490, 1
store i32 %491, i32* %22
br label %395
492: ; preds = %487, %395
store i32 0, i32* %21
br label %493
493: ; preds = %654, %492
%494 = load i32, i32* %21
%495 = load i32, i32* %19
%496 = sub nsw i32 %495, 2
%497 = icmp sle i32 %494, %496
br i1 %497, label %498, label %657
498: ; preds = %493
%499 = load %struct.peak*, %struct.peak** %13
%500 = load i32, i32* %30
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds %struct.peak, %struct.peak* %499, i64 %501
%503 = getelementptr inbounds %struct.peak, %struct.peak* %502, i32 0, i32 0
%504 = getelementptr inbounds [50 x i8], [50 x i8]* %503, i64 0, i64 0
%505 = load %struct.peak*, %struct.peak** %11
%506 = load i32, i32* %21
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds %struct.peak, %struct.peak* %505, i64 %507
%509 = getelementptr inbounds %struct.peak, %struct.peak* %508, i32 0, i32 0
%510 = getelementptr inbounds [50 x i8], [50 x i8]* %509, i64 0, i64 0
%511 = call i32 @strcpy(i8* %504, i8* %510)
%512 = load %struct.peak*, %struct.peak** %11
%513 = load i32, i32* %21
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds %struct.peak, %struct.peak* %512, i64 %514
%516 = getelementptr inbounds %struct.peak, %struct.peak* %515, i32 0, i32 1
%517 = load i32, i32* %516
%518 = load %struct.peak*, %struct.peak** %13
%519 = load i32, i32* %30
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds %struct.peak, %struct.peak* %518, i64 %520
%522 = getelementptr inbounds %struct.peak, %struct.peak* %521, i32 0, i32 1
store i32 %517, i32* %522
%523 = load %struct.peak*, %struct.peak** %11
%524 = load i32, i32* %21
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds %struct.peak, %struct.peak* %523, i64 %525
%527 = getelementptr inbounds %struct.peak, %struct.peak* %526, i32 0, i32 2
%528 = load i32, i32* %527
%529 = load %struct.peak*, %struct.peak** %13
%530 = load i32, i32* %30
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds %struct.peak, %struct.peak* %529, i64 %531
%533 = getelementptr inbounds %struct.peak, %struct.peak* %532, i32 0, i32 2
store i32 %528, i32* %533
%534 = load %struct.peak*, %struct.peak** %11
%535 = load i32, i32* %21
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds %struct.peak, %struct.peak* %534, i64 %536
%538 = getelementptr inbounds %struct.peak, %struct.peak* %537, i32 0, i32 3
%539 = load i32*, i32** %538
%540 = load %struct.peak*, %struct.peak** %13
%541 = load i32, i32* %30
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds %struct.peak, %struct.peak* %540, i64 %542
%544 = getelementptr inbounds %struct.peak, %struct.peak* %543, i32 0, i32 3
store i32* %539, i32** %544
%545 = load i32, i32* %30
%546 = add nsw i32 %545, 1
store i32 %546, i32* %30
br label %547
547: ; preds = %650, %498
%548 = load i32, i32* %22
%549 = load i32, i32* %20
%550 = sub nsw i32 %549, 1
%551 = icmp sle i32 %548, %550
br i1 %551, label %552, label %653
552: ; preds = %547
%553 = load %struct.peak*, %struct.peak** %12
%554 = load i32, i32* %22
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds %struct.peak, %struct.peak* %553, i64 %555
%557 = getelementptr inbounds %struct.peak, %struct.peak* %556, i32 0, i32 0
%558 = getelementptr inbounds [50 x i8], [50 x i8]* %557, i64 0, i64 0
%559 = load %struct.peak*, %struct.peak** %11
%560 = load i32, i32* %21
%561 = add nsw i32 %560, 1
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds %struct.peak, %struct.peak* %559, i64 %562
%564 = getelementptr inbounds %struct.peak, %struct.peak* %563, i32 0, i32 0
%565 = getelementptr inbounds [50 x i8], [50 x i8]* %564, i64 0, i64 0
%566 = call i64 @strcmp(i8* %558, i8* %565)
%567 = icmp slt i64 %566, 0
br i1 %567, label %599, label %568
568: ; preds = %552
%569 = load %struct.peak*, %struct.peak** %12
%570 = load i32, i32* %22
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds %struct.peak, %struct.peak* %569, i64 %571
%573 = getelementptr inbounds %struct.peak, %struct.peak* %572, i32 0, i32 0
%574 = getelementptr inbounds [50 x i8], [50 x i8]* %573, i64 0, i64 0
%575 = load %struct.peak*, %struct.peak** %11
%576 = load i32, i32* %21
%577 = add nsw i32 %576, 1
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds %struct.peak, %struct.peak* %575, i64 %578
%580 = getelementptr inbounds %struct.peak, %struct.peak* %579, i32 0, i32 0
%581 = getelementptr inbounds [50 x i8], [50 x i8]* %580, i64 0, i64 0
%582 = call i64 @strcmp(i8* %574, i8* %581)
%583 = icmp eq i64 %582, 0
br i1 %583, label %584, label %648
584: ; preds = %568
%585 = load %struct.peak*, %struct.peak** %12
%586 = load i32, i32* %22
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds %struct.peak, %struct.peak* %585, i64 %587
%589 = getelementptr inbounds %struct.peak, %struct.peak* %588, i32 0, i32 1
%590 = load i32, i32* %589
%591 = load %struct.peak*, %struct.peak** %11
%592 = load i32, i32* %21
%593 = add nsw i32 %592, 1
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds %struct.peak, %struct.peak* %591, i64 %594
%596 = getelementptr inbounds %struct.peak, %struct.peak* %595, i32 0, i32 1
%597 = load i32, i32* %596
%598 = icmp slt i32 %590, %597
br i1 %598, label %599, label %648
599: ; preds = %584, %552
%600 = load %struct.peak*, %struct.peak** %13
%601 = load i32, i32* %30
%602 = sext i32 %601 to i64
%603 = getelementptr inbounds %struct.peak, %struct.peak* %600, i64 %602
%604 = getelementptr inbounds %struct.peak, %struct.peak* %603, i32 0, i32 0
%605 = getelementptr inbounds [50 x i8], [50 x i8]* %604, i64 0, i64 0
%606 = load %struct.peak*, %struct.peak** %12
%607 = load i32, i32* %22
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds %struct.peak, %struct.peak* %606, i64 %608
%610 = getelementptr inbounds %struct.peak, %struct.peak* %609, i32 0, i32 0
%611 = getelementptr inbounds [50 x i8], [50 x i8]* %610, i64 0, i64 0
%612 = call i32 @strcpy(i8* %605, i8* %611)
%613 = load %struct.peak*, %struct.peak** %12
%614 = load i32, i32* %22
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds %struct.peak, %struct.peak* %613, i64 %615
%617 = getelementptr inbounds %struct.peak, %struct.peak* %616, i32 0, i32 1
%618 = load i32, i32* %617
%619 = load %struct.peak*, %struct.peak** %13
%620 = load i32, i32* %30
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds %struct.peak, %struct.peak* %619, i64 %621
%623 = getelementptr inbounds %struct.peak, %struct.peak* %622, i32 0, i32 1
store i32 %618, i32* %623
%624 = load %struct.peak*, %struct.peak** %12
%625 = load i32, i32* %22
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds %struct.peak, %struct.peak* %624, i64 %626
%628 = getelementptr inbounds %struct.peak, %struct.peak* %627, i32 0, i32 2
%629 = load i32, i32* %628
%630 = load %struct.peak*, %struct.peak** %13
%631 = load i32, i32* %30
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds %struct.peak, %struct.peak* %630, i64 %632
%634 = getelementptr inbounds %struct.peak, %struct.peak* %633, i32 0, i32 2
store i32 %629, i32* %634
%635 = load %struct.peak*, %struct.peak** %12
%636 = load i32, i32* %22
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds %struct.peak, %struct.peak* %635, i64 %637
%639 = getelementptr inbounds %struct.peak, %struct.peak* %638, i32 0, i32 3
%640 = load i32*, i32** %639
%641 = load %struct.peak*, %struct.peak** %13
%642 = load i32, i32* %30
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds %struct.peak, %struct.peak* %641, i64 %643
%645 = getelementptr inbounds %struct.peak, %struct.peak* %644, i32 0, i32 3
store i32* %640, i32** %645
%646 = load i32, i32* %30
%647 = add nsw i32 %646, 1
store i32 %647, i32* %30
br label %649
648: ; preds = %584, %568
br label %653
649: ; preds = %599
br label %650
650: ; preds = %649
%651 = load i32, i32* %22
%652 = add nsw i32 %651, 1
store i32 %652, i32* %22
br label %547
653: ; preds = %648, %547
br label %654
654: ; preds = %653
%655 = load i32, i32* %21
%656 = add nsw i32 %655, 1
store i32 %656, i32* %21
br label %493
657: ; preds = %493
%658 = load %struct.peak*, %struct.peak** %13
%659 = load i32, i32* %30
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds %struct.peak, %struct.peak* %658, i64 %660
%662 = getelementptr inbounds %struct.peak, %struct.peak* %661, i32 0, i32 0
%663 = getelementptr inbounds [50 x i8], [50 x i8]* %662, i64 0, i64 0
%664 = load %struct.peak*, %struct.peak** %11
%665 = load i32, i32* %21
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds %struct.peak, %struct.peak* %664, i64 %666
%668 = getelementptr inbounds %struct.peak, %struct.peak* %667, i32 0, i32 0
%669 = getelementptr inbounds [50 x i8], [50 x i8]* %668, i64 0, i64 0
%670 = call i32 @strcpy(i8* %663, i8* %669)
%671 = load %struct.peak*, %struct.peak** %11
%672 = load i32, i32* %21
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds %struct.peak, %struct.peak* %671, i64 %673
%675 = getelementptr inbounds %struct.peak, %struct.peak* %674, i32 0, i32 1
%676 = load i32, i32* %675
%677 = load %struct.peak*, %struct.peak** %13
%678 = load i32, i32* %30
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds %struct.peak, %struct.peak* %677, i64 %679
%681 = getelementptr inbounds %struct.peak, %struct.peak* %680, i32 0, i32 1
store i32 %676, i32* %681
%682 = load %struct.peak*, %struct.peak** %11
%683 = load i32, i32* %21
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds %struct.peak, %struct.peak* %682, i64 %684
%686 = getelementptr inbounds %struct.peak, %struct.peak* %685, i32 0, i32 2
%687 = load i32, i32* %686
%688 = load %struct.peak*, %struct.peak** %13
%689 = load i32, i32* %30
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds %struct.peak, %struct.peak* %688, i64 %690
%692 = getelementptr inbounds %struct.peak, %struct.peak* %691, i32 0, i32 2
store i32 %687, i32* %692
%693 = load %struct.peak*, %struct.peak** %11
%694 = load i32, i32* %21
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds %struct.peak, %struct.peak* %693, i64 %695
%697 = getelementptr inbounds %struct.peak, %struct.peak* %696, i32 0, i32 3
%698 = load i32*, i32** %697
%699 = load %struct.peak*, %struct.peak** %13
%700 = load i32, i32* %30
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds %struct.peak, %struct.peak* %699, i64 %701
%703 = getelementptr inbounds %struct.peak, %struct.peak* %702, i32 0, i32 3
store i32* %698, i32** %703
%704 = load i32, i32* %30
%705 = add nsw i32 %704, 1
store i32 %705, i32* %30
br label %706
706: ; preds = %760, %657
%707 = load i32, i32* %22
%708 = load i32, i32* %20
%709 = sub nsw i32 %708, 1
%710 = icmp sle i32 %707, %709
br i1 %710, label %711, label %763
711: ; preds = %706
%712 = load %struct.peak*, %struct.peak** %13
%713 = load i32, i32* %30
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds %struct.peak, %struct.peak* %712, i64 %714
%716 = getelementptr inbounds %struct.peak, %struct.peak* %715, i32 0, i32 0
%717 = getelementptr inbounds [50 x i8], [50 x i8]* %716, i64 0, i64 0
%718 = load %struct.peak*, %struct.peak** %12
%719 = load i32, i32* %22
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds %struct.peak, %struct.peak* %718, i64 %720
%722 = getelementptr inbounds %struct.peak, %struct.peak* %721, i32 0, i32 0
%723 = getelementptr inbounds [50 x i8], [50 x i8]* %722, i64 0, i64 0
%724 = call i32 @strcpy(i8* %717, i8* %723)
%725 = load %struct.peak*, %struct.peak** %12
%726 = load i32, i32* %22
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds %struct.peak, %struct.peak* %725, i64 %727
%729 = getelementptr inbounds %struct.peak, %struct.peak* %728, i32 0, i32 1
%730 = load i32, i32* %729
%731 = load %struct.peak*, %struct.peak** %13
%732 = load i32, i32* %30
%733 = sext i32 %732 to i64
%734 = getelementptr inbounds %struct.peak, %struct.peak* %731, i64 %733
%735 = getelementptr inbounds %struct.peak, %struct.peak* %734, i32 0, i32 1
store i32 %730, i32* %735
%736 = load %struct.peak*, %struct.peak** %12
%737 = load i32, i32* %22
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds %struct.peak, %struct.peak* %736, i64 %738
%740 = getelementptr inbounds %struct.peak, %struct.peak* %739, i32 0, i32 2
%741 = load i32, i32* %740
%742 = load %struct.peak*, %struct.peak** %13
%743 = load i32, i32* %30
%744 = sext i32 %743 to i64
%745 = getelementptr inbounds %struct.peak, %struct.peak* %742, i64 %744
%746 = getelementptr inbounds %struct.peak, %struct.peak* %745, i32 0, i32 2
store i32 %741, i32* %746
%747 = load %struct.peak*, %struct.peak** %12
%748 = load i32, i32* %22
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds %struct.peak, %struct.peak* %747, i64 %749
%751 = getelementptr inbounds %struct.peak, %struct.peak* %750, i32 0, i32 3
%752 = load i32*, i32** %751
%753 = load %struct.peak*, %struct.peak** %13
%754 = load i32, i32* %30
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds %struct.peak, %struct.peak* %753, i64 %755
%757 = getelementptr inbounds %struct.peak, %struct.peak* %756, i32 0, i32 3
store i32* %752, i32** %757
%758 = load i32, i32* %30
%759 = add nsw i32 %758, 1
store i32 %759, i32* %30
br label %760
760: ; preds = %711
%761 = load i32, i32* %22
%762 = add nsw i32 %761, 1
store i32 %762, i32* %22
br label %706
763: ; preds = %706
store i32 1, i32* %31
%764 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%765 = getelementptr inbounds [50 x i8], [50 x i8]* %764, i64 0, i64 0
%766 = load %struct.peak*, %struct.peak** %13
%767 = getelementptr inbounds %struct.peak, %struct.peak* %766, i64 0
%768 = getelementptr inbounds %struct.peak, %struct.peak* %767, i32 0, i32 0
%769 = getelementptr inbounds [50 x i8], [50 x i8]* %768, i64 0, i64 0
%770 = call i32 @strcpy(i8* %765, i8* %769)
%771 = load %struct.peak*, %struct.peak** %13
%772 = getelementptr inbounds %struct.peak, %struct.peak* %771, i64 0
%773 = getelementptr inbounds %struct.peak, %struct.peak* %772, i32 0, i32 1
%774 = load i32, i32* %773
%775 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
store i32 %774, i32* %775
%776 = load %struct.peak*, %struct.peak** %13
%777 = getelementptr inbounds %struct.peak, %struct.peak* %776, i64 0
%778 = getelementptr inbounds %struct.peak, %struct.peak* %777, i32 0, i32 2
%779 = load i32, i32* %778
%780 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
store i32 %779, i32* %780
%781 = load %struct.peak*, %struct.peak** %13
%782 = getelementptr inbounds %struct.peak, %struct.peak* %781, i64 0
%783 = getelementptr inbounds %struct.peak, %struct.peak* %782, i32 0, i32 3
%784 = load i32*, i32** %783
%785 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
store i32* %784, i32** %785
store i32 1, i32* %34
br label %786
786: ; preds = %961, %763
%787 = load i32, i32* %34
%788 = load i32, i32* %19
%789 = load i32, i32* %20
%790 = add nsw i32 %788, %789
%791 = sub nsw i32 %790, 1
%792 = icmp sle i32 %787, %791
br i1 %792, label %793, label %964
793: ; preds = %786
%794 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%795 = getelementptr inbounds [50 x i8], [50 x i8]* %794, i64 0, i64 0
%796 = load %struct.peak*, %struct.peak** %13
%797 = load i32, i32* %34
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds %struct.peak, %struct.peak* %796, i64 %798
%800 = getelementptr inbounds %struct.peak, %struct.peak* %799, i32 0, i32 0
%801 = getelementptr inbounds [50 x i8], [50 x i8]* %800, i64 0, i64 0
%802 = call i64 @strcmp(i8* %795, i8* %801)
%803 = icmp eq i64 %802, 0
br i1 %803, label %804, label %890
804: ; preds = %793
%805 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
%806 = load i32, i32* %805
%807 = load %struct.peak*, %struct.peak** %13
%808 = load i32, i32* %34
%809 = sext i32 %808 to i64
%810 = getelementptr inbounds %struct.peak, %struct.peak* %807, i64 %809
%811 = getelementptr inbounds %struct.peak, %struct.peak* %810, i32 0, i32 1
%812 = load i32, i32* %811
%813 = icmp slt i32 %806, %812
br i1 %813, label %890, label %814
814: ; preds = %804
%815 = load %struct.peak*, %struct.peak** %13
%816 = load i32, i32* %34
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds %struct.peak, %struct.peak* %815, i64 %817
%819 = getelementptr inbounds %struct.peak, %struct.peak* %818, i32 0, i32 2
%820 = load i32, i32* %819
%821 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
%822 = load i32, i32* %821
%823 = icmp slt i32 %820, %822
br i1 %823, label %890, label %824
824: ; preds = %814
%825 = load %struct.peak*, %struct.peak** %13
%826 = load i32, i32* %34
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds %struct.peak, %struct.peak* %825, i64 %827
%829 = getelementptr inbounds %struct.peak, %struct.peak* %828, i32 0, i32 1
%830 = load i32, i32* %829
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
%833 = load i32, i32* %832
%834 = sext i32 %833 to i64
%835 = call i64 @min(i64 %831, i64 %834)
%836 = trunc i64 %835 to i32
%837 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
store i32 %836, i32* %837
%838 = load %struct.peak*, %struct.peak** %13
%839 = load i32, i32* %34
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds %struct.peak, %struct.peak* %838, i64 %840
%842 = getelementptr inbounds %struct.peak, %struct.peak* %841, i32 0, i32 2
%843 = load i32, i32* %842
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
%846 = load i32, i32* %845
%847 = sext i32 %846 to i64
%848 = call i64 @max(i64 %844, i64 %847)
%849 = trunc i64 %848 to i32
%850 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
store i32 %849, i32* %850
store i32 0, i32* %32
br label %851
851: ; preds = %886, %824
%852 = load i32, i32* %32
%853 = load i32, i32* %39
%854 = load i32, i32* %39
%855 = mul nsw i32 %853, %854
%856 = sub nsw i32 %855, 1
%857 = icmp sle i32 %852, %856
br i1 %857, label %858, label %889
858: ; preds = %851
%859 = load %struct.peak*, %struct.peak** %13
%860 = load i32, i32* %34
%861 = sext i32 %860 to i64
%862 = getelementptr inbounds %struct.peak, %struct.peak* %859, i64 %861
%863 = getelementptr inbounds %struct.peak, %struct.peak* %862, i32 0, i32 3
%864 = load i32*, i32** %863
%865 = load i32, i32* %32
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds i32, i32* %864, i64 %866
%868 = load i32, i32* %867
%869 = icmp ne i32 %868, 0
br i1 %869, label %878, label %870
870: ; preds = %858
%871 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
%872 = load i32*, i32** %871
%873 = load i32, i32* %32
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds i32, i32* %872, i64 %874
%876 = load i32, i32* %875
%877 = icmp ne i32 %876, 0
br label %878
878: ; preds = %870, %858
%879 = phi i1 [ true, %858 ], [ %877, %870 ]
%880 = zext i1 %879 to i32
%881 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
%882 = load i32*, i32** %881
%883 = load i32, i32* %32
%884 = sext i32 %883 to i64
%885 = getelementptr inbounds i32, i32* %882, i64 %884
store i32 %880, i32* %885
br label %886
886: ; preds = %878
%887 = load i32, i32* %32
%888 = add nsw i32 %887, 1
store i32 %888, i32* %32
br label %851
889: ; preds = %851
br label %960
890: ; preds = %814, %804, %793
%891 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%892 = getelementptr inbounds [50 x i8], [50 x i8]* %891, i64 0, i64 0
%893 = call i32 @strlen(i8* %892)
%894 = icmp sle i32 %893, 6
br i1 %894, label %895, label %929
895: ; preds = %890
%896 = load i32*, i32** %18
%897 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%898 = getelementptr inbounds [50 x i8], [50 x i8]* %897, i64 0, i64 0
%899 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
%900 = load i32, i32* %899
%901 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
%902 = load i32, i32* %901
%903 = load i32, i32* %31
%904 = call i32 (i32*, i8*, ...) @fprintf(i32* %896, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %898, i32 %900, i32 %902, i32 %903)
store i32 0, i32* %32
br label %905
905: ; preds = %921, %895
%906 = load i32, i32* %32
%907 = load i32, i32* %39
%908 = load i32, i32* %39
%909 = mul nsw i32 %907, %908
%910 = sub nsw i32 %909, 1
%911 = icmp sle i32 %906, %910
br i1 %911, label %912, label %924
912: ; preds = %905
%913 = load i32*, i32** %18
%914 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
%915 = load i32*, i32** %914
%916 = load i32, i32* %32
%917 = sext i32 %916 to i64
%918 = getelementptr inbounds i32, i32* %915, i64 %917
%919 = load i32, i32* %918
%920 = call i32 (i32*, i8*, ...) @fprintf(i32* %913, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i32 %919)
br label %921
921: ; preds = %912
%922 = load i32, i32* %32
%923 = add nsw i32 %922, 1
store i32 %923, i32* %32
br label %905
924: ; preds = %905
%925 = load i32*, i32** %18
%926 = call i32 (i32*, i8*, ...) @fprintf(i32* %925, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%927 = load i32, i32* %31
%928 = add nsw i32 %927, 1
store i32 %928, i32* %31
br label %929
929: ; preds = %924, %890
%930 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%931 = getelementptr inbounds [50 x i8], [50 x i8]* %930, i64 0, i64 0
%932 = load %struct.peak*, %struct.peak** %13
%933 = load i32, i32* %34
%934 = sext i32 %933 to i64
%935 = getelementptr inbounds %struct.peak, %struct.peak* %932, i64 %934
%936 = getelementptr inbounds %struct.peak, %struct.peak* %935, i32 0, i32 0
%937 = getelementptr inbounds [50 x i8], [50 x i8]* %936, i64 0, i64 0
%938 = call i32 @strcpy(i8* %931, i8* %937)
%939 = load %struct.peak*, %struct.peak** %13
%940 = load i32, i32* %34
%941 = sext i32 %940 to i64
%942 = getelementptr inbounds %struct.peak, %struct.peak* %939, i64 %941
%943 = getelementptr inbounds %struct.peak, %struct.peak* %942, i32 0, i32 1
%944 = load i32, i32* %943
%945 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
store i32 %944, i32* %945
%946 = load %struct.peak*, %struct.peak** %13
%947 = load i32, i32* %34
%948 = sext i32 %947 to i64
%949 = getelementptr inbounds %struct.peak, %struct.peak* %946, i64 %948
%950 = getelementptr inbounds %struct.peak, %struct.peak* %949, i32 0, i32 2
%951 = load i32, i32* %950
%952 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
store i32 %951, i32* %952
%953 = load %struct.peak*, %struct.peak** %13
%954 = load i32, i32* %34
%955 = sext i32 %954 to i64
%956 = getelementptr inbounds %struct.peak, %struct.peak* %953, i64 %955
%957 = getelementptr inbounds %struct.peak, %struct.peak* %956, i32 0, i32 3
%958 = load i32*, i32** %957
%959 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
store i32* %958, i32** %959
br label %960
960: ; preds = %929, %889
br label %961
961: ; preds = %960
%962 = load i32, i32* %34
%963 = add nsw i32 %962, 1
store i32 %963, i32* %34
br label %786
964: ; preds = %786
%965 = load i32*, i32** %18
%966 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 0
%967 = getelementptr inbounds [50 x i8], [50 x i8]* %966, i64 0, i64 0
%968 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 1
%969 = load i32, i32* %968
%970 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 2
%971 = load i32, i32* %970
%972 = load i32, i32* %31
%973 = call i32 (i32*, i8*, ...) @fprintf(i32* %965, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %967, i32 %969, i32 %971, i32 %972)
store i32 0, i32* %32
br label %974
974: ; preds = %990, %964
%975 = load i32, i32* %32
%976 = load i32, i32* %39
%977 = load i32, i32* %39
%978 = mul nsw i32 %976, %977
%979 = sub nsw i32 %978, 1
%980 = icmp sle i32 %975, %979
br i1 %980, label %981, label %993
981: ; preds = %974
%982 = load i32*, i32** %18
%983 = getelementptr inbounds %struct.peak, %struct.peak* %14, i32 0, i32 3
%984 = load i32*, i32** %983
%985 = load i32, i32* %32
%986 = sext i32 %985 to i64
%987 = getelementptr inbounds i32, i32* %984, i64 %986
%988 = load i32, i32* %987
%989 = call i32 (i32*, i8*, ...) @fprintf(i32* %982, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i32 %988)
br label %990
990: ; preds = %981
%991 = load i32, i32* %32
%992 = add nsw i32 %991, 1
store i32 %992, i32* %32
br label %974
993: ; preds = %974
%994 = load i32*, i32** %18
%995 = call i32 (i32*, i8*, ...) @fprintf(i32* %994, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
br label %996
996: ; preds = %993, %170
br label %997
997: ; preds = %996, %143
br label %998
998: ; preds = %997, %84
%999 = load i32*, i32** %16
%1000 = call i32 @fclose(i32* %999)
%1001 = load i32*, i32** %17
%1002 = call i32 @fclose(i32* %1001)
%1003 = load i32*, i32** %18
%1004 = call i32 @fclose(i32* %1003)
ret void
}

LLVM IR (-O2):
%struct.peak = type { [50 x i8], i32, i32, i32* }
@.str = [2 x i8] c"r\00"
@.str.1 = [62 x i8] c"\0Aerror occurred when opening the input file to combine peaks!\00"
@.str.2 = [3 x i8] c"wb\00"
@EOF = global i8 0
@.str.4 = [16 x i8] c"%s\09%d\09%d\09%s\09%s\0A\00"
@.str.5 = [29 x i8] c"%s\09%d\09%d\09MACS_peak_order_%d\09\00"
@.str.8 = [2 x i8] c"\0A\00"
@.str.9 = [52 x i8] c"Memory is not sufficent.Creating output file fails.\00"
@.str.10 = [13 x i8] c"%s\09%d\09%d\09%s\09\00"
@.str.11 = [51 x i8] c"Memory is not sufficent.Creating order file fails.\00"
@.str.12 = [3 x i8] c"%d\00"
@str = [26 x i8] c"\0Acreate output file error\00"
define void @combine(i8* nocapture %0, i8* nocapture %1, i8* nocapture %2, i8* nocapture %3, i8* nocapture %4) {
%6 = alloca %struct.peak
%7 = alloca %struct.peak
%8 = alloca [50 x i8]
%9 = getelementptr inbounds %struct.peak, %struct.peak* %6, i64 0, i32 0, i64 0
%10 = getelementptr inbounds %struct.peak, %struct.peak* %7, i64 0, i32 0, i64 0
%11 = getelementptr inbounds [50 x i8], [50 x i8]* %8, i64 0, i64 0
%12 = tail call i32 @atoi(i8* %3)
%13 = tail call i32 @atoi(i8* %4)
%14 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%15 = icmp eq i32* %14, null
br i1 %15, label %16, label %20
16: ; preds = %5
%17 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0))
%18 = tail call i32 (...) @getchar()
%19 = tail call i32 @exit(i32 1)
unreachable
20: ; preds = %5
%21 = tail call i32* @fopen(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%22 = icmp eq i32* %21, null
br i1 %22, label %23, label %27
23: ; preds = %20
%24 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([62 x i8], [62 x i8]* @.str.1, i64 0, i64 0))
%25 = tail call i32 (...) @getchar()
%26 = tail call i32 @exit(i32 1)
unreachable
27: ; preds = %20
%28 = tail call i32* @fopen(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%29 = icmp eq i32* %28, null
br i1 %29, label %30, label %34
30: ; preds = %27
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str, i64 0, i64 0))
%32 = tail call i32 (...) @getchar()
%33 = tail call i32 @exit(i32 1)
unreachable
34: ; preds = %27
%35 = tail call i32 @fgetc(i32* %14)
%36 = tail call i32 @fgetc(i32* %21)
%37 = tail call i32 @rewind(i32* %14)
%38 = tail call i32 @rewind(i32* %21)
%39 = shl i32 %35, 24
%40 = ashr exact i32 %39, 24
%41 = load i8, i8* @EOF
%42 = sext i8 %41 to i32
%43 = icmp eq i32 %40, %42
%44 = shl i32 %36, 24
%45 = ashr exact i32 %44, 24
br i1 %43, label %46, label %75
46: ; preds = %34
%47 = icmp eq i32 %45, %40
br i1 %47, label %515, label %48
48: ; preds = %46
%49 = tail call i32 @feof(i32* %21)
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %515
51: ; preds = %48
%52 = getelementptr inbounds %struct.peak, %struct.peak* %7, i64 0, i32 0
%53 = getelementptr inbounds %struct.peak, %struct.peak* %7, i64 0, i32 1
%54 = getelementptr inbounds %struct.peak, %struct.peak* %7, i64 0, i32 2
%55 = mul i32 %12, %12
%56 = icmp eq i32 %55, 0
br label %57
57: ; preds = %51, %71
%58 = phi i32 [ 1, %51 ], [ %63, %71 ]
%59 = call i32 (i32*, i8*, ...) @fscanf(i32* %21, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), [50 x i8]* %52, i32* %53, i32* %54, [50 x i8]* %8, [50 x i8]* %8)
%60 = load i32, i32* %53
%61 = load i32, i32* %54
%62 = call i32 (i32*, i8*, ...) @fprintf(i32* %28, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %10, i32 %60, i32 %61, i32 %58)
%63 = add nuw nsw i32 %58, 1
br i1 %56, label %71, label %64
64: ; preds = %57, %64
%65 = phi i32 [ %69, %64 ], [ 0, %57 ]
%66 = icmp eq i32 %65, %13
%67 = select i1 %66, i32 49, i32 48
%68 = call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 %67, i32* %28)
%69 = add nuw i32 %65, 1
%70 = icmp eq i32 %69, %55
br i1 %70, label %71, label %64
71: ; preds = %64, %57
%72 = call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 10, i32* %28)
%73 = call i32 @feof(i32* %21)
%74 = icmp eq i32 %73, 0
br i1 %74, label %57, label %515
75: ; preds = %34
%76 = icmp eq i32 %45, %42
%77 = tail call i32 @feof(i32* %14)
%78 = icmp eq i32 %77, 0
br i1 %76, label %80, label %79
79: ; preds = %75
br i1 %78, label %94, label %103
80: ; preds = %75
br i1 %78, label %81, label %515
81: ; preds = %80, %91
%82 = tail call i32 @fgetc(i32* %14)
%83 = shl i32 %82, 24
%84 = ashr exact i32 %83, 24
%85 = load i8, i8* @EOF
%86 = sext i8 %85 to i32
%87 = icmp eq i32 %84, %86
br i1 %87, label %91, label %88
88: ; preds = %81
%89 = trunc i32 %82 to i8
%90 = tail call i32 @fputc(i8 signext %89, i32* %28)
br label %91
91: ; preds = %88, %81
%92 = tail call i32 @feof(i32* %14)
%93 = icmp eq i32 %92, 0
br i1 %93, label %81, label %515
94: ; preds = %79, %94
%95 = phi i32 [ %100, %94 ], [ 0, %79 ]
%96 = tail call i32 @fgetc(i32* %14)
%97 = and i32 %96, 255
%98 = icmp eq i32 %97, 10
%99 = zext i1 %98 to i32
%100 = add nuw nsw i32 %95, %99
%101 = tail call i32 @feof(i32* %14)
%102 = icmp eq i32 %101, 0
br i1 %102, label %94, label %103
103: ; preds = %94, %79
%104 = phi i32 [ 0, %79 ], [ %100, %94 ]
%105 = add nuw nsw i32 %104, 1
%106 = tail call i32 @rewind(i32* %14)
%107 = tail call i32 @feof(i32* %21)
%108 = icmp eq i32 %107, 0
br i1 %108, label %109, label %118
109: ; preds = %103, %109
%110 = phi i32 [ %115, %109 ], [ 0, %103 ]
%111 = tail call i32 @fgetc(i32* %21)
%112 = and i32 %111, 255
%113 = icmp eq i32 %112, 10
%114 = zext i1 %113 to i32
%115 = add nuw nsw i32 %110, %114
%116 = tail call i32 @feof(i32* %21)
%117 = icmp eq i32 %116, 0
br i1 %117, label %109, label %118
118: ; preds = %109, %103
%119 = phi i32 [ 0, %103 ], [ %115, %109 ]
%120 = add nuw nsw i32 %119, 1
%121 = tail call i32 @rewind(i32* %21)
%122 = mul i32 %105, 72
%123 = tail call i64 @malloc(i32 %122)
%124 = inttoptr i64 %123 to %struct.peak*
%125 = icmp eq i64 %123, 0
br i1 %125, label %126, label %129
126: ; preds = %118
%127 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%128 = tail call i32 @exit(i32 0)
unreachable
129: ; preds = %118
%130 = mul i32 %120, 72
%131 = tail call i64 @malloc(i32 %130)
%132 = inttoptr i64 %131 to %struct.peak*
%133 = icmp eq i64 %131, 0
br i1 %133, label %134, label %137
134: ; preds = %129
%135 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%136 = tail call i32 @exit(i32 0)
unreachable
137: ; preds = %129
%138 = add nuw nsw i32 %120, %105
%139 = mul i32 %138, 72
%140 = tail call i64 @malloc(i32 %139)
%141 = inttoptr i64 %140 to %struct.peak*
%142 = icmp eq i64 %140, 0
br i1 %142, label %151, label %143
143: ; preds = %137
%144 = tail call i32 @feof(i32* %14)
%145 = icmp eq i32 %144, 0
br i1 %145, label %146, label %156
146: ; preds = %143
%147 = mul i32 %12, %12
%148 = shl i32 %147, 2
%149 = icmp eq i32 %147, 0
%150 = zext i32 %147 to i64
br label %167
151: ; preds = %137
%152 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @.str.9, i64 0, i64 0))
%153 = tail call i32 @exit(i32 0)
unreachable
154: ; preds = %189
%155 = trunc i64 %191 to i32
br label %156
156: ; preds = %154, %143
%157 = phi i32 [ 0, %143 ], [ %155, %154 ]
%158 = call i32 @feof(i32* %21)
%159 = icmp eq i32 %158, 0
br i1 %159, label %160, label %253
160: ; preds = %156
%161 = mul i32 %12, %12
%162 = shl i32 %161, 2
%163 = icmp eq i32 %161, 0
%164 = sext i32 %13 to i64
%165 = zext i32 %161 to i64
%166 = shl nuw nsw i64 %165, 2
br label %201
167: ; preds = %146, %189
%168 = phi i64 [ 0, %146 ], [ %191, %189 ]
%169 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %168, i32 0
%170 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %168, i32 1
%171 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %168, i32 2
%172 = call i32 (i32*, i8*, ...) @fscanf(i32* %14, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i64 0, i64 0), [50 x i8]* %169, i32* %170, i32* %171, [50 x i8]* %8)
%173 = call i64 @malloc(i32 %148)
%174 = inttoptr i64 %173 to i32*
%175 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %168, i32 3
store i32* %174, i32** %175
%176 = icmp eq i64 %173, 0
br i1 %176, label %178, label %177
177: ; preds = %167
br i1 %149, label %189, label %181
178: ; preds = %167
%179 = call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.11, i64 0, i64 0))
%180 = call i32 @exit(i32 0)
unreachable
181: ; preds = %177, %181
%182 = phi i64 [ %187, %181 ], [ 0, %177 ]
%183 = call i32 @fgetc(i32* %14)
%184 = add nsw i32 %183, -48
%185 = load i32*, i32** %175
%186 = getelementptr inbounds i32, i32* %185, i64 %182
store i32 %184, i32* %186
%187 = add nuw nsw i64 %182, 1
%188 = icmp eq i64 %187, %150
br i1 %188, label %189, label %181
189: ; preds = %181, %177
%190 = call i32 (i32*, i8*, ...) @fscanf(i32* %14, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%191 = add nuw i64 %168, 1
%192 = call i32 @feof(i32* %14)
%193 = icmp eq i32 %192, 0
br i1 %193, label %167, label %154
194: ; preds = %217
%195 = trunc i64 %219 to i32
%196 = icmp eq i32 %195, 0
br i1 %196, label %253, label %197
197: ; preds = %194
%198 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 0, i32 0, i64 0
%199 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 0, i32 1
%200 = and i64 %219, 4294967295
br label %222
201: ; preds = %160, %217
%202 = phi i64 [ 0, %160 ], [ %219, %217 ]
%203 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %202, i32 0
%204 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %202, i32 1
%205 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %202, i32 2
%206 = call i32 (i32*, i8*, ...) @fscanf(i32* %21, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.4, i64 0, i64 0), [50 x i8]* %203, i32* %204, i32* %205, [50 x i8]* %8, [50 x i8]* %8)
%207 = call i64 @malloc(i32 %162)
%208 = inttoptr i64 %207 to i32*
%209 = inttoptr i64 %207 to i8*
%210 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %202, i32 3
store i32* %208, i32** %210
%211 = icmp eq i64 %207, 0
br i1 %211, label %214, label %212
212: ; preds = %201
br i1 %163, label %217, label %213
213: ; preds = %212
br label %217
214: ; preds = %201
%215 = call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.11, i64 0, i64 0))
%216 = call i32 @exit(i32 0)
unreachable
217: ; preds = %213, %212
%218 = getelementptr inbounds i32, i32* %208, i64 %164
store i32 1, i32* %218
%219 = add nuw i64 %202, 1
%220 = call i32 @feof(i32* %21)
%221 = icmp eq i32 %220, 0
br i1 %221, label %201, label %194
222: ; preds = %197, %235
%223 = phi i64 [ 0, %197 ], [ %247, %235 ]
%224 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %223, i32 0, i64 0
%225 = call i64 @strcmp(i8* %224, i8* %198)
%226 = icmp slt i64 %225, 0
br i1 %226, label %235, label %227
227: ; preds = %222
%228 = call i64 @strcmp(i8* %224, i8* %198)
%229 = icmp eq i64 %228, 0
br i1 %229, label %230, label %249
230: ; preds = %227
%231 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %223, i32 1
%232 = load i32, i32* %231
%233 = load i32, i32* %199
%234 = icmp slt i32 %232, %233
br i1 %234, label %235, label %251
235: ; preds = %230, %222
%236 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %223, i32 0, i64 0
%237 = call i32 @strcpy(i8* %236, i8* %224)
%238 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %223, i32 1
%239 = load i32, i32* %238
%240 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %223, i32 1
store i32 %239, i32* %240
%241 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %223, i32 2
%242 = load i32, i32* %241
%243 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %223, i32 2
store i32 %242, i32* %243
%244 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %223, i32 3
%245 = load i32*, i32** %244
%246 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %223, i32 3
store i32* %245, i32** %246
%247 = add nuw nsw i64 %223, 1
%248 = icmp eq i64 %247, %200
br i1 %248, label %253, label %222
249: ; preds = %227
%250 = trunc i64 %223 to i32
br label %253
251: ; preds = %230
%252 = trunc i64 %223 to i32
br label %253
253: ; preds = %235, %249, %251, %156, %194
%254 = phi i32 [ 0, %194 ], [ 0, %156 ], [ %195, %251 ], [ %195, %249 ], [ %195, %235 ]
%255 = phi i32 [ 0, %194 ], [ 0, %156 ], [ %252, %251 ], [ %250, %249 ], [ %195, %235 ]
%256 = icmp slt i32 %157, 2
br i1 %256, label %327, label %257
257: ; preds = %253
%258 = sext i32 %254 to i64
%259 = add nsw i32 %157, -1
%260 = zext i32 %259 to i64
br label %261
261: ; preds = %257, %323
%262 = phi i64 [ 0, %257 ], [ %280, %323 ]
%263 = phi i32 [ %255, %257 ], [ %324, %323 ]
%264 = phi i32 [ %255, %257 ], [ %325, %323 ]
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %265, i32 0, i64 0
%267 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %262, i32 0, i64 0
%268 = call i32 @strcpy(i8* %266, i8* %267)
%269 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %262, i32 1
%270 = load i32, i32* %269
%271 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %265, i32 1
store i32 %270, i32* %271
%272 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %262, i32 2
%273 = load i32, i32* %272
%274 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %265, i32 2
store i32 %273, i32* %274
%275 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %262, i32 3
%276 = load i32*, i32** %275
%277 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %265, i32 3
store i32* %276, i32** %277
%278 = add i32 %264, 1
%279 = icmp slt i32 %263, %254
%280 = add nuw nsw i64 %262, 1
br i1 %279, label %281, label %323
281: ; preds = %261
%282 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %280, i32 0, i64 0
%283 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %280, i32 1
%284 = sext i32 %278 to i64
%285 = sext i32 %263 to i64
%286 = add i32 %278, %254
%287 = sub i32 %286, %263
br label %288
288: ; preds = %281, %302
%289 = phi i64 [ %285, %281 ], [ %314, %302 ]
%290 = phi i64 [ %284, %281 ], [ %315, %302 ]
%291 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %289, i32 0, i64 0
%292 = call i64 @strcmp(i8* %291, i8* %282)
%293 = icmp slt i64 %292, 0
br i1 %293, label %302, label %294
294: ; preds = %288
%295 = call i64 @strcmp(i8* %291, i8* %282)
%296 = icmp eq i64 %295, 0
br i1 %296, label %297, label %320
297: ; preds = %294
%298 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %289, i32 1
%299 = load i32, i32* %298
%300 = load i32, i32* %283
%301 = icmp slt i32 %299, %300
br i1 %301, label %302, label %317
302: ; preds = %297, %288
%303 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %290, i32 0, i64 0
%304 = call i32 @strcpy(i8* %303, i8* %291)
%305 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %289, i32 1
%306 = load i32, i32* %305
%307 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %290, i32 1
store i32 %306, i32* %307
%308 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %289, i32 2
%309 = load i32, i32* %308
%310 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %290, i32 2
store i32 %309, i32* %310
%311 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %289, i32 3
%312 = load i32*, i32** %311
%313 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %290, i32 3
store i32* %312, i32** %313
%314 = add nsw i64 %289, 1
%315 = add nsw i64 %290, 1
%316 = icmp eq i64 %314, %258
br i1 %316, label %323, label %288
317: ; preds = %297
%318 = trunc i64 %290 to i32
%319 = trunc i64 %289 to i32
br label %323
320: ; preds = %294
%321 = trunc i64 %290 to i32
%322 = trunc i64 %289 to i32
br label %323
323: ; preds = %302, %317, %320, %261
%324 = phi i32 [ %263, %261 ], [ %319, %317 ], [ %322, %320 ], [ %254, %302 ]
%325 = phi i32 [ %278, %261 ], [ %318, %317 ], [ %321, %320 ], [ %287, %302 ]
%326 = icmp eq i64 %280, %260
br i1 %326, label %327, label %261
327: ; preds = %323, %253
%328 = phi i32 [ %255, %253 ], [ %325, %323 ]
%329 = phi i32 [ %255, %253 ], [ %324, %323 ]
%330 = phi i64 [ 0, %253 ], [ %260, %323 ]
%331 = sext i32 %328 to i64
%332 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %331, i32 0, i64 0
%333 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %330, i32 0, i64 0
%334 = call i32 @strcpy(i8* %332, i8* %333)
%335 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %330, i32 1
%336 = load i32, i32* %335
%337 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %331, i32 1
store i32 %336, i32* %337
%338 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %330, i32 2
%339 = load i32, i32* %338
%340 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %331, i32 2
store i32 %339, i32* %340
%341 = getelementptr inbounds %struct.peak, %struct.peak* %124, i64 %330, i32 3
%342 = load i32*, i32** %341
%343 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %331, i32 3
store i32* %342, i32** %343
%344 = icmp slt i32 %329, %254
br i1 %344, label %345, label %366
345: ; preds = %327
%346 = sext i32 %329 to i64
br label %347
347: ; preds = %345, %347
%348 = phi i64 [ %346, %345 ], [ %363, %347 ]
%349 = phi i64 [ %331, %345 ], [ %350, %347 ]
%350 = add nsw i64 %349, 1
%351 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %350, i32 0, i64 0
%352 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %348, i32 0, i64 0
%353 = call i32 @strcpy(i8* %351, i8* %352)
%354 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %348, i32 1
%355 = load i32, i32* %354
%356 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %350, i32 1
store i32 %355, i32* %356
%357 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %348, i32 2
%358 = load i32, i32* %357
%359 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %350, i32 2
store i32 %358, i32* %359
%360 = getelementptr inbounds %struct.peak, %struct.peak* %132, i64 %348, i32 3
%361 = load i32*, i32** %360
%362 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %350, i32 3
store i32* %361, i32** %362
%363 = add nsw i64 %348, 1
%364 = trunc i64 %363 to i32
%365 = icmp eq i32 %254, %364
br i1 %365, label %366, label %347
366: ; preds = %347, %327
%367 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 0, i32 0, i64 0
%368 = call i32 @strcpy(i8* %9, i8* %367)
%369 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 0, i32 1
%370 = load i32, i32* %369
%371 = getelementptr inbounds %struct.peak, %struct.peak* %6, i64 0, i32 1
store i32 %370, i32* %371
%372 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 0, i32 2
%373 = load i32, i32* %372
%374 = getelementptr inbounds %struct.peak, %struct.peak* %6, i64 0, i32 2
store i32 %373, i32* %374
%375 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 0, i32 3
%376 = load i32*, i32** %375
%377 = getelementptr inbounds %struct.peak, %struct.peak* %6, i64 0, i32 3
store i32* %376, i32** %377
%378 = add i32 %254, %157
%379 = icmp ugt i32 %378, 1
%380 = mul i32 %12, %12
br i1 %379, label %381, label %497
381: ; preds = %366
%382 = icmp eq i32 %380, 0
%383 = zext i32 %378 to i64
%384 = zext i32 %380 to i64
%385 = and i64 %384, 1
%386 = icmp eq i32 %380, 1
%387 = and i64 %384, 4294967294
%388 = icmp eq i64 %385, 0
br label %389
389: ; preds = %381, %490
%390 = phi i64 [ 1, %381 ], [ %492, %490 ]
%391 = phi i32 [ 1, %381 ], [ %491, %490 ]
%392 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 0, i64 0
%393 = call i64 @strcmp(i8* %9, i8* %392)
%394 = icmp eq i64 %393, 0
br i1 %394, label %395, label %449
395: ; preds = %389
%396 = load i32, i32* %374
%397 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 1
%398 = load i32, i32* %397
%399 = icmp slt i32 %396, %398
br i1 %399, label %449, label %400
400: ; preds = %395
%401 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 2
%402 = load i32, i32* %401
%403 = load i32, i32* %371
%404 = icmp slt i32 %402, %403
br i1 %404, label %449, label %405
405: ; preds = %400
%406 = sext i32 %398 to i64
%407 = sext i32 %403 to i64
%408 = call i64 @min(i64 %406, i64 %407)
%409 = trunc i64 %408 to i32
store i32 %409, i32* %371
%410 = load i32, i32* %401
%411 = sext i32 %410 to i64
%412 = load i32, i32* %374
%413 = sext i32 %412 to i64
%414 = call i64 @max(i64 %411, i64 %413)
%415 = trunc i64 %414 to i32
store i32 %415, i32* %374
br i1 %382, label %490, label %416
416: ; preds = %405
%417 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 3
%418 = load i32*, i32** %417
%419 = load i32*, i32** %377
br i1 %386, label %476, label %420
420: ; preds = %416, %442
%421 = phi i64 [ %446, %442 ], [ 0, %416 ]
%422 = phi i64 [ %447, %442 ], [ 0, %416 ]
%423 = getelementptr inbounds i32, i32* %418, i64 %421
%424 = load i32, i32* %423
%425 = icmp eq i32 %424, 0
br i1 %425, label %426, label %430
426: ; preds = %420
%427 = getelementptr inbounds i32, i32* %419, i64 %421
%428 = load i32, i32* %427
%429 = icmp ne i32 %428, 0
br label %430
430: ; preds = %426, %420
%431 = phi i1 [ true, %420 ], [ %429, %426 ]
%432 = zext i1 %431 to i32
%433 = getelementptr inbounds i32, i32* %419, i64 %421
store i32 %432, i32* %433
%434 = or i64 %421, 1
%435 = getelementptr inbounds i32, i32* %418, i64 %434
%436 = load i32, i32* %435
%437 = icmp eq i32 %436, 0
br i1 %437, label %438, label %442
438: ; preds = %430
%439 = getelementptr inbounds i32, i32* %419, i64 %434
%440 = load i32, i32* %439
%441 = icmp ne i32 %440, 0
br label %442
442: ; preds = %438, %430
%443 = phi i1 [ true, %430 ], [ %441, %438 ]
%444 = zext i1 %443 to i32
%445 = getelementptr inbounds i32, i32* %419, i64 %434
store i32 %444, i32* %445
%446 = add nuw nsw i64 %421, 2
%447 = add i64 %422, 2
%448 = icmp eq i64 %447, %387
br i1 %448, label %476, label %420
449: ; preds = %400, %395, %389
%450 = call i32 @strlen(i8* %9)
%451 = icmp slt i32 %450, 7
br i1 %451, label %452, label %467
452: ; preds = %449
%453 = load i32, i32* %371
%454 = load i32, i32* %374
%455 = call i32 (i32*, i8*, ...) @fprintf(i32* %28, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %9, i32 %453, i32 %454, i32 %391)
br i1 %382, label %464, label %456
456: ; preds = %452, %456
%457 = phi i64 [ %462, %456 ], [ 0, %452 ]
%458 = load i32*, i32** %377
%459 = getelementptr inbounds i32, i32* %458, i64 %457
%460 = load i32, i32* %459
%461 = call i32 (i32*, i8*, ...) @fprintf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i32 %460)
%462 = add nuw nsw i64 %457, 1
%463 = icmp eq i64 %462, %384
br i1 %463, label %464, label %456
464: ; preds = %456, %452
%465 = call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 10, i32* %28)
%466 = add nsw i32 %391, 1
br label %467
467: ; preds = %464, %449
%468 = phi i32 [ %466, %464 ], [ %391, %449 ]
%469 = call i32 @strcpy(i8* %9, i8* %392)
%470 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 1
%471 = load i32, i32* %470
store i32 %471, i32* %371
%472 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 2
%473 = load i32, i32* %472
store i32 %473, i32* %374
%474 = getelementptr inbounds %struct.peak, %struct.peak* %141, i64 %390, i32 3
%475 = load i32*, i32** %474
store i32* %475, i32** %377
br label %490
476: ; preds = %442, %416
%477 = phi i64 [ 0, %416 ], [ %446, %442 ]
br i1 %388, label %490, label %478
478: ; preds = %476
%479 = getelementptr inbounds i32, i32* %418, i64 %477
%480 = load i32, i32* %479
%481 = icmp eq i32 %480, 0
br i1 %481, label %482, label %486
482: ; preds = %478
%483 = getelementptr inbounds i32, i32* %419, i64 %477
%484 = load i32, i32* %483
%485 = icmp ne i32 %484, 0
br label %486
486: ; preds = %482, %478
%487 = phi i1 [ true, %478 ], [ %485, %482 ]
%488 = zext i1 %487 to i32
%489 = getelementptr inbounds i32, i32* %419, i64 %477
store i32 %488, i32* %489
br label %490
490: ; preds = %486, %476, %405, %467
%491 = phi i32 [ %468, %467 ], [ %391, %405 ], [ %391, %476 ], [ %391, %486 ]
%492 = add nuw nsw i64 %390, 1
%493 = icmp eq i64 %492, %383
br i1 %493, label %494, label %389
494: ; preds = %490
%495 = load i32, i32* %371
%496 = load i32, i32* %374
br label %497
497: ; preds = %366, %494
%498 = phi i32 [ %496, %494 ], [ %373, %366 ]
%499 = phi i32 [ %495, %494 ], [ %370, %366 ]
%500 = phi i32 [ %491, %494 ], [ 1, %366 ]
%501 = call i32 (i32*, i8*, ...) @fprintf(i32* %28, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %9, i32 %499, i32 %498, i32 %500)
%502 = icmp eq i32 %380, 0
br i1 %502, label %513, label %503
503: ; preds = %497
%504 = zext i32 %380 to i64
br label %505
505: ; preds = %503, %505
%506 = phi i64 [ 0, %503 ], [ %511, %505 ]
%507 = load i32*, i32** %377
%508 = getelementptr inbounds i32, i32* %507, i64 %506
%509 = load i32, i32* %508
%510 = call i32 (i32*, i8*, ...) @fprintf(i32* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i64 0, i64 0), i32 %509)
%511 = add nuw nsw i64 %506, 1
%512 = icmp eq i64 %511, %504
br i1 %512, label %513, label %505
513: ; preds = %505, %497
%514 = call i32 bitcast (i32 (i8, i32*)* @fputc to i32 (i32, i32*)*)(i32 10, i32* %28)
br label %515
515: ; preds = %91, %71, %80, %48, %513, %46
%516 = call i32 @fclose(i32* %14)
%517 = call i32 @fclose(i32* %21)
%518 = call i32 @fclose(i32* %28)
ret void
}