// File: /workspace/github_cpp_makefile_star2_O3/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 $0x388, %rsp            # imm = 0x388
movq %rdi, %rbx
leaq 0xb8f8(%rdi), %rax
movq %rax, 0x58(%rsp)
leaq 0x78(%rdi), %rax
movq %rax, 0x50(%rsp)
leaq 0x278(%rdi), %rax
movq %rax, 0x38(%rsp)
leaq 0x478(%rdi), %rax
movq %rax, 0x48(%rsp)
leaq 0xc78(%rdi), %rax
movq %rax, 0x68(%rsp)
leaq 0x1c78(%rdi), %rax
movq %rax, 0x60(%rsp)
pxor %xmm0, %xmm0
movq %rdi, 0x18(%rsp)
movl 0x34(%rbx), %eax
cmpl $0x31787661, %eax       # imm = 0x31787661
jle 0x5517
cmpl $0x31787662, %eax       # imm = 0x31787662
je 0x558c
cmpl $0x32787662, %eax       # imm = 0x32787662
je 0x558c
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
cmpl $0x6e787662, %eax       # imm = 0x6E787662
jne 0x630d
movl 0xb8fc(%rbx), %eax
testq %rax, %rax
sete %dil
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
seta %r8b
orb %dil, %r8b
cmpb $0x1, %r8b
jne 0x6264
leaq 0xb2(%rsp), %rdi
movdqu %xmm0, 0x16(%rdi)
movdqu %xmm0, 0x6(%rdi)
movdqu %xmm0, -0xa(%rdi)
movq %rcx, 0x80(%rsp)
addq %rax, %rcx
cmpq %rax, %rsi
cmovgq %rcx, %rdx
movq %rdx, 0x88(%rsp)
movq 0x20(%rbx), %rax
movq %rax, 0x98(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x90(%rsp)
movq 0x28(%rbx), %rdx
movq %rdx, 0xa0(%rsp)
subq %rax, %rdx
movl 0xb8f8(%rbx), %ecx
cmpq %rcx, %rdx
jle 0x545c
addq %rcx, %rax
movq %rax, 0xa0(%rsp)
movl 0xb900(%rbx), %eax
movq %rax, 0xc8(%rsp)
movl $0x0, 0xd0(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x727c
movq 0x80(%rsp), %rdi
movq %rdi, %rdx
subq (%rbx), %rdx
movl 0xb8fc(%rbx), %esi
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
cmpq %rsi, %rdx
ja 0x630d
movq 0x90(%rsp), %r8
movq %r8, %rax
subq 0x18(%rbx), %rax
movq 0x58(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
ja 0x630d
movq %rdi, (%rbx)
movq %r8, 0x18(%rbx)
movl %ecx, %edi
subl %eax, %edi
subl %edx, %esi
movl %esi, 0xb8fc(%rbx)
movl %edi, 0xb8f8(%rbx)
movl 0xc8(%rsp), %edx
movl %edx, 0xb900(%rbx)
movl 0xd0(%rsp), %edx
jne 0x6322
cmpl %eax, %ecx
jne 0x630d
testl %edx, %edx
je 0x630d
movl $0x0, 0x34(%rbx)
pxor %xmm0, %xmm0
jmp 0x538e
testl %eax, %eax
je 0x563a
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
cmpl $0x2d787662, %eax       # imm = 0x2D787662
jne 0x630d
movl 0xb904(%rbx), %eax
testq %rax, %rax
je 0x5836
movq (%rbx), %rsi
movq 0x10(%rbx), %rcx
subq %rsi, %rcx
jbe 0x6264
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %r15
subq %rdi, %r15
jbe 0x6307
cmpq %rax, %rcx
cmovael %eax, %ecx
cmpq %rcx, %r15
cmovael %ecx, %r15d
movq %r15, %rdx
callq 0x30c0
pxor %xmm0, %xmm0
addq %r15, (%rbx)
addq %r15, 0x18(%rbx)
subl %r15d, 0xb904(%rbx)
jmp 0x538e
movq (%rbx), %r11
movq 0x10(%rbx), %rax
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
subq %r11, %rax
jbe 0x630d
movl 0x3c(%rbx), %ecx
cmpq %rcx, %rax
jb 0x630d
movzwl 0x6c(%rbx), %eax
cmpw $0x40, %ax
jae 0x63fe
movzwl 0x6e(%rbx), %ecx
cmpw $0x40, %cx
jae 0x641d
movl %ecx, 0x10(%rsp)
movl %eax, 0x20(%rsp)
movzwl 0x70(%rbx), %eax
movl %eax, 0xc(%rsp)
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jae 0x643c
movq 0x58(%rbx), %rdx
movl 0x60(%rbx), %eax
movl 0x64(%rbx), %ecx
movl %ecx, 0x44(%rsp)
movq 0x8(%rbx), %rcx
movq %rcx, 0x70(%rsp)
movq 0x18(%rbx), %rbp
movl 0x68(%rbx), %ecx
addq %rcx, %r11
movq 0x40(%rbx), %r9
movl 0x38(%rbx), %r15d
movl 0x48(%rbx), %edi
movl 0x4c(%rbx), %r12d
movl 0x50(%rbx), %r8d
movq 0x28(%rbx), %r14
subq %rbp, %r14
addq $-0x20, %r14
movl %edi, %ecx
orl %r12d, %ecx
movq %r14, %rsi
jne 0x5f6c
jmp 0x6080
movq (%rbx), %r13
movq 0x10(%rbx), %r14
leaq 0x4(%r13), %rax
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpq %r14, %rax
ja 0x630d
movl (%r13), %r15d
cmpl $0x32787661, %r15d      # imm = 0x32787661
jg 0x567c
cmpl $0x2d787662, %r15d      # imm = 0x2D787662
je 0x5b94
cmpl $0x31787662, %r15d      # imm = 0x31787662
je 0x56d8
jmp 0x633c
cmpl $0x32787662, %r15d      # imm = 0x32787662
je 0x56d8
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
cmpl $0x6e787662, %r15d      # imm = 0x6E787662
jne 0x630d
leaq 0xc(%r13), %rax
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
cmpq %r14, %rax
ja 0x630d
movl 0x4(%r13), %ecx
movl %ecx, 0xb8f8(%rbx)
movl 0x8(%r13), %ecx
movl %ecx, 0xb8fc(%rbx)
movl $0x0, 0xb900(%rbx)
movq %rax, (%rbx)
movl $0x6e787662, 0x34(%rbx) # imm = 0x6E787662
jmp 0x538e
cmpl $0x32787662, %r15d      # imm = 0x32787662
jne 0x5842
leaq 0x20(%r13), %rbp
cmpq %r14, %rbp
ja 0x630d
movl 0x18(%r13), %r12d
leaq (%r12,%r13), %rax
cmpq %r14, %rax
leaq 0x441c(%rip), %rbx      # 0x9b20
ja 0x630d
movl $0x304, %edx            # imm = 0x304
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x3080
movq 0x8(%r13), %rax
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rcx
movl $0x31787662, 0x80(%rsp) # imm = 0x31787662
movl 0x4(%r13), %edx
movl %edx, 0x84(%rsp)
movl %eax, %edx
movl $0xfffff, %r10d         # imm = 0xFFFFF
andl %r10d, %edx
movl %edx, 0x8c(%rsp)
movq %rax, %rdx
shrq $0x14, %rdx
andl %r10d, %edx
movl %edx, 0x94(%rsp)
movq %rax, %rdi
shrq $0x3c, %rdi
andl $0x7, %edi
addl $-0x7, %edi
movl %edi, 0x9c(%rsp)
movl %esi, %edi
shrl $0xa, %edi
movq %rsi, %r8
movd %esi, %xmm0
movl %esi, %r9d
shrl $0x14, %r9d
pinsrw $0x1, %edi, %xmm0
pinsrw $0x2, %r9d, %xmm0
shrq $0x1e, %r8
pinsrw $0x3, %r8d, %xmm0
pand 0x4329(%rip), %xmm0     # 0x9ad0
movq %xmm0, 0xa0(%rsp)
shrq $0x28, %rax
andl %r10d, %eax
movl %eax, 0x90(%rsp)
movq %rsi, %rax
shrq $0x28, %rax
andl %r10d, %eax
movl %eax, 0x98(%rsp)
shrq $0x3c, %rsi
andl $0x7, %esi
addl $-0x7, %esi
movl %esi, 0xa8(%rsp)
movq %rcx, %rdi
movq %rcx, %r8
movl %ecx, %esi
shrq $0x20, %rcx
movl $0x3ff, %r9d            # imm = 0x3FF
andl %r9d, %ecx
movw %cx, 0xac(%rsp)
shrq $0x2a, %rdi
andl %r9d, %edi
movw %di, 0xae(%rsp)
shrq $0x34, %r8
andl %r9d, %r8d
movw %r8w, 0xb0(%rsp)
leal (%rax,%rdx), %ecx
movl %ecx, 0x88(%rsp)
cmpq $0x20, %rsi
jne 0x5e0b
pxor %xmm2, %xmm2
jmp 0x587f
movl $0x0, 0x34(%rbx)
jmp 0x538e
leaq 0x304(%r13), %rax
cmpq %r14, %rax
ja 0x630d
movl $0x304, %r12d           # imm = 0x304
movl $0x304, %edx            # imm = 0x304
leaq 0x80(%rsp), %rdi
movq %r13, %rsi
callq 0x30c0
pxor %xmm2, %xmm2
movl 0x94(%rsp), %edx
movl 0x98(%rsp), %eax
addq %r12, %r13
movl %edx, %ecx
addq %r13, %rcx
movl %eax, %edx
addq %rcx, %rdx
cmpq %r14, %rdx
ja 0x6264
movl %r15d, 0x14(%rsp)
movl 0x80(%rsp), %r9d
xorl %esi, %esi
cmpl $0x9c41, 0x8c(%rsp) # imm = 0x9C41
setae %sil
addl %esi, %esi
movl 0x90(%rsp), %ecx
xorl %edi, %edi
cmpl $0x2711, %ecx           # imm = 0x2711
setae %dil
shll $0x2, %edi
xorl %r10d, %r10d
movw $0x400, %r8w            # imm = 0x400
cmpw %r8w, 0xa0(%rsp)
setae %r10b
xorl %r11d, %r11d
cmpw %r8w, 0xa2(%rsp)
setae %r11b
xorl %edx, %edx
cmpw %r8w, 0xa4(%rsp)
setae %dl
xorl %ebp, %ebp
cmpw %r8w, 0xa6(%rsp)
setae %bpl
shll $0x3, %r10d
shll $0x4, %r11d
shll $0x5, %edx
shll $0x6, %ebp
xorl %ebx, %ebx
cmpw $0x40, 0xac(%rsp)
setae %bl
shll $0x7, %ebx
xorl %r14d, %r14d
cmpw $0x40, 0xae(%rsp)
setae %r14b
shll $0x8, %r14d
xorl %r8d, %r8d
cmpw $0x100, 0xb0(%rsp)      # imm = 0x100
setae %r8b
shll $0x9, %r8d
pxor %xmm0, %xmm0
movl $0x19, %r15d
movd 0x80(%rsp,%r15,2), %xmm1
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddq %xmm1, %xmm0
addq $0x2, %r15
cmpq $0x2d, %r15
jne 0x595f
xorl %r15d, %r15d
cmpl $0x31787662, %r9d       # imm = 0x31787662
setne %r15b
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %r12
xorl %r9d, %r9d
cmpq $0x41, %r12
setae %r9b
orl %edi, %esi
orl %r10d, %esi
orl %r11d, %esi
orl %r15d, %esi
orl %ebp, %edx
orl %ebx, %edx
orl %r14d, %edx
orl %esi, %edx
shll $0xa, %r9d
pxor %xmm0, %xmm0
movl $0x2d, %esi
movd 0x80(%rsp,%rsi,2), %xmm1
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddq %xmm1, %xmm0
addq $0x2, %rsi
cmpq $0x41, %rsi
jne 0x59c7
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %rdi
xorl %esi, %esi
cmpq $0x41, %rdi
setae %sil
orl %r8d, %edx
shll $0xb, %esi
pxor %xmm0, %xmm0
movl $0x41, %edi
movq 0x18(%rsp), %rbx
movq 0x38(%rsp), %r14
movq 0x48(%rsp), %r12
movd 0x80(%rsp,%rdi,2), %xmm1
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddq %xmm1, %xmm0
addq $0x2, %rdi
cmpq $0x81, %rdi
jne 0x5a1c
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %r8
xorl %edi, %edi
cmpq $0x101, %r8             # imm = 0x101
setae %dil
orl %r9d, %edx
shll $0xc, %edi
pxor %xmm0, %xmm0
movl $0x81, %r8d
movd 0x80(%rsp,%r8,2), %xmm1
punpcklwd %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddq %xmm1, %xmm0
addq $0x2, %r8
cmpq $0x181, %r8             # imm = 0x181
jne 0x5a69
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddq %xmm0, %xmm1
movq %xmm1, %r8
xorl %r9d, %r9d
cmpq $0x401, %r8             # imm = 0x401
setae %r9b
orl %esi, %edx
orl %edi, %edx
shll $0xd, %r9d
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
orl %edx, %r9d
jne 0x630d
movq %r13, (%rbx)
movl %eax, 0x3c(%rbx)
movl %ecx, 0x38(%rbx)
movl $0x400, %edi            # imm = 0x400
movl $0x100, %esi            # imm = 0x100
leaq 0x182(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x7730
movl $0x40, %edi
movl $0x14, %esi
leaq 0xb2(%rsp), %rdx
leaq 0x35d3(%rip), %rcx      # 0x90d0
leaq 0x35ec(%rip), %r8       # 0x90f0
movq 0x50(%rsp), %r9
callq 0x7865
movl $0x40, %edi
movl $0x14, %esi
leaq 0xda(%rsp), %rdx
leaq 0x3619(%rip), %rcx      # 0x9140
leaq 0x3632(%rip), %r8       # 0x9160
movq %r14, %r9
callq 0x7865
movl $0x100, %edi            # imm = 0x100
movl $0x40, %esi
leaq 0x102(%rsp), %rdx
leaq 0x3661(%rip), %rcx      # 0x91b0
leaq 0x369a(%rip), %r8       # 0x91f0
movq %r12, %r9
callq 0x7865
movl 0x94(%rsp), %edi
addq (%rbx), %rdi
movq 0x8(%rbx), %r13
movq %rdi, (%rbx)
movl 0x9c(%rsp), %eax
testl %eax, %eax
je 0x5bb8
leaq 0x8(%r13), %rcx
cmpq %rcx, %rdi
jb 0x6259
leaq -0x8(%rdi), %r8
movq -0x8(%rdi), %r14
addl $0x40, %eax
jmp 0x5be6
addq $0x8, %r13
cmpq %r14, %r13
ja 0x630d
movl (%rax), %eax
movl %eax, 0xb904(%rbx)
movq %r13, (%rbx)
movl $0x2d787662, 0x34(%rbx) # imm = 0x2D787662
jmp 0x538e
leaq 0x7(%r13), %rax
cmpq %rax, %rdi
jb 0x6259
leaq -0x7(%rdi), %r8
movzwl -0x3(%rdi), %eax
movzbl -0x1(%rdi), %ecx
shll $0x10, %ecx
orl %eax, %ecx
shlq $0x20, %rcx
movl -0x7(%rdi), %r14d
orq %rcx, %r14
movl $0x38, %eax
movl %eax, %esi
andl $-0x8, %esi
movq %r14, %rdx
movl %eax, %ecx
shrq %cl, %rdx
cmpl $0x38, %esi
pxor %xmm0, %xmm0
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
jne 0x630d
testq %rdx, %rdx
jne 0x630d
movq %rdi, 0x28(%rsp)
movl 0x8c(%rsp), %ecx
movl %ecx, 0xc(%rsp)
testl %ecx, %ecx
movq 0x60(%rsp), %rdi
je 0x5dbd
movzwl 0xa6(%rsp), %r12d
movzwl 0xa4(%rsp), %ebp
movzwl 0xa0(%rsp), %r10d
movzwl 0xa2(%rsp), %esi
xorl %r15d, %r15d
movq %r13, 0x30(%rsp)
movl $0x3f, %ecx
subl %eax, %ecx
movl %ecx, %edi
shrl $0x3, %edi
negl %edi
movslq %edi, %rdi
addq %r8, %rdi
cmpq %r13, %rdi
jb 0x6259
andl $-0x8, %ecx
shlq %cl, %r14
addl %ecx, %eax
movl %eax, %edx
andl $-0x8, %edx
cmpl $0x38, %edx
jne 0x6379
leaq 0x3660(%rip), %r8       # 0x92f0
movq (%r8,%rcx,8), %rdx
andq (%rdi), %rdx
orq %r14, %rdx
movq %rdx, %r11
movl %eax, %ecx
shrq %cl, %r11
testq %r11, %r11
jne 0x6382
movzwl %r10w, %ecx
movq 0x68(%rsp), %r14
movl (%r14,%rcx,4), %ebx
movzbl %bl, %ecx
subl %ecx, %eax
jb 0x635a
movq %rdi, 0x20(%rsp)
movq %rdx, %r10
movl %eax, %ecx
shrq %cl, %r10
movslq %eax, %rcx
movq (%r8,%rcx,8), %r11
movl %r15d, %eax
movq 0x60(%rsp), %rdi
movl %ebx, %r9d
movb %bh, (%rdi,%rax)
movzwl %si, %eax
movl (%r14,%rax,4), %ebx
movzbl %bl, %eax
subl %eax, %ecx
jl 0x635a
andq %rdx, %r11
movq %r11, %rsi
shrq %cl, %rsi
movslq %ecx, %rcx
movq (%r8,%rcx,8), %r13
leal 0x1(%r15), %eax
movl %ebx, 0x10(%rsp)
movb %bh, (%rdi,%rax)
movzwl %bp, %eax
movl (%r14,%rax,4), %edx
movzbl %dl, %eax
subl %eax, %ecx
jl 0x635a
movq %r14, %r8
movslq %ecx, %rax
leaq 0x35bf(%rip), %r14      # 0x92f0
movq (%r14,%rax,8), %r14
leal 0x2(%r15), %ebp
movb %dh, (%rdi,%rbp)
movzwl %r12w, %r12d
movl (%r8,%r12,4), %ebp
movl %ebp, %r8d
movzbl %bpl, %ebp
subl %ebp, %eax
jl 0x635a
movq %r15, %rbx
shrl $0x10, %r9d
addl %r9d, %r10d
andq %r11, %r13
andq %r13, %r14
shrq %cl, %r13
movl 0x10(%rsp), %r15d
shrl $0x10, %r15d
addl %r15d, %esi
movq %r14, %r12
movl %eax, %ecx
shrq %cl, %r12
shrl $0x10, %edx
addl %edx, %r13d
movl %r8d, %ecx
shrl $0x10, %ecx
addl %ecx, %r12d
movslq %eax, %rcx
leaq 0x355d(%rip), %rdx      # 0x92f0
andq (%rdx,%rcx,8), %r14
leal 0x3(%rbx), %ecx
movl %r8d, %edx
movb %dh, (%rdi,%rcx)
addl $0x4, %ebx
movl %r13d, %ebp
cmpl 0xc(%rsp), %ebx
movq 0x30(%rsp), %r13
movq 0x20(%rsp), %r8
movq %rbx, %r15
jb 0x5c56
movq 0x18(%rsp), %rax
movq %rdi, 0x40(%rax)
movl 0x98(%rsp), %edx
movl 0xa8(%rsp), %ecx
movq %rdx, %rax
movq 0x28(%rsp), %r9
addq %r9, %rax
testl %ecx, %ecx
je 0x5edb
cmpl $0x8, %edx
movl 0x14(%rsp), %r8d
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
jb 0x630d
movq -0x8(%rax), %rdx
addq $-0x8, %rax
addl $0x40, %ecx
jmp 0x5f0f
addq %r13, %rsi
xorl %edi, %edi
xorl %r9d, %r9d
xorl %r8d, %r8d
pxor %xmm2, %xmm2
cmpq %rsi, %rbp
jae 0x5e4a
cmpl $0x18, %r9d
jg 0x5e4a
movl %r9d, %ecx
movl %r8d, %r10d
movzbl (%rbp), %r8d
shll %cl, %r8d
leal 0x8(%rcx), %r9d
orl %r10d, %r8d
incq %rbp
cmpq %rsi, %rbp
jae 0x5e4a
cmpl $0x11, %ecx
movl %r9d, %ecx
jl 0x5e28
movl %r8d, %ecx
andl $0x1f, %ecx
movl %r8d, %r10d
andl $0xf, %r10d
cmpl $0xf, %r10d
je 0x5e74
cmpl $0x7, %r10d
jne 0x5e88
movl %r8d, %r10d
shrl $0x4, %r10d
andl $0xf, %r10d
addl $0x8, %r10d
jmp 0x5e94
movl %r8d, %r10d
shrl $0x4, %r10d
andl $0x3ff, %r10d           # imm = 0x3FF
addl $0x18, %r10d
jmp 0x5e94
leaq 0x3cb1(%rip), %r10      # 0x9b40
movsbl (%rcx,%r10), %r10d
movsbl (%rcx,%rbx), %ecx
movw %r10w, 0xb2(%rsp,%rdi,2)
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
subl %ecx, %r9d
jl 0x630d
shrl %cl, %r8d
incq %rdi
cmpq $0x168, %rdi            # imm = 0x168
jne 0x5e1a
cmpl $0x7, %r9d
jg 0x630d
cmpq %rsi, %rbp
je 0x587f
jmp 0x630d
cmpl $0x7, %edx
movl 0x14(%rsp), %r8d
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
jb 0x630d
movzwl -0x3(%rax), %ecx
movzbl -0x1(%rax), %esi
movl -0x7(%rax), %edx
addq $-0x7, %rax
shll $0x10, %esi
orl %ecx, %esi
shlq $0x20, %rsi
orq %rsi, %rdx
movl $0x38, %ecx
movl %ecx, %edi
andl $-0x8, %edi
movq %rdx, %rsi
shrq %cl, %rsi
cmpl $0x38, %edi
jne 0x630d
testq %rsi, %rsi
jne 0x630d
movl 0xac(%rsp), %esi
movq 0x18(%rsp), %rbx
movl %esi, 0x6c(%rbx)
movzwl 0xb0(%rsp), %esi
movw %si, 0x70(%rbx)
subl %r9d, %eax
movl %eax, 0x68(%rbx)
movq $0x0, 0x48(%rbx)
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movq %rdx, 0x58(%rbx)
movl %ecx, 0x60(%rbx)
movl %r8d, 0x34(%rbx)
jmp 0x538e
movl %r8d, %r13d
movl %r8d, %r8d
movslq %edi, %r10
leaq (%r10,%rbp), %rcx
movq %rcx, %rbx
movq 0x18(%rsp), %r14
subq 0x20(%r14), %rbx
cmpq %r8, %rbx
jl 0x6259
leal (%r12,%rdi), %r8d
movslq %r8d, %r8
movq %rsi, %r14
subq %r8, %r14
jge 0x6005
addq $0x20, %rsi
movq %rsi, %rbx
subq %r10, %rbx
jl 0x626f
testl %edi, %edi
je 0x5fc4
xorl %edi, %edi
movb (%r9,%rdi), %r8b
movb %r8b, (%rbp,%rdi)
incq %rdi
cmpq %rdi, %r10
jne 0x5fb3
addq %r10, %r9
movslq %r12d, %rdi
movq %rbx, %r14
subq %rdi, %r14
jl 0x628e
testl %r12d, %r12d
je 0x5ff6
movslq %r13d, %rsi
negq %rsi
movq %rcx, %r8
movq %rdi, %r10
movb (%r8,%rsi), %bl
movb %bl, (%r8)
incq %r8
decq %r10
jne 0x5fe7
addq %rdi, %rcx
addq $-0x20, %r14
movq %rcx, %rbp
movl %r13d, %r8d
jmp 0x6080
movq %r9, %rsi
movl %r13d, %r8d
movq (%rsi), %rdi
movq %rdi, (%rbp)
addq $0x8, %rbp
addq $0x8, %rsi
cmpq %rcx, %rbp
jb 0x600b
addq %r10, %r9
movslq %r12d, %rsi
cmpl $0x7, %r8d
jg 0x605a
cmpl %r12d, %r8d
jge 0x605a
movl $0x0, %esi
testl %r12d, %r12d
je 0x607a
movslq %r12d, %rsi
movslq %r8d, %rdi
negq %rdi
movq %rcx, %r8
movq %rsi, %r10
movb (%r8,%rdi), %bl
movb %bl, (%r8)
incq %r8
decq %r10
jne 0x6049
jmp 0x6077
movslq %r8d, %rdi
negq %rdi
leaq (%rcx,%rsi), %r8
movq %rcx, %r10
movq (%r10,%rdi), %rbx
movq %rbx, (%r10)
addq $0x8, %r10
cmpq %r8, %r10
jb 0x6067
movl %r13d, %r8d
addq %rsi, %rcx
movq %rcx, %rbp
testl %r15d, %r15d
je 0x623e
movl $0x3f, %ecx
subl %eax, %ecx
movl %ecx, %esi
sarl $0x3, %esi
negl %esi
movslq %esi, %rsi
addq %rsi, %r11
cmpq 0x70(%rsp), %r11
jb 0x6259
movl %r8d, 0x30(%rsp)
andl $-0x8, %ecx
shlq %cl, %rdx
addl %ecx, %eax
movl %eax, %esi
andl $-0x8, %esi
cmpl $0x38, %esi
jne 0x6379
movl %r15d, 0x14(%rsp)
movslq %ecx, %rcx
leaq 0x321e(%rip), %r12      # 0x92f0
movq (%r12,%rcx,8), %r8
andq (%r11), %r8
orq %rdx, %r8
movq %r8, %rdx
movl %eax, %ecx
shrq %cl, %rdx
testq %rdx, %rdx
movq 0x50(%rsp), %r10
movl 0x20(%rsp), %ecx
jne 0x6382
movzwl %cx, %esi
movzbl (%r10,%rsi,8), %ecx
cmpl %ecx, %eax
movq 0x38(%rsp), %r15
jb 0x635a
movzbl 0x1(%r10,%rsi,8), %edx
cltq
subq %rcx, %rax
movq %r8, %rdi
movl %eax, %ecx
shrq %cl, %rdi
movl %edi, %ebx
movl %edx, %ecx
shrl %cl, %ebx
addw 0x2(%r10,%rsi,8), %bx
cmpw $0x40, %bx
jae 0x63a1
andl (%r12,%rdx,8), %edi
addl 0x4(%r10,%rsi,8), %edi
movslq %edi, %rcx
addq %r9, %rcx
cmpq 0x58(%rsp), %rcx
jae 0x6259
movl %ebx, 0x20(%rsp)
movzwl 0x10(%rsp), %ebx
movzbl (%r15,%rbx,8), %ecx
cmpl %ecx, %eax
jl 0x635a
andq (%r12,%rax,8), %r8
movzbl 0x1(%r15,%rbx,8), %edx
cltq
subq %rcx, %rax
movq %r8, %r12
movl %eax, %ecx
shrq %cl, %r12
movl %r12d, %esi
movl %edx, %ecx
shrl %cl, %esi
addw 0x2(%r15,%rbx,8), %si
cmpw $0x40, %si
jae 0x63c0
movq %r9, 0x78(%rsp)
movl %esi, 0x10(%rsp)
movq %r11, 0x28(%rsp)
movzwl 0xc(%rsp), %r15d
movq 0x48(%rsp), %r13
movzbl (%r13,%r15,8), %ecx
cmpl %ecx, %eax
jl 0x635a
leaq 0x3130(%rip), %r11      # 0x92f0
andq (%r11,%rax,8), %r8
movzbl 0x1(%r13,%r15,8), %esi
cltq
subq %rcx, %rax
movq %r8, %r10
movl %eax, %ecx
shrq %cl, %r10
movl %r10d, %r9d
movl %esi, %ecx
shrl %cl, %r9d
addw 0x2(%r13,%r15,8), %r9w
movl %r9d, 0xc(%rsp)
movzwl %r9w, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jae 0x63df
andl (%r11,%rdx,8), %r12d
movq 0x38(%rsp), %rcx
addl 0x4(%rcx,%rbx,8), %r12d
andl (%r11,%rsi,8), %r10d
addl 0x4(%r13,%r15,8), %r10d
andq (%r11,%rax,8), %r8
testl %r10d, %r10d
cmovel 0x30(%rsp), %r10d
movl 0x14(%rsp), %r15d
decl %r15d
movq %r8, %rdx
movl %r10d, %r8d
movq %r14, %rsi
movq 0x28(%rsp), %r11
movq 0x78(%rsp), %r9
jmp 0x5f6c
movq 0x18(%rsp), %rbx
movq %rbp, 0x18(%rbx)
movl $0x0, 0x34(%rbx)
movl 0x3c(%rbx), %eax
addq %rax, (%rbx)
jmp 0x538e
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
jmp 0x630d
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
jmp 0x630d
testq %rsi, %rsi
je 0x6287
xorl %ecx, %ecx
movb (%r9,%rcx), %r8b
movb %r8b, (%rbp,%rcx)
incq %rcx
cmpq %rcx, %rsi
jne 0x6276
addq %rsi, %r9
subl %esi, %edi
jmp 0x62bb
cmpq %r10, %rsi
je 0x62b6
movslq %r13d, %rcx
cmpq $0x1, %rbx
movq %rbx, %rdi
adcq $0x0, %rdi
addq %rbp, %r10
negq %rcx
movb (%r10,%rcx), %r8b
movb %r8b, (%r10)
incq %r10
decq %rdi
jne 0x62a7
subl %ebx, %r12d
xorl %edi, %edi
addq %rsi, %rbp
movq 0x18(%rsp), %rcx
movl %edi, 0x48(%rcx)
movl %r12d, 0x4c(%rcx)
movl %r13d, 0x50(%rcx)
movl 0x20(%rsp), %esi
movw %si, 0x6c(%rcx)
movl 0x10(%rsp), %esi
movw %si, 0x6e(%rcx)
movl 0xc(%rsp), %esi
movw %si, 0x70(%rcx)
movq %rdx, 0x58(%rcx)
movl %eax, 0x60(%rcx)
movl 0x44(%rsp), %eax
movl %eax, 0x64(%rcx)
movl %r15d, 0x38(%rcx)
subl (%rcx), %r11d
movl %r11d, 0x68(%rcx)
movq %r9, 0x40(%rcx)
movq %rbp, 0x18(%rcx)
movl $0xfffffffe, %r10d      # imm = 0xFFFFFFFE
movl %r10d, %eax
addq $0x388, %rsp            # imm = 0x388
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %edx, %edx
setne %dl
cmpl %eax, %ecx
sete %al
orb %dl, %al
movzbl %al, %eax
movl $0xfffffffe, %r10d      # imm = 0xFFFFFFFE
subl %eax, %r10d
jmp 0x630d
movl $0xfffffffd, %r10d      # imm = 0xFFFFFFFD
cmpl $0x24787662, %r15d      # imm = 0x24787662
jne 0x630d
movq %rax, (%rbx)
movl $0x1, 0x30(%rbx)
xorl %r10d, %r10d
jmp 0x630d
leaq 0x34ef(%rip), %rdi      # 0x9850
leaq 0x3305(%rip), %rsi      # 0x966d
leaq 0x34ff(%rip), %rcx      # 0x986e
movl $0x198, %edx            # imm = 0x198
callq 0x3070
leaq 0x3453(%rip), %rdi      # 0x97d3
jmp 0x6389
leaq 0x3341(%rip), %rdi      # 0x96ca
leaq 0x32dd(%rip), %rsi      # 0x966d
leaq 0x3468(%rip), %rcx      # 0x97ff
movl $0x178, %edx            # imm = 0x178
callq 0x3070
leaq 0x34ff(%rip), %rdi      # 0x98a7
leaq 0x340c(%rip), %rsi      # 0x97bb
leaq 0x3511(%rip), %rcx      # 0x98c7
movl $0xc6, %edx
callq 0x3070
leaq 0x352c(%rip), %rdi      # 0x98f3
leaq 0x33ed(%rip), %rsi      # 0x97bb
leaq 0x34f2(%rip), %rcx      # 0x98c7
movl $0xcf, %edx
callq 0x3070
leaq 0x352d(%rip), %rdi      # 0x9913
leaq 0x33ce(%rip), %rsi      # 0x97bb
leaq 0x34d3(%rip), %rcx      # 0x98c7
movl $0xd5, %edx
callq 0x3070
leaq 0x34a2(%rip), %rdi      # 0x98a7
leaq 0x33af(%rip), %rsi      # 0x97bb
leaq 0x34b4(%rip), %rcx      # 0x98c7
movl $0xab, %edx
callq 0x3070
leaq 0x34cf(%rip), %rdi      # 0x98f3
leaq 0x3390(%rip), %rsi      # 0x97bb
leaq 0x3495(%rip), %rcx      # 0x98c7
movl $0xac, %edx
callq 0x3070
leaq 0x34d0(%rip), %rdi      # 0x9913
leaq 0x3371(%rip), %rsi      # 0x97bb
leaq 0x3476(%rip), %rcx      # 0x98c7
movl $0xad, %edx
callq 0x3070
nop