LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: create_table_in_array
static toml_table_t *create_table_in_array(context_t *ctx,
                                           toml_array_t *parent) {
  int n = parent->nitem;
  toml_arritem_t *base = expand_arritem(parent->item, n);
  if (!base) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  toml_table_t *ret = (toml_table_t *)CALLOC(1, sizeof(toml_table_t));
  if (!ret) {
    e_outofmemory(ctx, FLINE);
    return 0;
  }
  base[n].tab = ret;
  parent->item = base;
  parent->nitem++;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x6c50
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6bcf
movq -0x10(%rbp), %rdi
leaq 0x18a2(%rip), %rsi      # 0x8462
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6c3b
movl $0x1, %edi
movl $0x38, %esi
callq 0x28b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6c03
movq -0x10(%rbp), %rdi
leaq 0x1879(%rip), %rsi      # 0x846d
callq 0x2910
movq $0x0, -0x8(%rbp)
jmp 0x6c3b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: expand_arritem
static toml_arritem_t *expand_arritem(toml_arritem_t *p, int n) {
  toml_arritem_t *pp = expand(p, n * sizeof(*p), (n + 1) * sizeof(*p));
  if (!pp)
    return 0;

  memset(&pp[n], 0, sizeof(pp[n]));
  return pp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
movl %eax, %esi
movl -0x14(%rbp), %eax
addl $0x1, %eax
cltq
shlq $0x5, %rax
movl %eax, %edx
callq 0x3750
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6c95
movq $0x0, -0x8(%rbp)
jmp 0x6cb8
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x1100
movq -0x20(%rbp), %rax
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/cktan[P]tomlc99/toml.c
// Function: STRDUP
static char *STRDUP(const char *s) {
  int len = strlen(s);
  char *p = MALLOC(len + 1);
  if (p) {
    memcpy(p, s, len);
    p[len] = 0;
  }
  return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movl %eax, -0xc(%rbp)
movq 0x3f81(%rip), %rax      # 0xb100
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x71b2
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1170
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: xfree_kval
static void xfree_kval(toml_keyval_t *p) {
  if (!p)
    return;
  xfree(p->key);
  xfree(p->val);
  xfree(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x71d5
jmp 0x71f7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rdi
callq 0x3500
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: xfree_arr
static void xfree_arr(toml_array_t *p) {
  if (!p)
    return;

  xfree(p->key);
  const int n = p->nitem;
  for (int i = 0; i < n; i++) {
    toml_arritem_t *a = &p->item[i];
    if (a->val)
      xfree(a->val);
    else if (a->arr)
      xfree_arr(a->arr);
    else if (a->tab)
      xfree_tab(a->tab);
  }
  xfree(p->item);
  xfree(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7218
jmp 0x72c7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x72b1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x726e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3500
jmp 0x72a4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7288
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7200
jmp 0x72a2
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x72a0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x37c0
jmp 0x72a2
jmp 0x72a4
jmp 0x72a6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7235
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3500
movq -0x8(%rbp), %rdi
callq 0x3500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: set_token
static void set_token(context_t *ctx, tokentype_t tok, int lineno, char *ptr,
                      int len) {
  token_t t;
  t.tok = tok;
  t.lineno = lineno;
  t.ptr = ptr;
  t.len = len;
  t.eof = 0;
  ctx->tok = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml.c
// Function: scan_digits
static int scan_digits(const char *p, int n) {
  int ret = 0;
  for (; n > 0 && isdigit(*p); n--, p++) {
    ret = 10 * ret + (*p - '0');
  }
  return n ? -1 : ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jle 0x7ad5
callq 0x11d0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7ade
jmp 0x7b08
imull $0xa, -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x7aa6
cmpl $0x0, -0xc(%rbp)
je 0x7b18
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x7b1e
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (int8_t)(rand() % 32);
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (int8_t)(rand() % 32);
  }

  for (int i = 0; i < 32; i++) {
       op4_int16[i] = 1;
  }
}

// Assembly:
subq $0x18, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1050
movl $0x0, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jge 0x11f9
movl $0x0, 0x10(%rsp)
cmpl $0x1000, 0x10(%rsp)     # imm = 0x1000
jge 0x11ea
callq 0x1070
movl $0x20, %ecx
cltd
idivl %ecx
movslq 0x14(%rsp), %rcx
leaq 0x2e92(%rip), %rax      # 0x4060
shlq $0xc, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11ab
jmp 0x11ec
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x119c
movl $0x0, 0xc(%rsp)
cmpl $0x1000, 0xc(%rsp)      # imm = 0x1000
jge 0x1234
callq 0x1070
movl $0x20, %ecx
cltd
idivl %ecx
movslq 0xc(%rsp), %rcx
leaq 0x42e3c(%rip), %rax     # 0x44060
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1201
movl $0x0, 0x8(%rsp)
cmpl $0x20, 0x8(%rsp)
jge 0x1262
movslq 0x8(%rsp), %rcx
leaq 0x43e11(%rip), %rax     # 0x45060
movw $0x1, (%rax,%rcx,2)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x123c
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    int sum = 0;
    int8_t *vec = mat[j];

    for(int i = 0; i < col; i += 4) {
      int16_t hw_0 = (int16_t)(vec[i] * mutiplier[i] + vec[i + 1] * mutiplier[i + 1]);
      int16_t hw_1 = (int16_t)(vec[i + 2] * mutiplier[i + 2] + vec[i + 3] * mutiplier[i + 3]);
      sum += (int)hw_0 + (int)hw_1;
    }
    result[j] = sum;
  }
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x13b0
movl $0x0, -0x8(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x2dc9(%rip), %rax      # 0x4060
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x1000, -0x14(%rsp)    # imm = 0x1000
jge 0x138d
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movslq -0x14(%rsp), %rdx
leaq 0x42d8d(%rip), %rcx     # 0x44060
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rsi
leaq 0x42d62(%rip), %rdx     # 0x44060
movsbl (%rdx,%rsi), %edx
imull %edx, %ecx
addl %ecx, %eax
movw %ax, -0x16(%rsp)
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl -0x14(%rsp), %ecx
addl $0x2, %ecx
movslq %ecx, %rdx
leaq 0x42d30(%rip), %rcx     # 0x44060
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x3, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movl -0x14(%rsp), %edx
addl $0x3, %edx
movslq %edx, %rsi
leaq 0x42d05(%rip), %rdx     # 0x44060
movsbl (%rdx,%rsi), %edx
imull %edx, %ecx
addl %ecx, %eax
movw %ax, -0x18(%rsp)
movswl -0x16(%rsp), %eax
movswl -0x18(%rsp), %ecx
addl %ecx, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x14(%rsp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rsp)
jmp 0x12ab
movl -0x8(%rsp), %edx
movslq -0x4(%rsp), %rcx
leaq 0x43d03(%rip), %rax     # 0x450a0
movl %edx, (%rax,%rcx,4)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1278
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_int8.c
// Function: calc_avx512_vnni
void calc_avx512_vnni(void) {
  #define VLEN (512/8/sizeof(int))
  const int col_aligned = col - col % VLEN;

  __m512i op0, op1;
  volatile __m512i tgt;

  for (int i = 0; i < row; i++) {
    int sum = 0;

    tgt = _mm512_setzero_si512();
    for (int j = 0; j < col_aligned; j += 64) {
      op0 = _mm512_load_si512(&mutiplier[j]);
      op1 = _mm512_load_si512(&mat[i][j]);
      tgt = _mm512_dpbusds_epi32(tgt, op0, op1);
    }
    int *presult = (int *)&tgt;
    for (int k = 0; k < VLEN; k++)
      sum += presult[k];

    for (int l = col_aligned; l < col; l++)
      sum += (int)(mat[i][l] * mutiplier[l]);

    result[i] = sum;
  }
  #undef VLEN
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x280, %rsp            # imm = 0x280
movl $0x1000, 0x12c(%rsp) # imm = 0x1000
movl $0x0, 0x3c(%rsp)
cmpl $0x40, 0x3c(%rsp)
jge 0x186b
movl $0x0, 0x38(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovdqa64 %zmm0, 0x140(%rsp)
vmovdqa64 0x140(%rsp), %zmm0
vmovdqa64 %zmm0, 0x40(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x1000, 0x34(%rsp)     # imm = 0x1000
jge 0x17b3
movslq 0x34(%rsp), %rcx
leaq 0x4296d(%rip), %rax     # 0x44060
addq %rcx, %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rax
vmovdqa64 (%rax), %zmm0
vmovdqa64 %zmm0, 0xc0(%rsp)
movslq 0x3c(%rsp), %rcx
leaq 0x2940(%rip), %rax      # 0x4060
shlq $0xc, %rcx
addq %rcx, %rax
movslq 0x34(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
vmovdqa64 (%rax), %zmm0
vmovdqa64 %zmm0, 0x80(%rsp)
vmovdqa64 0x40(%rsp), %zmm2
vmovdqa64 0xc0(%rsp), %zmm1
vmovdqa64 0x80(%rsp), %zmm0
vmovdqa64 %zmm2, 0x200(%rsp)
vmovdqa64 %zmm1, 0x1c0(%rsp)
vmovdqa64 %zmm0, 0x180(%rsp)
vmovdqa64 0x200(%rsp), %zmm0
vmovdqa64 0x1c0(%rsp), %zmm1
vmovdqa64 0x180(%rsp), %zmm2
vpdpbusds %zmm2, %zmm1, %zmm0
vmovdqa64 %zmm0, 0x40(%rsp)
movl 0x34(%rsp), %eax
addl $0x40, %eax
movl %eax, 0x34(%rsp)
jmp 0x16d9
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movslq 0x24(%rsp), %rax
cmpq $0x10, %rax
jae 0x17f2
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x17c5
movl $0x1000, 0x20(%rsp)     # imm = 0x1000
cmpl $0x1000, 0x20(%rsp)     # imm = 0x1000
jge 0x1848
movslq 0x3c(%rsp), %rcx
leaq 0x2850(%rip), %rax      # 0x4060
shlq $0xc, %rcx
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movslq 0x20(%rsp), %rdx
leaq 0x42834(%rip), %rcx     # 0x44060
movsbl (%rcx,%rdx), %ecx
imull %ecx, %eax
addl 0x38(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x17fa
movl 0x38(%rsp), %edx
movslq 0x3c(%rsp), %rcx
leaq 0x43848(%rip), %rax     # 0x450a0
movl %edx, (%rax,%rcx,4)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x16a2
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/include/ua_server.h
// Function: UA_Server_addVariableNode
static UA_INLINE UA_StatusCode
UA_Server_addVariableNode(UA_Server *server, const UA_NodeId requestedNewNodeId,
                          const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                          const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
                          const UA_VariableAttributes attr,
                          UA_InstantiationCallback *instantiationCallback,
                          UA_NodeId *outNewNodeId) {
    return __UA_Server_addNode(server, UA_NODECLASS_VARIABLE, requestedNewNodeId, parentNodeId,
                               referenceTypeId, browseName, typeDefinition,
                               (const UA_NodeAttributes*)&attr,
                               &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],
                               instantiationCallback, outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rcx
leaq 0x88(%rbp), %rdx
leaq 0x70(%rbp), %rax
leaq 0x58(%rbp), %r10
leaq 0x40(%rbp), %r11
leaq 0x28(%rbp), %rbx
leaq 0x10(%rbp), %r14
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x2, %esi
movq 0x282e(%rip), %rcx      # 0x3fd0
addq $0x528, %rcx            # imm = 0x528
movq (%r14), %r15
movq %r15, (%rsp)
movq 0x8(%r14), %r15
movq %r15, 0x8(%rsp)
movq 0x10(%r14), %r14
movq %r14, 0x10(%rsp)
movq (%rbx), %r14
movq %r14, 0x18(%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x20(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x28(%rsp)
movq (%r11), %rbx
movq %rbx, 0x30(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x38(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x40(%rsp)
movq (%r10), %r11
movq %r11, 0x48(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x50(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x58(%rsp)
movq (%rax), %r10
movq %r10, 0x60(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x10c0
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshutils.c
// Function: depthHistogram
void depthHistogram (Moshset *ms, FILE *f)
{
  Array h = arrayCreate (256, U32) ;
  U32 i ;
  for (i = 1 ; i <= ms->max ; ++i)
    if (ms->depth[i] < arrayMax(h)) ++arr(h,ms->depth[i],U32) ; /* more efficient to check */
    else ++array(h,ms->depth[i],U32) ;
  for (i = 0 ; i < arrayMax(h) ; ++i)
    if (arr(h,i,U32)) fprintf (f, "DP\t%u\t%u\n", i, arr(h,i,U32)) ;
  arrayDestroy (h) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x100, %edi            # imm = 0x100
movl $0x4, %esi
callq 0x72a0
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
ja 0x13f7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x1c(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x13cb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl -0x1c(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
movq -0x18(%rbp), %rdx
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx)
jmp 0x13ea
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x1c(%rbp), %ecx
movzwl (%rax,%rcx,2), %esi
callq 0x7700
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x13ec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x137a
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x145f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
cmpl $0x0, (%rax,%rcx)
je 0x1452
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rsi
imull 0x14(%rsi), %ecx
movl %ecx, %ecx
movl (%rax,%rcx), %ecx
leaq 0x7bb9(%rip), %rsi      # 0x9004
movb $0x0, %al
callq 0x1120
jmp 0x1454
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13fe
movq -0x18(%rbp), %rdi
callq 0x74a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshutils.c
// Function: reportDepths
void reportDepths (Moshset *ms, Array ma, FILE *f)
{
  U32 i, j, index ;
  for (i = 1 ; i <= ms->max ; ++i)
    { fprintf (f, "MH\t%llx\t%d\t%u", ms->value[i], msCopy(ms,i), ms->depth[i]) ;
      for (j = 0 ; j < arrayMax(ma) ; ++j)
	if ((index = moshsetIndexFind (arr(ma,j,Moshset*), ms->value[i], FALSE)))
	  fprintf (f, "\t%u", arr(ma,j,Moshset*)->depth[index]) ;
	else
	  fprintf (f, "\t0") ;
      fputc ('\n', f) ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
ja 0x15ae
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15c0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x1c(%rbp), %esi
movzwl (%rax,%rsi,2), %r8d
leaq 0x7b2b(%rip), %rsi      # 0x900e
movb $0x0, %al
callq 0x1120
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x1592
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
movq (%rax,%rcx), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x53d0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x1570
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
movq (%rax,%rcx), %rax
movq 0x30(%rax), %rax
movl -0x24(%rbp), %ecx
movzwl (%rax,%rcx,2), %edx
leaq 0x7ab1(%rip), %rsi      # 0x9018
movb $0x0, %al
callq 0x1120
jmp 0x1582
movq -0x18(%rbp), %rdi
leaq 0x7aa1(%rip), %rsi      # 0x901c
movb $0x0, %al
callq 0x1120
jmp 0x1584
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x14f1
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x10e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x148b
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshutils.c
// Function: addSequenceFile
static BOOL addSequenceFile (Moshset *ms, char *filename, BOOL is10x)
{
  char *seq ;			/* ignore the name for now */
  int len ;
  U64 nSeq = 0, totLen = 0, totHash = 0 ;

  dna2indexConv['N'] = dna2indexConv['n'] = 0 ; /* to get 2-bit encoding */
  SeqIO *si = seqIOopen (filename, dna2indexConv, FALSE) ; /* false for no qualities */
  if (!si) return FALSE ;
  while (seqIOread (si))
    { ++nSeq ; totLen += si->seqLen ;
      if (is10x && (nSeq & 0x1)) totHash += addSequence (ms, sqioSeq(si)+23, si->seqLen-23) ;
      else totHash += addSequence (ms, sqioSeq(si), si->seqLen) ;
    }
  seqIOclose (si) ;
  fprintf (outFile, "added %llu sequences total length %llu total hashes %llu, new max %u\n",
	   nSeq, totLen, totHash, ms->max) ;
  return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
leaq 0xaefc(%rip), %rax      # 0xd740
movl $0x0, 0x1b8(%rax)
leaq 0xaeeb(%rip), %rax      # 0xd740
movl $0x0, 0x138(%rax)
movq -0x18(%rbp), %rdi
leaq 0xaed6(%rip), %rsi      # 0xd740
xorl %edx, %edx
callq 0x2a70
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x2885
movb $0x0, -0x1(%rbp)
jmp 0x29b7
jmp 0x2887
movq -0x50(%rbp), %rdi
callq 0x2d80
cmpb $0x0, %al
je 0x2981
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x50(%rbp), %rax
movslq 0x18(%rax), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x2928
movq -0x38(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x2928
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x28ea
movq -0x50(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x2901
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x50(%rbp), %rcx
movslq 0x24(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x17, %rsi
movq -0x50(%rbp), %rax
movl 0x18(%rax), %edx
subl $0x17, %edx
callq 0x29c0
cltq
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x297c
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x2947
movq -0x50(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x70(%rbp)
jmp 0x295e
movq -0x50(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x50(%rbp), %rcx
movslq 0x24(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x50(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x29c0
cltq
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x2887
movq -0x50(%rbp), %rdi
callq 0x2d10
movq 0xb9c7(%rip), %rdi      # 0xe358
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %r8
movq -0x10(%rbp), %rax
movl 0x40(%rax), %r9d
leaq 0x6e88(%rip), %rsi      # 0x9834
movb $0x0, %al
callq 0x1120
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshutils.c
// Function: addSequence
static int addSequence (Moshset *ms, char *s, int len) /* return number of hashes */
{
  int nHash = 0 ;
  SeqhashRCiterator *mi = moshRCiterator (ms->hasher, s, len) ;
  U64 hash ; int pos ;
  while (moshRCnext (mi, &hash, &pos, 0))
    { U32 index = moshsetIndexFind (ms, hash, TRUE) ;
      U16 *di = &ms->depth[index] ; ++*di ; if (!*di) *di = U16MAX ;
      ++nHash ;
    }
  return nHash ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x4c70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4e90
cmpb $0x0, %al
je 0x2a60
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x53d0
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x30(%rbp), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movq -0x38(%rbp), %rax
cmpw $0x0, (%rax)
jne 0x2a55
movq -0x38(%rbp), %rax
movw $0xffff, (%rax)         # imm = 0xFFFF
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x29f1
movl -0x18(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: seqIOclose
void seqIOclose (SeqIO *si)
{ free (si->buf) ;
  if (si->seqBuf) free (si->seqBuf) ; if (si->qualBuf) free (si->qualBuf) ;
  gzclose (si->f) ;
  free (si) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x2d41
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x2d59
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: bufRefill
static int bufRefill (SeqIO *si)
{ si->b -= si->recStart ;		/* will be position after move */
  memmove (si->buf, si->buf + si->recStart, si->b - si->buf) ;
  si->idStart -= si->recStart ; si->descStart -= si->recStart ; /* adjust all the offsets */
  si->seqStart -= si->recStart ; si->qualStart -= si->recStart ;
  si->recStart = 0 ;
  si->nb = gzread (si->f, si->b, si->buf + si->bufSize - si->b) ;
  return si->nb ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x40(%rax), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
subq %rax, %rdx
callq 0x11a0
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x34(%rcx), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x58(%rcx), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x1110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: bufExtend
static int bufExtend (SeqIO *si)
{
  char *newbuf = new (si->bufSize*2, char) ;
  memcpy (newbuf, si->buf, si->bufSize) ;
  free (si->buf) ; si->buf = newbuf ;
  si->b = si->buf + si->bufSize ; si->nb = si->bufSize ;
  si->nb = gzread (si->f, si->b, si->bufSize) ;
  si->bufSize *= 2 ;
  return si->nb ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
shll %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x8260
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x34(%rax), %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movslq 0x34(%rax), %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
callq 0x1110
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
shll %ecx
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: sqioSeqUnpack
void sqioSeqUnpack (U8 *u, char *s, int len) /* uncompress (len+3)/4 u into s */
{
  int i ;
  while (len > 4)
    { for (i = 4 ; i-- ; ) { s[i] = (*u & 0x3) ; *u >>= 2 ; }
      len -= 4 ; ++u ; s += 4 ;
    }
  if (len) for (i = len ; --i ; ) { s[i] = (*u & 0x3) ; *u >>= 2 ; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jle 0x4054
movl $0x4, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x4031
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
sarl $0x2, %ecx
movb %cl, (%rax)
jmp 0x3ffc
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x3fef
cmpl $0x0, -0x14(%rbp)
je 0x4095
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
je 0x4093
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x3, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
sarl $0x2, %ecx
movb %cl, (%rax)
jmp 0x4060
jmp 0x4095
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: sqioQualUnpack
void sqioQualUnpack (U8 *u, char *q, int len, int thresh) /* uncompress (len+7)/8 u into q */
{
  int i ;
  while (len > 8)
    { for (i = 8 ; i-- ; ) { q[i] = (*u & 0x1) ? thresh : 0 ; *u >>= 1 ; }
      len -= 8 ; ++u ; q += 8 ;
    }
  if (len) for (i = len ; --i ; ) { q[i] = (*u & 0x1) ? thresh : 0 ; *u >>= 1 ; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x8, -0x14(%rbp)
jle 0x412d
movl $0x8, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x410a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x40e6
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x40ed
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x40ed
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
sarl %ecx
movb %cl, (%rax)
jmp 0x40bf
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x40b2
cmpl $0x0, -0x14(%rbp)
je 0x4184
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x4182
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x415e
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x4165
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x4165
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
sarl %ecx
movb %cl, (%rax)
jmp 0x4139
jmp 0x4184
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: sqioSeqPack
void sqioSeqPack (char *s, U8 *u, int len) /* compress s into (len+3)/4 u  */
{
  int i ;
  while (len > 4)
    { *u = 0 ; for (i = 0 ; i < 4 ; ++i) *u = (*u << 2) | dna2indexConv[*s++] ;
      len -= 4 ; ++u ;
    }
  if (len) { *u = 0 ; for (i = 0 ; i < len ; ++i) *u = (*u << 2) | dna2indexConv[*s++] ; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jle 0x420a
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x41f3
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rcx), %rdx
leaq 0x9563(%rip), %rcx      # 0xd740
orl (%rcx,%rdx,4), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x41b3
movl -0x14(%rbp), %eax
subl $0x4, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x419f
cmpl $0x0, -0x14(%rbp)
je 0x4262
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4260
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x2, %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbq (%rcx), %rdx
leaq 0x94f6(%rip), %rcx      # 0xd740
orl (%rcx,%rdx,4), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x421e
jmp 0x4262
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqio.c
// Function: sqioQualPack
void sqioQualPack (char *q, U8 *u, int len, int thresh) /* compress q into (len+7)/8 u  */
{
  int i ;
  while (len > 8)
    { *u = 0 ; for (i = 0 ; i < 8 ; ++i) { if (*q++ >= thresh) *u |= 1 ; *u <<= 1 ; }
      len -= 8 ; ++u ;
    }
  if (len) { *u = 0 ; for (i = 0 ; i < len ; ++i) { if (*q++ >= thresh) *u |= 1 ; *u <<= 1 ; } }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpl $0x8, -0x14(%rbp)
jle 0x42ec
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x42d5
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jl 0x42bf
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
shll %ecx
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4296
movl -0x14(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4282
cmpl $0x0, -0x14(%rbp)
je 0x4343
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4341
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %eax
cmpl -0x18(%rbp), %eax
jl 0x432b
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
orl $0x1, %ecx
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movzbl (%rax), %ecx
shll %ecx
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4300
jmp 0x4343
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqhash.c
// Function: seqhashCreate
Seqhash *seqhashCreate (int k, int w)
{
  assert (sizeof (U64) == 8) ;
  Seqhash *sh = new0 (1, Seqhash) ;
  sh->k = k ; if (k < 1 || k >= 32) die ("seqhash k %d must be between 1 and 32\n", k) ;
  sh->w = w ; if (w < 1) die ("seqhash w %d must be positive\n", w) ;
  sh->mask = ((U64)1 << (2*k)) - 1 ;
  int i ;
  
  sh->factor1 = (random() << 32) | random() | 0x01 ;
  sh->shift1 = 64 - 2*k ;
  sh->factor2 = (random() << 32) | random() | 0x01 ;
  sh->shift2 = 2*k ;
  for (i = 0 ; i < 4 ; ++i) { sh->patternRC[i] = (3-i) ; sh->patternRC[i] <<= 2*(k-1) ; }
  return sh ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x82b0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x1, -0x4(%rbp)
jl 0x4386
cmpl $0x20, -0x4(%rbp)
jl 0x4397
movl -0x4(%rbp), %esi
leaq 0x55f5(%rip), %rdi      # 0x9985
movb $0x0, %al
callq 0x8180
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
cmpl $0x1, -0x8(%rbp)
jge 0x43b8
movl -0x8(%rbp), %esi
leaq 0x55fb(%rip), %rdi      # 0x99ac
movb $0x0, %al
callq 0x8180
movl -0x4(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
subq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x1160
shlq $0x20, %rax
movq %rax, -0x28(%rbp)
callq 0x1160
movq -0x28(%rbp), %rcx
orq %rax, %rcx
orq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x4(%rbp), %eax
shll %eax
movl $0x40, %ecx
subl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
callq 0x1160
shlq $0x20, %rax
movq %rax, -0x20(%rbp)
callq 0x1160
movq -0x20(%rbp), %rcx
orq %rax, %rcx
orq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x4(%rbp), %ecx
shll %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x4498
movl $0x3, %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
shll %ecx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq 0x28(%rax,%rdx,8), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq -0x30(%rbp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4448
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqhash.c
// Function: seqhashRead
Seqhash *seqhashRead (FILE *f)
{ Seqhash *sh = new (1, Seqhash) ;
  char name[8] ;
  if (fread (name,8,1,f) != 1) die ("failed to read seqhash header") ;
  if (strcmp (name, "SQHSHv1")) die ("seqhash read mismatch") ;
  if (fread (sh,sizeof(Seqhash),1,f) != 1) die ("failed to read seqhash") ;
  return sh ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
callq 0x8260
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x4565
leaq 0x54ac(%rip), %rdi      # 0x9a0a
movb $0x0, %al
callq 0x8180
leaq -0x18(%rbp), %rdi
leaq 0x545b(%rip), %rsi      # 0x99cb
callq 0x1100
cmpl $0x0, %eax
je 0x4588
leaq 0x54a7(%rip), %rdi      # 0x9a28
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x48, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x45b3
leaq 0x5492(%rip), %rdi      # 0x9a3e
movb $0x0, %al
callq 0x8180
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqhash.c
// Function: hashRC
static inline U64 hashRC (SeqhashRCiterator *mi, BOOL *isForward)
{ U64 hashF = hashFunc (mi->h, mi->sh) ;
  U64 hashR = hashFunc (mi->hRC, mi->sh) ;
#ifdef DEBUG
  printf ("hashRC: h %lx hRC %lx hashF %lx hashR %lx\n", mi->h, mi->hRC, hashF, hashR) ;
#endif
  if (hashF < hashR) { *isForward = TRUE ; return hashF ; }
  else { *isForward = FALSE ; return hashR ; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5000
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x5000
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x487b
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x488a
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqhash.c
// Function: advanceHashRC
static inline U64 advanceHashRC (SeqhashRCiterator *mi, BOOL *isForward)
{ Seqhash *sh = mi->sh ;
  if (mi->s < mi->sEnd)
    { mi->h = ((mi->h << 2) & sh->mask) | *(mi->s) ;
      mi->hRC = (mi->hRC >> 2) | sh->patternRC[*(mi->s)] ;
      return hashRC (mi, isForward) ;
    }
  else
    return U64MAX ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x4934
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
shlq $0x2, %rcx
movq -0x20(%rbp), %rax
andq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbq (%rax), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x2, %rcx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
movsbq (%rdx), %rdx
orq 0x28(%rax,%rdx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4820
movq %rax, -0x8(%rbp)
jmp 0x493c
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/seqhash.c
// Function: moshRCnext
BOOL moshRCnext (SeqhashRCiterator *mi, U64 *u, int *pos, BOOL *isF) /* returns (u, pos, isF) */
{
  if (mi->isDone) return FALSE ; /* we are done */

  *u = *mi->hashBuf ; *pos = mi->iMin ; if (isF) *isF = *mi->fBuf ;

  if (mi->s >= mi->sEnd) { mi->isDone = TRUE ; return TRUE ; }
    
  U64 hash = advanceHashRC (mi, mi->fBuf) ; ++mi->iMin ; ++mi->s ;
  int w = mi->sh->w ;
  while ((hash % w) && mi->s < mi->sEnd)
    { hash = advanceHashRC (mi, mi->fBuf) ; ++mi->iMin ; ++mi->s ; }
  if (!(hash % w)) *mi->hashBuf = hash ;
  else mi->isDone = TRUE ;

  return TRUE ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x44(%rax)
je 0x4ebb
movb $0x0, -0x1(%rbp)
jmp 0x4fee
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4ef1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4f14
movq -0x10(%rbp), %rax
movb $0x1, 0x44(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4fee
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x48a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorl %edx, %edx
divq %rcx
xorl %eax, %eax
cmpq $0x0, %rdx
movb %al, -0x35(%rbp)
je 0x4f81
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x4f8a
jmp 0x4fbe
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x48a0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4f53
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x4fe2
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
jmp 0x4fea
movq -0x10(%rbp), %rax
movb $0x1, 0x44(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/moshset.c
// Function: moshsetCreate
Moshset *moshsetCreate (Seqhash *sh, int bits, U32 size)
{
  if (bits < 20 || bits > 34) die ("table bits %d must be between 20 and 34", bits) ;
  Moshset *ms = new0 (1, Moshset) ;
  ms->hasher = sh ;
  ms->tableBits = bits ;
  ms->tableSize = (U64)1 << ms->tableBits ;
  ms->tableMask = ms->tableSize - 1 ;
  ms->index = new0 (ms->tableSize, U32) ;
  if (size >= (ms->tableSize >> 2)) die ("Moshset size %u is too big for %d bits", size, bits) ;
  else if (size) ms->size = size ;
  else ms->size = (ms->tableSize >> 2) - 1 ;
  ms->value = new (ms->size, U64) ;
  ms->depth = new0 (ms->size, U16) ;
  ms->info = new0 (ms->size, U8) ;
  return ms ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x14, -0xc(%rbp)
jl 0x504e
cmpl $0x22, -0xc(%rbp)
jle 0x505f
movl -0xc(%rbp), %esi
leaq 0x4b08(%rip), %rdi      # 0x9b60
movb $0x0, %al
callq 0x8180
movl $0x1, %edi
movl $0x48, %esi
callq 0x82b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x4, %esi
callq 0x82b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jb 0x50fe
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x4a93(%rip), %rdi      # 0x9b88
movb $0x0, %al
callq 0x8180
jmp 0x512b
cmpl $0x0, -0x10(%rbp)
je 0x5110
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x5129
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
shrq $0x2, %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x512b
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x8260
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
movl $0x2, %esi
callq 0x82b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x82b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop