LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_encoder_write_bytes
void xlink_encoder_write_bytes(xlink_encoder *enc, xlink_list *bytes) {
  int i, j;
  for (j = 0; j < xlink_list_length(bytes); j++) {
    unsigned char byte;
    unsigned char partial;
    byte = *xlink_list_get_byte(bytes, j);
    partial = 1;
    /* Build partially seen byte from high bit to low bit to match decoder. */
    for (i = 8; i-- > 0; ) {
      unsigned int counts[2];
      int bit;
      xlink_context_get_counts(enc->ctx, partial, counts);
      bit = !!(byte & (1 << i));
      xlink_encoder_write_bit(enc, counts[0], counts[1], bit);
      xlink_context_update_bit(enc->ctx, partial, bit);
      partial <<= 1;
      partial |= bit;
    }
    XLINK_ERROR(partial != byte,
     ("Mismatch between partial %02x and byte %02x", partial, byte));
    for (i = 8; i-- > 1; ) {
      enc->ctx->buf[i] = enc->ctx->buf[i - 1];
    }
    enc->ctx->buf[0] = byte;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0xa61e
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xc870
movb (%rax), %al
movb %al, -0x19(%rbp)
movb $0x1, -0x1a(%rbp)
movl $0x8, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0xa59a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x1a(%rbp), %al
leaq -0x24(%rbp), %rdx
movzbl %al, %esi
callq 0xb990
movzbl -0x19(%rbp), %eax
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0xa370
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x1a(%rbp), %al
movl -0x28(%rbp), %edx
movzbl %al, %esi
callq 0xba90
movzbl -0x1a(%rbp), %eax
shll %eax
movb %al, -0x1a(%rbp)
movl -0x28(%rbp), %ecx
movzbl -0x1a(%rbp), %eax
orl %ecx, %eax
movb %al, -0x1a(%rbp)
jmp 0xa50f
jmp 0xa59c
movzbl -0x1a(%rbp), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
je 0xa5c8
movzbl -0x1a(%rbp), %esi
movzbl -0x19(%rbp), %edx
leaq 0x5a7e(%rip), %rdi      # 0x10035
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xa5ca
movl $0x8, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x1, %eax
jle 0xa604
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xa5d1
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa4d7
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_encoder_finalize
void xlink_encoder_finalize(xlink_encoder *enc, xlink_bitstream *bs) {
  xlink_word m;
  int s;
  int i;
  m = EC_BASE - 1;
  /* Count how many bits must be output to ensure that the symbols encoded thus
      far will decode correctly regardless of the bits that follow. */
  for (s = 1; ((enc->low + m) | m) - enc->low >= enc->range; s++, m >>= 1);
  XLINK_ERROR(s > 2,
   ("At most two bits need to be written to finalize range coder"));
  if (m > EC_MASK - enc->low) {
    /* Handle carry */
    xlink_encoder_emit(enc, 1);
  }
  for (i = 0; i < s; i++) {
    if ((enc->low + m) & (EC_BASE >> i)) {
      enc->ones++;
    }
    else {
      xlink_encoder_emit(enc, 0);
    }
  }
  /* Flush any pending bits */
  xlink_encoder_emit(enc, 0);
  /* Copy finalized bits to bitstream */
  bs->bits = enc->bits;
  bs->bytes.length = 0;
  xlink_list_append(&bs->bytes, &enc->bytes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x7fffffff, -0x14(%rbp) # imm = 0x7FFFFFFF
movl $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addl -0x14(%rbp), %eax
orl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
subl 0x24(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jb 0xa680
jmp 0xa66d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
jmp 0xa64e
jmp 0xa682
cmpl $0x2, -0x18(%rbp)
jle 0xa6a0
leaq 0x59d2(%rip), %rdi      # 0x10061
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xa6a2
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
subl 0x24(%rdx), %ecx
cmpl %ecx, %eax
jbe 0xa6c3
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa760
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xa716
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
addl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
movl $0x80000000, %edx       # imm = 0x80000000
shrl %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xa6fe
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0xa709
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xa760
jmp 0xa70b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xa6ca
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xa760
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0xca30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_decoder_init
void xlink_decoder_init(xlink_decoder *dec, xlink_context *ctx,
 xlink_bitstream *bs) {
  dec->ctx = ctx;
  dec->bytes = &bs->bytes;
  dec->bits = bs->bits;
  dec->pos = 1;
  dec->low = 0;
  dec->range = 1;
  dec->value = 0;
  /* Discard first bit */
  XLINK_ERROR(xlink_decoder_read_bit(dec, 1, 1) == 0,
   ("Expected first decoded bit to be 1"));
  /* Update the context with 1 bit */
  xlink_context_update_bit(dec->ctx, 0, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xab20
cmpl $0x0, %eax
jne 0xab02
leaq 0x55ac(%rip), %rdi      # 0x1009d
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xab04
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xba90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_decoder_read_byte
unsigned char xlink_decoder_read_byte(xlink_decoder *dec) {
  unsigned char byte;
  int i;
  byte = 1;
  for (i = 8; i-- > 0; ) {
    unsigned int counts[2];
    int bit;
    xlink_context_get_counts(dec->ctx, byte, counts);
    bit = xlink_decoder_read_bit(dec, counts[0], counts[1]);
    xlink_context_update_bit(dec->ctx, byte, bit);
    byte <<= 1;
    byte |= bit;
  }
  for (i = 8; i-- > 1; ) {
    dec->ctx->buf[i] = dec->ctx->buf[i - 1];
  }
  dec->ctx->buf[0] = byte;
  return byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
movl $0x8, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jle 0xad3b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x9(%rbp), %al
leaq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0xb990
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0xab20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x9(%rbp), %al
movl -0x1c(%rbp), %edx
movzbl %al, %esi
callq 0xba90
movzbl -0x9(%rbp), %eax
shll %eax
movb %al, -0x9(%rbp)
movl -0x1c(%rbp), %ecx
movzbl -0x9(%rbp), %eax
orl %ecx, %eax
movb %al, -0x9(%rbp)
jmp 0xacd7
movl $0x8, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x1, %eax
jle 0xad75
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0xad42
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb %cl, (%rax)
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/internal.c
// Function: xlink_log
void xlink_log(const char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  fprintf(stderr, "Error: ");
  vfprintf(stderr, fmt, ap);
  fprintf(stderr, "\n");
  va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xadc5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x91e4(%rip), %rax      # 0x13ff8
movq %rax, -0xe0(%rbp)
movq (%rax), %rdi
leaq 0x5321(%rip), %rsi      # 0x10146
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x20e0
movq -0xe0(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2190
movq -0xe0(%rbp), %rcx
movb -0xd1(%rbp), %al
movq (%rcx), %rdi
leaq 0x49fd(%rip), %rsi      # 0xf85d
callq 0x20e0
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/internal.c
// Function: xlink_malloc
void *xlink_malloc(size_t size) {
  void *ptr;
  ptr = malloc(size);
  XLINK_ERROR(ptr == NULL, ("Insufficient memory for %i byte malloc", size));
  memset(ptr, 0, size);
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaeac
movq -0x8(%rbp), %rsi
leaq 0x52b3(%rip), %rdi      # 0x1014e
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xaeae
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x20b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/io.c
// Function: xlink_file_init
void xlink_file_init(xlink_file *file, const char *name) {
  FILE *fp;
  int size;
  fp = fopen(name, "rb");
  XLINK_ERROR(fp == NULL, ("Could not open file %s", name));
  file->name = name;
  fseek(fp, 0, SEEK_END);
  file->size = ftell(fp);
  file->buf = xlink_malloc(file->size);
  fseek(fp, 0, SEEK_SET);
  size = fread((unsigned char *)file->buf, 1, file->size, fp);
  XLINK_ERROR(size != file->size,
   ("Problem reading file %s, got %i of %i bytes", name, size, file->size));
  fclose(fp);
  file->pos = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x5262(%rip), %rsi      # 0x1019d
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xaf67
movq -0x10(%rbp), %rsi
leaq 0x524a(%rip), %rdi      # 0x101a0
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xaf69
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2150
movq -0x18(%rbp), %rdi
callq 0x20f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edi
callq 0xae70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2150
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x2060
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xb014
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x51b4(%rip), %rdi      # 0x101b7
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xb016
movq -0x18(%rbp), %rdi
callq 0x2070
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_model_init
void xlink_model_init(xlink_model *model, unsigned char mask) {
  int i;
  model->mask = mask;
  /* For now just compute the weight as the number of bits set in mask */
  model->weight = 0;
  for (i = 0; i < 8; i++) {
    model->weight += !!(mask & (1 << i));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0xb0b5
movzbl -0x9(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb079
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_model_compute_packed_weights
unsigned int xlink_model_compute_packed_weights(xlink_list *models) {
  unsigned int packed;
  int i, j;
  int last;
  packed = 0xffffffffu;
  i = 0;
  last = 0;
  for (j = 0; j < xlink_list_length(models); j++, i++) {
    xlink_model *model;
    model = xlink_list_get(models, j);
    i += model->weight - last;
    XLINK_ERROR(i > 31, ("Invalid list of models, i = %i", i));
    packed &= ~(1 << (31 - i));
    last = model->weight;
  }
  return packed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0xb17c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc870
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x1f, -0x10(%rbp)
jle 0xb141
movl -0x10(%rbp), %esi
leaq 0x50d8(%rip), %rdi      # 0x10208
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xb143
movl $0x1f, %ecx
subl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
andl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb0e8
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_model_set_state
void xlink_model_set_state(xlink_list *models, unsigned int state) {
  int weight;
  int i;
  weight = 0;
  for (i = 0; state != 0; i++) {
    int test;
    xlink_model *model;
    weight--;
    do {
      weight++;
      test = state >= 0x80000000u;
      state += state;
    }
    while (test);
    if (state == 0) break;
    model = xlink_list_get(models, i);
    XLINK_ERROR(model->weight != weight,
     ("Mismatch when decoding model %02x weight: got %i expected %i",
     model->mask, weight, model->weight));
    model->state = state;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xb251
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpl $0x80000000, -0xc(%rbp) # imm = 0x80000000
setae %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xb1c0
cmpl $0x0, -0xc(%rbp)
jne 0xb1f2
jmp 0xb251
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc870
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
je 0xb237
movq -0x20(%rbp), %rax
movzbl (%rax), %esi
movl -0x10(%rbp), %edx
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x5001(%rip), %rdi      # 0x10227
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xb239
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb1ad
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: model_comp
int model_comp(const void *a, const void *b) {
  const xlink_model *mod_a;
  const xlink_model *mod_b;
  int mask_a;
  int mask_b;
  int i;
  mod_a = (xlink_model *)a;
  mod_b = (xlink_model *)b;
  /* Compute the bit-reversal of the mask */
  mask_a = mask_b = 0;
  for (i = 0; i < 8; i++) {
    mask_a <<= 1;
    mask_b <<= 1;
    mask_a |= !!(mod_a->mask & (1 << i));
    mask_b |= !!(mod_b->mask & (1 << i));
  }
  /* Sort on weights ascending, then bit-reversed mask */
  if (mod_a->weight == mod_b->weight) {
    return mask_a - mask_b;
  }
  return mod_a->weight - mod_b->weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x8, -0x34(%rbp)
jge 0xb306
movl -0x2c(%rbp), %eax
shll %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
shll %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
orl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xb291
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xb321
movl -0x2c(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb332
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: match_comp
int match_comp(const void *a, const void *b) {
  const xlink_match *mat_a;
  const xlink_match *mat_b;
  mat_a = (xlink_match *)a;
  mat_b = (xlink_match *)b;
  int i;
  if (mat_a->mask == mat_b->mask) {
    if (mat_a->partial == mat_b->partial) {
      for (i = 0; i < 8; i++) {
        if (mat_a->mask & (1 << (7 - i))) {
          if (mat_a->buf[i] == mat_b->buf[i]) {
            continue;
          }
          return mat_a->buf[i] - mat_b->buf[i];
        }
      }
      return 0;
    }
    return mat_a->partial - mat_b->partial;
  }
  return mat_a->mask - mat_b->mask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x5(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jne 0xb427
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0xb410
movl $0x0, -0x2c(%rbp)
cmpl $0x8, -0x2c(%rbp)
jge 0xb407
movq -0x20(%rbp), %rax
movzbl 0x5(%rax), %eax
movl $0x7, %ecx
subl -0x2c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb3fa
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl 0x6(%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzbl 0x6(%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0xb3d9
jmp 0xb3fc
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl 0x6(%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzbl 0x6(%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb43c
jmp 0xb3fc
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb393
movl $0x0, -0x4(%rbp)
jmp 0xb43c
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xb43c
movq -0x20(%rbp), %rax
movzbl 0x5(%rax), %eax
movq -0x28(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: match_hash_code
unsigned int match_hash_code(const void *m) {
  const xlink_match *mat;
  unsigned int hash;
  int i;
  mat = (xlink_match *)m;
  hash = 0x0;
  /* Combine the mask */
  hash += mat->mask;
  hash *= 0x6f;
  hash ^= mat->mask;
  /* Combine the partial */
  hash += mat->partial;
  hash *= 0x6f;
  hash ^= mat->partial;
  /* Combine the history */
  for (i = 0; i < 8; i++) {
    if (mat->mask & (1 << (7 - i))) {
      hash += mat->buf[i];
      hash *= 0x6f;
      hash ^= mat->buf[i];
    }
  }
  /* Extra hashing for good measure */
  hash ^= (hash >> 20) ^ (hash >> 12);
  return hash ^ (hash >> 7) ^ (hash >> 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x6f, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x6f, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x8, -0x18(%rbp)
jge 0xb544
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movl $0x7, %ecx
subl -0x18(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb537
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl 0x6(%rax,%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
imull $0x6f, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl 0x6(%rax,%rcx), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xb539
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb4e4
movl -0x14(%rbp), %eax
shrl $0x14, %eax
movl -0x14(%rbp), %ecx
shrl $0xc, %ecx
xorl %ecx, %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x14(%rbp), %ecx
shrl $0x7, %ecx
xorl %ecx, %eax
movl -0x14(%rbp), %ecx
shrl $0x4, %ecx
xorl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: match_hash_code_simple
unsigned int match_hash_code_simple(const void *m) {
  const xlink_match *mat;
  unsigned int hash;
  unsigned char byte;
  int i;
  mat = (xlink_match *)m;
  /* Use current weight state to salt the hash */
  hash = mat->salt;
  /* Combine the mask */
  hash = (hash & 0xffffff00) | mat->mask;
  /* Combine the partial */
  byte = (hash & 0x000000ff);
  hash = (hash & 0xffffff00) | (byte ^ mat->partial);
  hash = ((int)hash)*0x6f;
  byte = (hash & 0x000000ff);
  hash = (hash & 0xffffff00) | ((byte + mat->partial) & 0x000000ff);
  hash--;
  /* Combine the history */
  for (i = 0; i < 8; i++) {
    if (mat->mask & (1 << (7 - i))) {
      byte = (hash & 0x000000ff);
      hash = (hash & 0xffffff00) | (byte ^ mat->buf[i]);
      hash = ((int)hash)*0x6f;
      byte = (hash & 0x000000ff);
      hash = (hash & 0xffffff00) | ((byte + mat->buf[i]) & 0x000000ff);
      hash--;
    }
  }
  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
xorl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
imull $0x6f, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
addl %edx, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xb6ad
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movl $0x7, %ecx
subl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb69d
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movzbl 0x6(%rdx,%rsi), %edx
xorl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
imull $0x6f, -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movzbl 0x6(%rdx,%rsi), %edx
addl %edx, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb69f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb607
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: match_hash_code_fast
unsigned int match_hash_code_fast(const void *m) {
  const xlink_match *mat;
  unsigned int hash;
  unsigned char byte;
  int i;
  mat = (xlink_match *)m;
  /* Use current weight state to salt the hash */
  hash = mat->salt;
  /* Combine the mask */
  hash = (hash & 0xffffff00) | mat->mask;
  /* Combine the partial */
  byte = (hash & 0x000000ff);
  hash = (hash & 0xffffff00) | (byte ^ mat->partial);
  hash = xlink_rotate_left(hash, 9);
  byte = (hash & 0x000000ff);
  hash = (hash & 0xffffff00) | ((byte + mat->partial) & 0x000000ff);
  hash--;
  /* Combine the history */
  for (i = 0; i < 8; i++) {
    if (mat->mask & (1 << (7 - i))) {
      byte = (hash & 0x000000ff);
      hash = (hash & 0xffffff00) | (byte ^ mat->buf[i]);
      hash = xlink_rotate_left(hash, 9);
      byte = (hash & 0x000000ff);
      hash = (hash & 0xffffff00) | ((byte + mat->buf[i]) & 0x000000ff);
      hash--;
    }
  }
  return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
xorl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x9, %esi
callq 0xb820
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
addl %edx, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xb813
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movl $0x7, %ecx
subl -0x1c(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xb803
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movzbl 0x6(%rdx,%rsi), %edx
xorl %edx, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x9, %esi
callq 0xb820
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rsi
movzbl 0x6(%rdx,%rsi), %edx
addl %edx, %ecx
andl $0xff, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb805
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb764
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_context_init
void xlink_context_init(xlink_context *ctx, xlink_list *models, int capacity,
 int fast, int clamp) {
  ctx->models = models;
  xlink_set_init(&ctx->matches, match_hash_code_simple, match_equals,
   sizeof(xlink_match), 0, 0.75);
  if (capacity > 0) {
    xlink_context_set_fixed_capacity(ctx, capacity);
  }
  if (fast) {
    ctx->matches.hash_code = match_hash_code_fast;
  }
  xlink_context_reset(ctx);
  ctx->clamp = clamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x315(%rip), %rsi      # 0xb570
leaq -0x43c(%rip), %rdx      # 0xb450
movl $0x10, %ecx
xorl %r8d, %r8d
movss 0x4948(%rip), %xmm0     # 0x101e4
callq 0xcdc0
cmpl $0x0, -0x14(%rbp)
jle 0xb8b3
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xb8f0
cmpl $0x0, -0x18(%rbp)
je 0xb8c8
movq -0x8(%rbp), %rax
leaq -0x204(%rip), %rcx      # 0xb6c0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0xb940
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_context_set_fixed_capacity
void xlink_context_set_fixed_capacity(xlink_context *ctx, int capacity) {
  ctx->matches.equals = NULL;
  ctx->matches.load = 1.f;
  xlink_set_reset(&ctx->matches);
  xlink_set_resize(&ctx->matches, capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movss 0x48d1(%rip), %xmm0     # 0x101e8
movss %xmm0, 0x24(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0xce80
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0xcf10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_context_get_counts
void xlink_context_get_counts(xlink_context *ctx, unsigned char partial,
 unsigned int counts[2]) {
  xlink_match key;
  int i;
  memcpy(key.buf, ctx->buf, sizeof(ctx->buf));
  key.partial = partial;
  counts[0] = counts[1] = 2;
  for (i = 0; i < xlink_list_length(ctx->models); i++) {
    xlink_model *model;
    xlink_match *match;
    model = xlink_list_get(ctx->models, i);
    key.mask = model->mask;
    key.salt = model->state;
    match = xlink_set_get(&ctx->matches, &key);
    if (match != NULL) {
      counts[0] += ((unsigned int)match->counts[0]) << model->weight;
      counts[1] += ((unsigned int)match->counts[1]) << model->weight;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x22(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0xba7e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0xc870
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb (%rax), %al
movb %al, -0x23(%rbp)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0xd4b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xba6e
movq -0x40(%rbp), %rax
movzbl 0xe(%rax), %eax
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movzbl 0xf(%rax), %eax
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0xba70
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb9d3
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_context_update_bit
void xlink_context_update_bit(xlink_context *ctx, unsigned char partial,
 int bit) {
  xlink_match key;
  int i;
  key.partial = partial;
  memcpy(key.buf, ctx->buf, sizeof(ctx->buf));
  for (i = 0; i < xlink_list_length(ctx->models); i++) {
    xlink_model *model;
    xlink_match *match;
    model = xlink_list_get(ctx->models, i);
    key.mask = model->mask;
    key.salt = model->state;
    match = xlink_set_get(&ctx->matches, &key);
    if (match == NULL) {
      memset(key.counts, 0, sizeof(key.counts));
      match = xlink_set_put(&ctx->matches, &key);
    }
    if (ctx->clamp) {
      match->counts[bit] = XLINK_MIN(255, match->counts[bit] + 1);
    }
    else {
      match->counts[bit] = match->counts[bit] + 1;
    }
    if (match->counts[1 - bit] > 1) {
      match->counts[1 - bit] >>= 1;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1a(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jge 0xbbfd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x24(%rbp), %esi
callq 0xc870
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
movb %al, -0x1b(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0xd4b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xbb49
leaq -0x20(%rbp), %rdi
addq $0xe, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x20b0
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0xd580
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
je 0xbb9c
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl 0xe(%rax,%rcx), %ecx
addl $0x1, %ecx
movl $0xff, %eax
cmpl %ecx, %eax
jg 0xbb76
movl $0xff, %eax
movl %eax, -0x40(%rbp)
jmp 0xbb89
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl 0xe(%rax,%rcx), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, 0xe(%rax,%rcx)
jmp 0xbbba
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl 0xe(%rax,%rcx), %eax
addl $0x1, %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, 0xe(%rax,%rcx)
movq -0x38(%rbp), %rax
movl $0x1, %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movzbl 0xe(%rax,%rcx), %eax
cmpl $0x1, %eax
jle 0xbbed
movq -0x38(%rbp), %rax
movl $0x1, %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movzbl 0xe(%rax,%rcx), %edx
sarl %edx
movb %dl, 0xe(%rax,%rcx)
jmp 0xbbef
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xbabd
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_modeler_init
void xlink_modeler_init(xlink_modeler *mod, int bytes) {
  xlink_list_init(&mod->bytes, sizeof(unsigned char), bytes);
  xlink_list_init(&mod->counts, sizeof(xlink_counts), 8*bytes);
  xlink_set_init(&mod->matches, match_hash_code, match_equals,
   sizeof(xlink_match), 256*8*bytes, 0.75);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0xc610
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0xc(%rbp), %edx
shll $0x3, %edx
movl $0x200, %esi            # imm = 0x200
callq 0xc610
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0xc(%rbp), %r8d
shll $0xb, %r8d
leaq -0x7df(%rip), %rsi      # 0xb480
leaq -0x816(%rip), %rdx      # 0xb450
movl $0x10, %ecx
movss 0x4571(%rip), %xmm0     # 0x101e4
callq 0xcdc0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/paq.c
// Function: xlink_modeler_print
void xlink_modeler_print(xlink_modeler *mod, xlink_list *models) {
  if (xlink_list_length(models) > 0) {
    double entropy;
    int bytes;
    int i;
    entropy = xlink_modeler_get_entropy(mod, models);
    entropy -= 8*(4 + xlink_list_length(models));
    bytes = ceil(entropy/8);
    printf("Found context: %i model(s), %0.3lf bits, %i bytes\n",
     xlink_list_length(models), entropy, bytes);
    for (i = 0; i < xlink_list_length(models); i++) {
      xlink_model *model;
      model = xlink_list_get(models, i);
      printf("(%02x, %i) ", model->mask, model->weight);
    }
    printf("\n");
    printf("Packed weights = %08x\n",
     xlink_model_compute_packed_weights(models));
  }
  else {
    printf("No context found.\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
cmpl $0x0, %eax
jle 0xc302
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xbf90
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
addl $0x4, %eax
shll $0x3, %eax
cvtsi2sd %eax, %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x3fae(%rip), %xmm1     # 0x10200
divsd %xmm1, %xmm0
callq 0x21e0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movl %eax, %esi
movsd -0x18(%rbp), %xmm0
movl -0x1c(%rbp), %edx
leaq 0x4091(%rip), %rdi      # 0x1030d
movb $0x1, %al
callq 0x20a0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0xc2d9
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0xc870
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl (%rax), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x4079(%rip), %rdi      # 0x10340
movb $0x0, %al
callq 0x20a0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc28a
leaq 0x357d(%rip), %rdi      # 0xf85d
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
callq 0xb0c0
movl %eax, %esi
leaq 0x4053(%rip), %rdi      # 0x1034c
movb $0x0, %al
callq 0x20a0
jmp 0xc310
leaq 0x405a(%rip), %rdi      # 0x10363
movb $0x0, %al
callq 0x20a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_init
void xlink_list_init(xlink_list *list, size_t size, int capacity) {
  memset(list, 0, sizeof(xlink_list));
  list->size = size;
  list->capacity = capacity;
  list->data = xlink_malloc(list->size*list->capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x20b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rax
imulq %rax, %rdi
callq 0xae70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_expand_capacity
void xlink_list_expand_capacity(xlink_list *list, int capacity) {
  if (list->capacity < capacity) {
    list->capacity = XLINK_MAX(capacity,
     XLINK_MAX(4, XLINK_MIN(list->capacity << 1, list->capacity + 1024)));
    list->data = xlink_realloc(list->data, list->capacity*list->size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0xc865
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x400, %ecx            # imm = 0x400
cmpl %ecx, %eax
jg 0xc72d
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0x14(%rbp)
jmp 0xc73c
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl $0x4, %eax
cmpl %ecx, %eax
jl 0xc752
movl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0xc78f
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x400, %ecx            # imm = 0x400
cmpl %ecx, %eax
jg 0xc77a
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0xc789
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jl 0xc7a4
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0xc834
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x400, %ecx            # imm = 0x400
cmpl %ecx, %eax
jg 0xc7cc
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0xc7db
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movl $0x4, %eax
cmpl %ecx, %eax
jl 0xc7f1
movl $0x4, %eax
movl %eax, -0x28(%rbp)
jmp 0xc82e
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
addl $0x400, %ecx            # imm = 0x400
cmpl %ecx, %eax
jg 0xc819
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shll %eax
movl %eax, -0x2c(%rbp)
jmp 0xc828
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x400, %eax            # imm = 0x400
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x14(%rax), %rsi
movq -0x8(%rbp), %rax
imulq 0x8(%rax), %rsi
callq 0xaed0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_add
int xlink_list_add(xlink_list *list, const void *element) {
  xlink_list_expand_capacity(list, list->length + 1);
  list->length++;
  xlink_list_set(list, list->length - 1, element);
  return list->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
callq 0xc6e0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
subl $0x1, %esi
movq -0x10(%rbp), %rdx
callq 0xc8e0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_add_all
int xlink_list_add_all(xlink_list *list, const void *elements, int length) {
  xlink_list_expand_capacity(list, list->length + length);
  memcpy(&list->data[list->length*list->size], elements, length*list->size);
  list->length += length;
  return list->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
addl -0x14(%rbp), %esi
callq 0xc6e0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
imulq 0x8(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movq -0x8(%rbp), %rax
imulq 0x8(%rax), %rdx
callq 0x2100
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/util.c
// Function: xlink_list_insert
void xlink_list_insert(xlink_list *list, int index, const void *element) {
  XLINK_ERROR(index < 0 || index > list->length,
   ("Cannot insert element at position %i, length = %i", index, list->length));
  xlink_list_expand_capacity(list, list->length + 1);
  list->length++;
  if (list->length - 1 > index) {
    memmove(xlink_list_get(list, index + 1), xlink_list_get(list, index),
     list->size*(list->length - 1 - index));
  }
  xlink_list_set(list, index, element);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0xcac5
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0xcae7
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x3960(%rip), %rdi      # 0x10436
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xcae9
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
addl $0x1, %esi
callq 0xc6e0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
cmpl -0xc(%rbp), %eax
jle 0xcb5e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0xc870
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc870
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
subl -0xc(%rbp), %eax
cltq
imulq %rax, %rdx
callq 0x2170
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0xc8e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)