// File: /workspace/github_c_makefile_star2_O2/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 $0x88, %rsp
movq %rdi, 0x8(%rsp)
callq 0x9576b
mulsd 0x23334c(%rip), %xmm0   # 0x3246b8
addsd 0x1f846c(%rip), %xmm0   # 0x2e97e0
movapd %xmm0, 0x30(%rsp)
callq 0x9576b
movsd 0x203c29(%rip), %xmm1   # 0x2f4fb0
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1f697d(%rip), %xmm0   # 0x2e7d20
cvttsd2si %xmm0, %rbx
andq %rcx, %rbx
orq %rax, %rbx
callq 0x9576b
mulsd 0x1f694d(%rip), %xmm0   # 0x2e7d08
addsd 0x203bed(%rip), %xmm0   # 0x2f4fb0
movapd %xmm0, 0x10(%rsp)
andq $0x0, 0x78(%rsp)
leaq (,%rbx,8), %rdi
leaq 0x233314(%rip), %r14    # 0x3246f2
movq %r14, %rsi
movl $0x312, %edx            # imm = 0x312
callq 0x93160
movq %rax, %r12
andq $0x0, 0x58(%rsp)
pushq $0x1
popq %rdi
callq 0x5809c
movq %rax, %rbp
pushq $0x8
popq %r13
movq %r13, %rdi
callq 0x5809c
movq %rax, %r15
movq %r13, %rdi
callq 0x5809c
movq %rax, 0x60(%rsp)
pushq $0x30
popq %rdi
movq %r14, %rsi
movl $0x31a, %edx            # imm = 0x31A
callq 0x93160
xorl %ecx, %ecx
cmpq %rcx, %rbx
je 0xf143c
andq $0x0, (%r12,%rcx,8)
incq %rcx
jmp 0xf142d
movq %rax, 0x68(%rsp)
movq %r12, 0x70(%rsp)
movapd 0x30(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x1f68c4(%rip), %xmm0   # 0x2e7d20
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x30(%rsp)
xorl %r13d, %r13d
movq %rbp, %r12
leaq 0x50(%rsp), %rbp
pushq $0x1
popq %r14
movq %r12, %rdi
callq 0x586a4
cmpq 0x30(%rsp), %rax
jae 0xf14dd
callq 0x9576b
movq %rbx, %rax
movl %r13d, %ecx
shrq %cl, %rax
movq %rax, %xmm1
punpckldq 0x1f6437(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1f643f(%rip), %xmm1   # 0x2e78f0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
xorq $0x1, %r13
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movb %al, 0x50(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x5851d
jmp 0xf147f
movapd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x28(%rsp)
subsd 0x1f682b(%rip), %xmm0   # 0x2e7d20
sarq $0x3f, %rax
cvttsd2si %xmm0, %r13
andq %rax, %r13
movq %r12, %rdi
callq 0x586a4
cmpq 0x30(%rsp), %rax
movq %r12, 0x48(%rsp)
jne 0xf153e
movq %r12, %rbp
xorl %r14d, %r14d
movq 0x70(%rsp), %r12
cmpq %r14, 0x30(%rsp)
je 0xf1583
movq %rbp, %rdi
movq %r14, %rsi
callq 0x581aa
movzbl (%rax), %eax
incq (%r12,%rax,8)
incq %r14
jmp 0xf1520
leaq 0x20cead(%rip), %rsi    # 0x2fe3f2
leaq 0x2334b1(%rip), %rdx    # 0x3249fd
leaq 0x2334cc(%rip), %rcx    # 0x324a1f
leaq 0x233198(%rip), %r8     # 0x3246f2
movq $0x0, 0x40(%rsp)
movq 0x8(%rsp), %rdi
movl $0x32e, %r9d            # imm = 0x32E
xorl %eax, %eax
callq 0x89dbb
movq $0x0, 0x10(%rsp)
jmp 0xf164a
leaq -0x246(%rip), %rsi      # 0xf1344
movq %r12, %rdi
movq %rbx, %rdx
callq 0xf04b4
testq %rax, %rax
movq %rax, 0x40(%rsp)
je 0xf1602
leaq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0xf0a86
movb $0x1, %al
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq %rax, (%rbx)
je 0xf164a
leaq 0x20ce22(%rip), %rsi    # 0x2fe3f2
leaq 0x233456(%rip), %rdx    # 0x324a2d
leaq 0x233441(%rip), %rcx    # 0x324a1f
leaq 0x23310d(%rip), %r8     # 0x3246f2
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl $0x33b, %r9d            # imm = 0x33B
xorl %eax, %eax
callq 0x89dbb
jmp 0xf164a
leaq 0x20cde9(%rip), %rsi    # 0x2fe3f2
leaq 0x233418(%rip), %rdx    # 0x324a28
leaq 0x233408(%rip), %rcx    # 0x324a1f
leaq 0x2330d4(%rip), %r8     # 0x3246f2
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movl $0x339, %r9d            # imm = 0x339
xorl %eax, %eax
callq 0x89dbb
leaq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdx
xorl %edi, %edi
callq 0xf0a86
orq %r13, 0x28(%rsp)
movb $0x40, %bpl
xorl %r13d, %r13d
cmpq 0x30(%rsp), %r13
setb %al
andb 0x10(%rsp), %al
movzbl %bpl, %ebx
cmpb $0x1, %al
jne 0xf16f0
movq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x581aa
movzbl (%rax), %esi
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rdx
leaq 0x84(%rsp), %rcx
callq 0xf0b83
movl 0x84(%rsp), %r14d
movq 0x50(%rsp), %r12
cmpl %ebx, %r14d
jbe 0xf16d3
subb %bpl, %r14b
movq %r12, %rax
movl %r14d, %ecx
shrq %cl, %rax
orq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x5851d
movb $0x40, %bpl
subb %r14b, %bpl
xorl %eax, %eax
jmp 0xf16db
subb %r14b, %bpl
movq 0x58(%rsp), %rax
movl %ebp, %ecx
shlq %cl, %r12
orq %rax, %r12
movq %r12, 0x58(%rsp)
incq %r13
jmp 0xf1655
pushq $-0x1
popq %rbp
cmpb $0x0, 0x10(%rsp)
je 0xf1789
leaq 0x58(%rsp), %rsi
pushq $0x8
popq %rdx
movq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x5851d
movq 0x78(%rsp), %r14
movq %r12, %rdi
callq 0x586a4
movq %rax, %r13
movq %r12, %rdi
callq 0x586b1
imulq %r13, %rax
shlq $0x3, %rax
subq %rbx, %rax
cmpq %rax, %r14
jne 0xf1790
movq 0x68(%rsp), %r14
andq $0x0, 0x8(%r14)
movq %rbx, 0x28(%r14)
movq %r12, %rdi
callq 0x586a4
shrq $0x2, %rax
movq %rax, 0x18(%r14)
movq %r12, %rdi
callq 0x586a4
xorl %edx, %edx
divq 0x18(%r14)
movq %rdx, %r13
movq %rdx, 0x20(%r14)
movq %r12, %rdi
callq 0x586a4
movq 0x18(%r14), %rcx
xorl %edx, %edx
divq %rcx
testq %r13, %r13
je 0xf17bb
incq %rax
jmp 0xf17bf
xorl %ebx, %ebx
jmp 0xf1831
leaq 0x20cc5b(%rip), %rsi    # 0x2fe3f2
leaq 0x2332ab(%rip), %rdx    # 0x324a49
leaq 0x23327a(%rip), %rcx    # 0x324a1f
leaq 0x232f46(%rip), %r8     # 0x3246f2
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
movl $0x353, %r9d            # imm = 0x353
jmp 0xf182a
movq %rcx, 0x20(%r14)
movq %rax, 0x10(%r14)
movq %r12, %rdi
callq 0x584c7
movq %rax, (%r14)
movq %r12, %rdi
callq 0x584c7
movq %rax, %r14
movq %r12, %rdi
callq 0x586a4
xorl %r13d, %r13d
movq 0x40(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0xf0c92
movq %rax, %rbx
testq %rax, %rax
jne 0xf1834
leaq 0x20cbea(%rip), %rsi    # 0x2fe3f2
leaq 0x233296(%rip), %rdx    # 0x324aa5
leaq 0x233209(%rip), %rcx    # 0x324a1f
leaq 0x232ed5(%rip), %r8     # 0x3246f2
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
movl $0x368, %r9d            # imm = 0x368
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %r13d
movq %rbx, 0x10(%rsp)
pushq $0x1
popq %rbp
xorl %r14d, %r14d
testl %r13d, %r13d
jne 0xf1a10
cmpq 0x30(%rsp), %r14
jae 0xf1a10
movq %r15, %rdi
callq 0x5876c
cmpl $0x1, %ebp
movq 0x8(%rsp), %r12
je 0xf1891
movq %r12, %rdi
leaq 0x20cb83(%rip), %rsi    # 0x2fe3f2
leaq 0x233237(%rip), %rdx    # 0x324aad
leaq 0x2331a2(%rip), %rcx    # 0x324a1f
leaq 0x232e6e(%rip), %r8     # 0x3246f2
movl $0x36d, %r9d            # imm = 0x36D
xorl %eax, %eax
callq 0x89dbb
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rcx
callq 0xf0ee7
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xf18f7
pushq $-0x1
popq %rax
movl %eax, %r13d
cmpl $0x1, %ebp
jne 0xf19ff
movq %r15, %rdi
callq 0x586a4
cmpq 0x28(%rsp), %rax
je 0xf192a
movq 0x8(%rsp), %rdi
leaq 0x20cb1b(%rip), %rsi    # 0x2fe3f2
leaq 0x2331e1(%rip), %rdx    # 0x324abf
leaq 0x23313a(%rip), %rcx    # 0x324a1f
leaq 0x232e06(%rip), %r8     # 0x3246f2
movl $0x373, %r9d            # imm = 0x373
jmp 0xf19f2
cmpl $0x1, %ebp
setne %al
testl %ebx, %ebx
sete %cl
orb %al, %cl
je 0xf19a6
movl %ebp, %eax
xorl $0x1, %eax
movl %ebx, %ecx
notl %ecx
orl %eax, %ecx
je 0xf19cd
pushq $-0x1
popq %rax
movl %eax, %r13d
cmpl $0x1, %ebp
jne 0xf19ff
xorl %ebp, %ebp
xorl %eax, %eax
movq 0x8(%rsp), %r13
testl %eax, %eax
jne 0xf19f9
movq %r15, %rdi
callq 0x586a4
cmpq %rax, %rbp
jae 0xf1a0b
movq %r15, %rdi
movq %rbp, %rsi
callq 0x581aa
movq (%rax), %r12
leaq (%r14,%rbp), %rsi
movq 0x48(%rsp), %rdi
callq 0x581aa
movzbl (%rax), %ecx
xorl %eax, %eax
cmpq %rcx, %r12
je 0xf19a1
movq %r13, %rdi
leaq 0x20ca76(%rip), %rsi    # 0x2fe3f2
leaq 0x23318f(%rip), %rdx    # 0x324b12
leaq 0x233095(%rip), %rcx    # 0x324a1f
leaq 0x232d61(%rip), %r8     # 0x3246f2
movl $0x37d, %r9d            # imm = 0x37D
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
incq %rbp
jmp 0xf1933
movq %r12, %rdi
leaq 0x20ca42(%rip), %rsi    # 0x2fe3f2
leaq 0x233136(%rip), %rdx    # 0x324aed
leaq 0x233061(%rip), %rcx    # 0x324a1f
leaq 0x232d2d(%rip), %r8     # 0x3246f2
movl $0x375, %r9d            # imm = 0x375
jmp 0xf19f2
movq %r12, %rdi
leaq 0x20ca1b(%rip), %rsi    # 0x2fe3f2
leaq 0x233121(%rip), %rdx    # 0x324aff
leaq 0x23303a(%rip), %rcx    # 0x324a1f
leaq 0x232d06(%rip), %r8     # 0x3246f2
movl $0x377, %r9d            # imm = 0x377
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
movl %eax, %r13d
addq 0x28(%rsp), %r14
movl %ebx, %ebp
jmp 0xf183f
xorl %r13d, %r13d
jmp 0xf19ff
pushq $-0x1
popq %rbp
testl %r13d, %r13d
jne 0xf1a97
cmpq 0x30(%rsp), %r14
jae 0xf1a48
leaq 0x20c9cc(%rip), %rsi    # 0x2fe3f2
leaq 0x2330f3(%rip), %rdx    # 0x324b20
leaq 0x232feb(%rip), %rcx    # 0x324a1f
leaq 0x232cb7(%rip), %r8     # 0x3246f2
movq 0x8(%rsp), %rdi
movl $0x382, %r9d            # imm = 0x382
jmp 0xf1a90
pushq $0x1
popq %rdx
movq 0x10(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0xf0ee7
testl %eax, %eax
je 0xf1d77
leaq 0x20c980(%rip), %rsi    # 0x2fe3f2
leaq 0x233074(%rip), %rdx    # 0x324aed
leaq 0x232f9f(%rip), %rcx    # 0x324a1f
leaq 0x232c6b(%rip), %r8     # 0x3246f2
movq %rbx, %rdi
movl $0x388, %r9d            # imm = 0x388
xorl %eax, %eax
callq 0x89dbb
movl %ebp, %r13d
movl %ebp, %eax
pushq $0x1
popq %rbp
xorl %r14d, %r14d
testl %eax, %eax
jne 0xf1c68
cmpq 0x30(%rsp), %r14
jae 0xf1c68
movq %r15, %rdi
callq 0x5876c
cmpl $0x1, %ebp
je 0xf1af0
movq 0x8(%rsp), %rdi
leaq 0x20c924(%rip), %rsi    # 0x2fe3f2
leaq 0x232fd8(%rip), %rdx    # 0x324aad
leaq 0x232f43(%rip), %rcx    # 0x324a1f
leaq 0x232c0f(%rip), %r8     # 0x3246f2
movl $0x397, %r9d            # imm = 0x397
xorl %eax, %eax
callq 0x89dbb
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0xf0ee7
movl %eax, %ebx
cmpl $0x1, %eax
jne 0xf1b55
movl %r13d, %eax
cmpl $0x1, %ebp
jne 0xf1c58
movq %r15, %rdi
callq 0x586a4
cmpq 0x28(%rsp), %rax
je 0xf1b85
movq 0x8(%rsp), %rdi
leaq 0x20c8bd(%rip), %rsi    # 0x2fe3f2
leaq 0x232ff3(%rip), %rdx    # 0x324b2f
leaq 0x232edc(%rip), %rcx    # 0x324a1f
leaq 0x232ba8(%rip), %r8     # 0x3246f2
movl $0x39d, %r9d            # imm = 0x39D
jmp 0xf1c4e
cmpl $0x1, %ebp
setne %al
testl %ebx, %ebx
sete %cl
orb %al, %cl
je 0xf1bfe
movl %ebp, %eax
xorl $0x1, %eax
movl %ebx, %ecx
notl %ecx
orl %eax, %ecx
je 0xf1c27
movl %r13d, %eax
cmpl $0x1, %ebp
jne 0xf1c58
xorl %ebp, %ebp
xorl %eax, %eax
testl %eax, %eax
jne 0xf1c55
movq %r15, %rdi
callq 0x586a4
cmpq %rax, %rbp
jae 0xf1c64
movq %r15, %rdi
movq %rbp, %rsi
callq 0x581aa
movq (%rax), %r12
leaq (%r14,%rbp), %rsi
movq 0x48(%rsp), %rdi
callq 0x581aa
movzbl (%rax), %ecx
xorl %eax, %eax
cmpq %rcx, %r12
je 0xf1bf9
movq 0x8(%rsp), %rdi
leaq 0x20c81e(%rip), %rsi    # 0x2fe3f2
leaq 0x232f37(%rip), %rdx    # 0x324b12
leaq 0x232e3d(%rip), %rcx    # 0x324a1f
leaq 0x232b09(%rip), %r8     # 0x3246f2
movl $0x3a7, %r9d            # imm = 0x3A7
xorl %eax, %eax
callq 0x89dbb
movl %r13d, %eax
incq %rbp
jmp 0xf1b89
movq 0x8(%rsp), %rdi
leaq 0x20c7e8(%rip), %rsi    # 0x2fe3f2
leaq 0x232edc(%rip), %rdx    # 0x324aed
leaq 0x232e07(%rip), %rcx    # 0x324a1f
leaq 0x232ad3(%rip), %r8     # 0x3246f2
movl $0x39f, %r9d            # imm = 0x39F
jmp 0xf1c4e
movq 0x8(%rsp), %rdi
leaq 0x20c7bf(%rip), %rsi    # 0x2fe3f2
leaq 0x232ec5(%rip), %rdx    # 0x324aff
leaq 0x232dde(%rip), %rcx    # 0x324a1f
leaq 0x232aaa(%rip), %r8     # 0x3246f2
movl $0x3a1, %r9d            # imm = 0x3A1
xorl %eax, %eax
callq 0x89dbb
movl %r13d, %eax
addq 0x28(%rsp), %r14
movl %ebx, %ebp
jmp 0xf1aa2
xorl %eax, %eax
jmp 0xf1c58
pushq $-0x1
popq %rbx
testl %eax, %eax
je 0xf1c83
movq 0x70(%rsp), %r12
movq 0x48(%rsp), %r13
movq 0x60(%rsp), %rbp
jmp 0xf1d0e
cmpq 0x30(%rsp), %r14
movq 0x70(%rsp), %r12
movq 0x48(%rsp), %r13
movq 0x60(%rsp), %rbp
jae 0xf1cc2
leaq 0x20c752(%rip), %rsi    # 0x2fe3f2
leaq 0x232e79(%rip), %rdx    # 0x324b20
leaq 0x232d71(%rip), %rcx    # 0x324a1f
leaq 0x232a3d(%rip), %r8     # 0x3246f2
movq 0x8(%rsp), %rdi
movl $0x3ac, %r9d            # imm = 0x3AC
jmp 0xf1d07
pushq $0x1
popq %rdx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq 0x8(%rsp), %r14
movq %r14, %rcx
callq 0xf0ee7
testl %eax, %eax
je 0xf1dac
leaq 0x20c709(%rip), %rsi    # 0x2fe3f2
leaq 0x232dfd(%rip), %rdx    # 0x324aed
leaq 0x232d28(%rip), %rcx    # 0x324a1f
leaq 0x2329f4(%rip), %r8     # 0x3246f2
movq %r14, %rdi
movl $0x3b2, %r9d            # imm = 0x3B2
xorl %eax, %eax
callq 0x89dbb
movq 0x10(%rsp), %rdi
callq 0xf120d
leaq 0x2329d3(%rip), %r14    # 0x3246f2
movq 0x68(%rsp), %rdi
movq %r14, %rsi
movl $0x3b5, %edx            # imm = 0x3B5
callq 0x936f9
movq 0x40(%rsp), %rdi
callq 0xf09fc
movq %r13, %rdi
callq 0x58eb9
movq %rbp, %rdi
callq 0x58eb9
movq %r15, %rdi
callq 0x58eb9
movq %r12, %rdi
movq %r14, %rsi
movl $0x3ba, %edx            # imm = 0x3BA
callq 0x936f9
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xf120d
leaq 0x60(%rip), %rsi        # 0xf1de6
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rdx
movq %rbx, %rcx
callq 0xf0d30
testq %rax, %rax
je 0xf1db3
movl %ebp, %r13d
movq %rax, 0x10(%rsp)
xorl %eax, %eax
jmp 0xf1a9c
xorl %ebx, %ebx
jmp 0xf1d0e
leaq 0x20c638(%rip), %rsi    # 0x2fe3f2
leaq 0x232ce4(%rip), %rdx    # 0x324aa5
leaq 0x232c57(%rip), %rcx    # 0x324a1f
leaq 0x232923(%rip), %r8     # 0x3246f2
movq $0x0, 0x10(%rsp)
movq %rbx, %rdi
movl $0x391, %r9d            # imm = 0x391
jmp 0xf1a90