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

/* Forward declarations */

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

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, char *, float, char *,
                           char *, char *, char *, char *, char *, float, float,
                           ...);
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/ *);
int /*<<< orphan*/ gets(char *);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ sprintf(char *, char *, char *, float, char *, char *,
                           char *, char *, char *, char *, float, float);
int /*<<< orphan*/ sscanf(char *, char *, char *, int *, float *, char *,
                          char *, char *, char *, char *, char *, float *,
                          float *);
int /*<<< orphan*/ strcpy(char *, char *);
int main(int argc, char *argv[]) {
  int i;
  int compno, compno2;
  float flux[25];
  float flux2;
  float highflux, secflux;
  float fratio;
  float maj, ratio, phi;
  float maj2, ratio2;
  float minor;
  char source[1000];
  char source2[1000];
  char hr[1000], min[1000], sec[1000];
  char deg[1000], amin[1000], asec[1000];
  char hr2[1000], min2[1000], sec2[1000];
  char deg2[1000], amin2[1000], asec2[1000];
  char line[1000];
  char outname[1000];
  FILE *ifp;
  FILE *ofp;
  compno = 0;
  ifp = fopen(argv[1], "r");
  printf("\n Enter the name of the output file:  ");
  gets(outname);
  ofp = fopen(outname, "w");
  fputs("Source   Flux (mJy)    RA (2000)     Dec (2000)    Size(mas)\n", ofp);
  fputs("-------  ---------- -------------  -------------  ---------\n", ofp);
  while (fgets(line, 1000, ifp) != NULL) {
    maj2 = ratio = 0;
    sscanf(line, "%s %d %f %s %s %s %s %s %s %f %f", source2, &compno2, &flux2,
           hr2, min2, sec2, deg2, amin2, asec2, &maj2, &ratio2);
    if (compno2 == 1) {
      if (compno == 1) {
        sprintf(
            line,
            "%s %6.1f     %s %s %s  %s %s %s %5.0f x %-5.0f (one component)\n",
            source, highflux, hr, min, sec, deg, amin, asec, maj, minor);
        fputs(line, ofp);
      } else if (compno > 1) {
        secflux = 0;
        for (i = 0; i < compno; i++)
          if (flux[i] != highflux && flux[i] > secflux) {
            fratio = highflux / flux[i];
            secflux = flux[i];
          }
        fprintf(
            ofp,
            "%s %6.1f     %s %s %s  %s %s %s %5.0f x %-5.0f (%3.0f:1 double)\n",
            source, highflux, hr, min, sec, deg, amin, asec, maj, minor,
            fratio);
      }
      highflux = flux2;
      strcpy(hr, hr2);
      strcpy(min, min2);
      strcpy(sec, sec2);
      strcpy(deg, deg2);
      strcpy(amin, amin2);
      strcpy(asec, asec2);
      maj = maj2;
      minor = maj2 * ratio2;
      strcpy(source, source2);
    } else if (flux2 > highflux) {
      highflux = flux2;
      strcpy(hr, hr2);
      strcpy(min, min2);
      strcpy(sec, sec2);
      strcpy(deg, deg2);
      strcpy(amin, amin2);
      strcpy(asec, asec2);
      maj = maj2;
      minor = maj2 * ratio2;
    }
    flux[compno2 - 1] = flux2;
    compno = compno2;
  }
  if (compno == 1) {
    fprintf(ofp,
            "%s %6.1f     %s %s %s  %s %s %s %5.0f x %-5.0f (one component)\n",
            source, highflux, hr, min, sec, deg, amin, asec, maj, minor);
  } else if (compno > 1) {
    secflux = 0;
    for (i = 0; i < compno; i++)
      if (flux[i] != highflux && flux[i] > secflux) {
        fratio = highflux / flux[i];
        secflux = flux[i];
      }
    fprintf(ofp,
            "%s %6.1f     %s %s %s  %s %s %s %5.0f x %-5.0f (%3.0f:1 double)\n",
            source, highflux, hr, min, sec, deg, amin, asec, maj, minor,
            fratio);
  }
  fclose(ifp);
  fclose(ofp);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x3ff0,%rsp
movl   $0x0,-0x24(%rbp)
mov    %edi,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe2a(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x3fc8(%rbp)
lea    0xe19(%rip),%rdi
call   1050 <printf@plt>
lea    -0x3fc0(%rbp),%rdi
call   1090 <gets@plt>
lea    -0x3fc0(%rbp),%rdi
lea    0xe21(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x3fd0(%rbp)
mov    -0x3fd0(%rbp),%rsi
lea    0xe09(%rip),%rdi
call   1060 <fputs@plt>
mov    -0x3fd0(%rbp),%rsi
lea    0xe34(%rip),%rdi
call   1060 <fputs@plt>
lea    -0x3bd0(%rbp),%rdi
mov    -0x3fc8(%rbp),%rdx
mov    $0x3e8,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     165a <main+0x4ba>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
lea    -0x3bd0(%rbp),%rdi
lea    -0x8a0(%rbp),%rdx
lea    -0x2430(%rbp),%r9
lea    -0x2820(%rbp),%r12
lea    -0x2c10(%rbp),%r15
lea    -0x3000(%rbp),%r14
lea    -0x33f0(%rbp),%rbx
lea    -0x37e0(%rbp),%r11
lea    0xdf5(%rip),%rsi
lea    -0x3c(%rbp),%rcx
lea    -0xa4(%rbp),%r8
lea    -0xc0(%rbp),%r10
lea    -0xc4(%rbp),%rax
mov    %r12,(%rsp)
mov    %r15,0x8(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x18(%rsp)
mov    %r11,0x20(%rsp)
mov    %r10,0x28(%rsp)
mov    %rax,0x30(%rsp)
call   10a0 <sscanf@plt>
cmpl   $0x1,-0x3c(%rbp)
jne    1572 <main+0x3d2>
cmpl   $0x1,-0x38(%rbp)
jne    1387 <main+0x1e7>
lea    -0x3bd0(%rbp),%rdi
lea    -0x4b0(%rbp),%rdx
movss  -0xa8(%rbp),%xmm0
ff
lea    -0xc90(%rbp),%rcx
lea    -0x1080(%rbp),%r8
lea    -0x1470(%rbp),%r9
lea    -0x1860(%rbp),%r11
lea    -0x1c50(%rbp),%r10
lea    -0x2040(%rbp),%rax
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
lea    0xd6b(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   10c0 <sprintf@plt>
lea    -0x3bd0(%rbp),%rdi
mov    -0x3fd0(%rbp),%rsi
call   1060 <fputs@plt>
jmp    14b0 <main+0x310>
cmpl   $0x1,-0x38(%rbp)
jle    14ab <main+0x30b>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1433 <main+0x293>
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0xa8(%rbp),%xmm0
jne    13d4 <main+0x234>
jp     13d4 <main+0x234>
jmp    1420 <main+0x280>
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0xac(%rbp),%xmm0
jbe    1420 <main+0x280>
movss  -0xa8(%rbp),%xmm0
ff
movslq -0x34(%rbp),%rax
divss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xb0(%rbp)
ff
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xac(%rbp)
ff
jmp    1425 <main+0x285>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a3 <main+0x203>
mov    -0x3fd0(%rbp),%rdi
lea    -0x4b0(%rbp),%rdx
movss  -0xa8(%rbp),%xmm0
ff
lea    -0xc90(%rbp),%rcx
lea    -0x1080(%rbp),%r8
lea    -0x1470(%rbp),%r9
lea    -0x1860(%rbp),%r11
lea    -0x1c50(%rbp),%r10
lea    -0x2040(%rbp),%rax
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
movss  -0xb0(%rbp),%xmm3
ff
cvtss2sd %xmm3,%xmm3
lea    0xc71(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x4,%al
call   1080 <fprintf@plt>
jmp    14b0 <main+0x310>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
lea    -0xc90(%rbp),%rdi
lea    -0x2430(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1080(%rbp),%rdi
lea    -0x2820(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1470(%rbp),%rdi
lea    -0x2c10(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1860(%rbp),%rdi
lea    -0x3000(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1c50(%rbp),%rdi
lea    -0x33f0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x2040(%rbp),%rdi
lea    -0x37e0(%rbp),%rsi
call   1030 <strcpy@plt>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
mulss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
lea    -0x4b0(%rbp),%rdi
lea    -0x8a0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    1636 <main+0x496>
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa8(%rbp),%xmm0
jbe    1631 <main+0x491>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
lea    -0xc90(%rbp),%rdi
lea    -0x2430(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1080(%rbp),%rdi
lea    -0x2820(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1470(%rbp),%rdi
lea    -0x2c10(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1860(%rbp),%rdi
lea    -0x3000(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1c50(%rbp),%rdi
lea    -0x33f0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x2040(%rbp),%rdi
lea    -0x37e0(%rbp),%rsi
call   1030 <strcpy@plt>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
mulss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xc8(%rbp)
ff
jmp    1636 <main+0x496>
movss  -0xa4(%rbp),%xmm0
ff
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
cltq
movss  %xmm0,-0xa0(%rbp,%rax,4)
ff ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    123a <main+0x9a>
cmpl   $0x1,-0x38(%rbp)
jne    16d5 <main+0x535>
mov    -0x3fd0(%rbp),%rdi
lea    -0x4b0(%rbp),%rdx
movss  -0xa8(%rbp),%xmm0
ff
lea    -0xc90(%rbp),%rcx
lea    -0x1080(%rbp),%r8
lea    -0x1470(%rbp),%r9
lea    -0x1860(%rbp),%r11
lea    -0x1c50(%rbp),%r10
lea    -0x2040(%rbp),%rax
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
lea    0xa0c(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x3,%al
call   1080 <fprintf@plt>
jmp    17fe <main+0x65e>
cmpl   $0x1,-0x38(%rbp)
jle    17f9 <main+0x659>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1781 <main+0x5e1>
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0xa8(%rbp),%xmm0
jne    1722 <main+0x582>
jp     1722 <main+0x582>
jmp    176e <main+0x5ce>
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
ucomiss -0xac(%rbp),%xmm0
jbe    176e <main+0x5ce>
movss  -0xa8(%rbp),%xmm0
ff
movslq -0x34(%rbp),%rax
divss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xb0(%rbp)
ff
movslq -0x34(%rbp),%rax
movss  -0xa0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xac(%rbp)
ff
jmp    1773 <main+0x5d3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16f1 <main+0x551>
mov    -0x3fd0(%rbp),%rdi
lea    -0x4b0(%rbp),%rdx
movss  -0xa8(%rbp),%xmm0
ff
lea    -0xc90(%rbp),%rcx
lea    -0x1080(%rbp),%r8
lea    -0x1470(%rbp),%r9
lea    -0x1860(%rbp),%r11
lea    -0x1c50(%rbp),%r10
lea    -0x2040(%rbp),%rax
movss  -0xb4(%rbp),%xmm1
ff
movss  -0xc8(%rbp),%xmm2
ff
movss  -0xb0(%rbp),%xmm3
ff
cvtss2sd %xmm3,%xmm3
lea    0x923(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x4,%al
call   1080 <fprintf@plt>
jmp    17fe <main+0x65e>
mov    -0x3fc8(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x3fd0(%rbp),%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x3ff0,%rsp
pop    %rbx
pop    %r12
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    $0x3fa8,%rsp
mov    0x8(%rsi),%rdi
lea    0xe34(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,%rbp
lea    0xe27(%rip),%rdi
call   1050 <printf@plt>
lea    0x3bc0(%rsp),%rbx
mov    %rbx,%rdi
call   1090 <gets@plt>
lea    0xe32(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <fopen@plt>
mov    %rax,%r15
lea    0xe22(%rip),%rdi
mov    $0x3d,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   10d0 <fwrite@plt>
lea    0xe47(%rip),%rdi
mov    $0x3c,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   10d0 <fwrite@plt>
lea    0x33e0(%rsp),%rdi
mov    $0x3e8,%esi
mov    %rbp,0x28(%rsp)
mov    %rbp,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     17f2 <main+0x642>
mov    %r15,0x20(%rsp)
xor    %r14d,%r14d
lea    0x10(%rsp),%rbp
lea    0x33e0(%rsp),%r15
lea    0x2ff0(%rsp),%rbx
jmp    13ca <main+0x21a>
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    %r15,%rdi
lea    0xe39(%rip),%rsi
lea    0x1468(%rsp),%r13
mov    %r13,%rdx
movss  0x14(%rsp),%xmm0
lea    0xb8(%rsp),%rcx
lea    0x4a8(%rsp),%r8
lea    0x1078(%rsp),%r9
movss  0xc(%rsp),%xmm1
movss  0x10(%rsp),%xmm2
lea    0x898(%rsp),%r14
push   %r14
push   %rbx
lea    0xc98(%rsp),%r12
push   %r12
call   10c0 <sprintf@plt>
add    $0x20,%rsp
mov    %r15,%rdi
mov    0x20(%rsp),%rsi
call   1060 <fputs@plt>
lea    0xb0(%rsp),%rdi
lea    0x4a0(%rsp),%rbp
movss  0x18(%rsp),%xmm0
movss  %xmm0,0xc(%rsp)
lea    0x2c00(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %rbp,%rdi
lea    0x2810(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0x1070(%rsp),%rdi
lea    0x2420(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %r12,%rdi
lea    0x2030(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %rbx,%rdi
lea    0x1c40(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %r14,%rdi
lea    0x1850(%rsp),%rsi
call   1030 <strcpy@plt>
movss  0x14(%rsp),%xmm1
movss  0x10(%rsp),%xmm0
movss  %xmm1,0x4(%rsp)
mulss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
mov    %r13,%rdi
lea    0x37d0(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0x10(%rsp),%rbp
movss  0x18(%rsp),%xmm0
movslq 0x1c(%rsp),%r14
movss  %xmm0,0x3c(%rsp,%r14,4)
mov    %r15,%rdi
mov    $0x3e8,%esi
mov    0x28(%rsp),%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     1660 <main+0x4b0>
movl   $0x0,0x14(%rsp)
sub    $0x8,%rsp
mov    %r15,%rdi
lea    0xcc6(%rip),%rsi
lea    0x37d8(%rsp),%rdx
lea    0x24(%rsp),%rcx
lea    0x20(%rsp),%r8
lea    0x2c08(%rsp),%r9
push   %rbp
lea    0x24(%rsp),%rax
push   %rax
lea    0x1868(%rsp),%rax
push   %rax
lea    0x1c60(%rsp),%rax
push   %rax
lea    0x2058(%rsp),%rax
push   %rax
lea    0x2450(%rsp),%rax
push   %rax
lea    0x2848(%rsp),%rax
push   %rax
call   10a0 <sscanf@plt>
add    $0x40,%rsp
cmpl   $0x1,0x1c(%rsp)
jne    14f0 <main+0x340>
cmp    $0x1,%r14d
je     1280 <main+0xd0>
jle    15a1 <main+0x3f1>
mov    %r14d,%esi
lea    0x0(,%rsi,4),%rdx
and    $0xfffffffffffffff8,%rdx
xorps  %xmm4,%xmm4
xor    %ecx,%ecx
lea    0x890(%rsp),%r14
lea    0xc80(%rsp),%r12
movaps 0x30(%rsp),%xmm3
movss  0xc(%rsp),%xmm0
jmp    14a0 <main+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movaps %xmm1,%xmm4
add    $0x8,%rcx
cmp    %rcx,%rdx
je     15be <main+0x40e>
movss  0x40(%rsp,%rcx,1),%xmm1
ucomiss %xmm1,%xmm0
setp   %bl
setne  %al
or     %bl,%al
ucomiss %xmm4,%xmm1
seta   %bl
test   %bl,%al
jne    14c0 <main+0x310>
movaps %xmm4,%xmm1
jmp    14c7 <main+0x317>
movaps %xmm0,%xmm3
divss  %xmm1,%xmm3
movss  0x44(%rsp,%rcx,1),%xmm4
ucomiss %xmm4,%xmm0
setp   %al
setne  %bl
or     %al,%bl
ucomiss %xmm1,%xmm4
seta   %al
test   %al,%bl
je     1490 <main+0x2e0>
movaps %xmm0,%xmm3
divss  %xmm4,%xmm3
jmp    1493 <main+0x2e3>
nopl   0x0(%rax,%rax,1)
movss  0x18(%rsp),%xmm0
ucomiss 0xc(%rsp),%xmm0
jbe    139d <main+0x1ed>
lea    0xb0(%rsp),%rdi
lea    0x2c00(%rsp),%rsi
movss  %xmm0,0xc(%rsp)
call   1030 <strcpy@plt>
lea    0x4a0(%rsp),%rdi
lea    0x2810(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0x1070(%rsp),%rdi
lea    0x2420(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0xc80(%rsp),%rdi
lea    0x2030(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %rbx,%rdi
lea    0x1c40(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0x890(%rsp),%rdi
lea    0x1850(%rsp),%rsi
call   1030 <strcpy@plt>
movss  0x14(%rsp),%xmm1
movss  0x10(%rsp),%xmm0
movss  %xmm1,0x4(%rsp)
mulss  %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
jmp    139d <main+0x1ed>
lea    0x890(%rsp),%r14
lea    0xc80(%rsp),%r12
lea    0x1460(%rsp),%r13
jmp    12ee <main+0x13e>
test   $0x1,%sil
lea    0x4a0(%rsp),%rbp
je     15f8 <main+0x448>
movss  0x40(%rsp,%rcx,1),%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
cmpltss %xmm1,%xmm4
andps  %xmm4,%xmm2
andnps %xmm3,%xmm4
orps   %xmm2,%xmm4
cmpneqss %xmm0,%xmm1
andps  %xmm1,%xmm4
andnps %xmm3,%xmm1
orps   %xmm4,%xmm1
movaps %xmm1,%xmm3
movss  0x8(%rsp),%xmm2
movss  0x4(%rsp),%xmm1
lea    0x1460(%rsp),%rdx
movaps %xmm3,0x30(%rsp)
cvtss2sd %xmm3,%xmm3
sub    $0x8,%rsp
mov    0x28(%rsp),%rdi
lea    0xae2(%rip),%rsi
mov    %rdx,%r13
lea    0xb8(%rsp),%rcx
mov    %rbp,%r8
lea    0x1078(%rsp),%r9
mov    $0x4,%al
push   %r14
lea    0x3000(%rsp),%rbx
push   %rbx
push   %r12
call   1080 <fprintf@plt>
lea    0xd0(%rsp),%rdi
add    $0x20,%rsp
jmp    12fe <main+0x14e>
cmp    $0x1,%r14d
jne    16ca <main+0x51a>
sub    $0x8,%rsp
lea    0xa56(%rip),%rsi
lea    0x1468(%rsp),%rdx
lea    0xb8(%rsp),%rcx
lea    0x4a8(%rsp),%r8
lea    0x1078(%rsp),%r9
mov    0x28(%rsp),%r15
mov    %r15,%rdi
movss  0x14(%rsp),%xmm0
movss  0xc(%rsp),%xmm1
movss  0x10(%rsp),%xmm2
mov    $0x3,%al
lea    0x898(%rsp),%rbp
push   %rbp
push   %rbx
lea    0xc98(%rsp),%rbp
push   %rbp
call   1080 <fprintf@plt>
jmp    17ee <main+0x63e>
mov    0x20(%rsp),%r15
movss  0xc(%rsp),%xmm0
jle    17f2 <main+0x642>
mov    %r14d,%esi
lea    0x0(,%rsi,4),%rdx
and    $0xfffffffffffffff8,%rdx
xorps  %xmm4,%xmm4
xor    %ecx,%ecx
lea    0x890(%rsp),%rbp
lea    0xc80(%rsp),%r10
movaps 0x30(%rsp),%xmm3
jmp    171c <main+0x56c>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm1,%xmm4
add    $0x8,%rcx
cmp    %rcx,%rdx
je     176b <main+0x5bb>
movss  0x40(%rsp,%rcx,1),%xmm1
ucomiss %xmm1,%xmm0
setp   %bl
setne  %al
or     %bl,%al
ucomiss %xmm4,%xmm1
seta   %bl
test   %bl,%al
jne    1740 <main+0x590>
movaps %xmm4,%xmm1
jmp    1747 <main+0x597>
nopl   0x0(%rax)
movaps %xmm0,%xmm3
divss  %xmm1,%xmm3
movss  0x44(%rsp,%rcx,1),%xmm4
ucomiss %xmm4,%xmm0
setp   %al
setne  %bl
or     %al,%bl
ucomiss %xmm1,%xmm4
seta   %al
test   %al,%bl
je     1710 <main+0x560>
movaps %xmm0,%xmm3
divss  %xmm4,%xmm3
jmp    1713 <main+0x563>
test   $0x1,%sil
je     179d <main+0x5ed>
movss  0x40(%rsp,%rcx,1),%xmm1
movaps %xmm0,%xmm2
divss  %xmm1,%xmm2
cmpltss %xmm1,%xmm4
andps  %xmm4,%xmm2
andnps %xmm3,%xmm4
orps   %xmm2,%xmm4
cmpneqss %xmm0,%xmm1
andps  %xmm1,%xmm4
andnps %xmm3,%xmm1
orps   %xmm4,%xmm1
movaps %xmm1,%xmm3
cvtss2sd %xmm3,%xmm3
sub    $0x8,%rsp
lea    0x95b(%rip),%rsi
lea    0x1468(%rsp),%rdx
lea    0xb8(%rsp),%rcx
lea    0x4a8(%rsp),%r8
lea    0x1078(%rsp),%r9
mov    %r15,%rdi
movss  0xc(%rsp),%xmm1
movss  0x10(%rsp),%xmm2
mov    $0x4,%al
push   %rbp
lea    0x3000(%rsp),%rbp
push   %rbp
push   %r10
call   1080 <fprintf@plt>
add    $0x20,%rsp
mov    0x28(%rsp),%rdi
call   1040 <fclose@plt>
mov    %r15,%rdi
call   1040 <fclose@plt>
xor    %eax,%eax
add    $0x3fa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@.str.1 = [39 x i8] c"\0A Enter the name of the output file: \00"
@.str.2 = [2 x i8] c"w\00"
@.str.3 = [62 x i8] c"Source Flux (mJy) RA (2000) Dec (2000) Size(mas)\0A\00"
@.str.4 = [61 x i8] c"------- ---------- ------------- ------------- ---------\0A\00"
@.str.5 = [33 x i8] c"%s %d %f %s %s %s %s %s %s %f %f\00"
@.str.6 = [64 x i8] c"%s %6.1f %s %s %s %s %s %s %5.0f x %-5.0f (one component)\0A\00"
@.str.7 = [65 x i8] c"%s %6.1f %s %s %s %s %s %s %5.0f x %-5.0f (%3.0f:1 double)\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca i32
%4 = alloca [25 x float]
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca [1000 x i8]
%9 = alloca [1000 x i8]
%10 = alloca [1000 x i8]
%11 = alloca [1000 x i8]
%12 = alloca [1000 x i8]
%13 = alloca [1000 x i8]
%14 = alloca [1000 x i8]
%15 = alloca [1000 x i8]
%16 = alloca [1000 x i8]
%17 = alloca [1000 x i8]
%18 = alloca [1000 x i8]
%19 = alloca [1000 x i8]
%20 = alloca [1000 x i8]
%21 = alloca [1000 x i8]
%22 = alloca [1000 x i8]
%23 = alloca [1000 x i8]
%24 = bitcast i32* %3 to i8*
%25 = bitcast [25 x float]* %4 to i8*
%26 = bitcast float* %5 to i8*
%27 = bitcast float* %6 to i8*
%28 = bitcast float* %7 to i8*
%29 = getelementptr inbounds [1000 x i8], [1000 x i8]* %8, i64 0, i64 0
%30 = getelementptr inbounds [1000 x i8], [1000 x i8]* %9, i64 0, i64 0
%31 = getelementptr inbounds [1000 x i8], [1000 x i8]* %10, i64 0, i64 0
%32 = getelementptr inbounds [1000 x i8], [1000 x i8]* %11, i64 0, i64 0
%33 = getelementptr inbounds [1000 x i8], [1000 x i8]* %12, i64 0, i64 0
%34 = getelementptr inbounds [1000 x i8], [1000 x i8]* %13, i64 0, i64 0
%35 = getelementptr inbounds [1000 x i8], [1000 x i8]* %14, i64 0, i64 0
%36 = getelementptr inbounds [1000 x i8], [1000 x i8]* %15, i64 0, i64 0
%37 = getelementptr inbounds [1000 x i8], [1000 x i8]* %16, i64 0, i64 0
%38 = getelementptr inbounds [1000 x i8], [1000 x i8]* %17, i64 0, i64 0
%39 = getelementptr inbounds [1000 x i8], [1000 x i8]* %18, i64 0, i64 0
%40 = getelementptr inbounds [1000 x i8], [1000 x i8]* %19, i64 0, i64 0
%41 = getelementptr inbounds [1000 x i8], [1000 x i8]* %20, i64 0, i64 0
%42 = getelementptr inbounds [1000 x i8], [1000 x i8]* %21, i64 0, i64 0
%43 = getelementptr inbounds [1000 x i8], [1000 x i8]* %22, i64 0, i64 0
%44 = getelementptr inbounds [1000 x i8], [1000 x i8]* %23, i64 0, i64 0
%45 = getelementptr inbounds i8*, i8** %1, i64 1
%46 = load i8*, i8** %45
%47 = tail call i32* @fopen(i8* %46, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%48 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.1, i64 0, i64 0))
%49 = call i32 @gets(i8* %44)
%50 = call i32* @fopen(i8* %44, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%51 = call i64 @fwrite(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.3, i64 0, i64 0), i64 61, i64 1, i32* %50)
%52 = call i64 @fwrite(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str.4, i64 0, i64 0), i64 60, i64 1, i32* %50)
%53 = call i32* @fgets(i8* %43, i32 1000, i32* %47)
%54 = icmp eq i32* %53, null
br i1 %54, label %201, label %55
55: ; preds = %2, %140
%56 = phi i32 [ %146, %140 ], [ 0, %2 ]
%57 = phi float [ %144, %140 ], [ undef, %2 ]
%58 = phi float [ %143, %140 ], [ undef, %2 ]
%59 = phi float [ %142, %140 ], [ undef, %2 ]
%60 = phi float [ %141, %140 ], [ undef, %2 ]
store float 0.000000e+00, float* %6
%61 = call i32 @sscanf(i8* %43, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.5, i64 0, i64 0), i8* %30, i32* %3, float* %5, i8* %37, i8* %38, i8* %39, i8* %40, i8* %41, i8* %42, float* %6, float* %7)
%62 = load i32, i32* %3
%63 = icmp eq i32 %62, 1
br i1 %63, label %64, label %127
64: ; preds = %55
%65 = icmp eq i32 %56, 1
br i1 %65, label %66, label %69
66: ; preds = %64
%67 = call i32 @sprintf(i8* %43, i8* dereferenceable(1) getelementptr inbounds ([64 x i8], [64 x i8]* @.str.6, i64 0, i64 0), i8* %29, float %58, i8* %31, i8* %32, i8* %33, i8* %34, i8* %35, i8* %36, float %59, float %57)
%68 = call i32 @fputs(i8* %43, i32* %50)
br label %114
69: ; preds = %64
%70 = icmp sgt i32 %56, 1
br i1 %70, label %71, label %114
71: ; preds = %69
%72 = zext i32 %56 to i64
%73 = and i64 %72, 1
%74 = and i64 %72, 4294967294
br label %75
75: ; preds = %75, %71
%76 = phi i64 [ 0, %71 ], [ %97, %75 ]
%77 = phi float [ 0.000000e+00, %71 ], [ %96, %75 ]
%78 = phi float [ %60, %71 ], [ %95, %75 ]
%79 = phi i64 [ 0, %71 ], [ %98, %75 ]
%80 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %76
%81 = load float, float* %80
%82 = fcmp une float %81, %58
%83 = fcmp ogt float %81, %77
%84 = select i1 %82, i1 %83, i1 false
%85 = fdiv float %58, %81
%86 = select i1 %84, float %85, float %78
%87 = select i1 %84, float %81, float %77
%88 = or i64 %76, 1
%89 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %88
%90 = load float, float* %89
%91 = fcmp une float %90, %58
%92 = fcmp ogt float %90, %87
%93 = select i1 %91, i1 %92, i1 false
%94 = fdiv float %58, %90
%95 = select i1 %93, float %94, float %86
%96 = select i1 %93, float %90, float %87
%97 = add nuw nsw i64 %76, 2
%98 = add i64 %79, 2
%99 = icmp eq i64 %98, %74
br i1 %99, label %100, label %75
100: ; preds = %75
%101 = icmp eq i64 %73, 0
br i1 %101, label %110, label %102
102: ; preds = %100
%103 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %97
%104 = load float, float* %103
%105 = fcmp une float %104, %58
%106 = fcmp ogt float %104, %96
%107 = select i1 %105, i1 %106, i1 false
%108 = fdiv float %58, %104
%109 = select i1 %107, float %108, float %95
br label %110
110: ; preds = %100, %102
%111 = phi float [ %95, %100 ], [ %109, %102 ]
%112 = fpext float %111 to double
%113 = call i32 (i32*, i8*, i8*, float, i8*, i8*, i8*, i8*, i8*, i8*, float, float, ...) @fprintf(i32* %50, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.7, i64 0, i64 0), i8* %29, float %58, i8* %31, i8* %32, i8* %33, i8* %34, i8* %35, i8* %36, float %59, float %57, double %112)
br label %114
114: ; preds = %69, %110, %66
%115 = phi float [ %60, %66 ], [ %111, %110 ], [ %60, %69 ]
%116 = load float, float* %5
%117 = call i32 @strcpy(i8* %31, i8* %37)
%118 = call i32 @strcpy(i8* %32, i8* %38)
%119 = call i32 @strcpy(i8* %33, i8* %39)
%120 = call i32 @strcpy(i8* %34, i8* %40)
%121 = call i32 @strcpy(i8* %35, i8* %41)
%122 = call i32 @strcpy(i8* %36, i8* %42)
%123 = load float, float* %6
%124 = load float, float* %7
%125 = fmul float %123, %124
%126 = call i32 @strcpy(i8* %29, i8* %30)
br label %140
127: ; preds = %55
%128 = load float, float* %5
%129 = fcmp ogt float %128, %58
br i1 %129, label %130, label %140
130: ; preds = %127
%131 = call i32 @strcpy(i8* %31, i8* %37)
%132 = call i32 @strcpy(i8* %32, i8* %38)
%133 = call i32 @strcpy(i8* %33, i8* %39)
%134 = call i32 @strcpy(i8* %34, i8* %40)
%135 = call i32 @strcpy(i8* %35, i8* %41)
%136 = call i32 @strcpy(i8* %36, i8* %42)
%137 = load float, float* %6
%138 = load float, float* %7
%139 = fmul float %137, %138
br label %140
140: ; preds = %127, %130, %114
%141 = phi float [ %115, %114 ], [ %60, %130 ], [ %60, %127 ]
%142 = phi float [ %123, %114 ], [ %137, %130 ], [ %59, %127 ]
%143 = phi float [ %116, %114 ], [ %128, %130 ], [ %58, %127 ]
%144 = phi float [ %125, %114 ], [ %139, %130 ], [ %57, %127 ]
%145 = load float, float* %5
%146 = load i32, i32* %3
%147 = add nsw i32 %146, -1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %148
store float %145, float* %149
%150 = call i32* @fgets(i8* %43, i32 1000, i32* %47)
%151 = icmp eq i32* %150, null
br i1 %151, label %152, label %55
152: ; preds = %140
%153 = icmp eq i32 %146, 1
br i1 %153, label %154, label %156
154: ; preds = %152
%155 = call i32 (i32*, i8*, i8*, float, i8*, i8*, i8*, i8*, i8*, i8*, float, float, ...) @fprintf(i32* %50, i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.6, i64 0, i64 0), i8* %29, float %143, i8* %31, i8* %32, i8* %33, i8* %34, i8* %35, i8* %36, float %142, float %144)
br label %201
156: ; preds = %152
%157 = icmp sgt i32 %146, 1
br i1 %157, label %158, label %201
158: ; preds = %156
%159 = zext i32 %146 to i64
%160 = and i64 %159, 1
%161 = and i64 %159, 4294967294
br label %162
162: ; preds = %162, %158
%163 = phi i64 [ 0, %158 ], [ %184, %162 ]
%164 = phi float [ 0.000000e+00, %158 ], [ %183, %162 ]
%165 = phi float [ %141, %158 ], [ %182, %162 ]
%166 = phi i64 [ 0, %158 ], [ %185, %162 ]
%167 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %163
%168 = load float, float* %167
%169 = fcmp une float %168, %143
%170 = fcmp ogt float %168, %164
%171 = select i1 %169, i1 %170, i1 false
%172 = fdiv float %143, %168
%173 = select i1 %171, float %172, float %165
%174 = select i1 %171, float %168, float %164
%175 = or i64 %163, 1
%176 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %175
%177 = load float, float* %176
%178 = fcmp une float %177, %143
%179 = fcmp ogt float %177, %174
%180 = select i1 %178, i1 %179, i1 false
%181 = fdiv float %143, %177
%182 = select i1 %180, float %181, float %173
%183 = select i1 %180, float %177, float %174
%184 = add nuw nsw i64 %163, 2
%185 = add i64 %166, 2
%186 = icmp eq i64 %185, %161
br i1 %186, label %187, label %162
187: ; preds = %162
%188 = icmp eq i64 %160, 0
br i1 %188, label %197, label %189
189: ; preds = %187
%190 = getelementptr inbounds [25 x float], [25 x float]* %4, i64 0, i64 %184
%191 = load float, float* %190
%192 = fcmp une float %191, %143
%193 = fcmp ogt float %191, %183
%194 = select i1 %192, i1 %193, i1 false
%195 = fdiv float %143, %191
%196 = select i1 %194, float %195, float %182
br label %197
197: ; preds = %187, %189
%198 = phi float [ %182, %187 ], [ %196, %189 ]
%199 = fpext float %198 to double
%200 = call i32 (i32*, i8*, i8*, float, i8*, i8*, i8*, i8*, i8*, i8*, float, float, ...) @fprintf(i32* %50, i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str.7, i64 0, i64 0), i8* %29, float %143, i8* %31, i8* %32, i8* %33, i8* %34, i8* %35, i8* %36, float %142, float %144, double %199)
br label %201
201: ; preds = %2, %156, %197, %154
%202 = call i32 @fclose(i32* %47)
%203 = call i32 @fclose(i32* %50)
ret i32 0
}