#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 */

/* Variables and functions */
double atof(char *);
int checkFormat(char *);
int fabs(double);
int /*<<< orphan*/ getSubstrings(char *, char **, int *);
int /*<<< orphan*/ strcpy(char *, char *);
int strlen(char *);
double strtod(char *, char **);
int sexToDegree(char *cra, char *cdec, double *ra, double *dec) {
  char crain[40], cdecin[40], *subst[10], teststr[40], coordin[40];
  char tmph[40], tmpd[40], tmpm[40], tmps[40];
  char chr, *p, *end;
  int ideg, syntax, lonstatus, latstatus, testlen;
  double scale, hr, deg, min, sec, testval;
  int i, leng;
  int isign, nsub, nh, nd, nm, ns;
  strcpy(crain, cra);
  strcpy(cdecin, cdec);
  ideg = 0;
  hr = 0;
  min = 0;
  sec = 0;
  strcpy(tmph, "0");
  strcpy(tmpm, "0");
  strcpy(tmps, "0");
  strcpy(coordin, crain);
  isign = 1;
  leng = strlen(crain);
  i = 0;
  while (crain[i] == ' ')
    i++;
  if (crain[i] == '-') {
    isign = -1;
    crain[i] = ' ';
  } else if (crain[i] == '+')
    crain[i] = ' ';
  nd = 0;
  nh = -1;
  nm = -1;
  ns = -1;
  leng = strlen(crain);
  for (i = 0; i <= leng - 1; i++) {
    chr = crain[i];
    if (chr == 'h' || chr == 'H')
      nh = i;
    else if (chr == 'd' || chr == 'D') {
      ideg = 1;
      nh = i;
    }
    if (chr == 'm' || chr == 'M')
      nm = i;
    if (chr == 's' || chr == 'S')
      ns = i;
  }
  if ((nh > 0 && nm > 0 && nh > nm) || (nh > 0 && ns > 0 && nh > ns) ||
      (nm > 0 && ns > 0 && nm > ns))
    return 1;
  if (nh > 0) {
    p = crain;
    strcpy(tmph, p);
    tmph[nh] = '\0';
  }
  if (nm > 0) {
    if (nh > 0 && nm - 1 > nh) {
      p = crain + nh + 1;
      strcpy(tmpm, p);
      tmpm[nm - nh - 1] = '\0';
    } else {
      p = crain;
      strcpy(tmpm, p);
      tmpm[nm] = '\0';
    }
  }
  if (ns > 0) {
    if (nm > 0 && ns - 1 > nm) {
      p = crain + nm + 1;
      strcpy(tmps, p);
      tmps[ns - nm - 1] = '\0';
    } else if (nh > 0 && ns - 1 > nh) {
      p = crain + nh + 1;
      strcpy(tmps, p);
      tmps[ns - nh - 1] = '\0';
    } else {
      p = crain;
      strcpy(tmps, p);
      tmps[ns] = '\0';
    }
  }
  nsub = 0;
  if (nh == -1 && nm == -1 && ns == -1) {
    getSubstrings(crain, subst, &nsub);
    if (nsub >= 3) {
      strcpy(tmph, subst[0]);
      strcpy(tmpm, subst[1]);
      strcpy(tmps, subst[2]);
    }
    if (nsub == 2) {
      strcpy(tmpm, subst[0]);
      strcpy(tmps, subst[1]);
    }
    if (nsub == 1)
      strcpy(tmps, subst[0]);
  } else if (nm == -1 && ns == -1) {
    getSubstrings((crain + nh + 1), subst, &nsub);
    if (nsub == 2) {
      strcpy(tmpm, subst[0]);
      strcpy(tmps, subst[1]);
    }
    if (nsub == 1)
      strcpy(tmpm, subst[0]);
  } else if (ns == -1) {
    getSubstrings((crain + nm + 1), subst, &nsub);
    if (nsub == 1)
      strcpy(tmps, subst[0]);
  }
  syntax = checkFormat(tmps);
  if (syntax == 1) {
    syntax = checkFormat(tmpm);
    syntax = checkFormat(tmph);
  }
  lonstatus = syntax;
  if (syntax == 1) {
    sec = atof(tmps);
    if (sec > 60.) {
      i = (int)(sec / 10000.);
      hr = (double)i;
      i = (int)((sec - hr * 10000.) / 100.);
      min = (double)i;
      sec = sec - hr * 10000. - min * 100.;
    } else {
      hr = atof(tmph);
      min = atof(tmpm);
      sec = atof(tmps);
    }
  }
  scale = 15.;
  if (ideg == 1)
    scale = 1.;
  *ra = isign * scale * (hr + (min / 60.) + (sec / 3600.));
  strcpy(teststr, coordin);
  testlen = strlen(teststr);
  testval = strtod(teststr, &end);
  for (i = 0; i < strlen(teststr); ++i)
    if (teststr[i] == '.')
      teststr[i] = '\0';
  if (end == teststr + testlen && strlen(teststr) < 5) {
    *ra = testval;
    lonstatus = 0;
  }
  deg = 0;
  min = 0;
  sec = 0;
  strcpy(tmpd, "0");
  strcpy(tmpm, "0");
  strcpy(tmps, "0");
  strcpy(coordin, cdecin);
  isign = 1;
  leng = strlen(cdecin);
  i = 0;
  while (cdecin[i] == ' ')
    i++;
  if (cdecin[i] == '-') {
    isign = -1;
    cdecin[i] = ' ';
  } else if (cdecin[i] == '+')
    cdecin[i] = ' ';
  nd = -1;
  nm = -1;
  ns = -1;
  leng = strlen(cdecin);
  for (i = 0; i <= leng - 1; i++) {
    chr = cdecin[i];
    if (chr == 'd' || chr == 'D')
      nd = i;
    if (chr == 'm' || chr == 'M')
      nm = i;
    if (chr == 's' || chr == 'S')
      ns = i;
  }
  if ((nd > 0 && nm > 0 && nd > nm) || (nd > 0 && ns > 0 && nd > ns) ||
      (nm > 0 && ns > 0 && nm > ns))
    return 1;
  if (nd > 0) {
    p = cdecin;
    strcpy(tmpd, p);
    tmpd[nd] = '\0';
  }
  if (nm > 0) {
    if (nd > 0 && nm - 1 > nd) {
      p = cdecin + nd + 1;
      strcpy(tmpm, p);
      tmpm[nm - nd - 1] = '\0';
    } else {
      p = cdecin;
      strcpy(tmpm, p);
      tmpm[nm] = '\0';
    }
  }
  if (ns > 0) {
    if (nm > 0 && ns - 1 > nm) {
      p = cdecin + nm + 1;
      strcpy(tmps, p);
      tmps[ns - nm - 1] = '\0';
    } else if (nd > 0 && ns - 1 > nd) {
      p = cdecin + nd + 1;
      strcpy(tmps, p);
      tmps[ns - nd - 1] = '\0';
    } else {
      p = cdecin;
      strcpy(tmps, p);
      tmps[ns] = '\0';
    }
  }
  nsub = 0;
  if (nd == -1 && nm == -1 && ns == -1) {
    getSubstrings(cdecin, subst, &nsub);
    if (nsub >= 3) {
      strcpy(tmpd, subst[0]);
      strcpy(tmpm, subst[1]);
      strcpy(tmps, subst[2]);
    }
    if (nsub == 2) {
      strcpy(tmpm, subst[0]);
      strcpy(tmps, subst[1]);
    }
    if (nsub == 1)
      strcpy(tmps, subst[0]);
  } else if (nm == -1 && ns == -1) {
    getSubstrings((cdecin + nd + 1), subst, &nsub);
    if (nsub == 2) {
      strcpy(tmpm, subst[0]);
      strcpy(tmpm, subst[0]);
      strcpy(tmps, subst[1]);
    }
    if (nsub == 1)
      strcpy(tmpm, subst[0]);
  } else if (ns == -1) {
    getSubstrings((cdecin + nm + 1), subst, &nsub);
    if (nsub == 1)
      strcpy(tmps, subst[0]);
  }
  syntax = checkFormat(tmps);
  if (syntax == 1)
    syntax = checkFormat(tmpm);
  if (syntax == 1)
    syntax = checkFormat(tmpd);
  latstatus = syntax;
  if (syntax == 1) {
    sec = atof(tmps);
    if (sec > 60.) {
      i = (int)(sec / 10000.);
      deg = (double)i;
      i = (int)((sec - deg * 10000.) / 100.);
      min = (double)i;
      sec = sec - deg * 10000. - min * 100.;
    } else {
      deg = atof(tmpd);
      min = atof(tmpm);
      sec = atof(tmps);
    }
  }
  *dec = isign * (deg + (min / 60.) + (sec / 3600.));
  strcpy(teststr, coordin);
  testlen = strlen(teststr);
  testval = strtod(teststr, &end);
  for (i = 0; i < strlen(teststr); ++i)
    if (teststr[i] == '.')
      teststr[i] = '\0';
  if (end == teststr + testlen && strlen(teststr) < 5) {
    *dec = testval;
    latstatus = 1;
    if (fabs(*dec) > 90.)
      latstatus = 0;
  }
  if (lonstatus == 0 && latstatus == 0)
    return (3);
  else if (lonstatus == 0)
    return (1);
  else if (latstatus == 0)
    return (2);
  else
    return (0);
}


