// File: /workspace/github_c_makefile_star2_O0/sheneman[P]clearcut/cmdargs.c
// Function: NJ_handle_args
NJ_ARGS *
NJ_handle_args(int argc,
	       char *argv[]) {
  
  static NJ_ARGS nj_args;
  int option_index, c;

  struct option NJ_long_options[] = {

    /* These options don't set a flag */
    {"in",        required_argument, NULL, 'i'},
    {"out",       required_argument, NULL, 'o'},
    {"seed",      required_argument, NULL, 's'},
    {"matrixout", required_argument, NULL, 'm'},
    {"ntrees",    required_argument, NULL, 'n'},

    /* These options set a flag */
    {"verbose",      no_argument, &(nj_args.verbose_flag),  1},
    {"quiet",        no_argument, &(nj_args.quiet_flag),    1},
    {"distance",     no_argument, &(nj_args.input_mode),    NJ_INPUT_MODE_DISTANCE}, 
    {"alignment",    no_argument, &(nj_args.input_mode),    NJ_INPUT_MODE_ALIGNED_SEQUENCES},
    {"help",         no_argument, &(nj_args.help),          1},
    {"version",      no_argument, &(nj_args.version),       1},
    {"norandom",     no_argument, &(nj_args.norandom),      1},
    {"shuffle",      no_argument, &(nj_args.shuffle),       1},
    {"stdin",        no_argument, &(nj_args.stdin_flag),    1},
    {"stdout",       no_argument, &(nj_args.stdout_flag),   1},
    {"dna",          no_argument, &(nj_args.dna_flag),      1},
    {"DNA",          no_argument, &(nj_args.dna_flag),      1},
    {"protein",      no_argument, &(nj_args.protein_flag),  1},
    {"neighbor",     no_argument, &(nj_args.neighbor),      1},
    {"expblen",      no_argument, &(nj_args.expblen),       1},
    {"expdist",      no_argument, &(nj_args.expdist),       1}, 

    {"jukes",        no_argument, &(nj_args.jukes_flag),    1},
    {"kimura",       no_argument, &(nj_args.kimura_flag),   1},
    
    {0, 0, 0, 0}

  };
  
  /* initializes options to their default */
  nj_args.infilename       = NULL;
  nj_args.outfilename      = NULL;
  nj_args.matrixout        = NULL;
  nj_args.seed             = time(0);
  nj_args.verbose_flag     = 0;
  nj_args.quiet_flag       = 0;
  nj_args.input_mode       = NJ_INPUT_MODE_DISTANCE;
  nj_args.help             = 0;
  nj_args.version          = 0;
  nj_args.norandom         = 0;
  nj_args.shuffle          = 0;
  nj_args.stdin_flag       = 0;
  nj_args.stdout_flag      = 0;
  nj_args.dna_flag         = 0;
  nj_args.protein_flag     = 0;
  nj_args.correction_model = NJ_MODEL_NONE;
  nj_args.jukes_flag       = 0;
  nj_args.kimura_flag      = 0;
  nj_args.neighbor         = 0;
  nj_args.ntrees           = 1;
  nj_args.expblen          = 0;
  nj_args.expdist          = 0;

  while(1) {
    c = getopt_long(argc,
		    argv,
		    "i:o:s:m:n:vqduahVSIOrDPjkNeE",
		    NJ_long_options,
		    &option_index);
    
    if(c == -1) {
      break;
    }

    switch(c) {

    case 0:
      if(NJ_long_options[option_index].flag) {
	break;
      }

      printf("option %s", NJ_long_options[option_index].name);
      if(optarg) {
	printf(" with arg %s", optarg);
      }
      printf("\n");
      break;

    case 'i':
      nj_args.infilename = optarg;
      break;

    case 'o':
      nj_args.outfilename = optarg;
      break;

    case 's':
      nj_args.seed = atoi(optarg);
      break;

    case 'm':
      nj_args.matrixout = optarg;
      break;

    case 'n':
      nj_args.ntrees = atoi(optarg);
      break;

    case 'v':
      nj_args.verbose_flag = 1;
      break; 

    case 'q':
      nj_args.quiet_flag = 1;
      break;

    case 'd':
      nj_args.input_mode = NJ_INPUT_MODE_DISTANCE;
      break;

    case 'a':
      nj_args.input_mode = NJ_INPUT_MODE_ALIGNED_SEQUENCES;
      break;

    case 'h':
      nj_args.help = 1;
      break;

    case 'V':
      nj_args.version = 1;
      break;

    case 'S':
      nj_args.shuffle = 1;
      break;
      
    case 'I':
      nj_args.stdin_flag = 1;
      break;

    case 'O':
      nj_args.stdin_flag = 1;
      break;

    case 'r':
      nj_args.norandom = 1;
      break;

    case 'D':
      nj_args.dna_flag = 1;
      break;

    case 'P':
      nj_args.protein_flag = 1;
      break;

    case 'j':
      nj_args.jukes_flag = 1;
      break;

    case 'k':
      nj_args.kimura_flag = 1;
      break;

    case 'N':
      nj_args.neighbor = 1;
      break;

    case 'e':
      nj_args.expblen = 1;
      break;

    case 'E':
      nj_args.expdist = 1;
      break;

   default:
     NJ_usage();
     exit(-1);
    }
  }
  
  if(optind < argc) {
    fprintf(stderr, "Clearcut: Unknown command-line argument:\n  --> %s\n", argv[optind]);
    NJ_usage();
    exit(-1);
  }
  
  if(nj_args.version) {
    printf("Clearcut Version: %s\n", NJ_VERSION);
    exit(0);
  }
  
  if(nj_args.help) {
    NJ_usage();
    exit(0);
  }
  
  /* if stdin & explicit filename are specified for input */
  if(nj_args.stdin_flag) {
    if(nj_args.infilename) {
      fprintf(stderr, "Clearcut:  Ambiguous input source specified.  Specify input filename OR stdin.\n");
      NJ_usage();
      exit(-1);
    }
  }

  /* if stdout & explicit filename are specified for output */
  if(nj_args.stdout_flag) {
    if(nj_args.outfilename) {
      fprintf(stderr, "Clearcut:  Ambiguous output specified.  Specify output filename OR stdout.\n");
      NJ_usage();
      exit(-1);
    }
  }

  /* if user did not specify stdin or filename, default to stdin */
  if(!nj_args.stdin_flag) {
    if(!nj_args.infilename) {

      fprintf(stderr, "Clearcut: No input file specified.  Using stdin.\n");
      nj_args.stdin_flag = 1;
    }
  }
  
  /* if user did not specify stdout or filename, default to stdout */
  if(!nj_args.stdout_flag) {
    if(!nj_args.outfilename) {
      
      fprintf(stderr, "Clearcut: No output file specified.  Using stdout.\n");
      nj_args.stdout_flag = 1;
    }
  }
  
  /* User must specify distance matrix or alignment */
  if(nj_args.input_mode == NJ_INPUT_MODE_UNKNOWN) {
    fprintf(stderr, "Clearcut: Must specify input type (--distance | --alignment)\n");
    NJ_usage();
    exit(-1);
  }

  /* do not allow protein or DNA options for distance matrix input */
  if(nj_args.input_mode == NJ_INPUT_MODE_DISTANCE) {
    if(nj_args.dna_flag || nj_args.protein_flag) {
      fprintf(stderr, "Clearcut:  Ambiguous arguments.  (--protein | --DNA) do not apply to distance \n");
      NJ_usage();
      exit(-1);
    }
  }
  
  /* make sure different filenames were specified for input and output */
  if(!nj_args.stdin_flag && !nj_args.stdout_flag) {

    if(!strcmp(nj_args.infilename, nj_args.outfilename)) {
      fprintf(stderr, "Clearcut: Input filename and output filename must be unique.\n");
      NJ_usage();
      exit(-1);
    }
  }

  /* make sure that user specifies DNA or Protein if dealing with alignment input */
  if(nj_args.input_mode == NJ_INPUT_MODE_ALIGNED_SEQUENCES) {
    if(!nj_args.dna_flag && !nj_args.protein_flag) {
      fprintf(stderr, "Clearcut: Must specify protein or DNA for alignment input.\n");
      NJ_usage();
      exit(-1);
    }
  }

  /* make sure that user does not specify both protein and DNA when dealing with alignment input */
  if(nj_args.input_mode == NJ_INPUT_MODE_ALIGNED_SEQUENCES) {
    if(nj_args.dna_flag && nj_args.protein_flag) {
      fprintf(stderr, "Clearcut: Specifying protein and DNA sequences are mutually exclusive options\n");
      NJ_usage();
      exit(-1);
    }
  }

  /* make sure verbose and quiet were not specified together */
  if(nj_args.verbose_flag && nj_args.quiet_flag) {
    fprintf(stderr, "Clearcut: Verbose and Quiet mode are mutually exclusive.\n");
    NJ_usage();
    exit(-1);
  }
  
  /* make sure that a correction model was specified only when providing an alignment */
  if(nj_args.input_mode == NJ_INPUT_MODE_DISTANCE) {
    if(nj_args.jukes_flag || nj_args.kimura_flag) {
      fprintf(stderr, "Clearcut:  Only specify correction model for alignment input.\n");
      NJ_usage();
      exit(-1);
    }
  } else {
    if(nj_args.jukes_flag && nj_args.kimura_flag) {
      fprintf(stderr, "Clearcut:  Only specify one correction model\n");
      NJ_usage();
      exit(-1);
    } else {
      if(nj_args.jukes_flag && !nj_args.kimura_flag) {
	nj_args.correction_model = NJ_MODEL_JUKES;
      } else if(nj_args.kimura_flag && !nj_args.jukes_flag) {
	nj_args.correction_model = NJ_MODEL_KIMURA;
      } else {
	nj_args.correction_model = NJ_MODEL_NONE;  /* DEFAULT */
      }
    }
  }
  
  /* make sure that the number of output trees is reasonable */
  if(nj_args.ntrees <= 0) {
    fprintf(stderr, "Clearcut: Number of output trees must be a positive integer.\n");
    NJ_usage();
    exit(-1);
  }
  
  /* 
   * make sure that if exponential distances are specified, 
   * we are dealing with alignment input
   */
  if(nj_args.expdist && nj_args.input_mode != NJ_INPUT_MODE_ALIGNED_SEQUENCES) {
    fprintf(stderr, "Clearcut: Exponential notation for distance matrix output requires that input be an alignment\n");
    NJ_usage();
    exit(-1);
  }
  
  return(&nj_args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x330, %rsp            # imm = 0x330
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x320(%rbp), %rdi
leaq 0x6840(%rip), %rsi      # 0xead0
movl $0x300, %edx            # imm = 0x300
callq 0x2180
movq $0x0, 0x7183(%rip) # 0xf428
movq $0x0, 0x7180(%rip) # 0xf430
movq $0x0, 0x717d(%rip) # 0xf438
xorl %eax, %eax
movl %eax, %edi
callq 0x2190
movl %eax, 0x71a6(%rip)      # 0xf470
movl $0x0, 0x7174(%rip)      # 0xf448
movl $0x0, 0x716e(%rip)      # 0xf44c
movl $0x64, 0x7158(%rip)     # 0xf440
movl $0x0, 0x7166(%rip)      # 0xf458
movl $0x0, 0x7160(%rip)      # 0xf45c
movl $0x0, 0x715a(%rip)      # 0xf460
movl $0x0, 0x7154(%rip)      # 0xf464
movl $0x0, 0x7136(%rip)      # 0xf450
movl $0x0, 0x7130(%rip)      # 0xf454
movl $0x0, 0x713a(%rip)      # 0xf468
movl $0x0, 0x7134(%rip)      # 0xf46c
movl $0x64, 0x7132(%rip)     # 0xf474
movl $0x0, 0x712c(%rip)      # 0xf478
movl $0x0, 0x7126(%rip)      # 0xf47c
movl $0x0, 0x7120(%rip)      # 0xf480
movl $0x1, 0x711a(%rip)      # 0xf484
movl $0x0, 0x7114(%rip)      # 0xf488
movl $0x0, 0x710e(%rip)      # 0xf48c
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x320(%rbp), %rcx
leaq 0x399d(%rip), %rdx      # 0xbd30
leaq -0x14(%rbp), %r8
callq 0x94b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x83aa
jmp 0x85b9
movl -0x18(%rbp), %eax
movq %rax, -0x328(%rbp)
subq $0x76, %rax
ja 0x85a5
movq -0x328(%rbp), %rax
leaq 0x36f0(%rip), %rcx      # 0xbabc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq -0x14(%rbp), %rcx
leaq -0x320(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x83f3
jmp 0x85b4
movslq -0x14(%rbp), %rcx
leaq -0x320(%rbp), %rax
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x393e(%rip), %rdi      # 0xbd4d
movb $0x0, %al
callq 0x20e0
leaq 0x8403(%rip), %rax      # 0x10820
cmpq $0x0, (%rax)
je 0x843b
leaq 0x83f6(%rip), %rax      # 0x10820
movq (%rax), %rsi
leaq 0x3923(%rip), %rdi      # 0xbd57
movb $0x0, %al
callq 0x20e0
leaq 0x2df4(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x20e0
jmp 0x85b4
leaq 0x83cb(%rip), %rax      # 0x10820
movq (%rax), %rax
movq %rax, 0x6fc9(%rip)      # 0xf428
jmp 0x85b4
leaq 0x83b5(%rip), %rax      # 0x10820
movq (%rax), %rax
movq %rax, 0x6fbb(%rip)      # 0xf430
jmp 0x85b4
leaq 0x839f(%rip), %rax      # 0x10820
movq (%rax), %rdi
callq 0x21e0
movl %eax, 0x6fe1(%rip)      # 0xf470
jmp 0x85b4
leaq 0x8385(%rip), %rax      # 0x10820
movq (%rax), %rax
movq %rax, 0x6f93(%rip)      # 0xf438
jmp 0x85b4
leaq 0x836f(%rip), %rax      # 0x10820
movq (%rax), %rdi
callq 0x21e0
movl %eax, 0x6fc5(%rip)      # 0xf484
jmp 0x85b4
movl $0x1, 0x6f7a(%rip)      # 0xf448
jmp 0x85b4
movl $0x1, 0x6f6f(%rip)      # 0xf44c
jmp 0x85b4
movl $0x64, 0x6f54(%rip)     # 0xf440
jmp 0x85b4
movl $0x66, 0x6f45(%rip)     # 0xf440
jmp 0x85b4
movl $0x1, 0x6f4e(%rip)      # 0xf458
jmp 0x85b4
movl $0x1, 0x6f43(%rip)      # 0xf45c
jmp 0x85b4
movl $0x1, 0x6f3c(%rip)      # 0xf464
jmp 0x85b4
movl $0x1, 0x6f19(%rip)      # 0xf450
jmp 0x85b4
movl $0x1, 0x6f0d(%rip)      # 0xf450
jmp 0x85b4
movl $0x1, 0x6f11(%rip)      # 0xf460
jmp 0x85b4
movl $0x1, 0x6f0d(%rip)      # 0xf468
jmp 0x85b4
movl $0x1, 0x6f05(%rip)      # 0xf46c
jmp 0x85b4
movl $0x1, 0x6f05(%rip)      # 0xf478
jmp 0x85b4
movl $0x1, 0x6efd(%rip)      # 0xf47c
jmp 0x85b4
movl $0x1, 0x6ef5(%rip)      # 0xf480
jmp 0x85b4
movl $0x1, 0x6ef1(%rip)      # 0xf488
jmp 0x85b4
movl $0x1, 0x6ee9(%rip)      # 0xf48c
jmp 0x85b4
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x837e
leaq 0x8258(%rip), %rax      # 0x10818
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jge 0x8600
movq 0x6a2a(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
leaq 0x823c(%rip), %rcx      # 0x10818
movslq (%rcx), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x377a(%rip), %rsi      # 0xbd64
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
cmpl $0x0, 0x6e55(%rip)      # 0xf45c
je 0x8625
leaq 0x3787(%rip), %rdi      # 0xbd97
leaq 0x3796(%rip), %rsi      # 0xbdad
movb $0x0, %al
callq 0x20e0
xorl %edi, %edi
callq 0x2200
cmpl $0x0, 0x6e2c(%rip)      # 0xf458
je 0x863a
callq 0x89f0
xorl %edi, %edi
callq 0x2200
cmpl $0x0, 0x6e0f(%rip)      # 0xf450
je 0x8676
cmpq $0x0, 0x6ddd(%rip)      # 0xf428
je 0x8674
movq 0x69a4(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3755(%rip), %rsi      # 0xbdb3
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x8676
cmpl $0x0, 0x6dd7(%rip)      # 0xf454
je 0x86b2
cmpq $0x0, 0x6da9(%rip)      # 0xf430
je 0x86b0
movq 0x6968(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3769(%rip), %rsi      # 0xbe03
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x86b2
cmpl $0x0, 0x6d97(%rip)      # 0xf450
jne 0x86e9
cmpq $0x0, 0x6d65(%rip)      # 0xf428
jne 0x86e7
movq 0x692c(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3779(%rip), %rsi      # 0xbe4f
movb $0x0, %al
callq 0x2150
movl $0x1, 0x6d69(%rip)      # 0xf450
jmp 0x86e9
cmpl $0x0, 0x6d64(%rip)      # 0xf454
jne 0x8720
cmpq $0x0, 0x6d36(%rip)      # 0xf430
jne 0x871e
movq 0x68f5(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3774(%rip), %rsi      # 0xbe81
movb $0x0, %al
callq 0x2150
movl $0x1, 0x6d36(%rip)      # 0xf454
jmp 0x8720
cmpl $0x0, 0x6d19(%rip)      # 0xf440
jne 0x8750
movq 0x68c8(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x377b(%rip), %rsi      # 0xbeb5
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
cmpl $0x64, 0x6ce9(%rip)     # 0xf440
jne 0x8794
cmpl $0x0, 0x6d08(%rip)      # 0xf468
jne 0x876b
cmpl $0x0, 0x6d03(%rip)      # 0xf46c
je 0x8792
movq 0x6886(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3777(%rip), %rsi      # 0xbef3
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x8794
cmpl $0x0, 0x6cb5(%rip)      # 0xf450
jne 0x87e7
cmpl $0x0, 0x6cb0(%rip)      # 0xf454
jne 0x87e7
movq 0x6c7b(%rip), %rdi      # 0xf428
movq 0x6c7c(%rip), %rsi      # 0xf430
callq 0x2140
cmpl $0x0, %eax
jne 0x87e5
movq 0x6833(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3774(%rip), %rsi      # 0xbf43
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x87e7
cmpl $0x66, 0x6c52(%rip)     # 0xf440
jne 0x882b
cmpl $0x0, 0x6c71(%rip)      # 0xf468
jne 0x8829
cmpl $0x0, 0x6c6c(%rip)      # 0xf46c
jne 0x8829
movq 0x67ef(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x376e(%rip), %rsi      # 0xbf81
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x882b
cmpl $0x66, 0x6c0e(%rip)     # 0xf440
jne 0x886f
cmpl $0x0, 0x6c2d(%rip)      # 0xf468
je 0x886d
cmpl $0x0, 0x6c28(%rip)      # 0xf46c
je 0x886d
movq 0x67ab(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3766(%rip), %rsi      # 0xbfbd
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x886f
cmpl $0x0, 0x6bd2(%rip)      # 0xf448
je 0x88a8
cmpl $0x0, 0x6bcd(%rip)      # 0xf44c
je 0x88a8
movq 0x6770(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x377a(%rip), %rsi      # 0xc00c
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
cmpl $0x64, 0x6b91(%rip)     # 0xf440
jne 0x88ef
cmpl $0x0, 0x6bc0(%rip)      # 0xf478
jne 0x88c3
cmpl $0x0, 0x6bbb(%rip)      # 0xf47c
je 0x88ea
movq 0x672e(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3772(%rip), %rsi      # 0xc046
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
jmp 0x8974
cmpl $0x0, 0x6b82(%rip)      # 0xf478
je 0x8928
cmpl $0x0, 0x6b7d(%rip)      # 0xf47c
je 0x8928
movq 0x66f0(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3773(%rip), %rsi      # 0xc085
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
cmpl $0x0, 0x6b49(%rip)      # 0xf478
je 0x8946
cmpl $0x0, 0x6b44(%rip)      # 0xf47c
jne 0x8946
movl $0x65, 0x6b30(%rip)     # 0xf474
jmp 0x8970
cmpl $0x0, 0x6b2f(%rip)      # 0xf47c
je 0x8964
cmpl $0x0, 0x6b22(%rip)      # 0xf478
jne 0x8964
movl $0x66, 0x6b12(%rip)     # 0xf474
jmp 0x896e
movl $0x64, 0x6b06(%rip)     # 0xf474
jmp 0x8970
jmp 0x8972
jmp 0x8974
cmpl $0x0, 0x6b09(%rip)      # 0xf484
jg 0x89a4
movq 0x6674(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x3725(%rip), %rsi      # 0xc0b3
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
cmpl $0x0, 0x6ae1(%rip)      # 0xf48c
je 0x89dd
cmpl $0x66, 0x6a8c(%rip)     # 0xf440
je 0x89dd
movq 0x663b(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x372a(%rip), %rsi      # 0xc0f1
movb $0x0, %al
callq 0x2150
callq 0x89f0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
leaq 0x6a44(%rip), %rax      # 0xf428
addq $0x330, %rsp            # imm = 0x330
popq %rbp
retq
nopl (%rax)