// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_simreads.c
// Function: gt_simreads_runner
static int gt_simreads_runner(GT_UNUSED int argc,
                              const char **argv, int parsed_args,
                              void *tool_arguments, GtError *err)
{
  GtSimreadsArguments *arguments = tool_arguments;
  GtEncseq *target = NULL;
  GtEncseqLoader *target_loader = NULL;
  GtEncseqReader *target_reader = NULL;
  GtReadmode readmode;
  GtStr *read = NULL, *description = NULL;
  GtUword output_bases = 0, output_reads = 0,
                output_rcmode_reads = 0,
                required_output_bases = 0,
                target_total_length,
                startpos, readlen, i;
  GtUint64 progress = 0;
  bool fixed_readlen;
  int had_err = 0;
  GtUchar ch;
  GtLogger *logger = NULL;
  GtDiscDistri *lengths = NULL, *starts = NULL;
  GtSimreadsDistvalue *input_distlen = NULL;
  off_t j, nofvalues = 0;

  gt_error_check(err);
  gt_assert(arguments);

  logger = gt_logger_new(arguments->verbose, GT_LOGGER_DEFLT_PREFIX, stderr);
  fixed_readlen = (arguments->maxlen == GT_UNDEF_UWORD &&
      arguments->minlen != GT_UNDEF_UWORD);
  if (arguments->ds)
    starts = gt_disc_distri_new();
  if (arguments->dl)
    lengths = gt_disc_distri_new();
  readlen = arguments->minlen;

  /* load encseq */
  target_loader = gt_encseq_loader_new();
  target = gt_encseq_loader_load(target_loader, argv[parsed_args], err);
  if (target == NULL)
    had_err = -1;
  if (!had_err) {
    target_reader = gt_encseq_create_reader_with_readmode(target,
                                                          GT_READMODE_FORWARD,
                                                          0);
  }

  if (!had_err)
  {
    target_total_length = gt_encseq_total_length(target);
    gt_logger_log(logger, "number of templates: "GT_WU"",
                  gt_encseq_num_of_sequences(target));
    gt_logger_log(logger, "total template length: "GT_WU"",
                  target_total_length);
    if (arguments->coverage != GT_UNDEF_UWORD)
    {
      gt_logger_log(logger, "required coverage: "GT_WU"",
                            arguments->coverage);
      required_output_bases = arguments->coverage * target_total_length;
      if (arguments->show_progressbar)
        gt_progressbar_start(&progress,
            (GtUint64)required_output_bases);
    }
    else
    {
      gt_assert(arguments->num != GT_UNDEF_UWORD);
      gt_logger_log(logger, "required number of reads: "GT_WU"",
                            arguments->num);
      if (arguments->show_progressbar)
        gt_progressbar_start(&progress, (GtUint64)arguments->num);
    }
    read = gt_str_new();
    description = gt_str_new();
    if (arguments->distlen_file != NULL)
    {
      gt_logger_log(logger, "read length distribution file: %s",
          gt_str_get(arguments->distlen_filename));
      nofvalues = gt_file_size(gt_str_get(arguments->distlen_filename)) /
                       (off_t) (sizeof (GtUword) << 1);
      input_distlen = gt_malloc(sizeof (GtSimreadsDistvalue) * nofvalues);
      for (j = 0; j < nofvalues; j++)
      {
        (void)gt_xfread(&(input_distlen[j].length), sizeof (GtUword),
            (size_t)1, arguments->distlen_file);
        (void)gt_xfread(&(input_distlen[j].value), sizeof (GtUword),
            (size_t)1, arguments->distlen_file);
      }
      for (j = (off_t)1; j < nofvalues; j++)
      {
        input_distlen[j].value += input_distlen[j - 1].value;
      }
    }
    else if (fixed_readlen)
      gt_logger_log(logger, "required read length (fixed): "GT_WU"",
                    arguments->minlen);
    else
      gt_logger_log(logger, "required read length range: "GT_WU"-"GT_WU"",
                    arguments->minlen, arguments->maxlen);
  }

  while (!had_err)
  {
    gt_str_reset(read);
    if (!fixed_readlen)
    {
      if (arguments->distlen_file != NULL)
      {
        gt_assert(input_distlen != NULL);
        readlen = gt_simreads_readlen_from_dist(input_distlen,
            gt_rand_max(input_distlen[nofvalues - 1].value),
            (GtUword)nofvalues);
        gt_assert(readlen <= input_distlen[nofvalues - 1].value);
      }
      else
      {
        readlen = gt_rand_max(arguments->maxlen -
            arguments->minlen) + arguments->minlen;
      }
      if (arguments->dl)
        gt_disc_distri_add(lengths, readlen);
    }
    gt_assert(target_total_length > readlen);
    startpos = gt_rand_max(target_total_length - readlen);
    readmode = (arguments->singlestrand || gt_rand_max(1UL)
      ? GT_READMODE_FORWARD : GT_READMODE_REVCOMPL);
    gt_encseq_reader_reinit_with_readmode(target_reader, target,
                                          readmode, startpos);
    for (i = 0; i < readlen; i++)
    {
      ch = gt_encseq_reader_next_encoded_char(target_reader);
      if (ch == (GtUchar) GT_SEPARATOR)
      {
        break;
      }
      else
      {
        gt_str_append_char(read, gt_alphabet_decode(
                             gt_encseq_alphabet(target), ch));
      }
    }
    if (i < readlen)
    {
      /* a separator was found, discard read and restart */
      continue;
    }
    else
    {
      gt_str_reset(description);
      gt_str_append_cstr(description, "read_");
      gt_str_append_uword(description, output_reads);
      gt_fasta_show_entry(gt_str_get(description),
                          gt_str_get(read),
                          gt_str_length(read),
                          60UL,
                          arguments->outfp);
      output_bases += gt_str_length(read);
      output_reads++;
      if (arguments->verbose && readmode == GT_READMODE_FORWARD)
        output_rcmode_reads++;
      if (arguments->ds)
      {
        if (readmode == GT_READMODE_FORWARD)
          gt_disc_distri_add(starts, startpos);
        else
          gt_disc_distri_add(starts, target_total_length - 1 - startpos);
      }
    }

    /* test break conditions and update progressbar */
    if (arguments->coverage != GT_UNDEF_UWORD)
    {
      if (arguments->show_progressbar)
        progress = (GtUint64)output_bases;
      if (output_bases >= required_output_bases)
        break;
    }
    else
    {
      gt_assert(arguments->num != GT_UNDEF_UWORD);
      if (arguments->show_progressbar)
        progress = (GtUint64)output_reads;
      if (output_reads == arguments->num)
        break;
    }
  }

  if (!had_err)
  {
    gt_logger_log(logger, "coverage: %.3f",
                  (float) output_bases / target_total_length);
    gt_logger_log(logger, "total reads length: "GT_WU"", output_bases);
    if (!fixed_readlen)
      gt_logger_log(logger, "average reads length: %.1f",
                    (float) output_bases / output_reads);
    gt_logger_log(logger, "number of reads: "GT_WU"", output_reads);
    gt_logger_log(logger, "- forward: "GT_WU"",
                  output_reads-output_rcmode_reads);
    gt_logger_log(logger, "- revcompl: "GT_WU"", output_rcmode_reads);
  }

  if (!had_err && arguments->dl)
    had_err = gt_simreads_write_dist_file(
                   "# distribution of read lengths:\n", lengths,
                   arguments->dlfilename, err);
  if (!had_err && arguments->ds)
    had_err = gt_simreads_write_dist_file(
                   "# distribution of start positions:\n", starts,
                   arguments->dsfilename, err);

  if (arguments->show_progressbar)
    gt_progressbar_stop();
  gt_free(input_distlen);
  gt_str_delete(read);
  gt_str_delete(description);
  gt_encseq_reader_delete(target_reader);
  gt_encseq_loader_delete(target_loader);
  gt_encseq_delete(target);
  gt_logger_delete(logger);
  if (arguments->dl)
    gt_disc_distri_delete(lengths);
  if (arguments->ds)
    gt_disc_distri_delete(starts);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %rbx
andq $0x0, 0x80(%rsp)
testq %r8, %r8
je 0x4e240
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x4ebfa
testq %r12, %r12
je 0x4ebcc
movzbl 0x21(%r12), %edi
movq 0x3e9d12(%rip), %rax    # 0x437f68
movq (%rax), %rdx
leaq 0x298674(%rip), %rsi    # 0x2e68d4
callq 0x92b50
movq %rax, %r14
cmpq $-0x1, 0x10(%r12)
je 0x4e27a
movl $0x0, 0x4(%rsp)
jmp 0x4e287
cmpq $-0x1, 0x8(%r12)
setne %al
movl %eax, 0x4(%rsp)
cmpb $0x1, 0x22(%r12)
jne 0x4e29b
callq 0x6d958
movq %rax, 0x48(%rsp)
jmp 0x4e2a4
movq $0x0, 0x48(%rsp)
cmpb $0x1, 0x23(%r12)
jne 0x4e2b8
callq 0x6d958
movq %rax, 0x40(%rsp)
jmp 0x4e2c1
movq $0x0, 0x40(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x10(%rsp)
callq 0x791cd
movq %rax, %rdi
movslq %ebp, %rax
movq (%rbx,%rax,8), %rsi
movq %rdi, 0x98(%rsp)
movq %r15, %rdx
callq 0x7921d
movq %rax, %rbp
pushq $-0x1
popq %rax
movl %eax, 0x1c(%rsp)
testq %rbp, %rbp
movq %r14, 0x20(%rsp)
je 0x4e38a
movq %r15, 0x88(%rsp)
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x72260
movq %rax, 0x60(%rsp)
movq %rbp, %rdi
callq 0x7055e
movq %rax, %rbx
movq %rbp, %rdi
callq 0x705a1
leaq 0x2ac8f3(%rip), %rsi    # 0x2fac28
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x92e71
leaq 0x2ac8f8(%rip), %rsi    # 0x2fac41
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x92e71
movq 0x18(%r12), %rdx
cmpq $-0x1, %rdx
je 0x4e3ac
leaq 0x2ac8f4(%rip), %rsi    # 0x2fac5c
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
movq 0x18(%r12), %r14
imulq %rbx, %r14
cmpb $0x0, 0x20(%r12)
movq %r14, 0x28(%rsp)
jne 0x4e3e8
jmp 0x4e3ff
leaq 0x20(%r12), %rbx
xorl %r15d, %r15d
movq $0x0, 0x70(%rsp)
xorl %r14d, %r14d
movq $0x0, 0x60(%rsp)
jmp 0x4ea12
movq (%r12), %rdx
cmpq $-0x1, %rdx
je 0x4ec28
leaq 0x2ac8d3(%rip), %rsi    # 0x2fac94
movq $0x0, 0x28(%rsp)
movq %r14, %rdi
xorl %eax, %eax
callq 0x92e71
cmpb $0x1, 0x20(%r12)
jne 0x4e3ff
movq (%r12), %rax
movq %rax, 0x28(%rsp)
xorl %r14d, %r14d
leaq 0x80(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9c79c
movq %r14, 0x28(%rsp)
callq 0xacb84
movq %rax, %r14
callq 0xacb84
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x50(%r12)
movq %r12, 0x38(%rsp)
movq %rbp, 0x68(%rsp)
je 0x4e548
movq %rbx, 0x58(%rsp)
movq 0x48(%r12), %rdi
callq 0xad1fa
leaq 0x2ac875(%rip), %rsi    # 0x2facb2
xorl %ebx, %ebx
movq 0x20(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x92e71
movq 0x48(%r12), %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8e0a6
pushq $0x10
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
movq %rax, %rdi
shlq $0x4, %rdi
leaq 0x2ac4e5(%rip), %rsi    # 0x2fa95e
movl $0x16c, %edx            # imm = 0x16C
callq 0x93160
movq %r15, %r8
testq %r15, %r15
cmovgq %r15, %rbx
movq %rax, %r12
pushq $0x1
popq %r15
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rbp
subq $0x1, %rbx
jb 0x4e4d6
leaq 0x8(%r12), %rdi
movq 0x50(%rbp), %rcx
pushq $0x8
popq %rsi
movq %r15, %rdx
movq %r8, %r13
callq 0xb2fab
movq 0x50(%rbp), %rcx
movq %r12, %rdi
pushq $0x8
popq %rsi
movq %r15, %rdx
callq 0xb2fab
movq %r13, %r8
addq $0x10, %r12
jmp 0x4e49e
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq 0x38(%rsp), %r12
movq 0x68(%rsp), %rbp
cmpq %r8, %r15
jge 0x4e4fe
movq -0x10(%rax), %rcx
addq %rcx, (%rax)
incq %r15
addq $0x10, %rax
jmp 0x4e4e9
movq 0x8(%rsp), %r15
testq %r15, %r15
sete 0x3(%rsp)
leaq 0x20(%r12), %rbx
testq %rbp, %rbp
je 0x4ea12
movq %rbx, 0x30(%rsp)
decq %r8
movq %r8, %rax
shlq $0x4, %rax
movq %r15, %rcx
addq %rax, %rcx
movq %rcx, 0x78(%rsp)
movq %r8, %rax
shrq %rax
movq %rax, 0x90(%rsp)
movq 0x58(%rsp), %rbx
jmp 0x4e5b1
movq 0x8(%r12), %rdx
cmpb $0x0, 0x4(%rsp)
je 0x4e569
leaq 0x2ac779(%rip), %rsi    # 0x2facd4
movq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x92e71
jmp 0x4e581
movq 0x10(%r12), %rcx
leaq 0x2ac781(%rip), %rsi    # 0x2facf6
movq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x92e71
leaq 0x20(%r12), %rax
movq %rax, 0x30(%rsp)
pushq $-0x1
popq %r8
movb $0x1, 0x3(%rsp)
pushq $-0x10
popq %rax
movq %rax, 0x78(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, 0x90(%rsp)
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r8, 0xa0(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, 0x50(%rsp)
movq %r14, %rdi
callq 0xad357
cmpb $0x0, 0x4(%rsp)
jne 0x4e6b7
cmpq $0x0, 0x50(%r12)
je 0x4e687
cmpb $0x0, 0x3(%rsp)
jne 0x4eb38
movq 0x78(%rsp), %rax
movq (%rax), %rdi
callq 0x955fa
xorl %edx, %edx
movq 0xa0(%rsp), %r9
movq %r9, %rsi
movq 0x90(%rsp), %rcx
movq %rcx, %rdi
shlq $0x4, %rdi
cmpq %rax, (%r15,%rdi)
je 0x4e66c
jbe 0x4e64f
cmpq %rsi, %rdx
ja 0x4ead6
testq %rcx, %rcx
je 0x4e66c
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %rcx, %rsi
cmpq %rax, (%r15,%r8)
jae 0x4e661
jmp 0x4e66c
cmpq %r9, %rcx
jae 0x4eaa5
incq %rcx
movq %rcx, %rdx
movq %rsi, %rcx
subq %rdx, %rcx
shrq %rcx
addq %rdx, %rcx
jmp 0x4e61d
addq %r15, %rdi
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x4e6a0
jmp 0x4eb66
movq 0x10(%r12), %rdi
subq 0x8(%r12), %rdi
callq 0x955fa
addq 0x8(%r12), %rax
movq %rax, 0x10(%rsp)
cmpb $0x1, 0x23(%r12)
jne 0x4e6b7
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x6d96d
movq %r15, %r13
movq %rbx, %r15
subq 0x10(%rsp), %rbx
jbe 0x4eb07
movq %rbx, %rdi
callq 0x955fa
movq %rax, %rbx
cmpb $0x0, 0x24(%r12)
je 0x4e6e4
xorl %edx, %edx
movb $0x1, 0x58(%rsp)
jmp 0x4e6fc
pushq $0x1
popq %rdi
callq 0x955fa
xorl %ecx, %ecx
testq %rax, %rax
setne 0x58(%rsp)
sete %cl
leal (%rcx,%rcx,2), %edx
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, 0xb0(%rsp)
movq %rbx, %rcx
callq 0x71f38
movq 0x10(%rsp), %rbx
subq $0x1, %rbx
jb 0x4e761
movq 0x60(%rsp), %rdi
callq 0x70f55
cmpb $-0x1, %al
je 0x4e751
movl %eax, %r12d
movq %rbp, %rdi
callq 0x754dd
movzbl %r12b, %esi
movq %rax, %rdi
callq 0x575cc
movsbl %al, %esi
movq %r14, %rdi
callq 0xaced9
jmp 0x4e719
movq 0x38(%rsp), %r12
movq %r15, %rbx
movq %r13, %r15
jmp 0x4e5d1
movq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xad357
movq %rbx, %rdi
leaq 0x2ac604(%rip), %rsi    # 0x2fad7c
callq 0xacbfb
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0xace26
movq %rbx, %rdi
callq 0xad1fa
movq %rax, %r12
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rbx
movq %r14, %rdi
callq 0xad289
movq 0x38(%rsp), %rbp
movq 0x30(%rbp), %r8
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
pushq $0x3c
popq %rcx
callq 0x8c0bc
movq %r14, %rdi
callq 0xad289
movq %rax, %r12
movb 0x21(%rbp), %bl
movb 0x58(%rsp), %cl
andb %cl, %bl
cmpb $0x1, 0x22(%rbp)
jne 0x4e7fd
movq 0xb0(%rsp), %rax
movq %rax, %rsi
notq %rsi
addq %r15, %rsi
testb %cl, %cl
cmovneq %rax, %rsi
movq 0x48(%rsp), %rdi
callq 0x6d96d
movq 0xa8(%rsp), %rdi
addq %r12, %rdi
movq 0x8(%rsp), %rsi
incq %rsi
movzbl %bl, %eax
movq 0x50(%rsp), %rdx
addq %rax, %rdx
movq 0x38(%rsp), %r12
cmpq $-0x1, 0x18(%r12)
je 0x4e852
movq 0x30(%rsp), %rax
cmpb $0x1, (%rax)
movq 0x68(%rsp), %rbp
movq %r15, %rbx
jne 0x4e842
movq %rdi, 0x80(%rsp)
cmpq 0x28(%rsp), %rdi
movq %r13, %r15
jb 0x4e5bf
jmp 0x4e886
movq (%r12), %rax
cmpq $-0x1, %rax
movq 0x68(%rsp), %rbp
je 0x4eb94
movq %r15, %rbx
movq 0x30(%rsp), %rcx
cmpb $0x1, (%rcx)
movq %r13, %r15
jne 0x4e87d
movq %rsi, 0x80(%rsp)
cmpq %rax, %rsi
jne 0x4e5bf
testq %rdi, %rdi
js 0x4e892
cvtsi2ss %rdi, %xmm1
jmp 0x4e8a9
movq %rdi, %rax
shrq %rax
movl %edi, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
testq %rbx, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, %r13
js 0x4e8c2
cvtsi2ss %rbx, %xmm0
jmp 0x4e8d7
movq %rbx, %rax
shrq %rax
andl $0x1, %ebx
orq %rax, %rbx
cvtsi2ss %rbx, %xmm0
addss %xmm0, %xmm0
movss %xmm1, 0x10(%rsp)
divss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
leaq 0x2ac496(%rip), %rsi    # 0x2fad82
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x92e71
leaq 0x2ac48f(%rip), %rsi    # 0x2fad91
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x92e71
cmpb $0x0, 0x4(%rsp)
jne 0x4e960
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
js 0x4e927
cvtsi2ss %rcx, %xmm0
jmp 0x4e93c
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss 0x10(%rsp), %xmm1
divss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
leaq 0x2ac458(%rip), %rsi    # 0x2fada9
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x92e71
leaq 0x2ac336(%rip), %rsi    # 0x2fac9d
movq %rbx, %rdi
movq 0x8(%rsp), %r13
movq %r13, %rdx
xorl %eax, %eax
callq 0x92e71
subq 0x50(%rsp), %r13
leaq 0x2ac43f(%rip), %rsi    # 0x2fadc4
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x92e71
leaq 0x2ac43a(%rip), %rsi    # 0x2fadd3
movq %rbx, %rdi
movq 0x50(%rsp), %rdx
xorl %eax, %eax
callq 0x92e71
cmpb $0x1, 0x23(%r12)
jne 0x4e9d9
movq 0x40(%r12), %rdx
leaq 0x2ac427(%rip), %rdi    # 0x2fade3
movq 0x40(%rsp), %rsi
movq 0x88(%rsp), %rcx
callq 0x4ec59
testl %eax, %eax
je 0x4e9d9
movq 0x30(%rsp), %rbx
jmp 0x4ea12
cmpb $0x1, 0x22(%r12)
movq 0x30(%rsp), %rbx
jne 0x4ea0a
movq 0x38(%r12), %rdx
leaq 0x2ac412(%rip), %rdi    # 0x2fae04
movq 0x48(%rsp), %rsi
movq 0x88(%rsp), %rcx
callq 0x4ec59
movl %eax, 0x1c(%rsp)
jmp 0x4ea12
movl $0x0, 0x1c(%rsp)
cmpb $0x1, (%rbx)
jne 0x4ea1c
callq 0x9cce9
leaq 0x2abf3b(%rip), %rsi    # 0x2fa95e
movq %r15, %rdi
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x936f9
movq %r14, %rdi
callq 0xae103
movq 0x70(%rsp), %rdi
callq 0xae103
movq 0x60(%rsp), %rdi
callq 0x722ae
movq 0x98(%rsp), %rdi
callq 0x79f01
movq %rbp, %rdi
callq 0x735fd
movq 0x20(%rsp), %rdi
callq 0x92fd0
cmpb $0x1, 0x23(%r12)
jne 0x4ea7d
movq 0x40(%rsp), %rdi
callq 0x6e064
cmpb $0x1, 0x22(%r12)
jne 0x4ea8f
movq 0x48(%rsp), %rdi
callq 0x6e064
movl 0x1c(%rsp), %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3e94bc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29655d(%rip), %rsi    # 0x2e5013
leaq 0x2ac390(%rip), %rdx    # 0x2fae4d
leaq 0x2ac36b(%rip), %rcx    # 0x2fae2f
leaq 0x2abe93(%rip), %r8     # 0x2fa95e
movl $0x115, %r9d            # imm = 0x115
jmp 0x4ebc0
movq 0x3e948b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29652c(%rip), %rsi    # 0x2e5013
leaq 0x2ac33a(%rip), %rdx    # 0x2fae28
leaq 0x2ac33a(%rip), %rcx    # 0x2fae2f
leaq 0x2abe62(%rip), %r8     # 0x2fa95e
movl $0x10d, %r9d            # imm = 0x10D
jmp 0x4ebc0
movq 0x3e945a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2964fb(%rip), %rsi    # 0x2e5013
leaq 0x2ac23f(%rip), %rdx    # 0x2fad5e
leaq 0x2ac0ef(%rip), %rcx    # 0x2fac15
leaq 0x2abe31(%rip), %r8     # 0x2fa95e
movl $0x196, %r9d            # imm = 0x196
jmp 0x4ebc0
movq 0x3e9429(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2964ca(%rip), %rsi    # 0x2e5013
leaq 0x2ac1ca(%rip), %rdx    # 0x2fad1a
leaq 0x2ac0be(%rip), %rcx    # 0x2fac15
leaq 0x2abe00(%rip), %r8     # 0x2fa95e
movl $0x188, %r9d            # imm = 0x188
jmp 0x4ebc0
movq 0x3e93fb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29649c(%rip), %rsi    # 0x2e5013
leaq 0x2ac1b2(%rip), %rdx    # 0x2fad30
leaq 0x2ac090(%rip), %rcx    # 0x2fac15
leaq 0x2abdd2(%rip), %r8     # 0x2fa95e
movl $0x18c, %r9d            # imm = 0x18C
jmp 0x4ebc0
movq 0x3e93cd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29646e(%rip), %rsi    # 0x2e5013
leaq 0x2ac0c7(%rip), %rdx    # 0x2fac73
leaq 0x2ac062(%rip), %rcx    # 0x2fac15
leaq 0x2abda4(%rip), %r8     # 0x2fa95e
movl $0x1cf, %r9d            # imm = 0x1CF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x3e9395(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x296436(%rip), %rsi    # 0x2e5013
leaq 0x2f9a6f(%rip), %rdx    # 0x348653
leaq 0x2ac02a(%rip), %rcx    # 0x2fac15
leaq 0x2abd6c(%rip), %r8     # 0x2fa95e
movl $0x136, %r9d            # imm = 0x136
jmp 0x4ebc0
movq 0x3e9367(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x296408(%rip), %rsi    # 0x2e5013
leaq 0x2965ad(%rip), %rdx    # 0x2e51bf
leaq 0x2abffc(%rip), %rcx    # 0x2fac15
leaq 0x2abd3e(%rip), %r8     # 0x2fa95e
movl $0x135, %r9d            # imm = 0x135
jmp 0x4ebc0
movq 0x3e9339(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2963da(%rip), %rsi    # 0x2e5013
leaq 0x2ac033(%rip), %rdx    # 0x2fac73
leaq 0x2abfce(%rip), %rcx    # 0x2fac15
leaq 0x2abd10(%rip), %r8     # 0x2fa95e
movl $0x15e, %r9d            # imm = 0x15E
jmp 0x4ebc0