#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int BUFSIZ;
char EOF;
int /*<<< orphan*/ exit(int /*<<< orphan*/);
char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
scalar_t__ isupper(char);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdin;
scalar_t__ strcmp(char *, char *);
char tolower(char);
void main() {
  char file1[BUFSIZ], file2[BUFSIZ], work[1000];
  FILE *in1, *out, *fopen();
  int i, ifile, ii, jj, kk, iatom;
  float x[3000];
  float y[3000];
  float z[3000];
  char aid[3000][10];
  int ires[3000];
  char aname[10], atype[10], *wp, *cp;
  float a;
  fgets(work, 80, stdin);
  for (i = 0; i < 80; i++)
    if (work[i] != ' ')
      break;
  for (ifile = i; ifile < 80; ifile++) {
    if (work[ifile] == ' ')
      break;
    if (work[ifile] == '\0')
      break;
    if (work[ifile] == '\n')
      break;
    file1[ifile - i] = work[ifile];
    file1[ifile - i + 1] = '\0';
  }
  fgets(work, 80, stdin);
  for (i = 0; i < 80; i++)
    if (work[i] != ' ')
      break;
  for (ifile = i; ifile < 80; ifile++) {
    if (work[ifile] == ' ')
      break;
    if (work[ifile] == '\0')
      break;
    if (work[ifile] == '\n')
      break;
    file2[ifile - i] = work[ifile];
    file2[ifile - i + 1] = '\0';
  }
  in1 = fopen(file1, "r");
  out = fopen(file2, "w");
  if (out == NULL) {
    fprintf(stderr, "cannot open %s\n", file2);
    exit(0);
  }
  if (in1 == NULL) {
    fprintf(stderr, "cannot open %s\n", file1);
    exit(0);
  }
  ii = 0;
  iatom = 0;
  while ((work[ii] = fgetc(in1)) != EOF && ii < 1000) {
    if (isupper(work[ii]))
      work[ii] = tolower(work[ii]);
    if (ii == 0 && (work[ii] == ' ' || work[ii] == '\n' || work[ii] == '\0'))
      ii = -1;
    if (work[ii] == '\n' || work[ii] == '\0')
      ii = ii - 1;
    if (work[ii] == ';') {
      if (work[0] == 'a' && work[1] == 't' && work[2] == 'o' &&
          work[3] == 'm') {
        wp = &work[4];
        while (*wp == ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        while (*wp != ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        while (*wp == ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        while (*wp != ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        while (*wp == ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        while (*wp != ' ') {
          wp++;
          if (*wp == ';') {
            wp--;
            break;
          }
        }
        sscanf(wp, "%d %s", &jj, aname);
        cp = &aname[0];
        while (*cp != '.' && *cp != '\0')
          cp++;
        if (*cp != '\0')
          cp++;
        if (strcmp("ca", cp) == 0) {
          wp = &work[4];
          sscanf(wp, "%f %f %f", &x[iatom], &y[iatom], &z[iatom]);
          ires[iatom] = jj;
          for (jj = 0; jj < 10; jj++)
            aid[iatom][jj] = aname[jj];
          iatom += 1;
        }
      }
      ii = -1;
    }
    ii++;
  }
  fprintf(out,
          " setf qu 0.;\n setf au 20.;\n setf bu 6000.; \n setf mu 40.; \n");
  fprintf(
      out,
      " setf kbu 100.;\n setf kau 100.;\n setf ang 109.5;\n setf tku 10.;\n");
  fprintf(out, " atom %f %f %f %d %s qu au bu mu;\n", x[0], y[0], z[0], ires[0],
          &aid[0][0]);
  fprintf(out, " atom %f %f %f %d %s qu au bu mu;\n", x[1], y[1], z[1], ires[1],
          &aid[1][0]);
  fprintf(out, " atom %f %f %f %d %s qu au bu mu;\n", x[2], y[3], z[2], ires[2],
          &aid[2][0]);
  fprintf(out, "bond  %d %d 3.8 kbu;\n", ires[0], ires[1]);
  fprintf(out, "bond  %d %d 3.8 kbu;\n", ires[1], ires[2]);
  fprintf(out, "angle %d %d %d kau 109.5;\n", ires[0], ires[1], ires[2]);
  for (jj = 0; jj < iatom - 3; jj++) {
    fprintf(out, " atom %f %f %f %d %s qu au bu mu;\n", x[jj + 3], y[jj + 3],
            z[jj + 3], ires[jj + 3], &aid[jj + 3][0]);
    fprintf(out, "bond  %d %d 3.8 kbu;\n", ires[jj + 2], ires[jj + 3]);
    fprintf(out, "angle %d %d %d kau 109.5;\n", ires[jj + 1], ires[jj + 2],
            ires[jj + 3]);
    fprintf(out, "torsion %d %d %d %d  0.4781527 1 286.7432;\n", ires[jj],
            ires[jj + 1], ires[jj + 2], ires[jj + 3]);
    fprintf(out, "torsion %d %d %d %d  0.2279931 2 413.2828;\n", ires[jj],
            ires[jj + 1], ires[jj + 2], ires[jj + 3]);
    fprintf(out, "torsion %d %d %d %d  0.4148926 3 346.9368;\n", ires[jj],
            ires[jj + 1], ires[jj + 2], ires[jj + 3]);
  }
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x13530,%rsp
mov    0x2e26(%rip),%rax
mov    (%rax),%ecx
mov    %rsp,%rdx
mov    %rdx,-0x8(%rbp)
mov    %rcx,%rsi
add    $0xf,%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x13520(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x10(%rbp)
mov    (%rax),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x13518(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x18(%rbp)
lea    -0x400(%rbp),%rdi
mov    0x2def(%rip),%rax
mov    (%rax),%edx
mov    $0x50,%esi
call   1040 <fgets@plt>
movl   $0x0,-0x414(%rbp)
cmpl   $0x50,-0x414(%rbp)
jge    1252 <main+0xc2>
movslq -0x414(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     1239 <main+0xa9>
jmp    1252 <main+0xc2>
jmp    123e <main+0xae>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    120f <main+0x7f>
mov    -0x414(%rbp),%eax
mov    %eax,-0x418(%rbp)
cmpl   $0x50,-0x418(%rbp)
jge    1313 <main+0x183>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    1288 <main+0xf8>
jmp    1313 <main+0x183>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    12a5 <main+0x115>
jmp    1313 <main+0x183>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    12c2 <main+0x132>
jmp    1313 <main+0x183>
mov    -0x13520(%rbp),%rax
movslq -0x418(%rbp),%rcx
mov    -0x400(%rbp,%rcx,1),%dl
mov    -0x418(%rbp),%ecx
sub    -0x414(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x418(%rbp),%ecx
sub    -0x414(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x418(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x418(%rbp)
jmp    125e <main+0xce>
lea    -0x400(%rbp),%rdi
mov    0x2cc7(%rip),%rax
mov    (%rax),%edx
mov    $0x50,%esi
call   1040 <fgets@plt>
movl   $0x0,-0x414(%rbp)
cmpl   $0x50,-0x414(%rbp)
jge    137a <main+0x1ea>
movslq -0x414(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     1361 <main+0x1d1>
jmp    137a <main+0x1ea>
jmp    1366 <main+0x1d6>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    1337 <main+0x1a7>
mov    -0x414(%rbp),%eax
mov    %eax,-0x418(%rbp)
cmpl   $0x50,-0x418(%rbp)
jge    143b <main+0x2ab>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
jne    13b0 <main+0x220>
jmp    143b <main+0x2ab>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    13cd <main+0x23d>
jmp    143b <main+0x2ab>
movslq -0x418(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
jne    13ea <main+0x25a>
jmp    143b <main+0x2ab>
mov    -0x13518(%rbp),%rax
movslq -0x418(%rbp),%rcx
mov    -0x400(%rbp,%rcx,1),%dl
mov    -0x418(%rbp),%ecx
sub    -0x414(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x418(%rbp),%ecx
sub    -0x414(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x418(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x418(%rbp)
jmp    1386 <main+0x1f6>
mov    -0x13520(%rbp),%rdi
lea    0xbb7(%rip),%rsi
call   10a0 <fopen@plt>
mov    -0x13518(%rbp),%rdi
mov    %rax,-0x408(%rbp)
lea    0xb9f(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x410(%rbp)
cmpq   $0x0,-0x410(%rbp)
jne    14a3 <main+0x313>
mov    -0x13518(%rbp),%rdx
mov    0x2b45(%rip),%rax
movslq (%rax),%rdi
lea    0xb6f(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
xor    %edi,%edi
call   10b0 <exit@plt>
cmpq   $0x0,-0x408(%rbp)
jne    14d7 <main+0x347>
mov    -0x13520(%rbp),%rdx
mov    0x2b11(%rip),%rax
movslq (%rax),%rdi
lea    0xb3b(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
xor    %edi,%edi
call   10b0 <exit@plt>
movl   $0x0,-0x41c(%rbp)
movl   $0x0,-0x428(%rbp)
mov    -0x408(%rbp),%rdi
call   1030 <fgetc@plt>
movslq -0x41c(%rbp),%rcx
mov    %al,-0x400(%rbp,%rcx,1)
movsbl %al,%ecx
mov    0x2ad1(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x13521(%rbp)
je     1535 <main+0x3a5>
cmpl   $0x3e8,-0x41c(%rbp)
setl   %al
mov    %al,-0x13521(%rbp)
mov    -0x13521(%rbp),%al
test   $0x1,%al
jne    1548 <main+0x3b8>
jmp    1a75 <main+0x8e5>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%edi
ff
call   1090 <isupper@plt>
cmp    $0x0,%rax
je     158a <main+0x3fa>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%edi
ff
call   1070 <tolower@plt>
mov    %al,%cl
movslq -0x41c(%rbp),%rax
mov    %cl,-0x400(%rbp,%rax,1)
cmpl   $0x0,-0x41c(%rbp)
jne    15e9 <main+0x459>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     15df <main+0x44f>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     15df <main+0x44f>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    15e9 <main+0x459>
movl   $0xffffffff,-0x41c(%rbp)
ff ff ff
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     1619 <main+0x489>
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
jne    1628 <main+0x498>
mov    -0x41c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x41c(%rbp)
movslq -0x41c(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cmp    $0x3b,%eax
jne    1a61 <main+0x8d1>
movsbl -0x400(%rbp),%eax
cmp    $0x61,%eax
jne    1a57 <main+0x8c7>
movsbl -0x3ff(%rbp),%eax
cmp    $0x74,%eax
jne    1a57 <main+0x8c7>
movsbl -0x3fe(%rbp),%eax
cmp    $0x6f,%eax
jne    1a57 <main+0x8c7>
movsbl -0x3fd(%rbp),%eax
cmp    $0x6d,%eax
jne    1a57 <main+0x8c7>
lea    -0x400(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    16e6 <main+0x556>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    16e1 <main+0x551>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    16e6 <main+0x556>
jmp    1692 <main+0x502>
jmp    16eb <main+0x55b>
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     173f <main+0x5af>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    173a <main+0x5aa>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    173f <main+0x5af>
jmp    16eb <main+0x55b>
jmp    1744 <main+0x5b4>
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    1798 <main+0x608>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    1793 <main+0x603>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    1798 <main+0x608>
jmp    1744 <main+0x5b4>
jmp    179d <main+0x60d>
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     17f1 <main+0x661>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    17ec <main+0x65c>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    17f1 <main+0x661>
jmp    179d <main+0x60d>
jmp    17f6 <main+0x666>
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
jne    184a <main+0x6ba>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    1845 <main+0x6b5>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    184a <main+0x6ba>
jmp    17f6 <main+0x666>
jmp    184f <main+0x6bf>
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x20,%eax
je     18a3 <main+0x713>
mov    -0x13500(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
jne    189e <main+0x70e>
mov    -0x13500(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x13500(%rbp)
jmp    18a3 <main+0x713>
jmp    184f <main+0x6bf>
mov    -0x13500(%rbp),%rdi
lea    -0x134ea(%rbp),%rcx
lea    0x75c(%rip),%rsi
lea    -0x420(%rbp),%rdx
mov    $0x0,%al
call   1080 <sscanf@plt>
lea    -0x134ea(%rbp),%rax
mov    %rax,-0x13508(%rbp)
mov    -0x13508(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x2e,%ecx
mov    %al,-0x13522(%rbp)
je     1905 <main+0x775>
mov    -0x13508(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x13522(%rbp)
mov    -0x13522(%rbp),%al
test   $0x1,%al
jne    1918 <main+0x788>
jmp    192f <main+0x79f>
mov    -0x13508(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13508(%rbp)
jmp    18d4 <main+0x744>
mov    -0x13508(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1954 <main+0x7c4>
mov    -0x13508(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x13508(%rbp)
mov    -0x13508(%rbp),%rsi
lea    0x6b8(%rip),%rdi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
jne    1a52 <main+0x8c2>
lea    -0x400(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x13500(%rbp)
mov    -0x13500(%rbp),%rdi
movslq -0x428(%rbp),%rax
lea    -0x3310(%rbp),%rdx
shl    $0x2,%rax
add    %rax,%rdx
movslq -0x428(%rbp),%rax
lea    -0x61f0(%rbp),%rcx
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x428(%rbp),%rax
lea    -0x90d0(%rbp),%r8
shl    $0x2,%rax
add    %rax,%r8
lea    0x64d(%rip),%rsi
mov    $0x0,%al
call   1080 <sscanf@plt>
mov    -0x420(%rbp),%ecx
movslq -0x428(%rbp),%rax
mov    %ecx,-0x134e0(%rbp,%rax,4)
movl   $0x0,-0x420(%rbp)
cmpl   $0xa,-0x420(%rbp)
jge    1a43 <main+0x8b3>
movslq -0x420(%rbp),%rax
mov    -0x134ea(%rbp,%rax,1),%dl
movslq -0x428(%rbp),%rcx
lea    -0x10600(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x420(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x420(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x420(%rbp)
jmp    19f5 <main+0x865>
mov    -0x428(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x428(%rbp)
jmp    1a57 <main+0x8c7>
movl   $0xffffffff,-0x41c(%rbp)
ff ff ff
mov    -0x41c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x41c(%rbp)
jmp    14eb <main+0x35b>
mov    -0x410(%rbp),%rdi
lea    0x5a3(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
lea    0x5ca(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movss  -0x3310(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x61f0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x90d0(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x134e0(%rbp),%edx
lea    -0x10600(%rbp),%rcx
lea    0x5c5(%rip),%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movss  -0x330c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x61ec(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x90cc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x134dc(%rbp),%edx
lea    -0x10600(%rbp),%rcx
add    $0xa,%rcx
lea    0x57b(%rip),%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movss  -0x3308(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x61e4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x90c8(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x134d8(%rbp),%edx
lea    -0x10600(%rbp),%rcx
add    $0x14,%rcx
lea    0x531(%rip),%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
mov    -0x134e0(%rbp),%edx
mov    -0x134dc(%rbp),%ecx
lea    0x533(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
mov    -0x134dc(%rbp),%edx
mov    -0x134d8(%rbp),%ecx
lea    0x512(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
mov    -0x134e0(%rbp),%edx
mov    -0x134dc(%rbp),%ecx
mov    -0x134d8(%rbp),%r8d
lea    0x500(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0x0,-0x420(%rbp)
mov    -0x420(%rbp),%eax
mov    -0x428(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1e36 <main+0xca6>
mov    -0x410(%rbp),%rdi
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
movss  -0x3310(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
movss  -0x61f0(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
movss  -0x90d0(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
lea    -0x10600(%rbp),%rcx
imul   $0xa,%rax,%rax
add    %rax,%rcx
lea    0x41e(%rip),%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
mov    -0x420(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%ecx
lea    0x408(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
mov    -0x420(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%ecx
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r8d
ff
lea    0x3d2(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movslq -0x420(%rbp),%rax
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%ecx
mov    -0x420(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r8d
ff
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r9d
ff
lea    0x392(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movslq -0x420(%rbp),%rax
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%ecx
mov    -0x420(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r8d
ff
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r9d
ff
lea    0x363(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x410(%rbp),%rdi
movslq -0x420(%rbp),%rax
mov    -0x134e0(%rbp,%rax,4),%edx
mov    -0x420(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%ecx
mov    -0x420(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r8d
mov    -0x420(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x134e0(%rbp,%rax,4),%r9d
ff
lea    0x334(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    -0x420(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x420(%rbp)
jmp    1bed <main+0xa5d>
xor    %edi,%edi
call   10b0 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x134c8,%rsp
mov    0x2e0d(%rip),%rax
mov    (%rax),%eax
mov    %rsp,%r15
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    0x2e0a(%rip),%rbx
mov    (%rbx),%edx
lea    -0x440(%rbp),%rdi
mov    $0x50,%esi
call   1040 <fgets@plt>
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
cmpb   $0x20,-0x444(%rbp,%rax,1)
20
jne    1242 <main+0xa2>
cmpb   $0x20,-0x443(%rbp,%rax,1)
20
jne    124d <main+0xad>
cmpb   $0x20,-0x442(%rbp,%rax,1)
20
jne    1258 <main+0xb8>
cmpb   $0x20,-0x441(%rbp,%rax,1)
20
jne    1315 <main+0x175>
cmpb   $0x20,-0x440(%rbp,%rax,1)
20
jne    125c <main+0xbc>
add    $0x5,%rax
cmp    $0x54,%rax
jne    1200 <main+0x60>
jmp    12b3 <main+0x113>
add    $0xfffffffffffffffc,%rax
cmp    $0x4f,%eax
jbe    1261 <main+0xc1>
jmp    12b3 <main+0x113>
add    $0xfffffffffffffffd,%rax
cmp    $0x4f,%eax
jbe    1261 <main+0xc1>
jmp    12b3 <main+0x113>
add    $0xfffffffffffffffe,%rax
cmp    $0x4f,%eax
ja     12b3 <main+0x113>
lea    (%rax,%rbp,1),%rcx
add    $0xfffffffffffffbc0,%rcx
mov    $0x50,%edx
sub    %rax,%rdx
xor    %eax,%eax
movabs $0x100000401,%rsi
jmp    12a3 <main+0x103>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %dil,(%r15,%rax,1)
movb   $0x0,0x1(%r15,%rax,1)
add    $0x1,%rax
cmp    %rax,%rdx
je     12b3 <main+0x113>
movzbl (%rcx,%rax,1),%edi
cmp    $0x20,%rdi
ja     1290 <main+0xf0>
bt     %rdi,%rsi
jae    1290 <main+0xf0>
mov    (%rbx),%edx
lea    -0x440(%rbp),%r13
mov    %r13,%rdi
mov    $0x50,%esi
call   1040 <fgets@plt>
mov    $0x4,%eax
xchg   %ax,%ax
cmpb   $0x20,-0x444(%rbp,%rax,1)
20
jne    1324 <main+0x184>
cmpb   $0x20,-0x443(%rbp,%rax,1)
20
jne    132f <main+0x18f>
cmpb   $0x20,-0x442(%rbp,%rax,1)
20
jne    133a <main+0x19a>
cmpb   $0x20,-0x441(%rbp,%rax,1)
20
jne    1952 <main+0x7b2>
cmpb   $0x20,-0x440(%rbp,%rax,1)
20
jne    133e <main+0x19e>
add    $0x5,%rax
cmp    $0x54,%rax
jne    12d0 <main+0x130>
jmp    1393 <main+0x1f3>
add    $0xffffffffffffffff,%rax
cmp    $0x4f,%eax
jbe    1261 <main+0xc1>
jmp    12b3 <main+0x113>
add    $0xfffffffffffffffc,%rax
cmp    $0x4f,%eax
jbe    1343 <main+0x1a3>
jmp    1393 <main+0x1f3>
add    $0xfffffffffffffffd,%rax
cmp    $0x4f,%eax
jbe    1343 <main+0x1a3>
jmp    1393 <main+0x1f3>
add    $0xfffffffffffffffe,%rax
cmp    $0x4f,%eax
ja     1393 <main+0x1f3>
lea    (%rax,%rbp,1),%rcx
add    $0xfffffffffffffbc0,%rcx
mov    $0x50,%edx
sub    %rax,%rdx
xor    %eax,%eax
movabs $0x100000401,%rsi
jmp    1383 <main+0x1e3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %dil,(%r12,%rax,1)
movb   $0x0,0x1(%r12,%rax,1)
add    $0x1,%rax
cmp    %rax,%rdx
je     1393 <main+0x1f3>
movzbl (%rcx,%rax,1),%edi
cmp    $0x20,%rdi
ja     1370 <main+0x1d0>
bt     %rdi,%rsi
jae    1370 <main+0x1d0>
lea    0xc66(%rip),%rsi
mov    %r15,%rdi
call   10a0 <fopen@plt>
mov    %rax,-0x40(%rbp)
lea    0xc55(%rip),%rsi
mov    %r12,%rdi
call   10a0 <fopen@plt>
test   %rax,%rax
jne    13d0 <main+0x230>
mov    0x2c0f(%rip),%rax
movslq (%rax),%rdi
lea    0xc39(%rip),%rsi
mov    %r12,%rdx
jmp    13eb <main+0x24b>
cmpq   $0x0,-0x40(%rbp)
jne    13f9 <main+0x259>
mov    0x2bf2(%rip),%rax
movslq (%rax),%rdi
lea    0xc1c(%rip),%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
xor    %edi,%edi
call   10b0 <exit@plt>
mov    %rax,%r14
mov    -0x40(%rbp),%rdi
call   1030 <fgetc@plt>
mov    %al,-0x440(%rbp)
mov    0x2bce(%rip),%rdx
xor    %ecx,%ecx
mov    %rcx,-0x38(%rbp)
cmp    (%rdx),%al
je     168b <main+0x4eb>
xor    %ecx,%ecx
mov    %rcx,-0x38(%rbp)
xor    %r12d,%r12d
nopl   0x0(%rax)
movsbl %al,%edi
call   1090 <isupper@plt>
test   %rax,%rax
je     144b <main+0x2ab>
movsbl 0x0(%r13),%edi
call   1070 <tolower@plt>
mov    %al,0x0(%r13)
test   %r12d,%r12d
jne    1474 <main+0x2d4>
movzbl 0x0(%r13),%eax
xor    %r12d,%r12d
cmp    $0x20,%rax
ja     1474 <main+0x2d4>
movabs $0x100000401,%rcx
bt     %rax,%rcx
jae    1474 <main+0x2d4>
mov    $0xffffffff,%r12d
movslq %r12d,%rcx
mov    -0x440(%rbp,%rcx,1),%al
cmp    $0xa,%al
je     1486 <main+0x2e6>
test   %al,%al
jne    1494 <main+0x2f4>
mov    -0x441(%rbp,%rcx,1),%al
add    $0xffffffffffffffff,%rcx
mov    %ecx,%r12d
cmp    $0x3b,%al
jne    1650 <main+0x4b0>
movdqa -0x440(%rbp),%xmm0
ff
movd   %xmm0,%eax
mov    $0xffffffff,%r12d
cmp    $0x6d6f7461,%eax
jne    1650 <main+0x4b0>
mov    -0x43c(%rbp),%cl
lea    -0x43c(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rdx,%rax
cmp    $0x20,%cl
jne    14e5 <main+0x345>
lea    0x1(%rax),%rdx
movzbl 0x1(%rax),%ecx
cmp    $0x3b,%cl
jne    14d0 <main+0x330>
mov    (%rax),%dl
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
cmp    $0x20,%dl
je     1505 <main+0x365>
lea    0x1(%rcx),%rax
movzbl 0x1(%rcx),%edx
cmp    $0x3b,%dl
jne    14f0 <main+0x350>
mov    (%rcx),%dl
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rax
cmp    $0x20,%dl
jne    1525 <main+0x385>
lea    0x1(%rax),%rcx
movzbl 0x1(%rax),%edx
cmp    $0x3b,%dl
jne    1510 <main+0x370>
mov    (%rax),%dl
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
cmp    $0x20,%dl
je     1545 <main+0x3a5>
lea    0x1(%rcx),%rax
movzbl 0x1(%rcx),%edx
cmp    $0x3b,%dl
jne    1530 <main+0x390>
mov    (%rcx),%dl
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rax
cmp    $0x20,%dl
jne    1565 <main+0x3c5>
lea    0x1(%rax),%rcx
movzbl 0x1(%rax),%edx
cmp    $0x3b,%dl
jne    1550 <main+0x3b0>
mov    (%rax),%cl
nopw   0x0(%rax,%rax,1)
mov    %rax,%rdi
cmp    $0x20,%cl
je     1585 <main+0x3e5>
lea    0x1(%rdi),%rax
movzbl 0x1(%rdi),%ecx
cmp    $0x3b,%cl
jne    1570 <main+0x3d0>
lea    0xa88(%rip),%rsi
lea    -0x2c(%rbp),%rdx
lea    -0x4a(%rbp),%rbx
mov    %rbx,%rcx
xor    %eax,%eax
call   1080 <sscanf@plt>
xchg   %ax,%ax
movzbl (%rbx),%eax
test   %al,%al
je     15c0 <main+0x420>
cmp    $0x2e,%al
je     15c0 <main+0x420>
add    $0x1,%rbx
jmp    15a0 <main+0x400>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%al
sbb    $0xffffffffffffffff,%rbx
lea    0xa4d(%rip),%rdi
mov    %rbx,%rsi
call   1050 <strcmp@plt>
test   %rax,%rax
jne    1650 <main+0x4b0>
mov    -0x38(%rbp),%rbx
movslq %ebx,%rbx
lea    -0xbfc0(,%rbx,4),%rdx
ff
add    %rbp,%rdx
lea    -0x90e0(%rbp,%rbx,4),%rcx
ff
lea    -0x6200(,%rbx,4),%r8
ff
add    %rbp,%r8
lea    -0x43c(%rbp),%rdi
lea    0xa10(%rip),%rsi
xor    %eax,%eax
call   1080 <sscanf@plt>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3320(%rbp,%rbx,4)
lea    (%rbx,%rbx,4),%rax
movzwl -0x42(%rbp),%ecx
mov    %cx,-0x134e8(%rbp,%rax,2)
ff
mov    -0x4a(%rbp),%rcx
mov    %rcx,-0x134f0(%rbp,%rax,2)
ff
movl   $0xa,-0x2c(%rbp)
add    $0x1,%ebx
mov    %rbx,-0x38(%rbp)
nopl   0x0(%rax,%rax,1)
movslq %r12d,%r15
mov    -0x40(%rbp),%rdi
call   1030 <fgetc@plt>
mov    %al,-0x43f(%rbp,%r15,1)
ff
mov    0x2975(%rip),%rcx
cmp    (%rcx),%al
je     168b <main+0x4eb>
lea    0x1(%r15),%r12
lea    (%r15,%rbp,1),%r13
add    $0xfffffffffffffbc1,%r13
cmp    $0x3e7,%r15d
jl     1430 <main+0x290>
lea    0x994(%rip),%rdi
mov    $0x3b,%esi
mov    $0x1,%edx
mov    %r14,%rcx
call   10c0 <fwrite@plt>
lea    0x9b7(%rip),%rdi
mov    $0x40,%esi
mov    $0x1,%edx
mov    %r14,%rcx
call   10c0 <fwrite@plt>
movss  -0xbfc0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x90e0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x6200(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x3320(%rbp),%edx
lea    0x9b5(%rip),%rbx
lea    -0x134f0(%rbp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
movss  -0xbfbc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x90dc(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x61fc(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x331c(%rbp),%edx
lea    -0x134e6(%rbp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
movss  -0xbfb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x90d4(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x61f8(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
mov    -0x3318(%rbp),%edx
lea    -0x134dc(%rbp),%rcx
mov    %r14,%rdi
mov    %rbx,%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
mov    -0x3320(%rbp),%edx
mov    -0x331c(%rbp),%ecx
lea    0x935(%rip),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    -0x331c(%rbp),%edx
mov    -0x3318(%rbp),%ecx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    -0x3320(%rbp),%edx
mov    -0x331c(%rbp),%ecx
mov    -0x3318(%rbp),%r8d
lea    0x90b(%rip),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <fprintf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x38(%rbp),%r12
cmp    $0x4,%r12d
jl     194b <main+0x7ab>
add    $0xfffffffd,%r12d
lea    0x8fc(%rip),%r13
lea    0x921(%rip),%rbx
lea    0x946(%rip),%r15
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
cltq
movss  -0xbfb4(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movss  -0x90d4(%rbp,%rax,4),%xmm1
ff ff
cvtss2sd %xmm1,%xmm1
movss  -0x61f4(%rbp,%rax,4),%xmm2
ff ff
cvtss2sd %xmm2,%xmm2
mov    -0x3314(%rbp,%rax,4),%edx
lea    0xf(%rax,%rax,4),%rax
lea    -0x134f0(%rbp,%rax,2),%rcx
ff
mov    %r14,%rdi
lea    0x84c(%rip),%rsi
mov    $0x3,%al
call   1060 <fprintf@plt>
movslq -0x2c(%rbp),%rax
mov    -0x3318(%rbp,%rax,4),%edx
mov    -0x3314(%rbp,%rax,4),%ecx
mov    %r14,%rdi
lea    0x84c(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movslq -0x2c(%rbp),%rax
mov    -0x331c(%rbp,%rax,4),%edx
mov    -0x3318(%rbp,%rax,4),%ecx
mov    -0x3314(%rbp,%rax,4),%r8d
ff
mov    %r14,%rdi
lea    0x837(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movslq -0x2c(%rbp),%rax
mov    -0x3320(%rbp,%rax,4),%edx
mov    -0x331c(%rbp,%rax,4),%ecx
mov    -0x3318(%rbp,%rax,4),%r8d
ff
mov    -0x3314(%rbp,%rax,4),%r9d
ff
mov    %r14,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movslq -0x2c(%rbp),%rax
mov    -0x3320(%rbp,%rax,4),%edx
mov    -0x331c(%rbp,%rax,4),%ecx
mov    -0x3318(%rbp,%rax,4),%r8d
ff
mov    -0x3314(%rbp,%rax,4),%r9d
ff
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
movslq -0x2c(%rbp),%rax
mov    -0x3320(%rbp,%rax,4),%edx
mov    -0x331c(%rbp,%rax,4),%ecx
mov    -0x3318(%rbp,%rax,4),%r8d
ff
mov    -0x3314(%rbp,%rax,4),%r9d
ff
mov    %r14,%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmp    %r12d,%eax
jl     1810 <main+0x670>
xor    %edi,%edi
call   10b0 <exit@plt>
add    $0xffffffffffffffff,%rax
cmp    $0x4f,%eax
jbe    1343 <main+0x1a3>
jmp    1393 <main+0x1f3>

LLVM IR (-O0):
@BUFSIZ = global i32 0
@stdin = global i32 0
@.str = [2 x i8] c"r\00"
@.str.1 = [2 x i8] c"w\00"
@stderr = global i32 0
@.str.2 = [16 x i8] c"cannot open %s\0A\00"
@EOF = global i8 0
@.str.3 = [6 x i8] c"%d %s\00"
@.str.4 = [3 x i8] c"ca\00"
@.str.5 = [9 x i8] c"%f %f %f\00"
@.str.6 = [60 x i8] c" setf qu 0.;\0A setf au 20.;\0A setf bu 6000.; \0A setf mu 40.; \0A\00"
@.str.7 = [65 x i8] c" setf kbu 100.;\0A setf kau 100.;\0A setf ang 109.5;\0A setf tku 10.;\0A\00"
@.str.8 = [35 x i8] c" atom %f %f %f %d %s qu au bu mu;\0A\00"
@.str.9 = [22 x i8] c"bond %d %d 3.8 kbu;\0A\00"
@.str.10 = [27 x i8] c"angle %d %d %d kau 109.5;\0A\00"
@.str.11 = [44 x i8] c"torsion %d %d %d %d 0.4781527 1 286.7432;\0A\00"
@.str.12 = [44 x i8] c"torsion %d %d %d %d 0.2279931 2 413.2828;\0A\00"
@.str.13 = [44 x i8] c"torsion %d %d %d %d 0.4148926 3 346.9368;\0A\00"
define void @main() {
%1 = alloca i8*
%2 = alloca i64
%3 = alloca i64
%4 = alloca [1000 x i8]
%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 [3000 x float]
%14 = alloca [3000 x float]
%15 = alloca [3000 x float]
%16 = alloca [3000 x [10 x i8]]
%17 = alloca [3000 x i32]
%18 = alloca [10 x i8]
%19 = alloca [10 x i8]
%20 = alloca i8*
%21 = alloca i8*
%22 = alloca float
%23 = load i32, i32* @BUFSIZ
%24 = zext i32 %23 to i64
%25 = call i8* @llvm.stacksave()
store i8* %25, i8** %1
%26 = alloca i8, i64 %24
store i64 %24, i64* %2
%27 = load i32, i32* @BUFSIZ
%28 = zext i32 %27 to i64
%29 = alloca i8, i64 %28
store i64 %28, i64* %3
%30 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
%31 = load i32, i32* @stdin
%32 = call i32 @fgets(i8* %30, i32 80, i32 %31)
store i32 0, i32* %7
br label %33
33: ; preds = %45, %0
%34 = load i32, i32* %7
%35 = icmp slt i32 %34, 80
br i1 %35, label %36, label %48
36: ; preds = %33
%37 = load i32, i32* %7
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %38
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp ne i32 %41, 32
br i1 %42, label %43, label %44
43: ; preds = %36
br label %48
44: ; preds = %36
br label %45
45: ; preds = %44
%46 = load i32, i32* %7
%47 = add nsw i32 %46, 1
store i32 %47, i32* %7
br label %33
48: ; preds = %43, %33
%49 = load i32, i32* %7
store i32 %49, i32* %8
br label %50
50: ; preds = %93, %48
%51 = load i32, i32* %8
%52 = icmp slt i32 %51, 80
br i1 %52, label %53, label %96
53: ; preds = %50
%54 = load i32, i32* %8
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %55
%57 = load i8, i8* %56
%58 = sext i8 %57 to i32
%59 = icmp eq i32 %58, 32
br i1 %59, label %60, label %61
60: ; preds = %53
br label %96
61: ; preds = %53
%62 = load i32, i32* %8
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %63
%65 = load i8, i8* %64
%66 = sext i8 %65 to i32
%67 = icmp eq i32 %66, 0
br i1 %67, label %68, label %69
68: ; preds = %61
br label %96
69: ; preds = %61
%70 = load i32, i32* %8
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = icmp eq i32 %74, 10
br i1 %75, label %76, label %77
76: ; preds = %69
br label %96
77: ; preds = %69
%78 = load i32, i32* %8
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %79
%81 = load i8, i8* %80
%82 = load i32, i32* %8
%83 = load i32, i32* %7
%84 = sub nsw i32 %82, %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %26, i64 %85
store i8 %81, i8* %86
%87 = load i32, i32* %8
%88 = load i32, i32* %7
%89 = sub nsw i32 %87, %88
%90 = add nsw i32 %89, 1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %26, i64 %91
store i8 0, i8* %92
br label %93
93: ; preds = %77
%94 = load i32, i32* %8
%95 = add nsw i32 %94, 1
store i32 %95, i32* %8
br label %50
96: ; preds = %76, %68, %60, %50
%97 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
%98 = load i32, i32* @stdin
%99 = call i32 @fgets(i8* %97, i32 80, i32 %98)
store i32 0, i32* %7
br label %100
100: ; preds = %112, %96
%101 = load i32, i32* %7
%102 = icmp slt i32 %101, 80
br i1 %102, label %103, label %115
103: ; preds = %100
%104 = load i32, i32* %7
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %105
%107 = load i8, i8* %106
%108 = sext i8 %107 to i32
%109 = icmp ne i32 %108, 32
br i1 %109, label %110, label %111
110: ; preds = %103
br label %115
111: ; preds = %103
br label %112
112: ; preds = %111
%113 = load i32, i32* %7
%114 = add nsw i32 %113, 1
store i32 %114, i32* %7
br label %100
115: ; preds = %110, %100
%116 = load i32, i32* %7
store i32 %116, i32* %8
br label %117
117: ; preds = %160, %115
%118 = load i32, i32* %8
%119 = icmp slt i32 %118, 80
br i1 %119, label %120, label %163
120: ; preds = %117
%121 = load i32, i32* %8
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = icmp eq i32 %125, 32
br i1 %126, label %127, label %128
127: ; preds = %120
br label %163
128: ; preds = %120
%129 = load i32, i32* %8
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %130
%132 = load i8, i8* %131
%133 = sext i8 %132 to i32
%134 = icmp eq i32 %133, 0
br i1 %134, label %135, label %136
135: ; preds = %128
br label %163
136: ; preds = %128
%137 = load i32, i32* %8
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %138
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = icmp eq i32 %141, 10
br i1 %142, label %143, label %144
143: ; preds = %136
br label %163
144: ; preds = %136
%145 = load i32, i32* %8
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %146
%148 = load i8, i8* %147
%149 = load i32, i32* %8
%150 = load i32, i32* %7
%151 = sub nsw i32 %149, %150
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds i8, i8* %29, i64 %152
store i8 %148, i8* %153
%154 = load i32, i32* %8
%155 = load i32, i32* %7
%156 = sub nsw i32 %154, %155
%157 = add nsw i32 %156, 1
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i8, i8* %29, i64 %158
store i8 0, i8* %159
br label %160
160: ; preds = %144
%161 = load i32, i32* %8
%162 = add nsw i32 %161, 1
store i32 %162, i32* %8
br label %117
163: ; preds = %143, %135, %127, %117
%164 = call i32* @fopen(i8* %26, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %164, i32** %5
%165 = call i32* @fopen(i8* %29, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %165, i32** %6
%166 = load i32*, i32** %6
%167 = icmp eq i32* %166, null
br i1 %167, label %168, label %174
168: ; preds = %163
%169 = load i32, i32* @stderr
%170 = sext i32 %169 to i64
%171 = inttoptr i64 %170 to i32*
%172 = call i32 (i32*, i8*, ...) @fprintf(i32* %171, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i8* %29)
%173 = call i32 @exit(i32 0)
unreachable
174: ; preds = %163
%175 = load i32*, i32** %5
%176 = icmp eq i32* %175, null
br i1 %176, label %177, label %183
177: ; preds = %174
%178 = load i32, i32* @stderr
%179 = sext i32 %178 to i64
%180 = inttoptr i64 %179 to i32*
%181 = call i32 (i32*, i8*, ...) @fprintf(i32* %180, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i8* %26)
%182 = call i32 @exit(i32 0)
unreachable
183: ; preds = %174
store i32 0, i32* %9
store i32 0, i32* %12
br label %184
184: ; preds = %458, %183
%185 = load i32*, i32** %5
%186 = call signext i8 @fgetc(i32* %185)
%187 = load i32, i32* %9
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %188
store i8 %186, i8* %189
%190 = sext i8 %186 to i32
%191 = load i8, i8* @EOF
%192 = sext i8 %191 to i32
%193 = icmp ne i32 %190, %192
br i1 %193, label %194, label %197
194: ; preds = %184
%195 = load i32, i32* %9
%196 = icmp slt i32 %195, 1000
br label %197
197: ; preds = %194, %184
%198 = phi i1 [ false, %184 ], [ %196, %194 ]
br i1 %198, label %199, label %461
199: ; preds = %197
%200 = load i32, i32* %9
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %201
%203 = load i8, i8* %202
%204 = call i64 @isupper(i8 signext %203)
%205 = icmp ne i64 %204, 0
br i1 %205, label %206, label %215
206: ; preds = %199
%207 = load i32, i32* %9
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %208
%210 = load i8, i8* %209
%211 = call signext i8 @tolower(i8 signext %210)
%212 = load i32, i32* %9
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %213
store i8 %211, i8* %214
br label %215
215: ; preds = %206, %199
%216 = load i32, i32* %9
%217 = icmp eq i32 %216, 0
br i1 %217, label %218, label %240
218: ; preds = %215
%219 = load i32, i32* %9
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %220
%222 = load i8, i8* %221
%223 = sext i8 %222 to i32
%224 = icmp eq i32 %223, 32
br i1 %224, label %239, label %225
225: ; preds = %218
%226 = load i32, i32* %9
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %227
%229 = load i8, i8* %228
%230 = sext i8 %229 to i32
%231 = icmp eq i32 %230, 10
br i1 %231, label %239, label %232
232: ; preds = %225
%233 = load i32, i32* %9
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %234
%236 = load i8, i8* %235
%237 = sext i8 %236 to i32
%238 = icmp eq i32 %237, 0
br i1 %238, label %239, label %240
239: ; preds = %232, %225, %218
store i32 -1, i32* %9
br label %240
240: ; preds = %239, %232, %215
%241 = load i32, i32* %9
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %242
%244 = load i8, i8* %243
%245 = sext i8 %244 to i32
%246 = icmp eq i32 %245, 10
br i1 %246, label %254, label %247
247: ; preds = %240
%248 = load i32, i32* %9
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %249
%251 = load i8, i8* %250
%252 = sext i8 %251 to i32
%253 = icmp eq i32 %252, 0
br i1 %253, label %254, label %257
254: ; preds = %247, %240
%255 = load i32, i32* %9
%256 = sub nsw i32 %255, 1
store i32 %256, i32* %9
br label %257
257: ; preds = %254, %247
%258 = load i32, i32* %9
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %259
%261 = load i8, i8* %260
%262 = sext i8 %261 to i32
%263 = icmp eq i32 %262, 59
br i1 %263, label %264, label %458
264: ; preds = %257
%265 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
%266 = load i8, i8* %265
%267 = sext i8 %266 to i32
%268 = icmp eq i32 %267, 97
br i1 %268, label %269, label %457
269: ; preds = %264
%270 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 1
%271 = load i8, i8* %270
%272 = sext i8 %271 to i32
%273 = icmp eq i32 %272, 116
br i1 %273, label %274, label %457
274: ; preds = %269
%275 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 2
%276 = load i8, i8* %275
%277 = sext i8 %276 to i32
%278 = icmp eq i32 %277, 111
br i1 %278, label %279, label %457
279: ; preds = %274
%280 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 3
%281 = load i8, i8* %280
%282 = sext i8 %281 to i32
%283 = icmp eq i32 %282, 109
br i1 %283, label %284, label %457
284: ; preds = %279
%285 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 4
store i8* %285, i8** %20
br label %286
286: ; preds = %301, %284
%287 = load i8*, i8** %20
%288 = load i8, i8* %287
%289 = sext i8 %288 to i32
%290 = icmp eq i32 %289, 32
br i1 %290, label %291, label %302
291: ; preds = %286
%292 = load i8*, i8** %20
%293 = getelementptr inbounds i8, i8* %292, i32 1
store i8* %293, i8** %20
%294 = load i8*, i8** %20
%295 = load i8, i8* %294
%296 = sext i8 %295 to i32
%297 = icmp eq i32 %296, 59
br i1 %297, label %298, label %301
298: ; preds = %291
%299 = load i8*, i8** %20
%300 = getelementptr inbounds i8, i8* %299, i32 -1
store i8* %300, i8** %20
br label %302
301: ; preds = %291
br label %286
302: ; preds = %298, %286
br label %303
303: ; preds = %318, %302
%304 = load i8*, i8** %20
%305 = load i8, i8* %304
%306 = sext i8 %305 to i32
%307 = icmp ne i32 %306, 32
br i1 %307, label %308, label %319
308: ; preds = %303
%309 = load i8*, i8** %20
%310 = getelementptr inbounds i8, i8* %309, i32 1
store i8* %310, i8** %20
%311 = load i8*, i8** %20
%312 = load i8, i8* %311
%313 = sext i8 %312 to i32
%314 = icmp eq i32 %313, 59
br i1 %314, label %315, label %318
315: ; preds = %308
%316 = load i8*, i8** %20
%317 = getelementptr inbounds i8, i8* %316, i32 -1
store i8* %317, i8** %20
br label %319
318: ; preds = %308
br label %303
319: ; preds = %315, %303
br label %320
320: ; preds = %335, %319
%321 = load i8*, i8** %20
%322 = load i8, i8* %321
%323 = sext i8 %322 to i32
%324 = icmp eq i32 %323, 32
br i1 %324, label %325, label %336
325: ; preds = %320
%326 = load i8*, i8** %20
%327 = getelementptr inbounds i8, i8* %326, i32 1
store i8* %327, i8** %20
%328 = load i8*, i8** %20
%329 = load i8, i8* %328
%330 = sext i8 %329 to i32
%331 = icmp eq i32 %330, 59
br i1 %331, label %332, label %335
332: ; preds = %325
%333 = load i8*, i8** %20
%334 = getelementptr inbounds i8, i8* %333, i32 -1
store i8* %334, i8** %20
br label %336
335: ; preds = %325
br label %320
336: ; preds = %332, %320
br label %337
337: ; preds = %352, %336
%338 = load i8*, i8** %20
%339 = load i8, i8* %338
%340 = sext i8 %339 to i32
%341 = icmp ne i32 %340, 32
br i1 %341, label %342, label %353
342: ; preds = %337
%343 = load i8*, i8** %20
%344 = getelementptr inbounds i8, i8* %343, i32 1
store i8* %344, i8** %20
%345 = load i8*, i8** %20
%346 = load i8, i8* %345
%347 = sext i8 %346 to i32
%348 = icmp eq i32 %347, 59
br i1 %348, label %349, label %352
349: ; preds = %342
%350 = load i8*, i8** %20
%351 = getelementptr inbounds i8, i8* %350, i32 -1
store i8* %351, i8** %20
br label %353
352: ; preds = %342
br label %337
353: ; preds = %349, %337
br label %354
354: ; preds = %369, %353
%355 = load i8*, i8** %20
%356 = load i8, i8* %355
%357 = sext i8 %356 to i32
%358 = icmp eq i32 %357, 32
br i1 %358, label %359, label %370
359: ; preds = %354
%360 = load i8*, i8** %20
%361 = getelementptr inbounds i8, i8* %360, i32 1
store i8* %361, i8** %20
%362 = load i8*, i8** %20
%363 = load i8, i8* %362
%364 = sext i8 %363 to i32
%365 = icmp eq i32 %364, 59
br i1 %365, label %366, label %369
366: ; preds = %359
%367 = load i8*, i8** %20
%368 = getelementptr inbounds i8, i8* %367, i32 -1
store i8* %368, i8** %20
br label %370
369: ; preds = %359
br label %354
370: ; preds = %366, %354
br label %371
371: ; preds = %386, %370
%372 = load i8*, i8** %20
%373 = load i8, i8* %372
%374 = sext i8 %373 to i32
%375 = icmp ne i32 %374, 32
br i1 %375, label %376, label %387
376: ; preds = %371
%377 = load i8*, i8** %20
%378 = getelementptr inbounds i8, i8* %377, i32 1
store i8* %378, i8** %20
%379 = load i8*, i8** %20
%380 = load i8, i8* %379
%381 = sext i8 %380 to i32
%382 = icmp eq i32 %381, 59
br i1 %382, label %383, label %386
383: ; preds = %376
%384 = load i8*, i8** %20
%385 = getelementptr inbounds i8, i8* %384, i32 -1
store i8* %385, i8** %20
br label %387
386: ; preds = %376
br label %371
387: ; preds = %383, %371
%388 = load i8*, i8** %20
%389 = getelementptr inbounds [10 x i8], [10 x i8]* %18, i64 0, i64 0
%390 = call i32 (i8*, i8*, ...) @sscanf(i8* %388, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i32* %10, i8* %389)
%391 = getelementptr inbounds [10 x i8], [10 x i8]* %18, i64 0, i64 0
store i8* %391, i8** %21
br label %392
392: ; preds = %404, %387
%393 = load i8*, i8** %21
%394 = load i8, i8* %393
%395 = sext i8 %394 to i32
%396 = icmp ne i32 %395, 46
br i1 %396, label %397, label %402
397: ; preds = %392
%398 = load i8*, i8** %21
%399 = load i8, i8* %398
%400 = sext i8 %399 to i32
%401 = icmp ne i32 %400, 0
br label %402
402: ; preds = %397, %392
%403 = phi i1 [ false, %392 ], [ %401, %397 ]
br i1 %403, label %404, label %407
404: ; preds = %402
%405 = load i8*, i8** %21
%406 = getelementptr inbounds i8, i8* %405, i32 1
store i8* %406, i8** %21
br label %392
407: ; preds = %402
%408 = load i8*, i8** %21
%409 = load i8, i8* %408
%410 = sext i8 %409 to i32
%411 = icmp ne i32 %410, 0
br i1 %411, label %412, label %415
412: ; preds = %407
%413 = load i8*, i8** %21
%414 = getelementptr inbounds i8, i8* %413, i32 1
store i8* %414, i8** %21
br label %415
415: ; preds = %412, %407
%416 = load i8*, i8** %21
%417 = call i64 @strcmp(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i8* %416)
%418 = icmp eq i64 %417, 0
br i1 %418, label %419, label %456
419: ; preds = %415
%420 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 4
store i8* %420, i8** %20
%421 = load i8*, i8** %20
%422 = load i32, i32* %12
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds [3000 x float], [3000 x float]* %13, i64 0, i64 %423
%425 = load i32, i32* %12
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [3000 x float], [3000 x float]* %14, i64 0, i64 %426
%428 = load i32, i32* %12
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds [3000 x float], [3000 x float]* %15, i64 0, i64 %429
%431 = call i32 (i8*, i8*, ...) @sscanf(i8* %421, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), float* %424, float* %427, float* %430)
%432 = load i32, i32* %10
%433 = load i32, i32* %12
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %434
store i32 %432, i32* %435
store i32 0, i32* %10
br label %436
436: ; preds = %450, %419
%437 = load i32, i32* %10
%438 = icmp slt i32 %437, 10
br i1 %438, label %439, label %453
439: ; preds = %436
%440 = load i32, i32* %10
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds [10 x i8], [10 x i8]* %18, i64 0, i64 %441
%443 = load i8, i8* %442
%444 = load i32, i32* %12
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [3000 x [10 x i8]], [3000 x [10 x i8]]* %16, i64 0, i64 %445
%447 = load i32, i32* %10
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds [10 x i8], [10 x i8]* %446, i64 0, i64 %448
store i8 %443, i8* %449
br label %450
450: ; preds = %439
%451 = load i32, i32* %10
%452 = add nsw i32 %451, 1
store i32 %452, i32* %10
br label %436
453: ; preds = %436
%454 = load i32, i32* %12
%455 = add nsw i32 %454, 1
store i32 %455, i32* %12
br label %456
456: ; preds = %453, %415
br label %457
457: ; preds = %456, %279, %274, %269, %264
store i32 -1, i32* %9
br label %458
458: ; preds = %457, %257
%459 = load i32, i32* %9
%460 = add nsw i32 %459, 1
store i32 %460, i32* %9
br label %184
461: ; preds = %197
%462 = load i32*, i32** %6
%463 = call i32 (i32*, i8*, ...) @fprintf(i32* %462, i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.6, i64 0, i64 0))
%464 = load i32*, i32** %6
%465 = call i32 (i32*, i8*, ...) @fprintf(i32* %464, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.7, i64 0, i64 0))
%466 = load i32*, i32** %6
%467 = getelementptr inbounds [3000 x float], [3000 x float]* %13, i64 0, i64 0
%468 = load float, float* %467
%469 = fpext float %468 to double
%470 = getelementptr inbounds [3000 x float], [3000 x float]* %14, i64 0, i64 0
%471 = load float, float* %470
%472 = fpext float %471 to double
%473 = getelementptr inbounds [3000 x float], [3000 x float]* %15, i64 0, i64 0
%474 = load float, float* %473
%475 = fpext float %474 to double
%476 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 0
%477 = load i32, i32* %476
%478 = getelementptr inbounds [3000 x [10 x i8]], [3000 x [10 x i8]]* %16, i64 0, i64 0
%479 = getelementptr inbounds [10 x i8], [10 x i8]* %478, i64 0, i64 0
%480 = call i32 (i32*, i8*, ...) @fprintf(i32* %466, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.8, i64 0, i64 0), double %469, double %472, double %475, i32 %477, i8* %479)
%481 = load i32*, i32** %6
%482 = getelementptr inbounds [3000 x float], [3000 x float]* %13, i64 0, i64 1
%483 = load float, float* %482
%484 = fpext float %483 to double
%485 = getelementptr inbounds [3000 x float], [3000 x float]* %14, i64 0, i64 1
%486 = load float, float* %485
%487 = fpext float %486 to double
%488 = getelementptr inbounds [3000 x float], [3000 x float]* %15, i64 0, i64 1
%489 = load float, float* %488
%490 = fpext float %489 to double
%491 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 1
%492 = load i32, i32* %491
%493 = getelementptr inbounds [3000 x [10 x i8]], [3000 x [10 x i8]]* %16, i64 0, i64 1
%494 = getelementptr inbounds [10 x i8], [10 x i8]* %493, i64 0, i64 0
%495 = call i32 (i32*, i8*, ...) @fprintf(i32* %481, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.8, i64 0, i64 0), double %484, double %487, double %490, i32 %492, i8* %494)
%496 = load i32*, i32** %6
%497 = getelementptr inbounds [3000 x float], [3000 x float]* %13, i64 0, i64 2
%498 = load float, float* %497
%499 = fpext float %498 to double
%500 = getelementptr inbounds [3000 x float], [3000 x float]* %14, i64 0, i64 3
%501 = load float, float* %500
%502 = fpext float %501 to double
%503 = getelementptr inbounds [3000 x float], [3000 x float]* %15, i64 0, i64 2
%504 = load float, float* %503
%505 = fpext float %504 to double
%506 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 2
%507 = load i32, i32* %506
%508 = getelementptr inbounds [3000 x [10 x i8]], [3000 x [10 x i8]]* %16, i64 0, i64 2
%509 = getelementptr inbounds [10 x i8], [10 x i8]* %508, i64 0, i64 0
%510 = call i32 (i32*, i8*, ...) @fprintf(i32* %496, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.8, i64 0, i64 0), double %499, double %502, double %505, i32 %507, i8* %509)
%511 = load i32*, i32** %6
%512 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 0
%513 = load i32, i32* %512
%514 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 1
%515 = load i32, i32* %514
%516 = call i32 (i32*, i8*, ...) @fprintf(i32* %511, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0), i32 %513, i32 %515)
%517 = load i32*, i32** %6
%518 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 1
%519 = load i32, i32* %518
%520 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 2
%521 = load i32, i32* %520
%522 = call i32 (i32*, i8*, ...) @fprintf(i32* %517, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0), i32 %519, i32 %521)
%523 = load i32*, i32** %6
%524 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 0
%525 = load i32, i32* %524
%526 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 1
%527 = load i32, i32* %526
%528 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 2
%529 = load i32, i32* %528
%530 = call i32 (i32*, i8*, ...) @fprintf(i32* %523, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i32 %525, i32 %527, i32 %529)
store i32 0, i32* %10
br label %531
531: ; preds = %659, %461
%532 = load i32, i32* %10
%533 = load i32, i32* %12
%534 = sub nsw i32 %533, 3
%535 = icmp slt i32 %532, %534
br i1 %535, label %536, label %662
536: ; preds = %531
%537 = load i32*, i32** %6
%538 = load i32, i32* %10
%539 = add nsw i32 %538, 3
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds [3000 x float], [3000 x float]* %13, i64 0, i64 %540
%542 = load float, float* %541
%543 = fpext float %542 to double
%544 = load i32, i32* %10
%545 = add nsw i32 %544, 3
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds [3000 x float], [3000 x float]* %14, i64 0, i64 %546
%548 = load float, float* %547
%549 = fpext float %548 to double
%550 = load i32, i32* %10
%551 = add nsw i32 %550, 3
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds [3000 x float], [3000 x float]* %15, i64 0, i64 %552
%554 = load float, float* %553
%555 = fpext float %554 to double
%556 = load i32, i32* %10
%557 = add nsw i32 %556, 3
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %558
%560 = load i32, i32* %559
%561 = load i32, i32* %10
%562 = add nsw i32 %561, 3
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds [3000 x [10 x i8]], [3000 x [10 x i8]]* %16, i64 0, i64 %563
%565 = getelementptr inbounds [10 x i8], [10 x i8]* %564, i64 0, i64 0
%566 = call i32 (i32*, i8*, ...) @fprintf(i32* %537, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.8, i64 0, i64 0), double %543, double %549, double %555, i32 %560, i8* %565)
%567 = load i32*, i32** %6
%568 = load i32, i32* %10
%569 = add nsw i32 %568, 2
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %570
%572 = load i32, i32* %571
%573 = load i32, i32* %10
%574 = add nsw i32 %573, 3
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %575
%577 = load i32, i32* %576
%578 = call i32 (i32*, i8*, ...) @fprintf(i32* %567, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.9, i64 0, i64 0), i32 %572, i32 %577)
%579 = load i32*, i32** %6
%580 = load i32, i32* %10
%581 = add nsw i32 %580, 1
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %582
%584 = load i32, i32* %583
%585 = load i32, i32* %10
%586 = add nsw i32 %585, 2
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %587
%589 = load i32, i32* %588
%590 = load i32, i32* %10
%591 = add nsw i32 %590, 3
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %592
%594 = load i32, i32* %593
%595 = call i32 (i32*, i8*, ...) @fprintf(i32* %579, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.10, i64 0, i64 0), i32 %584, i32 %589, i32 %594)
%596 = load i32*, i32** %6
%597 = load i32, i32* %10
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %598
%600 = load i32, i32* %599
%601 = load i32, i32* %10
%602 = add nsw i32 %601, 1
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %603
%605 = load i32, i32* %604
%606 = load i32, i32* %10
%607 = add nsw i32 %606, 2
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %608
%610 = load i32, i32* %609
%611 = load i32, i32* %10
%612 = add nsw i32 %611, 3
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %613
%615 = load i32, i32* %614
%616 = call i32 (i32*, i8*, ...) @fprintf(i32* %596, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.11, i64 0, i64 0), i32 %600, i32 %605, i32 %610, i32 %615)
%617 = load i32*, i32** %6
%618 = load i32, i32* %10
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %619
%621 = load i32, i32* %620
%622 = load i32, i32* %10
%623 = add nsw i32 %622, 1
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %624
%626 = load i32, i32* %625
%627 = load i32, i32* %10
%628 = add nsw i32 %627, 2
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %629
%631 = load i32, i32* %630
%632 = load i32, i32* %10
%633 = add nsw i32 %632, 3
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %634
%636 = load i32, i32* %635
%637 = call i32 (i32*, i8*, ...) @fprintf(i32* %617, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.12, i64 0, i64 0), i32 %621, i32 %626, i32 %631, i32 %636)
%638 = load i32*, i32** %6
%639 = load i32, i32* %10
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %640
%642 = load i32, i32* %641
%643 = load i32, i32* %10
%644 = add nsw i32 %643, 1
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %645
%647 = load i32, i32* %646
%648 = load i32, i32* %10
%649 = add nsw i32 %648, 2
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %650
%652 = load i32, i32* %651
%653 = load i32, i32* %10
%654 = add nsw i32 %653, 3
%655 = sext i32 %654 to i64
%656 = getelementptr inbounds [3000 x i32], [3000 x i32]* %17, i64 0, i64 %655
%657 = load i32, i32* %656
%658 = call i32 (i32*, i8*, ...) @fprintf(i32* %638, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.13, i64 0, i64 0), i32 %642, i32 %647, i32 %652, i32 %657)
br label %659
659: ; preds = %536
%660 = load i32, i32* %10
%661 = add nsw i32 %660, 1
store i32 %661, i32* %10
br label %531
662: ; preds = %531
%663 = call i32 @exit(i32 0)
unreachable
}

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