// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_next_desc
static int encdesc_next_desc(GtEncdesc *encdesc, GtStr *desc, GtError *err)
{
  int stat, had_err = 0;
  bool bit,
       sampled = false;
  GtWord tmp = 0;
  GtUword cur_field_num,
          fieldlen = 0,
          idx,
          numoffields,
          nearestsample,
          zero_count = 0,
          tmp_symbol = 0;
  GtBitsequence bitseq;
  GtHuffmanBitwiseDecoder *huff_bitwise_decoder;

  if (encdesc->cur_desc == encdesc->num_of_descs) {
    gt_error_set(err,"nothing done, eof?");
    return -1;
  }

  if (encdesc->sampling != NULL &&
      encdesc->cur_desc == gt_sampling_get_next_elementnum(encdesc->sampling)) {
    int sample_status;
    size_t startofnearestsample;
    gt_log_log("get next sampled description (" GT_WU ")", encdesc->cur_desc);
    sample_status = gt_sampling_get_next_sample(encdesc->sampling,
                                                &nearestsample,
                                                &startofnearestsample);
    if (sample_status == 1) {
      gt_bitinstream_reinit(encdesc->bitinstream, startofnearestsample);
      sampled = true;
    }
    else
      had_err = sample_status;
  }

  if (had_err)
    gt_error_set(err, "sampling did not work, input data corrupt?");

  if (desc != NULL)
    gt_str_reset(desc);
  if (!had_err && !encdesc->num_of_fields_is_const) {
    had_err = encdesc_read_bits(encdesc->bitinstream,
                                encdesc->bits_per_field,
                                &bitseq, err);
    numoffields = (GtUword) bitseq;
  }
  else
    numoffields = encdesc->num_of_fields;

  gt_assert(numoffields <= encdesc->num_of_fields);
  for (cur_field_num = 0;
       !had_err && cur_field_num < numoffields;
       cur_field_num++) {
    DescField *cur_field = &encdesc->fields[cur_field_num];
    if (cur_field->is_const) {
      if (desc != NULL) {
        gt_assert(cur_field->data != NULL);
        gt_str_append_cstr(desc, cur_field->data);
        gt_str_append_char(desc, cur_field->sep);
      }
      continue;
    }
    if (cur_field->is_numeric) {
      if (cur_field->has_zero_padding && !cur_field->fieldlen_is_const) {
        huff_bitwise_decoder = gt_huffman_bitwise_decoder_new(
                                            cur_field->huffman_zero_count, err);
        stat = -1;
        while (!had_err && stat != 0) {
          if (gt_bitinstream_get_next_bit(encdesc->bitinstream, &bit) != 1) {
            gt_error_set(err, "could not get next bit");
            had_err = -1;
          }
          else {
            stat = gt_huffman_bitwise_decoder_next(huff_bitwise_decoder, bit,
                                                   &zero_count, err);
            if (stat == -1) {
              had_err = -1;
              gt_assert(gt_error_is_set(err));
            }
          }
        }
        gt_huffman_bitwise_decoder_delete(huff_bitwise_decoder);
        for (idx = 0;
             !had_err && desc != NULL && idx < zero_count;
             idx++)
          gt_str_append_char(desc, '0');
      }
      /* read absolute value if description is first or sampled */
      if (!had_err && (encdesc->cur_desc == 0 || sampled)) {
        had_err = encdesc_read_bits(encdesc->bitinstream,
                                    cur_field->bits_per_value,
                                    &bitseq, err);
        if (!had_err) {
          tmp = (GtWord) bitseq + cur_field->min_value;
        }
      }
      else if (!had_err) {
        if (!cur_field->is_value_const || !cur_field->is_delta_const) {
          if (cur_field->bits_per_num) {
            if (cur_field->use_hc) {
              huff_bitwise_decoder =
                gt_huffman_bitwise_decoder_new(cur_field->huffman_num, err);
              stat = 1;
              while (!had_err && stat != 0) {
                if (gt_bitinstream_get_next_bit(encdesc->bitinstream,
                                                &bit) != 1) {
                  gt_error_set(err, "could not get next bit");
                  had_err = -1;
                }
                else {
                  stat = gt_huffman_bitwise_decoder_next(huff_bitwise_decoder,
                                                         bit, &tmp_symbol, err);
                  if (stat == -1) {
                    had_err = -1;
                    gt_assert(gt_error_is_set(err));
                  }
                  else
                    tmp = (GtWord) tmp_symbol;
                }
              }
              gt_huffman_bitwise_decoder_delete(huff_bitwise_decoder);
            }
            else {
              had_err = encdesc_read_bits(encdesc->bitinstream,
                                          cur_field->bits_per_num,
                                          &bitseq, err);
              tmp = (GtWord) bitseq;
            }
          }
          else
            tmp = 0;
        }
        else {
          if (cur_field->use_delta_coding)
            tmp = 0;
          else
            tmp = cur_field->prev_value - cur_field->min_value;
        }
        if (cur_field->use_delta_coding)
          tmp += cur_field->prev_value + cur_field->min_delta;
        else
          tmp += cur_field->min_value;
      }
      if (!had_err) {
        if (!(encdesc->cur_desc == 0) && !sampled) {
          if (cur_field->is_delta_negative)
            gt_assert(tmp < cur_field->prev_value);
          if (cur_field->is_delta_positive)
            gt_assert(tmp > cur_field->prev_value);
        }
        cur_field->prev_value = tmp;
        if (cur_field->has_zero_padding && cur_field->fieldlen_is_const) {
          zero_count = cur_field->len -
            encdesc_digits_per_value((GtUword) tmp, 10UL);
          for (idx = 0;
               desc != NULL && idx < zero_count;
               idx++)
            gt_str_append_char(desc, '0');
        }
        if (desc != NULL) {
          gt_str_append_uword(desc, (GtUword) tmp);
          gt_str_append_char(desc, cur_field->sep);
        }
        continue;
      }
    }
    /* variable cur_field len */
    if (!cur_field->fieldlen_is_const) {
      had_err = encdesc_read_bits(encdesc->bitinstream,
                                  cur_field->bits_per_len,
                                  &bitseq, err);
      fieldlen = (GtUword) bitseq + cur_field->min_len;
    }
    else
      fieldlen = cur_field->len;

    for (idx = 0; !had_err && idx < fieldlen; idx++) {
      if (idx < cur_field->len &&
          gt_bittab_bit_is_set(cur_field->bittab, idx)) {
        if (desc != NULL)
          gt_str_append_char(desc, cur_field->data[idx]);
      }
      else {
        huff_bitwise_decoder = gt_huffman_bitwise_decoder_new(
                                            cur_field->huffman_chars[idx], err);
        stat = -1;
        while (!had_err && stat != 0) {
          if (gt_bitinstream_get_next_bit(encdesc->bitinstream, &bit) != 1) {
            gt_error_set(err, "could not get next bit");
            had_err = -1;
          }
          else {
            stat = gt_huffman_bitwise_decoder_next(huff_bitwise_decoder,
                                                   bit, &tmp_symbol, err);
            if (stat == -1) {
              gt_assert(gt_error_is_set(err));
              had_err = stat;
            }
            else
              tmp = (GtWord) tmp_symbol;
          }
        }
        if (!had_err && desc != NULL) {
          gt_assert(tmp < 256L);
          gt_str_append_char(desc, (char) tmp);
        }
        gt_huffman_bitwise_decoder_delete(huff_bitwise_decoder);
      }
    }
    if (!had_err && desc != NULL)
      gt_str_append_char(desc, cur_field->sep);
  }
  if (desc != NULL && gt_str_length(desc) != 0)
    gt_str_set_length(desc, gt_str_length(desc) - 1);
  if (!had_err) {
    encdesc->cur_desc++;
  }

  if (had_err)
    gt_assert(gt_error_is_set(err));
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
xorl %r13d, %r13d
movq %r13, 0x48(%rsp)
movq %r13, 0x40(%rsp)
movq 0x48(%rdi), %r14
cmpq 0x38(%rdi), %r14
jne 0x1431aa
leaq 0x2428bf(%rip), %rsi    # 0x385a54
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x1439bd
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x14321f
callq 0x1794f7
xorl %r13d, %r13d
movl $0x0, %ecx
movq %rcx, 0x30(%rsp)
cmpq %rax, %r14
movq 0x18(%rsp), %r14
jne 0x14322d
movq 0x48(%r14), %rsi
leaq 0x242885(%rip), %rdi    # 0x385a67
xorl %eax, %eax
callq 0x108e02
movq 0x28(%r14), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x179557
movl %eax, %r13d
cmpl $0x1, %eax
sete %al
movq %rax, 0x30(%rsp)
jne 0x14322d
movq 0x20(%r14), %rdi
movq 0x20(%rsp), %rsi
callq 0x304a0f
xorl %r13d, %r13d
jmp 0x14322d
movq $0x0, 0x30(%rsp)
movq 0x18(%rsp), %r14
testl %r13d, %r13d
je 0x143243
leaq 0x242851(%rip), %rsi    # 0x385a8a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
testq %r12, %r12
je 0x143250
movq %r12, %rdi
callq 0x120db4
testl %r13d, %r13d
movq %r12, 0x38(%rsp)
jne 0x143265
cmpb $0x0, 0x6c(%r14)
je 0x1439cf
movq 0x40(%r14), %rcx
cmpq 0x40(%r14), %rcx
ja 0x143a63
testl %r13d, %r13d
sete %bpl
jne 0x14397c
testq %rcx, %rcx
je 0x14397c
xorl %eax, %eax
movq $0x0, 0x10(%rsp)
movq %rcx, 0x50(%rsp)
movq %rax, %rcx
movq 0x18(%r14), %rax
movq %rcx, 0x58(%rsp)
imulq $0xc8, %rcx, %rcx
leaq (%rax,%rcx), %r15
cmpb $0x1, 0xbb(%rax,%rcx)
jne 0x1432dd
testq %r12, %r12
je 0x143789
movq 0x40(%r15), %rsi
testq %rsi, %rsi
je 0x143a54
movq %r12, %rdi
callq 0x12097f
jmp 0x143779
cmpb $0x1, 0xbf(%r15)
movq 0x10(%rsp), %rax
movq %r15, 0x28(%rsp)
jne 0x14341e
cmpb $0x1, 0xba(%r15)
jne 0x143407
cmpb $0x0, 0xb9(%r15)
jne 0x143407
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x15c249
movq %rax, %r15
testl %r13d, %r13d
sete %r14b
jne 0x1433a2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xf(%rsp), %rsi
callq 0x304ab4
cmpl $0x1, %eax
jne 0x14337e
movzbl 0xf(%rsp), %esi
movq %r15, %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rcx
callq 0x15c27f
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x143395
movq %rbx, %rdi
callq 0x101a9a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
jne 0x143395
jmp 0x143a59
movq %rbx, %rdi
leaq 0x24277d(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
sete %r14b
jne 0x1433a2
testl %ebp, %ebp
jne 0x14332e
testq %r12, %r12
setne %bpl
movq %r15, %rdi
callq 0x15c2d3
andb %r14b, %bpl
cmpb $0x1, %bpl
jne 0x1433ee
movq $-0x1, %r14
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %r15
incq %r14
cmpq 0x48(%rsp), %r14
jae 0x1433ff
movq %r12, %rdi
movl $0x30, %esi
callq 0x120ba5
movq 0x10(%rsp), %rax
testb %bpl, %bpl
jne 0x1433cb
jmp 0x143402
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %r15
jmp 0x143407
xorl %r13d, %r13d
movq 0x18(%rsp), %r14
testl %r13d, %r13d
je 0x1434a6
testl %r13d, %r13d
je 0x143539
movq 0x18(%rsp), %r14
cmpb $0x0, 0xb9(%r15)
movq %rax, 0x10(%rsp)
je 0x143436
movq 0x50(%r15), %r14
jmp 0x143626
movl 0xa8(%r15), %ebp
testl %ebp, %ebp
je 0x143612
movq 0x20(%r14), %r15
xorl %r14d, %r14d
movl $0x1, %r12d
xorl %r13d, %r13d
addq %r14, %r14
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
callq 0x304ab4
cmpl $0x1, %eax
jne 0x143474
movzbl 0x20(%rsp), %eax
orq %rax, %r14
jmp 0x14348b
movq %rbx, %rdi
leaq 0x242687(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
jne 0x143618
leal 0x1(%r12), %eax
cmpl %ebp, %r12d
movl %eax, %r12d
jb 0x143455
jmp 0x143618
cmpq $0x0, 0x48(%r14)
setne %al
movq 0x30(%rsp), %rcx
notb %cl
testb %al, %cl
jne 0x1437b1
movl 0xb0(%r15), %ebp
testl %ebp, %ebp
je 0x1438b4
movq 0x20(%r14), %r15
xorl %r14d, %r14d
movl $0x1, %r12d
xorl %r13d, %r13d
addq %r14, %r14
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
callq 0x304ab4
cmpl $0x1, %eax
jne 0x1434fb
movzbl 0x20(%rsp), %eax
orq %rax, %r14
jmp 0x143512
movq %rbx, %rdi
leaq 0x242600(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testl %r13d, %r13d
jne 0x143524
leal 0x1(%r12), %eax
cmpl %ebp, %r12d
movl %eax, %r12d
jb 0x1434dc
testl %r13d, %r13d
sete %al
movq 0x38(%rsp), %r12
movq 0x28(%rsp), %r15
jmp 0x1438b9
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x48(%rax)
sete %al
orb 0x30(%rsp), %al
movq 0x10(%rsp), %rax
jne 0x143584
cmpb $0x1, 0xbe(%r15)
jne 0x14356d
cmpq 0xa0(%r15), %rax
jge 0x143a6d
cmpb $0x1, 0xbd(%r15)
jne 0x143584
cmpq 0xa0(%r15), %rax
jle 0x143a72
movq %rax, 0xa0(%r15)
cmpb $0x1, 0xba(%r15)
jne 0x1435ef
cmpb $0x1, 0xb9(%r15)
jne 0x1435ef
movq 0x50(%r15), %r14
movl $0xa, %esi
movq 0x10(%rsp), %rdi
callq 0x143cfb
movl %eax, %eax
movq %r14, %rcx
subq %rax, %rcx
movq %rcx, 0x48(%rsp)
testq %r12, %r12
je 0x1435ef
cmpq %rax, %r14
je 0x1435ef
movl $0x1, %r14d
movq %r12, %rdi
movl $0x30, %esi
callq 0x120ba5
testq %r12, %r12
je 0x1435ef
leaq 0x1(%r14), %rax
cmpq 0x48(%rsp), %r14
movq %rax, %r14
jb 0x1435cf
testq %r12, %r12
je 0x1438a7
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x120af4
xorl %r13d, %r13d
movq 0x18(%rsp), %r14
jmp 0x143779
xorl %r14d, %r14d
xorl %r13d, %r13d
movq 0x28(%rsp), %r15
addq 0x58(%r15), %r14
movq 0x38(%rsp), %r12
testl %r13d, %r13d
sete %al
jne 0x143767
testq %r14, %r14
je 0x143767
xorl %ebp, %ebp
cmpq 0x50(%r15), %rbp
jae 0x143671
movq 0x18(%r15), %rdi
movq %rbp, %rsi
callq 0xd94c7
testb %al, %al
je 0x143671
testq %r12, %r12
je 0x143753
movq 0x40(%r15), %rax
movsbl (%rax,%rbp), %esi
movq %r12, %rdi
callq 0x120ba5
jmp 0x143753
movq (%r15), %rax
movq (%rax,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x15c249
movq %rax, %r15
testl %r13d, %r13d
sete %al
jne 0x14371c
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xf(%rsp), %rsi
callq 0x304ab4
cmpl $0x1, %eax
jne 0x1436d6
movzbl 0xf(%rsp), %esi
movq %r15, %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rcx
callq 0x15c27f
cmpl $-0x1, %eax
je 0x1436ef
movl %eax, %r12d
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x14370b
movq %rbx, %rdi
leaq 0x242425(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x14370b
movq %rbx, %rdi
callq 0x101a9a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %al, %al
je 0x143a4a
testl %r13d, %r13d
sete %al
jne 0x14371c
testl %r12d, %r12d
jne 0x143695
movq 0x38(%rsp), %r12
testq %r12, %r12
je 0x143746
testb %al, %al
je 0x143746
movq 0x10(%rsp), %rax
cmpq $0x100, %rax            # imm = 0x100
jge 0x143a4f
movsbl %al, %esi
movq %r12, %rdi
callq 0x120ba5
movq %r15, %rdi
callq 0x15c2d3
movq 0x28(%rsp), %r15
testl %r13d, %r13d
sete %al
jne 0x143767
incq %rbp
cmpq %r14, %rbp
jb 0x14363d
testq %r12, %r12
je 0x1438aa
testb %al, %al
movq 0x18(%rsp), %r14
je 0x143789
movsbl 0xb8(%r15), %esi
movq %r12, %rdi
callq 0x120ba5
testl %r13d, %r13d
sete %bpl
jne 0x14397c
movq 0x58(%rsp), %rax
incq %rax
movq 0x50(%rsp), %rcx
cmpq %rcx, %rax
jb 0x143299
jmp 0x14397c
cmpb $0x1, 0xc0(%r15)
jne 0x1437e9
cmpb $0x0, 0xbc(%r15)
je 0x1437e9
xorl %r13d, %r13d
cmpb $0x0, 0xc1(%r15)
jne 0x1438e1
movq 0xa0(%r15), %rax
subq 0x98(%r15), %rax
jmp 0x143953
movl 0xac(%r15), %ebp
testl %ebp, %ebp
je 0x1438de
cmpb $0x1, 0xc2(%r15)
jne 0x1438e5
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x15c249
movq %rax, %r15
xorl %r13d, %r13d
movl $0x1, %ebp
movq 0x20(%r14), %rdi
leaq 0xf(%rsp), %rsi
callq 0x304ab4
cmpl $0x1, %eax
jne 0x143858
movzbl 0xf(%rsp), %esi
movq %r15, %rdi
leaq 0x40(%rsp), %rdx
movq %rbx, %rcx
callq 0x15c27f
cmpl $-0x1, %eax
je 0x143871
movl %eax, %ebp
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x14388c
movq %rbx, %rdi
leaq 0x2422a3(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x14388c
movq %rbx, %rdi
callq 0x101a9a
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x143a5e
testl %r13d, %r13d
jne 0x143895
testl %ebp, %ebp
jne 0x14381d
movq %r15, %rdi
callq 0x15c2d3
movq 0x10(%rsp), %rax
jmp 0x14394e
xorl %r13d, %r13d
movq 0x18(%rsp), %r14
jmp 0x143789
movb $0x1, %al
xorl %r14d, %r14d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testb %al, %al
movq 0x10(%rsp), %rax
je 0x143410
addq 0x98(%r15), %r14
xorl %r13d, %r13d
movq %r14, %rax
jmp 0x143410
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x143953
movq 0x20(%r14), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
movl $0x1, %r14d
xorl %r13d, %r13d
addq %rax, %rax
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %r15
callq 0x304ab4
cmpl $0x1, %eax
jne 0x14391d
movzbl 0x20(%rsp), %eax
orq %rax, %r15
jmp 0x143934
movq %rbx, %rdi
leaq 0x2421de(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r15, %rax
testl %r13d, %r13d
jne 0x14394e
movq %rax, %rcx
leal 0x1(%r14), %eax
cmpl %ebp, %r14d
movl %eax, %r14d
movq %rcx, %rax
jb 0x1438f9
movq 0x28(%rsp), %r15
cmpb $0x1, 0xc1(%r15)
jne 0x143970
addq 0xa0(%r15), %rax
addq 0x90(%r15), %rax
jmp 0x143410
addq 0x98(%r15), %rax
jmp 0x143410
testq %r12, %r12
je 0x1439a2
movq %r12, %rdi
callq 0x120d4c
testq %rax, %rax
je 0x1439a2
movq %r12, %rdi
callq 0x120d4c
leaq -0x1(%rax), %rsi
movq %r12, %rdi
callq 0x120d59
testb %bpl, %bpl
je 0x1439ad
incq 0x48(%r14)
jmp 0x1439bd
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
je 0x143a68
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
movl 0x68(%r14), %r14d
testl %r14d, %r14d
je 0x143a36
movq 0x20(%rax), %r15
movl $0x1, %ebp
xorl %ecx, %ecx
xorl %r13d, %r13d
addq %rcx, %rcx
movq %r15, %rdi
leaq 0x20(%rsp), %rsi
movq %rcx, %r12
callq 0x304ab4
cmpl $0x1, %eax
jne 0x143a0b
movzbl 0x20(%rsp), %eax
orq %rax, %r12
jmp 0x143a22
movq %rbx, %rdi
leaq 0x2420f0(%rip), %rsi    # 0x385b05
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r12, %rcx
testl %r13d, %r13d
jne 0x143a3b
leal 0x1(%rbp), %eax
cmpl %r14d, %ebp
movl %eax, %ebp
jb 0x1439e9
jmp 0x143a3b
xorl %ecx, %ecx
xorl %r13d, %r13d
movq 0x18(%rsp), %r14
movq 0x38(%rsp), %r12
jmp 0x143269
callq 0x414f7
callq 0x41530
callq 0x41614
callq 0x41485
callq 0x414be
callq 0x4164d
callq 0x415db
callq 0x41569
callq 0x415a2