// File: /workspace/github_c_makefile_star2_O3/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 $0x68, %rsp
movq %rdi, 0x20(%rsp)
callq 0x105e4d
mulsd 0x22f8bd(%rip), %xmm0   # 0x3842b0
addsd 0x1f4de5(%rip), %xmm0   # 0x3497e0
cvttsd2si %xmm0, %rax
subsd 0x1f3318(%rip), %xmm0   # 0x347d20
cvttsd2si %xmm0, %rcx
movq %rax, %r12
sarq $0x3f, %r12
andq %rcx, %r12
orq %rax, %r12
callq 0x105e4d
movsd 0x200579(%rip), %xmm1   # 0x354fa0
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x1f32dd(%rip), %xmm0   # 0x347d20
cvttsd2si %xmm0, %rbp
andq %rcx, %rbp
orq %rax, %rbp
callq 0x105e4d
mulsd 0x1f32ad(%rip), %xmm0   # 0x347d08
addsd 0x20053d(%rip), %xmm0   # 0x354fa0
cvttsd2si %xmm0, %r14
movq %r14, 0x28(%rsp)
sarq $0x3f, %r14
subsd 0x1f32a7(%rip), %xmm0   # 0x347d20
cvttsd2si %xmm0, %rax
movq %rax, 0x18(%rsp)
leaq (,%rbp,8), %rbx
leaq 0x22f858(%rip), %rsi    # 0x3842ea
movq %rbx, %rdi
movl $0x312, %edx            # imm = 0x312
callq 0x104226
movq %rax, %r13
movq $0x0, 0x38(%rsp)
movl $0x1, %edi
callq 0xd214c
movq %rax, %r15
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x8(%rsp)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x40(%rsp)
movl $0x30, %edi
leaq 0x22f808(%rip), %rsi    # 0x3842ea
movl $0x31a, %edx            # imm = 0x31A
callq 0x104226
movq %rax, 0x10(%rsp)
testq %rbp, %rbp
je 0x154b03
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x173a0
movq %r13, 0x58(%rsp)
movq 0x18(%rsp), %r13
andq %r14, %r13
movq %r15, %rdi
callq 0xd24e0
cmpq %r12, %rax
jae 0x154b7f
xorl %ebx, %ebx
leaq 0x48(%rsp), %r14
callq 0x105e4d
movq %rbp, %rax
movl %ebx, %ecx
shrq %cl, %rax
movq %rax, %xmm1
punpckldq 0x1f2da2(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1f2daa(%rip), %xmm1   # 0x3478f0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
xorq $0x1, %rbx
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %eax
movb %al, 0x48(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xd2410
movq %r15, %rdi
callq 0xd24e0
cmpq %r12, %rax
jb 0x154b24
movq 0x28(%rsp), %r14
orq %r13, %r14
movq %r15, %rdi
callq 0xd24e0
cmpq %r12, %rax
jne 0x154cb4
movq %rax, %rbx
movq %r14, 0x28(%rsp)
setne %al
testq %r12, %r12
sete %cl
orb %al, %cl
movq 0x58(%rsp), %r13
jne 0x154bd9
xorl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0xd2207
movzbl (%rax), %eax
incq (%r13,%rax,8)
incq %r14
cmpq %r12, %r14
jb 0x154bb5
cmpq %r12, %rbx
jne 0x154d3f
leaq -0x212(%rip), %rsi      # 0x1549ce
movq %r13, %rdi
movq %rbp, %rdx
callq 0x153ff8
testq %rax, %rax
je 0x15539c
movq %rax, %rbx
cmpq %r12, 0x8(%rax)
movq 0x8(%rsp), %rbp
jne 0x154cfc
movq %rbx, 0x18(%rsp)
movq (%rbx), %r14
testq %r12, %r12
je 0x154d4a
movq %r14, 0x60(%rsp)
movb $0x40, %bl
xorl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
callq 0xd2207
movzbl (%rax), %esi
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x54(%rsp), %rcx
callq 0x1544f4
movzbl %bl, %eax
movl 0x54(%rsp), %ebp
movq 0x48(%rsp), %r13
cmpl %eax, %ebp
jbe 0x154c80
subb %bl, %bpl
movq %r13, %rax
movl %ebp, %ecx
shrq %cl, %rax
orq %rax, 0x38(%rsp)
movl $0x8, %edx
movq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd2410
movb $0x40, %bl
subb %bpl, %bl
xorl %eax, %eax
jmp 0x154c88
subb %bpl, %bl
movq 0x38(%rsp), %rax
movl %ebx, %ecx
shlq %cl, %r13
orq %rax, %r13
movq %r13, 0x38(%rsp)
incq %r14
cmpq %r12, %r14
jb 0x154c21
movzbl %bl, %eax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rbp
movq 0x60(%rsp), %r14
jmp 0x154d54
leaq 0x209783(%rip), %rsi    # 0x35e43e
leaq 0x22f933(%rip), %rdx    # 0x3845f5
leaq 0x22f94e(%rip), %rcx    # 0x384617
leaq 0x22f61a(%rip), %r8     # 0x3842ea
xorl %r12d, %r12d
movq 0x20(%rsp), %rdi
movl $0x32e, %r9d            # imm = 0x32E
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %edi, %edi
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %r14
jmp 0x154fd5
leaq 0x20973b(%rip), %rsi    # 0x35e43e
leaq 0x22f91b(%rip), %rdx    # 0x384625
leaq 0x22f906(%rip), %rcx    # 0x384617
leaq 0x22f5d2(%rip), %r8     # 0x3842ea
movq 0x20(%rsp), %rdi
movl $0x33b, %r9d            # imm = 0x33B
xorl %eax, %eax
callq 0xfcb67
xorl %edi, %edi
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %r14
movq %rbx, %r12
jmp 0x154fd5
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
jmp 0x154ceb
movl $0x40, %eax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rsi
movl $0x8, %edx
movq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0xd2410
movq %r13, %rdi
callq 0xd24e0
movq %rax, %rbx
movq %r13, %rdi
callq 0xd24ed
imulq %rbx, %rax
shlq $0x3, %rax
movq 0x30(%rsp), %rcx
subq %rcx, %rax
cmpq %rax, %r14
jne 0x154de4
movq 0x10(%rsp), %r14
movq $0x0, 0x8(%r14)
movq %rcx, 0x28(%r14)
movq %r13, %rdi
callq 0xd24e0
shrq $0x2, %rax
movq %rax, 0x18(%r14)
movq %r13, %rdi
callq 0xd24e0
xorl %edx, %edx
divq 0x18(%r14)
movq %rdx, %rbx
movq %rdx, 0x20(%r14)
movq %r13, %rdi
callq 0xd24e0
movq 0x18(%r14), %rcx
xorl %edx, %edx
divq %rcx
testq %rbx, %rbx
je 0x154e10
incq %rax
jmp 0x154e14
leaq 0x209653(%rip), %rsi    # 0x35e43e
leaq 0x22f84f(%rip), %rdx    # 0x384641
leaq 0x22f81e(%rip), %rcx    # 0x384617
leaq 0x22f4ea(%rip), %r8     # 0x3842ea
movq 0x20(%rsp), %rdi
movl $0x353, %r9d            # imm = 0x353
jmp 0x154f44
movq %rcx, 0x20(%r14)
movq %rax, 0x10(%r14)
movq %r13, %rdi
callq 0xd23eb
movq %rax, (%r14)
movq %r13, %rdi
callq 0xd23eb
movq %rax, %rbx
movq %r13, %rdi
callq 0xd24e0
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
movq 0x30(%rsp), %r8
callq 0x154541
testq %rax, %rax
je 0x154f1d
movq %rax, 0x8(%rsp)
testq %r12, %r12
movq 0x20(%rsp), %rbx
je 0x154f88
movl $0x1, %r14d
xorl %r13d, %r13d
movq %rbp, %rdi
callq 0xd2519
cmpl $0x1, %r14d
jne 0x155194
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rcx
callq 0x1546bb
movl %eax, %r14d
testl %eax, %eax
je 0x154ebd
cmpl $0x1, %r14d
jne 0x15520a
movq %rbp, %rdi
callq 0xd24e0
cmpq 0x28(%rsp), %rax
jne 0x155234
movl %r14d, 0x30(%rsp)
movq %rbp, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x154f03
xorl %ebx, %ebx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xd2207
movq (%rax), %r14
leaq (%rbx,%r13), %rsi
movq %r15, %rdi
callq 0xd2207
movzbl (%rax), %eax
cmpq %rax, %r14
jne 0x154f5f
incq %rbx
movq %rbp, %rdi
callq 0xd24e0
cmpq %rax, %rbx
jb 0x154ed1
addq 0x28(%rsp), %r13
cmpq %r12, %r13
movq 0x20(%rsp), %rbx
movl 0x30(%rsp), %r14d
jb 0x154e72
jmp 0x154f8b
leaq 0x20951a(%rip), %rsi    # 0x35e43e
leaq 0x22f772(%rip), %rdx    # 0x38469d
leaq 0x22f6e5(%rip), %rcx    # 0x384617
leaq 0x22f3b1(%rip), %r8     # 0x3842ea
movq 0x20(%rsp), %rdi
movl $0x368, %r9d            # imm = 0x368
xorl %eax, %eax
callq 0xfcb67
xorl %edi, %edi
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r12
jmp 0x154fd5
leaq 0x2094d8(%rip), %rsi    # 0x35e43e
leaq 0x22f78a(%rip), %rdx    # 0x3846f7
leaq 0x22f6a3(%rip), %rcx    # 0x384617
leaq 0x22f36f(%rip), %r8     # 0x3842ea
movq 0x20(%rsp), %rdi
movl $0x37d, %r9d            # imm = 0x37D
jmp 0x154fb9
xorl %r13d, %r13d
cmpq %r12, %r13
jae 0x15503f
leaq 0x2094a3(%rip), %rsi    # 0x35e43e
leaq 0x22f763(%rip), %rdx    # 0x384705
leaq 0x22f66e(%rip), %rcx    # 0x384617
leaq 0x22f33a(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x382, %r9d            # imm = 0x382
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r12
movq 0x8(%rsp), %rdi
leaq 0x22f30e(%rip), %rbx    # 0x3842ea
movq %rbx, %rsi
movl $0x256, %edx            # imm = 0x256
callq 0x1045eb
movq %r14, %rdi
movq %rbx, %rsi
movl $0x3b5, %edx            # imm = 0x3B5
callq 0x1045eb
movq %r12, %rdi
callq 0x1543bd
movq %r15, %rdi
callq 0xd2938
movq 0x40(%rsp), %rdi
callq 0xd2938
movq %rbp, %rdi
callq 0xd2938
movq 0x58(%rsp), %rdi
movq %rbx, %rsi
movl $0x3ba, %edx            # imm = 0x3BA
callq 0x1045eb
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edx
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0x1546bb
testl %eax, %eax
je 0x155095
leaq 0x2093dc(%rip), %rsi    # 0x35e43e
leaq 0x22f67c(%rip), %rdx    # 0x3846e5
leaq 0x22f5a7(%rip), %rcx    # 0x384617
leaq 0x22f273(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x388, %r9d            # imm = 0x388
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r14, %rdi
jmp 0x154f53
leaq 0x22f24e(%rip), %rsi    # 0x3842ea
movq %r14, %rdi
movl $0x256, %edx            # imm = 0x256
callq 0x1045eb
leaq 0x2f6(%rip), %rsi       # 0x1553a6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x1545b4
testq %rax, %rax
je 0x1551e0
movq %rax, 0x8(%rsp)
testq %r12, %r12
je 0x15528a
movl $0x1, %r14d
xorl %r13d, %r13d
movq %rbp, %rdi
callq 0xd2519
cmpl $0x1, %r14d
jne 0x15531e
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rcx
callq 0x1546bb
movl %eax, %r14d
testl %eax, %eax
je 0x15512d
cmpl $0x1, %r14d
jne 0x155348
movq %rbp, %rdi
callq 0xd24e0
cmpq 0x28(%rsp), %rax
jne 0x155372
movl %r14d, 0x30(%rsp)
movq %rbp, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x155177
xorl %ebx, %ebx
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xd2207
movq (%rax), %r14
leaq (%rbx,%r13), %rsi
movq %r15, %rdi
callq 0xd2207
movzbl (%rax), %eax
cmpq %rax, %r14
jne 0x15525e
incq %rbx
movq %rbp, %rdi
callq 0xd24e0
cmpq %rax, %rbx
jb 0x155141
addq 0x28(%rsp), %r13
cmpq %r12, %r13
movq 0x20(%rsp), %rbx
movl 0x30(%rsp), %r14d
jb 0x1550e2
jmp 0x15528d
leaq 0x2092a3(%rip), %rsi    # 0x35e43e
leaq 0x22f503(%rip), %rdx    # 0x3846a5
leaq 0x22f46e(%rip), %rcx    # 0x384617
leaq 0x22f13a(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x36d, %r9d            # imm = 0x36D
xorl %eax, %eax
callq 0xfcb67
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rcx
callq 0x1546bb
movq %r14, %rdi
jmp 0x154f4d
leaq 0x209257(%rip), %rsi    # 0x35e43e
leaq 0x22f4af(%rip), %rdx    # 0x38469d
leaq 0x22f422(%rip), %rcx    # 0x384617
leaq 0x22f0ee(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x391, %r9d            # imm = 0x391
jmp 0x154f44
leaq 0x20922d(%rip), %rsi    # 0x35e43e
leaq 0x22f4cd(%rip), %rdx    # 0x3846e5
leaq 0x22f3f8(%rip), %rcx    # 0x384617
leaq 0x22f0c4(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x375, %r9d            # imm = 0x375
jmp 0x154fb9
leaq 0x209203(%rip), %rsi    # 0x35e43e
leaq 0x22f475(%rip), %rdx    # 0x3846b7
leaq 0x22f3ce(%rip), %rcx    # 0x384617
leaq 0x22f09a(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x373, %r9d            # imm = 0x373
jmp 0x154fb9
leaq 0x2091d9(%rip), %rsi    # 0x35e43e
leaq 0x22f48b(%rip), %rdx    # 0x3846f7
leaq 0x22f3a4(%rip), %rcx    # 0x384617
leaq 0x22f070(%rip), %r8     # 0x3842ea
movq 0x20(%rsp), %rdi
movl $0x3a7, %r9d            # imm = 0x3A7
jmp 0x154fb9
xorl %r13d, %r13d
cmpq %r12, %r13
jae 0x1552bc
leaq 0x2091a5(%rip), %rsi    # 0x35e43e
leaq 0x22f465(%rip), %rdx    # 0x384705
leaq 0x22f370(%rip), %rcx    # 0x384617
leaq 0x22f03c(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x3ac, %r9d            # imm = 0x3AC
jmp 0x154fb9
movl $0x1, %edx
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0x1546bb
testl %eax, %eax
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r12
je 0x155316
leaq 0x209158(%rip), %rsi    # 0x35e43e
leaq 0x22f3f8(%rip), %rdx    # 0x3846e5
leaq 0x22f323(%rip), %rcx    # 0x384617
leaq 0x22efef(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x3b2, %r9d            # imm = 0x3B2
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x154fd0
xorl %r13d, %r13d
jmp 0x154fd0
leaq 0x209119(%rip), %rsi    # 0x35e43e
leaq 0x22f379(%rip), %rdx    # 0x3846a5
leaq 0x22f2e4(%rip), %rcx    # 0x384617
leaq 0x22efb0(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x397, %r9d            # imm = 0x397
jmp 0x1551b9
leaq 0x2090ef(%rip), %rsi    # 0x35e43e
leaq 0x22f38f(%rip), %rdx    # 0x3846e5
leaq 0x22f2ba(%rip), %rcx    # 0x384617
leaq 0x22ef86(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x39f, %r9d            # imm = 0x39F
jmp 0x154fb9
leaq 0x2090c5(%rip), %rsi    # 0x35e43e
leaq 0x22f394(%rip), %rdx    # 0x384714
leaq 0x22f290(%rip), %rcx    # 0x384617
leaq 0x22ef5c(%rip), %r8     # 0x3842ea
movq %rbx, %rdi
movl $0x39d, %r9d            # imm = 0x39D
jmp 0x154fb9
movq 0x20(%rsp), %rdi
callq 0x4934f