#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 */
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  int quot;
};
typedef TYPE_1__ div_t;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ bubble_sort(int *, int);
TYPE_1__ div(int, int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, char *, int, int,
                           char *);
int /*<<< orphan*/ free(char *);
scalar_t__ malloc(int);
float sqrt(float);
int /*<<< orphan*/ sscanf(char *, char *, char *, ...);
int /*<<< orphan*/ strncmp(char *, char *, int);
main() {
  int i = 0, j = 0, k = 0, l = 0, m = 0, n = 0, q = 0, p = 0, flag = 0,
      end_atom = 0, line_length = 1000, res_atom_number = 0,
      lig_atom_number = 0, all_active[200000], active[200000],
      res_atoms[200000], res_pointers[200000], pointers[200000],
      all_sphere[200000];
  float radius = 0, dist = 0, res_coordx, res_coordy, res_coordz, lig_coordx,
        lig_coordy, lig_coordz, res_numb1, res_numb2, res_numb3, res_numb4,
        lig_numb1, lig_numb2, lig_numb3, lig_numb4;
  char res_buf[line_length], lig_buf[line_length], param_buf[line_length],
      res_word[15], lig_word[15], param_word[15], *res_name[200000],
      *lig_name[200000];
  for (j = 0; j < 200000; j++) {
    res_name[j] = (char *)malloc(15);
    lig_name[j] = (char *)malloc(15);
  }
  FILE *protein, *ligand, *numb_act, *param, *fopen();
  ligand = fopen("input_ligand.ammp", "r");
  numb_act = fopen("active.ammp", "w");
  param = fopen("param.temp", "r");
  for (i = 0; i < 5; i++)
    fgets(param_buf, line_length, param);
  sscanf(param_buf, "%s %f", param_word, &radius);
  for (i = 0; i < 200; i++) {
    flag++;
    protein = fopen("protein.ammp", "r");
    fgets(lig_buf, line_length, ligand);
    sscanf(lig_buf, "%s", lig_word);
    if (!strncmp(lig_word, "bond", 4))
      break;
    if (!strncmp(lig_word, "mompar", 6)) {
      fgets(lig_buf, line_length, ligand);
      sscanf(lig_buf, "%s", lig_word);
    }
    if (!strncmp(lig_word, "atom", 4)) {
      sscanf(lig_buf, "%s %f %f %f %i %s %f %f %f %f", lig_word, &lig_coordx,
             &lig_coordy, &lig_coordz, &lig_atom_number, lig_name[k],
             &lig_numb1, &lig_numb2, &lig_numb3, &lig_numb4);
      q++;
    }
    for (j = 0; j < 200000; j++) {
      fgets(res_buf, line_length, protein);
      sscanf(res_buf, "%s", res_word);
      if (!strncmp(res_word, "bond", 4)) {
        if (flag == 1) {
          end_atom = p;
          break;
        } else
          break;
      }
      if (!strncmp(res_word, "mompar", 6)) {
        fgets(res_buf, line_length, protein);
        sscanf(res_buf, "%s", res_word);
      }
      if (!strncmp(res_word, "atom", 4)) {
        sscanf(res_buf, "%s %f %f %f %i %s %f %f %f %f", res_word, &res_coordx,
               &res_coordy, &res_coordz, &res_atom_number, res_name[i],
               &res_numb1, &res_numb2, &res_numb3, &res_numb4);
        res_atoms[p] = res_atom_number;
        p++;
        dist = sqrt((res_coordx - lig_coordx) * (res_coordx - lig_coordx) +
                    (res_coordy - lig_coordy) * (res_coordy - lig_coordy) +
                    (res_coordz - lig_coordz) * (res_coordz - lig_coordz));
        if (dist < radius) {
          all_active[n] = res_atom_number;
          n++;
        } else
          continue;
      }
      continue;
    }
  }
  k = 0;
  for (i = 0; i < n;) {
    j = 0;
    while (all_active[i] != active[j] && j <= k)
      j++;
    if (j < k) {
      i++;
      continue;
    }
    active[k] = all_active[i];
    k++;
  }
  for (i = 0; i < k; i++) {
    div_t point;
    point = div(active[i], 100);
    res_pointers[i] = point.quot;
  }
  k = 0;
  for (i = 0; i < n;) {
    j = 0;
    while (res_pointers[i] != pointers[j] && j <= k)
      j++;
    if (j < k) {
      i++;
      continue;
    }
    pointers[k] = res_pointers[i];
    k++;
  }
  l = k - 1;
  bubble_sort(pointers, l);
  m = 0;
  for (i = 0; i < l; i++) {
    for (j = 0; j < end_atom; j++) {
      div_t numb;
      numb = div(res_atoms[j], 100);
      if (pointers[i] == numb.quot) {
        all_sphere[m] = res_atoms[j];
        m++;
      } else {
        continue;
      }
    }
  }
  for (j = 0; j < q; j++)
    fprintf(numb_act, "%s %i %i%s\n", "active", 1000000 + j, 1000000 + j, ";");
  for (i = 0; i < m; i++)
    fprintf(numb_act, "%s %i %i%s\n", "active", all_sphere[i], all_sphere[i],
            ";");
  for (i = 0; i < 200000; ++i) {
    free(res_name[i]);
    free(lig_name[i]);
  }
  fclose(protein);
  fclose(ligand);
  fclose(numb_act);
  fclose(param);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x7a1328,%rsp
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x3e8,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x493e54(%rbp)
movl   $0x0,-0x493e58(%rbp)
mov    -0x48(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x493e98(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x7a1338(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x493ea0(%rbp)
mov    -0x48(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x7a1330(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x493ea8(%rbp)
mov    -0x48(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x7a1328(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x493eb0(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x30d40,-0x24(%rbp)
jge    1303 <main+0x153>
mov    $0xf,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
mov    %rcx,-0x61a8e0(%rbp,%rax,8)
ff
mov    $0xf,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
mov    %rcx,-0x7a12e0(%rbp,%rax,8)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b6 <main+0x106>
lea    0xcf6(%rip),%rdi
lea    0xd3a(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x7a12f0(%rbp)
lea    0xcee(%rip),%rdi
lea    0xcf3(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x7a12f8(%rbp)
lea    0xce2(%rip),%rdi
lea    0xd06(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x7a1300(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x5,-0x20(%rbp)
jge    1386 <main+0x1d6>
mov    -0x7a1328(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x7a1300(%rbp),%rdx
call   1060 <fgets@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1358 <main+0x1a8>
mov    -0x7a1328(%rbp),%rdi
lea    -0x493edd(%rbp),%rdx
lea    0xc90(%rip),%rsi
lea    -0x493e54(%rbp),%rcx
mov    $0x0,%al
call   10a0 <sscanf@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0xc8,-0x20(%rbp)
jge    17ab <main+0x5fb>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
lea    0xc64(%rip),%rdi
lea    0xc77(%rip),%rsi
call   10b0 <fopen@plt>
mov    -0x7a1330(%rbp),%rdi
mov    %rax,-0x7a12e8(%rbp)
mov    -0x48(%rbp),%esi
mov    -0x7a12f0(%rbp),%rdx
call   1060 <fgets@plt>
mov    -0x7a1330(%rbp),%rdi
lea    -0x493ece(%rbp),%rdx
lea    0xc33(%rip),%rsi
mov    $0x0,%al
call   10a0 <sscanf@plt>
lea    -0x493ece(%rbp),%rdi
lea    0xc21(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1438 <main+0x288>
jmp    17ab <main+0x5fb>
lea    -0x493ece(%rbp),%rdi
lea    0xc00(%rip),%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    148b <main+0x2db>
mov    -0x7a1330(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x7a12f0(%rbp),%rdx
call   1060 <fgets@plt>
mov    -0x7a1330(%rbp),%rdi
lea    -0x493ece(%rbp),%rdx
lea    0xbba(%rip),%rsi
mov    $0x0,%al
call   10a0 <sscanf@plt>
lea    -0x493ece(%rbp),%rdi
lea    0xbb4(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1537 <main+0x387>
mov    -0x7a1330(%rbp),%rdi
lea    -0x493ece(%rbp),%rdx
movslq -0x28(%rbp),%rax
mov    -0x7a12e0(%rbp,%rax,8),%r14
ff
lea    0xb85(%rip),%rsi
lea    -0x493e68(%rbp),%rcx
lea    -0x493e6c(%rbp),%r8
lea    -0x493e70(%rbp),%r9
lea    -0x50(%rbp),%r15
lea    -0x493e84(%rbp),%rbx
lea    -0x493e88(%rbp),%r11
lea    -0x493e8c(%rbp),%r10
lea    -0x493e90(%rbp),%rax
sub    $0x30,%rsp
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
add    $0x30,%rsp
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x30d40,-0x24(%rbp)
jge    1798 <main+0x5e8>
mov    -0x7a1338(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x7a12e8(%rbp),%rdx
call   1060 <fgets@plt>
mov    -0x7a1338(%rbp),%rdi
lea    -0x493ebf(%rbp),%rdx
lea    0xac8(%rip),%rsi
mov    $0x0,%al
call   10a0 <sscanf@plt>
lea    -0x493ebf(%rbp),%rdi
lea    0xab6(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    15b8 <main+0x408>
cmpl   $0x1,-0x40(%rbp)
jne    15b3 <main+0x403>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1798 <main+0x5e8>
jmp    1798 <main+0x5e8>
lea    -0x493ebf(%rbp),%rdi
lea    0xa80(%rip),%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    160b <main+0x45b>
mov    -0x7a1338(%rbp),%rdi
mov    -0x48(%rbp),%esi
mov    -0x7a12e8(%rbp),%rdx
call   1060 <fgets@plt>
mov    -0x7a1338(%rbp),%rdi
lea    -0x493ebf(%rbp),%rdx
lea    0xa3a(%rip),%rsi
mov    $0x0,%al
call   10a0 <sscanf@plt>
lea    -0x493ebf(%rbp),%rdi
lea    0xa34(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1785 <main+0x5d5>
mov    -0x7a1338(%rbp),%rdi
lea    -0x493ebf(%rbp),%rdx
movslq -0x20(%rbp),%rax
mov    -0x61a8e0(%rbp,%rax,8),%r14
ff
lea    0xa05(%rip),%rsi
lea    -0x493e5c(%rbp),%rcx
lea    -0x493e60(%rbp),%r8
lea    -0x493e64(%rbp),%r9
lea    -0x4c(%rbp),%r15
lea    -0x493e74(%rbp),%rbx
lea    -0x493e78(%rbp),%r11
lea    -0x493e7c(%rbp),%r10
lea    -0x493e80(%rbp),%rax
sub    $0x30,%rsp
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
add    $0x30,%rsp
mov    -0x4c(%rbp),%ecx
movslq -0x3c(%rbp),%rax
mov    %ecx,-0x249f50(%rbp,%rax,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movss  -0x493e5c(%rbp),%xmm1
ff
subss  -0x493e68(%rbp),%xmm1
ff
movss  -0x493e5c(%rbp),%xmm2
ff
subss  -0x493e68(%rbp),%xmm2
ff
movss  -0x493e60(%rbp),%xmm0
ff
subss  -0x493e6c(%rbp),%xmm0
ff
movss  -0x493e60(%rbp),%xmm3
ff
subss  -0x493e6c(%rbp),%xmm3
ff
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x493e64(%rbp),%xmm0
ff
subss  -0x493e70(%rbp),%xmm0
ff
movss  -0x493e64(%rbp),%xmm2
ff
subss  -0x493e70(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10c0 <sqrt@plt>
movss  %xmm0,-0x493e58(%rbp)
ff
movss  -0x493e58(%rbp),%xmm1
ff
movss  -0x493e54(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    177b <main+0x5cb>
mov    -0x4c(%rbp),%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0xc3550(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1780 <main+0x5d0>
jmp    178a <main+0x5da>
jmp    1785 <main+0x5d5>
jmp    178a <main+0x5da>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    153e <main+0x38e>
jmp    179d <main+0x5ed>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13b0 <main+0x200>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    185e <main+0x6ae>
movl   $0x0,-0x24(%rbp)
movslq -0x20(%rbp),%rax
mov    -0xc3550(%rbp,%rax,4),%ecx
movslq -0x24(%rbp),%rdx
xor    %eax,%eax
cmp    -0x186a50(%rbp,%rdx,4),%ecx
mov    %al,-0x7a1339(%rbp)
je     17ff <main+0x64f>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
setle  %al
mov    %al,-0x7a1339(%rbp)
mov    -0x7a1339(%rbp),%al
test   $0x1,%al
jne    1812 <main+0x662>
jmp    1820 <main+0x670>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    17cc <main+0x61c>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    183a <main+0x68a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    17b9 <main+0x609>
movslq -0x20(%rbp),%rax
mov    -0xc3550(%rbp,%rax,4),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x186a50(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17b9 <main+0x609>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    18b7 <main+0x707>
movslq -0x20(%rbp),%rax
mov    -0x186a50(%rbp,%rax,4),%edi
mov    $0x64,%esi
call   1080 <div@plt>
mov    %eax,-0x7a1310(%rbp)
mov    -0x7a1310(%rbp),%eax
mov    %eax,-0x7a1308(%rbp)
mov    -0x7a1308(%rbp),%ecx
movslq -0x20(%rbp),%rax
mov    %ecx,-0x30d450(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1865 <main+0x6b5>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    196a <main+0x7ba>
movl   $0x0,-0x24(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x30d450(%rbp,%rax,4),%ecx
movslq -0x24(%rbp),%rdx
xor    %eax,%eax
cmp    -0x3d0950(%rbp,%rdx,4),%ecx
mov    %al,-0x7a133a(%rbp)
je     190b <main+0x75b>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
setle  %al
mov    %al,-0x7a133a(%rbp)
mov    -0x7a133a(%rbp),%al
test   $0x1,%al
jne    191e <main+0x76e>
jmp    192c <main+0x77c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18d8 <main+0x728>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1946 <main+0x796>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    18c5 <main+0x715>
movslq -0x20(%rbp),%rax
mov    -0x30d450(%rbp,%rax,4),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x3d0950(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18c5 <main+0x715>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
lea    -0x3d0950(%rbp),%rdi
mov    -0x2c(%rbp),%esi
call   10d0 <bubble_sort@plt>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a3c <main+0x88c>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1a29 <main+0x879>
movslq -0x24(%rbp),%rax
mov    -0x249f50(%rbp,%rax,4),%edi
mov    $0x64,%esi
call   1080 <div@plt>
mov    %eax,-0x7a1320(%rbp)
mov    -0x7a1320(%rbp),%eax
mov    %eax,-0x7a1318(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x3d0950(%rbp,%rax,4),%eax
cmp    -0x7a1318(%rbp),%eax
jne    1a11 <main+0x861>
movslq -0x24(%rbp),%rax
mov    -0x249f50(%rbp,%rax,4),%ecx
movslq -0x30(%rbp),%rax
mov    %ecx,-0x493e50(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1a16 <main+0x866>
jmp    1a1b <main+0x86b>
jmp    1a1b <main+0x86b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    19a3 <main+0x7f3>
jmp    1a2e <main+0x87e>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1990 <main+0x7e0>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1a92 <main+0x8e2>
mov    -0x7a12f8(%rbp),%rdi
mov    -0x24(%rbp),%ecx
add    $0xf4240,%ecx
mov    -0x24(%rbp),%r8d
add    $0xf4240,%r8d
lea    0x5ff(%rip),%rsi
lea    0x604(%rip),%rdx
lea    0x604(%rip),%r9
call   1070 <fprintf@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1a43 <main+0x893>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1aeb <main+0x93b>
mov    -0x7a12f8(%rbp),%rdi
movslq -0x20(%rbp),%rax
mov    -0x493e50(%rbp,%rax,4),%ecx
movslq -0x20(%rbp),%rax
mov    -0x493e50(%rbp,%rax,4),%r8d
ff
lea    0x5a6(%rip),%rsi
lea    0x5ab(%rip),%rdx
lea    0x5ab(%rip),%r9
call   1070 <fprintf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1a99 <main+0x8e9>
movl   $0x0,-0x20(%rbp)
cmpl   $0x30d40,-0x20(%rbp)
jge    1b2f <main+0x97f>
movslq -0x20(%rbp),%rax
mov    -0x61a8e0(%rbp,%rax,8),%rdi
ff
call   1030 <free@plt>
movslq -0x20(%rbp),%rax
mov    -0x7a12e0(%rbp,%rax,8),%rdi
ff
call   1030 <free@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1af2 <main+0x942>
mov    -0x7a12e8(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x7a12f0(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x7a12f8(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x7a1300(%rbp),%rdi
call   1050 <fclose@plt>
mov    -0x493e98(%rbp),%rax
mov    %rax,%rsp
mov    -0x1c(%rbp),%eax
lea    -0x18(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7a1ea8,%rsp
mov    %rsp,0x78(%rsp)
movl   $0x0,0x14(%rsp)
movl   $0x0,0x64(%rsp)
movl   $0x0,0x2c(%rsp)
xor    %ebx,%ebx
mov    $0xf,%edi
call   1090 <malloc@plt>
mov    %rax,0x1876a0(%rsp,%rbx,8)
mov    $0xf,%edi
call   1090 <malloc@plt>
mov    %rax,0x61b4a0(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0x30d40,%rbx
jne    11e0 <main+0x30>
lea    0xdec(%rip),%rdi
lea    0xe30(%rip),%rbx
mov    %rbx,%rsi
call   10b0 <fopen@plt>
mov    %rax,0x38(%rsp)
lea    0xde3(%rip),%rdi
lea    0xde8(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,%rbp
lea    0xddb(%rip),%rdi
mov    %rbx,%rsi
call   10b0 <fopen@plt>
mov    %rax,%rbx
lea    0x4c0(%rsp),%r14
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %rax,%rdx
call   1060 <fgets@plt>
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %rbx,%rdx
call   1060 <fgets@plt>
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %rbx,%rdx
call   1060 <fgets@plt>
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %rbx,%rdx
call   1060 <fgets@plt>
mov    %r14,%rdi
mov    $0x3e8,%esi
mov    %rbx,0x70(%rsp)
mov    %rbx,%rdx
call   1060 <fgets@plt>
lea    0xd77(%rip),%rsi
lea    0xa3(%rsp),%rdx
lea    0x2c(%rsp),%rcx
mov    %r14,%rdi
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    0x61b4a0(%rsp),%rax
mov    %rax,0x68(%rsp)
lea    0xd5f(%rip),%r12
lea    0x8b0(%rsp),%r15
lea    0xc1(%rsp),%r13
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
xor    %ebx,%ebx
movl   $0x0,0x4(%rsp)
mov    %rbp,0x8(%rsp)
jmp    134f <main+0x19f>
nopl   0x0(%rax)
cmpl   $0x0,0x18(%rsp)
mov    0x4(%rsp),%eax
cmove  %ebx,%eax
mov    %eax,0x4(%rsp)
mov    0x20(%rsp),%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    $0xc8,%rcx
mov    0x8(%rsp),%rbp
je     1642 <main+0x492>
mov    %ebx,0x28(%rsp)
lea    0xcdb(%rip),%rdi
lea    0xcee(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,0x20(%rsp)
mov    %r12,%r14
lea    0xd0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x3e8,%esi
mov    0x38(%rsp),%rdx
call   1060 <fgets@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
lea    0xb2(%rsp),%rbp
mov    %rbp,%rdx
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    %rbp,%rdi
lea    0xc9b(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1638 <main+0x488>
mov    %rbp,%rdi
lea    0xc84(%rip),%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
jne    1401 <main+0x251>
lea    0xd0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x3e8,%esi
mov    0x38(%rsp),%rdx
call   1060 <fgets@plt>
mov    %rbx,%rdi
mov    %r14,%r12
mov    %r14,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    %rbp,%rdi
lea    0xc46(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
mov    0x30(%rsp),%rbx
jne    1486 <main+0x2d6>
lea    0xd0(%rsp),%rdi
lea    0xc29(%rip),%rsi
mov    %rbp,%rdx
lea    0x54(%rsp),%rcx
lea    0x50(%rsp),%r8
lea    0x4c(%rsp),%r9
xor    %eax,%eax
lea    0x80(%rsp),%rbp
push   %rbp
lea    0x8c(%rsp),%rbp
push   %rbp
lea    0x98(%rsp),%rbp
push   %rbp
lea    0xa4(%rsp),%rbp
push   %rbp
push   0x88(%rsp)
lea    0x8c(%rsp),%rbp
push   %rbp
call   10a0 <sscanf@plt>
add    $0x30,%rsp
add    $0x1,%ebx
mov    %rbx,0x30(%rsp)
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%ebx
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x20(%rsp)
mov    $0x30d40,%ebp
jmp    14b9 <main+0x309>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffff,%ebp
je     1330 <main+0x180>
mov    %r15,%rdi
mov    $0x3e8,%esi
mov    %r14,%rdx
call   1060 <fgets@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    %r13,%rdi
lea    0xb62(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1320 <main+0x170>
mov    %r13,%rdi
lea    0xb4b(%rip),%rsi
mov    $0x6,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
jne    152d <main+0x37d>
mov    %r15,%rdi
mov    $0x3e8,%esi
mov    %r14,%rdx
call   1060 <fgets@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    %r13,%rdi
lea    0xb1a(%rip),%rsi
mov    $0x4,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
jne    14b0 <main+0x300>
mov    %r15,%rdi
lea    0xb03(%rip),%rsi
mov    %r13,%rdx
lea    0x60(%rsp),%rcx
lea    0x5c(%rsp),%r8
lea    0x58(%rsp),%r9
xor    %eax,%eax
mov    %ebx,%r10d
lea    0x90(%rsp),%rbx
push   %rbx
lea    0x9c(%rsp),%rbx
push   %rbx
lea    0xa8(%rsp),%rbx
push   %rbx
lea    0xb4(%rsp),%rbx
push   %rbx
mov    0x38(%rsp),%rbx
push   0x1876c0(%rsp,%rbx,8)
lea    0x3c(%rsp),%rbx
push   %rbx
mov    %r10d,%ebx
call   10a0 <sscanf@plt>
add    $0x30,%rsp
mov    0x14(%rsp),%eax
movslq %ebx,%rcx
mov    %eax,0x494aa0(%rsp,%rcx,4)
movss  0x60(%rsp),%xmm1
subss  0x54(%rsp),%xmm1
movss  0x5c(%rsp),%xmm0
subss  0x50(%rsp),%xmm0
mulss  %xmm0,%xmm0
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  0x58(%rsp),%xmm0
subss  0x4c(%rsp),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
ucomiss 0xa07(%rip),%xmm0
jb     1601 <main+0x451>
sqrtss %xmm0,%xmm0
jmp    1606 <main+0x456>
call   10c0 <sqrt@plt>
add    $0x1,%ebx
movss  0x2c(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jbe    14b0 <main+0x300>
mov    0x14(%rsp),%eax
mov    0x40(%rsp),%rcx
movslq %ecx,%rcx
mov    %eax,0x557fa0(%rsp,%rcx,4)
add    $0x1,%ecx
mov    %rcx,0x40(%rsp)
jmp    14b0 <main+0x300>
mov    0x20(%rsp),%r14
mov    0x8(%rsp),%rbp
mov    %r14,%r12
mov    0x40(%rsp),%r15
test   %r15d,%r15d
jle    174c <main+0x59c>
mov    %r15d,%r14d
xor    %eax,%eax
xor    %ecx,%ecx
movslq %ecx,%rcx
nopl   (%rax)
mov    0x557fa0(%rsp,%rcx,4),%edx
xor    %edi,%edi
nopl   0x0(%rax)
lea    0x1(%rdi),%rsi
cmp    0xc41a0(%rsp,%rdi,4),%edx
je     1685 <main+0x4d5>
cmp    %rax,%rdi
mov    %rsi,%rdi
jbe    1670 <main+0x4c0>
add    $0xffffffff,%esi
cmp    %rax,%rsi
jae    16a0 <main+0x4f0>
add    $0x1,%rcx
cmp    %r14,%rcx
jl     1660 <main+0x4b0>
jmp    16b0 <main+0x500>
nopl   0x0(%rax,%rax,1)
mov    %edx,0xc41a0(%rsp,%rax,4)
add    $0x1,%rax
cmp    %ecx,%r15d
jg     165a <main+0x4aa>
test   %eax,%eax
jle    16e1 <main+0x531>
mov    %eax,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0xc41a0(%rsp,%rbx,4),%edi
mov    $0x64,%esi
call   1080 <div@plt>
mov    %eax,0x3d15a0(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    16c0 <main+0x510>
test   %r15d,%r15d
mov    0x8(%rsp),%rbp
jle    174c <main+0x59c>
xor    %ebp,%ebp
xor    %eax,%eax
cltq
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x3d15a0(%rsp,%rax,4),%ecx
xor    %esi,%esi
nopl   0x0(%rax)
lea    0x1(%rsi),%rdx
cmp    0xca0(%rsp,%rsi,4),%ecx
je     1725 <main+0x575>
cmp    %rbp,%rsi
mov    %rdx,%rsi
jbe    1710 <main+0x560>
add    $0xffffffff,%edx
cmp    %rbp,%rdx
jae    1738 <main+0x588>
add    $0x1,%rax
cmp    %r14,%rax
jl     1700 <main+0x550>
jmp    1765 <main+0x5b5>
mov    %ecx,0xca0(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    %eax,%r15d
jle    1765 <main+0x5b5>
cltq
jmp    1700 <main+0x550>
lea    0xca0(%rsp),%rdi
mov    $0xffffffff,%esi
call   10d0 <bubble_sort@plt>
xor    %ebx,%ebx
jmp    17fb <main+0x64b>
lea    -0x1(%rbp),%r14d
lea    0xca0(%rsp),%rdi
mov    %r14d,%esi
call   10d0 <bubble_sort@plt>
xor    %ebx,%ebx
cmp    $0x2,%ebp
mov    0x8(%rsp),%rbp
jl     17fb <main+0x64b>
mov    %r14d,%eax
mov    %rax,0x18(%rsp)
mov    0x4(%rsp),%r15d
xor    %r13d,%r13d
xor    %ebx,%ebx
jmp    17ab <main+0x5fb>
nopl   0x0(%rax)
add    $0x1,%r13
cmp    0x18(%rsp),%r13
je     17fb <main+0x64b>
cmpl   $0x0,0x4(%rsp)
jle    17a0 <main+0x5f0>
xor    %r14d,%r14d
jmp    17ce <main+0x61e>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rbp
add    $0x1,%r14
cmp    %r14,%r15
je     17a0 <main+0x5f0>
mov    0x494aa0(%rsp,%r14,4),%ebp
mov    %ebp,%edi
mov    $0x64,%esi
call   1080 <div@plt>
cmp    %eax,0xca0(%rsp,%r13,4)
jne    17c0 <main+0x610>
movslq %ebx,%rbx
mov    %ebp,0x30e0a0(%rsp,%rbx,4)
add    $0x1,%ebx
jmp    17c0 <main+0x610>
mov    0x30(%rsp),%r15
test   %r15d,%r15d
mov    %rbp,%r14
jle    1853 <main+0x6a3>
neg    %r15d
mov    $0xf4240,%ebp
lea    0x870(%rip),%r13
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
lea    0x84a(%rip),%rsi
lea    0x84f(%rip),%rdx
mov    %ebp,%ecx
mov    %ebp,%r8d
mov    %r13,%r9
call   1070 <fprintf@plt>
lea    (%r15,%rbp,1),%eax
add    $0x1,%eax
mov    %ebp,%ecx
add    $0x1,%ecx
mov    %ecx,%ebp
cmp    $0xf4240,%eax
jne    1820 <main+0x670>
test   %ebx,%ebx
jle    1898 <main+0x6e8>
mov    %ebx,%ebx
xor    %ebp,%ebp
lea    0x81e(%rip),%r15
lea    0x81e(%rip),%r13
nopl   0x0(%rax)
mov    0x30e0a0(%rsp,%rbp,4),%ecx
mov    %r14,%rdi
lea    0x7f3(%rip),%rsi
mov    %r15,%rdx
mov    %ecx,%r8d
mov    %r13,%r9
call   1070 <fprintf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1870 <main+0x6c0>
mov    0x1876a0(%rsp),%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x61b4a0(%rsp,%rbx,8),%rbp
mov    0x1876a0(%rsp,%rbx,8),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    $0x30d40,%rbx
jne    18c0 <main+0x710>
mov    %r12,%rdi
call   1050 <fclose@plt>
mov    0x38(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x8(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x70(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x78(%rsp),%rsp
xor    %eax,%eax
add    $0x7a1ea8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [18 x i8] c"input_ligand.ammp\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [12 x i8] c"active.ammp\00"
@.str.3 = [2 x i8] c"w\00"
@.str.4 = [11 x i8] c"param.temp\00"
@.str.5 = [6 x i8] c"%s %f\00"
@.str.6 = [13 x i8] c"protein.ammp\00"
@.str.7 = [3 x i8] c"%s\00"
@.str.8 = [5 x i8] c"bond\00"
@.str.9 = [7 x i8] c"mompar\00"
@.str.10 = [5 x i8] c"atom\00"
@.str.11 = [30 x i8] c"%s %f %f %f %i %s %f %f %f %f\00"
@.str.12 = [12 x i8] c"%s %i %i%s\0A\00"
@.str.13 = [7 x i8] c"active\00"
@.str.14 = [2 x i8] c";\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [200000 x i32]
%4 = alloca [200000 x i32]
%5 = alloca [200000 x i32]
%6 = alloca [200000 x i32]
%7 = alloca [200000 x i32]
%8 = alloca [200000 x i32]
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca [15 x i8]
%25 = alloca [15 x i8]
%26 = alloca [15 x i8]
%27 = alloca [200000 x i8*]
%28 = alloca [200000 x i8*]
%29 = bitcast i32* %1 to i8*
store i32 0, i32* %1
%30 = bitcast i32* %2 to i8*
store i32 0, i32* %2
%31 = bitcast [200000 x i32]* %3 to i8*
%32 = bitcast [200000 x i32]* %4 to i8*
%33 = bitcast [200000 x i32]* %5 to i8*
%34 = bitcast [200000 x i32]* %6 to i8*
%35 = bitcast [200000 x i32]* %7 to i8*
%36 = bitcast [200000 x i32]* %8 to i8*
%37 = bitcast float* %9 to i8*
store float 0.000000e+00, float* %9
%38 = bitcast float* %10 to i8*
%39 = bitcast float* %11 to i8*
%40 = bitcast float* %12 to i8*
%41 = bitcast float* %13 to i8*
%42 = bitcast float* %14 to i8*
%43 = bitcast float* %15 to i8*
%44 = bitcast float* %16 to i8*
%45 = bitcast float* %17 to i8*
%46 = bitcast float* %18 to i8*
%47 = bitcast float* %19 to i8*
%48 = bitcast float* %20 to i8*
%49 = bitcast float* %21 to i8*
%50 = bitcast float* %22 to i8*
%51 = bitcast float* %23 to i8*
%52 = tail call i8* @llvm.stacksave()
%53 = alloca [1000 x i8]
%54 = alloca [1000 x i8]
%55 = alloca [1000 x i8]
%56 = getelementptr inbounds [1000 x i8], [1000 x i8]* %54, i64 0, i64 0
%57 = getelementptr inbounds [15 x i8], [15 x i8]* %24, i64 0, i64 0
%58 = getelementptr inbounds [15 x i8], [15 x i8]* %25, i64 0, i64 0
%59 = getelementptr inbounds [15 x i8], [15 x i8]* %26, i64 0, i64 0
%60 = bitcast [200000 x i8*]* %27 to i8*
%61 = bitcast [200000 x i8*]* %28 to i8*
br label %62
62: ; preds = %0, %62
%63 = phi i64 [ 0, %0 ], [ %70, %62 ]
%64 = tail call i64 @malloc(i32 15)
%65 = inttoptr i64 %64 to i8*
%66 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %27, i64 0, i64 %63
store i8* %65, i8** %66
%67 = tail call i64 @malloc(i32 15)
%68 = inttoptr i64 %67 to i8*
%69 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %28, i64 0, i64 %63
store i8* %68, i8** %69
%70 = add nuw nsw i64 %63, 1
%71 = icmp eq i64 %70, 200000
br i1 %71, label %72, label %62
72: ; preds = %62
%73 = getelementptr inbounds [1000 x i8], [1000 x i8]* %55, i64 0, i64 0
%74 = tail call i32* @fopen(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%75 = tail call i32* @fopen(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%76 = tail call i32* @fopen(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%77 = call i32 @fgets(i8* %73, i32 1000, i32* %76)
%78 = call i32 @fgets(i8* %73, i32 1000, i32* %76)
%79 = call i32 @fgets(i8* %73, i32 1000, i32* %76)
%80 = call i32 @fgets(i8* %73, i32 1000, i32* %76)
%81 = call i32 @fgets(i8* %73, i32 1000, i32* %76)
%82 = getelementptr inbounds [1000 x i8], [1000 x i8]* %53, i64 0, i64 0
%83 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %73, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), i8* %59, float* %9)
%84 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %28, i64 0, i64 0
%85 = load i8*, i8** %84
br label %86
86: ; preds = %72, %166
%87 = phi i64 [ 0, %72 ], [ %93, %166 ]
%88 = phi i32 [ 0, %72 ], [ %168, %166 ]
%89 = phi i32 [ 0, %72 ], [ %112, %166 ]
%90 = phi i32 [ 0, %72 ], [ %167, %166 ]
%91 = phi i32 [ 0, %72 ], [ %169, %166 ]
%92 = trunc i64 %87 to i32
%93 = add nuw nsw i64 %87, 1
%94 = call i32* @fopen(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%95 = call i32 @fgets(i8* %56, i32 1000, i32* %74)
%96 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i8* %58)
%97 = call i32 @strncmp(i8* %58, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0), i32 4)
%98 = icmp eq i32 %97, 0
br i1 %98, label %171, label %99
99: ; preds = %86
%100 = call i32 @strncmp(i8* %58, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i32 6)
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %105
102: ; preds = %99
%103 = call i32 @fgets(i8* %56, i32 1000, i32* %74)
%104 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %56, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i8* %58)
br label %105
105: ; preds = %102, %99
%106 = call i32 @strncmp(i8* %58, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i32 4)
%107 = icmp eq i32 %106, 0
br i1 %107, label %108, label %111
108: ; preds = %105
%109 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %56, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0), i8* %58, float* %13, float* %14, float* %15, i32* %2, i8* %85, float* %20, float* %21, float* %22, float* %23)
%110 = add nsw i32 %89, 1
br label %111
111: ; preds = %108, %105
%112 = phi i32 [ %89, %105 ], [ %110, %108 ]
%113 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %27, i64 0, i64 %87
br label %114
114: ; preds = %111, %161
%115 = phi i32 [ 0, %111 ], [ %164, %161 ]
%116 = phi i32 [ %88, %111 ], [ %163, %161 ]
%117 = phi i32 [ %90, %111 ], [ %162, %161 ]
%118 = call i32 @fgets(i8* %82, i32 1000, i32* %94)
%119 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %82, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i8* %57)
%120 = call i32 @strncmp(i8* %57, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.8, i64 0, i64 0), i32 4)
%121 = icmp eq i32 %120, 0
br i1 %121, label %122, label %125
122: ; preds = %114
%123 = icmp eq i32 %92, 0
%124 = select i1 %123, i32 %117, i32 %91
br label %166
125: ; preds = %114
%126 = call i32 @strncmp(i8* %57, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0), i32 6)
%127 = icmp eq i32 %126, 0
br i1 %127, label %128, label %131
128: ; preds = %125
%129 = call i32 @fgets(i8* %82, i32 1000, i32* %94)
%130 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %82, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.7, i64 0, i64 0), i8* %57)
br label %131
131: ; preds = %128, %125
%132 = call i32 @strncmp(i8* %57, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i32 4)
%133 = icmp eq i32 %132, 0
br i1 %133, label %134, label %161
134: ; preds = %131
%135 = load i8*, i8** %113
%136 = call i32 (i8*, i8*, i8*, ...) @sscanf(i8* %82, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.11, i64 0, i64 0), i8* %57, float* %10, float* %11, float* %12, i32* %1, i8* %135, float* %16, float* %17, float* %18, float* %19)
%137 = load i32, i32* %1
%138 = sext i32 %117 to i64
%139 = getelementptr inbounds [200000 x i32], [200000 x i32]* %5, i64 0, i64 %138
store i32 %137, i32* %139
%140 = add nsw i32 %117, 1
%141 = load float, float* %10
%142 = load float, float* %13
%143 = fsub float %141, %142
%144 = load float, float* %11
%145 = load float, float* %14
%146 = fsub float %144, %145
%147 = fmul float %146, %146
%148 = call float @llvm.fmuladd.f32(float %143, float %143, float %147)
%149 = load float, float* %12
%150 = load float, float* %15
%151 = fsub float %149, %150
%152 = call float @llvm.fmuladd.f32(float %151, float %151, float %148)
%153 = call float @sqrt(float %152)
%154 = load float, float* %9
%155 = fcmp olt float %153, %154
br i1 %155, label %156, label %161
156: ; preds = %134
%157 = load i32, i32* %1
%158 = sext i32 %116 to i64
%159 = getelementptr inbounds [200000 x i32], [200000 x i32]* %3, i64 0, i64 %158
store i32 %157, i32* %159
%160 = add nsw i32 %116, 1
br label %161
161: ; preds = %131, %156, %134
%162 = phi i32 [ %117, %131 ], [ %140, %156 ], [ %140, %134 ]
%163 = phi i32 [ %116, %131 ], [ %160, %156 ], [ %116, %134 ]
%164 = add nuw nsw i32 %115, 1
%165 = icmp eq i32 %164, 200000
br i1 %165, label %166, label %114
166: ; preds = %161, %122
%167 = phi i32 [ %117, %122 ], [ %162, %161 ]
%168 = phi i32 [ %116, %122 ], [ %163, %161 ]
%169 = phi i32 [ %124, %122 ], [ %91, %161 ]
%170 = icmp eq i64 %93, 200
br i1 %170, label %171, label %86
171: ; preds = %86, %166
%172 = phi i32 [ %91, %86 ], [ %169, %166 ]
%173 = phi i32 [ %89, %86 ], [ %112, %166 ]
%174 = phi i32 [ %88, %86 ], [ %168, %166 ]
%175 = icmp sgt i32 %174, 0
br i1 %175, label %176, label %251
176: ; preds = %171
%177 = zext i32 %174 to i64
br label %178
178: ; preds = %176, %207
%179 = phi i64 [ 0, %176 ], [ %210, %207 ]
%180 = phi i64 [ 0, %176 ], [ %184, %207 ]
%181 = shl i64 %180, 32
%182 = ashr exact i64 %181, 32
br label %183
183: ; preds = %178, %204
%184 = phi i64 [ %182, %178 ], [ %205, %204 ]
%185 = getelementptr inbounds [200000 x i32], [200000 x i32]* %3, i64 0, i64 %184
%186 = load i32, i32* %185
br label %193
187: ; preds = %207, %204
%188 = phi i64 [ %179, %204 ], [ %210, %207 ]
%189 = trunc i64 %188 to i32
%190 = icmp sgt i32 %189, 0
br i1 %190, label %191, label %212
191: ; preds = %187
%192 = and i64 %188, 4294967295
br label %215
193: ; preds = %193, %183
%194 = phi i64 [ %200, %193 ], [ 0, %183 ]
%195 = getelementptr inbounds [200000 x i32], [200000 x i32]* %4, i64 0, i64 %194
%196 = load i32, i32* %195
%197 = icmp ne i32 %186, %196
%198 = icmp ule i64 %194, %179
%199 = select i1 %197, i1 %198, i1 false
%200 = add nuw nsw i64 %194, 1
br i1 %199, label %193, label %201
201: ; preds = %193
%202 = and i64 %194, 4294967295
%203 = icmp ult i64 %202, %179
br i1 %203, label %204, label %207
204: ; preds = %201
%205 = add nsw i64 %184, 1
%206 = icmp slt i64 %205, %177
br i1 %206, label %183, label %187
207: ; preds = %201
%208 = trunc i64 %184 to i32
%209 = getelementptr inbounds [200000 x i32], [200000 x i32]* %4, i64 0, i64 %179
store i32 %186, i32* %209
%210 = add nuw i64 %179, 1
%211 = icmp sgt i32 %174, %208
br i1 %211, label %178, label %187
212: ; preds = %215, %187
br i1 %175, label %213, label %251
213: ; preds = %212
%214 = zext i32 %174 to i64
br label %246
215: ; preds = %191, %215
%216 = phi i64 [ 0, %191 ], [ %221, %215 ]
%217 = getelementptr inbounds [200000 x i32], [200000 x i32]* %4, i64 0, i64 %216
%218 = load i32, i32* %217
%219 = call i32 @div(i32 %218, i32 100)
%220 = getelementptr inbounds [200000 x i32], [200000 x i32]* %6, i64 0, i64 %216
store i32 %219, i32* %220
%221 = add nuw nsw i64 %216, 1
%222 = icmp eq i64 %221, %192
br i1 %222, label %212, label %215
223: ; preds = %246, %238
%224 = phi i64 [ %250, %246 ], [ %239, %238 ]
%225 = getelementptr inbounds [200000 x i32], [200000 x i32]* %6, i64 0, i64 %224
%226 = load i32, i32* %225
br label %227
227: ; preds = %227, %223
%228 = phi i64 [ %234, %227 ], [ 0, %223 ]
%229 = getelementptr inbounds [200000 x i32], [200000 x i32]* %7, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = icmp ne i32 %226, %230
%232 = icmp ule i64 %228, %247
%233 = select i1 %231, i1 %232, i1 false
%234 = add nuw nsw i64 %228, 1
br i1 %233, label %227, label %235
235: ; preds = %227
%236 = and i64 %228, 4294967295
%237 = icmp ult i64 %236, %247
br i1 %237, label %238, label %241
238: ; preds = %235
%239 = add nsw i64 %224, 1
%240 = icmp slt i64 %239, %214
br i1 %240, label %223, label %254
241: ; preds = %235
%242 = trunc i64 %224 to i32
%243 = getelementptr inbounds [200000 x i32], [200000 x i32]* %7, i64 0, i64 %247
store i32 %226, i32* %243
%244 = add nuw i64 %247, 1
%245 = icmp sgt i32 %174, %242
br i1 %245, label %246, label %254
246: ; preds = %213, %241
%247 = phi i64 [ 0, %213 ], [ %244, %241 ]
%248 = phi i64 [ 0, %213 ], [ %224, %241 ]
%249 = shl i64 %248, 32
%250 = ashr exact i64 %249, 32
br label %223
251: ; preds = %212, %171
%252 = getelementptr inbounds [200000 x i32], [200000 x i32]* %7, i64 0, i64 0
%253 = call i32 @bubble_sort(i32* %252, i32 -1)
br label %270
254: ; preds = %241, %238
%255 = phi i64 [ %247, %238 ], [ %244, %241 ]
%256 = trunc i64 %255 to i32
%257 = add nsw i32 %256, -1
%258 = getelementptr inbounds [200000 x i32], [200000 x i32]* %7, i64 0, i64 0
%259 = call i32 @bubble_sort(i32* %258, i32 %257)
%260 = icmp sgt i32 %256, 1
br i1 %260, label %261, label %270
261: ; preds = %254
%262 = icmp sgt i32 %172, 0
%263 = zext i32 %257 to i64
%264 = zext i32 %172 to i64
br label %265
265: ; preds = %261, %289
%266 = phi i64 [ 0, %261 ], [ %291, %289 ]
%267 = phi i32 [ 0, %261 ], [ %290, %289 ]
br i1 %262, label %268, label %289
268: ; preds = %265
%269 = getelementptr inbounds [200000 x i32], [200000 x i32]* %7, i64 0, i64 %266
br label %273
270: ; preds = %289, %251, %254
%271 = phi i32 [ 0, %254 ], [ 0, %251 ], [ %290, %289 ]
%272 = icmp sgt i32 %173, 0
br i1 %272, label %297, label %293
273: ; preds = %268, %285
%274 = phi i64 [ 0, %268 ], [ %287, %285 ]
%275 = phi i32 [ %267, %268 ], [ %286, %285 ]
%276 = getelementptr inbounds [200000 x i32], [200000 x i32]* %5, i64 0, i64 %274
%277 = load i32, i32* %276
%278 = call i32 @div(i32 %277, i32 100)
%279 = load i32, i32* %269
%280 = icmp eq i32 %279, %278
br i1 %280, label %281, label %285
281: ; preds = %273
%282 = sext i32 %275 to i64
%283 = getelementptr inbounds [200000 x i32], [200000 x i32]* %8, i64 0, i64 %282
store i32 %277, i32* %283
%284 = add nsw i32 %275, 1
br label %285
285: ; preds = %273, %281
%286 = phi i32 [ %284, %281 ], [ %275, %273 ]
%287 = add nuw nsw i64 %274, 1
%288 = icmp eq i64 %287, %264
br i1 %288, label %289, label %273
289: ; preds = %285, %265
%290 = phi i32 [ %267, %265 ], [ %286, %285 ]
%291 = add nuw nsw i64 %266, 1
%292 = icmp eq i64 %291, %263
br i1 %292, label %270, label %265
293: ; preds = %297, %270
%294 = icmp sgt i32 %271, 0
br i1 %294, label %295, label %303
295: ; preds = %293
%296 = zext i32 %271 to i64
br label %308
297: ; preds = %270, %297
%298 = phi i32 [ %301, %297 ], [ 0, %270 ]
%299 = add nuw nsw i32 %298, 1000000
%300 = call i32 @fprintf(i32* %75, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i64 0, i64 0), i32 %299, i32 %299, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%301 = add nuw nsw i32 %298, 1
%302 = icmp eq i32 %301, %173
br i1 %302, label %293, label %297
303: ; preds = %308, %293
%304 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %27, i64 0, i64 0
%305 = load i8*, i8** %304
%306 = call i32 @free(i8* %305)
%307 = call i32 @free(i8* %85)
br label %315
308: ; preds = %295, %308
%309 = phi i64 [ 0, %295 ], [ %313, %308 ]
%310 = getelementptr inbounds [200000 x i32], [200000 x i32]* %8, i64 0, i64 %309
%311 = load i32, i32* %310
%312 = call i32 @fprintf(i32* %75, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.13, i64 0, i64 0), i32 %311, i32 %311, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
%313 = add nuw nsw i64 %309, 1
%314 = icmp eq i64 %313, %296
br i1 %314, label %303, label %308
315: ; preds = %303, %315
%316 = phi i64 [ 1, %303 ], [ %323, %315 ]
%317 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %28, i64 0, i64 %316
%318 = load i8*, i8** %317
%319 = getelementptr inbounds [200000 x i8*], [200000 x i8*]* %27, i64 0, i64 %316
%320 = load i8*, i8** %319
%321 = call i32 @free(i8* %320)
%322 = call i32 @free(i8* %318)
%323 = add nuw nsw i64 %316, 1
%324 = icmp eq i64 %323, 200000
br i1 %324, label %325, label %315
325: ; preds = %315
%326 = call i32 @fclose(i32* %94)
%327 = call i32 @fclose(i32* %74)
%328 = call i32 @fclose(i32* %75)
%329 = call i32 @fclose(i32* %76)
ret i32 0
}