// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/huffcode.c
// Function: test_mem
int test_mem(GtError *err)
{
  unsigned char bits = (unsigned char) (sizeof (GtBitsequence) * 8),
                bits_remain = bits;
  unsigned int code_len;
  int decoder_stat = 1,
      had_err = 0;
  GtUword const max_num = (GtUword) (1000 * gt_rand_0_to_1() + 100),
                      dist_size = (GtUword) (10 + 10 * gt_rand_0_to_1()),
                      step_size = (GtUword) (10 + 5 * gt_rand_0_to_1());
  GtUword range = 0,
                idx, idx_j;
  uint64_t total_bits = 0;
  GtUint64 *distribution = gt_malloc(sizeof (*distribution) *
                                     dist_size);
  GtBitsequence buffer = 0,
                code;
  GtArray *numbers = gt_array_new(sizeof (unsigned char));
  GtArray *encoded = gt_array_new(sizeof (GtUword));
  GtArray *codes = gt_array_new(sizeof (GtBitsequence));
  GtHuffman *huff = NULL;
  GtHuffmanDecoder *huffdec = NULL;
  HuffmanUnitTestMeminfo *meminfo = gt_malloc(sizeof (*meminfo));

  for (idx = 0; idx < dist_size; idx++) {
    distribution[idx] = 0;
  }

  /*produce numbers with more numbers 0-(dist_size/2) */
  while (gt_array_size(numbers) < max_num) {
    unsigned char x;
    if (range) {
      x = (unsigned char) ((dist_size >> 1) * gt_rand_0_to_1());
      range = 0;
    }
    else {
      x = (unsigned char) (dist_size * gt_rand_0_to_1());
      range = 1UL;
    }
    gt_array_add(numbers, x);
  }

  gt_ensure(gt_array_size(numbers) == max_num);

  /*calculate distribution*/
  for (idx = 0; !had_err && idx < max_num; idx++) {
    unsigned char *c = (unsigned char*) gt_array_get(numbers, idx);
    distribution[*c]++;
  }

  if (!had_err) {
    uint64_t chars;
    huff = gt_huffman_new(distribution, unit_test_distr_func, dist_size);
    gt_ensure(huff);
    gt_huffman_size(huff, &total_bits, &chars);
    gt_ensure(chars == (uint64_t) max_num);
  }

  for (idx = 0; !had_err && idx < max_num; idx++) {
    gt_huffman_encode(huff,
                      *(unsigned char*) gt_array_get(numbers, idx),
                      &code,
                      &code_len);
    if (bits_remain < code_len) {
      unsigned char overhang = code_len - bits_remain;
      buffer |= code >> overhang;
      gt_array_add(codes, buffer);
      buffer = 0;
      bits_remain = bits - overhang;
    }
    else
      bits_remain -= code_len;
    buffer |= code << bits_remain;
  }
  if (!had_err)
    gt_array_add(codes, buffer);

  gt_ensure(
            total_bits == (uint64_t) gt_array_size(codes) *
                          gt_array_elem_size(codes) * 8 - bits_remain);

  if (!had_err) {
    meminfo->chunk = 0;
    meminfo->padding = bits_remain;
    meminfo->size = gt_array_size(codes) / 4;
    meminfo->lastchunk_size = gt_array_size(codes) % meminfo->size;
    if (meminfo->lastchunk_size) {
      meminfo->chunks = gt_array_size(codes) / meminfo->size + 1;
    }
    else {
      meminfo->chunks = gt_array_size(codes) / meminfo->size;
      meminfo->lastchunk_size = meminfo->size;
    }
    meminfo->data = gt_array_get_space(codes);

    huffdec = gt_huffman_decoder_new(huff,
                                     gt_array_get_space(codes),
                                     gt_array_size(codes),
                                     0, /*offset*/
                                     bits_remain);
    gt_ensure(huffdec);
  }

  for (idx = 0; !had_err && idx < max_num; idx += step_size) {
    gt_array_reset(encoded);
    gt_ensure(decoder_stat == 1);
    decoder_stat = gt_huffman_decoder_next(huffdec,
                                           encoded,
                                           (GtUword) step_size,
                                           err);
    if (decoder_stat == 1)
      gt_ensure(gt_array_size(encoded) == (GtUword) step_size);
    else
      gt_ensure(decoder_stat == 0);

    gt_ensure(decoder_stat != -1);
    if (!had_err) {
      for (idx_j = 0; !had_err && idx_j < gt_array_size(encoded); idx_j++) {
        GtUword ist = *(GtUword*) gt_array_get(encoded, idx_j);
        unsigned char soll =
          *(unsigned char*)gt_array_get(numbers, idx + idx_j);
        gt_ensure((ist == soll));
      }
    }
  }

  gt_ensure(idx >= max_num);
  if (!had_err)
    decoder_stat = gt_huffman_decoder_next(huffdec,
                                           encoded,
                                           1UL,
                                           err);
  gt_ensure(decoder_stat == 0);

  if (!had_err) {
    gt_huffman_decoder_delete(huffdec);

    huffdec = gt_huffman_decoder_new_from_memory(huff,
                                                 huffman_unit_get_next_block,
                                                 meminfo,
                                                 err);
    gt_ensure(huffdec);
  }

  decoder_stat = 1;
  for (idx = 0; !had_err && idx < max_num; idx += step_size) {
    gt_array_reset(encoded);
    gt_ensure(decoder_stat == 1);
    decoder_stat = gt_huffman_decoder_next(huffdec,
                                           encoded,
                                           step_size,
                                           err);
    if (decoder_stat == 1)
      gt_ensure(gt_array_size(encoded) == step_size);
    else
      gt_ensure(decoder_stat == 0);

    gt_ensure(decoder_stat != -1);
    if (!had_err) {
      for (idx_j = 0; !had_err && idx_j < gt_array_size(encoded); idx_j++) {
        GtUword ist = *(GtUword*)gt_array_get(encoded, idx_j);
        unsigned char soll =
          *(unsigned char*)gt_array_get(numbers, idx + idx_j);
        gt_ensure((ist == soll));
      }
    }
  }

  gt_ensure(idx >= max_num);
  if (!had_err)
    decoder_stat = gt_huffman_decoder_next(huffdec,
                                           encoded,
                                           1UL,
                                           err);
  gt_ensure(decoder_stat == 0);

  gt_huffman_decoder_delete(huffdec);
  gt_free(meminfo);
  gt_huffman_delete(huff);
  gt_array_delete(numbers);
  gt_array_delete(codes);
  gt_array_delete(encoded);
  gt_free(distribution);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, 0x40(%rsp)
callq 0x10af04
mulsd 0x231364(%rip), %xmm0   # 0x38d670
addsd 0x1f64dc(%rip), %xmm0   # 0x3527f0
cvttsd2si %xmm0, %rax
subsd 0x1f49ff(%rip), %xmm0   # 0x350d20
cvttsd2si %xmm0, %rcx
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x8(%rsp)
callq 0x10af04
movsd 0x201c93(%rip), %xmm1   # 0x35dfd8
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1f49bf(%rip), %xmm0   # 0x350d20
cvttsd2si %xmm0, %rbx
andq %rcx, %rbx
orq %rax, %rbx
callq 0x10af04
movapd %xmm0, 0x20(%rsp)
xorl %r15d, %r15d
movq %r15, 0x80(%rsp)
leaq (,%rbx,8), %r14
leaq 0x231319(%rip), %r13    # 0x38d6aa
movq %r14, %rdi
movq %r13, %rsi
movl $0x312, %edx            # imm = 0x312
callq 0x1092b2
movq %rax, %r12
movq %r15, 0x68(%rsp)
movl $0x1, %edi
callq 0xd46fc
movq %rax, %r15
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x48(%rsp)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x70(%rsp)
movl $0x30, %edi
movq %r13, %rsi
movl $0x31a, %edx            # imm = 0x31A
callq 0x1092b2
movq %rax, 0x78(%rsp)
testq %rbx, %rbx
je 0x15c3fd
movq %r12, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x173a0
movq %r15, %rdi
callq 0xd4a9a
movq 0x8(%rsp), %rbp
cmpq %rbp, %rax
jae 0x15c473
xorl %r14d, %r14d
leaq 0x50(%rsp), %r13
callq 0x10af04
movq %rbx, %rax
movl %r14d, %ecx
shrq %cl, %rax
movq %rax, %xmm1
punpckldq 0x1f44ae(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1f44b6(%rip), %xmm1   # 0x3508f0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
xorq $0x1, %r14
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movb %al, 0x50(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0xd49ce
movq %r15, %rdi
callq 0xd4a9a
cmpq %rbp, %rax
jb 0x15c417
movapd 0x20(%rsp), %xmm0
mulsd 0x1f4887(%rip), %xmm0   # 0x350d08
movapd %xmm0, 0x20(%rsp)
movq %r15, 0x60(%rsp)
movq %r15, %rdi
callq 0xd4a9a
movq %rax, %r14
cmpq %rbp, %rax
movq 0x40(%rsp), %r15
je 0x15c4cd
leaq 0x20b092(%rip), %rsi    # 0x36753a
leaq 0x231506(%rip), %rdx    # 0x38d9b5
leaq 0x231521(%rip), %rcx    # 0x38d9d7
leaq 0x2311ed(%rip), %r8     # 0x38d6aa
movq %r15, %rdi
movl $0x32e, %r9d            # imm = 0x32E
xorl %eax, %eax
callq 0x1019cf
movapd 0x20(%rsp), %xmm0
addsd 0x201afd(%rip), %xmm0   # 0x35dfd8
movapd %xmm0, 0x20(%rsp)
movq 0x8(%rsp), %rbp
cmpq %rbp, %r14
setne %al
testq %rbp, %rbp
sete %cl
orb %al, %cl
jne 0x15c51a
xorl %r13d, %r13d
movq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0xd47ba
movzbl (%rax), %eax
incq (%r12,%rax,8)
cmpq %rbp, %r14
jne 0x15c51a
incq %r13
cmpq %rbp, %r13
jb 0x15c4f9
movapd 0x20(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x38(%rsp)
subsd 0x1f47ee(%rip), %xmm0   # 0x350d20
cmpq %rbp, %r14
movq %rbp, %r14
movq %r12, 0x90(%rsp)
jne 0x15c5b7
movapd %xmm0, 0x20(%rsp)
leaq -0x26b(%rip), %rsi      # 0x15c2e4
movq %r12, %rdi
movq %rbx, %rdx
callq 0x15b8c0
movq %rax, %r13
testq %rax, %rax
je 0x15c5c5
leaq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rdx
callq 0x15bd0a
movb $0x1, %r12b
cmpq %r14, (%rbx)
je 0x15c609
leaq 0x20afad(%rip), %rsi    # 0x36753a
leaq 0x231451(%rip), %rdx    # 0x38d9e5
leaq 0x23143c(%rip), %rcx    # 0x38d9d7
leaq 0x231108(%rip), %r8     # 0x38d6aa
xorl %r12d, %r12d
movq %r15, %rdi
movl $0x33b, %r9d            # imm = 0x33B
xorl %eax, %eax
callq 0x1019cf
jmp 0x15c609
movq $0x0, 0x58(%rsp)
xorl %r12d, %r12d
jmp 0x15c614
leaq 0x20af6e(%rip), %rsi    # 0x36753a
leaq 0x23140d(%rip), %rdx    # 0x38d9e0
leaq 0x2313fd(%rip), %rcx    # 0x38d9d7
leaq 0x2310c9(%rip), %r8     # 0x38d6aa
xorl %r12d, %r12d
movq %r15, %rdi
movl $0x339, %r9d            # imm = 0x339
xorl %eax, %eax
callq 0x1019cf
leaq 0x80(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r13, %rdi
callq 0x15bd0a
movq %r13, 0x58(%rsp)
movapd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rcx
sarq $0x3f, %rcx
cvttsd2si %xmm0, %r13
testq %r14, %r14
setne %al
andb %r12b, %al
movl $0x40, %ebp
cmpb $0x1, %al
jne 0x15c6ec
movq %rcx, 0x10(%rsp)
movq %r13, 0x20(%rsp)
movb $0x40, %bpl
xorl %ebx, %ebx
leaq 0x8c(%rsp), %r13
movq 0x60(%rsp), %rdi
movq %rbx, %rsi
callq 0xd47ba
movzbl (%rax), %esi
movq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %r13, %rcx
callq 0x15bdb3
movzbl %bpl, %eax
movl 0x8c(%rsp), %r14d
cmpl %eax, %r14d
jbe 0x15c6b5
subb %bpl, %r14b
movq 0x50(%rsp), %rax
movl %r14d, %ecx
shrq %cl, %rax
orq %rax, 0x68(%rsp)
movl $0x8, %edx
movq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xd49ce
movq $0x0, 0x68(%rsp)
movb $0x40, %bpl
subb %r14b, %bpl
movq 0x50(%rsp), %rax
movl %ebp, %ecx
shlq %cl, %rax
orq %rax, 0x68(%rsp)
incq %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %rbx
setb %al
testb %al, %r12b
jne 0x15c64f
movzbl %bpl, %ebp
movq 0x20(%rsp), %r13
movq 0x10(%rsp), %rcx
andq %rcx, %r13
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movb $0x1, %bl
testb %r12b, %r12b
je 0x15c7a1
leaq 0x68(%rsp), %rsi
movl $0x8, %edx
movq 0x70(%rsp), %r12
movq %r12, %rdi
callq 0xd49ce
movq 0x80(%rsp), %r15
movq %r12, %rdi
callq 0xd4a9a
movq %rax, %r14
movq %r12, %rdi
callq 0xd4aa7
imulq %r14, %rax
shlq $0x3, %rax
subq %rbp, %rax
cmpq %rax, %r15
jne 0x15c7b4
movq 0x78(%rsp), %r15
movq $0x0, 0x8(%r15)
movq %rbp, 0x28(%r15)
movq %r12, %rdi
callq 0xd4a9a
shrq $0x2, %rax
movq %rax, 0x18(%r15)
movq %r12, %rdi
callq 0xd4a9a
xorl %edx, %edx
divq 0x18(%r15)
movq %rdx, %r14
movq %rdx, 0x20(%r15)
movq %r12, %rdi
callq 0xd4a9a
movq %r15, %rsi
movq 0x18(%r15), %rcx
xorl %edx, %edx
divq %rcx
testq %r14, %r14
movq 0x40(%rsp), %r15
je 0x15c7ec
incq %rax
movq %rax, 0x10(%rsi)
jmp 0x15c7f4
movq $0x0, 0x10(%rsp)
movq 0x48(%rsp), %rbp
jmp 0x15c87f
leaq 0x20ad7f(%rip), %rsi    # 0x36753a
leaq 0x23123f(%rip), %rdx    # 0x38da01
leaq 0x23120e(%rip), %rcx    # 0x38d9d7
leaq 0x230eda(%rip), %r8     # 0x38d6aa
movq $0x0, 0x10(%rsp)
movq 0x40(%rsp), %r15
movq %r15, %rdi
movl $0x353, %r9d            # imm = 0x353
jmp 0x15c86e
movq %rax, 0x10(%rsi)
movq %rcx, 0x20(%rsi)
movq %rsi, %r14
movq %r12, %rdi
callq 0xd49a9
movq %rax, (%r14)
movq %r12, %rdi
callq 0xd49a9
movq %rax, %r14
movq %r12, %rdi
callq 0xd4a9a
movq 0x58(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %rbp, %r8
callq 0x15be00
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x15c840
xorl %ebx, %ebx
movl $0x0, 0x20(%rsp)
jmp 0x15c875
leaq 0x20acf3(%rip), %rsi    # 0x36753a
leaq 0x23120f(%rip), %rdx    # 0x38da5d
leaq 0x231182(%rip), %rcx    # 0x38d9d7
leaq 0x230e4e(%rip), %r8     # 0x38d6aa
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl $0x368, %r9d            # imm = 0x368
xorl %eax, %eax
callq 0x1019cf
movq 0x48(%rsp), %rbp
movq 0x8(%rsp), %r14
orq %r13, 0x38(%rsp)
testq %r14, %r14
sete %al
orb %bl, %al
je 0x15c89e
movl $0x1, 0x1c(%rsp)
xorl %r12d, %r12d
jmp 0x15ca78
movl $0x1, 0x1c(%rsp)
xorl %r12d, %r12d
movq %rbp, %rdi
callq 0xd4ad3
cmpl $0x1, 0x1c(%rsp)
movl 0x20(%rsp), %ebx
movq %r15, %r13
je 0x15c8f0
movq %r13, %rdi
leaq 0x20ac71(%rip), %rsi    # 0x36753a
leaq 0x231195(%rip), %rdx    # 0x38da65
leaq 0x231100(%rip), %rcx    # 0x38d9d7
leaq 0x230dcc(%rip), %r8     # 0x38d6aa
movl $0x36d, %r9d            # imm = 0x36D
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq 0x38(%rsp), %rdx
movq %r13, %rcx
callq 0x15bf7a
cmpl $0x1, %eax
jne 0x15c95a
testl %ebx, %ebx
jne 0x15c992
movq %rbp, %rdi
movl %eax, %r13d
callq 0xd4a9a
xorl %ebx, %ebx
cmpq 0x38(%rsp), %rax
movl %r13d, %eax
je 0x15c997
movq %r15, %rdi
leaq 0x20ac07(%rip), %rsi    # 0x36753a
leaq 0x23113d(%rip), %rdx    # 0x38da77
leaq 0x231096(%rip), %rcx    # 0x38d9d7
leaq 0x230d62(%rip), %r8     # 0x38d6aa
movl $0x373, %r9d            # imm = 0x373
xorl %eax, %eax
callq 0x1019cf
movl %r13d, %eax
jmp 0x15c992
testl %ebx, %ebx
jne 0x15c997
testl %eax, %eax
je 0x15c997
movq %r15, %rdi
leaq 0x20abce(%rip), %rsi    # 0x36753a
leaq 0x231132(%rip), %rdx    # 0x38daa5
leaq 0x23105d(%rip), %rcx    # 0x38d9d7
leaq 0x230d29(%rip), %r8     # 0x38d6aa
movl $0x375, %r9d            # imm = 0x375
movl %eax, %ebx
xorl %eax, %eax
callq 0x1019cf
movl %ebx, %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %eax, 0x1c(%rsp)
notl %eax
orl %ebx, %eax
jne 0x15c9d2
movq %r15, %rdi
leaq 0x20ab8f(%rip), %rsi    # 0x36753a
leaq 0x231105(%rip), %rdx    # 0x38dab7
leaq 0x23101e(%rip), %rcx    # 0x38d9d7
leaq 0x230cea(%rip), %r8     # 0x38d6aa
movl $0x377, %r9d            # imm = 0x377
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movb $0x1, %bl
testl %eax, %eax
jne 0x15ca66
xorl %r14d, %r14d
movq %rbp, %rdi
callq 0xd4a9a
cmpq %rax, %r14
setb %bl
jae 0x15ca59
movq %rbp, %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rbp
leaq (%r12,%r14), %rsi
movq 0x60(%rsp), %rdi
callq 0xd47ba
movzbl (%rax), %r13d
cmpq %r13, %rbp
je 0x15ca4a
movq %r15, %rdi
leaq 0x20ab12(%rip), %rsi    # 0x36753a
leaq 0x23109b(%rip), %rdx    # 0x38daca
leaq 0x230fa1(%rip), %rcx    # 0x38d9d7
leaq 0x230c6d(%rip), %r8     # 0x38d6aa
movl $0x37d, %r9d            # imm = 0x37D
xorl %eax, %eax
callq 0x1019cf
incq %r14
cmpq %r13, %rbp
movq 0x48(%rsp), %rbp
je 0x15c9e9
jmp 0x15ca61
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %r14
addq 0x38(%rsp), %r12
testb %bl, %bl
jne 0x15ca78
cmpq %r14, %r12
jb 0x15c8a9
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movb $0x1, %r13b
testb %bl, %bl
je 0x15ca8b
movl 0x1c(%rsp), %eax
jmp 0x15cad8
xorl %r13d, %r13d
movl $0x0, %r14d
cmpq 0x8(%rsp), %r12
movl 0x1c(%rsp), %eax
jae 0x15cad8
leaq 0x20aa94(%rip), %rsi    # 0x36753a
leaq 0x23102b(%rip), %rdx    # 0x38dad8
leaq 0x230f23(%rip), %rcx    # 0x38d9d7
leaq 0x230bef(%rip), %r8     # 0x38d6aa
movq %r15, %rdi
movl $0x382, %r9d            # imm = 0x382
xorl %eax, %eax
callq 0x1019cf
movl 0x1c(%rsp), %eax
movb $0x1, %r13b
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %r13b, %r13b
jne 0x15caf2
movl $0x1, %edx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rcx
callq 0x15bf7a
testl %eax, %eax
sete %al
orb %al, %r13b
jne 0x15cb2e
leaq 0x20aa37(%rip), %rsi    # 0x36753a
leaq 0x230f9b(%rip), %rdx    # 0x38daa5
leaq 0x230ec6(%rip), %rcx    # 0x38d9d7
leaq 0x230b92(%rip), %r8     # 0x38d6aa
movq %r15, %rdi
movl $0x388, %r9d            # imm = 0x388
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movb $0x1, %bl
testl %r14d, %r14d
je 0x15cb42
movq 0x8(%rsp), %r14
jmp 0x15cbbc
leaq 0x230b61(%rip), %rsi    # 0x38d6aa
movq 0x10(%rsp), %rdi
movl $0x256, %edx            # imm = 0x256
callq 0x109670
leaq 0x37b(%rip), %rsi       # 0x15ceda
movq 0x58(%rsp), %rdi
movq 0x78(%rsp), %rdx
movq %r15, %rcx
callq 0x15be73
movq %rax, 0x10(%rsp)
testq %rax, %rax
movq 0x8(%rsp), %r14
je 0x15cb87
xorl %ebx, %ebx
xorl %r13d, %r13d
jmp 0x15cbbc
leaq 0x20a9ac(%rip), %rsi    # 0x36753a
leaq 0x230ec8(%rip), %rdx    # 0x38da5d
leaq 0x230e3b(%rip), %rcx    # 0x38d9d7
leaq 0x230b07(%rip), %r8     # 0x38d6aa
movq $0x0, 0x10(%rsp)
movq %r15, %rdi
movl $0x391, %r9d            # imm = 0x391
xorl %eax, %eax
callq 0x1019cf
testq %r14, %r14
sete %al
orb %bl, %al
je 0x15cbd6
movl $0x1, 0x20(%rsp)
xorl %r12d, %r12d
jmp 0x15cd9b
movl $0x1, 0x20(%rsp)
xorl %r12d, %r12d
movq %rbp, %rdi
callq 0xd4ad3
cmpl $0x1, 0x20(%rsp)
je 0x15cc22
movq %r15, %rdi
leaq 0x20a940(%rip), %rsi    # 0x36753a
leaq 0x230e64(%rip), %rdx    # 0x38da65
leaq 0x230dcf(%rip), %rcx    # 0x38d9d7
leaq 0x230a9b(%rip), %r8     # 0x38d6aa
movl $0x397, %r9d            # imm = 0x397
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq 0x38(%rsp), %rdx
movq %r15, %rcx
callq 0x15bf7a
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x15cc7c
testl %r13d, %r13d
jne 0x15ccb1
movq %rbp, %rdi
callq 0xd4a9a
xorl %r13d, %r13d
cmpq 0x38(%rsp), %rax
je 0x15ccb7
movq %r15, %rdi
leaq 0x20a8db(%rip), %rsi    # 0x36753a
leaq 0x230e81(%rip), %rdx    # 0x38dae7
leaq 0x230d6a(%rip), %rcx    # 0x38d9d7
leaq 0x230a36(%rip), %r8     # 0x38d6aa
movl $0x39d, %r9d            # imm = 0x39D
jmp 0x15ccaa
testl %r13d, %r13d
jne 0x15ccb7
testl %ebx, %ebx
je 0x15ccb7
movq %r15, %rdi
leaq 0x20a8ab(%rip), %rsi    # 0x36753a
leaq 0x230e0f(%rip), %rdx    # 0x38daa5
leaq 0x230d3a(%rip), %rcx    # 0x38d9d7
leaq 0x230a06(%rip), %r8     # 0x38d6aa
movl $0x39f, %r9d            # imm = 0x39F
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %ebx, 0x20(%rsp)
notl %ebx
orl %r13d, %ebx
jne 0x15ccf4
movq %r15, %rdi
leaq 0x20a86e(%rip), %rsi    # 0x36753a
leaq 0x230de4(%rip), %rdx    # 0x38dab7
leaq 0x230cfd(%rip), %rcx    # 0x38d9d7
leaq 0x2309c9(%rip), %r8     # 0x38d6aa
movl $0x3a1, %r9d            # imm = 0x3A1
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl %r13d, %eax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movb $0x1, %bl
testl %eax, %eax
jne 0x15cd89
xorl %r14d, %r14d
movq %rbp, %rdi
callq 0xd4a9a
cmpq %rax, %r14
setb %bl
jae 0x15cd7c
movq %rbp, %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rbp
leaq (%r12,%r14), %rsi
movq 0x60(%rsp), %rdi
callq 0xd47ba
movzbl (%rax), %r15d
cmpq %r15, %rbp
je 0x15cd6d
movq 0x40(%rsp), %rdi
leaq 0x20a7ef(%rip), %rsi    # 0x36753a
leaq 0x230d78(%rip), %rdx    # 0x38daca
leaq 0x230c7e(%rip), %rcx    # 0x38d9d7
leaq 0x23094a(%rip), %r8     # 0x38d6aa
movl $0x3a7, %r9d            # imm = 0x3A7
xorl %eax, %eax
callq 0x1019cf
incq %r14
cmpq %r15, %rbp
movq 0x48(%rsp), %rbp
je 0x15cd0a
jmp 0x15cd7f
xorl %r13d, %r13d
movq 0x40(%rsp), %r15
movq 0x8(%rsp), %r14
addq 0x38(%rsp), %r12
testb %bl, %bl
jne 0x15cd9b
cmpq %r14, %r12
jb 0x15cbe1
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movb $0x1, %r14b
testb %bl, %bl
je 0x15cdb7
movq 0x90(%rsp), %rbx
movq 0x70(%rsp), %r12
jmp 0x15ce09
xorl %r14d, %r14d
movl $0x0, %r13d
cmpq 0x8(%rsp), %r12
movq 0x90(%rsp), %rbx
movq 0x70(%rsp), %r12
jae 0x15ce09
leaq 0x20a75f(%rip), %rsi    # 0x36753a
leaq 0x230cf6(%rip), %rdx    # 0x38dad8
leaq 0x230bee(%rip), %rcx    # 0x38d9d7
leaq 0x2308ba(%rip), %r8     # 0x38d6aa
movq %r15, %rdi
movl $0x3ac, %r9d            # imm = 0x3AC
xorl %eax, %eax
callq 0x1019cf
movb $0x1, %r14b
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
testb %r14b, %r14b
jne 0x15ce27
movl $0x1, %edx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
movq %r15, %rcx
callq 0x15bf7a
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
sete %al
orb %al, %r14b
jne 0x15ce66
leaq 0x20a6ff(%rip), %rsi    # 0x36753a
leaq 0x230c63(%rip), %rdx    # 0x38daa5
leaq 0x230b8e(%rip), %rcx    # 0x38d9d7
leaq 0x23085a(%rip), %r8     # 0x38d6aa
movq %r15, %rdi
movl $0x3b2, %r9d            # imm = 0x3B2
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
leaq 0x23083d(%rip), %r14    # 0x38d6aa
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x256, %edx            # imm = 0x256
callq 0x109670
movq 0x78(%rsp), %rdi
movq %r14, %rsi
movl $0x3b5, %edx            # imm = 0x3B5
callq 0x109670
movq 0x58(%rsp), %rdi
callq 0x15bc80
movq 0x60(%rsp), %rdi
callq 0xd4ef4
movq %r12, %rdi
callq 0xd4ef4
movq %rbp, %rdi
callq 0xd4ef4
movq %rbx, %rdi
movq %r14, %rsi
movl $0x3ba, %edx            # imm = 0x3BA
callq 0x109670
movl %r13d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq