// File: /workspace/github_cpp_makefile_star2_O1/sbingner[P]kerneldec/lzfse/src/lzfse_decode_base.c
// Function: lzfse_decode
int lzfse_decode(lzfse_decoder_state *s) {
  while (1) {
    // Are we inside a block?
    switch (s->block_magic) {
    case LZFSE_NO_BLOCK_MAGIC: {
      // We need at least 4 bytes of magic number to identify next block
      if (s->src + 4 > s->src_end)
        return LZFSE_STATUS_SRC_EMPTY; // SRC truncated
      uint32_t magic = load4(s->src);

      if (magic == LZFSE_ENDOFSTREAM_BLOCK_MAGIC) {
        s->src += 4;
        s->end_of_stream = 1;
        return LZFSE_STATUS_OK; // done
      }

      if (magic == LZFSE_UNCOMPRESSED_BLOCK_MAGIC) {
        if (s->src + sizeof(uncompressed_block_header) > s->src_end)
          return LZFSE_STATUS_SRC_EMPTY; // SRC truncated
        // Setup state for uncompressed block
        uncompressed_block_decoder_state *bs = &(s->uncompressed_block_state);
        bs->n_raw_bytes =
            load4(s->src + offsetof(uncompressed_block_header, n_raw_bytes));
        s->src += sizeof(uncompressed_block_header);
        s->block_magic = magic;
        break;
      }

      if (magic == LZFSE_COMPRESSEDLZVN_BLOCK_MAGIC) {
        if (s->src + sizeof(lzvn_compressed_block_header) > s->src_end)
          return LZFSE_STATUS_SRC_EMPTY; // SRC truncated
        // Setup state for compressed LZVN block
        lzvn_compressed_block_decoder_state *bs =
            &(s->compressed_lzvn_block_state);
        bs->n_raw_bytes =
            load4(s->src + offsetof(lzvn_compressed_block_header, n_raw_bytes));
        bs->n_payload_bytes = load4(
            s->src + offsetof(lzvn_compressed_block_header, n_payload_bytes));
        bs->d_prev = 0;
        s->src += sizeof(lzvn_compressed_block_header);
        s->block_magic = magic;
        break;
      }

      if (magic == LZFSE_COMPRESSEDV1_BLOCK_MAGIC ||
          magic == LZFSE_COMPRESSEDV2_BLOCK_MAGIC) {
        lzfse_compressed_block_header_v1 header1;
        size_t header_size = 0;

        // Decode compressed headers
        if (magic == LZFSE_COMPRESSEDV2_BLOCK_MAGIC) {
          // Check we have the fixed part of the structure
          if (s->src + offsetof(lzfse_compressed_block_header_v2, freq) > s->src_end)
            return LZFSE_STATUS_SRC_EMPTY; // SRC truncated

          // Get size, and check we have the entire structure
          const lzfse_compressed_block_header_v2 *header2 =
              (const lzfse_compressed_block_header_v2 *)s->src; // not aligned, OK
          header_size = lzfse_decode_v2_header_size(header2);
          if (s->src + header_size > s->src_end)
            return LZFSE_STATUS_SRC_EMPTY; // SRC truncated
          int decodeStatus = lzfse_decode_v1(&header1, header2);
          if (decodeStatus != 0)
            return LZFSE_STATUS_ERROR; // failed
        } else {
          if (s->src + sizeof(lzfse_compressed_block_header_v1) > s->src_end)
            return LZFSE_STATUS_SRC_EMPTY; // SRC truncated
          memcpy(&header1, s->src, sizeof(lzfse_compressed_block_header_v1));
          header_size = sizeof(lzfse_compressed_block_header_v1);
        }

        // We require the header + entire encoded block to be present in SRC
        // during the entire block decoding.
        // This can be relaxed somehow, if it becomes a limiting factor, at the
        // price of a more complex state maintenance.
        // For DST, we can't easily require space for the entire decoded block,
        // because it may expand to something very very large.
        if (s->src + header_size + header1.n_literal_payload_bytes +
                header1.n_lmd_payload_bytes >
            s->src_end)
          return LZFSE_STATUS_SRC_EMPTY; // need all encoded block

        // Sanity checks
        if (lzfse_check_block_header_v1(&header1) != 0) {
          return LZFSE_STATUS_ERROR;
        }

        // Skip header
        s->src += header_size;

        // Setup state for compressed V1 block from header
        lzfse_compressed_block_decoder_state *bs =
            &(s->compressed_lzfse_block_state);
        bs->n_lmd_payload_bytes = header1.n_lmd_payload_bytes;
        bs->n_matches = header1.n_matches;
        fse_init_decoder_table(LZFSE_ENCODE_LITERAL_STATES,
                               LZFSE_ENCODE_LITERAL_SYMBOLS,
                               header1.literal_freq, bs->literal_decoder);
        fse_init_value_decoder_table(
            LZFSE_ENCODE_L_STATES, LZFSE_ENCODE_L_SYMBOLS, header1.l_freq,
            l_extra_bits, l_base_value, bs->l_decoder);
        fse_init_value_decoder_table(
            LZFSE_ENCODE_M_STATES, LZFSE_ENCODE_M_SYMBOLS, header1.m_freq,
            m_extra_bits, m_base_value, bs->m_decoder);
        fse_init_value_decoder_table(
            LZFSE_ENCODE_D_STATES, LZFSE_ENCODE_D_SYMBOLS, header1.d_freq,
            d_extra_bits, d_base_value, bs->d_decoder);

        // Decode literals
        {
          fse_in_stream in;
          const uint8_t *buf_start = s->src_begin;
          s->src += header1.n_literal_payload_bytes; // skip literal payload
          const uint8_t *buf = s->src; // read bits backwards from the end
          if (fse_in_init(&in, header1.literal_bits, &buf, buf_start) != 0)
            return LZFSE_STATUS_ERROR;

          fse_state state0 = header1.literal_state[0];
          fse_state state1 = header1.literal_state[1];
          fse_state state2 = header1.literal_state[2];
          fse_state state3 = header1.literal_state[3];

          for (uint32_t i = 0; i < header1.n_literals; i += 4) // n_literals is multiple of 4
          {
#if FSE_IOSTREAM_64
            if (fse_in_flush(&in, &buf, buf_start) != 0)
              return LZFSE_STATUS_ERROR; // [57, 64] bits
            bs->literals[i + 0] =
                fse_decode(&state0, bs->literal_decoder, &in); // 10b max
            bs->literals[i + 1] =
                fse_decode(&state1, bs->literal_decoder, &in); // 10b max
            bs->literals[i + 2] =
                fse_decode(&state2, bs->literal_decoder, &in); // 10b max
            bs->literals[i + 3] =
                fse_decode(&state3, bs->literal_decoder, &in); // 10b max
#else
            if (fse_in_flush(&in, &buf, buf_start) != 0)
              return LZFSE_STATUS_ERROR; // [25, 23] bits
            bs->literals[i + 0] =
                fse_decode(&state0, bs->literal_decoder, &in); // 10b max
            bs->literals[i + 1] =
                fse_decode(&state1, bs->literal_decoder, &in); // 10b max
            if (fse_in_flush(&in, &buf, buf_start) != 0)
              return LZFSE_STATUS_ERROR; // [25, 23] bits
            bs->literals[i + 2] =
                fse_decode(&state2, bs->literal_decoder, &in); // 10b max
            bs->literals[i + 3] =
                fse_decode(&state3, bs->literal_decoder, &in); // 10b max
#endif
          }

          bs->current_literal = bs->literals;
        } // literals

        // SRC is not incremented to skip the LMD payload, since we need it
        // during block decode.
        // We will increment SRC at the end of the block only after this point.

        // Initialize the L,M,D decode stream, do not start decoding matches
        // yet, and store decoder state
        {
          fse_in_stream in;
          // read bits backwards from the end
          const uint8_t *buf = s->src + header1.n_lmd_payload_bytes;
          if (fse_in_init(&in, header1.lmd_bits, &buf, s->src) != 0)
            return LZFSE_STATUS_ERROR;

          bs->l_state = header1.l_state;
          bs->m_state = header1.m_state;
          bs->d_state = header1.d_state;
          bs->lmd_in_buf = (uint32_t)(buf - s->src);
          bs->l_value = bs->m_value = 0;
          //  Initialize D to an illegal value so we can't erroneously use
          //  an uninitialized "previous" value.
          bs->d_value = -1;
          bs->lmd_in_stream = in;
        }

        s->block_magic = magic;
        break;
      }

      // Here we have an invalid magic number
      return LZFSE_STATUS_ERROR;
    } // LZFSE_NO_BLOCK_MAGIC

    case LZFSE_UNCOMPRESSED_BLOCK_MAGIC: {
      uncompressed_block_decoder_state *bs = &(s->uncompressed_block_state);

      //  Compute the size (in bytes) of the data that we will actually copy.
      //  This size is minimum(bs->n_raw_bytes, space in src, space in dst).

      uint32_t copy_size = bs->n_raw_bytes; // bytes left to copy
      if (copy_size == 0) {
        s->block_magic = 0;
        break;
      } // end of block

      if (s->src_end <= s->src)
        return LZFSE_STATUS_SRC_EMPTY; // need more SRC data
      const size_t src_space = s->src_end - s->src;
      if (copy_size > src_space)
        copy_size = (uint32_t)src_space; // limit to SRC data (> 0)

      if (s->dst_end <= s->dst)
        return LZFSE_STATUS_DST_FULL; // need more DST capacity
      const size_t dst_space = s->dst_end - s->dst;
      if (copy_size > dst_space)
        copy_size = (uint32_t)dst_space; // limit to DST capacity (> 0)

      // Now that we know that the copy size is bounded to the source and
      // dest buffers, go ahead and copy the data.
      // We always have copy_size > 0 here
      memcpy(s->dst, s->src, copy_size);
      s->src += copy_size;
      s->dst += copy_size;
      bs->n_raw_bytes -= copy_size;

      break;
    } // LZFSE_UNCOMPRESSED_BLOCK_MAGIC

    case LZFSE_COMPRESSEDV1_BLOCK_MAGIC:
    case LZFSE_COMPRESSEDV2_BLOCK_MAGIC: {
      lzfse_compressed_block_decoder_state *bs =
          &(s->compressed_lzfse_block_state);
      // Require the entire LMD payload to be in SRC
      if (s->src_end <= s->src ||
          bs->n_lmd_payload_bytes > (size_t)(s->src_end - s->src))
        return LZFSE_STATUS_SRC_EMPTY;

      int status = lzfse_decode_lmd(s);
      if (status != LZFSE_STATUS_OK)
        return status;

      s->block_magic = LZFSE_NO_BLOCK_MAGIC;
      s->src += bs->n_lmd_payload_bytes; // to next block
      break;
    } // LZFSE_COMPRESSEDV1_BLOCK_MAGIC || LZFSE_COMPRESSEDV2_BLOCK_MAGIC

    case LZFSE_COMPRESSEDLZVN_BLOCK_MAGIC: {
      lzvn_compressed_block_decoder_state *bs =
          &(s->compressed_lzvn_block_state);
      if (bs->n_payload_bytes > 0 && s->src_end <= s->src)
        return LZFSE_STATUS_SRC_EMPTY; // need more SRC data

      // Init LZVN decoder state
      lzvn_decoder_state dstate;
      memset(&dstate, 0x00, sizeof(dstate));
      dstate.src = s->src;
      dstate.src_end = s->src_end;
      if (dstate.src_end - s->src > bs->n_payload_bytes)
        dstate.src_end = s->src + bs->n_payload_bytes; // limit to payload bytes
      dstate.dst_begin = s->dst_begin;
      dstate.dst = s->dst;
      dstate.dst_end = s->dst_end;
      if (dstate.dst_end - s->dst > bs->n_raw_bytes)
        dstate.dst_end = s->dst + bs->n_raw_bytes; // limit to raw bytes
      dstate.d_prev = bs->d_prev;
      dstate.end_of_stream = 0;

      // Run LZVN decoder
      lzvn_decode(&dstate);

      // Update our state
      size_t src_used = dstate.src - s->src;
      size_t dst_used = dstate.dst - s->dst;
      if (src_used > bs->n_payload_bytes || dst_used > bs->n_raw_bytes)
        return LZFSE_STATUS_ERROR; // sanity check
      s->src = dstate.src;
      s->dst = dstate.dst;
      bs->n_payload_bytes -= (uint32_t)src_used;
      bs->n_raw_bytes -= (uint32_t)dst_used;
      bs->d_prev = (uint32_t)dstate.d_prev;

      // Test end of block
      if (bs->n_payload_bytes == 0 && bs->n_raw_bytes == 0 &&
          dstate.end_of_stream) {
        s->block_magic = 0;
        break;
      } // block done

      // Check for invalid state
      if (bs->n_payload_bytes == 0 || bs->n_raw_bytes == 0 ||
          dstate.end_of_stream)
        return LZFSE_STATUS_ERROR;

      // Here, block is not done and state is valid, so we need more space in dst.
      return LZFSE_STATUS_DST_FULL;
    }

    default:
      return LZFSE_STATUS_ERROR; // invalid magic

    } // switch magic

  } // block loop

  return LZFSE_STATUS_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a8, %rsp            # imm = 0x3A8
movq %rdi, %rbx
leaq 0xb8f8(%rdi), %rax
movq %rax, 0x98(%rsp)
leaq 0xc78(%rdi), %rax
movq %rax, 0x58(%rsp)
leaq 0x78(%rdi), %rax
movq %rax, 0x90(%rsp)
leaq 0x278(%rdi), %rax
movq %rax, 0x88(%rsp)
leaq 0x478(%rdi), %rax
movq %rax, 0x80(%rsp)
leaq 0x1c78(%rdi), %rax
movq %rax, 0x78(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, 0x50(%rsp)
movl 0x34(%rbx), %ecx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpl $0x32787661, %ecx       # imm = 0x32787661
jg 0x5502
cmpl $0x2d787662, %ecx       # imm = 0x2D787662
je 0x5715
cmpl $0x31787662, %ecx       # imm = 0x31787662
je 0x5637
testl %ecx, %ecx
jne 0x6559
movq (%rbx), %r14
movq 0x10(%rbx), %r12
leaq 0x4(%r14), %rax
cmpq %r12, %rax
ja 0x6554
movl (%r14), %edx
movb $0x1, %cl
cmpl $0x31787661, %edx       # imm = 0x31787661
jle 0x5c10
cmpl $0x31787662, %edx       # imm = 0x31787662
je 0x5c3c
cmpl $0x32787662, %edx       # imm = 0x32787662
je 0x5c3c
cmpl $0x6e787662, %edx       # imm = 0x6E787662
jne 0x562c
leaq 0xc(%r14), %rax
cmpq %r12, %rax
ja 0x5c31
movl 0x4(%r14), %ecx
movl %ecx, 0xb8f8(%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0xb8fc(%rbx)
movl $0x0, 0xb900(%rbx)
movq %rax, (%rbx)
movl $0x6e787662, 0x34(%rbx) # imm = 0x6E787662
jmp 0x57db
cmpl $0x32787662, %ecx       # imm = 0x32787662
je 0x5637
cmpl $0x6e787662, %ecx       # imm = 0x6E787662
jne 0x6559
movl 0xb8fc(%rbx), %eax
testq %rax, %rax
je 0x5532
movq 0x10(%rbx), %rcx
cmpq (%rbx), %rcx
jbe 0x577b
xorps %xmm0, %xmm0
movaps %xmm0, 0xe0(%rsp)
movaps %xmm0, 0xd0(%rsp)
movaps %xmm0, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movq $0x0, 0xf0(%rsp)
movq (%rbx), %rcx
movq %rcx, 0xa0(%rsp)
movq 0x10(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rax, %rcx
cmpq %rax, %rsi
cmovleq %rdx, %rcx
movq %rcx, 0xa8(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0xb8(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0xb0(%rsp)
movq 0x28(%rbx), %rdx
movq %rdx, 0xc0(%rsp)
subq %rax, %rdx
movl 0xb8f8(%rbx), %ecx
cmpq %rcx, %rdx
jle 0x55cd
addq %rcx, %rax
movq %rax, 0xc0(%rsp)
movl 0xb900(%rbx), %eax
movq %rax, 0xe8(%rsp)
movl $0x0, 0xf0(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x7640
movq 0xa0(%rsp), %r8
movq %r8, %rax
subq (%rbx), %rax
movl 0xb8fc(%rbx), %edx
movb $0x1, %cl
cmpq %rdx, %rax
ja 0x562c
movq 0xb0(%rsp), %r9
movq %r9, %rsi
subq 0x18(%rbx), %rsi
movl 0xb8f8(%rbx), %edi
cmpq %rdi, %rsi
jbe 0x5788
movl $0xfffffffd, %r15d      # imm = 0xFFFFFFFD
jmp 0x58c5
movq (%rbx), %r8
movq 0x10(%rbx), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movb $0x1, %dil
subq %r8, %rcx
jbe 0x5bd2
movl 0x3c(%rbx), %edx
cmpq %rdx, %rcx
jb 0x5bd2
movl %r15d, 0x10(%rsp)
movzwl 0x6c(%rbx), %r15d
cmpw $0x40, %r15w
jae 0x656b
movzwl 0x6e(%rbx), %r12d
cmpw $0x40, %r12w
jae 0x658a
movzwl 0x70(%rbx), %r13d
movzwl %r13w, %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0x65a9
movq 0x58(%rbx), %r11
movl 0x60(%rbx), %edx
movl 0x64(%rbx), %eax
movl %eax, 0x40(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rbx), %r14
movl 0x68(%rbx), %eax
addq %rax, %r8
movq 0x40(%rbx), %rax
movq %rax, 0x8(%rsp)
movl 0x38(%rbx), %esi
movl 0x48(%rbx), %ebp
movl 0x4c(%rbx), %r10d
movl 0x50(%rbx), %eax
movl %eax, (%rsp)
movq 0x28(%rbx), %r9
subq %r14, %r9
addq $-0x20, %r9
movl %ebp, %eax
orl %r10d, %eax
movq %r9, %rcx
je 0x5901
movl %esi, 0x18(%rsp)
movq %r11, 0x30(%rsp)
movl (%rsp), %r9d
movslq %ebp, %rsi
leaq (%r14,%rsi), %rax
movq %rax, %r11
subq 0x20(%rbx), %r11
cmpq %r9, %r11
jge 0x57e2
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0x5af0
movl 0xb904(%rbx), %eax
testq %rax, %rax
je 0x5762
movq (%rbx), %rsi
movq 0x10(%rbx), %rcx
subq %rsi, %rcx
jbe 0x5770
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %r14
subq %rdi, %r14
jbe 0x5831
cmpq %rax, %rcx
cmovael %eax, %ecx
cmpq %rcx, %r14
cmovael %ecx, %r14d
movq %r14, %rdx
callq 0x30c0
addq %r14, (%rbx)
addq %r14, 0x18(%rbx)
subl %r14d, 0xb904(%rbx)
jmp 0x5769
movl $0x0, 0x34(%rbx)
movb $0x1, %cl
jmp 0x5839
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x5837
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movb $0x1, %cl
jmp 0x58c5
movq %r8, (%rbx)
movq %r9, 0x18(%rbx)
movl %edi, %r8d
subl %esi, %r8d
movl %edx, %r9d
subl %eax, %r9d
movl %r9d, 0xb8fc(%rbx)
movl %r8d, 0xb8f8(%rbx)
movl 0xe8(%rsp), %r8d
movl %r8d, 0xb900(%rbx)
jne 0x58a7
cmpl %esi, %edi
jne 0x589f
cmpl $0x0, 0xf0(%rsp)
je 0x589f
movl $0x0, 0x34(%rbx)
xorl %ecx, %ecx
jmp 0x58c5
leal (%r10,%rbp), %r9d
movslq %r9d, %r11
movq %rcx, %r9
subq %r11, %r9
jge 0x5849
addq $0x20, %rcx
movq %rcx, %r9
subq %rsi, %r9
movq %r9, 0x20(%rsp)
movq 0x30(%rsp), %r9
jge 0x5b00
testq %rcx, %rcx
movq 0x8(%rsp), %r11
je 0x5827
xorl %eax, %eax
movb (%r11,%rax), %sil
movb %sil, (%r14,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x5817
addq %rcx, %r11
subl %ecx, %ebp
jmp 0x5b6f
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
xorl %ecx, %ecx
movl %r15d, %eax
testb %cl, %cl
jne 0x544b
jmp 0x6559
movq 0x8(%rsp), %rbp
movq %rbp, %rcx
movq (%rcx), %r11
movq %r11, (%r14)
addq $0x8, %r14
addq $0x8, %rcx
cmpq %rax, %r14
jb 0x5851
addq %rsi, %rbp
movq %rbp, 0x8(%rsp)
movslq %r10d, %rcx
movl (%rsp), %esi
cmpl $0x7, %esi
jg 0x58d5
cmpl %r10d, %esi
jge 0x58d5
testl %r10d, %r10d
je 0x58f2
movslq (%rsp), %rsi
negq %rsi
movq %rax, %r10
movq %rcx, %r11
movb (%r10,%rsi), %bpl
movb %bpl, (%r10)
incq %r10
decq %r11
jne 0x588e
jmp 0x58f2
cmpl %eax, %edx
je 0x562c
cmpl %esi, %edi
sete %al
cmpl $0x0, 0xf0(%rsp)
setne %dl
orb %al, %dl
movzbl %dl, %eax
movl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
subl %eax, %r15d
movl %r15d, %eax
testb %cl, %cl
je 0x544b
jmp 0x6559
movslq %esi, %rsi
negq %rsi
leaq (%rax,%rcx), %r10
movq %rax, %r11
movq (%r11,%rsi), %r14
movq %r14, (%r11)
addq $0x8, %r11
cmpq %r10, %r11
jb 0x58e2
addq %rcx, %rax
movq %rax, %r14
movq 0x30(%rsp), %r11
movl 0x18(%rsp), %esi
testl %esi, %esi
je 0x5af7
movl %esi, 0x18(%rsp)
movl $0x3f, %ecx
subl %edx, %ecx
movl %ecx, %eax
sarl $0x3, %eax
negl %eax
movslq %eax, %rsi
addq %r8, %rsi
movq 0x38(%rsp), %r10
cmpq %r10, %rsi
jb 0x5969
andl $-0x8, %ecx
addl %ecx, %edx
movl %edx, %eax
andl $-0x8, %eax
cmpl $0x38, %eax
jne 0x65e7
shlq %cl, %r11
movslq %ecx, %rax
movq (%rsi), %rcx
leaq 0x39b2(%rip), %r8       # 0x9300
andq (%r8,%rax,8), %rcx
orq %rcx, %r11
movq %r11, %rax
movl %edx, %ecx
shrq %cl, %rax
movq %rsi, %r8
testq %rax, %rax
jne 0x65f0
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
cmpq %r10, %rsi
jb 0x5af0
movzwl %r15w, %r10d
movzbl 0x78(%rbx,%r10,8), %ecx
cmpl %ecx, %edx
jl 0x65c8
movzbl 0x79(%rbx,%r10,8), %esi
movslq %edx, %rdx
subq %rcx, %rdx
movq %r11, %rbp
movl %edx, %ecx
shrq %cl, %rbp
movl %ebp, %r15d
movl %esi, %ecx
shrl %cl, %r15d
addw 0x7a(%rbx,%r10,8), %r15w
cmpw $0x40, %r15w
jae 0x660f
leaq 0x3943(%rip), %rcx      # 0x9300
andl (%rcx,%rsi,8), %ebp
addl 0x7c(%rbx,%r10,8), %ebp
movslq %ebp, %rcx
addq 0x8(%rsp), %rcx
cmpq 0x98(%rsp), %rcx
jae 0x5af0
movzwl %r12w, %esi
movzbl 0x278(%rbx,%rsi,8), %eax
cmpl %eax, %edx
jl 0x65c8
leaq 0x390a(%rip), %rcx      # 0x9300
andq (%rcx,%rdx,8), %r11
movzbl 0x279(%rbx,%rsi,8), %ecx
movq %rcx, 0x20(%rsp)
movslq %edx, %rdx
subq %rax, %rdx
movq %r11, %r10
movl %edx, %ecx
shrq %cl, %r10
movl %r10d, %r12d
movq 0x20(%rsp), %rcx
shrl %cl, %r12d
addw 0x27a(%rbx,%rsi,8), %r12w
cmpw $0x40, %r12w
jae 0x662e
movq %rsi, 0x70(%rsp)
movzwl %r13w, %eax
movzbl 0x478(%rbx,%rax,8), %ecx
cmpl %ecx, %edx
jl 0x65c8
leaq 0x38ac(%rip), %rsi      # 0x9300
andq (%rsi,%rdx,8), %r11
movzbl 0x479(%rbx,%rax,8), %esi
movslq %edx, %rdx
subq %rcx, %rdx
movq %r11, 0x30(%rsp)
movl %edx, %ecx
shrq %cl, %r11
movl %r11d, %r13d
movq %rsi, %rcx
movq %rsi, 0x68(%rsp)
shrl %cl, %r13d
addw 0x47a(%rbx,%rax,8), %r13w
movzwl %r13w, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jae 0x664d
movq 0x20(%rsp), %rcx
leaq 0x385d(%rip), %rsi      # 0x9300
andl (%rsi,%rcx,8), %r10d
movq 0x70(%rsp), %rcx
addl 0x27c(%rbx,%rcx,8), %r10d
movq 0x68(%rsp), %rcx
andl (%rsi,%rcx,8), %r11d
movq %rsi, %rcx
addl 0x47c(%rbx,%rax,8), %r11d
movq 0x30(%rsp), %rsi
andq (%rcx,%rdx,8), %rsi
testl %r11d, %r11d
cmovel (%rsp), %r11d
movl 0x18(%rsp), %eax
decl %eax
movl %r11d, (%rsp)
movq %r9, %rcx
movq %rsi, %r11
movl %eax, %esi
jmp 0x56e7
xorl %ecx, %ecx
jmp 0x5bb9
xorl %eax, %eax
movb $0x1, %cl
jmp 0x5bb5
testl %ebp, %ebp
movq 0x8(%rsp), %rbp
je 0x5b1d
xorl %r9d, %r9d
movb (%rbp,%r9), %r11b
movb %r11b, (%r14,%r9)
incq %r9
cmpq %r9, %rsi
jne 0x5b0c
addq %rsi, %rbp
movslq %r10d, %r11
movq 0x20(%rsp), %r9
subq %r11, %r9
movq %rbp, 0x8(%rsp)
jge 0x5be3
cmpq %rsi, %rcx
je 0x5b5e
movslq (%rsp), %rsi
movq 0x20(%rsp), %r9
cmpq $0x1, %r9
adcq $0x0, %r9
negq %rsi
movb (%rax,%rsi), %r11b
movb %r11b, (%rax)
incq %rax
decq %r9
jne 0x5b4f
subl 0x20(%rsp), %r10d
xorl %ebp, %ebp
movq 0x30(%rsp), %r9
movq 0x8(%rsp), %r11
addq %rcx, %r14
movl %ebp, 0x48(%rbx)
movl %r10d, 0x4c(%rbx)
movl (%rsp), %eax
movl %eax, 0x50(%rbx)
movw %r15w, 0x6c(%rbx)
movw %r12w, 0x6e(%rbx)
movw %r13w, 0x70(%rbx)
movq %r9, 0x58(%rbx)
movl %edx, 0x60(%rbx)
movl 0x40(%rsp), %eax
movl %eax, 0x64(%rbx)
movl 0x18(%rsp), %eax
movl %eax, 0x38(%rbx)
subl (%rbx), %r8d
movl %r8d, 0x68(%rbx)
movq %r11, 0x40(%rbx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
xorl %ecx, %ecx
movq %r14, 0x18(%rbx)
movl 0x10(%rsp), %edx
testb %cl, %cl
je 0x5bd2
movl $0x0, 0x34(%rbx)
movl 0x3c(%rbx), %eax
addq %rax, (%rbx)
xorl %edi, %edi
movl %edx, %eax
movl %eax, %r15d
testb %dil, %dil
je 0x544b
jmp 0x6559
testl %r10d, %r10d
je 0x5c04
movslq (%rsp), %rcx
negq %rcx
movq %rax, %rsi
movq %r11, %r10
movb (%rsi,%rcx), %bpl
movb %bpl, (%rsi)
incq %rsi
decq %r10
jne 0x5bf5
addq %r11, %rax
addq $-0x20, %r9
jmp 0x58f5
cmpl $0x24787662, %edx       # imm = 0x24787662
je 0x5c8f
cmpl $0x2d787662, %edx       # imm = 0x2D787662
jne 0x562c
addq $0x8, %r14
cmpq %r12, %r14
jbe 0x5cc5
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x58c5
cmpl $0x32787662, %edx       # imm = 0x32787662
jne 0x5c79
leaq 0x20(%r14), %rbp
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edi
cmpq %r12, %rbp
ja 0x645f
movl 0x18(%r14), %r13d
leaq (%r14,%r13), %rax
cmpq %r12, %rax
movl %edx, 0x8(%rsp)
jbe 0x5cdc
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
xorl %eax, %eax
jmp 0x5f02
leaq 0x304(%r14), %rax
cmpq %r12, %rax
jbe 0x5ca1
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
jmp 0x60ca
movq %rax, (%rbx)
movl $0x1, 0x30(%rbx)
xorl %r15d, %r15d
jmp 0x58c5
movl %edx, 0x8(%rsp)
movl $0x304, %r13d           # imm = 0x304
movl $0x304, %edx            # imm = 0x304
leaq 0xa0(%rsp), %rdi
movq %r14, %rsi
callq 0x30c0
jmp 0x5f0a
movl (%rax), %eax
movl %eax, 0xb904(%rbx)
movq %r14, (%rbx)
movl $0x2d787662, 0x34(%rbx) # imm = 0x2D787662
jmp 0x57db
movl $0x304, %edx            # imm = 0x304
leaq 0xa0(%rsp), %rdi
xorl %esi, %esi
callq 0x3080
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
movl $0x31787662, 0xa0(%rsp) # imm = 0x31787662
movl 0x4(%r14), %eax
movl %eax, 0xa4(%rsp)
movl %esi, %eax
movl $0xfffff, %r8d          # imm = 0xFFFFF
andl %r8d, %eax
movl %eax, 0xac(%rsp)
movq %rsi, %rax
shrq $0x14, %rax
andl %r8d, %eax
movl %eax, 0xb4(%rsp)
movq %rsi, %rdi
shrq $0x3c, %rdi
andl $0x7, %edi
addl $-0x7, %edi
movl %edi, 0xbc(%rsp)
movl %edx, %edi
movl $0x3ff, %r9d            # imm = 0x3FF
andl %r9d, %edi
movw %di, 0xc0(%rsp)
movl %edx, %edi
shrl $0xa, %edi
andl %r9d, %edi
movw %di, 0xc2(%rsp)
movl %edx, %edi
shrl $0x14, %edi
andl %r9d, %edi
movw %di, 0xc4(%rsp)
movq %rdx, %rdi
shrq $0x1e, %rdi
andl %r9d, %edi
movw %di, 0xc6(%rsp)
shrq $0x28, %rsi
andl %r8d, %esi
movl %esi, 0xb0(%rsp)
movq %rdx, %rsi
shrq $0x28, %rsi
andl %r8d, %esi
movl %esi, 0xb8(%rsp)
shrq $0x3c, %rdx
andl $0x7, %edx
addl $-0x7, %edx
movl %edx, 0xc8(%rsp)
movq %rcx, %rdi
movq %rcx, %r8
movl %ecx, %edx
shrq $0x20, %rcx
andl %r9d, %ecx
movw %cx, 0xcc(%rsp)
shrq $0x2a, %rdi
andl %r9d, %edi
movw %di, 0xce(%rsp)
shrq $0x34, %r8
andl %r9d, %r8d
movw %r8w, 0xd0(%rsp)
addl %eax, %esi
movl %esi, 0xa8(%rsp)
movb $0x1, %al
cmpq $0x20, %rdx
je 0x5ef2
addq %r14, %rdx
xorl %esi, %esi
xorl %r8d, %r8d
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdx, %rbp
jae 0x5e43
cmpl $0x18, %eax
jg 0x5e43
movl %edi, %r10d
movzbl (%rbp), %edi
movl %eax, %ecx
shll %cl, %edi
leal 0x8(%rax), %r9d
orl %r10d, %edi
incq %rbp
cmpq %rdx, %rbp
jae 0x5e46
cmpl $0x11, %eax
movl %r9d, %eax
jl 0x5e1f
jmp 0x5e46
movl %eax, %r9d
movl %edi, %eax
andl $0x1f, %eax
movl %edi, %ecx
andl $0xf, %ecx
cmpl $0xf, %ecx
je 0x5e6b
cmpl $0x7, %ecx
jne 0x5e7f
movl %edi, %r10d
shrl $0x4, %r10d
andl $0xf, %r10d
addl $0x8, %r10d
jmp 0x5e8b
movl %edi, %r10d
shrl $0x4, %r10d
andl $0x3ff, %r10d           # imm = 0x3FF
addl $0x18, %r10d
jmp 0x5e8b
leaq 0x3c6a(%rip), %rcx      # 0x9af0
movsbl (%rax,%rcx), %r10d
leaq 0x3c3e(%rip), %rcx      # 0x9ad0
movsbl (%rax,%rcx), %ecx
cmpl %ecx, %r9d
movl %ecx, %r11d
movl $0x0, %eax
cmovll %eax, %r11d
movl %r9d, %eax
subl %r11d, %eax
movw %r10w, 0xd2(%rsp,%rsi,2)
cmpl %ecx, %r9d
jl 0x5eda
shrl %cl, %edi
cmpq $0x167, %rsi            # imm = 0x167
leaq 0x1(%rsi), %rcx
setae %r8b
movq %rcx, %rsi
cmpq $0x168, %rcx            # imm = 0x168
jne 0x5e15
testb $0x1, %r8b
je 0x5ef0
cmpl $0x8, %eax
setl %cl
cmpq %rdx, %rbp
sete %al
andb %cl, %al
jmp 0x5ef2
xorl %eax, %eax
testb %al, %al
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
cmovel %ecx, %r15d
movl $0x1, %edi
testb %al, %al
je 0x645c
addq %r13, %r14
movl 0xb4(%rsp), %ecx
movl 0xb8(%rsp), %eax
addq %r14, %rcx
addq %rax, %rcx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edi
cmpq %r12, %rcx
ja 0x645f
movq %rax, 0x10(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, (%rsp)
xorl %esi, %esi
cmpl $0x9c41, 0xac(%rsp) # imm = 0x9C41
setae %sil
addl %esi, %esi
movl 0xb0(%rsp), %eax
xorl %r8d, %r8d
movl %eax, 0x38(%rsp)
cmpl $0x2711, %eax           # imm = 0x2711
setae %r8b
shll $0x2, %r8d
xorl %r9d, %r9d
movw $0x400, %ax             # imm = 0x400
cmpw %ax, 0xc0(%rsp)
setae %r9b
xorl %r10d, %r10d
cmpw %ax, 0xc2(%rsp)
setae %r10b
xorl %edx, %edx
cmpw %ax, 0xc4(%rsp)
setae %dl
xorl %r11d, %r11d
cmpw %ax, 0xc6(%rsp)
setae %r11b
shll $0x3, %r9d
shll $0x4, %r10d
shll $0x5, %edx
shll $0x6, %r11d
xorl %r12d, %r12d
cmpw $0x40, 0xcc(%rsp)
setae %r12b
shll $0x7, %r12d
xorl %r13d, %r13d
cmpw $0x40, 0xce(%rsp)
setae %r13b
shll $0x8, %r13d
xorl %ebp, %ebp
cmpw $0x100, 0xd0(%rsp)      # imm = 0x100
setae %bpl
shll $0x9, %ebp
xorl %edi, %edi
xorl %ecx, %ecx
movzwl 0xd2(%rsp,%rdi,2), %eax
addq %rax, %rcx
incq %rdi
cmpq $0x14, %rdi
jne 0x5ffd
xorl %eax, %eax
cmpl $0x31787662, (%rsp)     # imm = 0x31787662
setne %al
orl %r8d, %esi
orl %r9d, %esi
orl %r10d, %esi
orl %eax, %esi
orl %r11d, %edx
orl %r12d, %edx
orl %r13d, %edx
orl %esi, %edx
xorl %esi, %esi
cmpq $0x41, %rcx
setae %sil
shll $0xa, %esi
xorl %edi, %edi
xorl %ecx, %ecx
movzwl 0xfa(%rsp,%rdi,2), %eax
addq %rax, %rcx
incq %rdi
cmpq $0x14, %rdi
jne 0x6044
orl %ebp, %edx
xorl %edi, %edi
cmpq $0x41, %rcx
setae %dil
shll $0xb, %edi
xorl %ecx, %ecx
xorl %r8d, %r8d
movzwl 0x122(%rsp,%rcx,2), %eax
addq %rax, %r8
incq %rcx
cmpq $0x40, %rcx
jne 0x606c
orl %esi, %edx
xorl %ecx, %ecx
cmpq $0x101, %r8             # imm = 0x101
setae %cl
shll $0xc, %ecx
xorl %r8d, %r8d
xorl %esi, %esi
movzwl 0x1a2(%rsp,%r8,2), %eax
addq %rax, %rsi
incq %r8
cmpq $0x100, %r8             # imm = 0x100
jne 0x6096
orl %edi, %edx
orl %ecx, %edx
xorl %eax, %eax
cmpq $0x401, %rsi            # imm = 0x401
setae %al
shll $0xd, %eax
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
orl %edx, %eax
je 0x60d4
movl $0x1, %edi
jmp 0x645f
movq %r14, (%rbx)
movq 0x10(%rsp), %rax
movl %eax, 0x3c(%rbx)
movl 0x38(%rsp), %eax
movl %eax, 0x38(%rbx)
movl $0x400, %edi            # imm = 0x400
movl $0x100, %esi            # imm = 0x100
leaq 0x1a2(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x7ae4
movl $0x40, %edi
movl $0x14, %esi
leaq 0xd2(%rsp), %rdx
leaq 0x2fc5(%rip), %rcx      # 0x90e0
leaq 0x2fde(%rip), %r8       # 0x9100
movq 0x90(%rsp), %r9
callq 0x7c32
movl $0x40, %edi
movl $0x14, %esi
leaq 0xfa(%rsp), %rdx
leaq 0x3008(%rip), %rcx      # 0x9150
leaq 0x3021(%rip), %r8       # 0x9170
movq 0x88(%rsp), %r9
callq 0x7c32
movl $0x100, %edi            # imm = 0x100
movl $0x40, %esi
leaq 0x122(%rsp), %rdx
leaq 0x304b(%rip), %rcx      # 0x91c0
leaq 0x3084(%rip), %r8       # 0x9200
movq 0x80(%rsp), %r9
callq 0x7c32
movl 0xb4(%rsp), %r8d
addq (%rbx), %r8
movq 0x8(%rbx), %r10
movq %r8, (%rbx)
movl 0xbc(%rsp), %eax
testl %eax, %eax
je 0x61bc
leaq 0x8(%r10), %rcx
cmpq %rcx, %r8
jae 0x61d2
xorl %eax, %eax
movq %r8, (%rsp)
movq 0x48(%rsp), %r13
jmp 0x6229
leaq 0x7(%r10), %rax
cmpq %rax, %r8
movq 0x48(%rsp), %r13
jae 0x61e5
xorl %eax, %eax
movq %r8, (%rsp)
jmp 0x6229
leaq -0x8(%r8), %rcx
movq %rcx, (%rsp)
movq -0x8(%r8), %r13
addl $0x40, %eax
movl %eax, %ecx
jmp 0x620c
leaq -0x7(%r8), %rax
movq %rax, (%rsp)
movzwl -0x3(%r8), %eax
movzbl -0x1(%r8), %ecx
shll $0x10, %ecx
orl %eax, %ecx
shlq $0x20, %rcx
movl -0x7(%r8), %r13d
orq %rcx, %r13
movl $0x38, %ecx
leal -0x40(%rcx), %eax
cmpl $-0x8, %eax
movq %rcx, 0x28(%rsp)
jae 0x621d
xorl %eax, %eax
jmp 0x6229
movq %r13, %rax
shrq %cl, %rax
testq %rax, %rax
sete %al
testb %al, %al
je 0x6425
movl 0xac(%rsp), %eax
movl $0x5, %edi
movl %eax, 0x38(%rsp)
testl %eax, %eax
setne %r14b
je 0x6442
movq %r8, 0x40(%rsp)
movl %r15d, 0x10(%rsp)
movzwl 0xc6(%rsp), %r11d
movzwl 0xc4(%rsp), %ebp
movzwl 0xc0(%rsp), %r9d
movzwl 0xc2(%rsp), %r12d
xorl %r8d, %r8d
movq 0x28(%rsp), %r15
movq %r10, 0x18(%rsp)
movl $0x3f, %ecx
subl %r15d, %ecx
movl %ecx, %eax
sarl $0x3, %eax
negl %eax
cltq
addq (%rsp), %rax
cmpq %r10, %rax
jae 0x62a8
movq %r15, 0x28(%rsp)
jmp 0x62f5
andl $-0x8, %ecx
addl %ecx, %r15d
movl %r15d, %edx
andl $-0x8, %edx
cmpl $0x38, %edx
jne 0x65e7
movq %r13, %rdi
shlq %cl, %rdi
movslq %ecx, %rcx
movq (%rax), %rdx
leaq 0x3030(%rip), %rsi      # 0x9300
andq (%rsi,%rcx,8), %rdx
orq %rdx, %rdi
movq %rdi, %r13
movq %rdi, %rdx
movq %r15, 0x28(%rsp)
movl %r15d, %ecx
shrq %cl, %rdx
movq %rax, (%rsp)
testq %rdx, %rdx
jne 0x65f0
cmpq %r10, %rax
jb 0x6432
movzwl %r9w, %eax
movq 0x58(%rsp), %rcx
movl (%rcx,%rax,4), %edx
movzbl %dl, %eax
movq 0x28(%rsp), %rcx
subl %eax, %ecx
jl 0x65c8
movq %r13, %r9
shrq %cl, %r9
movslq %ecx, %rcx
leaq 0x2fd6(%rip), %rsi      # 0x9300
movq (%rsi,%rcx,8), %r10
movl %r8d, %eax
movl %edx, %edi
movb %dh, 0x1c78(%rbx,%rax)
movzwl %r12w, %eax
movl 0xc78(%rbx,%rax,4), %edx
movzbl %dl, %eax
subl %eax, %ecx
jl 0x65c8
andq %r13, %r10
movq %r10, %r12
shrq %cl, %r12
movslq %ecx, %rcx
movq (%rsi,%rcx,8), %r14
leal 0x1(%r8), %eax
movb %dh, 0x1c78(%rbx,%rax)
movzwl %bp, %eax
movl 0xc78(%rbx,%rax,4), %eax
movzbl %al, %ebp
subl %ebp, %ecx
jl 0x65c8
movl %edx, %esi
movslq %ecx, %r15
leaq 0x2f74(%rip), %rdx      # 0x9300
movq (%rdx,%r15,8), %r13
leal 0x2(%r8), %ebp
movb %ah, 0x1c78(%rbx,%rbp)
movzwl %r11w, %r11d
movl 0xc78(%rbx,%r11,4), %edx
movzbl %dl, %r11d
subl %r11d, %r15d
jl 0x65c8
shrl $0x10, %edi
addl %edi, %r9d
andq %r10, %r14
andq %r14, %r13
shrq %cl, %r14
shrl $0x10, %esi
addl %esi, %r12d
shrl $0x10, %eax
addl %eax, %r14d
movq %r13, %r11
movl %r15d, %ecx
shrq %cl, %r11
movl %edx, %eax
shrl $0x10, %eax
addl %eax, %r11d
movslq %r15d, %rax
leaq 0x2f16(%rip), %rcx      # 0x9300
andq (%rcx,%rax,8), %r13
leal 0x3(%r8), %eax
movb %dh, 0x1c78(%rbx,%rax)
addl $0x4, %r8d
movl %r14d, %ebp
cmpl 0x38(%rsp), %r8d
setb %r14b
movq 0x18(%rsp), %r10
jb 0x6287
movq %r15, 0x28(%rsp)
movl 0x10(%rsp), %r15d
movl $0x5, %edi
jmp 0x643d
movl $0xfffffffd, %r15d      # imm = 0xFFFFFFFD
movl $0x1, %edi
jmp 0x6453
movl $0xfffffffd, %r15d      # imm = 0xFFFFFFFD
movl $0x1, %edi
movq 0x40(%rsp), %r8
testb $0x1, %r14b
jne 0x6453
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rbx)
xorl %edi, %edi
testl %edi, %edi
movq %r13, 0x48(%rsp)
je 0x646d
movl %r15d, %esi
cmpl $0x1, %edi
sete %cl
movl %esi, %r15d
jmp 0x58c5
movl 0xb8(%rsp), %ecx
movl 0xc8(%rsp), %eax
movq %rcx, %rdx
addq %r8, %rdx
testl %eax, %eax
je 0x6499
cmpl $0x8, %ecx
jb 0x64d0
movq -0x8(%rdx), %rsi
addq $-0x8, %rdx
addl $0x40, %eax
movl %eax, %ecx
jmp 0x64be
cmpl $0x7, %ecx
jb 0x64d0
movzwl -0x3(%rdx), %eax
movzbl -0x1(%rdx), %ecx
movl -0x7(%rdx), %esi
addq $-0x7, %rdx
shll $0x10, %ecx
orl %eax, %ecx
shlq $0x20, %rcx
orq %rcx, %rsi
movl $0x38, %ecx
leal -0x40(%rcx), %eax
cmpl $-0x8, %eax
movq %rsi, 0x60(%rsp)
movq %rcx, 0x50(%rsp)
jae 0x64d4
xorl %eax, %eax
jmp 0x64e0
movq %rsi, %rax
shrq %cl, %rax
testq %rax, %rax
sete %al
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
testb %al, %al
je 0x6536
movzwl 0xcc(%rsp), %ecx
movw %cx, 0x6c(%rbx)
movzwl 0xce(%rsp), %ecx
movw %cx, 0x6e(%rbx)
movzwl 0xd0(%rsp), %ecx
movw %cx, 0x70(%rbx)
subl %r8d, %edx
movl %edx, 0x68(%rbx)
movq $0x0, 0x48(%rbx)
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movq 0x60(%rsp), %rcx
movq %rcx, 0x58(%rbx)
movq 0x50(%rsp), %rcx
movl %ecx, 0x60(%rbx)
movl %r15d, %esi
movl $0x1, %edi
testb %al, %al
je 0x645f
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rbx)
movl $0x4, %edi
jmp 0x645f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x3a8, %rsp            # imm = 0x3A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3345(%rip), %rdi      # 0x98b7
leaq 0x3252(%rip), %rsi      # 0x97cb
leaq 0x3357(%rip), %rcx      # 0x98d7
movl $0xab, %edx
callq 0x3070
leaq 0x3372(%rip), %rdi      # 0x9903
leaq 0x3233(%rip), %rsi      # 0x97cb
leaq 0x3338(%rip), %rcx      # 0x98d7
movl $0xac, %edx
callq 0x3070
leaq 0x3373(%rip), %rdi      # 0x9923
leaq 0x3214(%rip), %rsi      # 0x97cb
leaq 0x3319(%rip), %rcx      # 0x98d7
movl $0xad, %edx
callq 0x3070
leaq 0x3291(%rip), %rdi      # 0x9860
leaq 0x30a7(%rip), %rsi      # 0x967d
leaq 0x32a1(%rip), %rcx      # 0x987e
movl $0x198, %edx            # imm = 0x198
callq 0x3070
leaq 0x31f5(%rip), %rdi      # 0x97e3
jmp 0x65f7
leaq 0x30e3(%rip), %rdi      # 0x96da
leaq 0x307f(%rip), %rsi      # 0x967d
leaq 0x320a(%rip), %rcx      # 0x980f
movl $0x178, %edx            # imm = 0x178
callq 0x3070
leaq 0x32a1(%rip), %rdi      # 0x98b7
leaq 0x31ae(%rip), %rsi      # 0x97cb
leaq 0x32b3(%rip), %rcx      # 0x98d7
movl $0xc6, %edx
callq 0x3070
leaq 0x32ce(%rip), %rdi      # 0x9903
leaq 0x318f(%rip), %rsi      # 0x97cb
leaq 0x3294(%rip), %rcx      # 0x98d7
movl $0xcf, %edx
callq 0x3070
leaq 0x32cf(%rip), %rdi      # 0x9923
leaq 0x3170(%rip), %rsi      # 0x97cb
leaq 0x3275(%rip), %rcx      # 0x98d7
movl $0xd5, %edx
callq 0x3070