// File: sbingner[P]kerneldec/lzfse/src/lzfse_decode_base.c
// Function: lzfse_decode_lmd
static int lzfse_decode_lmd(lzfse_decoder_state *s) {
  lzfse_compressed_block_decoder_state *bs = &(s->compressed_lzfse_block_state);
  fse_state l_state = bs->l_state;
  fse_state m_state = bs->m_state;
  fse_state d_state = bs->d_state;
  fse_in_stream in = bs->lmd_in_stream;
  const uint8_t *src_start = s->src_begin;
  const uint8_t *src = s->src + bs->lmd_in_buf;
  const uint8_t *lit = bs->current_literal;
  uint8_t *dst = s->dst;
  uint32_t symbols = bs->n_matches;
  int32_t L = bs->l_value;
  int32_t M = bs->m_value;
  int32_t D = bs->d_value;

  assert(l_state < LZFSE_ENCODE_L_STATES);
  assert(m_state < LZFSE_ENCODE_M_STATES);
  assert(d_state < LZFSE_ENCODE_D_STATES);

  //  Number of bytes remaining in the destination buffer, minus 32 to
  //  provide a margin of safety for using overlarge copies on the fast path.
  //  This is a signed quantity, and may go negative when we are close to the
  //  end of the buffer.  That's OK; we're careful about how we handle it
  //  in the slow-and-careful match execution path.
  ptrdiff_t remaining_bytes = s->dst_end - dst - 32;

  //  If L or M is non-zero, that means that we have already started decoding
  //  this block, and that we needed to interrupt decoding to get more space
  //  from the caller.  There's a pending L, M, D triplet that we weren't
  //  able to completely process.  Jump ahead to finish executing that symbol
  //  before decoding new values.
  if (L || M)
    goto ExecuteMatch;

  while (symbols > 0) {
    int res;
    //  Decode the next L, M, D symbol from the input stream.
    res = fse_in_flush(&in, &src, src_start);
    if (res) {
      return LZFSE_STATUS_ERROR;
    }
    L = fse_value_decode(&l_state, bs->l_decoder, &in);
    assert(l_state < LZFSE_ENCODE_L_STATES);
    if ((lit + L) >= (bs->literals + LZFSE_LITERALS_PER_BLOCK + 64)) {
      return LZFSE_STATUS_ERROR;
    }
    res = fse_in_flush2(&in, &src, src_start);
    if (res) {
      return LZFSE_STATUS_ERROR;
    }
    M = fse_value_decode(&m_state, bs->m_decoder, &in);
    assert(m_state < LZFSE_ENCODE_M_STATES);
    res = fse_in_flush2(&in, &src, src_start);
    if (res) {
      return LZFSE_STATUS_ERROR;
    }
    int32_t new_d = fse_value_decode(&d_state, bs->d_decoder, &in);
    assert(d_state < LZFSE_ENCODE_D_STATES);
    D = new_d ? new_d : D;
    symbols--;

  ExecuteMatch:
    //  Error if D is out of range, so that we avoid passing through
    //  uninitialized data or accesssing memory out of the destination
    //  buffer.
    if ((uint32_t)D > dst + L - s->dst_begin)
      return LZFSE_STATUS_ERROR;

    if (L + M <= remaining_bytes) {
      //  If we have plenty of space remaining, we can copy the literal
      //  and match with 16- and 32-byte operations, without worrying
      //  about writing off the end of the buffer.
      remaining_bytes -= L + M;
      copy(dst, lit, L);
      dst += L;
      lit += L;
      //  For the match, we have two paths; a fast copy by 16-bytes if
      //  the match distance is large enough to allow it, and a more
      //  careful path that applies a permutation to account for the
      //  possible overlap between source and destination if the distance
      //  is small.
      if (D >= 8 || D >= M)
        copy(dst, dst - D, M);
      else
        for (size_t i = 0; i < M; i++)
          dst[i] = dst[i - D];
      dst += M;
    }

    else {
      //  Otherwise, we are very close to the end of the destination
      //  buffer, so we cannot use wide copies that slop off the end
      //  of the region that we are copying to. First, we restore
      //  the true length remaining, rather than the sham value we've
      //  been using so far.
      remaining_bytes += 32;
      //  Now, we process the literal. Either there's space for it
      //  or there isn't; if there is, we copy the whole thing and
      //  update all the pointers and lengths to reflect the copy.
      if (L <= remaining_bytes) {
        for (size_t i = 0; i < L; i++)
          dst[i] = lit[i];
        dst += L;
        lit += L;
        remaining_bytes -= L;
        L = 0;
      }
      //  There isn't enough space to fit the whole literal. Copy as
      //  much of it as we can, update the pointers and the value of
      //  L, and report that the destination buffer is full. Note that
      //  we always write right up to the end of the destination buffer.
      else {
        for (size_t i = 0; i < remaining_bytes; i++)
          dst[i] = lit[i];
        dst += remaining_bytes;
        lit += remaining_bytes;
        L -= remaining_bytes;
        goto DestinationBufferIsFull;
      }
      //  The match goes just like the literal does. We copy as much as
      //  we can byte-by-byte, and if we reach the end of the buffer
      //  before finishing, we return to the caller indicating that
      //  the buffer is full.
      if (M <= remaining_bytes) {
        for (size_t i = 0; i < M; i++)
          dst[i] = dst[i - D];
        dst += M;
        remaining_bytes -= M;
        M = 0;
        (void)M; // no dead store warning
                 //  We don't need to update M = 0, because there's no partial
                 //  symbol to continue executing. Either we're at the end of
                 //  the block, in which case we will never need to resume with
                 //  this state, or we're going to decode another L, M, D set,
                 //  which will overwrite M anyway.
                 //
                 // But we still set M = 0, to maintain the post-condition.
      } else {
        for (size_t i = 0; i < remaining_bytes; i++)
          dst[i] = dst[i - D];
        dst += remaining_bytes;
        M -= remaining_bytes;
      DestinationBufferIsFull:
        //  Because we want to be able to resume decoding where we've left
        //  off (even in the middle of a literal or match), we need to
        //  update all of the block state fields with the current values
        //  so that we can resume execution from this point once the
        //  caller has given us more space to write into.
        bs->l_value = L;
        bs->m_value = M;
        bs->d_value = D;
        bs->l_state = l_state;
        bs->m_state = m_state;
        bs->d_state = d_state;
        bs->lmd_in_stream = in;
        bs->n_matches = symbols;
        bs->lmd_in_buf = (uint32_t)(src - s->src);
        bs->current_literal = lit;
        s->dst = dst;
        return LZFSE_STATUS_DST_FULL;
      }
      //  Restore the "sham" decremented value of remaining_bytes and
      //  continue to the next L, M, D triple. We'll just be back in
      //  the careful path again, but this only happens at the very end
      //  of the buffer, so a little minor inefficiency here is a good
      //  tradeoff for simpler code.
      remaining_bytes -= 32;
    }
  }
  //  Because we've finished with the whole block, we don't need to update
  //  any of the blockstate fields; they will not be used again. We just
  //  update the destination pointer in the state object and return.
  s->dst = dst;
  return LZFSE_STATUS_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x100(%rbp)
movq -0x100(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movw 0x34(%rax), %ax
movw %ax, -0x10a(%rbp)
movq -0x108(%rbp), %rax
movw 0x36(%rax), %ax
movw %ax, -0x10c(%rbp)
movq -0x108(%rbp), %rax
movw 0x38(%rax), %ax
movw %ax, -0x10e(%rbp)
movq -0x108(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x120(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x118(%rbp)
movq -0x100(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x128(%rbp)
movq -0x100(%rbp), %rax
movq (%rax), %rax
movq -0x108(%rbp), %rcx
movl 0x30(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x130(%rbp)
movq -0x108(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x138(%rbp)
movq -0x100(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x108(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x144(%rbp)
movq -0x108(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x148(%rbp)
movq -0x108(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14c(%rbp)
movq -0x108(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x150(%rbp)
movzwl -0x10a(%rbp), %eax
cmpl $0x40, %eax
jge 0x97e8
jmp 0x9807
leaq 0x71c4(%rip), %rdi      # 0x109b3
leaq 0x70aa(%rip), %rsi      # 0x108a0
movl $0xab, %edx
leaq 0x71d1(%rip), %rcx      # 0x109d3
callq 0x3070
movzwl -0x10c(%rbp), %eax
cmpl $0x40, %eax
jge 0x9815
jmp 0x9834
leaq 0x71e3(%rip), %rdi      # 0x109ff
leaq 0x707d(%rip), %rsi      # 0x108a0
movl $0xac, %edx
leaq 0x71a4(%rip), %rcx      # 0x109d3
callq 0x3070
movzwl -0x10e(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0x9844
jmp 0x9863
leaq 0x71d4(%rip), %rdi      # 0x10a1f
leaq 0x704e(%rip), %rsi      # 0x108a0
movl $0xad, %edx
leaq 0x7175(%rip), %rcx      # 0x109d3
callq 0x3070
movq -0x100(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x140(%rbp), %rcx
subq %rcx, %rax
subq $0x20, %rax
movq %rax, -0x158(%rbp)
cmpl $0x0, -0x148(%rbp)
jne 0x9895
cmpl $0x0, -0x14c(%rbp)
je 0x989a
jmp 0x9f07
jmp 0x989c
cmpl $0x0, -0x144(%rbp)
jbe 0xa429
movq -0x128(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
leaq -0x130(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movq %rax, -0xd8(%rbp)
movq -0xc8(%rbp), %rcx
movl $0x3f, %eax
subl 0x8(%rcx), %eax
andl $-0x8, %eax
movl %eax, -0xdc(%rbp)
movq -0xd0(%rbp), %rax
movq (%rax), %rax
movl -0xdc(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpq -0xd8(%rbp), %rax
jae 0x992f
movl $0xffffffff, -0xc0(%rbp) # imm = 0xFFFFFFFF
jmp 0x9a27
movq -0xe8(%rbp), %rcx
movq -0xd0(%rbp), %rax
movq %rcx, (%rax)
movq -0xe8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movl -0xdc(%rbp), %ecx
shlq %cl, %rax
movq %rax, -0x190(%rbp)
movq -0xf0(%rbp), %rdi
movl -0xdc(%rbp), %esi
callq 0xa570
movq -0x190(%rbp), %rcx
orq %rax, %rcx
movq -0xc8(%rbp), %rax
movq %rcx, (%rax)
movl -0xdc(%rbp), %ecx
movq -0xc8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0xc8(%rbp), %rax
cmpl $0x38, 0x8(%rax)
jl 0x99dd
movq -0xc8(%rbp), %rax
cmpl $0x40, 0x8(%rax)
jge 0x99dd
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq -0xc8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
cmpq $0x0, %rax
je 0x99fc
jmp 0x9a08
leaq 0x6efb(%rip), %rdi      # 0x108df
leaq 0x6d67(%rip), %rsi      # 0x10752
movl $0x178, %edx            # imm = 0x178
leaq 0x6f14(%rip), %rcx      # 0x1090b
callq 0x3070
movl $0x0, -0xc0(%rbp)
jmp 0x9a27
leaq 0x6da0(%rip), %rdi      # 0x107af
leaq 0x6d3c(%rip), %rsi      # 0x10752
movl $0x178, %edx            # imm = 0x178
leaq 0x6ee9(%rip), %rcx      # 0x1090b
callq 0x3070
movl -0xc0(%rbp), %eax
movl %eax, -0x15c(%rbp)
cmpl $0x0, -0x15c(%rbp)
je 0x9a4b
movl $0xfffffffd, -0xf4(%rbp) # imm = 0xFFFFFFFD
jmp 0xa445
movq -0x108(%rbp), %rax
addq $0x40, %rax
leaq -0x10a(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movzbl -0x38(%rbp), %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x9aa4
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x9ac3
leaq 0x6eb1(%rip), %rdi      # 0x1095c
leaq 0x6ca0(%rip), %rsi      # 0x10752
movl $0x198, %edx            # imm = 0x198
leaq 0x6ebc(%rip), %rcx      # 0x1097a
callq 0x3070
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xa570
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl %eax, -0x3c(%rbp)
movswl -0x36(%rbp), %eax
movl -0x3c(%rbp), %edx
movzbl -0x37(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movslq -0x34(%rbp), %rax
movq %rax, -0x198(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %edi
movzbl -0x37(%rbp), %esi
callq 0xa570
movq %rax, %rcx
movq -0x198(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x148(%rbp)
movzwl -0x10a(%rbp), %eax
cmpl $0x40, %eax
jge 0x9b60
jmp 0x9b7f
leaq 0x6e4c(%rip), %rdi      # 0x109b3
leaq 0x6d32(%rip), %rsi      # 0x108a0
movl $0xc6, %edx
leaq 0x6e59(%rip), %rcx      # 0x109d3
callq 0x3070
movq -0x138(%rbp), %rax
movslq -0x148(%rbp), %rcx
addq %rcx, %rax
movq -0x108(%rbp), %rcx
addq $0x1c40, %rcx           # imm = 0x1C40
addq $0x9c40, %rcx           # imm = 0x9C40
addq $0x40, %rcx
cmpq %rcx, %rax
jb 0x9bbd
movl $0xfffffffd, -0xf4(%rbp) # imm = 0xFFFFFFFD
jmp 0xa445
movl $0x0, -0x15c(%rbp)
cmpl $0x0, -0x15c(%rbp)
je 0x9bdf
movl $0xfffffffd, -0xf4(%rbp) # imm = 0xFFFFFFFD
jmp 0xa445
movq -0x108(%rbp), %rax
addq $0x240, %rax            # imm = 0x240
leaq -0x10c(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
movzwl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rcx
movzbl -0x78(%rbp), %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jl 0x9c3a
movl -0x4c(%rbp), %eax
movq -0x48(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x9c59
leaq 0x6d1b(%rip), %rdi      # 0x1095c
leaq 0x6b0a(%rip), %rsi      # 0x10752
movl $0x198, %edx            # imm = 0x198
leaq 0x6d26(%rip), %rcx      # 0x1097a
callq 0x3070
movl -0x4c(%rbp), %edx
movq -0x48(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xa570
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rax
movl %eax, -0x7c(%rbp)
movswl -0x76(%rbp), %eax
movl -0x7c(%rbp), %edx
movzbl -0x77(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0x60(%rbp), %rax
movw %cx, (%rax)
movslq -0x74(%rbp), %rax
movq %rax, -0x1a0(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, %edi
movzbl -0x77(%rbp), %esi
callq 0xa570
movq %rax, %rcx
movq -0x1a0(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14c(%rbp)
movzwl -0x10c(%rbp), %eax
cmpl $0x40, %eax
jge 0x9cf6
jmp 0x9d15
leaq 0x6d02(%rip), %rdi      # 0x109ff
leaq 0x6b9c(%rip), %rsi      # 0x108a0
movl $0xcf, %edx
leaq 0x6cc3(%rip), %rcx      # 0x109d3
callq 0x3070
movl $0x0, -0x15c(%rbp)
cmpl $0x0, -0x15c(%rbp)
je 0x9d37
movl $0xfffffffd, -0xf4(%rbp) # imm = 0xFFFFFFFD
jmp 0xa445
movq -0x108(%rbp), %rax
addq $0x440, %rax            # imm = 0x440
leaq -0x10e(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
movq -0xa0(%rbp), %rcx
movzwl (%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rcx
movzbl -0xb8(%rbp), %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
cmpl $0x0, -0x8c(%rbp)
jl 0x9db9
movl -0x8c(%rbp), %eax
movq -0x88(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x9dd8
leaq 0x6b9c(%rip), %rdi      # 0x1095c
leaq 0x698b(%rip), %rsi      # 0x10752
movl $0x198, %edx            # imm = 0x198
leaq 0x6ba7(%rip), %rcx      # 0x1097a
callq 0x3070
movl -0x8c(%rbp), %edx
movq -0x88(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x88(%rbp), %rax
movq (%rax), %rax
movq -0x88(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
movq %rax, -0x98(%rbp)
movq -0x88(%rbp), %rax
movq (%rax), %rdi
movq -0x88(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xa570
movq %rax, %rcx
movq -0x88(%rbp), %rax
movq %rcx, (%rax)
movq -0x98(%rbp), %rax
movl %eax, -0xbc(%rbp)
movswl -0xb6(%rbp), %eax
movl -0xbc(%rbp), %edx
movzbl -0xb7(%rbp), %ecx
shrl %cl, %edx
movl %edx, %ecx
addl %ecx, %eax
movw %ax, %cx
movq -0xa0(%rbp), %rax
movw %cx, (%rax)
movslq -0xb4(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movl -0xbc(%rbp), %eax
movl %eax, %edi
movzbl -0xb7(%rbp), %esi
callq 0xa570
movq %rax, %rcx
movq -0x1a8(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x160(%rbp)
movzwl -0x10e(%rbp), %eax
cmpl $0x100, %eax            # imm = 0x100
jge 0x9eaa
jmp 0x9ec9
leaq 0x6b6e(%rip), %rdi      # 0x10a1f
leaq 0x69e8(%rip), %rsi      # 0x108a0
movl $0xd5, %edx
leaq 0x6b0f(%rip), %rcx      # 0x109d3
callq 0x3070
cmpl $0x0, -0x160(%rbp)
je 0x9ee0
movl -0x160(%rbp), %eax
movl %eax, -0x1ac(%rbp)
jmp 0x9eec
movl -0x150(%rbp), %eax
movl %eax, -0x1ac(%rbp)
movl -0x1ac(%rbp), %eax
movl %eax, -0x150(%rbp)
movl -0x144(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x144(%rbp)
movl -0x150(%rbp), %eax
movq -0x140(%rbp), %rcx
movslq -0x148(%rbp), %rdx
addq %rdx, %rcx
movq -0x100(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x9f40
movl $0xfffffffd, -0xf4(%rbp) # imm = 0xFFFFFFFD
jmp 0xa445
movl -0x148(%rbp), %eax
addl -0x14c(%rbp), %eax
cltq
cmpq -0x158(%rbp), %rax
jg 0xa08a
movl -0x148(%rbp), %eax
addl -0x14c(%rbp), %eax
movslq %eax, %rcx
movq -0x158(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x158(%rbp)
movq -0x140(%rbp), %rdi
movq -0x138(%rbp), %rsi
movslq -0x148(%rbp), %rdx
callq 0xa590
movl -0x148(%rbp), %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
movl -0x148(%rbp), %ecx
movq -0x138(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
cmpl $0x8, -0x150(%rbp)
jge 0x9fe0
movl -0x150(%rbp), %eax
cmpl -0x14c(%rbp), %eax
jl 0xa00b
movq -0x140(%rbp), %rdi
movq -0x140(%rbp), %rsi
movslq -0x150(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0x14c(%rbp), %rdx
callq 0xa590
jmp 0xa06b
movq $0x0, -0x168(%rbp)
movq -0x168(%rbp), %rax
movslq -0x14c(%rbp), %rcx
cmpq %rcx, %rax
jae 0xa069
movq -0x140(%rbp), %rax
movq -0x168(%rbp), %rcx
movslq -0x150(%rbp), %rdx
subq %rdx, %rcx
movb (%rax,%rcx), %dl
movq -0x140(%rbp), %rax
movq -0x168(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x168(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x168(%rbp)
jmp 0xa016
jmp 0xa06b
movl -0x14c(%rbp), %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
jmp 0xa424
movq -0x158(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x158(%rbp)
movslq -0x148(%rbp), %rax
cmpq -0x158(%rbp), %rax
jg 0xa15f
movq $0x0, -0x170(%rbp)
movq -0x170(%rbp), %rax
movslq -0x148(%rbp), %rcx
cmpq %rcx, %rax
jae 0xa104
movq -0x138(%rbp), %rax
movq -0x170(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x140(%rbp), %rax
movq -0x170(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x170(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x170(%rbp)
jmp 0xa0bb
movl -0x148(%rbp), %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
movl -0x148(%rbp), %ecx
movq -0x138(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
movslq -0x148(%rbp), %rcx
movq -0x158(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x158(%rbp)
movl $0x0, -0x148(%rbp)
jmp 0xa1f6
movq $0x0, -0x178(%rbp)
movq -0x178(%rbp), %rax
cmpq -0x158(%rbp), %rax
jae 0xa1b0
movq -0x138(%rbp), %rax
movq -0x178(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x140(%rbp), %rax
movq -0x178(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x178(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x178(%rbp)
jmp 0xa16a
movq -0x158(%rbp), %rax
addq -0x140(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x158(%rbp), %rax
addq -0x138(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x158(%rbp), %rcx
movslq -0x148(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x148(%rbp)
jmp 0xa330
movslq -0x14c(%rbp), %rax
cmpq -0x158(%rbp), %rax
jg 0xa2a9
movq $0x0, -0x180(%rbp)
movq -0x180(%rbp), %rax
movslq -0x14c(%rbp), %rcx
cmpq %rcx, %rax
jae 0xa268
movq -0x140(%rbp), %rax
movq -0x180(%rbp), %rcx
movslq -0x150(%rbp), %rdx
subq %rdx, %rcx
movb (%rax,%rcx), %dl
movq -0x140(%rbp), %rax
movq -0x180(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x180(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x180(%rbp)
jmp 0xa215
movl -0x14c(%rbp), %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x140(%rbp)
movslq -0x14c(%rbp), %rcx
movq -0x158(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x158(%rbp)
movl $0x0, -0x14c(%rbp)
jmp 0xa412
movq $0x0, -0x188(%rbp)
movq -0x188(%rbp), %rax
cmpq -0x158(%rbp), %rax
jae 0xa304
movq -0x140(%rbp), %rax
movq -0x188(%rbp), %rcx
movslq -0x150(%rbp), %rdx
subq %rdx, %rcx
movb (%rax,%rcx), %dl
movq -0x140(%rbp), %rax
movq -0x188(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x188(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x188(%rbp)
jmp 0xa2b4
movq -0x158(%rbp), %rax
addq -0x140(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x158(%rbp), %rcx
movslq -0x14c(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x14c(%rbp)
movl -0x148(%rbp), %ecx
movq -0x108(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x14c(%rbp), %ecx
movq -0x108(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x150(%rbp), %ecx
movq -0x108(%rbp), %rax
movl %ecx, 0x18(%rax)
movw -0x10a(%rbp), %cx
movq -0x108(%rbp), %rax
movw %cx, 0x34(%rax)
movw -0x10c(%rbp), %cx
movq -0x108(%rbp), %rax
movw %cx, 0x36(%rax)
movw -0x10e(%rbp), %cx
movq -0x108(%rbp), %rax
movw %cx, 0x38(%rax)
movq -0x108(%rbp), %rax
movq -0x120(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x118(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl -0x144(%rbp), %ecx
movq -0x108(%rbp), %rax
movl %ecx, (%rax)
movq -0x130(%rbp), %rax
movq -0x100(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x108(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x138(%rbp), %rcx
movq -0x108(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x140(%rbp), %rcx
movq -0x100(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0xfffffffe, -0xf4(%rbp) # imm = 0xFFFFFFFE
jmp 0xa445
movq -0x158(%rbp), %rax
subq $0x20, %rax
movq %rax, -0x158(%rbp)
jmp 0x989c
movq -0x140(%rbp), %rcx
movq -0x100(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0xf4(%rbp)
movl -0xf4(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopw %cs:(%rax,%rax)