#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 */
struct option {
  char *member_0;
  char member_3;
  int /*<<< orphan*/ member_2;
  int /*<<< orphan*/ const member_1;
};
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ DisplayHelp(int);
double INT_MAX;
int /*<<< orphan*/ abort();
int atoi(char *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int getopt_long_only(int, char **, char *, struct option *, int *);
#define no_argument 129
char *optarg;
int optind;
int /*<<< orphan*/ printf(char *, ...);
#define required_argument 128
double str2double(char *);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
void ReadCommandLine(int nargs, char **args, char *cxFile, char *countFile,
                     char *logFile, char *distFile, char *LambdaFile,
                     int *SortOutput, int *WriteLambda, double *MaxSizeLambda,
                     double *kT, int *quiet, int *WriteLogFile, int *Toverride,
                     int *NoPermID, int *NUPACK_VALIDATE) {
  int options;
  int ShowHelp;
  char prefix[10000];
  char InputStr[10000];
  FILE *fp;
  if (nargs == 1) {
    printf("For instructions on running this program, run it with the ");
    printf("-help flag.\n\nExiting....\n\n");
    exit(2);
  }
  *NoPermID = 1;
  *SortOutput = 1;
  *WriteLogFile = 0;
  *WriteLambda = 0;
  *MaxSizeLambda = 1e6;
  *kT = 0.00198717 * (37.0 + 273.15);
  *quiet = 0;
  *Toverride = 0;
  *NUPACK_VALIDATE = 0;
  ShowHelp = 0;
  while (1) {
    static struct option long_options[] = {
        {"sort", required_argument, 0, 'a'},
        {"T", required_argument, 0, 'b'},
        {"maxstates", required_argument, 0, 'c'},
        {"quiet", no_argument, 0, 'd'},
        {"help", no_argument, 0, 'e'},
        {"writestates", no_argument, 0, 'f'},
        {"writelogfile", no_argument, 0, 'g'},
        {"ordered", no_argument, 0, 'h'},
        {"validate", no_argument, 0, 'i'},
        {0, 0, 0, 0}};
    int option_index = 0;
    options = getopt_long_only(nargs, args, "a:b:c:defghi", long_options,
                               &option_index);
    if (options == -1)
      break;
    switch (options) {
    case 'a':
      strcpy(InputStr, optarg);
      *SortOutput = atoi(InputStr);
      break;
    case 'b':
      strcpy(InputStr, optarg);
      *kT = 0.00198717 * (str2double(InputStr) + 273.15);
      *Toverride = 1;
      break;
    case 'c':
      strcpy(InputStr, optarg);
      (*MaxSizeLambda) = str2double(InputStr);
      break;
    case 'd':
      *quiet = 1;
      break;
    case 'e':
      ShowHelp = 1;
      break;
    case 'f':
      *WriteLambda = 1;
      break;
    case 'g':
      *WriteLogFile = 1;
      break;
    case 'h':
      *NoPermID = 0;
      break;
    case 'i':
      *NUPACK_VALIDATE = 1;
      *SortOutput = 3;
      break;
    case '?':
      break;
    default:
      abort();
    }
  }
  if (ShowHelp) {
    DisplayHelp(1);
    exit(3);
  }
  if ((*MaxSizeLambda) > INT_MAX) {
    if (*quiet == 0) {
      printf("The maximum size of Lambda must be less than %d\n", INT_MAX);
      printf("This is the maximal allowed size of an integer.\n");
      printf("Using MaxSizeLambda = %d.\n", INT_MAX - 1);
    }
    (*MaxSizeLambda) = INT_MAX - 1;
  }
  if (*SortOutput > 4 || *SortOutput < 1) {
    if (*quiet == 0) {
      printf("Sorting option is an integer from 1 to 4.  Output will be sorted "
             "by\n");
      printf("average count of complexes.\n\n");
    }
    *SortOutput = 1;
  }
  if (optind == nargs) {
    if (*quiet == 0) {
      printf("You must have a prefix or an input file on the command line.\n");
      printf("For instructions on running this program, run it with the ");
      printf("-help flag.\n\nExiting....\n\n");
    }
    exit(2);
  } else {
    strcpy(prefix, args[optind]);
  }
  if (*NoPermID == 1 && *SortOutput == 2) {
    *SortOutput = 1;
  }
  strcpy(cxFile, prefix);
  strcpy(countFile, prefix);
  strcpy(logFile, prefix);
  strcpy(distFile, prefix);
  strcpy(LambdaFile, prefix);
  if (*NoPermID) {
    strcat(cxFile, ".cx");
  } else {
    strcat(cxFile, ".ocx");
  }
  strcat(countFile, ".count");
  strcat(logFile, ".log");
  strcat(distFile, ".dist");
  strcat(LambdaFile, ".states");
  if ((fp = fopen(cxFile, "r")) == NULL) {
    if (*quiet == 0) {
      printf("Error opening %s!\n\nExiting....\n", cxFile);
    }
    exit(6);
  }
  fclose(fp);
}


x86 assembly (clang, -O0):
<ReadCommandLine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e80,%rsp
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,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    122a <ReadCommandLine+0x7a>
lea    0xec9(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xef6(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x2,%edi
call   10d0 <exit@plt>
mov    0x50(%rbp),%rax
movl   $0x1,(%rax)
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    0x40(%rbp),%rax
movl   $0x0,(%rax)
mov    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    0x28(%rbp),%rax
movsd  0xdaa(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x30(%rbp),%rax
movsd  0xd92(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
mov    0x48(%rbp),%rax
movl   $0x0,(%rax)
mov    0x58(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x4e6c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xec1(%rip),%rdx
lea    0x2dca(%rip),%rcx
lea    -0x4e6c(%rbp),%r8
call   1080 <getopt_long_only@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0xffffffff,-0x34(%rbp)
jne    12d4 <ReadCommandLine+0x124>
jmp    1427 <ReadCommandLine+0x277>
mov    -0x34(%rbp),%eax
add    $0xffffffc1,%eax
mov    %eax,%ecx
mov    %rcx,-0x4e78(%rbp)
sub    $0x2a,%eax
ja     141b <ReadCommandLine+0x26b>
mov    -0x4e78(%rbp),%rax
lea    0xd2e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    -0x4e60(%rbp),%rdi
mov    0x2ce7(%rip),%rax
mov    (%rax),%rsi
call   1040 <strcpy@plt>
lea    -0x4e60(%rbp),%rdi
call   10b0 <atoi@plt>
mov    %eax,%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    1422 <ReadCommandLine+0x272>
lea    -0x4e60(%rbp),%rdi
mov    0x2cb8(%rip),%rax
mov    (%rax),%rsi
call   1040 <strcpy@plt>
lea    -0x4e60(%rbp),%rdi
call   1050 <str2double@plt>
movaps %xmm0,%xmm1
movsd  0xcb9(%rip),%xmm0
addsd  %xmm0,%xmm1
movsd  0xca5(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x48(%rbp),%rax
movl   $0x1,(%rax)
jmp    1422 <ReadCommandLine+0x272>
lea    -0x4e60(%rbp),%rdi
mov    0x2c64(%rip),%rax
mov    (%rax),%rsi
call   1040 <strcpy@plt>
lea    -0x4e60(%rbp),%rdi
call   1050 <str2double@plt>
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1422 <ReadCommandLine+0x272>
mov    0x38(%rbp),%rax
movl   $0x1,(%rax)
jmp    1422 <ReadCommandLine+0x272>
movl   $0x1,-0x38(%rbp)
jmp    1422 <ReadCommandLine+0x272>
mov    0x20(%rbp),%rax
movl   $0x1,(%rax)
jmp    1422 <ReadCommandLine+0x272>
mov    0x40(%rbp),%rax
movl   $0x1,(%rax)
jmp    1422 <ReadCommandLine+0x272>
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
jmp    1422 <ReadCommandLine+0x272>
mov    0x58(%rbp),%rax
movl   $0x1,(%rax)
mov    0x18(%rbp),%rax
movl   $0x3,(%rax)
jmp    1422 <ReadCommandLine+0x272>
jmp    1422 <ReadCommandLine+0x272>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1297 <ReadCommandLine+0xe7>
cmpl   $0x0,-0x38(%rbp)
je     1445 <ReadCommandLine+0x295>
mov    $0x1,%edi
call   1090 <DisplayHelp@plt>
mov    $0x3,%edi
call   10d0 <exit@plt>
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x2b8c(%rip),%rax
ucomisd (%rax),%xmm0
jbe    14d6 <ReadCommandLine+0x326>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    14b7 <ReadCommandLine+0x307>
mov    0x2b6e(%rip),%rax
movsd  (%rax),%xmm0
lea    0xd00(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
lea    0xd23(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    0x2b47(%rip),%rax
movsd  (%rax),%xmm0
movsd  0xb7b(%rip),%xmm1
subsd  %xmm1,%xmm0
lea    0xd2f(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    0x2b22(%rip),%rax
movsd  (%rax),%xmm0
movsd  0xb56(%rip),%xmm1
subsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
cmpl   $0x4,(%rax)
jg     14f0 <ReadCommandLine+0x340>
mov    0x18(%rbp),%rax
cmpl   $0x1,(%rax)
jge    1523 <ReadCommandLine+0x373>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1519 <ReadCommandLine+0x369>
lea    0xcf6(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xd2d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    0x2aae(%rip),%rax
mov    (%rax),%eax
cmp    -0x4(%rbp),%eax
jne    1576 <ReadCommandLine+0x3c6>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    156c <ReadCommandLine+0x3bc>
lea    0xd14(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xb7d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
lea    0xbaa(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x2,%edi
call   10d0 <exit@plt>
lea    -0x2750(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x2a50(%rip),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rsi
call   1040 <strcpy@plt>
mov    0x50(%rbp),%rax
cmpl   $0x1,(%rax)
jne    15b8 <ReadCommandLine+0x408>
mov    0x18(%rbp),%rax
cmpl   $0x2,(%rax)
jne    15b8 <ReadCommandLine+0x408>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x18(%rbp),%rdi
lea    -0x2750(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x20(%rbp),%rdi
lea    -0x2750(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x28(%rbp),%rdi
lea    -0x2750(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x30(%rbp),%rdi
lea    -0x2750(%rbp),%rsi
call   1040 <strcpy@plt>
mov    0x10(%rbp),%rdi
lea    -0x2750(%rbp),%rsi
call   1040 <strcpy@plt>
mov    0x50(%rbp),%rax
cmpl   $0x0,(%rax)
je     162a <ReadCommandLine+0x47a>
mov    -0x18(%rbp),%rdi
lea    0xc7b(%rip),%rsi
call   10c0 <strcat@plt>
jmp    163a <ReadCommandLine+0x48a>
mov    -0x18(%rbp),%rdi
lea    0xc6a(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x20(%rbp),%rdi
lea    0xc5f(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x28(%rbp),%rdi
lea    0xc56(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x30(%rbp),%rdi
lea    0xc4b(%rip),%rsi
call   10c0 <strcat@plt>
mov    0x10(%rbp),%rdi
lea    0xc41(%rip),%rsi
call   10c0 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc39(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x4e68(%rbp)
cmp    $0x0,%rax
jne    16c4 <ReadCommandLine+0x514>
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jne    16ba <ReadCommandLine+0x50a>
mov    -0x18(%rbp),%rsi
lea    0xc0d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    $0x6,%edi
call   10d0 <exit@plt>
mov    -0x4e68(%rbp),%rdi
call   1060 <fclose@plt>
add    $0x4e80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ReadCommandLine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x4e58,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x20(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,0x10(%rsp)
cmp    $0x1,%edi
je     1620 <ReadCommandLine+0x460>
mov    %rsi,%r15
mov    %edi,%r12d
mov    0x4ed8(%rsp),%r8
mov    0x4ed0(%rsp),%rax
mov    0x4ec8(%rsp),%r9
mov    0x4ec0(%rsp),%rdi
mov    0x4eb8(%rsp),%r10
mov    0x4eb0(%rsp),%rbx
mov    0x4ea8(%rsp),%rsi
mov    0x4ea0(%rsp),%rcx
mov    0x4e98(%rsp),%rdx
movl   $0x1,(%rax)
movl   $0x1,(%rdx)
movl   $0x0,(%rdi)
movl   $0x0,(%rcx)
movabs $0x412e848000000000,%rax
84 2e 41
mov    %rax,(%rsi)
movabs $0x3fe3b8e658d3c57e,%rax
b8 e3 3f
mov    %rax,(%rbx)
movl   $0x0,(%r10)
movl   $0x0,(%r9)
movl   $0x0,(%r8)
movl   $0x0,0xc(%rsp)
lea    0xfb3(%rip),%rbx
lea    0x2df7(%rip),%r14
lea    0x30(%rsp),%rbp
lea    0xd73(%rip),%r13
jmp    12d0 <ReadCommandLine+0x110>
mov    0x4ed8(%rsp),%rax
movl   $0x1,(%rax)
mov    0x4e98(%rsp),%rax
movl   $0x3,(%rax)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movl   $0x0,0x30(%rsp)
mov    %r12d,%edi
mov    %r15,%rsi
mov    %rbx,%rdx
mov    %r14,%rcx
mov    %rbp,%r8
call   1090 <getopt_long_only@plt>
add    $0x1,%eax
cmp    $0x6a,%eax
ja     1619 <ReadCommandLine+0x459>
movslq 0x0(%r13,%rax,4),%rax
add    %r13,%rax
jmp    *%rax
mov    0x2cef(%rip),%rax
mov    (%rax),%rsi
mov    %r14,%rbp
lea    0x2740(%rsp),%r14
mov    %r14,%rdi
call   1040 <strcpy@plt>
mov    %r14,%rdi
mov    %rbp,%r14
lea    0x30(%rsp),%rbp
call   10c0 <atoi@plt>
mov    0x4e98(%rsp),%rcx
mov    %eax,(%rcx)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x4ec0(%rsp),%rax
movl   $0x1,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x2ca6(%rip),%rax
mov    (%rax),%rsi
lea    0x2740(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strcpy@plt>
mov    %rbp,%rdi
lea    0x30(%rsp),%rbp
call   1060 <str2double@plt>
addsd  0xc86(%rip),%xmm0
mulsd  0xc86(%rip),%xmm0
mov    0x4eb0(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x4ec8(%rsp),%rax
movl   $0x1,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x2c50(%rip),%rax
mov    (%rax),%rsi
lea    0x2740(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <strcpy@plt>
mov    %rbp,%rdi
lea    0x30(%rsp),%rbp
call   1060 <str2double@plt>
mov    0x4ea8(%rsp),%rax
movsd  %xmm0,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x4eb8(%rsp),%rax
movl   $0x1,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x4ea0(%rsp),%rax
movl   $0x1,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
mov    0x4ed0(%rsp),%rax
movl   $0x0,(%rax)
jmp    12d0 <ReadCommandLine+0x110>
movl   $0x1,0xc(%rsp)
jmp    12d0 <ReadCommandLine+0x110>
cmpl   $0x0,0xc(%rsp)
jne    1644 <ReadCommandLine+0x484>
mov    0x4ea8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ba3(%rip),%rbx
movsd  (%rbx),%xmm0
ucomisd %xmm0,%xmm1
jbe    14a0 <ReadCommandLine+0x2e0>
mov    0x4eb8(%rsp),%rax
cmpl   $0x0,(%rax)
jne    148c <ReadCommandLine+0x2cc>
lea    0xdf7(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0xf18(%rip),%rdi
call   1050 <puts@plt>
movsd  (%rbx),%xmm0
addsd  0xb96(%rip),%xmm0
lea    0xe02(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  (%rbx),%xmm0
addsd  0xb7c(%rip),%xmm0
mov    0x4ea8(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x4e98(%rsp),%rax
mov    (%rax),%eax
add    $0xfffffffb,%eax
cmp    $0xfffffffb,%eax
ja     14e5 <ReadCommandLine+0x325>
mov    0x4eb8(%rsp),%rax
cmpl   $0x0,(%rax)
jne    14d7 <ReadCommandLine+0x317>
lea    0xe5a(%rip),%rdi
call   1050 <puts@plt>
lea    0xe92(%rip),%rdi
call   1050 <puts@plt>
mov    0x4e98(%rsp),%rax
movl   $0x1,(%rax)
mov    0x2aec(%rip),%rax
movslq (%rax),%rax
cmp    %r12d,%eax
je     1658 <ReadCommandLine+0x498>
mov    (%r15,%rax,8),%rsi
lea    0x30(%rsp),%rdi
call   1040 <strcpy@plt>
mov    0x4ed0(%rsp),%rax
cmpl   $0x1,(%rax)
mov    0x10(%rsp),%r14
jne    1533 <ReadCommandLine+0x373>
mov    0x4e98(%rsp),%rax
cmpl   $0x2,(%rax)
jne    1533 <ReadCommandLine+0x373>
mov    0x4e98(%rsp),%rax
movl   $0x1,(%rax)
lea    0x30(%rsp),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    0x18(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    0x20(%rsp),%r13
mov    %r13,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    0x28(%rsp),%r15
mov    %r15,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    0x4e90(%rsp),%r12
mov    %r12,%rdi
mov    %rbx,%rsi
call   1040 <strcpy@plt>
mov    0x4ed0(%rsp),%rax
cmpl   $0x0,(%rax)
lea    0xd0a(%rip),%rax
lea    0xcff(%rip),%rsi
cmove  %rax,%rsi
mov    %r14,%rdi
call   10d0 <strcat@plt>
lea    0xcf5(%rip),%rsi
mov    %rbp,%rdi
call   10d0 <strcat@plt>
lea    0xced(%rip),%rsi
mov    %r13,%rdi
call   10d0 <strcat@plt>
lea    0xce3(%rip),%rsi
mov    %r15,%rdi
call   10d0 <strcat@plt>
lea    0xcda(%rip),%rsi
mov    %r12,%rdi
call   10d0 <strcat@plt>
lea    0xcd3(%rip),%rsi
mov    %r14,%rdi
call   10b0 <fopen@plt>
test   %rax,%rax
je     1695 <ReadCommandLine+0x4d5>
mov    %rax,%rdi
call   1070 <fclose@plt>
add    $0x4e58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1030 <abort@plt>
lea    0xb9d(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xd7c(%rip),%rdi
call   1050 <puts@plt>
mov    $0x2,%edi
call   10e0 <exit@plt>
mov    $0x1,%edi
call   10a0 <DisplayHelp@plt>
mov    $0x3,%edi
call   10e0 <exit@plt>
mov    0x4eb8(%rsp),%rax
cmpl   $0x0,(%rax)
jne    168b <ReadCommandLine+0x4cb>
lea    0xc77(%rip),%rdi
call   1050 <puts@plt>
lea    0xb4c(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0xd2b(%rip),%rdi
call   1050 <puts@plt>
mov    $0x2,%edi
call   10e0 <exit@plt>
mov    0x4eb8(%rsp),%rax
cmpl   $0x0,(%rax)
jne    16b5 <ReadCommandLine+0x4f5>
lea    0xc1a(%rip),%rdi
mov    0x10(%rsp),%rsi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0x6,%edi
call   10e0 <exit@plt>

LLVM IR (-O0):
%struct.option = type { i8*, i8, i32, i32 }
@.str = [59 x i8] c"For instructions on running this program, run it with the \00"
@.str.1 = [27 x i8] c"-help flag.\0A\0AExiting....\0A\0A\00"
@ReadCommandLine.long_options = internal global [10 x %struct.option] [%struct.option { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i8 -128, i32 0, i32 97 }, %struct.option { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i32 0, i32 0), i8 -128, i32 0, i32 98 }, %struct.option { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i8 -128, i32 0, i32 99 }, %struct.option { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i32 0, i32 0), i8 -127, i32 0, i32 100 }, %struct.option { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i8 -127, i32 0, i32 101 }, %struct.option { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i32 0, i32 0), i8 -127, i32 0, i32 102 }, %struct.option { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i8 -127, i32 0, i32 103 }, %struct.option { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i32 0, i32 0), i8 -127, i32 0, i32 104 }, %struct.option { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0), i8 -127, i32 0, i32 105 }, %struct.option zeroinitializer]
@.str.2 = [5 x i8] c"sort\00"
@.str.3 = [2 x i8] c"T\00"
@.str.4 = [10 x i8] c"maxstates\00"
@.str.5 = [6 x i8] c"quiet\00"
@.str.6 = [5 x i8] c"help\00"
@.str.7 = [12 x i8] c"writestates\00"
@.str.8 = [13 x i8] c"writelogfile\00"
@.str.9 = [8 x i8] c"ordered\00"
@.str.10 = [9 x i8] c"validate\00"
@.str.11 = [13 x i8] c"a:b:c:defghi\00"
@optarg = global i8* null
@INT_MAX = global double 0.000000e+00
@.str.12 = [49 x i8] c"The maximum size of Lambda must be less than %d\0A\00"
@.str.13 = [49 x i8] c"This is the maximal allowed size of an integer.\0A\00"
@.str.14 = [27 x i8] c"Using MaxSizeLambda = %d.\0A\00"
@.str.15 = [69 x i8] c"Sorting option is an integer from 1 to 4. Output will be sorted by\0A\00"
@.str.16 = [30 x i8] c"average count of complexes.\0A\0A\00"
@optind = global i32 0
@.str.17 = [62 x i8] c"You must have a prefix or an input file on the command line.\0A\00"
@.str.18 = [4 x i8] c".cx\00"
@.str.19 = [5 x i8] c".ocx\00"
@.str.20 = [7 x i8] c".count\00"
@.str.21 = [5 x i8] c".log\00"
@.str.22 = [6 x i8] c".dist\00"
@.str.23 = [8 x i8] c".states\00"
@.str.24 = [2 x i8] c"r\00"
@.str.25 = [32 x i8] c"Error opening %s!\0A\0AExiting....\0A\00"
define void @ReadCommandLine(i32 %0, i8** %1, i8* %2, i8* %3, i8* %4, i8* %5, i8* %6, i32* %7, i32* %8, double* %9, double* %10, i32* %11, i32* %12, i32* %13, i32* %14, i32* %15) {
%17 = alloca i32
%18 = alloca i8**
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i8*
%22 = alloca i8*
%23 = alloca i8*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca double*
%27 = alloca double*
%28 = alloca i32*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca i32*
%33 = alloca i32
%34 = alloca i32
%35 = alloca [10000 x i8]
%36 = alloca [10000 x i8]
%37 = alloca i32*
%38 = alloca i32
store i32 %0, i32* %17
store i8** %1, i8*** %18
store i8* %2, i8** %19
store i8* %3, i8** %20
store i8* %4, i8** %21
store i8* %5, i8** %22
store i8* %6, i8** %23
store i32* %7, i32** %24
store i32* %8, i32** %25
store double* %9, double** %26
store double* %10, double** %27
store i32* %11, i32** %28
store i32* %12, i32** %29
store i32* %13, i32** %30
store i32* %14, i32** %31
store i32* %15, i32** %32
%39 = load i32, i32* %17
%40 = icmp eq i32 %39, 1
br i1 %40, label %41, label %45
41: ; preds = %16
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0))
%44 = call i32 @exit(i32 2)
unreachable
45: ; preds = %16
%46 = load i32*, i32** %31
store i32 1, i32* %46
%47 = load i32*, i32** %24
store i32 1, i32* %47
%48 = load i32*, i32** %29
store i32 0, i32* %48
%49 = load i32*, i32** %25
store i32 0, i32* %49
%50 = load double*, double** %26
store double 1.000000e+06, double* %50
%51 = load double*, double** %27
store double 0x3FE3B8E658D3C57E, double* %51
%52 = load i32*, i32** %28
store i32 0, i32* %52
%53 = load i32*, i32** %30
store i32 0, i32* %53
%54 = load i32*, i32** %32
store i32 0, i32* %54
store i32 0, i32* %34
br label %55
55: ; preds = %45, %103
store i32 0, i32* %38
%56 = load i32, i32* %17
%57 = load i8**, i8*** %18
%58 = call i32 @getopt_long_only(i32 %56, i8** %57, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i64 0, i64 0), %struct.option* getelementptr inbounds ([10 x %struct.option], [10 x %struct.option]* @ReadCommandLine.long_options, i64 0, i64 0), i32* %38)
store i32 %58, i32* %33
%59 = load i32, i32* %33
%60 = icmp eq i32 %59, -1
br i1 %60, label %61, label %62
61: ; preds = %55
br label %104
62: ; preds = %55
%63 = load i32, i32* %33
switch i32 %63, label %101 [
i32 97, label %64
i32 98, label %71
i32 99, label %81
i32 100, label %88
i32 101, label %90
i32 102, label %91
i32 103, label %93
i32 104, label %95
i32 105, label %97
i32 63, label %100
]
64: ; preds = %62
%65 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%66 = load i8*, i8** @optarg
%67 = call i32 @strcpy(i8* %65, i8* %66)
%68 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%69 = call i32 @atoi(i8* %68)
%70 = load i32*, i32** %24
store i32 %69, i32* %70
br label %103
71: ; preds = %62
%72 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%73 = load i8*, i8** @optarg
%74 = call i32 @strcpy(i8* %72, i8* %73)
%75 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%76 = call double @str2double(i8* %75)
%77 = fadd double %76, 2.731500e+02
%78 = fmul double 1.987170e-03, %77
%79 = load double*, double** %27
store double %78, double* %79
%80 = load i32*, i32** %30
store i32 1, i32* %80
br label %103
81: ; preds = %62
%82 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%83 = load i8*, i8** @optarg
%84 = call i32 @strcpy(i8* %82, i8* %83)
%85 = getelementptr inbounds [10000 x i8], [10000 x i8]* %36, i64 0, i64 0
%86 = call double @str2double(i8* %85)
%87 = load double*, double** %26
store double %86, double* %87
br label %103
88: ; preds = %62
%89 = load i32*, i32** %28
store i32 1, i32* %89
br label %103
90: ; preds = %62
store i32 1, i32* %34
br label %103
91: ; preds = %62
%92 = load i32*, i32** %25
store i32 1, i32* %92
br label %103
93: ; preds = %62
%94 = load i32*, i32** %29
store i32 1, i32* %94
br label %103
95: ; preds = %62
%96 = load i32*, i32** %31
store i32 0, i32* %96
br label %103
97: ; preds = %62
%98 = load i32*, i32** %32
store i32 1, i32* %98
%99 = load i32*, i32** %24
store i32 3, i32* %99
br label %103
100: ; preds = %62
br label %103
101: ; preds = %62
%102 = call i32 (...) @abort()
unreachable
103: ; preds = %100, %97, %95, %93, %91, %90, %88, %81, %71, %64
br label %55
104: ; preds = %61
%105 = load i32, i32* %34
%106 = icmp ne i32 %105, 0
br i1 %106, label %107, label %110
107: ; preds = %104
%108 = call i32 @DisplayHelp(i32 1)
%109 = call i32 @exit(i32 3)
unreachable
110: ; preds = %104
%111 = load double*, double** %26
%112 = load double, double* %111
%113 = load double, double* @INT_MAX
%114 = fcmp ogt double %112, %113
br i1 %114, label %115, label %130
115: ; preds = %110
%116 = load i32*, i32** %28
%117 = load i32, i32* %116
%118 = icmp eq i32 %117, 0
br i1 %118, label %119, label %126
119: ; preds = %115
%120 = load double, double* @INT_MAX
%121 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.12, i64 0, i64 0), double %120)
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.13, i64 0, i64 0))
%123 = load double, double* @INT_MAX
%124 = fsub double %123, 1.000000e+00
%125 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.14, i64 0, i64 0), double %124)
br label %126
126: ; preds = %119, %115
%127 = load double, double* @INT_MAX
%128 = fsub double %127, 1.000000e+00
%129 = load double*, double** %26
store double %128, double* %129
br label %130
130: ; preds = %126, %110
%131 = load i32*, i32** %24
%132 = load i32, i32* %131
%133 = icmp sgt i32 %132, 4
br i1 %133, label %138, label %134
134: ; preds = %130
%135 = load i32*, i32** %24
%136 = load i32, i32* %135
%137 = icmp slt i32 %136, 1
br i1 %137, label %138, label %147
138: ; preds = %134, %130
%139 = load i32*, i32** %28
%140 = load i32, i32* %139
%141 = icmp eq i32 %140, 0
br i1 %141, label %142, label %145
142: ; preds = %138
%143 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.15, i64 0, i64 0))
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.16, i64 0, i64 0))
br label %145
145: ; preds = %142, %138
%146 = load i32*, i32** %24
store i32 1, i32* %146
br label %147
147: ; preds = %145, %134
%148 = load i32, i32* @optind
%149 = load i32, i32* %17
%150 = icmp eq i32 %148, %149
br i1 %150, label %151, label %161
151: ; preds = %147
%152 = load i32*, i32** %28
%153 = load i32, i32* %152
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %159
155: ; preds = %151
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.17, i64 0, i64 0))
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%158 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0))
br label %159
159: ; preds = %155, %151
%160 = call i32 @exit(i32 2)
unreachable
161: ; preds = %147
%162 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%163 = load i8**, i8*** %18
%164 = load i32, i32* @optind
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i8*, i8** %163, i64 %165
%167 = load i8*, i8** %166
%168 = call i32 @strcpy(i8* %162, i8* %167)
br label %169
169: ; preds = %161
%170 = load i32*, i32** %31
%171 = load i32, i32* %170
%172 = icmp eq i32 %171, 1
br i1 %172, label %173, label %179
173: ; preds = %169
%174 = load i32*, i32** %24
%175 = load i32, i32* %174
%176 = icmp eq i32 %175, 2
br i1 %176, label %177, label %179
177: ; preds = %173
%178 = load i32*, i32** %24
store i32 1, i32* %178
br label %179
179: ; preds = %177, %173, %169
%180 = load i8*, i8** %19
%181 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%182 = call i32 @strcpy(i8* %180, i8* %181)
%183 = load i8*, i8** %20
%184 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%185 = call i32 @strcpy(i8* %183, i8* %184)
%186 = load i8*, i8** %21
%187 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%188 = call i32 @strcpy(i8* %186, i8* %187)
%189 = load i8*, i8** %22
%190 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%191 = call i32 @strcpy(i8* %189, i8* %190)
%192 = load i8*, i8** %23
%193 = getelementptr inbounds [10000 x i8], [10000 x i8]* %35, i64 0, i64 0
%194 = call i32 @strcpy(i8* %192, i8* %193)
%195 = load i32*, i32** %31
%196 = load i32, i32* %195
%197 = icmp ne i32 %196, 0
br i1 %197, label %198, label %201
198: ; preds = %179
%199 = load i8*, i8** %19
%200 = call i32 @strcat(i8* %199, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0))
br label %204
201: ; preds = %179
%202 = load i8*, i8** %19
%203 = call i32 @strcat(i8* %202, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
br label %204
204: ; preds = %201, %198
%205 = load i8*, i8** %20
%206 = call i32 @strcat(i8* %205, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.20, i64 0, i64 0))
%207 = load i8*, i8** %21
%208 = call i32 @strcat(i8* %207, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0))
%209 = load i8*, i8** %22
%210 = call i32 @strcat(i8* %209, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
%211 = load i8*, i8** %23
%212 = call i32 @strcat(i8* %211, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i64 0, i64 0))
%213 = load i8*, i8** %19
%214 = call i32* @fopen(i8* %213, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0))
store i32* %214, i32** %37
%215 = icmp eq i32* %214, null
br i1 %215, label %216, label %225
216: ; preds = %204
%217 = load i32*, i32** %28
%218 = load i32, i32* %217
%219 = icmp eq i32 %218, 0
br i1 %219, label %220, label %223
220: ; preds = %216
%221 = load i8*, i8** %19
%222 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.25, i64 0, i64 0), i8* %221)
br label %223
223: ; preds = %220, %216
%224 = call i32 @exit(i32 6)
unreachable
225: ; preds = %204
%226 = load i32*, i32** %37
%227 = call i32 @fclose(i32* %226)
ret void
}

LLVM IR (-O2):
%struct.option = type { i8*, i8, i32, i32 }
@.str = [59 x i8] c"For instructions on running this program, run it with the \00"
@ReadCommandLine.long_options = internal global [10 x %struct.option] [%struct.option { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i32 0, i32 0), i8 -128, i32 0, i32 97 }, %struct.option { i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i32 0, i32 0), i8 -128, i32 0, i32 98 }, %struct.option { i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.4, i32 0, i32 0), i8 -128, i32 0, i32 99 }, %struct.option { i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i32 0, i32 0), i8 -127, i32 0, i32 100 }, %struct.option { i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i8 -127, i32 0, i32 101 }, %struct.option { i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.7, i32 0, i32 0), i8 -127, i32 0, i32 102 }, %struct.option { i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i8 -127, i32 0, i32 103 }, %struct.option { i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.9, i32 0, i32 0), i8 -127, i32 0, i32 104 }, %struct.option { i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i32 0, i32 0), i8 -127, i32 0, i32 105 }, %struct.option zeroinitializer]
@.str.2 = [5 x i8] c"sort\00"
@.str.3 = [2 x i8] c"T\00"
@.str.4 = [10 x i8] c"maxstates\00"
@.str.5 = [6 x i8] c"quiet\00"
@.str.6 = [5 x i8] c"help\00"
@.str.7 = [12 x i8] c"writestates\00"
@.str.8 = [13 x i8] c"writelogfile\00"
@.str.9 = [8 x i8] c"ordered\00"
@.str.10 = [9 x i8] c"validate\00"
@.str.11 = [13 x i8] c"a:b:c:defghi\00"
@optarg = global i8* null
@INT_MAX = global double 0.000000e+00
@.str.12 = [49 x i8] c"The maximum size of Lambda must be less than %d\0A\00"
@.str.14 = [27 x i8] c"Using MaxSizeLambda = %d.\0A\00"
@optind = global i32 0
@.str.18 = [4 x i8] c".cx\00"
@.str.19 = [5 x i8] c".ocx\00"
@.str.20 = [7 x i8] c".count\00"
@.str.21 = [5 x i8] c".log\00"
@.str.22 = [6 x i8] c".dist\00"
@.str.23 = [8 x i8] c".states\00"
@.str.24 = [2 x i8] c"r\00"
@.str.25 = [32 x i8] c"Error opening %s!\0A\0AExiting....\0A\00"
@str = [61 x i8] c"You must have a prefix or an input file on the command line.\00"
@str.27 = [68 x i8] c"Sorting option is an integer from 1 to 4. Output will be sorted by\00"
@str.28 = [29 x i8] c"average count of complexes.\0A\00"
@str.29 = [48 x i8] c"This is the maximal allowed size of an integer.\00"
@str.30 = [26 x i8] c"-help flag.\0A\0AExiting....\0A\00"
define void @ReadCommandLine(i32 %0, i8** %1, i8* %2, i8* %3, i8* %4, i8* %5, i8* %6, i32* nocapture %7, i32* nocapture writeonly %8, double* nocapture %9, double* nocapture writeonly %10, i32* nocapture %11, i32* nocapture writeonly %12, i32* nocapture writeonly %13, i32* nocapture %14, i32* nocapture writeonly %15) {
%17 = alloca [10000 x i8]
%18 = alloca [10000 x i8]
%19 = alloca i32
%20 = getelementptr inbounds [10000 x i8], [10000 x i8]* %17, i64 0, i64 0
%21 = getelementptr inbounds [10000 x i8], [10000 x i8]* %18, i64 0, i64 0
%22 = icmp eq i32 %0, 1
br i1 %22, label %23, label %27
23: ; preds = %16
%24 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.30, i64 0, i64 0))
%26 = tail call i32 @exit(i32 2)
unreachable
27: ; preds = %16
store i32 1, i32* %14
store i32 1, i32* %7
store i32 0, i32* %12
store i32 0, i32* %8
store double 1.000000e+06, double* %9
store double 0x3FE3B8E658D3C57E, double* %10
store i32 0, i32* %11
store i32 0, i32* %13
store i32 0, i32* %15
%28 = bitcast i32* %19 to i8*
br label %29
29: ; preds = %54, %27
%30 = phi i32 [ 0, %27 ], [ %55, %54 ]
store i32 0, i32* %19
%31 = call i32 @getopt_long_only(i32 %0, i8** %1, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i64 0, i64 0), %struct.option* getelementptr inbounds ([10 x %struct.option], [10 x %struct.option]* @ReadCommandLine.long_options, i64 0, i64 0), i32* %19)
switch i32 %31, label %52 [
i32 -1, label %56
i32 97, label %32
i32 98, label %36
i32 99, label %42
i32 100, label %46
i32 101, label %47
i32 102, label %48
i32 103, label %49
i32 104, label %50
i32 105, label %51
i32 63, label %54
]
32: ; preds = %29
%33 = load i8*, i8** @optarg
%34 = call i32 @strcpy(i8* %21, i8* %33)
%35 = call i32 @atoi(i8* %21)
store i32 %35, i32* %7
br label %54
36: ; preds = %29
%37 = load i8*, i8** @optarg
%38 = call i32 @strcpy(i8* %21, i8* %37)
%39 = call double @str2double(i8* %21)
%40 = fadd double %39, 2.731500e+02
%41 = fmul double %40, 1.987170e-03
store double %41, double* %10
store i32 1, i32* %13
br label %54
42: ; preds = %29
%43 = load i8*, i8** @optarg
%44 = call i32 @strcpy(i8* %21, i8* %43)
%45 = call double @str2double(i8* %21)
store double %45, double* %9
br label %54
46: ; preds = %29
store i32 1, i32* %11
br label %54
47: ; preds = %29
br label %54
48: ; preds = %29
store i32 1, i32* %8
br label %54
49: ; preds = %29
store i32 1, i32* %12
br label %54
50: ; preds = %29
store i32 0, i32* %14
br label %54
51: ; preds = %29
store i32 1, i32* %15
store i32 3, i32* %7
br label %54
52: ; preds = %29
%53 = call i32 (...) @abort()
unreachable
54: ; preds = %32, %36, %42, %46, %47, %48, %49, %50, %51, %29
%55 = phi i32 [ %30, %51 ], [ %30, %50 ], [ %30, %49 ], [ %30, %48 ], [ 1, %47 ], [ %30, %46 ], [ %30, %42 ], [ %30, %36 ], [ %30, %32 ], [ %30, %29 ]
br label %29
56: ; preds = %29
%57 = icmp eq i32 %30, 0
br i1 %57, label %61, label %58
58: ; preds = %56
%59 = call i32 @DisplayHelp(i32 1)
%60 = call i32 @exit(i32 3)
unreachable
61: ; preds = %56
%62 = load double, double* %9
%63 = load double, double* @INT_MAX
%64 = fcmp ogt double %62, %63
br i1 %64, label %65, label %78
65: ; preds = %61
%66 = load i32, i32* %11
%67 = icmp eq i32 %66, 0
br i1 %67, label %68, label %75
68: ; preds = %65
%69 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.12, i64 0, i64 0), double %63)
%70 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @str.29, i64 0, i64 0))
%71 = load double, double* @INT_MAX
%72 = fadd double %71, -1.000000e+00
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.14, i64 0, i64 0), double %72)
%74 = load double, double* @INT_MAX
br label %75
75: ; preds = %68, %65
%76 = phi double [ %74, %68 ], [ %63, %65 ]
%77 = fadd double %76, -1.000000e+00
store double %77, double* %9
br label %78
78: ; preds = %75, %61
%79 = load i32, i32* %7
%80 = add i32 %79, -5
%81 = icmp ult i32 %80, -4
br i1 %81, label %82, label %89
82: ; preds = %78
%83 = load i32, i32* %11
%84 = icmp eq i32 %83, 0
br i1 %84, label %85, label %88
85: ; preds = %82
%86 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @str.27, i64 0, i64 0))
%87 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.28, i64 0, i64 0))
br label %88
88: ; preds = %85, %82
store i32 1, i32* %7
br label %89
89: ; preds = %78, %88
%90 = load i32, i32* @optind
%91 = icmp eq i32 %90, %0
br i1 %91, label %92, label %101
92: ; preds = %89
%93 = load i32, i32* %11
%94 = icmp eq i32 %93, 0
br i1 %94, label %95, label %99
95: ; preds = %92
%96 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @str, i64 0, i64 0))
%97 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str, i64 0, i64 0))
%98 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.30, i64 0, i64 0))
br label %99
99: ; preds = %95, %92
%100 = call i32 @exit(i32 2)
unreachable
101: ; preds = %89
%102 = sext i32 %90 to i64
%103 = getelementptr inbounds i8*, i8** %1, i64 %102
%104 = load i8*, i8** %103
%105 = call i32 @strcpy(i8* %20, i8* %104)
%106 = load i32, i32* %14
%107 = icmp eq i32 %106, 1
br i1 %107, label %108, label %112
108: ; preds = %101
%109 = load i32, i32* %7
%110 = icmp eq i32 %109, 2
br i1 %110, label %111, label %112
111: ; preds = %108
store i32 1, i32* %7
br label %112
112: ; preds = %111, %108, %101
%113 = call i32 @strcpy(i8* %2, i8* %20)
%114 = call i32 @strcpy(i8* %3, i8* %20)
%115 = call i32 @strcpy(i8* %4, i8* %20)
%116 = call i32 @strcpy(i8* %5, i8* %20)
%117 = call i32 @strcpy(i8* %6, i8* %20)
%118 = load i32, i32* %14
%119 = icmp eq i32 %118, 0
%120 = select i1 %119, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0)
%121 = call i32 @strcat(i8* %2, i8* %120)
%122 = call i32 @strcat(i8* %3, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.20, i64 0, i64 0))
%123 = call i32 @strcat(i8* %4, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0))
%124 = call i32 @strcat(i8* %5, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
%125 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.23, i64 0, i64 0))
%126 = call i32* @fopen(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.24, i64 0, i64 0))
%127 = icmp eq i32* %126, null
br i1 %127, label %128, label %135
128: ; preds = %112
%129 = load i32, i32* %11
%130 = icmp eq i32 %129, 0
br i1 %130, label %131, label %133
131: ; preds = %128
%132 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.25, i64 0, i64 0), i8* %2)
br label %133
133: ; preds = %131, %128
%134 = call i32 @exit(i32 6)
unreachable
135: ; preds = %112
%136 = call i32 @fclose(i32* %126)
ret void
}