#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 */
double M_PI;
double acos(double);
double atan2(double, double);
double atof(char *);
unsigned int atoi(char *);
double cos(double);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fputs(char *, int /*<<< orphan*/);
int /*<<< orphan*/ free(void *);
int /*<<< orphan*/ isnan(double);
int /*<<< orphan*/ printf(char *, ...);
double sin(double);
int /*<<< orphan*/ *stdin;
int /*<<< orphan*/ stdout;
scalar_t__ strcmp(char *, char *);
char *strdup(char *);
char *strsep(char **, char *);
scalar_t__ strstr(char *, char *);
int main(int argc, char *argv[]) {
  unsigned int n1, j;
  unsigned int cols[] = {1, 2}, ncolumns = 2;
  char **argptr, *filename = NULL;
  double pos[2], transform[6], dumx, dumy, ra_c, dec_c;
  char *fs, *inputstring, **ap, *argv2[100];
  FILE *in;
  char buffer[1024];
  int dotransform = 0, doimage = 0;
  if (argc < 2) {
    printf("Format:\n\n   transform file1\n\n   where the options can appear "
           "anywhere in any order:\n\n   -x column                 column to "
           "read x-coordinate (or RA in degrees) from file - default %d\n   -y "
           "column                 column to read y-coordinate (or Dec in "
           "degrees) from file - default %d\n   -fs FS                    "
           "field separator - default space/TAB\n   -c  RA_Centre Dec_Centre  "
           "set field center and use x and y as RA and Dec\n   -t  params      "
           "          six parameter transformation to apply (from "
           "triangle_kd)\n   -                         read from standard "
           "input\n\n   Only the first files listed will be read.  The final "
           "listed parameter\n   stands.\n\n   transform transforms one set of "
           "coordinates to another.  If the field\n   center is given, it will "
           "return the distance north and east of center\n   in arcseconds as "
           "x and y.  The transformation will act on these coordinates.\n",
           cols[0], cols[1]);
    return -1;
  }
  fs = strdup(" \t");
  for (argptr = argv + 1; argptr < argv + argc; argptr++) {
    if (strstr(*argptr, "-x")) {
      if (++argptr < argv + argc) {
        cols[0] = atoi(*argptr);
      }
    } else if (strstr(*argptr, "-y")) {
      if (++argptr < argv + argc) {
        cols[1] = atoi(*argptr);
      }
    } else if (strstr(*argptr, "-fs")) {
      if (++argptr < argv + argc) {
        free((void *)fs);
        fs = strdup(*argptr);
      }
    } else if (strstr(*argptr, "-t")) {
      dotransform = 1;
      for (j = 0; j < 6 && ++argptr < argv + argc; j++) {
        transform[j] = atof(*argptr);
      }
    } else if (strstr(*argptr, "-c")) {
      doimage = 1;
      if (++argptr < argv + argc) {
        ra_c = atof(*argptr) * M_PI / 180.0;
      }
      if (++argptr < argv + argc) {
        dec_c = atof(*argptr) * M_PI / 180.0;
      }
    } else {
      if (filename == NULL)
        filename = *argptr;
    }
  }
  if (strcmp(filename, "-")) {
    if ((in = fopen(filename, "r")) == NULL) {
      printf("Unable to open %s  __FILE__:__LINENO__\n", filename);
      return 0;
    }
  } else {
    in = stdin;
  }
  while (fgets(buffer, 1023, in)) {
    if (buffer[0] == '#') {
      fputs(buffer, stdout);
    } else {
      inputstring = strdup(buffer);
      for (ap = argv2; (*ap = strsep(&inputstring, fs)) != NULL;)
        if (**ap != '\0')
          if (++ap >= &argv2[100])
            break;
      if (ap > argv2) {
        for (j = 0; j < ncolumns; j++) {
          pos[j] =
              (argv2 + cols[j] <= ap ? atof(argv2[cols[j] - 1]) : 0.0 / 0.0);
        }
        if (doimage) {
          pos[0] *= M_PI / 180.0;
          pos[1] *= M_PI / 180.0;
          dumy = acos(cos(pos[1]) * cos(dec_c) * cos(pos[0] - ra_c) +
                      sin(pos[1]) * sin(dec_c));
          dumx = atan2(sin(pos[1]) - cos(dumy) * sin(dec_c),
                       cos(pos[1]) * sin(pos[0] - ra_c) * cos(dec_c));
          dumy *= 180.0 * 3600.0 / M_PI;
          pos[0] = dumy * cos(dumx);
          pos[1] = dumy * sin(dumx);
        }
        if (dotransform) {
          dumx = pos[0] * transform[0] + pos[1] * transform[1] + transform[2];
          pos[1] = pos[0] * transform[3] + pos[1] * transform[4] + transform[5];
          pos[0] = dumx;
        }
        if (!isnan(pos[0]) && !isnan(pos[1]))
          printf("%8.4f %8.4f %s", pos[0], pos[1], buffer);
      }
      free((void *)inputstring);
    }
  }
  if (in != stdin)
    fclose(in);
  free((void *)fs);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x860,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    0xde8(%rip),%rax
mov    %rax,-0x20(%rbp)
movl   $0x2,-0x24(%rbp)
movq   $0x0,-0x38(%rbp)
movl   $0x0,-0x7f4(%rbp)
movl   $0x0,-0x7f8(%rbp)
cmpl   $0x2,-0x8(%rbp)
jge    1281 <main+0x71>
mov    -0x20(%rbp),%esi
mov    -0x1c(%rbp),%edx
lea    0xdb2(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1abc <main+0x8ac>
lea    0x1106(%rip),%rdi
call   1120 <strdup@plt>
mov    %rax,-0xa8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    157c <main+0x36c>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
lea    0x10c7(%rip),%rsi
call   1130 <strstr@plt>
cmp    $0x0,%rax
je     1311 <main+0x101>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    130c <main+0xfc>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1110 <atoi@plt>
mov    %eax,-0x20(%rbp)
jmp    1566 <main+0x356>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
lea    0x1075(%rip),%rsi
call   1130 <strstr@plt>
cmp    $0x0,%rax
je     1366 <main+0x156>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1361 <main+0x151>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1110 <atoi@plt>
mov    %eax,-0x1c(%rbp)
jmp    1561 <main+0x351>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
lea    0x1023(%rip),%rsi
call   1130 <strstr@plt>
cmp    $0x0,%rax
je     13cb <main+0x1bb>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    13c6 <main+0x1b6>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1120 <strdup@plt>
mov    %rax,-0xa8(%rbp)
jmp    155c <main+0x34c>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
lea    0xfc2(%rip),%rsi
call   1130 <strstr@plt>
cmp    $0x0,%rax
je     146d <main+0x25d>
movl   $0x1,-0x7f4(%rbp)
movl   $0x0,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x6,-0x18(%rbp)
mov    %al,-0x7f9(%rbp)
jae    1432 <main+0x222>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
setb   %al
mov    %al,-0x7f9(%rbp)
mov    -0x7f9(%rbp),%al
test   $0x1,%al
jne    1445 <main+0x235>
jmp    1468 <main+0x258>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1040 <atof@plt>
mov    -0x18(%rbp),%eax
movsd  %xmm0,-0x80(%rbp,%rax,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    13f9 <main+0x1e9>
jmp    1557 <main+0x347>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
lea    0xf23(%rip),%rsi
call   1130 <strstr@plt>
cmp    $0x0,%rax
je     1537 <main+0x327>
movl   $0x1,-0x7f8(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    14e3 <main+0x2d3>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1040 <atof@plt>
mov    0x2b1d(%rip),%rax
mulsd  (%rax),%xmm0
movsd  0xb31(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rcx
movslq -0x8(%rbp),%rdx
shl    $0x3,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    1532 <main+0x322>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
call   1040 <atof@plt>
mov    0x2ace(%rip),%rax
mulsd  (%rax),%xmm0
movsd  0xae2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1552 <main+0x342>
cmpq   $0x0,-0x38(%rbp)
jne    154d <main+0x33d>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
jmp    1552 <main+0x342>
jmp    1557 <main+0x347>
jmp    155c <main+0x34c>
jmp    1561 <main+0x351>
jmp    1566 <main+0x356>
jmp    156b <main+0x35b>
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
jmp    12a0 <main+0x90>
mov    -0x38(%rbp),%rdi
lea    0xe1a(%rip),%rsi
call   10b0 <strcmp@plt>
cmp    $0x0,%rax
je     15da <main+0x3ca>
mov    -0x38(%rbp),%rdi
lea    0xe02(%rip),%rsi
call   1100 <fopen@plt>
mov    %rax,-0x3e8(%rbp)
cmp    $0x0,%rax
jne    15d5 <main+0x3c5>
mov    -0x38(%rbp),%rsi
lea    0xde3(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1abc <main+0x8ac>
jmp    15eb <main+0x3db>
mov    0x29ff(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x3e8(%rbp)
jmp    15f0 <main+0x3e0>
lea    -0x7f0(%rbp),%rdi
mov    -0x3e8(%rbp),%rdx
mov    $0x3ff,%esi
call   10a0 <fgets@plt>
cmp    $0x0,%rax
je     1a8d <main+0x87d>
movsbl -0x7f0(%rbp),%eax
cmp    $0x23,%eax
jne    163c <main+0x42c>
lea    -0x7f0(%rbp),%rdi
mov    0x29a0(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
jmp    1a88 <main+0x878>
lea    -0x7f0(%rbp),%rdi
call   1120 <strdup@plt>
mov    %rax,-0xb0(%rbp)
lea    -0x3e0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xa8(%rbp),%rsi
lea    -0xb0(%rbp),%rdi
call   10d0 <strsep@plt>
mov    -0xb8(%rbp),%rcx
mov    %rax,(%rcx)
cmp    $0x0,%rax
je     16d2 <main+0x4c2>
mov    -0xb8(%rbp),%rax
mov    (%rax),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     16cd <main+0x4bd>
mov    -0xb8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0xb8(%rbp)
lea    -0x3e0(%rbp),%rcx
add    $0x320,%rcx
cmp    %rcx,%rax
jb     16c8 <main+0x4b8>
jmp    16d2 <main+0x4c2>
jmp    16cd <main+0x4bd>
jmp    165d <main+0x44d>
mov    -0xb8(%rbp),%rax
lea    -0x3e0(%rbp),%rcx
cmp    %rcx,%rax
jbe    1a7c <main+0x86c>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1778 <main+0x568>
lea    -0x3e0(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp,%rcx,4),%ecx
shl    $0x3,%rcx
add    %rcx,%rax
cmp    -0xb8(%rbp),%rax
ja     1744 <main+0x534>
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp,%rax,4),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    -0x3e0(%rbp,%rax,8),%rdi
ff
call   1040 <atof@plt>
movsd  %xmm0,-0x808(%rbp)
ff
jmp    1759 <main+0x549>
movsd  0x8c4(%rip),%xmm0
movsd  %xmm0,-0x808(%rbp)
ff
jmp    1759 <main+0x549>
movsd  -0x808(%rbp),%xmm0
ff
mov    -0x18(%rbp),%eax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    16f0 <main+0x4e0>
cmpl   $0x0,-0x7f8(%rbp)
je     19c9 <main+0x7b9>
mov    0x285c(%rip),%rax
movsd  (%rax),%xmm0
movsd  0x870(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x283b(%rip),%rax
movsd  (%rax),%xmm0
movsd  0x84f(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
call   10f0 <cos@plt>
movsd  %xmm0,-0x860(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   10f0 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x860(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x848(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
call   10f0 <cos@plt>
movsd  %xmm0,-0x850(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
call   10c0 <sin@plt>
movsd  %xmm0,-0x858(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   10c0 <sin@plt>
movsd  -0x858(%rbp),%xmm1
ff
movsd  -0x850(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x848(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1090 <acos@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
call   10c0 <sin@plt>
movsd  %xmm0,-0x840(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   10f0 <cos@plt>
movsd  %xmm0,-0x838(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   10c0 <sin@plt>
movsd  -0x840(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x838(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x820(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
call   10f0 <cos@plt>
movsd  %xmm0,-0x830(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
call   10c0 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x830(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x828(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   10f0 <cos@plt>
movsd  -0x828(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x820(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
call   1050 <atan2@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x6b4(%rip),%xmm0
mov    0x2695(%rip),%rax
divsd  (%rax),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x818(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   10f0 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x818(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x810(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   10c0 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x810(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
cmpl   $0x0,-0x7f4(%rbp)
je     1a32 <main+0x822>
movsd  -0x50(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
call   10e0 <isnan@plt>
cmp    $0x0,%eax
jne    1a77 <main+0x867>
movsd  -0x48(%rbp),%xmm0
call   10e0 <isnan@plt>
cmp    $0x0,%eax
jne    1a77 <main+0x867>
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
lea    -0x7f0(%rbp),%rsi
lea    0x95d(%rip),%rdi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1a7c <main+0x86c>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
jmp    15f0 <main+0x3e0>
mov    -0x3e8(%rbp),%rax
mov    0x2545(%rip),%rcx
cmp    (%rcx),%rax
je     1ab0 <main+0x8a0>
mov    -0x3e8(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x860,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x7c8,%rsp
cmp    $0x1,%edi
jg     1248 <main+0x38>
lea    0xdeb(%rip),%rdi
mov    $0x1,%esi
mov    $0x2,%edx
xor    %eax,%eax
call   1070 <printf@plt>
mov    $0xffffffff,%ebx
jmp    1908 <main+0x6f8>
mov    %rsi,%r12
mov    %edi,%ebp
lea    0x1132(%rip),%rdi
call   1120 <strdup@plt>
mov    %rax,%rbx
mov    %ebp,%eax
lea    (%r12,%rax,8),%r15
lea    0x8(%r12),%rbp
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    $0x1,%r14d
mov    $0x2,%eax
mov    %rax,0x30(%rsp)
lea    0x1104(%rip),%r13
movl   $0x0,0x1c(%rsp)
xor    %eax,%eax
mov    %rax,(%rsp)
jmp    12be <main+0xae>
cmpq   $0x0,(%rsp)
je     14af <main+0x29f>
mov    %rbp,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x8(%r12),%rbp
cmp    %r15,%rbp
jae    14bc <main+0x2ac>
mov    0x8(%r12),%rdi
mov    %r13,%rsi
call   1130 <strstr@plt>
test   %rax,%rax
je     12f0 <main+0xe0>
add    $0x10,%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    (%r12),%rdi
call   1110 <atoi@plt>
mov    %eax,%r14d
jmp    12b0 <main+0xa0>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp),%rdi
lea    0x1091(%rip),%rsi
call   1130 <strstr@plt>
test   %rax,%rax
je     131e <main+0x10e>
add    $0x10,%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    (%r12),%rdi
call   1110 <atoi@plt>
mov    %rax,0x30(%rsp)
jmp    12b0 <main+0xa0>
mov    0x0(%rbp),%rdi
lea    0x1066(%rip),%rsi
call   1130 <strstr@plt>
test   %rax,%rax
je     1359 <main+0x149>
add    $0x10,%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    (%r12),%rdi
call   1120 <strdup@plt>
mov    %rax,%rbx
jmp    12b0 <main+0xa0>
mov    0x0(%rbp),%rdi
lea    0x102f(%rip),%rsi
call   1130 <strstr@plt>
test   %rax,%rax
je     142d <main+0x21d>
lea    0x8(%rbp),%r12
movl   $0x1,0x1c(%rsp)
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    0x8(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x88(%rsp)
lea    0x10(%rbp),%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    0x10(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x80(%rsp)
lea    0x18(%rbp),%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    0x18(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x68(%rsp)
lea    0x20(%rbp),%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    0x20(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x60(%rsp)
lea    0x28(%rbp),%r12
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    0x28(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x58(%rsp)
add    $0x30,%rbp
cmp    %r15,%rbp
jae    12a0 <main+0x90>
mov    0x0(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x50(%rsp)
jmp    12a0 <main+0x90>
mov    0x0(%rbp),%rdi
lea    0xf5e(%rip),%rsi
call   1130 <strstr@plt>
test   %rax,%rax
je     1295 <main+0x85>
lea    0x10(%r12),%rax
cmp    %r15,%rax
jae    1471 <main+0x261>
mov    (%rax),%rdi
call   1040 <atof@plt>
mov    0x2b89(%rip),%rax
mulsd  (%rax),%xmm0
divsd  0xb95(%rip),%xmm0
movsd  %xmm0,0x78(%rsp)
add    $0x18,%r12
mov    $0x1,%eax
mov    %rax,0x40(%rsp)
cmp    %r15,%r12
jae    12b0 <main+0xa0>
mov    (%r12),%rdi
call   1040 <atof@plt>
mov    0x2b50(%rip),%rax
mulsd  (%rax),%xmm0
divsd  0xb5c(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
jmp    12b0 <main+0xa0>
mov    0x0(%rbp),%rax
mov    %rax,(%rsp)
jmp    12a0 <main+0x90>
lea    0xed6(%rip),%rsi
mov    (%rsp),%rbp
mov    %rbp,%rdi
call   10b0 <strcmp@plt>
test   %rax,%rax
je     1503 <main+0x2f3>
lea    0xec0(%rip),%rsi
mov    %rbp,%rdi
call   1100 <fopen@plt>
mov    %rax,%r13
test   %rax,%rax
jne    150d <main+0x2fd>
lea    0xeab(%rip),%rdi
xor    %ebx,%ebx
mov    %rbp,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
jmp    1908 <main+0x6f8>
mov    0x2ad6(%rip),%rax
mov    (%rax),%r13
lea    0x3c0(%rsp),%rdi
mov    $0x3ff,%esi
mov    %r13,%rdx
call   10a0 <fgets@plt>
test   %rax,%rax
je     18ea <main+0x6da>
lea    0x3c0(%rsp),%r15
mov    %r14d,%eax
lea    (%rsp,%rax,8),%rax
add    $0xa0,%rax
mov    %rax,0x98(%rsp)
add    $0xffffffff,%r14d
mov    %r14,0x70(%rsp)
mov    0x30(%rsp),%rcx
mov    %ecx,%eax
lea    (%rsp,%rax,8),%rax
add    $0xa0,%rax
mov    %rax,0x90(%rsp)
add    $0xffffffff,%ecx
mov    %rcx,0x30(%rsp)
lea    0x3c0(%rsp),%r12
lea    0x48(%rsp),%rbp
jmp    15b3 <main+0x3a3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
mov    $0x3ff,%esi
mov    %r13,%rdx
call   10a0 <fgets@plt>
test   %rax,%rax
je     18ea <main+0x6da>
cmpb   $0x23,0x3c0(%rsp)
23
jne    15d0 <main+0x3c0>
mov    0x2a0c(%rip),%rax
mov    (%rax),%esi
mov    %r12,%rdi
call   1080 <fputs@plt>
jmp    159a <main+0x38a>
mov    %r12,%rdi
call   1120 <strdup@plt>
mov    %rax,0x48(%rsp)
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10d0 <strsep@plt>
mov    %rax,0xa0(%rsp)
test   %rax,%rax
je     1590 <main+0x380>
lea    0xa0(%rsp),%r14
jmp    1613 <main+0x403>
nop
mov    %rbp,%rdi
mov    %rbx,%rsi
call   10d0 <strsep@plt>
mov    %rax,(%r14)
test   %rax,%rax
je     1621 <main+0x411>
cmpb   $0x0,(%rax)
je     1600 <main+0x3f0>
add    $0x8,%r14
cmp    %r15,%r14
jb     1600 <main+0x3f0>
lea    0xa0(%rsp),%rax
cmp    %rax,%r14
jbe    1590 <main+0x380>
movsd  0x9ce(%rip),%xmm0
movapd %xmm0,%xmm1
cmp    %r14,0x98(%rsp)
jbe    1836 <main+0x626>
cmp    %r14,0x90(%rsp)
jbe    1862 <main+0x652>
cmpl   $0x0,0x40(%rsp)
je     1889 <main+0x679>
mov    0x297c(%rip),%r14
movsd  (%r14),%xmm2
divsd  0x987(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  %xmm1,(%rsp)
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsp)
movapd %xmm2,%xmm0
call   10f0 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x28(%rsp),%xmm0
call   10f0 <cos@plt>
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rsp),%xmm0
subsd  0x78(%rsp),%xmm0
movsd  %xmm0,(%rsp)
call   10f0 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
call   10c0 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x28(%rsp),%xmm0
call   10c0 <sin@plt>
mulsd  0x38(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x10(%rsp),%xmm1
addsd  %xmm1,%xmm0
call   1090 <acos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rsp),%xmm0
call   10c0 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   10f0 <cos@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x28(%rsp),%xmm0
call   10c0 <sin@plt>
mulsd  0x38(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x8(%rsp),%xmm0
call   10f0 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
call   10c0 <sin@plt>
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x28(%rsp),%xmm0
call   10f0 <cos@plt>
movsd  0x8(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x10(%rsp),%xmm0
call   1050 <atan2@plt>
movapd %xmm0,%xmm1
movsd  %xmm0,0x10(%rsp)
movsd  0x866(%rip),%xmm0
divsd  (%r14),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movapd %xmm1,%xmm0
call   10f0 <cos@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
call   10c0 <sin@plt>
mulsd  0x8(%rsp),%xmm0
cmpl   $0x0,0x1c(%rsp)
je     1899 <main+0x689>
movapd %xmm0,%xmm3
mulsd  0x80(%rsp),%xmm3
movsd  (%rsp),%xmm2
movapd %xmm2,%xmm1
mulsd  0x88(%rsp),%xmm1
addsd  %xmm3,%xmm1
addsd  0x68(%rsp),%xmm1
mulsd  0x58(%rsp),%xmm0
mulsd  0x60(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x50(%rsp),%xmm2
movsd  %xmm2,0x8(%rsp)
movapd %xmm1,%xmm0
jmp    18a4 <main+0x694>
mov    0x70(%rsp),%rax
mov    0xa0(%rsp,%rax,8),%rdi
call   1040 <atof@plt>
movapd %xmm0,%xmm1
movsd  0x7b4(%rip),%xmm0
cmp    %r14,0x90(%rsp)
ja     165a <main+0x44a>
mov    0x30(%rsp),%rax
mov    0xa0(%rsp,%rax,8),%rdi
movsd  %xmm1,(%rsp)
call   1040 <atof@plt>
movsd  (%rsp),%xmm1
cmpl   $0x0,0x40(%rsp)
jne    1665 <main+0x455>
movsd  %xmm1,(%rsp)
cmpl   $0x0,0x1c(%rsp)
jne    17eb <main+0x5db>
movsd  %xmm0,0x8(%rsp)
movsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
call   10e0 <isnan@plt>
test   %eax,%eax
jne    1590 <main+0x380>
movsd  0x8(%rsp),%xmm0
call   10e0 <isnan@plt>
test   %eax,%eax
jne    1590 <main+0x380>
lea    0xaf5(%rip),%rdi
movsd  (%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mov    %r12,%rsi
mov    $0x2,%al
call   1070 <printf@plt>
jmp    1590 <main+0x380>
mov    0x26ef(%rip),%rax
cmp    (%rax),%r13
je     18fe <main+0x6ee>
mov    %r13,%rdi
call   1060 <fclose@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %ebx,%ebx
mov    %ebx,%eax
add    $0x7c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.main.cols = [2 x i32] [i32 1, i32 2]
@.str = [878 x i8] c"Format:\0A\0A transform file1\0A\0A where the options can appear anywhere in any order:\0A\0A -x column column to read x-coordinate (or RA in degrees) from file - default %d\0A -y column column to read y-coordinate (or Dec in degrees) from file - default %d\0A -fs FS field separator - default space/TAB\0A -c RA_Centre Dec_Centre set field center and use x and y as RA and Dec\0A -t params six parameter transformation to apply (from triangle_kd)\0A - read from standard input\0A\0A Only the first files listed will be read. The final listed parameter\0A stands.\0A\0A transform transforms one set of coordinates to another. If the field\0A center is given, it will return the distance north and east of center\0A in arcseconds as x and y. The transformation will act on these coordinates.\0A\00"
@.str.1 = [3 x i8] c" \09\00"
@.str.2 = [3 x i8] c"-x\00"
@.str.3 = [3 x i8] c"-y\00"
@.str.4 = [4 x i8] c"-fs\00"
@.str.5 = [3 x i8] c"-t\00"
@.str.6 = [3 x i8] c"-c\00"
@M_PI = global double 0.000000e+00
@.str.7 = [2 x i8] c"-\00"
@.str.8 = [2 x i8] c"r\00"
@.str.9 = [40 x i8] c"Unable to open %s __FILE__:__LINENO__\0A\00"
@stdin = global i32* null
@stdout = global i32 0
@.str.10 = [15 x i8] c"%8.4f %8.4f %s\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 [2 x i32]
%9 = alloca i32
%10 = alloca i8**
%11 = alloca i8*
%12 = alloca [2 x double]
%13 = alloca [6 x double]
%14 = alloca double
%15 = alloca double
%16 = alloca double
%17 = alloca double
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i8**
%21 = alloca [100 x i8*]
%22 = alloca i32*
%23 = alloca [1024 x i8]
%24 = alloca i32
%25 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%26 = bitcast [2 x i32]* %8 to i8*
store i32 2, i32* %9
store i8* null, i8** %11
store i32 0, i32* %24
store i32 0, i32* %25
%27 = load i32, i32* %4
%28 = icmp slt i32 %27, 2
br i1 %28, label %29, label %35
29: ; preds = %2
%30 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 0
%31 = load i32, i32* %30
%32 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 1
%33 = load i32, i32* %32
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([878 x i8], [878 x i8]* @.str, i64 0, i64 0), i32 %31, i32 %33)
store i32 -1, i32* %3
br label %409
35: ; preds = %2
%36 = call i8* @strdup(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i8* %36, i8** %18
%37 = load i8**, i8*** %5
%38 = getelementptr inbounds i8*, i8** %37, i64 1
store i8** %38, i8*** %10
br label %39
39: ; preds = %182, %35
%40 = load i8**, i8*** %10
%41 = load i8**, i8*** %5
%42 = load i32, i32* %4
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8*, i8** %41, i64 %43
%45 = icmp ult i8** %40, %44
br i1 %45, label %46, label %185
46: ; preds = %39
%47 = load i8**, i8*** %10
%48 = load i8*, i8** %47
%49 = call i64 @strstr(i8* %48, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%50 = icmp ne i64 %49, 0
br i1 %50, label %51, label %65
51: ; preds = %46
%52 = load i8**, i8*** %10
%53 = getelementptr inbounds i8*, i8** %52, i32 1
store i8** %53, i8*** %10
%54 = load i8**, i8*** %5
%55 = load i32, i32* %4
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8*, i8** %54, i64 %56
%58 = icmp ult i8** %53, %57
br i1 %58, label %59, label %64
59: ; preds = %51
%60 = load i8**, i8*** %10
%61 = load i8*, i8** %60
%62 = call i32 @atoi(i8* %61)
%63 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 0
store i32 %62, i32* %63
br label %64
64: ; preds = %59, %51
br label %181
65: ; preds = %46
%66 = load i8**, i8*** %10
%67 = load i8*, i8** %66
%68 = call i64 @strstr(i8* %67, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%69 = icmp ne i64 %68, 0
br i1 %69, label %70, label %84
70: ; preds = %65
%71 = load i8**, i8*** %10
%72 = getelementptr inbounds i8*, i8** %71, i32 1
store i8** %72, i8*** %10
%73 = load i8**, i8*** %5
%74 = load i32, i32* %4
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8*, i8** %73, i64 %75
%77 = icmp ult i8** %72, %76
br i1 %77, label %78, label %83
78: ; preds = %70
%79 = load i8**, i8*** %10
%80 = load i8*, i8** %79
%81 = call i32 @atoi(i8* %80)
%82 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 1
store i32 %81, i32* %82
br label %83
83: ; preds = %78, %70
br label %180
84: ; preds = %65
%85 = load i8**, i8*** %10
%86 = load i8*, i8** %85
%87 = call i64 @strstr(i8* %86, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
%88 = icmp ne i64 %87, 0
br i1 %88, label %89, label %104
89: ; preds = %84
%90 = load i8**, i8*** %10
%91 = getelementptr inbounds i8*, i8** %90, i32 1
store i8** %91, i8*** %10
%92 = load i8**, i8*** %5
%93 = load i32, i32* %4
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8*, i8** %92, i64 %94
%96 = icmp ult i8** %91, %95
br i1 %96, label %97, label %103
97: ; preds = %89
%98 = load i8*, i8** %18
%99 = call i32 @free(i8* %98)
%100 = load i8**, i8*** %10
%101 = load i8*, i8** %100
%102 = call i8* @strdup(i8* %101)
store i8* %102, i8** %18
br label %103
103: ; preds = %97, %89
br label %179
104: ; preds = %84
%105 = load i8**, i8*** %10
%106 = load i8*, i8** %105
%107 = call i64 @strstr(i8* %106, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%108 = icmp ne i64 %107, 0
br i1 %108, label %109, label %134
109: ; preds = %104
store i32 1, i32* %24
store i32 0, i32* %7
br label %110
110: ; preds = %130, %109
%111 = load i32, i32* %7
%112 = icmp ult i32 %111, 6
br i1 %112, label %113, label %121
113: ; preds = %110
%114 = load i8**, i8*** %10
%115 = getelementptr inbounds i8*, i8** %114, i32 1
store i8** %115, i8*** %10
%116 = load i8**, i8*** %5
%117 = load i32, i32* %4
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i8*, i8** %116, i64 %118
%120 = icmp ult i8** %115, %119
br label %121
121: ; preds = %113, %110
%122 = phi i1 [ false, %110 ], [ %120, %113 ]
br i1 %122, label %123, label %133
123: ; preds = %121
%124 = load i8**, i8*** %10
%125 = load i8*, i8** %124
%126 = call double @atof(i8* %125)
%127 = load i32, i32* %7
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 %128
store double %126, double* %129
br label %130
130: ; preds = %123
%131 = load i32, i32* %7
%132 = add i32 %131, 1
store i32 %132, i32* %7
br label %110
133: ; preds = %121
br label %178
134: ; preds = %104
%135 = load i8**, i8*** %10
%136 = load i8*, i8** %135
%137 = call i64 @strstr(i8* %136, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%138 = icmp ne i64 %137, 0
br i1 %138, label %139, label %170
139: ; preds = %134
store i32 1, i32* %25
%140 = load i8**, i8*** %10
%141 = getelementptr inbounds i8*, i8** %140, i32 1
store i8** %141, i8*** %10
%142 = load i8**, i8*** %5
%143 = load i32, i32* %4
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i8*, i8** %142, i64 %144
%146 = icmp ult i8** %141, %145
br i1 %146, label %147, label %154
147: ; preds = %139
%148 = load i8**, i8*** %10
%149 = load i8*, i8** %148
%150 = call double @atof(i8* %149)
%151 = load double, double* @M_PI
%152 = fmul double %150, %151
%153 = fdiv double %152, 1.800000e+02
store double %153, double* %16
br label %154
154: ; preds = %147, %139
%155 = load i8**, i8*** %10
%156 = getelementptr inbounds i8*, i8** %155, i32 1
store i8** %156, i8*** %10
%157 = load i8**, i8*** %5
%158 = load i32, i32* %4
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i8*, i8** %157, i64 %159
%161 = icmp ult i8** %156, %160
br i1 %161, label %162, label %169
162: ; preds = %154
%163 = load i8**, i8*** %10
%164 = load i8*, i8** %163
%165 = call double @atof(i8* %164)
%166 = load double, double* @M_PI
%167 = fmul double %165, %166
%168 = fdiv double %167, 1.800000e+02
store double %168, double* %17
br label %169
169: ; preds = %162, %154
br label %177
170: ; preds = %134
%171 = load i8*, i8** %11
%172 = icmp eq i8* %171, null
br i1 %172, label %173, label %176
173: ; preds = %170
%174 = load i8**, i8*** %10
%175 = load i8*, i8** %174
store i8* %175, i8** %11
br label %176
176: ; preds = %173, %170
br label %177
177: ; preds = %176, %169
br label %178
178: ; preds = %177, %133
br label %179
179: ; preds = %178, %103
br label %180
180: ; preds = %179, %83
br label %181
181: ; preds = %180, %64
br label %182
182: ; preds = %181
%183 = load i8**, i8*** %10
%184 = getelementptr inbounds i8*, i8** %183, i32 1
store i8** %184, i8*** %10
br label %39
185: ; preds = %39
%186 = load i8*, i8** %11
%187 = call i64 @strcmp(i8* %186, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%188 = icmp ne i64 %187, 0
br i1 %188, label %189, label %197
189: ; preds = %185
%190 = load i8*, i8** %11
%191 = call i32* @fopen(i8* %190, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
store i32* %191, i32** %22
%192 = icmp eq i32* %191, null
br i1 %192, label %193, label %196
193: ; preds = %189
%194 = load i8*, i8** %11
%195 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0), i8* %194)
store i32 0, i32* %3
br label %409
196: ; preds = %189
br label %199
197: ; preds = %185
%198 = load i32*, i32** @stdin
store i32* %198, i32** %22
br label %199
199: ; preds = %197, %196
br label %200
200: ; preds = %398, %199
%201 = getelementptr inbounds [1024 x i8], [1024 x i8]* %23, i64 0, i64 0
%202 = load i32*, i32** %22
%203 = call i64 @fgets(i8* %201, i32 1023, i32* %202)
%204 = icmp ne i64 %203, 0
br i1 %204, label %205, label %399
205: ; preds = %200
%206 = getelementptr inbounds [1024 x i8], [1024 x i8]* %23, i64 0, i64 0
%207 = load i8, i8* %206
%208 = sext i8 %207 to i32
%209 = icmp eq i32 %208, 35
br i1 %209, label %210, label %214
210: ; preds = %205
%211 = getelementptr inbounds [1024 x i8], [1024 x i8]* %23, i64 0, i64 0
%212 = load i32, i32* @stdout
%213 = call i32 @fputs(i8* %211, i32 %212)
br label %398
214: ; preds = %205
%215 = getelementptr inbounds [1024 x i8], [1024 x i8]* %23, i64 0, i64 0
%216 = call i8* @strdup(i8* %215)
store i8* %216, i8** %19
%217 = getelementptr inbounds [100 x i8*], [100 x i8*]* %21, i64 0, i64 0
store i8** %217, i8*** %20
br label %218
218: ; preds = %236, %214
%219 = load i8*, i8** %18
%220 = call i8* @strsep(i8** %19, i8* %219)
%221 = load i8**, i8*** %20
store i8* %220, i8** %221
%222 = icmp ne i8* %220, null
br i1 %222, label %223, label %237
223: ; preds = %218
%224 = load i8**, i8*** %20
%225 = load i8*, i8** %224
%226 = load i8, i8* %225
%227 = sext i8 %226 to i32
%228 = icmp ne i32 %227, 0
br i1 %228, label %229, label %236
229: ; preds = %223
%230 = load i8**, i8*** %20
%231 = getelementptr inbounds i8*, i8** %230, i32 1
store i8** %231, i8*** %20
%232 = getelementptr inbounds [100 x i8*], [100 x i8*]* %21, i64 0, i64 100
%233 = icmp uge i8** %231, %232
br i1 %233, label %234, label %235
234: ; preds = %229
br label %237
235: ; preds = %229
br label %236
236: ; preds = %235, %223
br label %218
237: ; preds = %234, %218
%238 = load i8**, i8*** %20
%239 = getelementptr inbounds [100 x i8*], [100 x i8*]* %21, i64 0, i64 0
%240 = icmp ugt i8** %238, %239
br i1 %240, label %241, label %395
241: ; preds = %237
store i32 0, i32* %7
br label %242
242: ; preds = %272, %241
%243 = load i32, i32* %7
%244 = load i32, i32* %9
%245 = icmp ult i32 %243, %244
br i1 %245, label %246, label %275
246: ; preds = %242
%247 = getelementptr inbounds [100 x i8*], [100 x i8*]* %21, i64 0, i64 0
%248 = load i32, i32* %7
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 %249
%251 = load i32, i32* %250
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds i8*, i8** %247, i64 %252
%254 = load i8**, i8*** %20
%255 = icmp ule i8** %253, %254
br i1 %255, label %256, label %266
256: ; preds = %246
%257 = load i32, i32* %7
%258 = zext i32 %257 to i64
%259 = getelementptr inbounds [2 x i32], [2 x i32]* %8, i64 0, i64 %258
%260 = load i32, i32* %259
%261 = sub i32 %260, 1
%262 = zext i32 %261 to i64
%263 = getelementptr inbounds [100 x i8*], [100 x i8*]* %21, i64 0, i64 %262
%264 = load i8*, i8** %263
%265 = call double @atof(i8* %264)
br label %267
266: ; preds = %246
br label %267
267: ; preds = %266, %256
%268 = phi double [ %265, %256 ], [ 0x7FF8000000000000, %266 ]
%269 = load i32, i32* %7
%270 = zext i32 %269 to i64
%271 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 %270
store double %268, double* %271
br label %272
272: ; preds = %267
%273 = load i32, i32* %7
%274 = add i32 %273, 1
store i32 %274, i32* %7
br label %242
275: ; preds = %242
%276 = load i32, i32* %25
%277 = icmp ne i32 %276, 0
br i1 %277, label %278, label %344
278: ; preds = %275
%279 = load double, double* @M_PI
%280 = fdiv double %279, 1.800000e+02
%281 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%282 = load double, double* %281
%283 = fmul double %282, %280
store double %283, double* %281
%284 = load double, double* @M_PI
%285 = fdiv double %284, 1.800000e+02
%286 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%287 = load double, double* %286
%288 = fmul double %287, %285
store double %288, double* %286
%289 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%290 = load double, double* %289
%291 = call double @cos(double %290)
%292 = load double, double* %17
%293 = call double @cos(double %292)
%294 = fmul double %291, %293
%295 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%296 = load double, double* %295
%297 = load double, double* %16
%298 = fsub double %296, %297
%299 = call double @cos(double %298)
%300 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%301 = load double, double* %300
%302 = call double @sin(double %301)
%303 = load double, double* %17
%304 = call double @sin(double %303)
%305 = fmul double %302, %304
%306 = call double @llvm.fmuladd.f64(double %294, double %299, double %305)
%307 = call double @acos(double %306)
store double %307, double* %15
%308 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%309 = load double, double* %308
%310 = call double @sin(double %309)
%311 = load double, double* %15
%312 = call double @cos(double %311)
%313 = load double, double* %17
%314 = call double @sin(double %313)
%315 = fneg double %312
%316 = call double @llvm.fmuladd.f64(double %315, double %314, double %310)
%317 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%318 = load double, double* %317
%319 = call double @cos(double %318)
%320 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%321 = load double, double* %320
%322 = load double, double* %16
%323 = fsub double %321, %322
%324 = call double @sin(double %323)
%325 = fmul double %319, %324
%326 = load double, double* %17
%327 = call double @cos(double %326)
%328 = fmul double %325, %327
%329 = call double @atan2(double %316, double %328)
store double %329, double* %14
%330 = load double, double* @M_PI
%331 = fdiv double 6.480000e+05, %330
%332 = load double, double* %15
%333 = fmul double %332, %331
store double %333, double* %15
%334 = load double, double* %15
%335 = load double, double* %14
%336 = call double @cos(double %335)
%337 = fmul double %334, %336
%338 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
store double %337, double* %338
%339 = load double, double* %15
%340 = load double, double* %14
%341 = call double @sin(double %340)
%342 = fmul double %339, %341
%343 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
store double %342, double* %343
br label %344
344: ; preds = %278, %275
%345 = load i32, i32* %24
%346 = icmp ne i32 %345, 0
br i1 %346, label %347, label %377
347: ; preds = %344
%348 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%349 = load double, double* %348
%350 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 0
%351 = load double, double* %350
%352 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%353 = load double, double* %352
%354 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 1
%355 = load double, double* %354
%356 = fmul double %353, %355
%357 = call double @llvm.fmuladd.f64(double %349, double %351, double %356)
%358 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 2
%359 = load double, double* %358
%360 = fadd double %357, %359
store double %360, double* %14
%361 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%362 = load double, double* %361
%363 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 3
%364 = load double, double* %363
%365 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%366 = load double, double* %365
%367 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 4
%368 = load double, double* %367
%369 = fmul double %366, %368
%370 = call double @llvm.fmuladd.f64(double %362, double %364, double %369)
%371 = getelementptr inbounds [6 x double], [6 x double]* %13, i64 0, i64 5
%372 = load double, double* %371
%373 = fadd double %370, %372
%374 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
store double %373, double* %374
%375 = load double, double* %14
%376 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
store double %375, double* %376
br label %377
377: ; preds = %347, %344
%378 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%379 = load double, double* %378
%380 = call i32 @isnan(double %379)
%381 = icmp ne i32 %380, 0
br i1 %381, label %394, label %382
382: ; preds = %377
%383 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%384 = load double, double* %383
%385 = call i32 @isnan(double %384)
%386 = icmp ne i32 %385, 0
br i1 %386, label %394, label %387
387: ; preds = %382
%388 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 0
%389 = load double, double* %388
%390 = getelementptr inbounds [2 x double], [2 x double]* %12, i64 0, i64 1
%391 = load double, double* %390
%392 = getelementptr inbounds [1024 x i8], [1024 x i8]* %23, i64 0, i64 0
%393 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), double %389, double %391, i8* %392)
br label %394
394: ; preds = %387, %382, %377
br label %395
395: ; preds = %394, %237
%396 = load i8*, i8** %19
%397 = call i32 @free(i8* %396)
br label %398
398: ; preds = %395, %210
br label %200
399: ; preds = %200
%400 = load i32*, i32** %22
%401 = load i32*, i32** @stdin
%402 = icmp ne i32* %400, %401
br i1 %402, label %403, label %406
403: ; preds = %399
%404 = load i32*, i32** %22
%405 = call i32 @fclose(i32* %404)
br label %406
406: ; preds = %403, %399
%407 = load i8*, i8** %18
%408 = call i32 @free(i8* %407)
br label %409
409: ; preds = %406, %193, %29
%410 = load i32, i32* %3
ret i32 %410
}

LLVM IR (-O2):
@.str = [878 x i8] c"Format:\0A\0A transform file1\0A\0A where the options can appear anywhere in any order:\0A\0A -x column column to read x-coordinate (or RA in degrees) from file - default %d\0A -y column column to read y-coordinate (or Dec in degrees) from file - default %d\0A -fs FS field separator - default space/TAB\0A -c RA_Centre Dec_Centre set field center and use x and y as RA and Dec\0A -t params six parameter transformation to apply (from triangle_kd)\0A - read from standard input\0A\0A Only the first files listed will be read. The final listed parameter\0A stands.\0A\0A transform transforms one set of coordinates to another. If the field\0A center is given, it will return the distance north and east of center\0A in arcseconds as x and y. The transformation will act on these coordinates.\0A\00"
@.str.1 = [3 x i8] c" \09\00"
@.str.2 = [3 x i8] c"-x\00"
@.str.3 = [3 x i8] c"-y\00"
@.str.4 = [4 x i8] c"-fs\00"
@.str.5 = [3 x i8] c"-t\00"
@.str.6 = [3 x i8] c"-c\00"
@M_PI = global double 0.000000e+00
@.str.7 = [2 x i8] c"-\00"
@.str.8 = [2 x i8] c"r\00"
@.str.9 = [40 x i8] c"Unable to open %s __FILE__:__LINENO__\0A\00"
@stdin = global i32* null
@stdout = global i32 0
@.str.10 = [15 x i8] c"%8.4f %8.4f %s\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i8*
%4 = alloca [100 x i8*]
%5 = alloca [1024 x i8]
%6 = bitcast i8** %3 to i8*
%7 = bitcast [100 x i8*]* %4 to i8*
%8 = getelementptr inbounds [1024 x i8], [1024 x i8]* %5, i64 0, i64 0
%9 = icmp slt i32 %0, 2
br i1 %9, label %10, label %12
10: ; preds = %2
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([878 x i8], [878 x i8]* @.str, i64 0, i64 0), i32 1, i32 2)
br label %277
12: ; preds = %2
%13 = tail call dereferenceable_or_null(3) i8* @strdup(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%14 = zext i32 %0 to i64
%15 = getelementptr inbounds i8*, i8** %1, i64 %14
%16 = getelementptr inbounds i8*, i8** %1, i64 1
br label %17
17: ; preds = %12, %126
%18 = phi double [ undef, %12 ], [ %127, %126 ]
%19 = phi double [ undef, %12 ], [ %128, %126 ]
%20 = phi double [ undef, %12 ], [ %129, %126 ]
%21 = phi double [ undef, %12 ], [ %130, %126 ]
%22 = phi double [ undef, %12 ], [ %131, %126 ]
%23 = phi double [ undef, %12 ], [ %132, %126 ]
%24 = phi i32 [ 2, %12 ], [ %133, %126 ]
%25 = phi i32 [ 1, %12 ], [ %134, %126 ]
%26 = phi i8** [ %16, %12 ], [ %142, %126 ]
%27 = phi i32 [ 0, %12 ], [ %141, %126 ]
%28 = phi i32 [ 0, %12 ], [ %140, %126 ]
%29 = phi i8* [ %13, %12 ], [ %139, %126 ]
%30 = phi double [ undef, %12 ], [ %138, %126 ]
%31 = phi double [ undef, %12 ], [ %137, %126 ]
%32 = phi i8* [ null, %12 ], [ %136, %126 ]
%33 = phi i8** [ %1, %12 ], [ %135, %126 ]
%34 = load i8*, i8** %26
%35 = tail call i64 @strstr(i8* %34, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%36 = icmp eq i64 %35, 0
br i1 %36, label %43, label %37
37: ; preds = %17
%38 = getelementptr inbounds i8*, i8** %33, i64 2
%39 = icmp ult i8** %38, %15
br i1 %39, label %40, label %126
40: ; preds = %37
%41 = load i8*, i8** %38
%42 = tail call i32 @atoi(i8* %41)
br label %126
43: ; preds = %17
%44 = load i8*, i8** %26
%45 = tail call i64 @strstr(i8* %44, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
%46 = icmp eq i64 %45, 0
br i1 %46, label %53, label %47
47: ; preds = %43
%48 = getelementptr inbounds i8*, i8** %33, i64 2
%49 = icmp ult i8** %48, %15
br i1 %49, label %50, label %126
50: ; preds = %47
%51 = load i8*, i8** %48
%52 = tail call i32 @atoi(i8* %51)
br label %126
53: ; preds = %43
%54 = load i8*, i8** %26
%55 = tail call i64 @strstr(i8* %54, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0))
%56 = icmp eq i64 %55, 0
br i1 %56, label %64, label %57
57: ; preds = %53
%58 = getelementptr inbounds i8*, i8** %33, i64 2
%59 = icmp ult i8** %58, %15
br i1 %59, label %60, label %126
60: ; preds = %57
%61 = tail call i32 @free(i8* %29)
%62 = load i8*, i8** %58
%63 = tail call i8* @strdup(i8* %62)
br label %126
64: ; preds = %53
%65 = load i8*, i8** %26
%66 = tail call i64 @strstr(i8* %65, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.5, i64 0, i64 0))
%67 = icmp eq i64 %66, 0
br i1 %67, label %99, label %68
68: ; preds = %64
%69 = getelementptr inbounds i8*, i8** %26, i64 1
%70 = icmp ult i8** %69, %15
br i1 %70, label %71, label %126
71: ; preds = %68
%72 = load i8*, i8** %69
%73 = tail call double @atof(i8* %72)
%74 = getelementptr inbounds i8*, i8** %26, i64 2
%75 = icmp ult i8** %74, %15
br i1 %75, label %76, label %126
76: ; preds = %71
%77 = load i8*, i8** %74
%78 = tail call double @atof(i8* %77)
%79 = getelementptr inbounds i8*, i8** %26, i64 3
%80 = icmp ult i8** %79, %15
br i1 %80, label %81, label %126
81: ; preds = %76
%82 = load i8*, i8** %79
%83 = tail call double @atof(i8* %82)
%84 = getelementptr inbounds i8*, i8** %26, i64 4
%85 = icmp ult i8** %84, %15
br i1 %85, label %86, label %126
86: ; preds = %81
%87 = load i8*, i8** %84
%88 = tail call double @atof(i8* %87)
%89 = getelementptr inbounds i8*, i8** %26, i64 5
%90 = icmp ult i8** %89, %15
br i1 %90, label %91, label %126
91: ; preds = %86
%92 = load i8*, i8** %89
%93 = tail call double @atof(i8* %92)
%94 = getelementptr inbounds i8*, i8** %26, i64 6
%95 = icmp ult i8** %94, %15
br i1 %95, label %96, label %126
96: ; preds = %91
%97 = load i8*, i8** %94
%98 = tail call double @atof(i8* %97)
br label %126
99: ; preds = %64
%100 = load i8*, i8** %26
%101 = tail call i64 @strstr(i8* %100, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.6, i64 0, i64 0))
%102 = icmp eq i64 %101, 0
br i1 %102, label %122, label %103
103: ; preds = %99
%104 = getelementptr inbounds i8*, i8** %33, i64 2
%105 = icmp ult i8** %104, %15
br i1 %105, label %106, label %112
106: ; preds = %103
%107 = load i8*, i8** %104
%108 = tail call double @atof(i8* %107)
%109 = load double, double* @M_PI
%110 = fmul double %108, %109
%111 = fdiv double %110, 1.800000e+02
br label %112
112: ; preds = %106, %103
%113 = phi double [ %111, %106 ], [ %31, %103 ]
%114 = getelementptr inbounds i8*, i8** %33, i64 3
%115 = icmp ult i8** %114, %15
br i1 %115, label %116, label %126
116: ; preds = %112
%117 = load i8*, i8** %114
%118 = tail call double @atof(i8* %117)
%119 = load double, double* @M_PI
%120 = fmul double %118, %119
%121 = fdiv double %120, 1.800000e+02
br label %126
122: ; preds = %99
%123 = icmp eq i8* %32, null
br i1 %123, label %124, label %126
124: ; preds = %122
%125 = load i8*, i8** %26
br label %126
126: ; preds = %68, %71, %76, %81, %86, %91, %96, %40, %37, %60, %57, %116, %112, %124, %122, %47, %50
%127 = phi double [ %18, %124 ], [ %18, %122 ], [ %18, %116 ], [ %18, %112 ], [ %18, %60 ], [ %18, %57 ], [ %18, %50 ], [ %18, %47 ], [ %18, %40 ], [ %18, %37 ], [ %98, %96 ], [ %18, %91 ], [ %18, %86 ], [ %18, %81 ], [ %18, %76 ], [ %18, %71 ], [ %18, %68 ]
%128 = phi double [ %19, %124 ], [ %19, %122 ], [ %19, %116 ], [ %19, %112 ], [ %19, %60 ], [ %19, %57 ], [ %19, %50 ], [ %19, %47 ], [ %19, %40 ], [ %19, %37 ], [ %93, %96 ], [ %93, %91 ], [ %19, %86 ], [ %19, %81 ], [ %19, %76 ], [ %19, %71 ], [ %19, %68 ]
%129 = phi double [ %20, %124 ], [ %20, %122 ], [ %20, %116 ], [ %20, %112 ], [ %20, %60 ], [ %20, %57 ], [ %20, %50 ], [ %20, %47 ], [ %20, %40 ], [ %20, %37 ], [ %88, %96 ], [ %88, %91 ], [ %88, %86 ], [ %20, %81 ], [ %20, %76 ], [ %20, %71 ], [ %20, %68 ]
%130 = phi double [ %21, %124 ], [ %21, %122 ], [ %21, %116 ], [ %21, %112 ], [ %21, %60 ], [ %21, %57 ], [ %21, %50 ], [ %21, %47 ], [ %21, %40 ], [ %21, %37 ], [ %83, %96 ], [ %83, %91 ], [ %83, %86 ], [ %83, %81 ], [ %21, %76 ], [ %21, %71 ], [ %21, %68 ]
%131 = phi double [ %22, %124 ], [ %22, %122 ], [ %22, %116 ], [ %22, %112 ], [ %22, %60 ], [ %22, %57 ], [ %22, %50 ], [ %22, %47 ], [ %22, %40 ], [ %22, %37 ], [ %78, %96 ], [ %78, %91 ], [ %78, %86 ], [ %78, %81 ], [ %78, %76 ], [ %22, %71 ], [ %22, %68 ]
%132 = phi double [ %23, %124 ], [ %23, %122 ], [ %23, %116 ], [ %23, %112 ], [ %23, %60 ], [ %23, %57 ], [ %23, %50 ], [ %23, %47 ], [ %23, %40 ], [ %23, %37 ], [ %73, %96 ], [ %73, %91 ], [ %73, %86 ], [ %73, %81 ], [ %73, %76 ], [ %73, %71 ], [ %23, %68 ]
%133 = phi i32 [ %24, %124 ], [ %24, %122 ], [ %24, %116 ], [ %24, %112 ], [ %24, %60 ], [ %24, %57 ], [ %52, %50 ], [ %24, %47 ], [ %24, %40 ], [ %24, %37 ], [ %24, %96 ], [ %24, %91 ], [ %24, %86 ], [ %24, %81 ], [ %24, %76 ], [ %24, %71 ], [ %24, %68 ]
%134 = phi i32 [ %25, %124 ], [ %25, %122 ], [ %25, %116 ], [ %25, %112 ], [ %25, %60 ], [ %25, %57 ], [ %25, %50 ], [ %25, %47 ], [ %42, %40 ], [ %25, %37 ], [ %25, %96 ], [ %25, %91 ], [ %25, %86 ], [ %25, %81 ], [ %25, %76 ], [ %25, %71 ], [ %25, %68 ]
%135 = phi i8** [ %26, %124 ], [ %26, %122 ], [ %114, %116 ], [ %114, %112 ], [ %58, %60 ], [ %58, %57 ], [ %48, %50 ], [ %48, %47 ], [ %38, %40 ], [ %38, %37 ], [ %94, %96 ], [ %94, %91 ], [ %89, %86 ], [ %84, %81 ], [ %79, %76 ], [ %74, %71 ], [ %69, %68 ]
%136 = phi i8* [ %125, %124 ], [ %32, %122 ], [ %32, %116 ], [ %32, %112 ], [ %32, %60 ], [ %32, %57 ], [ %32, %50 ], [ %32, %47 ], [ %32, %40 ], [ %32, %37 ], [ %32, %96 ], [ %32, %91 ], [ %32, %86 ], [ %32, %81 ], [ %32, %76 ], [ %32, %71 ], [ %32, %68 ]
%137 = phi double [ %31, %124 ], [ %31, %122 ], [ %113, %116 ], [ %113, %112 ], [ %31, %60 ], [ %31, %57 ], [ %31, %50 ], [ %31, %47 ], [ %31, %40 ], [ %31, %37 ], [ %31, %96 ], [ %31, %91 ], [ %31, %86 ], [ %31, %81 ], [ %31, %76 ], [ %31, %71 ], [ %31, %68 ]
%138 = phi double [ %30, %124 ], [ %30, %122 ], [ %121, %116 ], [ %30, %112 ], [ %30, %60 ], [ %30, %57 ], [ %30, %50 ], [ %30, %47 ], [ %30, %40 ], [ %30, %37 ], [ %30, %96 ], [ %30, %91 ], [ %30, %86 ], [ %30, %81 ], [ %30, %76 ], [ %30, %71 ], [ %30, %68 ]
%139 = phi i8* [ %29, %124 ], [ %29, %122 ], [ %29, %116 ], [ %29, %112 ], [ %63, %60 ], [ %29, %57 ], [ %29, %50 ], [ %29, %47 ], [ %29, %40 ], [ %29, %37 ], [ %29, %96 ], [ %29, %91 ], [ %29, %86 ], [ %29, %81 ], [ %29, %76 ], [ %29, %71 ], [ %29, %68 ]
%140 = phi i32 [ %28, %124 ], [ %28, %122 ], [ %28, %116 ], [ %28, %112 ], [ %28, %60 ], [ %28, %57 ], [ %28, %50 ], [ %28, %47 ], [ %28, %40 ], [ %28, %37 ], [ 1, %96 ], [ 1, %91 ], [ 1, %86 ], [ 1, %81 ], [ 1, %76 ], [ 1, %71 ], [ 1, %68 ]
%141 = phi i32 [ %27, %124 ], [ %27, %122 ], [ 1, %116 ], [ 1, %112 ], [ %27, %60 ], [ %27, %57 ], [ %27, %50 ], [ %27, %47 ], [ %27, %40 ], [ %27, %37 ], [ %27, %96 ], [ %27, %91 ], [ %27, %86 ], [ %27, %81 ], [ %27, %76 ], [ %27, %71 ], [ %27, %68 ]
%142 = getelementptr inbounds i8*, i8** %135, i64 1
%143 = icmp ult i8** %142, %15
br i1 %143, label %17, label %144
144: ; preds = %126
%145 = tail call i64 @strcmp(i8* %136, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0))
%146 = icmp eq i64 %145, 0
br i1 %146, label %152, label %147
147: ; preds = %144
%148 = tail call i32* @fopen(i8* %136, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0))
%149 = icmp eq i32* %148, null
br i1 %149, label %150, label %154
150: ; preds = %147
%151 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str.9, i64 0, i64 0), i8* %136)
br label %277
152: ; preds = %144
%153 = load i32*, i32** @stdin
br label %154
154: ; preds = %147, %152
%155 = phi i32* [ %148, %147 ], [ %153, %152 ]
%156 = call i64 @fgets(i8* %8, i32 1023, i32* %155)
%157 = icmp eq i64 %156, 0
br i1 %157, label %270, label %158
158: ; preds = %154
%159 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 0
%160 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 100
%161 = icmp eq i32 %141, 0
%162 = icmp eq i32 %140, 0
%163 = zext i32 %134 to i64
%164 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 %163
%165 = add i32 %134, -1
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 %166
%168 = zext i32 %133 to i64
%169 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 %168
%170 = add i32 %133, -1
%171 = zext i32 %170 to i64
%172 = getelementptr inbounds [100 x i8*], [100 x i8*]* %4, i64 0, i64 %171
br label %173
173: ; preds = %158, %267
%174 = load i8, i8* %8
%175 = icmp eq i8 %174, 35
br i1 %175, label %176, label %179
176: ; preds = %173
%177 = load i32, i32* @stdout
%178 = call i32 @fputs(i8* %8, i32 %177)
br label %267
179: ; preds = %173
%180 = call i8* @strdup(i8* %8)
store i8* %180, i8** %3
%181 = call i8* @strsep(i8** %3, i8* %139)
store i8* %181, i8** %159
%182 = icmp eq i8* %181, null
br i1 %182, label %264, label %183
183: ; preds = %179, %191
%184 = phi i8* [ %193, %191 ], [ %181, %179 ]
%185 = phi i8** [ %192, %191 ], [ %159, %179 ]
%186 = load i8, i8* %184
%187 = icmp eq i8 %186, 0
br i1 %187, label %191, label %188
188: ; preds = %183
%189 = getelementptr inbounds i8*, i8** %185, i64 1
%190 = icmp ult i8** %189, %160
br i1 %190, label %191, label %195
191: ; preds = %188, %183
%192 = phi i8** [ %189, %188 ], [ %185, %183 ]
%193 = call i8* @strsep(i8** %3, i8* %139)
store i8* %193, i8** %192
%194 = icmp eq i8* %193, null
br i1 %194, label %195, label %183
195: ; preds = %191, %188
%196 = phi i8** [ %192, %191 ], [ %189, %188 ]
%197 = icmp ugt i8** %196, %159
br i1 %197, label %198, label %264
198: ; preds = %195
%199 = icmp ugt i8** %164, %196
br i1 %199, label %203, label %200
200: ; preds = %198
%201 = load i8*, i8** %167
%202 = call double @atof(i8* %201)
br label %203
203: ; preds = %198, %200
%204 = phi double [ %202, %200 ], [ 0x7FF8000000000000, %198 ]
%205 = icmp ugt i8** %169, %196
br i1 %205, label %209, label %206
206: ; preds = %203
%207 = load i8*, i8** %172
%208 = call double @atof(i8* %207)
br label %209
209: ; preds = %206, %203
%210 = phi double [ %208, %206 ], [ 0x7FF8000000000000, %203 ]
br i1 %161, label %244, label %211
211: ; preds = %209
%212 = load double, double* @M_PI
%213 = fdiv double %212, 1.800000e+02
%214 = fmul double %204, %213
%215 = fmul double %213, %210
%216 = call double @cos(double %215)
%217 = call double @cos(double %138)
%218 = fmul double %216, %217
%219 = fsub double %214, %137
%220 = call double @cos(double %219)
%221 = call double @sin(double %215)
%222 = call double @sin(double %138)
%223 = fmul double %221, %222
%224 = call double @llvm.fmuladd.f64(double %218, double %220, double %223)
%225 = call double @acos(double %224)
%226 = call double @sin(double %215)
%227 = call double @cos(double %225)
%228 = call double @sin(double %138)
%229 = fneg double %227
%230 = call double @llvm.fmuladd.f64(double %229, double %228, double %226)
%231 = call double @cos(double %215)
%232 = call double @sin(double %219)
%233 = fmul double %231, %232
%234 = call double @cos(double %138)
%235 = fmul double %233, %234
%236 = call double @atan2(double %230, double %235)
%237 = load double, double* @M_PI
%238 = fdiv double 6.480000e+05, %237
%239 = fmul double %225, %238
%240 = call double @cos(double %236)
%241 = fmul double %240, %239
%242 = call double @sin(double %236)
%243 = fmul double %239, %242
br label %244
244: ; preds = %211, %209
%245 = phi double [ %210, %209 ], [ %243, %211 ]
%246 = phi double [ %204, %209 ], [ %241, %211 ]
br i1 %162, label %254, label %247
247: ; preds = %244
%248 = fmul double %245, %131
%249 = call double @llvm.fmuladd.f64(double %246, double %132, double %248)
%250 = fadd double %130, %249
%251 = fmul double %245, %128
%252 = call double @llvm.fmuladd.f64(double %246, double %129, double %251)
%253 = fadd double %127, %252
br label %254
254: ; preds = %247, %244
%255 = phi double [ %245, %244 ], [ %253, %247 ]
%256 = phi double [ %246, %244 ], [ %250, %247 ]
%257 = call i32 @isnan(double %256)
%258 = icmp eq i32 %257, 0
br i1 %258, label %259, label %264
259: ; preds = %254
%260 = call i32 @isnan(double %255)
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %264
262: ; preds = %259
%263 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.10, i64 0, i64 0), double %256, double %255, i8* %8)
br label %264
264: ; preds = %179, %254, %259, %262, %195
%265 = load i8*, i8** %3
%266 = call i32 @free(i8* %265)
br label %267
267: ; preds = %264, %176
%268 = call i64 @fgets(i8* %8, i32 1023, i32* %155)
%269 = icmp eq i64 %268, 0
br i1 %269, label %270, label %173
270: ; preds = %267, %154
%271 = load i32*, i32** @stdin
%272 = icmp eq i32* %155, %271
br i1 %272, label %275, label %273
273: ; preds = %270
%274 = call i32 @fclose(i32* %155)
br label %275
275: ; preds = %273, %270
%276 = call i32 @free(i8* %139)
br label %277
277: ; preds = %275, %150, %10
%278 = phi i32 [ -1, %10 ], [ 0, %150 ], [ 0, %275 ]
ret i32 %278
}