#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 */
int /*<<< orphan*/ ErrPrint(char *);
double IsoMass(int, int);
double IsoQ(int, int, int, int, int, int);
int ScanPro(char *, double *, int *);
int ScanTarget(char *, char *, double *, double *, double *, int *, int *);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int strlen(char *);
int ScanArgs(int ArgC, char *ArgS[], double *E1, double *E2, double *DeltaE,
             double *Q, double *MP, double MT[], double *MProd, double *MRes,
             double CT[], double *TT, double *Angle1, double *Angle2,
             double *DeltaA, int ZT[], int *ZP, int *ZProd, int *ZRes,
             int *NTarEl, int *IsGas, int *ESteps, int *CSn, int *SwitchQ,
             int *Switchq, int *Switchv, int *Switchx, int *SwitchX, int Com[],
             char *Char_S, char *Char_s) {
  int i = 0, ii = 0, ArgNo = 0, ArgLen = 0, SwNo = 1, ArgNeed = 5, MixMass1 = 0,
      GetProd = 0, done = 0;
  double EX = 0, EX3 = 0;
  if (ArgC < ArgNeed) {
    ErrPrint("ERROR: Too few parameters");
    return -1;
  };
  while (!done) {
    if (ArgS[ArgNo][0] == '-') {
      ArgNeed++;
      if (ArgC < ArgNeed) {
        ErrPrint("ERROR: Too few parameters");
        return 0;
      };
      SwNo = 1;
      ArgLen = strlen(ArgS[ArgNo]);
      if (ArgLen == 1) {
        ErrPrint("ERROR: '-' alone is an invalid argument.");
        return -1;
      };
      while (ArgLen - 1 >= SwNo) {
        switch (ArgS[ArgNo][SwNo]) {
        case 'q':
          *Switchq = 1;
          *SwitchQ = 0;
          *Switchv = 0;
          break;
        case 'Q':
          *SwitchQ = 1;
          *Switchq = 1;
          *Switchv = 0;
          break;
        case 'v':
          *Switchv = 1;
          *Switchq = 0;
          *SwitchQ = 0;
          break;
        case 'g':
          *IsGas = 1;
          break;
        case 'c':
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: c- switch not last in parameter");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (!sscanf(ArgS[ArgNo + 1], "%i", CSn)) {
            ErrPrint("ERROR: Unable to charge state argument!");
            return -1;
          }
          ArgNo++;
          ArgNeed++;
          ArgLen = 0;
          break;
        case 'x':
          *Switchx = 1;
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: x- switch not last in parameter");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (!sscanf(ArgS[ArgNo + 1], "%lf", &EX)) {
            ErrPrint("ERROR: Unable to covert (2) ex. energy arg.!");
            return -1;
          }
          ArgNo++;
          ArgNeed++;
          ArgLen = 0;
          break;
        case 'X':
          *SwitchX = 1;
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: X- switch not last in parameter");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (!sscanf(ArgS[ArgNo + 1], "%lf", &EX3)) {
            ErrPrint("ERROR: Unable to covert (3)-ex. energy arg.!");
            return -1;
          }
          ArgNo++;
          ArgNeed++;
          ArgLen = 0;
          break;
        case 's':
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: s- switch not last in parameter");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (strlen(ArgS[ArgNo + 1]) != 1) {
            ErrPrint("ERROR: after -s one Character expected");
            return -1;
          };
          *Char_s = ArgS[ArgNo + 1][0];
          ArgNo++;
          ArgNeed++;
          ArgLen = 0;
          break;
        case 'S':
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: S- switch not last in parameter");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (strlen(ArgS[ArgNo + 1]) != 1) {
            ErrPrint("ERROR: after -S one Character expected");
            return -1;
          };
          *Char_S = ArgS[ArgNo + 1][0];
          ArgNo++;
          ArgNeed++;
          ArgLen = 0;
          break;
        case 'a':
          if (ArgLen - 1 > SwNo) {
            ErrPrint("ERROR: a- switch not last in Argument");
            return -1;
          };
          if (ArgNeed > ArgC) {
            ErrPrint("ERROR: Too few parameter");
            return -1;
          };
          if (!sscanf(ArgS[ArgNo + 1], "%lf", Angle1)) {
            ErrPrint("ERROR: Unable to covert angle argument!");
            return -1;
          }
          ArgNo++;
          ArgNeed++;
          if (!sscanf(ArgS[ArgNo + 1], "%lf", Angle2)) {
            *Angle2 = *Angle1;
            *DeltaA = 1;
          } else {
            ArgNeed = ArgNeed + 2;
            ArgNo = ArgNo + 2;
            if (!sscanf(ArgS[ArgNo], "%lf", DeltaA)) {
              ErrPrint("ERROR: Trouble cov. angle step Arg.!");
              return -1;
            };
          };
          ArgLen = 0;
          break;
        default:
          ErrPrint("ERROR: Unimplemented Switch");
          return -1;
          break;
        }
        SwNo++;
      };
      ArgNo++;
    } else
      done = 1;
  };
  done = 0;
  if (ArgNeed > ArgC) {
    ErrPrint("ERROR: Too few parameter");
    return -1;
  };
  ArgLen = strlen(ArgS[ArgNo]);
  for (i = 0; (i <= ArgLen - 1); i++) {
    if (ii >= 20) {
      ErrPrint("ERROR: Too many commands in Com-String");
      return -1;
    }
    switch (ArgS[ArgNo][i]) {
    case 'A':
      Com[ii] = 122;
      break;
    case 'E':
      Com[ii] = 1;
      break;
    case 'a':
      Com[ii] = 2;
      break;
    case 'e':
      Com[ii] = 3;
      break;
    case 'l':
      Com[ii] = 4;
      break;
    case 'r':
      Com[ii] = 5;
      break;
    case 'p':
      Com[ii] = 6;
      break;
    case 'P':
      Com[ii] = 9;
      break;
    case 'c':
      Com[ii] = 7;
      break;
    case 'v':
      Com[ii] = 10;
      break;
    case 'o':
      Com[ii] = 8;
      break;
    case 's':
      Com[ii] = 11;
      break;
    case 'X':
      i++;
      switch (ArgS[ArgNo][i]) {
      case 'r':
        Com[ii] = 201;
        break;
      default:
        ErrPrint("Undefined X-command.");
        return -1;
        break;
      };
      break;
    case 'D':
      i++;
      switch (ArgS[ArgNo][i]) {
      case 'm':
        Com[ii] = 300;
        break;
      case 'z':
        Com[ii] = 301;
        break;
      case 'q':
        Com[ii] = 302;
        break;
      case 's':
        Com[ii] = 303;
        break;
      default:
        ErrPrint("Undefined D-command.");
        return -1;
        break;
      };
      break;
    case 'R':
      i++;
      GetProd = 1;
      switch (ArgS[ArgNo][i]) {
      case '4':
        i++;
        switch (ArgS[ArgNo][i]) {
        case 's':
          Com[ii] = 1245;
          break;
        case 'A':
          i++;
          switch (ArgS[ArgNo][i]) {
          case '+':
            Com[ii] = 1231;
            break;
          case '-':
            Com[ii] = 1232;
            break;
          default:
            ErrPrint("Undefined R4A-command. use R4A+ or R4A-");
            return -1;
            break;
          };
          break;
        case 'E':
          i++;
          switch (ArgS[ArgNo][i]) {
          case '+':
            Com[ii] = 1241;
            break;
          case '-':
            Com[ii] = 1242;
            break;
          default:
            ErrPrint("Undefined R4E-command: Use R4E+ or R4E-");
            return -1;
            break;
          };
          break;
        case 't':
          i++;
          switch (ArgS[ArgNo][i]) {
          case '+':
            Com[ii] = 1235;
            break;
          case '-':
            Com[ii] = 1236;
            break;
          default:
            ErrPrint("Undefined R4C-command: Use R4t+ or R4t-");
            return -1;
            break;
          };
          break;
        default:
          ErrPrint("Undefined R4-command");
          return -1;
          break;
        };
        break;
      case 'E':
        i++;
        switch (ArgS[ArgNo][i]) {
        case '+':
          Com[ii] = 1001;
          break;
        case '-':
          Com[ii] = 1002;
          break;
        case '0':
          Com[ii] = 100;
          break;
        default:
          ErrPrint("Undef. RE-command: Last letter must be +,- or 0");
          return -1;
          break;
        };
        break;
      case 't':
        i++;
        switch (ArgS[ArgNo][i]) {
        case '+':
          Com[ii] = 1233;
          break;
        case '-':
          Com[ii] = 1234;
          break;
        default:
          ErrPrint("Undef. RC-command: Last letter must be + or -");
          return -1;
          break;
        };
        break;
      case 'J':
        i++;
        switch (ArgS[ArgNo][i]) {
        case '+':
          Com[ii] = 1251;
          break;
        case '-':
          Com[ii] = 1252;
          break;
        default:
          ErrPrint("Undef. RJ-command: Last letter must be + or -");
          return -1;
          break;
        };
        break;
      case 's':
        Com[ii] = 108;
        break;
      case 'a':
        Com[ii] = 102;
        break;
      case 'e':
        Com[ii] = 103;
        break;
      case 'l':
        Com[ii] = 104;
        break;
      case 'c':
        Com[ii] = 107;
        break;
      case 'o':
        Com[ii] = 109;
        break;
      case 'T':
        Com[ii] = 121;
        break;
      case 'C':
        Com[ii] = 120;
        break;
      default:
        ErrPrint("Undefined rekation prod. command in command string!");
        return -1;
        break;
      };
      break;
    case '.':
      ii--;
      break;
    default:
      ErrPrint("Undefined command in command string!");
      return -1;
      break;
    };
    ii++;
  };
  Com[ii] = -1;
  ArgNo++;
  *NTarEl = ScanTarget(ArgS[ArgNo], ArgS[ArgNo + 1], MT, CT, TT, ZT, &MixMass1);
  if (*NTarEl < 1)
    return -1;
  ArgNo += 2;
  if (-1 == ScanPro(ArgS[ArgNo], MP, ZP))
    return -1;
  if (*ZP == 0) {
    ErrPrint("ERROR: Sorry, can't calculate neutron scattering.");
    return -1;
  };
  ArgNo++;
  if (GetProd) {
    ArgNeed += 2;
    if (ArgNeed > ArgC) {
      ErrPrint("ERROR: Too few parameter for reakion produkt mode");
      return -1;
    };
    if (MixMass1)
      ErrPrint("WARNING: 1st target set to isotopic mass. (check with -v)");
    if (-1 == ScanPro(ArgS[ArgNo], MProd, ZProd))
      return -1;
    *MP = IsoMass(*ZP, (int)(*MP + 0.5)) + EX * 0.001073543;
    MT[0] = IsoMass(ZT[0], (int)(MT[0] + 0.5));
    *MProd = IsoMass(*ZProd, (int)(*MProd + 0.5)) + EX3 * 0.001073543;
    *ZRes = *ZP + ZT[0] - *ZProd;
    if (*ZRes < 0) {
      ErrPrint("ERROR: This resction is impossible (4th charge negative)");
      return -1;
    };
    if (*ZRes > 92) {
      ErrPrint("ERROR: Z of 4th reaction partner is too large!");
      return -1;
    };
    *MRes = IsoMass(*ZRes, (int)(*MP + MT[0] - *MProd + 0.5));
    if (*MRes < 0) {
      ErrPrint("ERROR: This reaction is impossible (4th mass negative)");
      return -1;
    };
    ArgNo++;
    if ((ArgS[ArgNo][0] == 'X') || (ArgS[ArgNo][0] == 'x') ||
        (ArgS[ArgNo][0] == 'D') || (ArgS[ArgNo][0] == 'd')) {
      *Q = IsoQ(*ZP, ZT[0], *ZProd, (int)(*MP + 0.5), (int)(MT[0] + 0.5),
                (int)(*MProd + 0.5));
      if (*Q == -9999999.0) {
        ErrPrint("ERROR: Sorry, can't calculate Q-Value. No Data");
        return -1;
      };
      *Q = *Q + EX - EX3;
    } else if (!sscanf(ArgS[ArgNo], "%lf", Q)) {
      ErrPrint("ERROR:Unable to covert energy Q-value argument!");
      return -1;
    } else {
      if (*MProd > *MRes)
        *MProd = MT[0] + *MP - *MRes - *Q * 0.001073543;
      else
        *MRes = MT[0] + *MP - *MProd - *Q * 0.001073543;
    };
    ArgNo++;
  }
  if (!sscanf(ArgS[ArgNo], "%lf", E1)) {
    ErrPrint("ERROR:Unable to covert energy (E1) argument!");
    return -1;
  };
  if (*E1 <= 0.0)
    *E1 = 0.0000001;
  if (ArgNo == (ArgC - 1))
    return 1;
  if (ArgNo != (ArgC - 3)) {
    ErrPrint("ERROR: Number of arguments either one to small or to large");
    return -1;
  };
  ArgNo++;
  if (!sscanf(ArgS[ArgNo], "%lf", E2)) {
    ErrPrint("ERROR:Unable to covert energy (E2) argument!");
    return -1;
  };
  if ((*E2 <= 0.) || (((*E1 - *E2) * (*E1 - *E2)) < 0.0001)) {
    ErrPrint("ERROR:Energy E2 must be positive and other than E1");
    return -1;
  };
  ArgNo++;
  if (!sscanf(ArgS[ArgNo], "%i", ESteps)) {
    ErrPrint("ERROR:Unable to covert energy (ESteps) argument!");
    return -1;
  };
  if (*ESteps < 1) {
    ErrPrint("ERROR: Number of energy steps < 1: Nonsense!");
    return -1;
  };
  *DeltaE = (*E2 - *E1) / (float)(*ESteps - 1);
  return 1;
}


