// File: /workspace/github_c_makefile_star2_O1/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, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq $0x0, 0x80(%rsp)
testq %r8, %r8
je 0xcb7a8
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0xcc094
movq %r15, 0x60(%rsp)
testq %r14, %r14
je 0xcc08f
movzbl 0x21(%r14), %edi
movq 0x3f87be(%rip), %rax    # 0x4c3f80
movq (%rax), %rdx
leaq 0x284108(%rip), %rsi    # 0x34f8d4
callq 0x108ed0
movq %rax, %r15
cmpq $-0x1, 0x10(%r14)
je 0xcb7e5
movl $0x0, 0x1c(%rsp)
jmp 0xcb7f1
cmpq $-0x1, 0x8(%r14)
setne %al
movl %eax, 0x1c(%rsp)
cmpb $0x1, 0x22(%r14)
jne 0xcb804
callq 0xe99dc
movq %rax, 0x48(%rsp)
jmp 0xcb80d
movq $0x0, 0x48(%rsp)
cmpb $0x1, 0x23(%r14)
jne 0xcb820
callq 0xe99dc
movq %rax, 0x50(%rsp)
jmp 0xcb829
movq $0x0, 0x50(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
callq 0xf36ef
movq %rax, %rdi
movslq %ebp, %rax
movq (%rbx,%rax,8), %rsi
movq %rdi, 0xa8(%rsp)
movq 0x60(%rsp), %rdx
callq 0xf374b
movq %rax, %rbp
testq %rax, %rax
je 0xcb86c
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xed76d
movq %rax, %r12
jmp 0xcb86f
xorl %r12d, %r12d
testq %rbp, %rbp
movq %r14, 0x38(%rsp)
movq %r15, 0x28(%rsp)
je 0xcb8fb
movq %rbp, %rdi
callq 0xec1d8
movq %rax, %rbx
movq %rbp, %r13
movq %rbp, %rdi
callq 0xec1e8
leaq 0x298429(%rip), %rsi    # 0x363cc4
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10906e
leaq 0x29842e(%rip), %rsi    # 0x363cdd
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10906e
movq 0x18(%r14), %rdx
cmpq $-0x1, %rdx
movq %rbx, 0x70(%rsp)
je 0xcb92a
leaq 0x298426(%rip), %rsi    # 0x363cf8
movq %r15, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x18(%r14), %rax
imulq %rbx, %rax
cmpb $0x0, 0x20(%r14)
movq %rax, 0x30(%rsp)
movq %rax, %rbx
movq %r13, %r15
jne 0xcb965
jmp 0xcb981
movq $0x0, 0x40(%rsp)
movq $0x0, 0x68(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r13d, %r13d
movq $0x0, 0x8(%rsp)
movq %rbp, %r15
jmp 0xcbadf
movq (%r14), %rdx
cmpq $-0x1, %rdx
je 0xcc099
leaq 0x2983f2(%rip), %rsi    # 0x363d30
movq $0x0, 0x30(%rsp)
movq %r15, %rdi
xorl %eax, %eax
callq 0x10906e
cmpb $0x1, 0x20(%r14)
jne 0xcb97e
movq (%r14), %rax
movq %rax, 0x30(%rsp)
xorl %ebx, %ebx
movq %r13, %r15
leaq 0x80(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x110c6c
movq %rbx, 0x30(%rsp)
jmp 0xcb981
movq %r13, %r15
callq 0x1208f8
movq %rax, 0x40(%rsp)
callq 0x1208f8
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x50(%r14)
je 0xcba8d
movq 0x48(%r14), %rdi
callq 0x120d23
leaq 0x29839e(%rip), %rsi    # 0x363d4e
movq 0x28(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10906e
movq 0x48(%r14), %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x104631
movq %rax, %rbp
leaq 0xf(%rax), %rdi
testq %rax, %rax
cmovnsq %rax, %rdi
movq %rdi, %rax
sarq $0x4, %rax
movq %rax, 0x8(%rsp)
andq $-0x10, %rdi
leaq 0x298005(%rip), %rsi    # 0x3639fa
movl $0x16c, %edx            # imm = 0x16C
callq 0x1092b2
movq %rax, 0x20(%rsp)
cmpq $0x10, %rbp
jl 0xcba4d
movq %r14, %rbx
movq 0x20(%rsp), %r13
movq 0x8(%rsp), %r14
leaq 0x8(%r13), %rdi
movq 0x50(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x125604
movq 0x50(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x125604
addq $0x10, %r13
decq %r14
jne 0xcba17
cmpq $0x20, %rbp
jl 0xcbab0
movq 0x8(%rsp), %rcx
cmpq $0x3, %rcx
movl $0x2, %eax
cmovgeq %rcx, %rax
shlq $0x4, %rax
movl $0x10, %ecx
movq 0x38(%rsp), %r14
movq 0x20(%rsp), %r13
movq -0x10(%r13,%rcx), %rdx
addq %rdx, (%r13,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xcba78
jmp 0xcbadf
movq 0x8(%r14), %rdx
cmpb $0x0, 0x1c(%rsp)
je 0xcbabc
leaq 0x2982d1(%rip), %rsi    # 0x363d70
xorl %r13d, %r13d
movq 0x28(%rsp), %rdi
xorl %eax, %eax
callq 0x10906e
jmp 0xcbad6
movq 0x38(%rsp), %r14
movq 0x20(%rsp), %r13
jmp 0xcbadf
movq 0x10(%r14), %rcx
leaq 0x2982cb(%rip), %rsi    # 0x363d92
xorl %r13d, %r13d
movq 0x28(%rsp), %rdi
xorl %eax, %eax
callq 0x10906e
movq $0x0, 0x8(%rsp)
testq %r15, %r15
movq %r13, 0x20(%rsp)
movq %r12, 0x90(%rsp)
je 0xcbe32
movq 0x8(%rsp), %rax
decq %rax
movq %rax, %rcx
shlq $0x4, %rcx
addq %r13, %rcx
movq %rcx, 0x98(%rsp)
movq %rax, 0x8(%rsp)
shrq %rax
movq %rax, 0xb0(%rsp)
shlq $0x4, %rax
addq %r13, %rax
movq %rax, 0x88(%rsp)
movq $0x0, 0x58(%rsp)
xorl %edx, %edx
xorl %eax, %eax
movq %rax, 0xa0(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x40(%rsp), %rdi
callq 0x120db4
cmpb $0x0, 0x1c(%rsp)
movq 0x70(%rsp), %rbx
jne 0xcbc4f
cmpq $0x0, 0x50(%r14)
je 0xcbc23
testq %r13, %r13
je 0xcc080
movq 0x98(%rsp), %rax
movq (%rax), %rdi
callq 0x10ae3c
movq 0x88(%rsp), %rsi
movq (%rsi), %r8
cmpq %rax, %r8
je 0xcbc08
movq 0x88(%rsp), %rsi
movq 0xb0(%rsp), %rcx
movq 0x8(%rsp), %rdi
xorl %edx, %edx
cmpq %rax, %r8
jbe 0xcbbd6
cmpq %rdi, %rdx
ja 0xcc076
testq %rcx, %rcx
je 0xcbc08
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %rcx, %rdi
cmpq %rax, (%r13,%r8)
jae 0xcbbea
jmp 0xcbc08
cmpq 0x8(%rsp), %rcx
jae 0xcc071
incq %rcx
movq %rcx, %rdx
movq %rdi, %rcx
subq %rdx, %rcx
shrq %rcx
addq %rdx, %rcx
movq %rcx, %r8
shlq $0x4, %r8
leaq (%r8,%r13), %rsi
movq (%r13,%r8), %r8
cmpq %rax, %r8
jne 0xcbbad
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0xcbc39
jmp 0xcc085
movq 0x10(%r14), %rdi
subq 0x8(%r14), %rdi
callq 0x10ae3c
addq 0x8(%r14), %rax
movq %rax, 0x10(%rsp)
cmpb $0x1, 0x23(%r14)
jne 0xcbc4f
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe99f7
movq %rbx, %rdi
subq 0x10(%rsp), %rdi
jbe 0xcc07b
callq 0x10ae3c
movq %rax, %rbx
movb $0x1, %r13b
cmpb $0x0, 0x24(%r14)
jne 0xcbc80
movl $0x1, %edi
callq 0x10ae3c
testq %rax, %rax
setne %r13b
movl %r13d, %eax
xorb $0x1, %al
movzbl %al, %eax
leal (%rax,%rax,2), %edx
movq %r12, %rdi
movq %r15, %rbp
movq %r15, %rsi
movq %rbx, %r15
movq %rbx, %rcx
callq 0xed48e
cmpq $0x0, 0x10(%rsp)
je 0xcbcfc
movq 0x10(%rsp), %r14
movq %r12, %rdi
callq 0xec7be
cmpb $-0x1, %al
je 0xcbce1
movl %eax, %ebx
movq %rbp, %rdi
callq 0xf02da
movzbl %bl, %esi
movq %rax, %rdi
callq 0xd3da7
movsbl %al, %esi
movq 0x40(%rsp), %rdi
callq 0x120ba5
decq %r14
jne 0xcbcac
jmp 0xcbcfc
movq %rbp, %r15
testq %rbp, %rbp
movq 0x38(%rsp), %r14
movq 0x20(%rsp), %r13
jne 0xcbb48
jmp 0xcbe41
movq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x120db4
movq %rbx, %rdi
leaq 0x298105(%rip), %rsi    # 0x363e18
callq 0x12097f
movq %rbx, %rdi
movq 0x78(%rsp), %rsi
callq 0x120af4
movq %rbx, %rdi
callq 0x120d23
movq %rax, %rbx
movb %r13b, 0x7(%rsp)
movq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x120d23
movq %rax, %r14
movq %r13, %rdi
callq 0x120d4c
movq 0x38(%rsp), %r12
movq 0x30(%r12), %r8
movl $0x3c, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x102ec0
movq %r13, %rdi
movb 0x7(%rsp), %r13b
callq 0x120d4c
movq %rax, %rbx
movb 0x21(%r12), %r14b
andb %r13b, %r14b
cmpb $0x1, 0x22(%r12)
jne 0xcbda6
movq %r15, %rsi
notq %rsi
addq 0x70(%rsp), %rsi
testb %r13b, %r13b
cmovneq %r15, %rsi
movq 0x48(%rsp), %rdi
callq 0xe99f7
addq 0xa0(%rsp), %rbx
movq 0x78(%rsp), %rdx
incq %rdx
movzbl %r14b, %eax
movq 0x58(%rsp), %rcx
addq %rax, %rcx
movq 0x38(%rsp), %r14
cmpq $-0x1, 0x18(%r14)
movq 0x90(%rsp), %r12
movq %rcx, 0x58(%rsp)
je 0xcbdfb
cmpb $0x1, 0x20(%r14)
movq 0x20(%rsp), %r13
movq %rbp, %r15
jne 0xcbdf2
movq %rbx, 0x80(%rsp)
cmpq 0x30(%rsp), %rbx
jb 0xcbe24
jmp 0xcbe4e
movq (%r14), %rax
cmpq $-0x1, %rax
movq 0x20(%rsp), %r13
je 0xcc08a
movq %rbp, %r15
cmpb $0x1, 0x20(%r14)
jne 0xcbe1f
movq %rdx, 0x80(%rsp)
cmpq %rax, %rdx
je 0xcbe4e
movq %rbx, %rax
testq %r15, %r15
jne 0xcbb3b
jmp 0xcbe4e
xorl %ebx, %ebx
xorl %edx, %edx
movq $0x0, 0x58(%rsp)
jmp 0xcbe4e
movq 0xa0(%rsp), %rbx
movq 0x78(%rsp), %rdx
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testq %r15, %r15
je 0xcbfdd
testq %rbx, %rbx
js 0xcbe69
cvtsi2ss %rbx, %xmm1
jmp 0xcbe80
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
movq 0x70(%rsp), %rcx
testq %rcx, %rcx
movq %rdx, %r13
js 0xcbe94
cvtsi2ss %rcx, %xmm0
jmp 0xcbea9
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss %xmm1, 0x10(%rsp)
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x297f5d(%rip), %rsi    # 0x363e1e
movq 0x28(%rsp), %r12
movq %r12, %rdi
movb $0x1, %al
callq 0x10906e
leaq 0x297f56(%rip), %rsi    # 0x363e2d
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10906e
cmpb $0x0, 0x1c(%rsp)
jne 0xcbf3c
movq %r13, %rcx
testq %r13, %r13
js 0xcbefd
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
jmp 0xcbf15
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
movss 0x10(%rsp), %xmm1
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x297f18(%rip), %rsi    # 0x363e45
movq 0x28(%rsp), %r12
movq %r12, %rdi
movb $0x1, %al
callq 0x10906e
leaq 0x297df6(%rip), %rsi    # 0x363d39
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x10906e
movq 0x58(%rsp), %rbx
subq %rbx, %r13
leaq 0x297f01(%rip), %rsi    # 0x363e60
movq %r12, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x10906e
leaq 0x297efc(%rip), %rsi    # 0x363e6f
movq %r12, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10906e
cmpb $0x1, 0x23(%r14)
movq 0x90(%rsp), %r12
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jne 0xcbfb3
movq 0x40(%r14), %rdx
leaq 0x297edf(%rip), %rdi    # 0x363e7f
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rcx
callq 0xcc09e
testl %eax, %eax
jne 0xcbfdd
cmpb $0x1, 0x22(%r14)
movl $0x0, %r13d
jne 0xcbfdd
movq 0x38(%r14), %rdx
leaq 0x297ed5(%rip), %rdi    # 0x363ea0
movq 0x48(%rsp), %rsi
movq 0x60(%rsp), %rcx
callq 0xcc09e
movl %eax, %r13d
cmpb $0x1, 0x20(%r14)
jne 0xcbfe9
callq 0x111189
leaq 0x297a0a(%rip), %rsi    # 0x3639fa
movq 0x20(%rsp), %rdi
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x109670
movq 0x40(%rsp), %rdi
callq 0x121b03
movq 0x68(%rsp), %rdi
callq 0x121b03
movq %r12, %rdi
callq 0xed7bf
movq 0xa8(%rsp), %rdi
callq 0xf424d
movq %r15, %rdi
callq 0xee90c
movq 0x28(%rsp), %rdi
callq 0x10916a
cmpb $0x1, 0x23(%r14)
jne 0xcc04b
movq 0x50(%rsp), %rdi
callq 0xe9ff6
cmpb $0x1, 0x22(%r14)
jne 0xcc05c
movq 0x48(%rsp), %rdi
callq 0xe9ff6
movl %r13d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20742
callq 0x2077b
callq 0x20826
callq 0x207ed
callq 0x207b4
callq 0x2085f
callq 0x20898
callq 0x206d0
callq 0x20709