// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq $0x0, 0x88(%rsp)
testq %r8, %r8
je 0xc953f
movq %r12, %rdi
callq 0xfcc32
testb %al, %al
jne 0xc9dc1
testq %r15, %r15
je 0xc9dbc
movzbl 0x21(%r15), %edi
movq 0x3efa2c(%rip), %rax    # 0x4b8f80
movq (%rax), %rdx
leaq 0x27d376(%rip), %rsi    # 0x3468d4
callq 0x103e40
movq %rax, %r14
cmpq $-0x1, 0x10(%r15)
je 0xc9577
movl $0x0, 0xc(%rsp)
jmp 0xc9583
cmpq $-0x1, 0x8(%r15)
setne %al
movl %eax, 0xc(%rsp)
cmpb $0x1, 0x22(%r15)
jne 0xc9596
callq 0xe54e0
movq %rax, 0x58(%rsp)
jmp 0xc959f
movq $0x0, 0x58(%rsp)
cmpb $0x1, 0x23(%r15)
jne 0xc95b2
callq 0xe54e0
movq %rax, 0x50(%rsp)
jmp 0xc95bb
movq $0x0, 0x50(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
callq 0xef0cd
movq %rax, %rdi
movslq %ebp, %rax
movq (%rbx,%rax,8), %rsi
movq %rdi, 0xa8(%rsp)
movq %r12, %rdx
callq 0xef129
movq %rax, %r13
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
testq %rax, %rax
movq %r14, 0x20(%rsp)
je 0xc9689
movq %r12, 0x90(%rsp)
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe91b2
movq %rax, 0x70(%rsp)
movq %r13, %rdi
callq 0xe7b9c
movq %rax, %rbx
movq %r13, %rdi
callq 0xe7bac
leaq 0x291621(%rip), %rsi    # 0x35ac50
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103fe1
leaq 0x291626(%rip), %rsi    # 0x35ac69
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x103fe1
movq 0x18(%r15), %rdx
cmpq $-0x1, %rdx
movq %rbx, 0x40(%rsp)
je 0xc96a6
leaq 0x29161e(%rip), %rsi    # 0x35ac84
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
movq 0x18(%r15), %rax
imulq %rbx, %rax
cmpb $0x0, 0x20(%r15)
movq %rax, 0x30(%rsp)
movq %rax, %rbx
jne 0xc96de
jmp 0xc96f5
xorl %r12d, %r12d
movq $0x0, 0x78(%rsp)
xorl %r14d, %r14d
movq $0x0, 0x70(%rsp)
jmp 0xc9d0b
movq (%r15), %rdx
cmpq $-0x1, %rdx
je 0xc9dc6
leaq 0x291602(%rip), %rsi    # 0x35acbc
movq $0x0, 0x30(%rsp)
movq %r14, %rdi
xorl %eax, %eax
callq 0x103fe1
cmpb $0x1, 0x20(%r15)
jne 0xc96f5
movq (%r15), %rax
movq %rax, 0x30(%rsp)
xorl %ebx, %ebx
leaq 0x88(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x10ba28
movq %rbx, 0x30(%rsp)
callq 0x11ac6c
movq %rax, %r14
callq 0x11ac6c
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x50(%r15)
movq %r15, 0x68(%rsp)
je 0xc9813
movq 0x48(%r15), %rdi
callq 0x11b0a1
leaq 0x2915b3(%rip), %rsi    # 0x35acda
movq 0x20(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103fe1
movq 0x48(%r15), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff72f
movq %rax, %rbp
leaq 0xf(%rax), %rdi
testq %rax, %rax
cmovnsq %rax, %rdi
movq %rdi, %rax
sarq $0x4, %rax
movq %rax, 0x28(%rsp)
andq $-0x10, %rdi
leaq 0x29121a(%rip), %rsi    # 0x35a986
movl $0x16c, %edx            # imm = 0x16C
callq 0x104226
movq %rax, %r12
cmpq $0x10, %rbp
jl 0xc9838
movq %r12, 0x38(%rsp)
movq %r15, %rbx
movq 0x28(%rsp), %r15
leaq 0x8(%r12), %rdi
movq 0x50(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x11f848
movq 0x50(%rbx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
callq 0x11f848
addq $0x10, %r12
decq %r15
jne 0xc9790
cmpq $0x20, %rbp
movq 0x40(%rsp), %rbx
movq 0x38(%rsp), %r12
movq 0x28(%rsp), %rsi
jl 0xc9804
cmpq $0x3, %rsi
movl $0x2, %eax
cmovgeq %rsi, %rax
shlq $0x4, %rax
movl $0x10, %ecx
movq -0x10(%r12,%rcx), %rdx
addq %rdx, (%r12,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0xc97f2
testq %r13, %r13
movq 0x68(%rsp), %r15
jne 0xc9860
jmp 0xc9d0b
movq 0x8(%r15), %rdx
cmpb $0x0, 0xc(%rsp)
movq 0x40(%rsp), %rbx
je 0xc9844
leaq 0x2914d2(%rip), %rsi    # 0x35acfc
movq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x103fe1
jmp 0xc985b
movq 0x40(%rsp), %rbx
movq 0x28(%rsp), %rsi
jmp 0xc9860
movq 0x10(%r15), %rcx
leaq 0x2914cf(%rip), %rsi    # 0x35ad1e
movq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x103fe1
xorl %esi, %esi
xorl %r12d, %r12d
decq %rsi
movq %rsi, %rax
shlq $0x4, %rax
addq %r12, %rax
movq %rax, 0xa0(%rsp)
movq %rsi, %rax
shrq %rax
movq %rax, 0xb0(%rsp)
shlq $0x4, %rax
addq %r12, %rax
movq %rax, 0x98(%rsp)
xorl %edx, %edx
xorl %edi, %edi
xorl %ecx, %ecx
movq %r12, 0x38(%rsp)
movq %rsi, 0x28(%rsp)
movq %rcx, 0x80(%rsp)
movq %rdi, 0x48(%rsp)
movq %rdx, 0x60(%rsp)
movq %r14, %rdi
callq 0x11b132
cmpb $0x0, 0xc(%rsp)
jne 0xc99b3
cmpq $0x0, 0x50(%r15)
je 0xc9987
testq %r12, %r12
je 0xc9dad
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
callq 0x105d85
movq 0x98(%rsp), %rsi
movq (%rsi), %r8
cmpq %rax, %r8
movq 0x28(%rsp), %r9
je 0xc996c
movq 0x98(%rsp), %rsi
movq 0xb0(%rsp), %rcx
movq %r9, %rdi
xorl %edx, %edx
cmpq %rax, %r8
jbe 0xc993d
cmpq %rdi, %rdx
ja 0xc9d9e
testq %rcx, %rcx
je 0xc996c
decq %rcx
movq %rcx, %r8
shlq $0x4, %r8
movq %rcx, %rdi
cmpq %rax, (%r12,%r8)
jae 0xc994f
jmp 0xc996c
cmpq %r9, %rcx
jae 0xc9da3
incq %rcx
movq %rcx, %rdx
movq %rdi, %rcx
subq %rdx, %rcx
shrq %rcx
addq %rdx, %rcx
movq %rcx, %r8
shlq $0x4, %r8
leaq (%r12,%r8), %rsi
movq (%r12,%r8), %r8
cmpq %rax, %r8
jne 0xc9915
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0xc999d
jmp 0xc9db2
movq 0x10(%r15), %rdi
subq 0x8(%r15), %rdi
callq 0x105d85
addq 0x8(%r15), %rax
movq %rax, 0x10(%rsp)
cmpb $0x1, 0x23(%r15)
jne 0xc99b3
movq 0x50(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe54fb
movq %rbx, %rdi
movq 0x10(%rsp), %rbx
subq %rbx, %rdi
jbe 0xc9da8
callq 0x105d85
movq %rax, %r12
cmpb $0x0, 0x24(%r15)
je 0xc99dc
xorl %edx, %edx
movb $0x1, 0xb(%rsp)
jmp 0xc99f6
movl $0x1, %edi
callq 0x105d85
xorl %ecx, %ecx
testq %rax, %rax
setne 0xb(%rsp)
sete %cl
leal (%rcx,%rcx,2), %edx
movq 0x70(%rsp), %rdi
movq %r13, %rbp
movq %r13, %rsi
movq %r12, %r13
movq %r12, %rcx
callq 0xe8eed
testq %rbx, %rbx
je 0xc9a62
movq %rbx, %r15
movq 0x70(%rsp), %rdi
callq 0xe8186
cmpb $-0x1, %al
je 0xc9a4b
movl %eax, %r12d
movq %rbp, %rdi
callq 0xebcd9
movzbl %r12b, %esi
movq %rax, %rdi
callq 0xd187b
movsbl %al, %esi
movq %r14, %rdi
callq 0x11af23
decq %r15
jne 0xc9a14
jmp 0xc9a62
movq 0x68(%rsp), %r15
movq 0x40(%rsp), %rbx
movq 0x38(%rsp), %r12
movq %rbp, %r13
jmp 0xc98b4
movq 0x78(%rsp), %rbx
movq %rbx, %rdi
callq 0x11b132
movq %rbx, %rdi
leaq 0x29132b(%rip), %rsi    # 0x35ada4
callq 0x11acf3
movq %rbx, %rdi
movq 0x48(%rsp), %rsi
callq 0x11ae72
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %r12
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %r15
movq %r14, %rdi
callq 0x11b0ca
movq 0x68(%rsp), %rbx
movq 0x30(%rbx), %r8
movl $0x3c, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xfe000
movq %r14, %rdi
callq 0x11b0ca
movq %rax, %r12
movb 0x21(%rbx), %r15b
movb 0xb(%rsp), %cl
andb %cl, %r15b
cmpb $0x1, 0x22(%rbx)
movq 0x40(%rsp), %rbx
jne 0xc9aff
movq %r13, %rsi
notq %rsi
addq %rbx, %rsi
testb %cl, %cl
cmovneq %r13, %rsi
movq 0x58(%rsp), %rdi
callq 0xe54fb
movq 0x80(%rsp), %rcx
addq %r12, %rcx
movq 0x48(%rsp), %rdi
incq %rdi
movzbl %r15b, %eax
movq 0x60(%rsp), %rdx
addq %rax, %rdx
movq 0x68(%rsp), %r15
cmpq $-0x1, 0x18(%r15)
je 0xc9b4e
cmpb $0x1, 0x20(%r15)
movq 0x38(%rsp), %r12
movq %rbp, %r13
jne 0xc9b41
movq %rcx, 0x88(%rsp)
cmpq 0x30(%rsp), %rcx
jb 0xc98a2
jmp 0xc9b7b
movq (%r15), %rax
cmpq $-0x1, %rax
movq 0x38(%rsp), %r12
je 0xc9db7
movq %rbp, %r13
cmpb $0x1, 0x20(%r15)
jne 0xc9b72
movq %rdi, 0x88(%rsp)
cmpq %rax, %rdi
jne 0xc98a2
testq %rcx, %rcx
movq %rcx, 0x80(%rsp)
js 0xc9b8f
cvtsi2ss %rcx, %xmm1
jmp 0xc9ba4
movq %rcx, %rax
shrq %rax
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
testq %rbx, %rbx
movq %rdi, 0x48(%rsp)
movq %rdx, 0x60(%rsp)
js 0xc9bba
cvtsi2ss %rbx, %xmm0
jmp 0xc9bcf
movq %rbx, %rax
shrq %rax
andl $0x1, %ebx
orq %rax, %rbx
cvtsi2ss %rbx, %xmm0
addss %xmm0, %xmm0
movss %xmm1, 0x10(%rsp)
divss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
leaq 0x2911c3(%rip), %rsi    # 0x35adaa
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
movb $0x1, %al
callq 0x103fe1
leaq 0x2911bc(%rip), %rsi    # 0x35adb9
movq %rbp, %rdi
movq 0x80(%rsp), %rdx
xorl %eax, %eax
callq 0x103fe1
cmpb $0x0, 0xc(%rsp)
jne 0xc9c69
movq 0x48(%rsp), %rcx
testq %rcx, %rcx
js 0xc9c2a
xorps %xmm0, %xmm0
cvtsi2ss %rcx, %xmm0
jmp 0xc9c42
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 0x291177(%rip), %rsi    # 0x35add1
movq 0x20(%rsp), %rbp
movq %rbp, %rdi
movb $0x1, %al
callq 0x103fe1
leaq 0x291055(%rip), %rsi    # 0x35acc5
movq %rbp, %rdi
movq 0x48(%rsp), %rbx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x103fe1
subq 0x60(%rsp), %rbx
leaq 0x29115e(%rip), %rsi    # 0x35adec
movq %rbp, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x103fe1
leaq 0x291159(%rip), %rsi    # 0x35adfb
movq %rbp, %rdi
movq 0x60(%rsp), %rdx
xorl %eax, %eax
callq 0x103fe1
cmpb $0x1, 0x23(%r15)
jne 0xc9cd9
movq 0x40(%r15), %rdx
leaq 0x291148(%rip), %rdi    # 0x35ae0b
movq 0x50(%rsp), %rsi
movq 0x90(%rsp), %rcx
callq 0xc9dcb
testl %eax, %eax
jne 0xc9d0b
cmpb $0x1, 0x22(%r15)
jne 0xc9d03
movq 0x38(%r15), %rdx
leaq 0x291141(%rip), %rdi    # 0x35ae2c
movq 0x58(%rsp), %rsi
movq 0x90(%rsp), %rcx
callq 0xc9dcb
movl %eax, 0x1c(%rsp)
jmp 0xc9d0b
movl $0x0, 0x1c(%rsp)
cmpb $0x1, 0x20(%r15)
jne 0xc9d17
callq 0x10bf8a
leaq 0x290c68(%rip), %rsi    # 0x35a986
movq %r12, %rdi
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x1045eb
movq %r14, %rdi
callq 0x11bdbf
movq 0x78(%rsp), %rdi
callq 0x11bdbf
movq 0x70(%rsp), %rdi
callq 0xe9204
movq 0xa8(%rsp), %rdi
callq 0xefbe3
movq %r13, %rdi
callq 0xea375
movq 0x20(%rsp), %rdi
callq 0x1040e0
cmpb $0x1, 0x23(%r15)
jne 0xc9d77
movq 0x50(%rsp), %rdi
callq 0xe5a93
cmpb $0x1, 0x22(%r15)
jne 0xc9d88
movq 0x58(%rsp), %rdi
callq 0xe5a93
movl 0x1c(%rsp), %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20346
callq 0x2030d
callq 0x203f1
callq 0x203b8
callq 0x2037f
callq 0x2042a
callq 0x2049c
callq 0x202d4
callq 0x20463