x86 assembly (clang, -O0):
<ScanArgs>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0xd0(%rbp),%rax
mov    0xc8(%rbp),%rax
mov    0xc0(%rbp),%rax
mov    0xb8(%rbp),%rax
mov    0xb0(%rbp),%rax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%rax
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
movl   $0x5,-0x48(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    128a <ScanArgs+0x11a>
lea    0x20b7(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    128f <ScanArgs+0x11f>
cmpl   $0x0,-0x54(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    12a5 <ScanArgs+0x135>
jmp    193b <ScanArgs+0x7cb>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    192f <ScanArgs+0x7bf>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    12ea <ScanArgs+0x17a>
lea    0x2057(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0x0,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
movl   $0x1,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x40(%rbp)
cmpl   $0x1,-0x40(%rbp)
jne    1327 <ScanArgs+0x1b7>
lea    0x2034(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    132c <ScanArgs+0x1bc>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jl     1921 <ScanArgs+0x7b1>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffaf,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0x27,%eax
ja     18fb <ScanArgs+0x78b>
mov    -0x70(%rbp),%rax
lea    0x1f24(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0xa0(%rbp),%rax
movl   $0x1,(%rax)
mov    0x98(%rbp),%rax
movl   $0x0,(%rax)
mov    0xa8(%rbp),%rax
movl   $0x0,(%rax)
jmp    1913 <ScanArgs+0x7a3>
mov    0x98(%rbp),%rax
movl   $0x1,(%rax)
mov    0xa0(%rbp),%rax
movl   $0x1,(%rax)
mov    0xa8(%rbp),%rax
movl   $0x0,(%rax)
jmp    1913 <ScanArgs+0x7a3>
mov    0xa8(%rbp),%rax
movl   $0x1,(%rax)
mov    0xa0(%rbp),%rax
movl   $0x0,(%rax)
mov    0x98(%rbp),%rax
movl   $0x0,(%rax)
jmp    1913 <ScanArgs+0x7a3>
mov    0x80(%rbp),%rax
movl   $0x1,(%rax)
jmp    1913 <ScanArgs+0x7a3>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    1432 <ScanArgs+0x2c2>
lea    0x1f52(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1456 <ScanArgs+0x2e6>
lea    0x1f55(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x90(%rbp),%rdx
lea    0x1f3e(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    149d <ScanArgs+0x32d>
lea    0x1f2a(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
mov    0xb0(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    14ef <ScanArgs+0x37f>
lea    0x1f00(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1513 <ScanArgs+0x3a3>
lea    0x1e98(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1eda(%rip),%rsi
lea    -0x60(%rbp),%rdx
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    1557 <ScanArgs+0x3e7>
lea    0x1ec3(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
mov    0xb8(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    15a9 <ScanArgs+0x439>
lea    0x1e9e(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    15cd <ScanArgs+0x45d>
lea    0x1dde(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
lea    0x1e20(%rip),%rsi
lea    -0x68(%rbp),%rdx
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    1611 <ScanArgs+0x4a1>
lea    0x1e5d(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    1656 <ScanArgs+0x4e6>
lea    0x1e45(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    167a <ScanArgs+0x50a>
lea    0x1d31(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1060 <strlen@plt>
cmp    $0x1,%eax
je     16b1 <ScanArgs+0x541>
lea    0x1e11(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%cl
mov    0xd0(%rbp),%rax
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    1712 <ScanArgs+0x5a2>
lea    0x1dd7(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1736 <ScanArgs+0x5c6>
lea    0x1c75(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1060 <strlen@plt>
cmp    $0x1,%eax
je     176d <ScanArgs+0x5fd>
lea    0x1da3(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%cl
mov    0xc8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
cmp    -0x44(%rbp),%eax
jle    17ce <ScanArgs+0x65e>
lea    0x1d69(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    17f2 <ScanArgs+0x682>
lea    0x1bb9(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x40(%rbp),%rdx
lea    0x1bf7(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    1836 <ScanArgs+0x6c6>
lea    0x1d27(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x48(%rbp),%rdx
lea    0x1ba1(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    1899 <ScanArgs+0x729>
mov    0x40(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x50(%rbp),%rax
movsd  0x1798(%rip),%xmm0
movsd  %xmm0,(%rax)
jmp    18ef <ScanArgs+0x77f>
mov    -0x48(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x50(%rbp),%rdx
lea    0x1b43(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    18ea <ScanArgs+0x77a>
lea    0x1c9b(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    18ef <ScanArgs+0x77f>
movl   $0x0,-0x40(%rbp)
jmp    1913 <ScanArgs+0x7a3>
lea    0x1c97(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    132c <ScanArgs+0x1bc>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1936 <ScanArgs+0x7c6>
movl   $0x1,-0x54(%rbp)
jmp    128f <ScanArgs+0x11f>
movl   $0x0,-0x54(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1966 <ScanArgs+0x7f6>
lea    0x1a45(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1060 <strlen@plt>
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     21a9 <ScanArgs+0x1039>
cmpl   $0x14,-0x38(%rbp)
jl     19b4 <ScanArgs+0x844>
lea    0x1c12(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffd2,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x48,%eax
ja     217a <ScanArgs+0x100a>
mov    -0x78(%rbp),%rax
lea    0x164b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x7a,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x3,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x5,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x6,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x9,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x7,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0xa,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x8,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0xb,(%rax,%rcx,4)
jmp    2192 <ScanArgs+0x1022>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%al
sub    $0x72,%al
jne    1b42 <ScanArgs+0x9d2>
jmp    1b2b <ScanArgs+0x9bb>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0xc9,(%rax,%rcx,4)
jmp    1b5a <ScanArgs+0x9ea>
lea    0x1a93(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2192 <ScanArgs+0x1022>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffff93,%eax
mov    %eax,%ecx
mov    %rcx,-0x80(%rbp)
sub    $0xd,%eax
ja     1bfe <ScanArgs+0xa8e>
mov    -0x80(%rbp),%rax
lea    0x16bf(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x12c,(%rax,%rcx,4)
jmp    1c16 <ScanArgs+0xaa6>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x12d,(%rax,%rcx,4)
jmp    1c16 <ScanArgs+0xaa6>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x12e,(%rax,%rcx,4)
jmp    1c16 <ScanArgs+0xaa6>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x12f,(%rax,%rcx,4)
jmp    1c16 <ScanArgs+0xaa6>
lea    0x19ec(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2192 <ScanArgs+0x1022>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffcc,%eax
mov    %eax,%ecx
mov    %rcx,-0x88(%rbp)
sub    $0x40,%eax
ja     214f <ScanArgs+0xfdf>
mov    -0x88(%rbp),%rax
lea    0x14f2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x8c(%rbp)
sub    $0x41,%eax
je     1cef <ScanArgs+0xb7f>
jmp    1c9c <ScanArgs+0xb2c>
mov    -0x8c(%rbp),%eax
sub    $0x45,%eax
je     1d7f <ScanArgs+0xc0f>
jmp    1cb0 <ScanArgs+0xb40>
mov    -0x8c(%rbp),%eax
sub    $0x73,%eax
je     1cd8 <ScanArgs+0xb68>
jmp    1cc4 <ScanArgs+0xb54>
mov    -0x8c(%rbp),%eax
sub    $0x74,%eax
je     1e0f <ScanArgs+0xc9f>
jmp    1e9f <ScanArgs+0xd2f>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4dd,(%rax,%rcx,4)
jmp    1eb7 <ScanArgs+0xd47>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
sub    $0x2b,%eax
je     1d34 <ScanArgs+0xbc4>
jmp    1d20 <ScanArgs+0xbb0>
mov    -0x90(%rbp),%eax
sub    $0x2d,%eax
je     1d4b <ScanArgs+0xbdb>
jmp    1d62 <ScanArgs+0xbf2>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4cf,(%rax,%rcx,4)
jmp    1d7a <ScanArgs+0xc0a>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d0,(%rax,%rcx,4)
jmp    1d7a <ScanArgs+0xc0a>
lea    0x189d(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    1eb7 <ScanArgs+0xd47>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x94(%rbp)
sub    $0x2b,%eax
je     1dc4 <ScanArgs+0xc54>
jmp    1db0 <ScanArgs+0xc40>
mov    -0x94(%rbp),%eax
sub    $0x2d,%eax
je     1ddb <ScanArgs+0xc6b>
jmp    1df2 <ScanArgs+0xc82>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d9,(%rax,%rcx,4)
jmp    1e0a <ScanArgs+0xc9a>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4da,(%rax,%rcx,4)
jmp    1e0a <ScanArgs+0xc9a>
lea    0x1835(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    1eb7 <ScanArgs+0xd47>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
sub    $0x2b,%eax
je     1e54 <ScanArgs+0xce4>
jmp    1e40 <ScanArgs+0xcd0>
mov    -0x98(%rbp),%eax
sub    $0x2d,%eax
je     1e6b <ScanArgs+0xcfb>
jmp    1e82 <ScanArgs+0xd12>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d3,(%rax,%rcx,4)
jmp    1e9a <ScanArgs+0xd2a>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d4,(%rax,%rcx,4)
jmp    1e9a <ScanArgs+0xd2a>
lea    0x17cd(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    1eb7 <ScanArgs+0xd47>
lea    0x17d8(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2167 <ScanArgs+0xff7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x9c(%rbp)
sub    $0x2b,%eax
je     1f15 <ScanArgs+0xda5>
jmp    1eed <ScanArgs+0xd7d>
mov    -0x9c(%rbp),%eax
sub    $0x2d,%eax
je     1f2c <ScanArgs+0xdbc>
jmp    1f01 <ScanArgs+0xd91>
mov    -0x9c(%rbp),%eax
sub    $0x30,%eax
je     1f43 <ScanArgs+0xdd3>
jmp    1f5a <ScanArgs+0xdea>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x3e9,(%rax,%rcx,4)
jmp    1f72 <ScanArgs+0xe02>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x3ea,(%rax,%rcx,4)
jmp    1f72 <ScanArgs+0xe02>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x64,(%rax,%rcx,4)
jmp    1f72 <ScanArgs+0xe02>
lea    0x1732(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2167 <ScanArgs+0xff7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
sub    $0x2b,%eax
je     1fbc <ScanArgs+0xe4c>
jmp    1fa8 <ScanArgs+0xe38>
mov    -0xa0(%rbp),%eax
sub    $0x2d,%eax
je     1fd3 <ScanArgs+0xe63>
jmp    1fea <ScanArgs+0xe7a>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d1,(%rax,%rcx,4)
jmp    2002 <ScanArgs+0xe92>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4d2,(%rax,%rcx,4)
jmp    2002 <ScanArgs+0xe92>
lea    0x16d2(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2167 <ScanArgs+0xff7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0xa4(%rbp)
sub    $0x2b,%eax
je     204c <ScanArgs+0xedc>
jmp    2038 <ScanArgs+0xec8>
mov    -0xa4(%rbp),%eax
sub    $0x2d,%eax
je     2063 <ScanArgs+0xef3>
jmp    207a <ScanArgs+0xf0a>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4e3,(%rax,%rcx,4)
jmp    2092 <ScanArgs+0xf22>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x4e4,(%rax,%rcx,4)
jmp    2092 <ScanArgs+0xf22>
lea    0x1670(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x6c,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x66,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x67,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x68,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x6b,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x6d,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x79,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x78,(%rax,%rcx,4)
jmp    2167 <ScanArgs+0xff7>
lea    0x15c9(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
jmp    2192 <ScanArgs+0x1022>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    2192 <ScanArgs+0x1022>
lea    0x15d2(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1981 <ScanArgs+0x811>
mov    0xc0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    0x18(%rbp),%rdx
mov    0x30(%rbp),%rcx
mov    0x38(%rbp),%r8
mov    0x58(%rbp),%r9
lea    -0x4c(%rbp),%rax
mov    %rax,(%rsp)
call   1090 <ScanTarget@plt>
mov    %eax,%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    0x78(%rbp),%rax
cmpl   $0x1,(%rax)
jge    221f <ScanArgs+0x10af>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x10(%rbp),%rsi
mov    0x60(%rbp),%rdx
call   1050 <ScanPro@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cmp    %ecx,%eax
jne    225c <ScanArgs+0x10ec>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x60(%rbp),%rax
cmpl   $0x0,(%rax)
jne    2281 <ScanArgs+0x1111>
lea    0x1508(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     269e <ScanArgs+0x152e>
mov    -0x48(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    22c1 <ScanArgs+0x1151>
lea    0x14fa(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
cmpl   $0x0,-0x4c(%rbp)
je     22d7 <ScanArgs+0x1167>
lea    0x150a(%rip),%rdi
call   1040 <ErrPrint@plt>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x20(%rbp),%rsi
mov    0x68(%rbp),%rdx
call   1050 <ScanPro@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cmp    %ecx,%eax
jne    230b <ScanArgs+0x119b>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x60(%rbp),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
movsd  0xceb(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
movsd  0xcc6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x58(%rbp),%rax
mov    (%rax),%edi
mov    0x18(%rbp),%rax
movsd  0xcac(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x68(%rbp),%rax
mov    (%rax),%edi
mov    0x20(%rbp),%rax
movsd  0xc85(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
movaps %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  0xc60(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x60(%rbp),%rax
mov    (%rax),%ecx
mov    0x58(%rbp),%rax
add    (%rax),%ecx
mov    0x68(%rbp),%rax
sub    (%rax),%ecx
mov    0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    0x70(%rbp),%rax
cmpl   $0x0,(%rax)
jge    23ed <ScanArgs+0x127d>
lea    0x143a(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x70(%rbp),%rax
cmpl   $0x5c,(%rax)
jle    2412 <ScanArgs+0x12a2>
lea    0x144e(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x70(%rbp),%rax
mov    (%rax),%edi
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
addsd  (%rax),%xmm0
mov    0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  0xbd0(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    2476 <ScanArgs+0x1306>
lea    0x1419(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x58,%eax
je     24df <ScanArgs+0x136f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x78,%eax
je     24df <ScanArgs+0x136f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x44,%eax
je     24df <ScanArgs+0x136f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x64,%eax
jne    2593 <ScanArgs+0x1423>
mov    0x60(%rbp),%rax
mov    (%rax),%edi
mov    0x58(%rbp),%rax
mov    (%rax),%esi
mov    0x68(%rbp),%rax
mov    (%rax),%edx
mov    0x10(%rbp),%rax
movsd  0xb0b(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%ecx
mov    0x18(%rbp),%rax
movsd  0xaf7(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%r8d
mov    0x20(%rbp),%rax
movsd  0xae2(%rip),%xmm0
addsd  (%rax),%xmm0
cvttsd2si %xmm0,%r9d
call   1080 <IsoQ@plt>
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xac4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2574 <ScanArgs+0x1404>
jp     2574 <ScanArgs+0x1404>
lea    0x1352(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    2695 <ScanArgs+0x1525>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x30(%rbp),%rdx
lea    0xe5b(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    25d2 <ScanArgs+0x1462>
lea    0x1323(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    263c <ScanArgs+0x14cc>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm1
mov    0x28(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x9d9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    268b <ScanArgs+0x151b>
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x10(%rbp),%rax
addsd  (%rax),%xmm1
mov    0x20(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x985(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    2690 <ScanArgs+0x1520>
jmp    2695 <ScanArgs+0x1525>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rdx
lea    0xd50(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    26dd <ScanArgs+0x156d>
lea    0x1248(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jb     26fe <ScanArgs+0x158e>
mov    -0x18(%rbp),%rax
movsd  0x91e(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x3c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    271b <ScanArgs+0x15ab>
movl   $0x1,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
je     2744 <ScanArgs+0x15d4>
lea    0x120e(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rdx
lea    0xca1(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    278c <ScanArgs+0x161c>
lea    0x1201(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jae    27d3 <ScanArgs+0x1663>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
mulsd  %xmm0,%xmm1
movsd  0x857(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    27eb <ScanArgs+0x167b>
lea    0x11cf(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    0x88(%rbp),%rdx
lea    0xba5(%rip),%rsi
mov    $0x0,%al
call   1070 <sscanf@plt>
cmp    $0x0,%eax
jne    2836 <ScanArgs+0x16c6>
lea    0x11b7(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    0x88(%rbp),%rax
cmpl   $0x1,(%rax)
jge    285e <ScanArgs+0x16ee>
lea    0x11c0(%rip),%rdi
call   1040 <ErrPrint@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    2895 <ScanArgs+0x1725>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x88(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ScanArgs>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
movl   $0x0,0x34(%rsp)
movq   $0x0,0x48(%rsp)
movq   $0x0,0x40(%rsp)
cmp    $0x5,%edi
jge    11a9 <ScanArgs+0x39>
lea    0x2184(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
mov    %rsi,%r10
mov    %edi,%r13d
mov    %r9,0x38(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x58(%rsp)
mov    %r8,0x60(%rsp)
mov    $0x5,%edx
xor    %r12d,%r12d
mov    %rsi,0x18(%rsp)
mov    %r13,0x28(%rsp)
jmp    11ef <ScanArgs+0x7f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12d
cmpb   $0x2d,0x17(%rsp)
jne    1561 <ScanArgs+0x3f1>
movslq %r12d,%rax
mov    (%r10,%rax,8),%rdi
mov    (%rdi),%bl
cmp    $0x2d,%bl
jne    1561 <ScanArgs+0x3f1>
cmp    %r13d,%edx
jge    158a <ScanArgs+0x41a>
mov    %edx,%ebp
call   1060 <strlen@plt>
cmp    $0x1,%eax
je     159b <ScanArgs+0x42b>
mov    %eax,%r15d
mov    %bl,0x17(%rsp)
mov    %ebp,%edx
add    $0x1,%edx
cmp    $0x2,%eax
mov    0x18(%rsp),%r10
jl     11e0 <ScanArgs+0x70>
mov    $0x1,%ebx
jmp    126e <ScanArgs+0xfe>
mov    0x138(%rsp),%rax
movl   $0x1,(%rax)
mov    0x130(%rsp),%rax
movl   $0x0,(%rax)
mov    0x128(%rsp),%rax
movl   $0x0,(%rax)
add    $0x1,%rbx
cmp    %ebx,%r15d
jle    11e0 <ScanArgs+0x70>
movslq %r12d,%rbp
mov    (%r10,%rbp,8),%rax
movsbl (%rax,%rbx,1),%ecx
add    $0xffffffaf,%ecx
cmp    $0x27,%ecx
ja     15e8 <ScanArgs+0x478>
lea    -0x1(%r15),%eax
lea    0x1d98(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
mov    0x128(%rsp),%rax
movl   $0x1,(%rax)
mov    0x130(%rsp),%rax
movl   $0x1,(%rax)
mov    0x138(%rsp),%rax
jmp    125b <ScanArgs+0xeb>
cltq
cmp    %rax,%rbx
jl     15f4 <ScanArgs+0x484>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %edx,%r14d
mov    0x8(%r10,%rbp,8),%rdi
mov    %r10,%r13
call   1060 <strlen@plt>
cmp    $0x1,%eax
jne    163c <ScanArgs+0x4cc>
add    $0x1,%r12d
add    $0x1,%rbp
mov    0x0(%r13,%rbp,8),%rax
movzbl (%rax),%eax
mov    0x158(%rsp),%rcx
jmp    14b8 <ScanArgs+0x348>
mov    0x148(%rsp),%rcx
movl   $0x1,(%rcx)
cltq
cmp    %rax,%rbx
jl     1600 <ScanArgs+0x490>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %edx,%r14d
mov    0x8(%r10,%rbp,8),%rdi
lea    0x20c3(%rip),%rsi
lea    0x40(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
jne    1511 <ScanArgs+0x3a1>
jmp    1648 <ScanArgs+0x4d8>
cltq
cmp    %rax,%rbx
jl     160c <ScanArgs+0x49c>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %r12,%r14
mov    %edx,0x24(%rsp)
mov    0x8(%r10,%rbp,8),%rdi
lea    0x2083(%rip),%r12
mov    %r12,%rsi
mov    0xd0(%rsp),%rdx
xor    %eax,%eax
mov    %r10,%r13
call   1070 <sscanf@plt>
test   %eax,%eax
je     1654 <ScanArgs+0x4e4>
mov    0x10(%r13,%rbp,8),%rdi
mov    %r12,%rsi
mov    0xd8(%rsp),%r15
mov    %r15,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     1528 <ScanArgs+0x3b8>
mov    0x18(%r13,%rbp,8),%rdi
xor    %r15d,%r15d
mov    %r12,%rsi
mov    0xe0(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     1ce3 <ScanArgs+0xb73>
mov    0x24(%rsp),%edx
add    $0x3,%edx
mov    %r14,%r12
add    $0x3,%r12d
mov    0x18(%rsp),%r10
mov    0x28(%rsp),%r13
jmp    1261 <ScanArgs+0xf1>
cltq
cmp    %rax,%rbx
jl     1618 <ScanArgs+0x4a8>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %edx,%r14d
mov    0x8(%r10,%rbp,8),%rdi
lea    0x1f90(%rip),%rsi
mov    0x120(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
jne    1511 <ScanArgs+0x3a1>
jmp    1660 <ScanArgs+0x4f0>
mov    0x110(%rsp),%rax
movl   $0x1,(%rax)
jmp    1261 <ScanArgs+0xf1>
mov    0x130(%rsp),%rax
movl   $0x1,(%rax)
mov    0x128(%rsp),%rax
movl   $0x0,(%rax)
mov    0x138(%rsp),%rax
jmp    125b <ScanArgs+0xeb>
cltq
cmp    %rax,%rbx
jl     1624 <ScanArgs+0x4b4>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %edx,%r14d
mov    0x8(%r10,%rbp,8),%rdi
mov    %r10,%r13
call   1060 <strlen@plt>
cmp    $0x1,%eax
jne    166c <ScanArgs+0x4fc>
add    $0x1,%r12d
add    $0x1,%rbp
mov    0x0(%r13,%rbp,8),%rax
movzbl (%rax),%eax
mov    0x160(%rsp),%rcx
mov    %al,(%rcx)
mov    %r14d,%edx
add    $0x1,%edx
xor    %r15d,%r15d
mov    %r13,%r10
mov    0x28(%rsp),%r13
jmp    1261 <ScanArgs+0xf1>
mov    0x140(%rsp),%rcx
movl   $0x1,(%rcx)
cltq
cmp    %rax,%rbx
jl     1630 <ScanArgs+0x4c0>
cmp    %r13d,%edx
jg     1566 <ScanArgs+0x3f6>
mov    %edx,%r14d
mov    0x8(%r10,%rbp,8),%rdi
lea    0x1f00(%rip),%rsi
lea    0x48(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     1678 <ScanArgs+0x508>
add    $0x1,%r12d
mov    %r14d,%edx
add    $0x1,%edx
xor    %r15d,%r15d
mov    0x18(%rsp),%r10
jmp    1261 <ScanArgs+0xf1>
mov    %r14,%r12
add    $0x1,%r12d
mov    0x24(%rsp),%edx
add    $0x1,%edx
mov    0xd0(%rsp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,(%r15)
mov    0xe0(%rsp),%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rax)
jmp    14c0 <ScanArgs+0x350>
cmp    %r13d,%edx
jle    15a4 <ScanArgs+0x434>
lea    0x1e25(%rip),%rdi
call   1040 <ErrPrint@plt>
mov    $0xffffffff,%r14d
mov    %r14d,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1d97(%rip),%rdi
call   1040 <ErrPrint@plt>
xor    %r14d,%r14d
jmp    1578 <ScanArgs+0x408>
lea    0x1da0(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
mov    %edx,0x24(%rsp)
movslq %r12d,%r15
mov    (%r10,%r15,8),%rdi
mov    %r10,%rbp
call   1060 <strlen@plt>
test   %eax,%eax
jle    1c19 <ScanArgs+0xaa9>
mov    0x0(%rbp,%r15,8),%rdx
xor    %r11d,%r11d
lea    0x1afa(%rip),%rsi
lea    0x1d1b(%rip),%r8
lea    0x1c10(%rip),%r9
xor    %ecx,%ecx
xor    %ebx,%ebx
mov    %rbp,%r10
jmp    16ae <ScanArgs+0x53e>
lea    0x1fa2(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1ed5(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1e27(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1f0b(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1d4c(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1e57(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1d9f(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1eb4(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1e06(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1ee9(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1d47(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1e36(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1d82(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x7a,0x0(%rbp,%rdi,4)
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
add    $0x1,%ebx
cmp    %eax,%ebx
jge    1c21 <ScanArgs+0xab1>
cmp    $0x14,%ecx
jge    1cef <ScanArgs+0xb7f>
movslq %ebx,%rdi
movsbl (%rdx,%rdi,1),%ebp
add    $0xffffffd2,%ebp
cmp    $0x48,%ebp
ja     1f0e <ScanArgs+0xd9e>
movslq (%rsi,%rbp,4),%rbp
add    %rsi,%rbp
jmp    *%rbp
add    $0xffffffff,%ecx
jmp    16a0 <ScanArgs+0x530>
movsbl 0x1(%rdx,%rdi,1),%ebp
add    $0xffffff93,%ebp
cmp    $0xd,%ebp
ja     204d <ScanArgs+0xedd>
add    $0x1,%rdi
mov    %edi,%ebx
movslq (%r8,%rbp,4),%rdi
add    %r8,%rdi
jmp    *%rdi
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x12c,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x1,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x9,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movsbl 0x1(%rdx,%rdi,1),%ebp
add    $0xffffffcc,%ebp
cmp    $0x40,%ebp
ja     206a <ScanArgs+0xefa>
lea    0x1(%rdi),%rbx
movslq (%r9,%rbp,4),%rbp
add    %r9,%rbp
jmp    *%rbp
movsbl 0x2(%rdx,%rdi,1),%ebp
cmp    $0x72,%ebp
jg     1aa4 <ScanArgs+0x934>
cmp    $0x41,%ebp
je     1b51 <ScanArgs+0x9e1>
cmp    $0x45,%ebp
jne    21a7 <ScanArgs+0x1037>
movsbl 0x3(%rdx,%rdi,1),%ebp
add    $0x3,%rdi
mov    %edi,%ebx
cmp    $0x2d,%ebp
je     1bbf <ScanArgs+0xa4f>
cmp    $0x2b,%ebp
jne    2210 <ScanArgs+0x10a0>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d9,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
cmpb   $0x72,0x1(%rdx,%rdi,1)
jne    1f1a <ScanArgs+0xdaa>
add    $0x1,%rdi
movslq %ecx,%rbp
mov    0x150(%rsp),%rbx
movl   $0xc9,(%rbx,%rbp,4)
mov    %edi,%ebx
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x2,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x7,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x3,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x8,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x6,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x5,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0xb,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0xa,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x12e,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x12f,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x12d,0x0(%rbp,%rdi,4)
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x78,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movsbl 0x2(%rdx,%rdi,1),%ebp
add    $0x2,%rdi
mov    %edi,%ebx
cmp    $0x30,%ebp
je     1b15 <ScanArgs+0x9a5>
cmp    $0x2d,%ebp
je     1b33 <ScanArgs+0x9c3>
cmp    $0x2b,%ebp
jne    219b <ScanArgs+0x102b>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x3e9,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movsbl 0x2(%rdx,%rdi,1),%ebp
add    $0x2,%rdi
mov    %edi,%ebx
cmp    $0x2d,%ebp
je     1ad9 <ScanArgs+0x969>
cmp    $0x2b,%ebp
jne    2172 <ScanArgs+0x1002>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4e3,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x79,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x66,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x6b,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x67,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x68,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x6d,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x6c,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movsbl 0x2(%rdx,%rdi,1),%ebp
add    $0x2,%rdi
mov    %edi,%ebx
cmp    $0x2d,%ebp
je     1af7 <ScanArgs+0x987>
cmp    $0x2b,%ebp
jne    217e <ScanArgs+0x100e>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d1,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
cmp    $0x74,%ebp
je     1b88 <ScanArgs+0xa18>
cmp    $0x73,%ebp
jne    21a7 <ScanArgs+0x1037>
add    $0x2,%rdi
movslq %ecx,%rbp
mov    0x150(%rsp),%rbx
movl   $0x4dd,(%rbx,%rbp,4)
mov    $0x1,%r11d
mov    %edi,%ebx
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4e4,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d2,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x64,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x3ea,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movsbl 0x3(%rdx,%rdi,1),%ebp
add    $0x3,%rdi
mov    %edi,%ebx
cmp    $0x2d,%ebp
je     1bdd <ScanArgs+0xa6d>
cmp    $0x2b,%ebp
jne    221c <ScanArgs+0x10ac>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4cf,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movsbl 0x3(%rdx,%rdi,1),%ebp
add    $0x3,%rdi
mov    %edi,%ebx
cmp    $0x2d,%ebp
je     1bfb <ScanArgs+0xa8b>
cmp    $0x2b,%ebp
jne    2228 <ScanArgs+0x10b8>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d3,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4da,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d0,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
movslq %ecx,%rdi
mov    0x150(%rsp),%rbp
movl   $0x4d4,0x0(%rbp,%rdi,4)
mov    $0x1,%r11d
jmp    16a0 <ScanArgs+0x530>
xor    %ecx,%ecx
xor    %r11d,%r11d
mov    %rbp,%r10
mov    %r11d,%ebp
movslq %ecx,%rax
mov    0x150(%rsp),%rcx
movl   $0xffffffff,(%rcx,%rax,4)
mov    0x8(%r10,%r15,8),%rdi
mov    0x10(%r10,%r15,8),%rsi
lea    0x34(%rsp),%rax
mov    %rax,(%rsp)
mov    0xa8(%rsp),%rdx
mov    0xc0(%rsp),%rcx
mov    0xc8(%rsp),%r8
mov    0xe8(%rsp),%r9
mov    %r10,%rbx
call   1090 <ScanTarget@plt>
mov    0x108(%rsp),%rcx
mov    %eax,(%rcx)
mov    $0xffffffff,%r14d
test   %eax,%eax
jle    1578 <ScanArgs+0x408>
mov    0x18(%rbx,%r15,8),%rdi
mov    0xa0(%rsp),%rsi
mov    0xf0(%rsp),%rbx
mov    %rbx,%rdx
call   1050 <ScanPro@plt>
cmp    $0xffffffff,%eax
je     1578 <ScanArgs+0x408>
cmpl   $0x0,(%rbx)
je     1cfb <ScanArgs+0xb8b>
lea    0x4(%r12),%ebx
test   %ebp,%ebp
je     1d0c <ScanArgs+0xb9c>
mov    0x24(%rsp),%eax
add    $0x2,%eax
cmp    %r13d,%eax
mov    0x18(%rsp),%rcx
jle    1d6b <ScanArgs+0xbfb>
lea    0x1ac9(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x1882(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x18b7(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1a6e(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
mov    0x18(%rsp),%rax
movslq %ebx,%r15
mov    (%rax,%r15,8),%rdi
lea    0x16de(%rip),%rsi
mov    0x58(%rsp),%rbp
mov    %rbp,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     1e8f <ScanArgs+0xd1f>
xorpd  %xmm0,%xmm0
ucomisd 0x0(%rbp),%xmm0
jb     1d4f <ScanArgs+0xbdf>
movabs $0x3e7ad7f29abcaf48,%rax
d7 7a 3e
mov    %rax,0x0(%rbp)
lea    -0x1(%r13),%eax
cmp    %eax,%ebx
mov    0x18(%rsp),%rax
jne    1ea0 <ScanArgs+0xd30>
mov    $0x1,%r14d
jmp    1578 <ScanArgs+0x408>
cmpl   $0x0,0x34(%rsp)
je     1d83 <ScanArgs+0xc13>
lea    0x1a5b(%rip),%rdi
call   1040 <ErrPrint@plt>
mov    0x18(%rsp),%rcx
movslq %ebx,%rax
mov    (%rcx,%rax,8),%rdi
mov    0xb0(%rsp),%rsi
mov    0xf8(%rsp),%rdx
call   1050 <ScanPro@plt>
cmp    $0xffffffff,%eax
je     1578 <ScanArgs+0x408>
mov    0xf0(%rsp),%rbx
mov    (%rbx),%edi
mov    0xa0(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
addsd  0x1239(%rip),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
movsd  0x48(%rsp),%xmm1
mulsd  0x122a(%rip),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
mov    0xe8(%rsp),%r13
mov    0x0(%r13),%edi
mov    0xa8(%rsp),%rbp
movsd  0x0(%rbp),%xmm0
addsd  0x11f8(%rip),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
movsd  %xmm0,0x0(%rbp)
mov    0xb0(%rsp),%rbp
mov    0xf8(%rsp),%rax
mov    (%rax),%edi
movsd  0x0(%rbp),%xmm0
addsd  0x11cb(%rip),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
movsd  0x11c2(%rip),%xmm1
mulsd  0x40(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
mov    0x0(%r13),%edi
add    (%rbx),%edi
mov    0xf8(%rsp),%rbx
sub    (%rbx),%edi
mov    0x100(%rsp),%rax
mov    %edi,(%rax)
js     1f26 <ScanArgs+0xdb6>
cmp    $0x5d,%edi
jb     1f37 <ScanArgs+0xdc7>
lea    0x19c2(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x1a76(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
add    $0xfffffffd,%r13d
cmp    %r13d,%ebx
jne    1f8b <ScanArgs+0xe1b>
mov    0x8(%rax,%r15,8),%rdi
lea    0x1544(%rip),%rsi
mov    0x50(%rsp),%rbx
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     2059 <ScanArgs+0xee9>
movsd  (%rbx),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    1efd <ScanArgs+0xd8d>
movsd  0x0(%rbp),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm1
movsd  0x112d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2076 <ScanArgs+0xf06>
lea    0x1a9d(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x1836(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x16b3(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x18e1(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
mov    0xa0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0xa8(%rsp),%rax
addsd  (%rax),%xmm0
subsd  %xmm1,%xmm0
addsd  0x10a5(%rip),%xmm0
cvttsd2si %xmm0,%esi
call   1030 <IsoMass@plt>
mov    0xb8(%rsp),%rax
movsd  %xmm0,(%rax)
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jbe    1f9c <ScanArgs+0xe2c>
lea    0x18f5(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x19a7(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
mov    0x18(%rsp),%rax
mov    0x28(%rax,%r15,8),%rdi
mov    (%rdi),%al
add    $0xbc,%al
cmp    $0x34,%al
ja     20f7 <ScanArgs+0xf87>
movzbl %al,%eax
movabs $0x10000100100001,%rcx
bt     %rax,%rcx
jae    20f7 <ScanArgs+0xf87>
mov    0xf0(%rsp),%rax
mov    (%rax),%edi
mov    0xe8(%rsp),%rax
mov    (%rax),%esi
mov    (%rbx),%edx
mov    0xa0(%rsp),%rax
movsd  (%rax),%xmm0
movsd  0x100d(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    0xa8(%rsp),%rax
movsd  (%rax),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%r8d
addsd  0x0(%rbp),%xmm1
cvttsd2si %xmm1,%r9d
call   1080 <IsoQ@plt>
mov    0x38(%rsp),%rax
movsd  %xmm0,(%rax)
ucomisd 0xfe0(%rip),%xmm0
jne    20e2 <ScanArgs+0xf72>
jp     20e2 <ScanArgs+0xf72>
lea    0x186a(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x1595(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1914(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x16a6(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
mov    0x18(%rsp),%rax
mov    0x10(%rax,%r15,8),%rdi
lea    0x1324(%rip),%rsi
mov    0x118(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     218a <ScanArgs+0x101a>
mov    0x118(%rsp),%rax
mov    (%rax),%eax
test   %eax,%eax
jle    21b3 <ScanArgs+0x1043>
mov    0x50(%rsp),%rcx
movsd  (%rcx),%xmm0
mov    0x58(%rsp),%rcx
subsd  (%rcx),%xmm0
add    $0xffffffff,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
mov    0x60(%rsp),%rax
movsd  %xmm0,(%rax)
jmp    1d60 <ScanArgs+0xbf0>
addsd  0x48(%rsp),%xmm0
subsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%rax)
jmp    21fa <ScanArgs+0x108a>
lea    0x12ff(%rip),%rsi
mov    0x38(%rsp),%rdx
xor    %eax,%eax
call   1070 <sscanf@plt>
test   %eax,%eax
je     21c4 <ScanArgs+0x1054>
mov    0xb0(%rsp),%rax
movsd  (%rax),%xmm1
mov    0xb8(%rsp),%rax
movsd  (%rax),%xmm2
ucomisd %xmm2,%xmm1
mov    0xa8(%rsp),%rax
movsd  (%rax),%xmm0
mov    0xa0(%rsp),%rax
addsd  (%rax),%xmm0
jbe    21d5 <ScanArgs+0x1065>
subsd  %xmm2,%xmm0
mov    0x38(%rsp),%rax
movsd  (%rax),%xmm1
mulsd  0xeb7(%rip),%xmm1
addsd  %xmm0,%xmm1
mov    0xb0(%rsp),%rax
jmp    21f6 <ScanArgs+0x1086>
lea    0x1570(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1536(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x1843(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x14e9(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x14c8(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x184b(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
lea    0x1711(%rip),%rdi
call   1040 <ErrPrint@plt>
jmp    1578 <ScanArgs+0x408>
subsd  %xmm1,%xmm0
mov    0x38(%rsp),%rax
movsd  (%rax),%xmm1
mulsd  0xe2e(%rip),%xmm1
addsd  %xmm0,%xmm1
mov    0xb8(%rsp),%rax
movsd  %xmm1,(%rax)
add    $0x6,%r12d
mov    %r12d,%ebx
mov    0x18(%rsp),%rax
mov    0x28(%rsp),%r13
jmp    1d11 <ScanArgs+0xba1>
lea    0x140f(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x13db(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>
lea    0x141f(%rip),%rdi
jmp    156d <ScanArgs+0x3fd>

LLVM IR (-O0):
@.str = [26 x i8] c"ERROR: Too few parameters\00"
@.str.1 = [41 x i8] c"ERROR: '-' alone is an invalid argument.\00"
@.str.2 = [39 x i8] c"ERROR: c- switch not last in parameter\00"
@.str.3 = [25 x i8] c"ERROR: Too few parameter\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [40 x i8] c"ERROR: Unable to charge state argument!\00"
@.str.6 = [39 x i8] c"ERROR: x- switch not last in parameter\00"
@.str.7 = [4 x i8] c"%lf\00"
@.str.8 = [45 x i8] c"ERROR: Unable to covert (2) ex. energy arg.!\00"
@.str.9 = [39 x i8] c"ERROR: X- switch not last in parameter\00"
@.str.10 = [45 x i8] c"ERROR: Unable to covert (3)-ex. energy arg.!\00"
@.str.11 = [39 x i8] c"ERROR: s- switch not last in parameter\00"
@.str.12 = [39 x i8] c"ERROR: after -s one Character expected\00"
@.str.13 = [39 x i8] c"ERROR: S- switch not last in parameter\00"
@.str.14 = [39 x i8] c"ERROR: after -S one Character expected\00"
@.str.15 = [38 x i8] c"ERROR: a- switch not last in Argument\00"
@.str.16 = [40 x i8] c"ERROR: Unable to covert angle argument!\00"
@.str.17 = [37 x i8] c"ERROR: Trouble cov. angle step Arg.!\00"
@.str.18 = [28 x i8] c"ERROR: Unimplemented Switch\00"
@.str.19 = [39 x i8] c"ERROR: Too many commands in Com-String\00"
@.str.20 = [21 x i8] c"Undefined X-command.\00"
@.str.21 = [21 x i8] c"Undefined D-command.\00"
@.str.22 = [40 x i8] c"Undefined R4A-command. use R4A+ or R4A-\00"
@.str.23 = [40 x i8] c"Undefined R4E-command: Use R4E+ or R4E-\00"
@.str.24 = [40 x i8] c"Undefined R4C-command: Use R4t+ or R4t-\00"
@.str.25 = [21 x i8] c"Undefined R4-command\00"
@.str.26 = [48 x i8] c"Undef. RE-command: Last letter must be +,- or 0\00"
@.str.27 = [46 x i8] c"Undef. RC-command: Last letter must be + or -\00"
@.str.28 = [46 x i8] c"Undef. RJ-command: Last letter must be + or -\00"
@.str.29 = [52 x i8] c"Undefined rekation prod. command in command string!\00"
@.str.30 = [37 x i8] c"Undefined command in command string!\00"
@.str.31 = [50 x i8] c"ERROR: Sorry, can't calculate neutron scattering.\00"
@.str.32 = [50 x i8] c"ERROR: Too few parameter for reakion produkt mode\00"
@.str.33 = [58 x i8] c"WARNING: 1st target set to isotopic mass. (check with -v)\00"
@.str.34 = [57 x i8] c"ERROR: This resction is impossible (4th charge negative)\00"
@.str.35 = [47 x i8] c"ERROR: Z of 4th reaction partner is too large!\00"
@.str.36 = [55 x i8] c"ERROR: This reaction is impossible (4th mass negative)\00"
@.str.37 = [47 x i8] c"ERROR: Sorry, can't calculate Q-Value. No Data\00"
@.str.38 = [48 x i8] c"ERROR:Unable to covert energy Q-value argument!\00"
@.str.39 = [45 x i8] c"ERROR:Unable to covert energy (E1) argument!\00"
@.str.40 = [59 x i8] c"ERROR: Number of arguments either one to small or to large\00"
@.str.41 = [45 x i8] c"ERROR:Unable to covert energy (E2) argument!\00"
@.str.42 = [51 x i8] c"ERROR:Energy E2 must be positive and other than E1\00"
@.str.43 = [49 x i8] c"ERROR:Unable to covert energy (ESteps) argument!\00"
@.str.44 = [45 x i8] c"ERROR: Number of energy steps < 1: Nonsense!\00"
define i32 @ScanArgs(i32 %0, i8** %1, double* %2, double* %3, double* %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14, i32* %15, i32* %16, i32* %17, i32* %18, i32* %19, i32* %20, i32* %21, i32* %22, i32* %23, i32* %24, i32* %25, i32* %26, i32* %27, i32* %28, i8* %29, i8* %30) {
%32 = alloca i32
%33 = alloca i32
%34 = alloca i8**
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca double*
%40 = alloca double*
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = alloca double*
%48 = alloca i32*
%49 = alloca i32*
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca i32*
%53 = alloca i32*
%54 = alloca i32*
%55 = alloca i32*
%56 = alloca i32*
%57 = alloca i32*
%58 = alloca i32*
%59 = alloca i32*
%60 = alloca i32*
%61 = alloca i32*
%62 = alloca i8*
%63 = alloca i8*
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca double
%74 = alloca double
store i32 %0, i32* %33
store i8** %1, i8*** %34
store double* %2, double** %35
store double* %3, double** %36
store double* %4, double** %37
store double* %5, double** %38
store double* %6, double** %39
store double* %7, double** %40
store double* %8, double** %41
store double* %9, double** %42
store double* %10, double** %43
store double* %11, double** %44
store double* %12, double** %45
store double* %13, double** %46
store double* %14, double** %47
store i32* %15, i32** %48
store i32* %16, i32** %49
store i32* %17, i32** %50
store i32* %18, i32** %51
store i32* %19, i32** %52
store i32* %20, i32** %53
store i32* %21, i32** %54
store i32* %22, i32** %55
store i32* %23, i32** %56
store i32* %24, i32** %57
store i32* %25, i32** %58
store i32* %26, i32** %59
store i32* %27, i32** %60
store i32* %28, i32** %61
store i8* %29, i8** %62
store i8* %30, i8** %63
store i32 0, i32* %64
store i32 0, i32* %65
store i32 0, i32* %66
store i32 0, i32* %67
store i32 1, i32* %68
store i32 5, i32* %69
store i32 0, i32* %70
store i32 0, i32* %71
store i32 0, i32* %72
store double 0.000000e+00, double* %73
store double 0.000000e+00, double* %74
%75 = load i32, i32* %33
%76 = load i32, i32* %69
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %80
78: ; preds = %31
%79 = call i32 @ErrPrint(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
80: ; preds = %31
br label %81
81: ; preds = %381, %80
%82 = load i32, i32* %72
%83 = icmp ne i32 %82, 0
%84 = xor i1 %83, true
br i1 %84, label %85, label %382
85: ; preds = %81
%86 = load i8**, i8*** %34
%87 = load i32, i32* %66
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8*, i8** %86, i64 %88
%90 = load i8*, i8** %89
%91 = getelementptr inbounds i8, i8* %90, i64 0
%92 = load i8, i8* %91
%93 = sext i8 %92 to i32
%94 = icmp eq i32 %93, 45
br i1 %94, label %95, label %380
95: ; preds = %85
%96 = load i32, i32* %69
%97 = add nsw i32 %96, 1
store i32 %97, i32* %69
%98 = load i32, i32* %33
%99 = load i32, i32* %69
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %103
101: ; preds = %95
%102 = call i32 @ErrPrint(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %32
br label %1156
103: ; preds = %95
store i32 1, i32* %68
%104 = load i8**, i8*** %34
%105 = load i32, i32* %66
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8*, i8** %104, i64 %106
%108 = load i8*, i8** %107
%109 = call i32 @strlen(i8* %108)
store i32 %109, i32* %67
%110 = load i32, i32* %67
%111 = icmp eq i32 %110, 1
br i1 %111, label %112, label %114
112: ; preds = %103
%113 = call i32 @ErrPrint(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
114: ; preds = %103
br label %115
115: ; preds = %374, %114
%116 = load i32, i32* %67
%117 = sub nsw i32 %116, 1
%118 = load i32, i32* %68
%119 = icmp sge i32 %117, %118
br i1 %119, label %120, label %377
120: ; preds = %115
%121 = load i8**, i8*** %34
%122 = load i32, i32* %66
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i8*, i8** %121, i64 %123
%125 = load i8*, i8** %124
%126 = load i32, i32* %68
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %125, i64 %127
%129 = load i8, i8* %128
%130 = sext i8 %129 to i32
switch i32 %130, label %372 [
i32 113, label %131
i32 81, label %135
i32 118, label %139
i32 103, label %143
i32 99, label %145
i32 120, label %175
i32 88, label %205
i32 115, label %235
i32 83, label %273
i32 97, label %311
]
131: ; preds = %120
%132 = load i32*, i32** %57
store i32 1, i32* %132
%133 = load i32*, i32** %56
store i32 0, i32* %133
%134 = load i32*, i32** %58
store i32 0, i32* %134
br label %374
135: ; preds = %120
%136 = load i32*, i32** %56
store i32 1, i32* %136
%137 = load i32*, i32** %57
store i32 1, i32* %137
%138 = load i32*, i32** %58
store i32 0, i32* %138
br label %374
139: ; preds = %120
%140 = load i32*, i32** %58
store i32 1, i32* %140
%141 = load i32*, i32** %57
store i32 0, i32* %141
%142 = load i32*, i32** %56
store i32 0, i32* %142
br label %374
143: ; preds = %120
%144 = load i32*, i32** %53
store i32 1, i32* %144
br label %374
145: ; preds = %120
%146 = load i32, i32* %67
%147 = sub nsw i32 %146, 1
%148 = load i32, i32* %68
%149 = icmp sgt i32 %147, %148
br i1 %149, label %150, label %152
150: ; preds = %145
%151 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
152: ; preds = %145
%153 = load i32, i32* %69
%154 = load i32, i32* %33
%155 = icmp sgt i32 %153, %154
br i1 %155, label %156, label %158
156: ; preds = %152
%157 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
158: ; preds = %152
%159 = load i8**, i8*** %34
%160 = load i32, i32* %66
%161 = add nsw i32 %160, 1
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i8*, i8** %159, i64 %162
%164 = load i8*, i8** %163
%165 = load i32*, i32** %55
%166 = call i32 (i8*, i8*, ...) @sscanf(i8* %164, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %165)
%167 = icmp ne i32 %166, 0
br i1 %167, label %170, label %168
168: ; preds = %158
%169 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.5, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
170: ; preds = %158
%171 = load i32, i32* %66
%172 = add nsw i32 %171, 1
store i32 %172, i32* %66
%173 = load i32, i32* %69
%174 = add nsw i32 %173, 1
store i32 %174, i32* %69
store i32 0, i32* %67
br label %374
175: ; preds = %120
%176 = load i32*, i32** %59
store i32 1, i32* %176
%177 = load i32, i32* %67
%178 = sub nsw i32 %177, 1
%179 = load i32, i32* %68
%180 = icmp sgt i32 %178, %179
br i1 %180, label %181, label %183
181: ; preds = %175
%182 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.6, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
183: ; preds = %175
%184 = load i32, i32* %69
%185 = load i32, i32* %33
%186 = icmp sgt i32 %184, %185
br i1 %186, label %187, label %189
187: ; preds = %183
%188 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
189: ; preds = %183
%190 = load i8**, i8*** %34
%191 = load i32, i32* %66
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8*, i8** %190, i64 %193
%195 = load i8*, i8** %194
%196 = call i32 (i8*, i8*, ...) @sscanf(i8* %195, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %73)
%197 = icmp ne i32 %196, 0
br i1 %197, label %200, label %198
198: ; preds = %189
%199 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.8, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
200: ; preds = %189
%201 = load i32, i32* %66
%202 = add nsw i32 %201, 1
store i32 %202, i32* %66
%203 = load i32, i32* %69
%204 = add nsw i32 %203, 1
store i32 %204, i32* %69
store i32 0, i32* %67
br label %374
205: ; preds = %120
%206 = load i32*, i32** %60
store i32 1, i32* %206
%207 = load i32, i32* %67
%208 = sub nsw i32 %207, 1
%209 = load i32, i32* %68
%210 = icmp sgt i32 %208, %209
br i1 %210, label %211, label %213
211: ; preds = %205
%212 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.9, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
213: ; preds = %205
%214 = load i32, i32* %69
%215 = load i32, i32* %33
%216 = icmp sgt i32 %214, %215
br i1 %216, label %217, label %219
217: ; preds = %213
%218 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
219: ; preds = %213
%220 = load i8**, i8*** %34
%221 = load i32, i32* %66
%222 = add nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8*, i8** %220, i64 %223
%225 = load i8*, i8** %224
%226 = call i32 (i8*, i8*, ...) @sscanf(i8* %225, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %74)
%227 = icmp ne i32 %226, 0
br i1 %227, label %230, label %228
228: ; preds = %219
%229 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.10, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
230: ; preds = %219
%231 = load i32, i32* %66
%232 = add nsw i32 %231, 1
store i32 %232, i32* %66
%233 = load i32, i32* %69
%234 = add nsw i32 %233, 1
store i32 %234, i32* %69
store i32 0, i32* %67
br label %374
235: ; preds = %120
%236 = load i32, i32* %67
%237 = sub nsw i32 %236, 1
%238 = load i32, i32* %68
%239 = icmp sgt i32 %237, %238
br i1 %239, label %240, label %242
240: ; preds = %235
%241 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.11, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
242: ; preds = %235
%243 = load i32, i32* %69
%244 = load i32, i32* %33
%245 = icmp sgt i32 %243, %244
br i1 %245, label %246, label %248
246: ; preds = %242
%247 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
248: ; preds = %242
%249 = load i8**, i8*** %34
%250 = load i32, i32* %66
%251 = add nsw i32 %250, 1
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8*, i8** %249, i64 %252
%254 = load i8*, i8** %253
%255 = call i32 @strlen(i8* %254)
%256 = icmp ne i32 %255, 1
br i1 %256, label %257, label %259
257: ; preds = %248
%258 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.12, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
259: ; preds = %248
%260 = load i8**, i8*** %34
%261 = load i32, i32* %66
%262 = add nsw i32 %261, 1
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i8*, i8** %260, i64 %263
%265 = load i8*, i8** %264
%266 = getelementptr inbounds i8, i8* %265, i64 0
%267 = load i8, i8* %266
%268 = load i8*, i8** %63
store i8 %267, i8* %268
%269 = load i32, i32* %66
%270 = add nsw i32 %269, 1
store i32 %270, i32* %66
%271 = load i32, i32* %69
%272 = add nsw i32 %271, 1
store i32 %272, i32* %69
store i32 0, i32* %67
br label %374
273: ; preds = %120
%274 = load i32, i32* %67
%275 = sub nsw i32 %274, 1
%276 = load i32, i32* %68
%277 = icmp sgt i32 %275, %276
br i1 %277, label %278, label %280
278: ; preds = %273
%279 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.13, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
280: ; preds = %273
%281 = load i32, i32* %69
%282 = load i32, i32* %33
%283 = icmp sgt i32 %281, %282
br i1 %283, label %284, label %286
284: ; preds = %280
%285 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
286: ; preds = %280
%287 = load i8**, i8*** %34
%288 = load i32, i32* %66
%289 = add nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds i8*, i8** %287, i64 %290
%292 = load i8*, i8** %291
%293 = call i32 @strlen(i8* %292)
%294 = icmp ne i32 %293, 1
br i1 %294, label %295, label %297
295: ; preds = %286
%296 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
297: ; preds = %286
%298 = load i8**, i8*** %34
%299 = load i32, i32* %66
%300 = add nsw i32 %299, 1
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds i8*, i8** %298, i64 %301
%303 = load i8*, i8** %302
%304 = getelementptr inbounds i8, i8* %303, i64 0
%305 = load i8, i8* %304
%306 = load i8*, i8** %62
store i8 %305, i8* %306
%307 = load i32, i32* %66
%308 = add nsw i32 %307, 1
store i32 %308, i32* %66
%309 = load i32, i32* %69
%310 = add nsw i32 %309, 1
store i32 %310, i32* %69
store i32 0, i32* %67
br label %374
311: ; preds = %120
%312 = load i32, i32* %67
%313 = sub nsw i32 %312, 1
%314 = load i32, i32* %68
%315 = icmp sgt i32 %313, %314
br i1 %315, label %316, label %318
316: ; preds = %311
%317 = call i32 @ErrPrint(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.15, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
318: ; preds = %311
%319 = load i32, i32* %69
%320 = load i32, i32* %33
%321 = icmp sgt i32 %319, %320
br i1 %321, label %322, label %324
322: ; preds = %318
%323 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
324: ; preds = %318
%325 = load i8**, i8*** %34
%326 = load i32, i32* %66
%327 = add nsw i32 %326, 1
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i8*, i8** %325, i64 %328
%330 = load i8*, i8** %329
%331 = load double*, double** %45
%332 = call i32 (i8*, i8*, ...) @sscanf(i8* %330, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %331)
%333 = icmp ne i32 %332, 0
br i1 %333, label %336, label %334
334: ; preds = %324
%335 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.16, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
336: ; preds = %324
%337 = load i32, i32* %66
%338 = add nsw i32 %337, 1
store i32 %338, i32* %66
%339 = load i32, i32* %69
%340 = add nsw i32 %339, 1
store i32 %340, i32* %69
%341 = load i8**, i8*** %34
%342 = load i32, i32* %66
%343 = add nsw i32 %342, 1
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds i8*, i8** %341, i64 %344
%346 = load i8*, i8** %345
%347 = load double*, double** %46
%348 = call i32 (i8*, i8*, ...) @sscanf(i8* %346, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %347)
%349 = icmp ne i32 %348, 0
br i1 %349, label %355, label %350
350: ; preds = %336
%351 = load double*, double** %45
%352 = load double, double* %351
%353 = load double*, double** %46
store double %352, double* %353
%354 = load double*, double** %47
store double 1.000000e+00, double* %354
br label %371
355: ; preds = %336
%356 = load i32, i32* %69
%357 = add nsw i32 %356, 2
store i32 %357, i32* %69
%358 = load i32, i32* %66
%359 = add nsw i32 %358, 2
store i32 %359, i32* %66
%360 = load i8**, i8*** %34
%361 = load i32, i32* %66
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i8*, i8** %360, i64 %362
%364 = load i8*, i8** %363
%365 = load double*, double** %47
%366 = call i32 (i8*, i8*, ...) @sscanf(i8* %364, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %365)
%367 = icmp ne i32 %366, 0
br i1 %367, label %370, label %368
368: ; preds = %355
%369 = call i32 @ErrPrint(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.17, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
370: ; preds = %355
br label %371
371: ; preds = %370, %350
store i32 0, i32* %67
br label %374
372: ; preds = %120
%373 = call i32 @ErrPrint(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
374: ; preds = %371, %297, %259, %230, %200, %170, %143, %139, %135, %131
%375 = load i32, i32* %68
%376 = add nsw i32 %375, 1
store i32 %376, i32* %68
br label %115
377: ; preds = %115
%378 = load i32, i32* %66
%379 = add nsw i32 %378, 1
store i32 %379, i32* %66
br label %381
380: ; preds = %85
store i32 1, i32* %72
br label %381
381: ; preds = %380, %377
br label %81
382: ; preds = %81
store i32 0, i32* %72
%383 = load i32, i32* %69
%384 = load i32, i32* %33
%385 = icmp sgt i32 %383, %384
br i1 %385, label %386, label %388
386: ; preds = %382
%387 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
388: ; preds = %382
%389 = load i8**, i8*** %34
%390 = load i32, i32* %66
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i8*, i8** %389, i64 %391
%393 = load i8*, i8** %392
%394 = call i32 @strlen(i8* %393)
store i32 %394, i32* %67
store i32 0, i32* %64
br label %395
395: ; preds = %779, %388
%396 = load i32, i32* %64
%397 = load i32, i32* %67
%398 = sub nsw i32 %397, 1
%399 = icmp sle i32 %396, %398
br i1 %399, label %400, label %782
400: ; preds = %395
%401 = load i32, i32* %65
%402 = icmp sge i32 %401, 20
br i1 %402, label %403, label %405
403: ; preds = %400
%404 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.19, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
405: ; preds = %400
%406 = load i8**, i8*** %34
%407 = load i32, i32* %66
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i8*, i8** %406, i64 %408
%410 = load i8*, i8** %409
%411 = load i32, i32* %64
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i8, i8* %410, i64 %412
%414 = load i8, i8* %413
%415 = sext i8 %414 to i32
switch i32 %415, label %774 [
i32 65, label %416
i32 69, label %421
i32 97, label %426
i32 101, label %431
i32 108, label %436
i32 114, label %441
i32 112, label %446
i32 80, label %451
i32 99, label %456
i32 118, label %461
i32 111, label %466
i32 115, label %471
i32 88, label %476
i32 68, label %497
i32 82, label %533
i32 46, label %771
]
416: ; preds = %405
%417 = load i32*, i32** %61
%418 = load i32, i32* %65
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i32, i32* %417, i64 %419
store i32 122, i32* %420
br label %776
421: ; preds = %405
%422 = load i32*, i32** %61
%423 = load i32, i32* %65
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds i32, i32* %422, i64 %424
store i32 1, i32* %425
br label %776
426: ; preds = %405
%427 = load i32*, i32** %61
%428 = load i32, i32* %65
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i32, i32* %427, i64 %429
store i32 2, i32* %430
br label %776
431: ; preds = %405
%432 = load i32*, i32** %61
%433 = load i32, i32* %65
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds i32, i32* %432, i64 %434
store i32 3, i32* %435
br label %776
436: ; preds = %405
%437 = load i32*, i32** %61
%438 = load i32, i32* %65
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i32, i32* %437, i64 %439
store i32 4, i32* %440
br label %776
441: ; preds = %405
%442 = load i32*, i32** %61
%443 = load i32, i32* %65
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
store i32 5, i32* %445
br label %776
446: ; preds = %405
%447 = load i32*, i32** %61
%448 = load i32, i32* %65
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %447, i64 %449
store i32 6, i32* %450
br label %776
451: ; preds = %405
%452 = load i32*, i32** %61
%453 = load i32, i32* %65
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %452, i64 %454
store i32 9, i32* %455
br label %776
456: ; preds = %405
%457 = load i32*, i32** %61
%458 = load i32, i32* %65
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i32, i32* %457, i64 %459
store i32 7, i32* %460
br label %776
461: ; preds = %405
%462 = load i32*, i32** %61
%463 = load i32, i32* %65
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
store i32 10, i32* %465
br label %776
466: ; preds = %405
%467 = load i32*, i32** %61
%468 = load i32, i32* %65
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i32, i32* %467, i64 %469
store i32 8, i32* %470
br label %776
471: ; preds = %405
%472 = load i32*, i32** %61
%473 = load i32, i32* %65
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32, i32* %472, i64 %474
store i32 11, i32* %475
br label %776
476: ; preds = %405
%477 = load i32, i32* %64
%478 = add nsw i32 %477, 1
store i32 %478, i32* %64
%479 = load i8**, i8*** %34
%480 = load i32, i32* %66
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i8*, i8** %479, i64 %481
%483 = load i8*, i8** %482
%484 = load i32, i32* %64
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i8, i8* %483, i64 %485
%487 = load i8, i8* %486
%488 = sext i8 %487 to i32
switch i32 %488, label %494 [
i32 114, label %489
]
489: ; preds = %476
%490 = load i32*, i32** %61
%491 = load i32, i32* %65
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds i32, i32* %490, i64 %492
store i32 201, i32* %493
br label %496
494: ; preds = %476
%495 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.20, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
496: ; preds = %489
br label %776
497: ; preds = %405
%498 = load i32, i32* %64
%499 = add nsw i32 %498, 1
store i32 %499, i32* %64
%500 = load i8**, i8*** %34
%501 = load i32, i32* %66
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds i8*, i8** %500, i64 %502
%504 = load i8*, i8** %503
%505 = load i32, i32* %64
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i8, i8* %504, i64 %506
%508 = load i8, i8* %507
%509 = sext i8 %508 to i32
switch i32 %509, label %530 [
i32 109, label %510
i32 122, label %515
i32 113, label %520
i32 115, label %525
]
510: ; preds = %497
%511 = load i32*, i32** %61
%512 = load i32, i32* %65
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds i32, i32* %511, i64 %513
store i32 300, i32* %514
br label %532
515: ; preds = %497
%516 = load i32*, i32** %61
%517 = load i32, i32* %65
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i32, i32* %516, i64 %518
store i32 301, i32* %519
br label %532
520: ; preds = %497
%521 = load i32*, i32** %61
%522 = load i32, i32* %65
%523 = sext i32 %522 to i64
%524 = getelementptr inbounds i32, i32* %521, i64 %523
store i32 302, i32* %524
br label %532
525: ; preds = %497
%526 = load i32*, i32** %61
%527 = load i32, i32* %65
%528 = sext i32 %527 to i64
%529 = getelementptr inbounds i32, i32* %526, i64 %528
store i32 303, i32* %529
br label %532
530: ; preds = %497
%531 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.21, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
532: ; preds = %525, %520, %515, %510
br label %776
533: ; preds = %405
%534 = load i32, i32* %64
%535 = add nsw i32 %534, 1
store i32 %535, i32* %64
store i32 1, i32* %71
%536 = load i8**, i8*** %34
%537 = load i32, i32* %66
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i8*, i8** %536, i64 %538
%540 = load i8*, i8** %539
%541 = load i32, i32* %64
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i8, i8* %540, i64 %542
%544 = load i8, i8* %543
%545 = sext i8 %544 to i32
switch i32 %545, label %768 [
i32 52, label %546
i32 69, label %645
i32 116, label %676
i32 74, label %702
i32 115, label %728
i32 97, label %733
i32 101, label %738
i32 108, label %743
i32 99, label %748
i32 111, label %753
i32 84, label %758
i32 67, label %763
]
546: ; preds = %533
%547 = load i32, i32* %64
%548 = add nsw i32 %547, 1
store i32 %548, i32* %64
%549 = load i8**, i8*** %34
%550 = load i32, i32* %66
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i8*, i8** %549, i64 %551
%553 = load i8*, i8** %552
%554 = load i32, i32* %64
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i8, i8* %553, i64 %555
%557 = load i8, i8* %556
%558 = sext i8 %557 to i32
switch i32 %558, label %642 [
i32 115, label %559
i32 65, label %564
i32 69, label %590
i32 116, label %616
]
559: ; preds = %546
%560 = load i32*, i32** %61
%561 = load i32, i32* %65
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds i32, i32* %560, i64 %562
store i32 1245, i32* %563
br label %644
564: ; preds = %546
%565 = load i32, i32* %64
%566 = add nsw i32 %565, 1
store i32 %566, i32* %64
%567 = load i8**, i8*** %34
%568 = load i32, i32* %66
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds i8*, i8** %567, i64 %569
%571 = load i8*, i8** %570
%572 = load i32, i32* %64
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds i8, i8* %571, i64 %573
%575 = load i8, i8* %574
%576 = sext i8 %575 to i32
switch i32 %576, label %587 [
i32 43, label %577
i32 45, label %582
]
577: ; preds = %564
%578 = load i32*, i32** %61
%579 = load i32, i32* %65
%580 = sext i32 %579 to i64
%581 = getelementptr inbounds i32, i32* %578, i64 %580
store i32 1231, i32* %581
br label %589
582: ; preds = %564
%583 = load i32*, i32** %61
%584 = load i32, i32* %65
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds i32, i32* %583, i64 %585
store i32 1232, i32* %586
br label %589
587: ; preds = %564
%588 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.22, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
589: ; preds = %582, %577
br label %644
590: ; preds = %546
%591 = load i32, i32* %64
%592 = add nsw i32 %591, 1
store i32 %592, i32* %64
%593 = load i8**, i8*** %34
%594 = load i32, i32* %66
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds i8*, i8** %593, i64 %595
%597 = load i8*, i8** %596
%598 = load i32, i32* %64
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds i8, i8* %597, i64 %599
%601 = load i8, i8* %600
%602 = sext i8 %601 to i32
switch i32 %602, label %613 [
i32 43, label %603
i32 45, label %608
]
603: ; preds = %590
%604 = load i32*, i32** %61
%605 = load i32, i32* %65
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %604, i64 %606
store i32 1241, i32* %607
br label %615
608: ; preds = %590
%609 = load i32*, i32** %61
%610 = load i32, i32* %65
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds i32, i32* %609, i64 %611
store i32 1242, i32* %612
br label %615
613: ; preds = %590
%614 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
615: ; preds = %608, %603
br label %644
616: ; preds = %546
%617 = load i32, i32* %64
%618 = add nsw i32 %617, 1
store i32 %618, i32* %64
%619 = load i8**, i8*** %34
%620 = load i32, i32* %66
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds i8*, i8** %619, i64 %621
%623 = load i8*, i8** %622
%624 = load i32, i32* %64
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds i8, i8* %623, i64 %625
%627 = load i8, i8* %626
%628 = sext i8 %627 to i32
switch i32 %628, label %639 [
i32 43, label %629
i32 45, label %634
]
629: ; preds = %616
%630 = load i32*, i32** %61
%631 = load i32, i32* %65
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i32, i32* %630, i64 %632
store i32 1235, i32* %633
br label %641
634: ; preds = %616
%635 = load i32*, i32** %61
%636 = load i32, i32* %65
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds i32, i32* %635, i64 %637
store i32 1236, i32* %638
br label %641
639: ; preds = %616
%640 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
641: ; preds = %634, %629
br label %644
642: ; preds = %546
%643 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
644: ; preds = %641, %615, %589, %559
br label %770
645: ; preds = %533
%646 = load i32, i32* %64
%647 = add nsw i32 %646, 1
store i32 %647, i32* %64
%648 = load i8**, i8*** %34
%649 = load i32, i32* %66
%650 = sext i32 %649 to i64
%651 = getelementptr inbounds i8*, i8** %648, i64 %650
%652 = load i8*, i8** %651
%653 = load i32, i32* %64
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds i8, i8* %652, i64 %654
%656 = load i8, i8* %655
%657 = sext i8 %656 to i32
switch i32 %657, label %673 [
i32 43, label %658
i32 45, label %663
i32 48, label %668
]
658: ; preds = %645
%659 = load i32*, i32** %61
%660 = load i32, i32* %65
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds i32, i32* %659, i64 %661
store i32 1001, i32* %662
br label %675
663: ; preds = %645
%664 = load i32*, i32** %61
%665 = load i32, i32* %65
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i32, i32* %664, i64 %666
store i32 1002, i32* %667
br label %675
668: ; preds = %645
%669 = load i32*, i32** %61
%670 = load i32, i32* %65
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds i32, i32* %669, i64 %671
store i32 100, i32* %672
br label %675
673: ; preds = %645
%674 = call i32 @ErrPrint(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.26, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
675: ; preds = %668, %663, %658
br label %770
676: ; preds = %533
%677 = load i32, i32* %64
%678 = add nsw i32 %677, 1
store i32 %678, i32* %64
%679 = load i8**, i8*** %34
%680 = load i32, i32* %66
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds i8*, i8** %679, i64 %681
%683 = load i8*, i8** %682
%684 = load i32, i32* %64
%685 = sext i32 %684 to i64
%686 = getelementptr inbounds i8, i8* %683, i64 %685
%687 = load i8, i8* %686
%688 = sext i8 %687 to i32
switch i32 %688, label %699 [
i32 43, label %689
i32 45, label %694
]
689: ; preds = %676
%690 = load i32*, i32** %61
%691 = load i32, i32* %65
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds i32, i32* %690, i64 %692
store i32 1233, i32* %693
br label %701
694: ; preds = %676
%695 = load i32*, i32** %61
%696 = load i32, i32* %65
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds i32, i32* %695, i64 %697
store i32 1234, i32* %698
br label %701
699: ; preds = %676
%700 = call i32 @ErrPrint(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.27, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
701: ; preds = %694, %689
br label %770
702: ; preds = %533
%703 = load i32, i32* %64
%704 = add nsw i32 %703, 1
store i32 %704, i32* %64
%705 = load i8**, i8*** %34
%706 = load i32, i32* %66
%707 = sext i32 %706 to i64
%708 = getelementptr inbounds i8*, i8** %705, i64 %707
%709 = load i8*, i8** %708
%710 = load i32, i32* %64
%711 = sext i32 %710 to i64
%712 = getelementptr inbounds i8, i8* %709, i64 %711
%713 = load i8, i8* %712
%714 = sext i8 %713 to i32
switch i32 %714, label %725 [
i32 43, label %715
i32 45, label %720
]
715: ; preds = %702
%716 = load i32*, i32** %61
%717 = load i32, i32* %65
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds i32, i32* %716, i64 %718
store i32 1251, i32* %719
br label %727
720: ; preds = %702
%721 = load i32*, i32** %61
%722 = load i32, i32* %65
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds i32, i32* %721, i64 %723
store i32 1252, i32* %724
br label %727
725: ; preds = %702
%726 = call i32 @ErrPrint(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.28, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
727: ; preds = %720, %715
br label %770
728: ; preds = %533
%729 = load i32*, i32** %61
%730 = load i32, i32* %65
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds i32, i32* %729, i64 %731
store i32 108, i32* %732
br label %770
733: ; preds = %533
%734 = load i32*, i32** %61
%735 = load i32, i32* %65
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds i32, i32* %734, i64 %736
store i32 102, i32* %737
br label %770
738: ; preds = %533
%739 = load i32*, i32** %61
%740 = load i32, i32* %65
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds i32, i32* %739, i64 %741
store i32 103, i32* %742
br label %770
743: ; preds = %533
%744 = load i32*, i32** %61
%745 = load i32, i32* %65
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds i32, i32* %744, i64 %746
store i32 104, i32* %747
br label %770
748: ; preds = %533
%749 = load i32*, i32** %61
%750 = load i32, i32* %65
%751 = sext i32 %750 to i64
%752 = getelementptr inbounds i32, i32* %749, i64 %751
store i32 107, i32* %752
br label %770
753: ; preds = %533
%754 = load i32*, i32** %61
%755 = load i32, i32* %65
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds i32, i32* %754, i64 %756
store i32 109, i32* %757
br label %770
758: ; preds = %533
%759 = load i32*, i32** %61
%760 = load i32, i32* %65
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds i32, i32* %759, i64 %761
store i32 121, i32* %762
br label %770
763: ; preds = %533
%764 = load i32*, i32** %61
%765 = load i32, i32* %65
%766 = sext i32 %765 to i64
%767 = getelementptr inbounds i32, i32* %764, i64 %766
store i32 120, i32* %767
br label %770
768: ; preds = %533
%769 = call i32 @ErrPrint(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.29, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
770: ; preds = %763, %758, %753, %748, %743, %738, %733, %728, %727, %701, %675, %644
br label %776
771: ; preds = %405
%772 = load i32, i32* %65
%773 = add nsw i32 %772, -1
store i32 %773, i32* %65
br label %776
774: ; preds = %405
%775 = call i32 @ErrPrint(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.30, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
776: ; preds = %771, %770, %532, %496, %471, %466, %461, %456, %451, %446, %441, %436, %431, %426, %421, %416
%777 = load i32, i32* %65
%778 = add nsw i32 %777, 1
store i32 %778, i32* %65
br label %779
779: ; preds = %776
%780 = load i32, i32* %64
%781 = add nsw i32 %780, 1
store i32 %781, i32* %64
br label %395
782: ; preds = %395
%783 = load i32*, i32** %61
%784 = load i32, i32* %65
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds i32, i32* %783, i64 %785
store i32 -1, i32* %786
%787 = load i32, i32* %66
%788 = add nsw i32 %787, 1
store i32 %788, i32* %66
%789 = load i8**, i8*** %34
%790 = load i32, i32* %66
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds i8*, i8** %789, i64 %791
%793 = load i8*, i8** %792
%794 = load i8**, i8*** %34
%795 = load i32, i32* %66
%796 = add nsw i32 %795, 1
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds i8*, i8** %794, i64 %797
%799 = load i8*, i8** %798
%800 = load double*, double** %40
%801 = load double*, double** %43
%802 = load double*, double** %44
%803 = load i32*, i32** %48
%804 = call i32 @ScanTarget(i8* %793, i8* %799, double* %800, double* %801, double* %802, i32* %803, i32* %70)
%805 = load i32*, i32** %52
store i32 %804, i32* %805
%806 = load i32*, i32** %52
%807 = load i32, i32* %806
%808 = icmp slt i32 %807, 1
br i1 %808, label %809, label %810
809: ; preds = %782
store i32 -1, i32* %32
br label %1156
810: ; preds = %782
%811 = load i32, i32* %66
%812 = add nsw i32 %811, 2
store i32 %812, i32* %66
%813 = load i8**, i8*** %34
%814 = load i32, i32* %66
%815 = sext i32 %814 to i64
%816 = getelementptr inbounds i8*, i8** %813, i64 %815
%817 = load i8*, i8** %816
%818 = load double*, double** %39
%819 = load i32*, i32** %49
%820 = call i32 @ScanPro(i8* %817, double* %818, i32* %819)
%821 = icmp eq i32 -1, %820
br i1 %821, label %822, label %823
822: ; preds = %810
store i32 -1, i32* %32
br label %1156
823: ; preds = %810
%824 = load i32*, i32** %49
%825 = load i32, i32* %824
%826 = icmp eq i32 %825, 0
br i1 %826, label %827, label %829
827: ; preds = %823
%828 = call i32 @ErrPrint(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.31, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
829: ; preds = %823
%830 = load i32, i32* %66
%831 = add nsw i32 %830, 1
store i32 %831, i32* %66
%832 = load i32, i32* %71
%833 = icmp ne i32 %832, 0
br i1 %833, label %834, label %1062
834: ; preds = %829
%835 = load i32, i32* %69
%836 = add nsw i32 %835, 2
store i32 %836, i32* %69
%837 = load i32, i32* %69
%838 = load i32, i32* %33
%839 = icmp sgt i32 %837, %838
br i1 %839, label %840, label %842
840: ; preds = %834
%841 = call i32 @ErrPrint(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.32, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
842: ; preds = %834
%843 = load i32, i32* %70
%844 = icmp ne i32 %843, 0
br i1 %844, label %845, label %847
845: ; preds = %842
%846 = call i32 @ErrPrint(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.33, i64 0, i64 0))
br label %847
847: ; preds = %845, %842
%848 = load i8**, i8*** %34
%849 = load i32, i32* %66
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds i8*, i8** %848, i64 %850
%852 = load i8*, i8** %851
%853 = load double*, double** %41
%854 = load i32*, i32** %50
%855 = call i32 @ScanPro(i8* %852, double* %853, i32* %854)
%856 = icmp eq i32 -1, %855
br i1 %856, label %857, label %858
857: ; preds = %847
store i32 -1, i32* %32
br label %1156
858: ; preds = %847
%859 = load i32*, i32** %49
%860 = load i32, i32* %859
%861 = load double*, double** %39
%862 = load double, double* %861
%863 = fadd double %862, 5.000000e-01
%864 = fptosi double %863 to i32
%865 = call double @IsoMass(i32 %860, i32 %864)
%866 = load double, double* %73
%867 = call double @llvm.fmuladd.f64(double %866, double 0x3F5196C404DAB8D1, double %865)
%868 = load double*, double** %39
store double %867, double* %868
%869 = load i32*, i32** %48
%870 = getelementptr inbounds i32, i32* %869, i64 0
%871 = load i32, i32* %870
%872 = load double*, double** %40
%873 = getelementptr inbounds double, double* %872, i64 0
%874 = load double, double* %873
%875 = fadd double %874, 5.000000e-01
%876 = fptosi double %875 to i32
%877 = call double @IsoMass(i32 %871, i32 %876)
%878 = load double*, double** %40
%879 = getelementptr inbounds double, double* %878, i64 0
store double %877, double* %879
%880 = load i32*, i32** %50
%881 = load i32, i32* %880
%882 = load double*, double** %41
%883 = load double, double* %882
%884 = fadd double %883, 5.000000e-01
%885 = fptosi double %884 to i32
%886 = call double @IsoMass(i32 %881, i32 %885)
%887 = load double, double* %74
%888 = call double @llvm.fmuladd.f64(double %887, double 0x3F5196C404DAB8D1, double %886)
%889 = load double*, double** %41
store double %888, double* %889
%890 = load i32*, i32** %49
%891 = load i32, i32* %890
%892 = load i32*, i32** %48
%893 = getelementptr inbounds i32, i32* %892, i64 0
%894 = load i32, i32* %893
%895 = add nsw i32 %891, %894
%896 = load i32*, i32** %50
%897 = load i32, i32* %896
%898 = sub nsw i32 %895, %897
%899 = load i32*, i32** %51
store i32 %898, i32* %899
%900 = load i32*, i32** %51
%901 = load i32, i32* %900
%902 = icmp slt i32 %901, 0
br i1 %902, label %903, label %905
903: ; preds = %858
%904 = call i32 @ErrPrint(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.34, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
905: ; preds = %858
%906 = load i32*, i32** %51
%907 = load i32, i32* %906
%908 = icmp sgt i32 %907, 92
br i1 %908, label %909, label %911
909: ; preds = %905
%910 = call i32 @ErrPrint(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.35, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
911: ; preds = %905
%912 = load i32*, i32** %51
%913 = load i32, i32* %912
%914 = load double*, double** %39
%915 = load double, double* %914
%916 = load double*, double** %40
%917 = getelementptr inbounds double, double* %916, i64 0
%918 = load double, double* %917
%919 = fadd double %915, %918
%920 = load double*, double** %41
%921 = load double, double* %920
%922 = fsub double %919, %921
%923 = fadd double %922, 5.000000e-01
%924 = fptosi double %923 to i32
%925 = call double @IsoMass(i32 %913, i32 %924)
%926 = load double*, double** %42
store double %925, double* %926
%927 = load double*, double** %42
%928 = load double, double* %927
%929 = fcmp olt double %928, 0.000000e+00
br i1 %929, label %930, label %932
930: ; preds = %911
%931 = call i32 @ErrPrint(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.36, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
932: ; preds = %911
%933 = load i32, i32* %66
%934 = add nsw i32 %933, 1
store i32 %934, i32* %66
%935 = load i8**, i8*** %34
%936 = load i32, i32* %66
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds i8*, i8** %935, i64 %937
%939 = load i8*, i8** %938
%940 = getelementptr inbounds i8, i8* %939, i64 0
%941 = load i8, i8* %940
%942 = sext i8 %941 to i32
%943 = icmp eq i32 %942, 88
br i1 %943, label %974, label %944
944: ; preds = %932
%945 = load i8**, i8*** %34
%946 = load i32, i32* %66
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds i8*, i8** %945, i64 %947
%949 = load i8*, i8** %948
%950 = getelementptr inbounds i8, i8* %949, i64 0
%951 = load i8, i8* %950
%952 = sext i8 %951 to i32
%953 = icmp eq i32 %952, 120
br i1 %953, label %974, label %954
954: ; preds = %944
%955 = load i8**, i8*** %34
%956 = load i32, i32* %66
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds i8*, i8** %955, i64 %957
%959 = load i8*, i8** %958
%960 = getelementptr inbounds i8, i8* %959, i64 0
%961 = load i8, i8* %960
%962 = sext i8 %961 to i32
%963 = icmp eq i32 %962, 68
br i1 %963, label %974, label %964
964: ; preds = %954
%965 = load i8**, i8*** %34
%966 = load i32, i32* %66
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds i8*, i8** %965, i64 %967
%969 = load i8*, i8** %968
%970 = getelementptr inbounds i8, i8* %969, i64 0
%971 = load i8, i8* %970
%972 = sext i8 %971 to i32
%973 = icmp eq i32 %972, 100
br i1 %973, label %974, label %1010
974: ; preds = %964, %954, %944, %932
%975 = load i32*, i32** %49
%976 = load i32, i32* %975
%977 = load i32*, i32** %48
%978 = getelementptr inbounds i32, i32* %977, i64 0
%979 = load i32, i32* %978
%980 = load i32*, i32** %50
%981 = load i32, i32* %980
%982 = load double*, double** %39
%983 = load double, double* %982
%984 = fadd double %983, 5.000000e-01
%985 = fptosi double %984 to i32
%986 = load double*, double** %40
%987 = getelementptr inbounds double, double* %986, i64 0
%988 = load double, double* %987
%989 = fadd double %988, 5.000000e-01
%990 = fptosi double %989 to i32
%991 = load double*, double** %41
%992 = load double, double* %991
%993 = fadd double %992, 5.000000e-01
%994 = fptosi double %993 to i32
%995 = call double @IsoQ(i32 %976, i32 %979, i32 %981, i32 %985, i32 %990, i32 %994)
%996 = load double*, double** %38
store double %995, double* %996
%997 = load double*, double** %38
%998 = load double, double* %997
%999 = fcmp oeq double %998, 0xC16312CFE0000000
br i1 %999, label %1000, label %1002
1000: ; preds = %974
%1001 = call i32 @ErrPrint(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.37, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1002: ; preds = %974
%1003 = load double*, double** %38
%1004 = load double, double* %1003
%1005 = load double, double* %73
%1006 = fadd double %1004, %1005
%1007 = load double, double* %74
%1008 = fsub double %1006, %1007
%1009 = load double*, double** %38
store double %1008, double* %1009
br label %1059
1010: ; preds = %964
%1011 = load i8**, i8*** %34
%1012 = load i32, i32* %66
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds i8*, i8** %1011, i64 %1013
%1015 = load i8*, i8** %1014
%1016 = load double*, double** %38
%1017 = call i32 (i8*, i8*, ...) @sscanf(i8* %1015, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %1016)
%1018 = icmp ne i32 %1017, 0
br i1 %1018, label %1021, label %1019
1019: ; preds = %1010
%1020 = call i32 @ErrPrint(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.38, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1021: ; preds = %1010
%1022 = load double*, double** %41
%1023 = load double, double* %1022
%1024 = load double*, double** %42
%1025 = load double, double* %1024
%1026 = fcmp ogt double %1023, %1025
br i1 %1026, label %1027, label %1042
1027: ; preds = %1021
%1028 = load double*, double** %40
%1029 = getelementptr inbounds double, double* %1028, i64 0
%1030 = load double, double* %1029
%1031 = load double*, double** %39
%1032 = load double, double* %1031
%1033 = fadd double %1030, %1032
%1034 = load double*, double** %42
%1035 = load double, double* %1034
%1036 = fsub double %1033, %1035
%1037 = load double*, double** %38
%1038 = load double, double* %1037
%1039 = fneg double %1038
%1040 = call double @llvm.fmuladd.f64(double %1039, double 0x3F5196C404DAB8D1, double %1036)
%1041 = load double*, double** %41
store double %1040, double* %1041
br label %1057
1042: ; preds = %1021
%1043 = load double*, double** %40
%1044 = getelementptr inbounds double, double* %1043, i64 0
%1045 = load double, double* %1044
%1046 = load double*, double** %39
%1047 = load double, double* %1046
%1048 = fadd double %1045, %1047
%1049 = load double*, double** %41
%1050 = load double, double* %1049
%1051 = fsub double %1048, %1050
%1052 = load double*, double** %38
%1053 = load double, double* %1052
%1054 = fneg double %1053
%1055 = call double @llvm.fmuladd.f64(double %1054, double 0x3F5196C404DAB8D1, double %1051)
%1056 = load double*, double** %42
store double %1055, double* %1056
br label %1057
1057: ; preds = %1042, %1027
br label %1058
1058: ; preds = %1057
br label %1059
1059: ; preds = %1058, %1002
%1060 = load i32, i32* %66
%1061 = add nsw i32 %1060, 1
store i32 %1061, i32* %66
br label %1062
1062: ; preds = %1059, %829
%1063 = load i8**, i8*** %34
%1064 = load i32, i32* %66
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds i8*, i8** %1063, i64 %1065
%1067 = load i8*, i8** %1066
%1068 = load double*, double** %35
%1069 = call i32 (i8*, i8*, ...) @sscanf(i8* %1067, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %1068)
%1070 = icmp ne i32 %1069, 0
br i1 %1070, label %1073, label %1071
1071: ; preds = %1062
%1072 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.39, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1073: ; preds = %1062
%1074 = load double*, double** %35
%1075 = load double, double* %1074
%1076 = fcmp ole double %1075, 0.000000e+00
br i1 %1076, label %1077, label %1079
1077: ; preds = %1073
%1078 = load double*, double** %35
store double 0x3E7AD7F29ABCAF48, double* %1078
br label %1079
1079: ; preds = %1077, %1073
%1080 = load i32, i32* %66
%1081 = load i32, i32* %33
%1082 = sub nsw i32 %1081, 1
%1083 = icmp eq i32 %1080, %1082
br i1 %1083, label %1084, label %1085
1084: ; preds = %1079
store i32 1, i32* %32
br label %1156
1085: ; preds = %1079
%1086 = load i32, i32* %66
%1087 = load i32, i32* %33
%1088 = sub nsw i32 %1087, 3
%1089 = icmp ne i32 %1086, %1088
br i1 %1089, label %1090, label %1092
1090: ; preds = %1085
%1091 = call i32 @ErrPrint(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.40, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1092: ; preds = %1085
%1093 = load i32, i32* %66
%1094 = add nsw i32 %1093, 1
store i32 %1094, i32* %66
%1095 = load i8**, i8*** %34
%1096 = load i32, i32* %66
%1097 = sext i32 %1096 to i64
%1098 = getelementptr inbounds i8*, i8** %1095, i64 %1097
%1099 = load i8*, i8** %1098
%1100 = load double*, double** %36
%1101 = call i32 (i8*, i8*, ...) @sscanf(i8* %1099, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %1100)
%1102 = icmp ne i32 %1101, 0
br i1 %1102, label %1105, label %1103
1103: ; preds = %1092
%1104 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.41, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1105: ; preds = %1092
%1106 = load double*, double** %36
%1107 = load double, double* %1106
%1108 = fcmp ole double %1107, 0.000000e+00
br i1 %1108, label %1122, label %1109
1109: ; preds = %1105
%1110 = load double*, double** %35
%1111 = load double, double* %1110
%1112 = load double*, double** %36
%1113 = load double, double* %1112
%1114 = fsub double %1111, %1113
%1115 = load double*, double** %35
%1116 = load double, double* %1115
%1117 = load double*, double** %36
%1118 = load double, double* %1117
%1119 = fsub double %1116, %1118
%1120 = fmul double %1114, %1119
%1121 = fcmp olt double %1120, 1.000000e-04
br i1 %1121, label %1122, label %1124
1122: ; preds = %1109, %1105
%1123 = call i32 @ErrPrint(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.42, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1124: ; preds = %1109
%1125 = load i32, i32* %66
%1126 = add nsw i32 %1125, 1
store i32 %1126, i32* %66
%1127 = load i8**, i8*** %34
%1128 = load i32, i32* %66
%1129 = sext i32 %1128 to i64
%1130 = getelementptr inbounds i8*, i8** %1127, i64 %1129
%1131 = load i8*, i8** %1130
%1132 = load i32*, i32** %54
%1133 = call i32 (i8*, i8*, ...) @sscanf(i8* %1131, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %1132)
%1134 = icmp ne i32 %1133, 0
br i1 %1134, label %1137, label %1135
1135: ; preds = %1124
%1136 = call i32 @ErrPrint(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.43, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1137: ; preds = %1124
%1138 = load i32*, i32** %54
%1139 = load i32, i32* %1138
%1140 = icmp slt i32 %1139, 1
br i1 %1140, label %1141, label %1143
1141: ; preds = %1137
%1142 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.44, i64 0, i64 0))
store i32 -1, i32* %32
br label %1156
1143: ; preds = %1137
%1144 = load double*, double** %36
%1145 = load double, double* %1144
%1146 = load double*, double** %35
%1147 = load double, double* %1146
%1148 = fsub double %1145, %1147
%1149 = load i32*, i32** %54
%1150 = load i32, i32* %1149
%1151 = sub nsw i32 %1150, 1
%1152 = sitofp i32 %1151 to float
%1153 = fpext float %1152 to double
%1154 = fdiv double %1148, %1153
%1155 = load double*, double** %37
store double %1154, double* %1155
store i32 1, i32* %32
br label %1156
1156: ; preds = %1143, %1141, %1135, %1122, %1103, %1090, %1084, %1071, %1019, %1000, %930, %909, %903, %857, %840, %827, %822, %809, %774, %768, %725, %699, %673, %642, %639, %613, %587, %530, %494, %403, %386, %372, %368, %334, %322, %316, %295, %284, %278, %257, %246, %240, %228, %217, %211, %198, %187, %181, %168, %156, %150, %112, %101, %78
%1157 = load i32, i32* %32
ret i32 %1157
}

LLVM IR (-O2):
@.str = [26 x i8] c"ERROR: Too few parameters\00"
@.str.1 = [41 x i8] c"ERROR: '-' alone is an invalid argument.\00"
@.str.2 = [39 x i8] c"ERROR: c- switch not last in parameter\00"
@.str.3 = [25 x i8] c"ERROR: Too few parameter\00"
@.str.4 = [3 x i8] c"%i\00"
@.str.5 = [40 x i8] c"ERROR: Unable to charge state argument!\00"
@.str.6 = [39 x i8] c"ERROR: x- switch not last in parameter\00"
@.str.7 = [4 x i8] c"%lf\00"
@.str.8 = [45 x i8] c"ERROR: Unable to covert (2) ex. energy arg.!\00"
@.str.9 = [39 x i8] c"ERROR: X- switch not last in parameter\00"
@.str.10 = [45 x i8] c"ERROR: Unable to covert (3)-ex. energy arg.!\00"
@.str.11 = [39 x i8] c"ERROR: s- switch not last in parameter\00"
@.str.12 = [39 x i8] c"ERROR: after -s one Character expected\00"
@.str.13 = [39 x i8] c"ERROR: S- switch not last in parameter\00"
@.str.14 = [39 x i8] c"ERROR: after -S one Character expected\00"
@.str.15 = [38 x i8] c"ERROR: a- switch not last in Argument\00"
@.str.16 = [40 x i8] c"ERROR: Unable to covert angle argument!\00"
@.str.17 = [37 x i8] c"ERROR: Trouble cov. angle step Arg.!\00"
@.str.18 = [28 x i8] c"ERROR: Unimplemented Switch\00"
@.str.19 = [39 x i8] c"ERROR: Too many commands in Com-String\00"
@.str.20 = [21 x i8] c"Undefined X-command.\00"
@.str.21 = [21 x i8] c"Undefined D-command.\00"
@.str.22 = [40 x i8] c"Undefined R4A-command. use R4A+ or R4A-\00"
@.str.23 = [40 x i8] c"Undefined R4E-command: Use R4E+ or R4E-\00"
@.str.24 = [40 x i8] c"Undefined R4C-command: Use R4t+ or R4t-\00"
@.str.25 = [21 x i8] c"Undefined R4-command\00"
@.str.26 = [48 x i8] c"Undef. RE-command: Last letter must be +,- or 0\00"
@.str.27 = [46 x i8] c"Undef. RC-command: Last letter must be + or -\00"
@.str.28 = [46 x i8] c"Undef. RJ-command: Last letter must be + or -\00"
@.str.29 = [52 x i8] c"Undefined rekation prod. command in command string!\00"
@.str.30 = [37 x i8] c"Undefined command in command string!\00"
@.str.31 = [50 x i8] c"ERROR: Sorry, can't calculate neutron scattering.\00"
@.str.32 = [50 x i8] c"ERROR: Too few parameter for reakion produkt mode\00"
@.str.33 = [58 x i8] c"WARNING: 1st target set to isotopic mass. (check with -v)\00"
@.str.34 = [57 x i8] c"ERROR: This resction is impossible (4th charge negative)\00"
@.str.35 = [47 x i8] c"ERROR: Z of 4th reaction partner is too large!\00"
@.str.36 = [55 x i8] c"ERROR: This reaction is impossible (4th mass negative)\00"
@.str.37 = [47 x i8] c"ERROR: Sorry, can't calculate Q-Value. No Data\00"
@.str.38 = [48 x i8] c"ERROR:Unable to covert energy Q-value argument!\00"
@.str.39 = [45 x i8] c"ERROR:Unable to covert energy (E1) argument!\00"
@.str.40 = [59 x i8] c"ERROR: Number of arguments either one to small or to large\00"
@.str.41 = [45 x i8] c"ERROR:Unable to covert energy (E2) argument!\00"
@.str.42 = [51 x i8] c"ERROR:Energy E2 must be positive and other than E1\00"
@.str.43 = [49 x i8] c"ERROR:Unable to covert energy (ESteps) argument!\00"
@.str.44 = [45 x i8] c"ERROR: Number of energy steps < 1: Nonsense!\00"
define i32 @ScanArgs(i32 %0, i8** nocapture %1, double* %2, double* %3, double* nocapture writeonly %4, double* %5, double* %6, double* %7, double* %8, double* nocapture %9, double* %10, double* %11, double* %12, double* %13, double* %14, i32* %15, i32* %16, i32* %17, i32* nocapture writeonly %18, i32* nocapture writeonly %19, i32* nocapture writeonly %20, i32* %21, i32* %22, i32* nocapture writeonly %23, i32* nocapture writeonly %24, i32* nocapture writeonly %25, i32* nocapture writeonly %26, i32* nocapture writeonly %27, i32* writeonly %28, i8* nocapture writeonly %29, i8* nocapture writeonly %30) {
%32 = alloca i32
%33 = alloca double
%34 = alloca double
%35 = bitcast i32* %32 to i8*
store i32 0, i32* %32
%36 = bitcast double* %33 to i8*
store double 0.000000e+00, double* %33
%37 = bitcast double* %34 to i8*
store double 0.000000e+00, double* %34
%38 = icmp slt i32 %0, 5
br i1 %38, label %39, label %41
39: ; preds = %31
%40 = tail call i32 @ErrPrint(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
br label %669
41: ; preds = %31, %228
%42 = phi i32 [ %230, %228 ], [ 5, %31 ]
%43 = phi i32 [ %231, %228 ], [ 0, %31 ]
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8*, i8** %1, i64 %44
%46 = load i8*, i8** %45
%47 = load i8, i8* %46
%48 = icmp eq i8 %47, 45
br i1 %48, label %49, label %232
49: ; preds = %41
%50 = icmp slt i32 %42, %0
br i1 %50, label %53, label %51
51: ; preds = %49
%52 = call i32 @ErrPrint(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
br label %669
53: ; preds = %49
%54 = add nsw i32 %42, 1
%55 = call i32 @strlen(i8* %46)
%56 = icmp eq i32 %55, 1
br i1 %56, label %59, label %57
57: ; preds = %53
%58 = icmp sgt i32 %55, 1
br i1 %58, label %61, label %228
59: ; preds = %53
%60 = call i32 @ErrPrint(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0))
br label %669
61: ; preds = %57, %221
%62 = phi i64 [ %225, %221 ], [ 1, %57 ]
%63 = phi i32 [ %224, %221 ], [ %54, %57 ]
%64 = phi i32 [ %223, %221 ], [ %55, %57 ]
%65 = phi i32 [ %222, %221 ], [ %43, %57 ]
%66 = add nsw i32 %64, -1
%67 = sext i32 %65 to i64
%68 = getelementptr inbounds i8*, i8** %1, i64 %67
%69 = load i8*, i8** %68
%70 = getelementptr inbounds i8, i8* %69, i64 %62
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
switch i32 %72, label %219 [
i32 113, label %73
i32 81, label %74
i32 118, label %75
i32 103, label %76
i32 99, label %77
i32 120, label %97
i32 88, label %117
i32 115, label %137
i32 83, label %159
i32 97, label %181
]
73: ; preds = %61
store i32 1, i32* %24
store i32 0, i32* %23
store i32 0, i32* %25
br label %221
74: ; preds = %61
store i32 1, i32* %23
store i32 1, i32* %24
store i32 0, i32* %25
br label %221
75: ; preds = %61
store i32 1, i32* %25
store i32 0, i32* %24
store i32 0, i32* %23
br label %221
76: ; preds = %61
store i32 1, i32* %20
br label %221
77: ; preds = %61
%78 = sext i32 %66 to i64
%79 = icmp slt i64 %62, %78
br i1 %79, label %80, label %82
80: ; preds = %77
%81 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.2, i64 0, i64 0))
br label %669
82: ; preds = %77
%83 = icmp sgt i32 %63, %0
br i1 %83, label %84, label %86
84: ; preds = %82
%85 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
86: ; preds = %82
%87 = add nsw i32 %65, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8*, i8** %1, i64 %88
%90 = load i8*, i8** %89
%91 = call i32 (i8*, i8*, ...) @sscanf(i8* %90, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %22)
%92 = icmp eq i32 %91, 0
br i1 %92, label %93, label %95
93: ; preds = %86
%94 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.5, i64 0, i64 0))
br label %669
95: ; preds = %86
%96 = add nsw i32 %63, 1
br label %221
97: ; preds = %61
store i32 1, i32* %26
%98 = sext i32 %66 to i64
%99 = icmp slt i64 %62, %98
br i1 %99, label %100, label %102
100: ; preds = %97
%101 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.6, i64 0, i64 0))
br label %669
102: ; preds = %97
%103 = icmp sgt i32 %63, %0
br i1 %103, label %104, label %106
104: ; preds = %102
%105 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
106: ; preds = %102
%107 = add nsw i32 %65, 1
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8*, i8** %1, i64 %108
%110 = load i8*, i8** %109
%111 = call i32 (i8*, i8*, ...) @sscanf(i8* %110, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %33)
%112 = icmp eq i32 %111, 0
br i1 %112, label %113, label %115
113: ; preds = %106
%114 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.8, i64 0, i64 0))
br label %669
115: ; preds = %106
%116 = add nsw i32 %63, 1
br label %221
117: ; preds = %61
store i32 1, i32* %27
%118 = sext i32 %66 to i64
%119 = icmp slt i64 %62, %118
br i1 %119, label %120, label %122
120: ; preds = %117
%121 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.9, i64 0, i64 0))
br label %669
122: ; preds = %117
%123 = icmp sgt i32 %63, %0
br i1 %123, label %124, label %126
124: ; preds = %122
%125 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
126: ; preds = %122
%127 = add nsw i32 %65, 1
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i8*, i8** %1, i64 %128
%130 = load i8*, i8** %129
%131 = call i32 (i8*, i8*, ...) @sscanf(i8* %130, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %34)
%132 = icmp eq i32 %131, 0
br i1 %132, label %133, label %135
133: ; preds = %126
%134 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.10, i64 0, i64 0))
br label %669
135: ; preds = %126
%136 = add nsw i32 %63, 1
br label %221
137: ; preds = %61
%138 = sext i32 %66 to i64
%139 = icmp slt i64 %62, %138
br i1 %139, label %140, label %142
140: ; preds = %137
%141 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.11, i64 0, i64 0))
br label %669
142: ; preds = %137
%143 = icmp sgt i32 %63, %0
br i1 %143, label %144, label %146
144: ; preds = %142
%145 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
146: ; preds = %142
%147 = add nsw i32 %65, 1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8*, i8** %1, i64 %148
%150 = load i8*, i8** %149
%151 = call i32 @strlen(i8* %150)
%152 = icmp eq i32 %151, 1
br i1 %152, label %155, label %153
153: ; preds = %146
%154 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.12, i64 0, i64 0))
br label %669
155: ; preds = %146
%156 = load i8*, i8** %149
%157 = load i8, i8* %156
store i8 %157, i8* %30
%158 = add nsw i32 %63, 1
br label %221
159: ; preds = %61
%160 = sext i32 %66 to i64
%161 = icmp slt i64 %62, %160
br i1 %161, label %162, label %164
162: ; preds = %159
%163 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.13, i64 0, i64 0))
br label %669
164: ; preds = %159
%165 = icmp sgt i32 %63, %0
br i1 %165, label %166, label %168
166: ; preds = %164
%167 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
168: ; preds = %164
%169 = add nsw i32 %65, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8*, i8** %1, i64 %170
%172 = load i8*, i8** %171
%173 = call i32 @strlen(i8* %172)
%174 = icmp eq i32 %173, 1
br i1 %174, label %177, label %175
175: ; preds = %168
%176 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.14, i64 0, i64 0))
br label %669
177: ; preds = %168
%178 = load i8*, i8** %171
%179 = load i8, i8* %178
store i8 %179, i8* %29
%180 = add nsw i32 %63, 1
br label %221
181: ; preds = %61
%182 = sext i32 %66 to i64
%183 = icmp slt i64 %62, %182
br i1 %183, label %184, label %186
184: ; preds = %181
%185 = call i32 @ErrPrint(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.15, i64 0, i64 0))
br label %669
186: ; preds = %181
%187 = icmp sgt i32 %63, %0
br i1 %187, label %188, label %190
188: ; preds = %186
%189 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
190: ; preds = %186
%191 = add nsw i32 %65, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8*, i8** %1, i64 %192
%194 = load i8*, i8** %193
%195 = call i32 (i8*, i8*, ...) @sscanf(i8* %194, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %12)
%196 = icmp eq i32 %195, 0
br i1 %196, label %197, label %199
197: ; preds = %190
%198 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.16, i64 0, i64 0))
br label %669
199: ; preds = %190
%200 = add nsw i32 %65, 2
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8*, i8** %1, i64 %201
%203 = load i8*, i8** %202
%204 = call i32 (i8*, i8*, ...) @sscanf(i8* %203, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %13)
%205 = icmp eq i32 %204, 0
br i1 %205, label %206, label %209
206: ; preds = %199
%207 = add nsw i32 %63, 1
%208 = load double, double* %12
store double %208, double* %13
store double 1.000000e+00, double* %14
br label %221
209: ; preds = %199
%210 = add nsw i32 %63, 3
%211 = add nsw i32 %65, 3
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i8*, i8** %1, i64 %212
%214 = load i8*, i8** %213
%215 = call i32 (i8*, i8*, ...) @sscanf(i8* %214, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %14)
%216 = icmp eq i32 %215, 0
br i1 %216, label %217, label %221
217: ; preds = %209
%218 = call i32 @ErrPrint(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.17, i64 0, i64 0))
br label %669
219: ; preds = %61
%220 = call i32 @ErrPrint(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.18, i64 0, i64 0))
br label %669
221: ; preds = %206, %209, %177, %155, %135, %115, %95, %76, %75, %74, %73
%222 = phi i32 [ %169, %177 ], [ %147, %155 ], [ %127, %135 ], [ %107, %115 ], [ %87, %95 ], [ %65, %76 ], [ %65, %75 ], [ %65, %74 ], [ %65, %73 ], [ %211, %209 ], [ %191, %206 ]
%223 = phi i32 [ 0, %177 ], [ 0, %155 ], [ 0, %135 ], [ 0, %115 ], [ 0, %95 ], [ %64, %76 ], [ %64, %75 ], [ %64, %74 ], [ %64, %73 ], [ 0, %209 ], [ 0, %206 ]
%224 = phi i32 [ %180, %177 ], [ %158, %155 ], [ %136, %135 ], [ %116, %115 ], [ %96, %95 ], [ %63, %76 ], [ %63, %75 ], [ %63, %74 ], [ %63, %73 ], [ %210, %209 ], [ %207, %206 ]
%225 = add nuw i64 %62, 1
%226 = trunc i64 %225 to i32
%227 = icmp sgt i32 %223, %226
br i1 %227, label %61, label %228
228: ; preds = %221, %57
%229 = phi i32 [ %43, %57 ], [ %222, %221 ]
%230 = phi i32 [ %54, %57 ], [ %224, %221 ]
%231 = add nsw i32 %229, 1
br i1 %48, label %41, label %232
232: ; preds = %41, %228
%233 = phi i32 [ %230, %228 ], [ %42, %41 ]
%234 = phi i32 [ %231, %228 ], [ %43, %41 ]
%235 = icmp sgt i32 %233, %0
br i1 %235, label %236, label %238
236: ; preds = %232
%237 = call i32 @ErrPrint(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.3, i64 0, i64 0))
br label %669
238: ; preds = %232
%239 = sext i32 %234 to i64
%240 = getelementptr inbounds i8*, i8** %1, i64 %239
%241 = load i8*, i8** %240
%242 = call i32 @strlen(i8* %241)
%243 = icmp sgt i32 %242, 0
br i1 %243, label %244, label %466
244: ; preds = %238
%245 = load i8*, i8** %240
br label %246
246: ; preds = %244, %459
%247 = phi i32 [ 0, %244 ], [ %462, %459 ]
%248 = phi i32 [ 0, %244 ], [ %463, %459 ]
%249 = phi i32 [ 0, %244 ], [ %464, %459 ]
%250 = icmp sgt i32 %248, 19
br i1 %250, label %251, label %253
251: ; preds = %246
%252 = call i32 @ErrPrint(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.19, i64 0, i64 0))
br label %669
253: ; preds = %246
%254 = sext i32 %249 to i64
%255 = getelementptr inbounds i8, i8* %245, i64 %254
%256 = load i8, i8* %255
%257 = sext i8 %256 to i32
switch i32 %257, label %457 [
i32 65, label %258
i32 69, label %261
i32 97, label %264
i32 101, label %267
i32 108, label %270
i32 114, label %273
i32 112, label %276
i32 80, label %279
i32 99, label %282
i32 118, label %285
i32 111, label %288
i32 115, label %291
i32 88, label %294
i32 68, label %305
i32 82, label %325
i32 46, label %455
]
258: ; preds = %253
%259 = sext i32 %248 to i64
%260 = getelementptr inbounds i32, i32* %28, i64 %259
store i32 122, i32* %260
br label %459
261: ; preds = %253
%262 = sext i32 %248 to i64
%263 = getelementptr inbounds i32, i32* %28, i64 %262
store i32 1, i32* %263
br label %459
264: ; preds = %253
%265 = sext i32 %248 to i64
%266 = getelementptr inbounds i32, i32* %28, i64 %265
store i32 2, i32* %266
br label %459
267: ; preds = %253
%268 = sext i32 %248 to i64
%269 = getelementptr inbounds i32, i32* %28, i64 %268
store i32 3, i32* %269
br label %459
270: ; preds = %253
%271 = sext i32 %248 to i64
%272 = getelementptr inbounds i32, i32* %28, i64 %271
store i32 4, i32* %272
br label %459
273: ; preds = %253
%274 = sext i32 %248 to i64
%275 = getelementptr inbounds i32, i32* %28, i64 %274
store i32 5, i32* %275
br label %459
276: ; preds = %253
%277 = sext i32 %248 to i64
%278 = getelementptr inbounds i32, i32* %28, i64 %277
store i32 6, i32* %278
br label %459
279: ; preds = %253
%280 = sext i32 %248 to i64
%281 = getelementptr inbounds i32, i32* %28, i64 %280
store i32 9, i32* %281
br label %459
282: ; preds = %253
%283 = sext i32 %248 to i64
%284 = getelementptr inbounds i32, i32* %28, i64 %283
store i32 7, i32* %284
br label %459
285: ; preds = %253
%286 = sext i32 %248 to i64
%287 = getelementptr inbounds i32, i32* %28, i64 %286
store i32 10, i32* %287
br label %459
288: ; preds = %253
%289 = sext i32 %248 to i64
%290 = getelementptr inbounds i32, i32* %28, i64 %289
store i32 8, i32* %290
br label %459
291: ; preds = %253
%292 = sext i32 %248 to i64
%293 = getelementptr inbounds i32, i32* %28, i64 %292
store i32 11, i32* %293
br label %459
294: ; preds = %253
%295 = add nsw i32 %249, 1
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds i8, i8* %245, i64 %296
%298 = load i8, i8* %297
%299 = icmp eq i8 %298, 114
br i1 %299, label %300, label %303
300: ; preds = %294
%301 = sext i32 %248 to i64
%302 = getelementptr inbounds i32, i32* %28, i64 %301
store i32 201, i32* %302
br label %459
303: ; preds = %294
%304 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.20, i64 0, i64 0))
br label %669
305: ; preds = %253
%306 = add nsw i32 %249, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i8, i8* %245, i64 %307
%309 = load i8, i8* %308
%310 = sext i8 %309 to i32
switch i32 %310, label %323 [
i32 109, label %311
i32 122, label %314
i32 113, label %317
i32 115, label %320
]
311: ; preds = %305
%312 = sext i32 %248 to i64
%313 = getelementptr inbounds i32, i32* %28, i64 %312
store i32 300, i32* %313
br label %459
314: ; preds = %305
%315 = sext i32 %248 to i64
%316 = getelementptr inbounds i32, i32* %28, i64 %315
store i32 301, i32* %316
br label %459
317: ; preds = %305
%318 = sext i32 %248 to i64
%319 = getelementptr inbounds i32, i32* %28, i64 %318
store i32 302, i32* %319
br label %459
320: ; preds = %305
%321 = sext i32 %248 to i64
%322 = getelementptr inbounds i32, i32* %28, i64 %321
store i32 303, i32* %322
br label %459
323: ; preds = %305
%324 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.21, i64 0, i64 0))
br label %669
325: ; preds = %253
%326 = add nsw i32 %249, 1
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i8, i8* %245, i64 %327
%329 = load i8, i8* %328
%330 = sext i8 %329 to i32
switch i32 %330, label %453 [
i32 52, label %331
i32 69, label %384
i32 116, label %401
i32 74, label %415
i32 115, label %429
i32 97, label %432
i32 101, label %435
i32 108, label %438
i32 99, label %441
i32 111, label %444
i32 84, label %447
i32 67, label %450
]
331: ; preds = %325
%332 = add nsw i32 %249, 2
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i8, i8* %245, i64 %333
%335 = load i8, i8* %334
%336 = sext i8 %335 to i32
switch i32 %336, label %382 [
i32 115, label %337
i32 65, label %340
i32 69, label %354
i32 116, label %368
]
337: ; preds = %331
%338 = sext i32 %248 to i64
%339 = getelementptr inbounds i32, i32* %28, i64 %338
store i32 1245, i32* %339
br label %459
340: ; preds = %331
%341 = add nsw i32 %249, 3
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i8, i8* %245, i64 %342
%344 = load i8, i8* %343
%345 = sext i8 %344 to i32
switch i32 %345, label %352 [
i32 43, label %346
i32 45, label %349
]
346: ; preds = %340
%347 = sext i32 %248 to i64
%348 = getelementptr inbounds i32, i32* %28, i64 %347
store i32 1231, i32* %348
br label %459
349: ; preds = %340
%350 = sext i32 %248 to i64
%351 = getelementptr inbounds i32, i32* %28, i64 %350
store i32 1232, i32* %351
br label %459
352: ; preds = %340
%353 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.22, i64 0, i64 0))
br label %669
354: ; preds = %331
%355 = add nsw i32 %249, 3
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i8, i8* %245, i64 %356
%358 = load i8, i8* %357
%359 = sext i8 %358 to i32
switch i32 %359, label %366 [
i32 43, label %360
i32 45, label %363
]
360: ; preds = %354
%361 = sext i32 %248 to i64
%362 = getelementptr inbounds i32, i32* %28, i64 %361
store i32 1241, i32* %362
br label %459
363: ; preds = %354
%364 = sext i32 %248 to i64
%365 = getelementptr inbounds i32, i32* %28, i64 %364
store i32 1242, i32* %365
br label %459
366: ; preds = %354
%367 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0))
br label %669
368: ; preds = %331
%369 = add nsw i32 %249, 3
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i8, i8* %245, i64 %370
%372 = load i8, i8* %371
%373 = sext i8 %372 to i32
switch i32 %373, label %380 [
i32 43, label %374
i32 45, label %377
]
374: ; preds = %368
%375 = sext i32 %248 to i64
%376 = getelementptr inbounds i32, i32* %28, i64 %375
store i32 1235, i32* %376
br label %459
377: ; preds = %368
%378 = sext i32 %248 to i64
%379 = getelementptr inbounds i32, i32* %28, i64 %378
store i32 1236, i32* %379
br label %459
380: ; preds = %368
%381 = call i32 @ErrPrint(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.24, i64 0, i64 0))
br label %669
382: ; preds = %331
%383 = call i32 @ErrPrint(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.25, i64 0, i64 0))
br label %669
384: ; preds = %325
%385 = add nsw i32 %249, 2
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i8, i8* %245, i64 %386
%388 = load i8, i8* %387
%389 = sext i8 %388 to i32
switch i32 %389, label %399 [
i32 43, label %390
i32 45, label %393
i32 48, label %396
]
390: ; preds = %384
%391 = sext i32 %248 to i64
%392 = getelementptr inbounds i32, i32* %28, i64 %391
store i32 1001, i32* %392
br label %459
393: ; preds = %384
%394 = sext i32 %248 to i64
%395 = getelementptr inbounds i32, i32* %28, i64 %394
store i32 1002, i32* %395
br label %459
396: ; preds = %384
%397 = sext i32 %248 to i64
%398 = getelementptr inbounds i32, i32* %28, i64 %397
store i32 100, i32* %398
br label %459
399: ; preds = %384
%400 = call i32 @ErrPrint(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.26, i64 0, i64 0))
br label %669
401: ; preds = %325
%402 = add nsw i32 %249, 2
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i8, i8* %245, i64 %403
%405 = load i8, i8* %404
%406 = sext i8 %405 to i32
switch i32 %406, label %413 [
i32 43, label %407
i32 45, label %410
]
407: ; preds = %401
%408 = sext i32 %248 to i64
%409 = getelementptr inbounds i32, i32* %28, i64 %408
store i32 1233, i32* %409
br label %459
410: ; preds = %401
%411 = sext i32 %248 to i64
%412 = getelementptr inbounds i32, i32* %28, i64 %411
store i32 1234, i32* %412
br label %459
413: ; preds = %401
%414 = call i32 @ErrPrint(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.27, i64 0, i64 0))
br label %669
415: ; preds = %325
%416 = add nsw i32 %249, 2
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8, i8* %245, i64 %417
%419 = load i8, i8* %418
%420 = sext i8 %419 to i32
switch i32 %420, label %427 [
i32 43, label %421
i32 45, label %424
]
421: ; preds = %415
%422 = sext i32 %248 to i64
%423 = getelementptr inbounds i32, i32* %28, i64 %422
store i32 1251, i32* %423
br label %459
424: ; preds = %415
%425 = sext i32 %248 to i64
%426 = getelementptr inbounds i32, i32* %28, i64 %425
store i32 1252, i32* %426
br label %459
427: ; preds = %415
%428 = call i32 @ErrPrint(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.28, i64 0, i64 0))
br label %669
429: ; preds = %325
%430 = sext i32 %248 to i64
%431 = getelementptr inbounds i32, i32* %28, i64 %430
store i32 108, i32* %431
br label %459
432: ; preds = %325
%433 = sext i32 %248 to i64
%434 = getelementptr inbounds i32, i32* %28, i64 %433
store i32 102, i32* %434
br label %459
435: ; preds = %325
%436 = sext i32 %248 to i64
%437 = getelementptr inbounds i32, i32* %28, i64 %436
store i32 103, i32* %437
br label %459
438: ; preds = %325
%439 = sext i32 %248 to i64
%440 = getelementptr inbounds i32, i32* %28, i64 %439
store i32 104, i32* %440
br label %459
441: ; preds = %325
%442 = sext i32 %248 to i64
%443 = getelementptr inbounds i32, i32* %28, i64 %442
store i32 107, i32* %443
br label %459
444: ; preds = %325
%445 = sext i32 %248 to i64
%446 = getelementptr inbounds i32, i32* %28, i64 %445
store i32 109, i32* %446
br label %459
447: ; preds = %325
%448 = sext i32 %248 to i64
%449 = getelementptr inbounds i32, i32* %28, i64 %448
store i32 121, i32* %449
br label %459
450: ; preds = %325
%451 = sext i32 %248 to i64
%452 = getelementptr inbounds i32, i32* %28, i64 %451
store i32 120, i32* %452
br label %459
453: ; preds = %325
%454 = call i32 @ErrPrint(i8* getelementptr inbounds ([52 x i8], [52 x i8]* @.str.29, i64 0, i64 0))
br label %669
455: ; preds = %253
%456 = add nsw i32 %248, -1
br label %459
457: ; preds = %253
%458 = call i32 @ErrPrint(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.30, i64 0, i64 0))
br label %669
459: ; preds = %429, %432, %435, %438, %441, %444, %447, %450, %374, %377, %360, %363, %346, %349, %337, %396, %393, %390, %410, %407, %424, %421, %311, %314, %317, %320, %455, %300, %291, %288, %285, %282, %279, %276, %273, %270, %267, %264, %261, %258
%460 = phi i32 [ %249, %455 ], [ %326, %450 ], [ %326, %447 ], [ %326, %444 ], [ %326, %441 ], [ %326, %438 ], [ %326, %435 ], [ %326, %432 ], [ %326, %429 ], [ %416, %424 ], [ %416, %421 ], [ %402, %410 ], [ %402, %407 ], [ %385, %396 ], [ %385, %393 ], [ %385, %390 ], [ %369, %377 ], [ %369, %374 ], [ %355, %363 ], [ %355, %360 ], [ %341, %349 ], [ %341, %346 ], [ %332, %337 ], [ %306, %320 ], [ %306, %317 ], [ %306, %314 ], [ %306, %311 ], [ %295, %300 ], [ %249, %291 ], [ %249, %288 ], [ %249, %285 ], [ %249, %282 ], [ %249, %279 ], [ %249, %276 ], [ %249, %273 ], [ %249, %270 ], [ %249, %267 ], [ %249, %264 ], [ %249, %261 ], [ %249, %258 ]
%461 = phi i32 [ %456, %455 ], [ %248, %450 ], [ %248, %447 ], [ %248, %444 ], [ %248, %441 ], [ %248, %438 ], [ %248, %435 ], [ %248, %432 ], [ %248, %429 ], [ %248, %424 ], [ %248, %421 ], [ %248, %410 ], [ %248, %407 ], [ %248, %396 ], [ %248, %393 ], [ %248, %390 ], [ %248, %377 ], [ %248, %374 ], [ %248, %363 ], [ %248, %360 ], [ %248, %349 ], [ %248, %346 ], [ %248, %337 ], [ %248, %320 ], [ %248, %317 ], [ %248, %314 ], [ %248, %311 ], [ %248, %300 ], [ %248, %291 ], [ %248, %288 ], [ %248, %285 ], [ %248, %282 ], [ %248, %279 ], [ %248, %276 ], [ %248, %273 ], [ %248, %270 ], [ %248, %267 ], [ %248, %264 ], [ %248, %261 ], [ %248, %258 ]
%462 = phi i32 [ %247, %455 ], [ 1, %450 ], [ 1, %447 ], [ 1, %444 ], [ 1, %441 ], [ 1, %438 ], [ 1, %435 ], [ 1, %432 ], [ 1, %429 ], [ 1, %424 ], [ 1, %421 ], [ 1, %410 ], [ 1, %407 ], [ 1, %396 ], [ 1, %393 ], [ 1, %390 ], [ 1, %377 ], [ 1, %374 ], [ 1, %363 ], [ 1, %360 ], [ 1, %349 ], [ 1, %346 ], [ 1, %337 ], [ %247, %320 ], [ %247, %317 ], [ %247, %314 ], [ %247, %311 ], [ %247, %300 ], [ %247, %291 ], [ %247, %288 ], [ %247, %285 ], [ %247, %282 ], [ %247, %279 ], [ %247, %276 ], [ %247, %273 ], [ %247, %270 ], [ %247, %267 ], [ %247, %264 ], [ %247, %261 ], [ %247, %258 ]
%463 = add nsw i32 %461, 1
%464 = add nsw i32 %460, 1
%465 = icmp slt i32 %464, %242
br i1 %465, label %246, label %466
466: ; preds = %459, %238
%467 = phi i32 [ 0, %238 ], [ %463, %459 ]
%468 = phi i32 [ 0, %238 ], [ %462, %459 ]
%469 = sext i32 %467 to i64
%470 = getelementptr inbounds i32, i32* %28, i64 %469
store i32 -1, i32* %470
%471 = add nsw i32 %234, 1
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds i8*, i8** %1, i64 %472
%474 = load i8*, i8** %473
%475 = add nsw i32 %234, 2
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds i8*, i8** %1, i64 %476
%478 = load i8*, i8** %477
%479 = call i32 @ScanTarget(i8* %474, i8* %478, double* %7, double* %10, double* %11, i32* %15, i32* %32)
store i32 %479, i32* %19
%480 = icmp slt i32 %479, 1
br i1 %480, label %669, label %481
481: ; preds = %466
%482 = add nsw i32 %234, 3
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds i8*, i8** %1, i64 %483
%485 = load i8*, i8** %484
%486 = call i32 @ScanPro(i8* %485, double* %6, i32* %16)
%487 = icmp eq i32 %486, -1
br i1 %487, label %669, label %488
488: ; preds = %481
%489 = load i32, i32* %16
%490 = icmp eq i32 %489, 0
br i1 %490, label %491, label %493
491: ; preds = %488
%492 = call i32 @ErrPrint(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.31, i64 0, i64 0))
br label %669
493: ; preds = %488
%494 = add nsw i32 %234, 4
%495 = icmp eq i32 %468, 0
br i1 %495, label %607, label %496
496: ; preds = %493
%497 = add nsw i32 %233, 2
%498 = icmp sgt i32 %497, %0
br i1 %498, label %499, label %501
499: ; preds = %496
%500 = call i32 @ErrPrint(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.32, i64 0, i64 0))
br label %669
501: ; preds = %496
%502 = load i32, i32* %32
%503 = icmp eq i32 %502, 0
br i1 %503, label %506, label %504
504: ; preds = %501
%505 = call i32 @ErrPrint(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.33, i64 0, i64 0))
br label %506
506: ; preds = %504, %501
%507 = sext i32 %494 to i64
%508 = getelementptr inbounds i8*, i8** %1, i64 %507
%509 = load i8*, i8** %508
%510 = call i32 @ScanPro(i8* %509, double* %8, i32* %17)
%511 = icmp eq i32 %510, -1
br i1 %511, label %669, label %512
512: ; preds = %506
%513 = load i32, i32* %16
%514 = load double, double* %6
%515 = fadd double %514, 5.000000e-01
%516 = fptosi double %515 to i32
%517 = call double @IsoMass(i32 %513, i32 %516)
%518 = load double, double* %33
%519 = call double @llvm.fmuladd.f64(double %518, double 0x3F5196C404DAB8D1, double %517)
store double %519, double* %6
%520 = load i32, i32* %15
%521 = load double, double* %7
%522 = fadd double %521, 5.000000e-01
%523 = fptosi double %522 to i32
%524 = call double @IsoMass(i32 %520, i32 %523)
store double %524, double* %7
%525 = load i32, i32* %17
%526 = load double, double* %8
%527 = fadd double %526, 5.000000e-01
%528 = fptosi double %527 to i32
%529 = call double @IsoMass(i32 %525, i32 %528)
%530 = load double, double* %34
%531 = call double @llvm.fmuladd.f64(double %530, double 0x3F5196C404DAB8D1, double %529)
store double %531, double* %8
%532 = load i32, i32* %16
%533 = load i32, i32* %15
%534 = add nsw i32 %533, %532
%535 = load i32, i32* %17
%536 = sub i32 %534, %535
store i32 %536, i32* %18
%537 = icmp slt i32 %536, 0
br i1 %537, label %538, label %540
538: ; preds = %512
%539 = call i32 @ErrPrint(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.34, i64 0, i64 0))
br label %669
540: ; preds = %512
%541 = icmp ugt i32 %536, 92
br i1 %541, label %542, label %544
542: ; preds = %540
%543 = call i32 @ErrPrint(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.35, i64 0, i64 0))
br label %669
544: ; preds = %540
%545 = load double, double* %6
%546 = load double, double* %7
%547 = fadd double %545, %546
%548 = fsub double %547, %531
%549 = fadd double %548, 5.000000e-01
%550 = fptosi double %549 to i32
%551 = call double @IsoMass(i32 %536, i32 %550)
store double %551, double* %9
%552 = fcmp olt double %551, 0.000000e+00
br i1 %552, label %553, label %555
553: ; preds = %544
%554 = call i32 @ErrPrint(i8* getelementptr inbounds ([55 x i8], [55 x i8]* @.str.36, i64 0, i64 0))
br label %669
555: ; preds = %544
%556 = add nsw i32 %234, 5
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i8*, i8** %1, i64 %557
%559 = load i8*, i8** %558
%560 = load i8, i8* %559
switch i8 %560, label %583 [
i8 88, label %561
i8 120, label %561
i8 68, label %561
i8 100, label %561
]
561: ; preds = %555, %555, %555, %555
%562 = load i32, i32* %16
%563 = load i32, i32* %15
%564 = load i32, i32* %17
%565 = load double, double* %6
%566 = fadd double %565, 5.000000e-01
%567 = fptosi double %566 to i32
%568 = load double, double* %7
%569 = fadd double %568, 5.000000e-01
%570 = fptosi double %569 to i32
%571 = load double, double* %8
%572 = fadd double %571, 5.000000e-01
%573 = fptosi double %572 to i32
%574 = call double @IsoQ(i32 %562, i32 %563, i32 %564, i32 %567, i32 %570, i32 %573)
store double %574, double* %5
%575 = fcmp oeq double %574, 0xC16312CFE0000000
br i1 %575, label %576, label %578
576: ; preds = %561
%577 = call i32 @ErrPrint(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str.37, i64 0, i64 0))
br label %669
578: ; preds = %561
%579 = load double, double* %33
%580 = fadd double %574, %579
%581 = load double, double* %34
%582 = fsub double %580, %581
store double %582, double* %5
br label %605
583: ; preds = %555
%584 = call i32 (i8*, i8*, ...) @sscanf(i8* %559, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %5)
%585 = icmp eq i32 %584, 0
br i1 %585, label %586, label %588
586: ; preds = %583
%587 = call i32 @ErrPrint(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.38, i64 0, i64 0))
br label %669
588: ; preds = %583
%589 = load double, double* %8
%590 = load double, double* %9
%591 = fcmp ogt double %589, %590
%592 = load double, double* %7
%593 = load double, double* %6
%594 = fadd double %592, %593
br i1 %591, label %595, label %600
595: ; preds = %588
%596 = fsub double %594, %590
%597 = load double, double* %5
%598 = fneg double %597
%599 = call double @llvm.fmuladd.f64(double %598, double 0x3F5196C404DAB8D1, double %596)
store double %599, double* %8
br label %605
600: ; preds = %588
%601 = fsub double %594, %589
%602 = load double, double* %5
%603 = fneg double %602
%604 = call double @llvm.fmuladd.f64(double %603, double 0x3F5196C404DAB8D1, double %601)
store double %604, double* %9
br label %605
605: ; preds = %600, %595, %578
%606 = add nsw i32 %234, 6
br label %607
607: ; preds = %605, %493
%608 = phi i32 [ %606, %605 ], [ %494, %493 ]
%609 = sext i32 %608 to i64
%610 = getelementptr inbounds i8*, i8** %1, i64 %609
%611 = load i8*, i8** %610
%612 = call i32 (i8*, i8*, ...) @sscanf(i8* %611, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %2)
%613 = icmp eq i32 %612, 0
br i1 %613, label %614, label %616
614: ; preds = %607
%615 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.39, i64 0, i64 0))
br label %669
616: ; preds = %607
%617 = load double, double* %2
%618 = fcmp ugt double %617, 0.000000e+00
br i1 %618, label %620, label %619
619: ; preds = %616
store double 0x3E7AD7F29ABCAF48, double* %2
br label %620
620: ; preds = %619, %616
%621 = add nsw i32 %0, -1
%622 = icmp eq i32 %608, %621
br i1 %622, label %669, label %623
623: ; preds = %620
%624 = add nsw i32 %0, -3
%625 = icmp eq i32 %608, %624
br i1 %625, label %628, label %626
626: ; preds = %623
%627 = call i32 @ErrPrint(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.40, i64 0, i64 0))
br label %669
628: ; preds = %623
%629 = add nsw i32 %608, 1
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds i8*, i8** %1, i64 %630
%632 = load i8*, i8** %631
%633 = call i32 (i8*, i8*, ...) @sscanf(i8* %632, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), double* %3)
%634 = icmp eq i32 %633, 0
br i1 %634, label %635, label %637
635: ; preds = %628
%636 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.41, i64 0, i64 0))
br label %669
637: ; preds = %628
%638 = load double, double* %3
%639 = fcmp ugt double %638, 0.000000e+00
br i1 %639, label %640, label %645
640: ; preds = %637
%641 = load double, double* %2
%642 = fsub double %641, %638
%643 = fmul double %642, %642
%644 = fcmp olt double %643, 1.000000e-04
br i1 %644, label %645, label %647
645: ; preds = %640, %637
%646 = call i32 @ErrPrint(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.42, i64 0, i64 0))
br label %669
647: ; preds = %640
%648 = add nsw i32 %608, 2
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds i8*, i8** %1, i64 %649
%651 = load i8*, i8** %650
%652 = call i32 (i8*, i8*, ...) @sscanf(i8* %651, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %21)
%653 = icmp eq i32 %652, 0
br i1 %653, label %654, label %656
654: ; preds = %647
%655 = call i32 @ErrPrint(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.43, i64 0, i64 0))
br label %669
656: ; preds = %647
%657 = load i32, i32* %21
%658 = icmp slt i32 %657, 1
br i1 %658, label %659, label %661
659: ; preds = %656
%660 = call i32 @ErrPrint(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.44, i64 0, i64 0))
br label %669
661: ; preds = %656
%662 = load double, double* %3
%663 = load double, double* %2
%664 = fsub double %662, %663
%665 = add nsw i32 %657, -1
%666 = sitofp i32 %665 to float
%667 = fpext float %666 to double
%668 = fdiv double %664, %667
store double %668, double* %4
br label %669
669: ; preds = %620, %506, %481, %466, %661, %659, %654, %645, %635, %626, %614, %586, %576, %553, %542, %538, %499, %491, %457, %453, %427, %413, %399, %382, %380, %366, %352, %323, %303, %251, %236, %219, %217, %197, %188, %184, %175, %166, %162, %153, %144, %140, %133, %124, %120, %113, %104, %100, %93, %84, %80, %59, %51, %39
%670 = phi i32 [ -1, %39 ], [ 0, %51 ], [ -1, %59 ], [ -1, %219 ], [ -1, %184 ], [ -1, %188 ], [ -1, %217 ], [ -1, %197 ], [ -1, %162 ], [ -1, %166 ], [ -1, %175 ], [ -1, %140 ], [ -1, %144 ], [ -1, %153 ], [ -1, %120 ], [ -1, %124 ], [ -1, %133 ], [ -1, %100 ], [ -1, %104 ], [ -1, %113 ], [ -1, %80 ], [ -1, %84 ], [ -1, %93 ], [ -1, %236 ], [ -1, %251 ], [ -1, %457 ], [ -1, %453 ], [ -1, %427 ], [ -1, %413 ], [ -1, %399 ], [ -1, %382 ], [ -1, %380 ], [ -1, %366 ], [ -1, %352 ], [ -1, %323 ], [ -1, %303 ], [ -1, %491 ], [ -1, %499 ], [ -1, %538 ], [ -1, %542 ], [ -1, %553 ], [ -1, %576 ], [ -1, %626 ], [ -1, %645 ], [ -1, %659 ], [ 1, %661 ], [ -1, %654 ], [ -1, %635 ], [ -1, %614 ], [ -1, %586 ], [ -1, %466 ], [ -1, %481 ], [ -1, %506 ], [ 1, %620 ]
ret i32 %670
}