x86 assembly (clang, -O0):
<sexToDegree>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x80(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x0,-0x20c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
lea    -0x160(%rbp),%rdi
lea    0x1e5a(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x1c0(%rbp),%rdi
lea    0x1e47(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
lea    0x1e34(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x130(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x1,-0x25c(%rbp)
lea    -0x50(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x258(%rbp)
movl   $0x0,-0x254(%rbp)
movslq -0x254(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x20,%eax
jne    1265 <sexToDegree+0xf5>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    123c <sexToDegree+0xcc>
movslq -0x254(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x2d,%eax
jne    1295 <sexToDegree+0x125>
movl   $0xffffffff,-0x25c(%rbp)
ff ff ff
movslq -0x254(%rbp),%rax
movb   $0x20,-0x50(%rbp,%rax,1)
jmp    12bb <sexToDegree+0x14b>
movslq -0x254(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
cmp    $0x2b,%eax
jne    12b6 <sexToDegree+0x146>
movslq -0x254(%rbp),%rax
movb   $0x20,-0x50(%rbp,%rax,1)
jmp    12bb <sexToDegree+0x14b>
movl   $0x0,-0x268(%rbp)
movl   $0xffffffff,-0x264(%rbp)
ff ff ff
movl   $0xffffffff,-0x26c(%rbp)
ff ff ff
movl   $0xffffffff,-0x270(%rbp)
ff ff ff
lea    -0x50(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x258(%rbp)
movl   $0x0,-0x254(%rbp)
mov    -0x254(%rbp),%eax
mov    -0x258(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1401 <sexToDegree+0x291>
movslq -0x254(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%al
mov    %al,-0x1f1(%rbp)
movsbl -0x1f1(%rbp),%eax
cmp    $0x68,%eax
je     1344 <sexToDegree+0x1d4>
movsbl -0x1f1(%rbp),%eax
cmp    $0x48,%eax
jne    1355 <sexToDegree+0x1e5>
mov    -0x254(%rbp),%eax
mov    %eax,-0x264(%rbp)
jmp    1390 <sexToDegree+0x220>
movsbl -0x1f1(%rbp),%eax
cmp    $0x64,%eax
je     1375 <sexToDegree+0x205>
movsbl -0x1f1(%rbp),%eax
cmp    $0x44,%eax
jne    138b <sexToDegree+0x21b>
movl   $0x1,-0x20c(%rbp)
mov    -0x254(%rbp),%eax
mov    %eax,-0x264(%rbp)
jmp    1390 <sexToDegree+0x220>
movsbl -0x1f1(%rbp),%eax
cmp    $0x6d,%eax
je     13b0 <sexToDegree+0x240>
movsbl -0x1f1(%rbp),%eax
cmp    $0x4d,%eax
jne    13bc <sexToDegree+0x24c>
mov    -0x254(%rbp),%eax
mov    %eax,-0x26c(%rbp)
movsbl -0x1f1(%rbp),%eax
cmp    $0x73,%eax
je     13dc <sexToDegree+0x26c>
movsbl -0x1f1(%rbp),%eax
cmp    $0x53,%eax
jne    13e8 <sexToDegree+0x278>
mov    -0x254(%rbp),%eax
mov    %eax,-0x270(%rbp)
jmp    13ed <sexToDegree+0x27d>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    12fc <sexToDegree+0x18c>
cmpl   $0x0,-0x264(%rbp)
jle    142d <sexToDegree+0x2bd>
cmpl   $0x0,-0x26c(%rbp)
jle    142d <sexToDegree+0x2bd>
mov    -0x264(%rbp),%eax
cmp    -0x26c(%rbp),%eax
jg     1485 <sexToDegree+0x315>
cmpl   $0x0,-0x264(%rbp)
jle    1459 <sexToDegree+0x2e9>
cmpl   $0x0,-0x270(%rbp)
jle    1459 <sexToDegree+0x2e9>
mov    -0x264(%rbp),%eax
cmp    -0x270(%rbp),%eax
jg     1485 <sexToDegree+0x315>
cmpl   $0x0,-0x26c(%rbp)
jle    1491 <sexToDegree+0x321>
cmpl   $0x0,-0x270(%rbp)
jle    1491 <sexToDegree+0x321>
mov    -0x26c(%rbp),%eax
cmp    -0x270(%rbp),%eax
jle    1491 <sexToDegree+0x321>
movl   $0x1,-0x4(%rbp)
jmp    25fb <sexToDegree+0x148b>
cmpl   $0x0,-0x264(%rbp)
jle    14cb <sexToDegree+0x35b>
lea    -0x50(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x160(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x264(%rbp),%rax
movb   $0x0,-0x160(%rbp,%rax,1)
cmpl   $0x0,-0x26c(%rbp)
jle    1576 <sexToDegree+0x406>
cmpl   $0x0,-0x264(%rbp)
jle    1544 <sexToDegree+0x3d4>
mov    -0x26c(%rbp),%eax
sub    $0x1,%eax
cmp    -0x264(%rbp),%eax
jle    1544 <sexToDegree+0x3d4>
lea    -0x50(%rbp),%rax
movslq -0x264(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x26c(%rbp),%eax
sub    -0x264(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1c0(%rbp,%rax,1)
jmp    1571 <sexToDegree+0x401>
lea    -0x50(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x26c(%rbp),%rax
movb   $0x0,-0x1c0(%rbp,%rax,1)
jmp    1576 <sexToDegree+0x406>
cmpl   $0x0,-0x270(%rbp)
jle    1692 <sexToDegree+0x522>
cmpl   $0x0,-0x26c(%rbp)
jle    15ef <sexToDegree+0x47f>
mov    -0x270(%rbp),%eax
sub    $0x1,%eax
cmp    -0x26c(%rbp),%eax
jle    15ef <sexToDegree+0x47f>
lea    -0x50(%rbp),%rax
movslq -0x26c(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x270(%rbp),%eax
sub    -0x26c(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    168d <sexToDegree+0x51d>
cmpl   $0x0,-0x264(%rbp)
jle    165b <sexToDegree+0x4eb>
mov    -0x270(%rbp),%eax
sub    $0x1,%eax
cmp    -0x264(%rbp),%eax
jle    165b <sexToDegree+0x4eb>
lea    -0x50(%rbp),%rax
movslq -0x264(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x270(%rbp),%eax
sub    -0x264(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    1688 <sexToDegree+0x518>
lea    -0x50(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x270(%rbp),%rax
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    168d <sexToDegree+0x51d>
jmp    1692 <sexToDegree+0x522>
movl   $0x0,-0x260(%rbp)
cmpl   $0xffffffff,-0x264(%rbp)
jne    1778 <sexToDegree+0x608>
cmpl   $0xffffffff,-0x26c(%rbp)
jne    1778 <sexToDegree+0x608>
cmpl   $0xffffffff,-0x270(%rbp)
jne    1778 <sexToDegree+0x608>
lea    -0x50(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x3,-0x260(%rbp)
jl     1720 <sexToDegree+0x5b0>
lea    -0x160(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1c0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x2,-0x260(%rbp)
jne    1753 <sexToDegree+0x5e3>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x1,-0x260(%rbp)
jne    1773 <sexToDegree+0x603>
lea    -0x1f0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    1870 <sexToDegree+0x700>
cmpl   $0xffffffff,-0x26c(%rbp)
jne    180f <sexToDegree+0x69f>
cmpl   $0xffffffff,-0x270(%rbp)
jne    180f <sexToDegree+0x69f>
lea    -0x50(%rbp),%rdi
movslq -0x264(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x2,-0x260(%rbp)
jne    17ea <sexToDegree+0x67a>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x1,-0x260(%rbp)
jne    180a <sexToDegree+0x69a>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    186b <sexToDegree+0x6fb>
cmpl   $0xffffffff,-0x270(%rbp)
jne    1866 <sexToDegree+0x6f6>
lea    -0x50(%rbp),%rdi
movslq -0x26c(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x1,-0x260(%rbp)
jne    1861 <sexToDegree+0x6f1>
lea    -0x1f0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    1866 <sexToDegree+0x6f6>
jmp    186b <sexToDegree+0x6fb>
jmp    1870 <sexToDegree+0x700>
lea    -0x1f0(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
cmpl   $0x1,-0x210(%rbp)
jne    18b3 <sexToDegree+0x743>
lea    -0x1c0(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
lea    -0x160(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
mov    -0x210(%rbp),%eax
mov    %eax,-0x214(%rbp)
cmpl   $0x1,-0x210(%rbp)
jne    1a39 <sexToDegree+0x8c9>
lea    -0x1f0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movsd  0x1710(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19f8 <sexToDegree+0x888>
movsd  -0x248(%rbp),%xmm0
ff
movsd  0x1706(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x254(%rbp)
cvtsi2sdl -0x254(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x248(%rbp),%xmm1
ff
movsd  -0x230(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x16b9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x16a1(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x254(%rbp)
cvtsi2sdl -0x254(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x165c(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x240(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x1625(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
jmp    1a34 <sexToDegree+0x8c4>
lea    -0x160(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x230(%rbp)
ff
lea    -0x1c0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x240(%rbp)
ff
lea    -0x1f0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x248(%rbp)
ff
jmp    1a39 <sexToDegree+0x8c9>
movsd  0x15d7(%rip),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
cmpl   $0x1,-0x20c(%rbp)
jne    1a66 <sexToDegree+0x8f6>
movsd  0x15c2(%rip),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
cvtsi2sdl -0x25c(%rbp),%xmm0
ff
mulsd  -0x228(%rbp),%xmm0
ff
movsd  -0x230(%rbp),%xmm1
ff
movsd  -0x240(%rbp),%xmm2
ff
movsd  0x1572(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x248(%rbp),%xmm2
ff
movsd  0x1582(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
lea    -0x100(%rbp),%rdi
lea    -0x130(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x21c(%rbp)
lea    -0x100(%rbp),%rdi
lea    -0x208(%rbp),%rsi
call   1040 <strtod@plt>
movsd  %xmm0,-0x250(%rbp)
ff
movl   $0x0,-0x254(%rbp)
mov    -0x254(%rbp),%eax
mov    %eax,-0x274(%rbp)
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0x274(%rbp),%eax
cmp    %ecx,%eax
jge    1b6c <sexToDegree+0x9fc>
movslq -0x254(%rbp),%rax
movsbl -0x100(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
jne    1b53 <sexToDegree+0x9e3>
movslq -0x254(%rbp),%rax
movb   $0x0,-0x100(%rbp,%rax,1)
jmp    1b58 <sexToDegree+0x9e8>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    1b04 <sexToDegree+0x994>
mov    -0x208(%rbp),%rax
lea    -0x100(%rbp),%rcx
movslq -0x21c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    1bbc <sexToDegree+0xa4c>
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
cmp    $0x5,%eax
jge    1bbc <sexToDegree+0xa4c>
movsd  -0x250(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x214(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
lea    -0x190(%rbp),%rdi
lea    0x144d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x1c0(%rbp),%rdi
lea    0x143a(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
lea    0x1427(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x130(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1030 <strcpy@plt>
movl   $0x1,-0x25c(%rbp)
lea    -0x80(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x258(%rbp)
movl   $0x0,-0x254(%rbp)
movslq -0x254(%rbp),%rax
movsbl -0x80(%rbp,%rax,1),%eax
cmp    $0x20,%eax
jne    1c72 <sexToDegree+0xb02>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    1c49 <sexToDegree+0xad9>
movslq -0x254(%rbp),%rax
movsbl -0x80(%rbp,%rax,1),%eax
cmp    $0x2d,%eax
jne    1ca2 <sexToDegree+0xb32>
movl   $0xffffffff,-0x25c(%rbp)
ff ff ff
movslq -0x254(%rbp),%rax
movb   $0x20,-0x80(%rbp,%rax,1)
jmp    1cc8 <sexToDegree+0xb58>
movslq -0x254(%rbp),%rax
movsbl -0x80(%rbp,%rax,1),%eax
cmp    $0x2b,%eax
jne    1cc3 <sexToDegree+0xb53>
movslq -0x254(%rbp),%rax
movb   $0x20,-0x80(%rbp,%rax,1)
jmp    1cc8 <sexToDegree+0xb58>
movl   $0xffffffff,-0x268(%rbp)
ff ff ff
movl   $0xffffffff,-0x26c(%rbp)
ff ff ff
movl   $0xffffffff,-0x270(%rbp)
ff ff ff
lea    -0x80(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x258(%rbp)
movl   $0x0,-0x254(%rbp)
mov    -0x254(%rbp),%eax
mov    -0x258(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1dc4 <sexToDegree+0xc54>
movslq -0x254(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%al
mov    %al,-0x1f1(%rbp)
movsbl -0x1f1(%rbp),%eax
cmp    $0x64,%eax
je     1d47 <sexToDegree+0xbd7>
movsbl -0x1f1(%rbp),%eax
cmp    $0x44,%eax
jne    1d53 <sexToDegree+0xbe3>
mov    -0x254(%rbp),%eax
mov    %eax,-0x268(%rbp)
movsbl -0x1f1(%rbp),%eax
cmp    $0x6d,%eax
je     1d73 <sexToDegree+0xc03>
movsbl -0x1f1(%rbp),%eax
cmp    $0x4d,%eax
jne    1d7f <sexToDegree+0xc0f>
mov    -0x254(%rbp),%eax
mov    %eax,-0x26c(%rbp)
movsbl -0x1f1(%rbp),%eax
cmp    $0x73,%eax
je     1d9f <sexToDegree+0xc2f>
movsbl -0x1f1(%rbp),%eax
cmp    $0x53,%eax
jne    1dab <sexToDegree+0xc3b>
mov    -0x254(%rbp),%eax
mov    %eax,-0x270(%rbp)
jmp    1db0 <sexToDegree+0xc40>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    1cff <sexToDegree+0xb8f>
cmpl   $0x0,-0x268(%rbp)
jle    1df0 <sexToDegree+0xc80>
cmpl   $0x0,-0x26c(%rbp)
jle    1df0 <sexToDegree+0xc80>
mov    -0x268(%rbp),%eax
cmp    -0x26c(%rbp),%eax
jg     1e48 <sexToDegree+0xcd8>
cmpl   $0x0,-0x268(%rbp)
jle    1e1c <sexToDegree+0xcac>
cmpl   $0x0,-0x270(%rbp)
jle    1e1c <sexToDegree+0xcac>
mov    -0x268(%rbp),%eax
cmp    -0x270(%rbp),%eax
jg     1e48 <sexToDegree+0xcd8>
cmpl   $0x0,-0x26c(%rbp)
jle    1e54 <sexToDegree+0xce4>
cmpl   $0x0,-0x270(%rbp)
jle    1e54 <sexToDegree+0xce4>
mov    -0x26c(%rbp),%eax
cmp    -0x270(%rbp),%eax
jle    1e54 <sexToDegree+0xce4>
movl   $0x1,-0x4(%rbp)
jmp    25fb <sexToDegree+0x148b>
cmpl   $0x0,-0x268(%rbp)
jle    1e8e <sexToDegree+0xd1e>
lea    -0x80(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x190(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x268(%rbp),%rax
movb   $0x0,-0x190(%rbp,%rax,1)
cmpl   $0x0,-0x26c(%rbp)
jle    1f39 <sexToDegree+0xdc9>
cmpl   $0x0,-0x268(%rbp)
jle    1f07 <sexToDegree+0xd97>
mov    -0x26c(%rbp),%eax
sub    $0x1,%eax
cmp    -0x268(%rbp),%eax
jle    1f07 <sexToDegree+0xd97>
lea    -0x80(%rbp),%rax
movslq -0x268(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x26c(%rbp),%eax
sub    -0x268(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1c0(%rbp,%rax,1)
jmp    1f34 <sexToDegree+0xdc4>
lea    -0x80(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1c0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x26c(%rbp),%rax
movb   $0x0,-0x1c0(%rbp,%rax,1)
jmp    1f39 <sexToDegree+0xdc9>
cmpl   $0x0,-0x270(%rbp)
jle    2055 <sexToDegree+0xee5>
cmpl   $0x0,-0x26c(%rbp)
jle    1fb2 <sexToDegree+0xe42>
mov    -0x270(%rbp),%eax
sub    $0x1,%eax
cmp    -0x26c(%rbp),%eax
jle    1fb2 <sexToDegree+0xe42>
lea    -0x80(%rbp),%rax
movslq -0x26c(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x270(%rbp),%eax
sub    -0x26c(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    2050 <sexToDegree+0xee0>
cmpl   $0x0,-0x268(%rbp)
jle    201e <sexToDegree+0xeae>
mov    -0x270(%rbp),%eax
sub    $0x1,%eax
cmp    -0x268(%rbp),%eax
jle    201e <sexToDegree+0xeae>
lea    -0x80(%rbp),%rax
movslq -0x268(%rbp),%rcx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x270(%rbp),%eax
sub    -0x268(%rbp),%eax
sub    $0x1,%eax
cltq
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    204b <sexToDegree+0xedb>
lea    -0x80(%rbp),%rax
mov    %rax,-0x200(%rbp)
lea    -0x1f0(%rbp),%rdi
mov    -0x200(%rbp),%rsi
call   1030 <strcpy@plt>
movslq -0x270(%rbp),%rax
movb   $0x0,-0x1f0(%rbp,%rax,1)
jmp    2050 <sexToDegree+0xee0>
jmp    2055 <sexToDegree+0xee5>
movl   $0x0,-0x260(%rbp)
cmpl   $0xffffffff,-0x268(%rbp)
jne    213b <sexToDegree+0xfcb>
cmpl   $0xffffffff,-0x26c(%rbp)
jne    213b <sexToDegree+0xfcb>
cmpl   $0xffffffff,-0x270(%rbp)
jne    213b <sexToDegree+0xfcb>
lea    -0x80(%rbp),%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x3,-0x260(%rbp)
jl     20e3 <sexToDegree+0xf73>
lea    -0x190(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1c0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc0(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x2,-0x260(%rbp)
jne    2116 <sexToDegree+0xfa6>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x1,-0x260(%rbp)
jne    2136 <sexToDegree+0xfc6>
lea    -0x1f0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    2246 <sexToDegree+0x10d6>
cmpl   $0xffffffff,-0x26c(%rbp)
jne    21e5 <sexToDegree+0x1075>
cmpl   $0xffffffff,-0x270(%rbp)
jne    21e5 <sexToDegree+0x1075>
lea    -0x80(%rbp),%rdi
movslq -0x268(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x2,-0x260(%rbp)
jne    21c0 <sexToDegree+0x1050>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x1f0(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
call   1030 <strcpy@plt>
cmpl   $0x1,-0x260(%rbp)
jne    21e0 <sexToDegree+0x1070>
lea    -0x1c0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    2241 <sexToDegree+0x10d1>
cmpl   $0xffffffff,-0x270(%rbp)
jne    223c <sexToDegree+0x10cc>
lea    -0x80(%rbp),%rdi
movslq -0x26c(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
lea    -0xd0(%rbp),%rsi
lea    -0x260(%rbp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x1,-0x260(%rbp)
jne    2237 <sexToDegree+0x10c7>
lea    -0x1f0(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    223c <sexToDegree+0x10cc>
jmp    2241 <sexToDegree+0x10d1>
jmp    2246 <sexToDegree+0x10d6>
lea    -0x1f0(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
cmpl   $0x1,-0x210(%rbp)
jne    2277 <sexToDegree+0x1107>
lea    -0x1c0(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
cmpl   $0x1,-0x210(%rbp)
jne    2296 <sexToDegree+0x1126>
lea    -0x190(%rbp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,-0x210(%rbp)
mov    -0x210(%rbp),%eax
mov    %eax,-0x218(%rbp)
cmpl   $0x1,-0x210(%rbp)
jne    241c <sexToDegree+0x12ac>
lea    -0x1f0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movsd  0xd2d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    23db <sexToDegree+0x126b>
movsd  -0x248(%rbp),%xmm0
ff
movsd  0xd23(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x254(%rbp)
cvtsi2sdl -0x254(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x248(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xcd6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xcbe(%rip),%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x254(%rbp)
cvtsi2sdl -0x254(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
movsd  -0x238(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xc79(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x240(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xc42(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
jmp    2417 <sexToDegree+0x12a7>
lea    -0x190(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x238(%rbp)
ff
lea    -0x1c0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x240(%rbp)
ff
lea    -0x1f0(%rbp),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x248(%rbp)
ff
jmp    241c <sexToDegree+0x12ac>
cvtsi2sdl -0x25c(%rbp),%xmm0
ff
movsd  -0x238(%rbp),%xmm1
ff
movsd  -0x240(%rbp),%xmm2
ff
movsd  0xbc4(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x248(%rbp),%xmm2
ff
movsd  0xbd4(%rip),%xmm3
divsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
lea    -0x100(%rbp),%rdi
lea    -0x130(%rbp),%rsi
call   1030 <strcpy@plt>
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x21c(%rbp)
lea    -0x100(%rbp),%rdi
lea    -0x208(%rbp),%rsi
call   1040 <strtod@plt>
movsd  %xmm0,-0x250(%rbp)
ff
movl   $0x0,-0x254(%rbp)
mov    -0x254(%rbp),%eax
mov    %eax,-0x278(%rbp)
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
mov    %eax,%ecx
mov    -0x278(%rbp),%eax
cmp    %ecx,%eax
jge    251a <sexToDegree+0x13aa>
movslq -0x254(%rbp),%rax
movsbl -0x100(%rbp,%rax,1),%eax
ff
cmp    $0x2e,%eax
jne    2501 <sexToDegree+0x1391>
movslq -0x254(%rbp),%rax
movb   $0x0,-0x100(%rbp,%rax,1)
jmp    2506 <sexToDegree+0x1396>
mov    -0x254(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x254(%rbp)
jmp    24b2 <sexToDegree+0x1342>
mov    -0x208(%rbp),%rax
lea    -0x100(%rbp),%rcx
movslq -0x21c(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    259c <sexToDegree+0x142c>
lea    -0x100(%rbp),%rdi
call   1060 <strlen@plt>
cmp    $0x5,%eax
jge    259c <sexToDegree+0x142c>
movsd  -0x250(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x218(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
call   1070 <fabs@plt>
cvtsi2sd %eax,%xmm0
movsd  0xaad(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2597 <sexToDegree+0x1427>
movl   $0x0,-0x218(%rbp)
jmp    259c <sexToDegree+0x142c>
cmpl   $0x0,-0x214(%rbp)
jne    25c2 <sexToDegree+0x1452>
cmpl   $0x0,-0x218(%rbp)
jne    25c2 <sexToDegree+0x1452>
movl   $0x3,-0x4(%rbp)
jmp    25fb <sexToDegree+0x148b>
cmpl   $0x0,-0x214(%rbp)
jne    25db <sexToDegree+0x146b>
movl   $0x1,-0x4(%rbp)
jmp    25fb <sexToDegree+0x148b>
cmpl   $0x0,-0x218(%rbp)
jne    25f4 <sexToDegree+0x1484>
movl   $0x2,-0x4(%rbp)
jmp    25fb <sexToDegree+0x148b>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x280,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sexToDegree>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%rsp
mov    %rcx,0xd8(%rsp)
mov    %rdx,%r15
mov    %rsi,%rbp
mov    %rdi,%rsi
lea    0xb0(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0x80(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
lea    0xe87(%rip),%rbp
lea    0x1a0(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
lea    0x40(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
lea    0x10(%rsp),%rdi
mov    %rbp,%rsi
call   1030 <strcpy@plt>
lea    0x1d0(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
xor    %eax,%eax
nopl   (%rax)
movzbl 0xb0(%rsp,%rax,1),%ecx
cmp    $0x20,%cl
jne    1213 <sexToDegree+0xa3>
add    $0x1,%rax
jmp    1200 <sexToDegree+0x90>
cmp    $0x2b,%cl
je     1227 <sexToDegree+0xb7>
cmp    $0x2d,%cl
jne    1241 <sexToDegree+0xd1>
movsd  0xde3(%rip),%xmm0
jmp    122f <sexToDegree+0xbf>
movsd  0xdd1(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %eax,%eax
movb   $0x20,0xb0(%rsp,%rax,1)
20
jmp    124f <sexToDegree+0xdf>
movsd  0xdb7(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0xb0(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    1286 <sexToDegree+0x116>
mov    %eax,%r8d
cmp    $0x1,%eax
jne    1365 <sexToDegree+0x1f5>
xor    %eax,%eax
mov    $0xffffffff,%r12d
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
xor    %r13d,%r13d
jmp    13fa <sexToDegree+0x28a>
xor    %r13d,%r13d
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
mov    $0xffffffff,%r12d
movl   $0x0,0x4(%rsp)
cmp    $0xffffffff,%ebx
jne    14d1 <sexToDegree+0x361>
cmp    $0xffffffff,%ebp
jne    14d1 <sexToDegree+0x361>
cmp    $0xffffffff,%r12d
jne    14d1 <sexToDegree+0x361>
lea    0xb0(%rsp),%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
mov    0x4(%rsp),%eax
cmp    $0x3,%eax
jl     131d <sexToDegree+0x1ad>
mov    0xe0(%rsp),%rsi
lea    0x1a0(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xf0(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x2,%eax
jne    134a <sexToDegree+0x1da>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x1,%eax
jne    1631 <sexToDegree+0x4c1>
mov    0xe0(%rsp),%rsi
lea    0x10(%rsp),%rdi
jmp    1543 <sexToDegree+0x3d3>
mov    %r8d,%esi
and    $0xfffffffe,%esi
xor    %eax,%eax
mov    $0xffffffff,%r12d
mov    $0x1,%r9d
mov    $0xffffffff,%ebp
mov    $0xffffffff,%ebx
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
movzbl 0xb0(%rsp,%rax,1),%ecx
and    $0xdf,%cl
cmp    $0x44,%cl
mov    %r13d,%edi
cmove  %r9d,%edi
cmove  %eax,%ebx
cmp    $0x48,%cl
cmove  %r13d,%edi
cmove  %eax,%ebx
cmp    $0x4d,%cl
cmove  %eax,%ebp
movzbl 0xb1(%rsp,%rax,1),%edx
cmp    $0x53,%cl
cmove  %eax,%r12d
and    $0xdf,%dl
cmp    $0x44,%dl
mov    %edi,%r13d
cmove  %r9d,%r13d
lea    0x1(%rax),%ecx
cmove  %ecx,%ebx
cmp    $0x48,%dl
cmove  %edi,%r13d
cmove  %ecx,%ebx
cmp    $0x4d,%dl
cmove  %ecx,%ebp
cmp    $0x53,%dl
cmove  %ecx,%r12d
add    $0x2,%rax
cmp    %rsi,%rax
jne    1390 <sexToDegree+0x220>
test   $0x1,%r8b
je     1430 <sexToDegree+0x2c0>
mov    0xb0(%rsp,%rax,1),%cl
and    $0xdf,%cl
cmp    $0x44,%cl
mov    $0x1,%edx
cmovne %r13d,%edx
cmove  %eax,%ebx
cmp    $0x48,%cl
cmovne %edx,%r13d
cmove  %eax,%ebx
cmp    $0x4d,%cl
cmove  %eax,%ebp
cmp    $0x53,%cl
cmove  %eax,%r12d
mov    $0x1,%eax
test   %ebx,%ebx
setg   %r14b
jle    1449 <sexToDegree+0x2d9>
test   %ebp,%ebp
jle    1449 <sexToDegree+0x2d9>
cmp    %ebp,%ebx
jg     1e7f <sexToDegree+0xd0f>
test   %ebx,%ebx
jle    145b <sexToDegree+0x2eb>
test   %r12d,%r12d
jle    145b <sexToDegree+0x2eb>
cmp    %r12d,%ebx
jg     1e7f <sexToDegree+0xd0f>
test   %ebp,%ebp
jle    146d <sexToDegree+0x2fd>
test   %r12d,%r12d
jle    146d <sexToDegree+0x2fd>
cmp    %r12d,%ebp
jg     1e7f <sexToDegree+0xd0f>
test   %ebx,%ebx
jle    1587 <sexToDegree+0x417>
lea    0x1a0(%rsp),%rdi
lea    0xb0(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %ebx,%eax
movb   $0x0,0x1a0(%rsp,%rax,1)
test   %ebp,%ebp
jle    15d7 <sexToDegree+0x467>
lea    -0x1(%rbp),%ecx
cmp    %ebx,%ecx
jbe    158b <sexToDegree+0x41b>
lea    (%rsp,%rax,1),%rsi
add    $0xb1,%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    %ebx,%eax
not    %eax
add    %ebp,%eax
cltq
movb   $0x0,0x40(%rsp,%rax,1)
mov    $0x1,%r14b
jmp    15a4 <sexToDegree+0x434>
cmp    $0xffffffff,%ebp
jne    154d <sexToDegree+0x3dd>
cmp    $0xffffffff,%r12d
jne    154d <sexToDegree+0x3dd>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0xb1,%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
mov    0x4(%rsp),%eax
cmp    $0x2,%eax
jne    152d <sexToDegree+0x3bd>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x1,%eax
jne    1631 <sexToDegree+0x4c1>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
jmp    1631 <sexToDegree+0x4c1>
cmp    $0xffffffff,%r12d
jne    1631 <sexToDegree+0x4c1>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0xb1,%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x1,0x4(%rsp)
je     1353 <sexToDegree+0x1e3>
jmp    1631 <sexToDegree+0x4c1>
test   %ebp,%ebp
jle    15d7 <sexToDegree+0x467>
lea    0x40(%rsp),%rdi
lea    0xb0(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %ebp,%eax
movb   $0x0,0x40(%rsp,%rax,1)
test   %r12d,%r12d
jle    1299 <sexToDegree+0x129>
lea    -0x1(%r12),%eax
cmp    %ebp,%eax
jle    15e5 <sexToDegree+0x475>
mov    %ebp,%eax
lea    (%rsp,%rax,1),%rsi
add    $0xb1,%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
not    %ebp
add    %ebp,%r12d
movslq %r12d,%rax
jmp    1624 <sexToDegree+0x4b4>
test   %r12d,%r12d
jle    1299 <sexToDegree+0x129>
lea    -0x1(%r12),%eax
test   %r14b,%r14b
je     160f <sexToDegree+0x49f>
cmp    %ebx,%eax
jle    160f <sexToDegree+0x49f>
mov    %ebx,%eax
lea    (%rsp,%rax,1),%rsi
add    $0xb1,%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
not    %ebx
add    %ebx,%r12d
movslq %r12d,%rax
jmp    1624 <sexToDegree+0x4b4>
lea    0x10(%rsp),%rdi
lea    0xb0(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %r12d,%eax
movb   $0x0,0x10(%rsp,%rax,1)
movl   $0x0,0x4(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <checkFormat@plt>
xorpd  %xmm3,%xmm3
cmp    $0x1,%eax
jne    16d9 <sexToDegree+0x569>
lea    0x40(%rsp),%rdi
call   1080 <checkFormat@plt>
lea    0x1a0(%rsp),%rdi
call   1080 <checkFormat@plt>
xorpd  %xmm3,%xmm3
mov    %eax,%r12d
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
cmp    $0x1,%eax
jne    1721 <sexToDegree+0x5b1>
lea    0x10(%rsp),%rdi
call   1050 <atof@plt>
movapd %xmm0,%xmm4
ucomisd 0x983(%rip),%xmm0
jbe    16e6 <sexToDegree+0x576>
movsd  0x981(%rip),%xmm0
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
cvtdq2pd %xmm1,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm4
movsd  0x965(%rip),%xmm1
movapd %xmm4,%xmm0
divsd  %xmm1,%xmm0
cvttpd2dq %xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm4
jmp    171b <sexToDegree+0x5ab>
mov    %eax,%r12d
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
jmp    1721 <sexToDegree+0x5b1>
lea    0x1a0(%rsp),%rdi
movsd  %xmm4,0x70(%rsp)
call   1050 <atof@plt>
movapd %xmm0,0x160(%rsp)
lea    0x40(%rsp),%rdi
call   1050 <atof@plt>
movsd  0x70(%rsp),%xmm4
movapd 0x160(%rsp),%xmm3
mov    $0x1,%r12d
xor    %eax,%eax
cmp    $0x1,%r13d
sete   %al
lea    0x8ff(%rip),%rcx
movsd  0x8(%rsp),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
divsd  0x8cc(%rip),%xmm0
divsd  0x8dc(%rip),%xmm4
addsd  %xmm3,%xmm0
addsd  %xmm0,%xmm4
mulsd  %xmm1,%xmm4
movsd  %xmm4,(%r15)
lea    0x130(%rsp),%rbp
lea    0x1d0(%rsp),%rsi
mov    %rbp,%rdi
call   1030 <strcpy@plt>
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %eax,%r14d
lea    0x78(%rsp),%rsi
mov    %rbp,%rdi
call   1040 <strtod@plt>
movsd  %xmm0,0x8(%rsp)
mov    %rbp,%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    17d7 <sexToDegree+0x667>
xor    %ebx,%ebx
lea    0x130(%rsp),%rbp
jmp    17c3 <sexToDegree+0x653>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    %rbp,%rdi
call   1060 <strlen@plt>
cltq
cmp    %rax,%rbx
jge    17d7 <sexToDegree+0x667>
cmpb   $0x2e,0x130(%rsp,%rbx,1)
2e
jne    17b0 <sexToDegree+0x640>
movb   $0x0,0x130(%rsp,%rbx,1)
jmp    17b0 <sexToDegree+0x640>
movslq %r14d,%rax
add    %rsp,%rax
add    $0x130,%rax
cmp    %rax,0x78(%rsp)
jne    180a <sexToDegree+0x69a>
lea    0x130(%rsp),%rdi
call   1060 <strlen@plt>
cmp    $0x4,%eax
jg     180a <sexToDegree+0x69a>
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r15)
xor    %r12d,%r12d
lea    0x82f(%rip),%rbx
lea    0x170(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
lea    0x40(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
lea    0x10(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <strcpy@plt>
lea    0x1d0(%rsp),%rdi
lea    0x80(%rsp),%rbx
mov    %rbx,%rsi
call   1030 <strcpy@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
xor    %eax,%eax
nopl   (%rax)
movzbl 0x80(%rsp,%rax,1),%ecx
cmp    $0x20,%cl
jne    1873 <sexToDegree+0x703>
add    $0x1,%rax
jmp    1860 <sexToDegree+0x6f0>
cmp    $0x2b,%cl
je     1887 <sexToDegree+0x717>
cmp    $0x2d,%cl
jne    18a1 <sexToDegree+0x731>
movsd  0x783(%rip),%xmm0
jmp    188f <sexToDegree+0x71f>
movsd  0x771(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %eax,%eax
movb   $0x20,0x80(%rsp,%rax,1)
20
jmp    18af <sexToDegree+0x73f>
movsd  0x757(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
lea    0x80(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    18e2 <sexToDegree+0x772>
mov    %eax,%esi
cmp    $0x1,%eax
jne    19be <sexToDegree+0x84e>
mov    $0xffffffff,%r15d
xor    %eax,%eax
mov    $0xffffffff,%ebx
mov    $0xffffffff,%ebp
jmp    1a28 <sexToDegree+0x8b8>
mov    $0xffffffff,%ebx
mov    $0xffffffff,%ebp
mov    $0xffffffff,%r15d
movl   $0x0,0x4(%rsp)
cmp    $0xffffffff,%ebp
jne    1aec <sexToDegree+0x97c>
cmp    $0xffffffff,%ebx
jne    1aec <sexToDegree+0x97c>
cmp    $0xffffffff,%r15d
jne    1aec <sexToDegree+0x97c>
lea    0x80(%rsp),%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
mov    0x4(%rsp),%eax
cmp    $0x3,%eax
jl     1976 <sexToDegree+0x806>
mov    0xe0(%rsp),%rsi
lea    0x170(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xf0(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x2,%eax
jne    19a3 <sexToDegree+0x833>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x1,%eax
jne    1c65 <sexToDegree+0xaf5>
mov    0xe0(%rsp),%rsi
lea    0x10(%rsp),%rdi
jmp    1b79 <sexToDegree+0xa09>
mov    %esi,%edi
and    $0xfffffffe,%edi
mov    $0xffffffff,%r15d
xor    %eax,%eax
mov    $0xffffffff,%ebx
mov    $0xffffffff,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x80(%rsp,%rax,1),%ecx
and    $0xdf,%cl
cmp    $0x44,%cl
cmove  %eax,%ebp
movzbl 0x81(%rsp,%rax,1),%edx
cmp    $0x4d,%cl
cmove  %eax,%ebx
cmp    $0x53,%cl
cmove  %eax,%r15d
and    $0xdf,%dl
lea    0x1(%rax),%ecx
cmp    $0x44,%dl
cmove  %ecx,%ebp
cmp    $0x4d,%dl
cmove  %ecx,%ebx
cmp    $0x53,%dl
cmove  %ecx,%r15d
add    $0x2,%rax
cmp    %rdi,%rax
jne    19e0 <sexToDegree+0x870>
test   $0x1,%sil
je     1a4b <sexToDegree+0x8db>
mov    0x80(%rsp,%rax,1),%cl
and    $0xdf,%cl
cmp    $0x44,%cl
cmove  %eax,%ebp
cmp    $0x4d,%cl
cmove  %eax,%ebx
cmp    $0x53,%cl
cmove  %eax,%r15d
mov    $0x1,%eax
test   %ebp,%ebp
setg   %r14b
jle    1a64 <sexToDegree+0x8f4>
test   %ebx,%ebx
jle    1a64 <sexToDegree+0x8f4>
cmp    %ebx,%ebp
jg     1e7f <sexToDegree+0xd0f>
test   %ebp,%ebp
jle    1a76 <sexToDegree+0x906>
test   %r15d,%r15d
jle    1a76 <sexToDegree+0x906>
cmp    %r15d,%ebp
jg     1e7f <sexToDegree+0xd0f>
test   %ebx,%ebx
jle    1a88 <sexToDegree+0x918>
test   %r15d,%r15d
jle    1a88 <sexToDegree+0x918>
cmp    %r15d,%ebx
jg     1e7f <sexToDegree+0xd0f>
test   %ebp,%ebp
jle    1bbd <sexToDegree+0xa4d>
lea    0x170(%rsp),%rdi
lea    0x80(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %ebp,%eax
movb   $0x0,0x170(%rsp,%rax,1)
test   %ebx,%ebx
jle    1c0c <sexToDegree+0xa9c>
lea    -0x1(%rbx),%ecx
cmp    %ebp,%ecx
jbe    1bc1 <sexToDegree+0xa51>
lea    (%rsp,%rax,1),%rsi
add    $0x81,%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
mov    %ebp,%eax
not    %eax
add    %ebx,%eax
cltq
movb   $0x0,0x40(%rsp,%rax,1)
mov    $0x1,%r14b
jmp    1bda <sexToDegree+0xa6a>
cmp    $0xffffffff,%ebx
jne    1b83 <sexToDegree+0xa13>
cmp    $0xffffffff,%r15d
jne    1b83 <sexToDegree+0xa13>
movslq %ebp,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x81,%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
mov    0x4(%rsp),%eax
cmp    $0x2,%eax
jne    1b63 <sexToDegree+0x9f3>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rbx
mov    %rbx,%rdi
call   1030 <strcpy@plt>
mov    0xe0(%rsp),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
mov    0xe8(%rsp),%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
mov    0x4(%rsp),%eax
cmp    $0x1,%eax
jne    1c65 <sexToDegree+0xaf5>
mov    0xe0(%rsp),%rsi
lea    0x40(%rsp),%rdi
call   1030 <strcpy@plt>
jmp    1c65 <sexToDegree+0xaf5>
cmp    $0xffffffff,%r15d
jne    1c65 <sexToDegree+0xaf5>
movslq %ebx,%rax
lea    (%rsp,%rax,1),%rdi
add    $0x81,%rdi
lea    0xe0(%rsp),%rsi
lea    0x4(%rsp),%rdx
call   1090 <getSubstrings@plt>
cmpl   $0x1,0x4(%rsp)
je     19ac <sexToDegree+0x83c>
jmp    1c65 <sexToDegree+0xaf5>
test   %ebx,%ebx
jle    1c0c <sexToDegree+0xa9c>
lea    0x40(%rsp),%rdi
lea    0x80(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %ebx,%eax
movb   $0x0,0x40(%rsp,%rax,1)
test   %r15d,%r15d
jle    18f2 <sexToDegree+0x782>
lea    -0x1(%r15),%eax
cmp    %ebx,%eax
jle    1c19 <sexToDegree+0xaa9>
mov    %ebx,%eax
lea    (%rsp,%rax,1),%rsi
add    $0x81,%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
not    %ebx
add    %ebx,%r15d
movslq %r15d,%rax
jmp    1c58 <sexToDegree+0xae8>
test   %r15d,%r15d
jle    18f2 <sexToDegree+0x782>
lea    -0x1(%r15),%eax
test   %r14b,%r14b
je     1c43 <sexToDegree+0xad3>
cmp    %ebp,%eax
jle    1c43 <sexToDegree+0xad3>
mov    %ebp,%eax
lea    (%rsp,%rax,1),%rsi
add    $0x81,%rsi
lea    0x10(%rsp),%rdi
call   1030 <strcpy@plt>
not    %ebp
add    %ebp,%r15d
movslq %r15d,%rax
jmp    1c58 <sexToDegree+0xae8>
lea    0x10(%rsp),%rdi
lea    0x80(%rsp),%rsi
call   1030 <strcpy@plt>
mov    %r15d,%eax
movb   $0x0,0x10(%rsp,%rax,1)
movl   $0x0,0x4(%rsp)
lea    0x10(%rsp),%rdi
call   1080 <checkFormat@plt>
xorpd  %xmm3,%xmm3
cmp    $0x1,%eax
jne    1d16 <sexToDegree+0xba6>
lea    0x40(%rsp),%rdi
call   1080 <checkFormat@plt>
cmp    $0x1,%eax
jne    1d23 <sexToDegree+0xbb3>
lea    0x170(%rsp),%rdi
call   1080 <checkFormat@plt>
mov    %eax,%r14d
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
cmp    $0x1,%eax
xorpd  %xmm3,%xmm3
jne    1d6f <sexToDegree+0xbff>
lea    0x10(%rsp),%rdi
call   1050 <atof@plt>
movapd %xmm0,%xmm4
ucomisd 0x346(%rip),%xmm0
jbe    1d34 <sexToDegree+0xbc4>
movsd  0x344(%rip),%xmm0
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
cvtdq2pd %xmm1,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm4
movsd  0x328(%rip),%xmm1
movapd %xmm4,%xmm0
divsd  %xmm1,%xmm0
cvttpd2dq %xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
subsd  %xmm2,%xmm4
jmp    1d69 <sexToDegree+0xbf9>
mov    %eax,%r14d
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
jmp    1d6f <sexToDegree+0xbff>
mov    %eax,%r14d
xorpd  %xmm0,%xmm0
xorpd  %xmm4,%xmm4
xorpd  %xmm3,%xmm3
jmp    1d6f <sexToDegree+0xbff>
lea    0x170(%rsp),%rdi
movsd  %xmm4,0x70(%rsp)
call   1050 <atof@plt>
movapd %xmm0,0x160(%rsp)
lea    0x40(%rsp),%rdi
call   1050 <atof@plt>
movsd  0x70(%rsp),%xmm4
movapd 0x160(%rsp),%xmm3
mov    $0x1,%r14d
divsd  0x299(%rip),%xmm0
divsd  0x2a9(%rip),%xmm4
addsd  %xmm3,%xmm0
addsd  %xmm0,%xmm4
movsd  0x8(%rsp),%xmm0
mulsd  %xmm4,%xmm0
mov    0xd8(%rsp),%rax
movsd  %xmm0,(%rax)
lea    0x130(%rsp),%rbp
lea    0x1d0(%rsp),%rsi
mov    %rbp,%rdi
call   1030 <strcpy@plt>
mov    %rbp,%rdi
call   1060 <strlen@plt>
mov    %eax,%r15d
lea    0x78(%rsp),%rsi
mov    %rbp,%rdi
call   1040 <strtod@plt>
movsd  %xmm0,0x8(%rsp)
mov    %rbp,%rdi
call   1060 <strlen@plt>
test   %eax,%eax
jle    1e17 <sexToDegree+0xca7>
xor    %ebx,%ebx
lea    0x130(%rsp),%rbp
jmp    1e03 <sexToDegree+0xc93>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
mov    %rbp,%rdi
call   1060 <strlen@plt>
cltq
cmp    %rax,%rbx
jge    1e17 <sexToDegree+0xca7>
cmpb   $0x2e,0x130(%rsp,%rbx,1)
2e
jne    1df0 <sexToDegree+0xc80>
movb   $0x0,0x130(%rsp,%rbx,1)
jmp    1df0 <sexToDegree+0xc80>
movslq %r15d,%rax
add    %rsp,%rax
add    $0x130,%rax
cmp    %rax,0x78(%rsp)
jne    1e5d <sexToDegree+0xced>
lea    0x130(%rsp),%rdi
call   1060 <strlen@plt>
cmp    $0x4,%eax
jg     1e5d <sexToDegree+0xced>
mov    0xd8(%rsp),%rax
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%rax)
call   1070 <fabs@plt>
xor    %r14d,%r14d
cmp    $0x5b,%eax
setl   %r14b
mov    $0x3,%eax
mov    %r12d,%ecx
or     %r14d,%ecx
je     1e7f <sexToDegree+0xd0f>
xor    %ecx,%ecx
test   %r14d,%r14d
sete   %cl
add    %ecx,%ecx
test   %r12d,%r12d
mov    $0x1,%eax
cmovne %ecx,%eax
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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