LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_intra_chroma_pred_mode_cabac
static void CAFUNC(parse_intra_chroma_pred_mode)
{
	static const int8_t IntraChromaModes[4][4] = {
		{IC8x8_DC_8, IC8x8_DCA_8, IC8x8_DCB_8, IC8x8_DCAB_8},
		{IC8x8_H_8 , IC8x8_DCA_8, IC8x8_H_8  , IC8x8_DCAB_8},
		{IC8x8_V_8 , IC8x8_V_8  , IC8x8_DCB_8, IC8x8_DCAB_8},
		{IC8x8_P_8 , IC8x8_DCA_8, IC8x8_DCB_8, IC8x8_DCAB_8},
	};
	
	// Do not optimise too hard to keep the code understandable here.
	int type = ctx->t.ChromaArrayType;
	if (type == 1 || type == 2) {
		#if !CABAC
			int mode = get_ue16(&ctx->t._gb, 3);
		#else
			int ctxIdx = 64 + ctx->inc.intra_chroma_pred_mode_non_zero;
			int mode = 0;
			while (mode <3 && get_ae(ctx, ctxIdx))
				mode++, ctxIdx = 67;
			mb->f.intra_chroma_pred_mode_non_zero = (mode > 0);
		#endif
		log_mb(ctx, "    intra_chroma_pred_mode: %u\n", mode);
		decode_intraChroma(IntraChromaModes[mode][ctx->unavail4x4[0] & 3], ctx->samples_mb[1], ctx->t.stride[1] >> 1, ctx->t.samples_clip_v[1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x2a(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
je 0xb2897
cmpl $0x2, -0xc(%rbp)
jne 0xb29c0
movq -0x8(%rbp), %rax
movsbl 0x6c5(%rax), %eax
addl $0x40, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x3, -0x14(%rbp)
movb %al, -0x15(%rbp)
jge 0xb28cf
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0xae5c0
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xb28d8
jmp 0xb28ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x43, -0x10(%rbp)
jmp 0xb28af
cmpl $0x0, -0x14(%rbp)
setg %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq 0x680(%rax), %rax
movb %cl, 0x25(%rax)
movq -0x8(%rbp), %rax
movswq 0x1cd0(%rax), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jae 0xb2970
movq -0x8(%rbp), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movq -0x8(%rbp), %rax
movswl 0x1cd0(%rax), %eax
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movswq 0x1cd0(%rax), %rax
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
movl -0x14(%rbp), %ecx
leaq 0x1e1fc(%rip), %rdx     # 0xd0b4f
movb $0x0, %al
callq 0x7070
movl %eax, %edx
movq -0x8(%rbp), %rax
movswl 0x1cd0(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x1cd0(%rax)
movslq -0x14(%rbp), %rcx
leaq 0x1d005(%rip), %rax     # 0xcf980
shlq $0x2, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movsbl 0x6d0(%rcx), %ecx
andl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x670(%rax), %rsi
movq -0x8(%rbp), %rax
movzwl 0x36(%rax), %eax
sarl %eax
movslq %eax, %rdx
movq -0x8(%rbp), %rax
vmovdqa 0x180(%rax), %xmm0
callq 0xa7dd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_bitstream.c
// Function: cabac_terminate
static int cabac_terminate(Edge264Context *ctx) {
	int extra = SIZE_BIT - 9 - clz(ctx->t._gb.codIRange); // [0..SIZE_BIT-9]
	ctx->t._gb.codIRange -= (size_t)2 << extra;
	if (ctx->t._gb.codIOffset >= ctx->t._gb.codIRange) {
		// reclaim the extra bits minus alignment bits, then refill the cache
		ctx->t._gb.msb_cache = (ctx->t._gb.codIOffset * 2 + 1) << (SIZE_BIT - 1 - (extra & -8));
		return refill(&ctx->t._gb, 1);
	}
	if (__builtin_expect(ctx->t._gb.codIRange < 256, 0)) {
		ctx->t._gb.codIOffset = shld(get_bytes(&ctx->t._gb, SIZE_BIT / 8 - 1), ctx->t._gb.codIOffset, SIZE_BIT - 8);
		ctx->t._gb.codIRange <<= SIZE_BIT - 8;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
lzcntq %rax, %rax
movl %eax, %ecx
movl $0x37, %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
movl $0x2, %edx
shlq %cl, %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4b052
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
addq $0x1, %rax
movl -0x24(%rbp), %edx
andl $-0x8, %edx
movl $0x3f, %ecx
subl %edx, %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1ca60
movl %eax, -0x18(%rbp)
jmp 0x4b0cc
movq -0x20(%rbp), %rax
cmpq $0x100, 0x10(%rax)      # imm = 0x100
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x4b0c5
movq -0x20(%rbp), %rdi
movl $0x7, %esi
callq 0x4c850
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl $0x38, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x38, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_bypass
static inline int get_bypass(Edge264Context *ctx) {
	if (ctx->t._gb.codIRange < 512) {
		ctx->t._gb.codIOffset = shld(get_bytes(&ctx->t._gb, SIZE_BIT / 8 - 2), ctx->t._gb.codIOffset, SIZE_BIT - 16);
		ctx->t._gb.codIRange <<= SIZE_BIT - 16;
	}
	ctx->t._gb.codIRange >>= 1;
	size_t binVal = ctx->t._gb.codIOffset >= ctx->t._gb.codIRange;
	ctx->t._gb.codIOffset = binVal ? ctx->t._gb.codIOffset - ctx->t._gb.codIRange : ctx->t._gb.codIOffset;
	return binVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x200, 0x10(%rax)      # imm = 0x200
jae 0x4cee1
movq -0x20(%rbp), %rdi
movl $0x6, %esi
callq 0x4c850
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movl $0x30, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movl -0x14(%rbp), %ecx
shldq %cl, %rdx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shlq $0x30, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
shrq %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4cf2b
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
jmp 0x4cf37
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_headers.c
// Function: ppow
static unsigned ppow(unsigned p65536, unsigned k) {
	unsigned r = 65536;
	while (k) {
		if (k & 1)
			r = (r * p65536) >> 16;
		p65536 = (p65536 * p65536) >> 16;
		k >>= 1;
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x10000, -0xc(%rbp)    # imm = 0x10000
cmpl $0x0, -0x8(%rbp)
je 0x64f86
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x64f6f
movl -0xc(%rbp), %eax
imull -0x4(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
imull -0x4(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
shrl %eax
movl %eax, -0x8(%rbp)
jmp 0x64f51
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_internal.h
// Function: print_dec
static inline int print_dec(Edge264Decoder *dec) {
		int pos = dec->log_pos;
		dec->log_pos = 0;
		if (pos >= sizeof(dec->log_buf))
			return ENOTSUP;
		dec->log_cb(dec->log_buf, dec->log_arg);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x7ca0(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movw $0x0, 0x7ca0(%rax)
movslq -0x14(%rbp), %rax
cmpq $0x2542, %rax           # imm = 0x2542
jb 0x65e5c
movl $0x5f, -0x4(%rbp)
jmp 0x65e86
movq -0x10(%rbp), %rax
movq 0x7c90(%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x7ca2, %rdi           # imm = 0x7CA2
movq -0x10(%rbp), %rcx
movq 0x7c98(%rcx), %rsi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tvlabs[P]edge264/./edge264_internal.h
// Function: print_mb
static inline int print_mb(Edge264Context *ctx) {
		int pos = ctx->log_pos;
		ctx->log_pos = 0;
		if (pos >= sizeof(ctx->log_buf))
			return ENOTSUP;
		ctx->log_cb(ctx->log_buf, ctx->log_arg);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movswl 0x1cd0(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movw $0x0, 0x1cd0(%rax)
movslq -0x14(%rbp), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jb 0x7f96c
movl $0x5f, -0x4(%rbp)
jmp 0x7f996
movq -0x10(%rbp), %rax
movq 0x1cc0(%rax), %rax
movq -0x10(%rbp), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movq -0x10(%rbp), %rcx
movq 0x1cc8(%rcx), %rsi
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/check_fastq.c
// Function: check_seq
static int check_seq(ReadSeq *read) {
  int i, j;
  char c;
  int err;
  /* string of valid nucleotide identifiers, including ambiguity codes */
  static const char *valid_nucs = "ATCGNatcgnMRWSYKmrwsyk";

  err = FALSE;
  for(i = 0; i < read->read_len; i++) {
    c = read->line2[i];

    j = 0;
    while(c != valid_nucs[j]) {
      if(valid_nucs[j] == '\0') {
	if(warn_count < MAX_WARN) {
	  warn_count += 1;
	  my_warn("%s:%d: read contains invalid base '%c'", 
		  __FILE__, __LINE__, c);
	}
	err = TRUE;
	break;
      }
      j++;
    }

    if(err) {
      read->status = FASTQ_ERR;
      break;
    }
  }

  return read->status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x418(%rcx), %eax
jge 0x1eb4
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb 0x81e(%rax,%rcx), %al
movb %al, -0x11(%rbp)
movl $0x0, -0x10(%rbp)
movsbl -0x11(%rbp), %eax
movq 0x6347(%rip), %rcx      # 0x8168
movslq -0x10(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x1e8e
movq 0x6334(%rip), %rax      # 0x8168
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1e83
cmpl $0x3e8, 0x6329(%rip)    # imm = 0x3E8
jge 0x1e7a
movl 0x6321(%rip), %eax      # 0x8174
addl $0x1, %eax
movl %eax, 0x6318(%rip)      # 0x8174
movsbl -0x11(%rbp), %ecx
leaq 0x34f1(%rip), %rdi      # 0x5358
leaq 0x324f(%rip), %rsi      # 0x50bd
movl $0x102, %edx            # imm = 0x102
movb $0x0, %al
callq 0x3e60
movl $0x1, -0x18(%rbp)
jmp 0x1e8e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1e16
cmpl $0x0, -0x18(%rbp)
je 0x1ea4
movq -0x8(%rbp), %rax
movl $0x1, 0x1420(%rax)
jmp 0x1eb4
jmp 0x1ea6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1dea
movq -0x8(%rbp), %rax
movl 0x1420(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gmcvicker[P]check_fastq/check_fastq.c
// Function: seek_next_header
static void seek_next_header(gzFile f) {
  char c1, c2;
  size_t n;

  c1 = '\n';
  c2 = gzgetc(f);

  /* search for the next line that starts with '@' */
  n = 0;
  while(c2 != -1) {
    if((c1 == '\n') && (c2 == '@')) {
      /* backup one byte to put '@' back on file stream */
      /* gzseek(f, -1, SEEK_CUR);*/
      gzungetc(c2, f);

      if(warn_count < MAX_WARN) {
	fprintf(stderr, "skipped %ld bytes to find next fastq header line\n", 
		n);
      }
      return;
    }
    c1 = c2;
    c2 = gzgetc(f);
    n++;
  }
  fprintf(stderr, "skipped %ld bytes at end of file\n", n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0xa, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x208f
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x209b
movq -0x8(%rbp), %rdi
callq 0x10f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $-0x1, %eax
je 0x216a
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
jne 0x2102
movsbl -0xa(%rbp), %eax
cmpl $0x40, %eax
jne 0x2102
movsbl -0xa(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1100
cmpl $0x3e8, 0x6095(%rip)    # imm = 0x3E8
jge 0x20fd
movq 0x5f10(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3114(%rip), %rsi      # 0x520a
movb $0x0, %al
callq 0x1180
jmp 0x2186
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2147
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x2153
movq -0x8(%rbp), %rdi
callq 0x10f0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20a9
movq 0x5e87(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x30bd(%rip), %rsi      # 0x523c
movb $0x0, %al
callq 0x1180
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/perdisci[P]LSH/minhash.cpp
// Function: rp::MinHash::random_uint32_universal_hash(unsigned long)
vector<uint32_t> MinHash::random_uint32_universal_hash(const uint64_t x) {
    
    assert(x > 0 && x < UINT64_MAX);
    
    static const unsigned w = sizeof(uint64_t)*8;
    static const unsigned M = sizeof(uint32_t)*8;
    
    vector<uint32_t> hv;
    hv.push_back(static_cast<uint32_t>(x));
    
    for(int i=0; i<sig_len; i++) {
        if(a.size()<sig_len) {
            a.push_back(urandom_64(rand_eng));
            b.push_back(urandom_32(rand_eng));
        }
        
        uint32_t h = static_cast<uint32_t>((a[i]*x+b[i]) >> (w-M));
        hv.push_back(h);
    }
    
    return hv;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x70(%rsp)
movb %al, 0x43(%rsp)
jbe 0x18bdb
cmpq $-0x1, 0x70(%rsp)
setb %al
movb %al, 0x43(%rsp)
movb 0x43(%rsp), %al
testb $0x1, %al
jne 0x18be5
jmp 0x18be7
jmp 0x18c06
leaq 0x19a31(%rip), %rdi     # 0x3261f
leaq 0x19a42(%rip), %rsi     # 0x32637
movl $0x22, %edx
leaq 0x19a42(%rip), %rcx     # 0x32643
callq 0x82e0
movq 0x28(%rsp), %rdi
movb $0x0, 0x6f(%rsp)
callq 0x19550
movq 0x28(%rsp), %rdi
movl 0x70(%rsp), %eax
movl %eax, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x19560
jmp 0x18c2e
movl $0x0, 0x58(%rsp)
movq 0x38(%rsp), %rcx
movl 0x58(%rsp), %eax
cmpl 0x50(%rcx), %eax
jae 0x18d6e
movq 0x38(%rsp), %rdi
callq 0x19590
movq 0x38(%rsp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jae 0x18d04
movq 0x38(%rsp), %rsi
movq %rsi, %rax
movq %rax, 0x18(%rsp)
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x30, %rsi
callq 0x195e0
movq %rax, 0x20(%rsp)
jmp 0x18c87
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x195b0
jmp 0x18ca2
movq 0x38(%rsp), %rsi
movq %rsi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rdi
addq $0x48, %rdi
addq $0x30, %rsi
callq 0x19610
movl %eax, 0x14(%rsp)
jmp 0x18cc9
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %eax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x195b0
jmp 0x18ce5
jmp 0x18d04
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0xbe70
jmp 0x18d91
movq 0x38(%rsp), %rdi
movslq 0x58(%rsp), %rsi
callq 0x19640
movq 0x38(%rsp), %rdi
movq (%rax), %rax
movq 0x70(%rsp), %rcx
imulq %rcx, %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movslq 0x58(%rsp), %rsi
callq 0x19640
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
shrq $0x20, %rax
movl %eax, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0x19660
jmp 0x18d5c
jmp 0x18d5e
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x18c36
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x18d84
movq 0x28(%rsp), %rdi
callq 0xbe70
movq 0x30(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x8820
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/perdisci[P]LSH/./xxHash/xxhash.c
// Function: XXH32_reset
XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
leaq 0xc(%rsp), %rdi
xorl %esi, %esi
movl $0x2c, %edx
callq 0x8220
movl 0x3c(%rsp), %eax
addl $0x9e3779b1, %eax       # imm = 0x9E3779B1
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, 0x14(%rsp)
movl 0x3c(%rsp), %eax
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, 0x18(%rsp)
movl 0x3c(%rsp), %eax
addl $0x0, %eax
movl %eax, 0x1c(%rsp)
movl 0x3c(%rsp), %eax
subl $0x9e3779b1, %eax       # imm = 0x9E3779B1
movl %eax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl $0x30, %edx
callq 0x83d0
xorl %eax, %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/perdisci[P]LSH/./xxHash/xxhash.c
// Function: XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x8220
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
addq 0x58(%rsp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
addq $0x0, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
subq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
movl $0x58, %edx
callq 0x83d0
xorl %eax, %eax
addq $0x68, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/perdisci[P]LSH/lsh.cpp
// Function: rp::LSH::LSH(unsigned int, unsigned int, unsigned int, unsigned int)
LSH::LSH(const unsigned minhash_sig_len, const unsigned lsh_bands,
             const unsigned ngram_len, const unsigned seed) {
        this->minhash_sig_len = minhash_sig_len;
        this->lsh_bands = lsh_bands;
        this->ngram_len = ngram_len;
        this->seed = seed;
        
        mh = MinHash(minhash_sig_len,seed);
    }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movl %edx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl %r8d, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x10, %rdi
movq %rdi, 0x8(%rsp)
movl $0x64, %esi
xorl %edx, %edx
callq 0x18ad0
movq 0x40(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, 0x10(%rsp)
callq 0x249c0
movq 0x40(%rsp), %rdi
addq $0x98, %rdi
movq %rdi, 0x18(%rsp)
callq 0x249c0
movq 0x40(%rsp), %rdi
addq $0xc8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x249d0
movq 0x40(%rsp), %rdi
addq $0xf8, %rdi
movq %rdi, 0x28(%rsp)
callq 0x249e0
movq 0x40(%rsp), %rdi
addq $0x110, %rdi            # imm = 0x110
movq %rdi, 0x30(%rsp)
callq 0x249f0
movq 0x40(%rsp), %rdi
addq $0x128, %rdi            # imm = 0x128
movq %rdi, 0x38(%rsp)
callq 0x249f0
movq 0x40(%rsp), %rax
movl 0xbc(%rsp), %ecx
movl %ecx, (%rax)
movl 0xb8(%rsp), %ecx
movl %ecx, 0x4(%rax)
movl 0xb4(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0xb0(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0xbc(%rsp), %esi
movl 0xb0(%rsp), %edx
leaq 0x58(%rsp), %rdi
callq 0x18ad0
jmp 0x21e35
movq 0x40(%rsp), %rdi
addq $0x10, %rdi
leaq 0x58(%rsp), %rsi
callq 0x24a00
leaq 0x58(%rsp), %rdi
callq 0xbfa0
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0xa3f0
movq 0x30(%rsp), %rdi
callq 0xa3f0
movq 0x28(%rsp), %rdi
callq 0xa450
movq 0x20(%rsp), %rdi
callq 0xbf90
movq 0x18(%rsp), %rdi
callq 0xa4b0
movq 0x10(%rsp), %rdi
callq 0xa4b0
movq 0x8(%rsp), %rdi
callq 0xbfa0
movq 0x50(%rsp), %rdi
callq 0x8820
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/perdisci[P]LSH/lsh.cpp
// Function: rp::LSH::candidate_probability(unsigned int, unsigned int, float)
float LSH::candidate_probability(unsigned minhash_sig_len, unsigned lsh_bands, float jaccard_sim) {
        unsigned r = minhash_sig_len/lsh_bands;
        unsigned b = lsh_bands;
        float s = jaccard_sim;
        return 1 - std::pow((1 - std::pow(s,r)),b);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movl 0x1c(%rsp), %eax
xorl %edx, %edx
divl 0x18(%rsp)
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
movss 0x8(%rsp), %xmm0
movl 0x10(%rsp), %edi
callq 0x25830
movaps %xmm0, %xmm1
movsd 0xe465(%rip), %xmm0     # 0x326a8
subsd %xmm1, %xmm0
movl 0xc(%rsp), %edi
callq 0x25800
movaps %xmm0, %xmm1
movsd 0xe44d(%rip), %xmm0     # 0x326a8
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_rows_destory
static void _table_rows_destory(TableRows *rows, int destory_row)
{
    int i;

    if (destory_row)
    {
        for(i = 0; i< rows->counts; i++)
        {
            table_row_destory(rows->rows[i]);
        }
    }
    free(rows->rows);
    free(rows);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x3f4b
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3f49
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4c10
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3f1c
jmp 0x3f4b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_get_path
const void table_index_get_path(TableIndex *index, uint64_t column, char* buff)
{
    int   dir_len;
    dir_len = strlen(index->dir);
    strcpy(buff, index->dir);
    buff[dir_len] = '/';
    sprintf(buff + dir_len + 1, "column%lu.index", column);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1070
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x1040
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rdx
leaq 0x29fe(%rip), %rsi      # 0x69c7
movb $0x0, %al
callq 0x1150
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_search_range
TableRows *table_search_range(Table *table, uint64_t column, uint64_t min_value, uint64_t max_value, uint64_t limit)
{
    TableRows *rows;

    table_lock(table);

    if(table_index_is_exist(table->indexs, column))
        rows = table_search_by_index(table, column, min_value, max_value, limit);
    else
        rows = table_search_by_exhaustion(table, column, min_value, max_value, limit);

    table_unlock(table);

    return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4070
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x40c0
cmpl $0x0, %eax
je 0x403a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x40e0
movq %rax, -0x30(%rbp)
jmp 0x4057
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x41b0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4290
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_search_by_index
static TableRows *table_search_by_index(Table *table, uint64_t column, uint64_t min_value, uint64_t max_value, uint64_t limit)
{
    TableRows   *rows;
    TableRow    *row;
    BTree       *bt;
    BTreeValues *values;
    uint64_t     rowid, i, counts;

    rows = table_rows_new_empty();
    bt = table_index_get(table->indexs, column, 0);
    values = bt_search_range(bt, limit, min_value, max_value);
    counts = bt_values_get_count(values);
    for(i = 0; i < counts; i++)
    {
        rowid = bt_values_get_value(values, i);
        row = table_content_get_row(table->content, rowid);
        table_rows_append_row(rows, row);
    }
    bt_values_destory(values);
    return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x4dc0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x4c30
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x1c90
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1800
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
jae 0x4195
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x1820
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x50(%rbp), %rsi
callq 0x4d20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4d50
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x414a
movq -0x48(%rbp), %rdi
callq 0x17d0
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_search_by_exhaustion
static TableRows *table_search_by_exhaustion(Table *table, uint64_t column, uint64_t min_value, uint64_t max_value, uint64_t limit)
{
    TableRows   *rows;
    TableRow    *row;
    uint64_t     rowid ,row_counts, value;

    rows = table_rows_new_empty();
    
    row_counts = table_content_get_row_counts(table->content);
    for(rowid = 0; rowid < row_counts && limit > 0; rowid++)
    {
        row = table_content_get_row(table->content, rowid);
        value = table_row_get_property(row, column);
        if(value >= min_value && value <= max_value)
        {
            table_rows_append_row(rows, row);
            limit--;
        }
    }

    return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
callq 0x4dc0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4e00
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x48(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x4208
cmpq $0x0, -0x28(%rbp)
seta %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x4211
jmp 0x4277
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x4d20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3e10
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x4264
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x4264
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4d50
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4266
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x41ee
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_search
TableRows *table_search(Table *table, uint64_t column, uint64_t value, uint64_t limit)
{
    TableRows *rows;

    table_lock(table);

    rows = table_search_range(table, column, value, value, limit);

    table_unlock(table);

    return rows;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4070
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x3fe0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4290
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_append
void table_append(Table *table, TableRow *row)
{
    uint64_t rowid;
    
    table_lock(table);
    
    rowid = table_content_append_row(table->content, row);
    table_index_update(table->indexs, row, rowid);

    table_unlock(table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x43a0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x43d0
movq -0x8(%rbp), %rdi
callq 0x4290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_update
static void table_index_update(TableIndex *index, TableRow *row, uint64_t rowid)
{
    uint64_t  col, value;
    BTree    *bt;

    for(col = 0; col < COLUMNS; col++)
    {
        if(index->index_flag[col] == 1)
        {
            value = table_row_get_property(row, col);
            bt = table_index_get(index, col, 0);
            bt_insert(bt, value, rowid);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x64, -0x20(%rbp)
jae 0x4448
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x1, 0x8(%rax,%rcx,8)
jne 0x4438
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3e10
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x4c30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1ab0
jmp 0x443a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x43ec
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_create_index
int table_create_index(Table *table, uint64_t column)
{
    TableRows *rows;
    int rtv;
    
    table_lock(table);
    
    rows = table_content_get_all_rows(table->content);
    rtv = table_index_create(table->indexs, column, rows);
    
    table_unlock(table);
    return rtv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4070
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x44b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x44d0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4290
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_create
static int table_index_create(TableIndex *index, uint64_t column, TableRows *all_rows)
{
    BTree     *bt;
    TableRow  *row;
    uint64_t   row_counts, rowid, value;

    // do nothing if index on this column already exist
    if(index->index_flag[column] != 0)
    {
        assert(index->index_trees[column] != NULL);
        return -1;
    }

    // create an empty index on column
    index->index_flag[column] = 1;
    bt = table_index_get(index, column, 1);
    assert(index->index_trees[column] != NULL);

    // update newly created index by all rows
    row_counts = table_rows_get_counts(all_rows);
    for(rowid = 0; rowid < row_counts; rowid++)
    {
        row = table_rows_get_row(all_rows, rowid);
        value = table_row_get_property(row, column);
        bt_insert(bt, value, rowid);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x4534
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0x328(%rax,%rcx,8)
je 0x4509
jmp 0x4528
leaq 0x2543(%rip), %rdi      # 0x6a53
leaq 0x2474(%rip), %rsi      # 0x698b
movl $0x19d, %edx            # imm = 0x19D
leaq 0x2553(%rip), %rcx      # 0x6a76
callq 0x10b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45f6
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x1, 0x8(%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x4c30
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, 0x328(%rax,%rcx,8)
je 0x4570
jmp 0x458f
leaq 0x24dc(%rip), %rdi      # 0x6a53
leaq 0x240d(%rip), %rsi      # 0x698b
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x24ec(%rip), %rcx      # 0x6a76
callq 0x10b0
movq -0x20(%rbp), %rdi
callq 0x3e60
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x45ef
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x3e80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e10
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x1ab0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x45a4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_open
Table *table_open(TableOpenFlag flag)
{
    if(access(flag.dir, F_OK) != -1)
    {
        if(flag.error_if_exist)
            return NULL;
        return table_new_from_file(flag.dir);
    }
    else
    {
        // table not exist!
        if(!flag.create_if_missing)
            return NULL;
        return table_new_empty(flag.dir);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1140
cmpl $-0x1, %eax
je 0x463f
cmpl $0x0, -0xc(%rbp)
je 0x4630
movq $0x0, -0x8(%rbp)
jmp 0x465c
movq -0x18(%rbp), %rdi
callq 0x4670
movq %rax, -0x8(%rbp)
jmp 0x465c
cmpl $0x0, -0x10(%rbp)
jne 0x464f
movq $0x0, -0x8(%rbp)
jmp 0x465c
movq -0x18(%rbp), %rdi
callq 0x4730
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_new_from_file
static Table *table_new_from_file(const char *dir)
{
    Table *table;
    char  *h_dir;
    int rtv;

    table = (Table *)malloc(sizeof(Table));
    
    h_dir = (char *)malloc(strlen(dir) + 1);
    strcpy(h_dir, dir);

    table->dir = h_dir;
    table->content = table_content_new_from_file(dir);
    table->indexs = table_index_new_by_meta(dir, &(table->content->meta));
    rtv = pthread_mutex_init(&table->mutex, NULL);
    if (rtv != 0)
    {
        table_close(table);
        return NULL;
    }
    
    return table;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x40, %edi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4e20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x20, %rsi
callq 0x4fd0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1160
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x471c
movq -0x18(%rbp), %rdi
callq 0x4ae0
movq $0x0, -0x8(%rbp)
jmp 0x4724
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_new_empty
static Table *table_new_empty(const char *dir)
{
    Table *table;
    char  *h_dir;
    int    rtv;

    table = (Table *)malloc(sizeof(Table));
    
    h_dir = (char *)malloc(strlen(dir) + 1);
    strcpy(h_dir, dir);

    rtv = mkdir(h_dir, S_IRUSR | S_IWUSR | S_IXUSR);
    assert(rtv == 0);

    table->dir = h_dir;
    table->content = table_content_new_empty(dir);
    table->indexs = table_index_new_empty(dir);
    rtv = pthread_mutex_init(&table->mutex, NULL);
    if (rtv != 0)
    {
        table_close(table);
        return NULL;
    }
    return table;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x40, %edi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
addq $0x1, %rdi
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1040
movq -0x20(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1050
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4789
jmp 0x47a8
leaq 0x2247(%rip), %rdi      # 0x69d7
leaq 0x21f4(%rip), %rsi      # 0x698b
movl $0x259, %edx            # imm = 0x259
leaq 0x23f0(%rip), %rcx      # 0x6b93
callq 0x10b0
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x5110
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x51a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1160
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4808
movq -0x18(%rbp), %rdi
callq 0x4ae0
movq $0x0, -0x8(%rbp)
jmp 0x4810
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_content_flush
static void table_content_flush(TableContent *content)
{
    ssize_t       rtv;
    TableRow     *row;
    uint64_t      row_counts;
    int           i;

    table_content_open_file(content);
    rtv = lseek(content->file_fd, 0, SEEK_SET);
    assert(rtv == 0);
    rtv = write(content->file_fd, &content->meta, sizeof(TableMeta));

    row_counts = table_rows_get_counts(content->rows);
    assert(rtv == sizeof(TableMeta));
    rtv = lseek(content->file_fd, sizeof(TableRow) * content->next_rowid_to_flush, SEEK_CUR);
    assert(rtv == sizeof(TableRow) * content->next_rowid_to_flush + sizeof(TableMeta));
    for(i = content->next_rowid_to_flush; i < row_counts; i++)
    {
        row = table_rows_get_row(content->rows, i);
        rtv = write(content->file_fd, row, sizeof(TableRow));
        assert(rtv == sizeof(TableRow));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x48f4
jmp 0x4913
leaq 0x20dc(%rip), %rdi      # 0x69d7
leaq 0x2089(%rip), %rsi      # 0x698b
movl $0x111, %edx            # imm = 0x111
leaq 0x22aa(%rip), %rcx      # 0x6bb8
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movl $0x330, %edx            # imm = 0x330
callq 0x1060
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3e60
movq %rax, -0x20(%rbp)
cmpq $0x330, -0x10(%rbp)     # imm = 0x330
jne 0x494d
jmp 0x496c
leaq 0x2196(%rip), %rdi      # 0x6aea
leaq 0x2030(%rip), %rsi      # 0x698b
movl $0x115, %edx            # imm = 0x115
leaq 0x2251(%rip), %rcx      # 0x6bb8
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rax
imulq $0x320, 0x10(%rax), %rsi # imm = 0x320
movl $0x1, %edx
callq 0x10a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x320, 0x10(%rcx), %rcx # imm = 0x320
addq $0x330, %rcx            # imm = 0x330
cmpq %rcx, %rax
jne 0x49ab
jmp 0x49ca
leaq 0x222f(%rip), %rdi      # 0x6be1
leaq 0x1fd2(%rip), %rsi      # 0x698b
movl $0x117, %edx            # imm = 0x117
leaq 0x21f3(%rip), %rcx      # 0x6bb8
callq 0x10b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4a45
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x24(%rbp), %rsi
callq 0x3e80
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rsi
movl $0x320, %edx            # imm = 0x320
callq 0x1060
movq %rax, -0x10(%rbp)
cmpq $0x320, -0x10(%rbp)     # imm = 0x320
jne 0x4a19
jmp 0x4a38
leaq 0x2110(%rip), %rdi      # 0x6b30
leaq 0x1f64(%rip), %rsi      # 0x698b
movl $0x11c, %edx            # imm = 0x11C
leaq 0x2185(%rip), %rcx      # 0x6bb8
callq 0x10b0
jmp 0x4a3a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x49d5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_flush
static void table_index_flush(TableIndex *index)
{
    int i;

    for(i = 0; i < COLUMNS; i++)
    {
        if(index->index_trees[i] != NULL)
        {
            assert(index->index_flag[i] == 1);
            bt_flush(index->index_trees[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x4acf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x328(%rax,%rcx,8)
je 0x4ac2
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x1, 0x8(%rax,%rcx,8)
jne 0x4a8e
jmp 0x4aad
leaq 0x2197(%rip), %rdi      # 0x6c2c
leaq 0x1eef(%rip), %rsi      # 0x698b
movl $0x1ba, %edx            # imm = 0x1BA
leaq 0x219e(%rip), %rcx      # 0x6c46
callq 0x10b0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x328(%rax,%rcx,8), %rdi
callq 0x1880
jmp 0x4ac4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a63
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_close
void table_close(Table *table)
{
    pthread_mutex_destroy(&table->mutex);
    table_flush(table);
    table_index_destory(table->indexs);
    table_content_destory(table->content);
    free(table->dir);
    free(table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x4820
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4b40
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4bd0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_destory
static void table_index_destory(TableIndex *index)
{
    int i;

    for(i = 0; i < COLUMNS; i++)
    {
        if(index->index_trees[i] != NULL)
        {
            assert(index->index_flag[i] == 1);
            bt_close(index->index_trees[i]);
        }
    }

    free(index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x64, -0xc(%rbp)
jge 0x4bbf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x328(%rax,%rcx,8)
je 0x4bb2
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x1, 0x8(%rax,%rcx,8)
jne 0x4b7e
jmp 0x4b9d
leaq 0x20a7(%rip), %rdi      # 0x6c2c
leaq 0x1dff(%rip), %rsi      # 0x698b
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x20d3(%rip), %rcx      # 0x6c6b
callq 0x10b0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x328(%rax,%rcx,8), %rdi
callq 0x2170
jmp 0x4bb4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b53
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_get
static BTree *table_index_get(TableIndex *index, uint64_t column, int is_creat)
{
    BTree        *bt;
    BTreeOpenFlag flag;
    char          full_name[64];

    if (index->index_trees[column] == NULL)
    {
        table_index_get_path(index, column, full_name);

        flag.file = full_name;
        flag.order = 101;
        if (is_creat)
        {
            flag.create_if_missing = 1;
            flag.error_if_exist = 1;
        }
        else
        {
            flag.create_if_missing = 0;
            flag.error_if_exist = 0;
        }
        

        bt = bt_open(flag);
        assert(bt != NULL);
        index->index_trees[column] = bt;
    }


    return index->index_trees[column];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, 0x328(%rax,%rcx,8)
jne 0x4d04
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x3f70
leaq -0x80(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x65, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4c94
movl $0x1, -0x28(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x4ca2
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1db0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4cd1
jmp 0x4cf0
leaq 0x1d21(%rip), %rdi      # 0x69f9
leaq 0x1cac(%rip), %rsi      # 0x698b
movl $0x17c, %edx            # imm = 0x17C
leaq 0x1d19(%rip), %rcx      # 0x6a04
callq 0x10b0
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0x328(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x328(%rax,%rcx,8), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_rows_append_row
static uint64_t table_rows_append_row(TableRows *rows, TableRow *row)
{
    uint64_t rowid;
    rowid = rows->counts;

    rows->counts++;
    rows->rows = (TableRow **)realloc(rows->rows, sizeof(TableRow *) * (rows->counts));
    rows->rows[rowid] = row;

    return rowid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
shlq $0x3, %rsi
callq 0x1110
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)