LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/db.c
// Function: JFDB_get_value
JFT_Stem *JFDB_get_value(JFDB *db, JFT *node, JFT_Stem *value) {
  JFT_Leaf leaf = JFT_leaf(node);
  if (leaf.size == 0)
    return NULL;
  JFDB_Region region = *(JFDB_Region *)leaf.data;
  value->size = region.size;
  value->data = db->vmap.map + JFDB_voffset(region);
  return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4220
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0x41c4
movq $0x0, -0x8(%rbp)
jmp 0x420c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x34(%rbp), %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3ad0
movq -0x40(%rbp), %rcx
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_leaf
static inline JFT_Leaf JFT_leaf(const JFT *trie) {
  JFT_TypeInfo size = JFT_type_info(trie);
  const uint8_t *data = JFT_type_data(trie);
  if (size == 0xFF) {
    size = *(JFT_Count *)data;
    data += sizeof(JFT_Count);
  }
  return (JFT_Leaf) {
    .size = size,
    .data = (JFT_Word *)data
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b50
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4b70
movq %rax, -0x28(%rbp)
cmpl $0xff, -0x1c(%rbp)
jne 0x4263
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/db.c
// Function: JFDB_find
JFT_Cursor *JFDB_find(JFDB *db, JFT_Cursor *cursor, const JFT_Stem *key) {
  JFT *trie;
  for (JFT_Offset pos = db->tip.cp.offset; pos; pos = JFT_parent_offset(trie)) {
    trie = JFDB_get_trie(db, pos);
    JFT_cursor_init(cursor, In, trie);
    if (JFT_cursor_find(cursor, key) != JFT_SYMBOL_NIL)
      return cursor;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x42fb
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3480
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x1, %esi
callq 0x4bd0
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x50a0
cmpq $-0x2, %rax
je 0x42ea
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4303
jmp 0x42ec
movq -0x28(%rbp), %rdi
callq 0x34f0
movq %rax, -0x30(%rbp)
jmp 0x42a3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/db.c
// Function: JFDB_fold
JFT_Status JFDB_fold(JFDB *db,
                     JFT_Stem *stem,
                     JFT_Symbol *stop,
                     JFDB_FoldFun fun,
                     void *restrict acc,
                     int flags) {
  // fold all active tries in the DB simultaneously, in order
  // as usual, stem serves as both input and output
  JFT_Amount N = db->tip.level, i = 0;
  JFT_Cursor cursors[N];
  JFT *trie;
  for (JFT_Offset pos = db->tip.cp.offset; pos; pos = JFT_parent_offset(trie)) {
    // we want all the cursors to be at the same position, so only add them if they have the prefix
    trie = JFDB_get_trie(db, pos);
    cursors[i] = JFT_cursor(trie);
    if (JFT_cursor_find(&cursors[i], stem) < JFT_SYMBOL_NIL)
      i++;
  }
  JFDB_Slice slice = (JFDB_Slice) {
    .db = db,
    .stem = stem,
    .stop = stop,
    .zero = stem->size,
    .fun = fun,
    .acc = acc
  };
  if (i)
    return JFT_cursor_merge(cursors, i, &splice_fold, &slice, flags);
  return Ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x10(%rbp), %rax
movzbl 0xc8(%rax), %eax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x50(%rbp)
imulq $0x38, %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0xe0(%rbp)
movq %rcx, %rsp
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x441f
movq -0x10(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3480
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq %rcx, -0x60(%rbp)
imulq $0x38, -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0x60(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x34a0
movq -0xe8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x38, %edx
callq 0x1140
movq -0xe0(%rbp), %rdi
imulq $0x38, -0x48(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x50a0
cmpq $-0x2, %rax
jae 0x440b
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x440d
movq -0x60(%rbp), %rdi
callq 0x34f0
movq %rax, -0x68(%rbp)
jmp 0x4384
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movw 0x8(%rax), %ax
movw %ax, -0xb8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x449d
movq -0xe0(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x34(%rbp), %r8d
leaq 0x3e(%rip), %rdx        # 0x44c0
leaq -0xd0(%rbp), %rcx
callq 0x5270
movl %eax, -0x4(%rbp)
movl $0x1, -0xd4(%rbp)
jmp 0x44ae
movl $0x0, -0x4(%rbp)
movl $0x1, -0xd4(%rbp)
movq -0x50(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/db.c
// Function: splice_fold
static JFT_Status splice_fold(JFT_Cursor *cursors, JFT_MergeContext *ctx, JFT_Phase phase) {
  JFT_MergeFrame *frame = ctx->frame;
  JFDB_Slice *slice = (JFDB_Slice *)ctx->acc;
  JFT_Cursor *cursor = cursors + ffsll(frame->active) - 1;
  JFT_KeySize depth = frame - ctx->stack;

  if (phase == Out)
    return Ok;

  if ((slice->stem->size = slice->zero + depth))
    JFT_set_symbol_at_point(slice->stem, slice->stem->size - 1, cursor->symbol);

  if (JFT_cursor_at_terminal(cursor)) {
    return slice->fun(cursor, slice, True);
  } else if (slice->stop && cursor->symbol == *slice->stop && depth) {
    return slice->fun(cursor, slice, False);
  }
  return Step;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
tzcntq %rsi, %rcx
addq $0x1, %rcx
xorl %edx, %edx
cmpq $0x0, %rsi
cmoveq %rdx, %rcx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
addq $-0x38, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
sarq $0x5, %rax
movw %ax, -0x3a(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x4544
movl $0x0, -0x4(%rbp)
jmp 0x4600
movq -0x30(%rbp), %rax
movzwl 0x18(%rax), %eax
movzwl -0x3a(%rbp), %ecx
addl %ecx, %eax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rcx
movw %ax, 0x8(%rcx)
cmpw $0x0, %ax
je 0x458b
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rsi
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x4920
movq -0x38(%rbp), %rdi
callq 0x49c0
cmpl $0x0, %eax
je 0x45b5
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0x1, %edx
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x4600
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x45f7
movq -0x38(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x45f7
movzwl -0x3a(%rbp), %eax
cmpl $0x0, %eax
je 0x45f7
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x4600
jmp 0x45f9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_keys
static inline JFT_Keys JFT_keys(JFT_Cursor *cursor,
                                JFT_Stem *stem,
                                JFT_Direction direction) {
  // stem is both the prefix to match, and where to store the iterated keys
  JFT_cursor_find(cursor, stem);
  return (JFT_Keys) {
    .cursor = cursor,
    .stem = stem,
    .zero = stem->size,
    .direction = direction
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x10(%rbp), %rcx
movw 0x8(%rcx), %cx
movw %cx, 0x10(%rdi)
movl -0x14(%rbp), %ecx
movl %ecx, 0x14(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/db.c
// Function: JFDB_vfree
static void JFDB_vfree(JFDB *db, JFDB_Region region) {
  if (db->freeList.size < JFDB_MAX_FREE - 1)
    JFDB_add_to_free_list(db, region);
  if (db->freeList.size >= JFDB_MAX_FREE)
    db->oughtFlush = True;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0xff, 0x138(%rax)
jae 0x473e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3af0
movq -0x10(%rbp), %rax
cmpq $0x100, 0x138(%rax) # imm = 0x100
jb 0x475d
movq -0x10(%rbp), %rax
movl $0x1, 0x984(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: JFT_cursor_init
JFT_Symbol JFT_cursor_init(JFT_Cursor *cursor, JFT_Phase phase, JFT *node) {
  // initialize the cursor at node, if it exists, and return the symbol
  // we assume non-root branches always have children
  // it is impossible to construct such a node without children
  // we assume non-root nodes cannot have an empty stem
  // although technically it is possible to construct such a node, it would be invalid
  if (node == NULL)
    return cursor->symbol = JFT_SYMBOL_NIL;
  switch (JFT_node_type(node)) {
    case Root:
      cursor->node = node;
      cursor->stem = (JFT_Stem) {0};
      cursor->point = 0;
      cursor->symbol = JFT_SYMBOL_TOP;
      break;
    default:
      cursor->node = node;
      cursor->stem = JFT_stem(node);
      cursor->point = phase == In ? 0 : cursor->stem.size - 1;
      cursor->symbol = JFT_cursor_symbol_at_point(cursor);
      break;
  }
  return cursor->symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4c03
movq -0x10(%rbp), %rax
movq $-0x2, 0x30(%rax)
movq $-0x2, -0x8(%rbp)
jmp 0x4cf2
movq -0x20(%rbp), %rdi
callq 0x4d00
testl %eax, %eax
jne 0x4c6c
jmp 0x4c12
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x10f0
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $-0x3, 0x30(%rax)
jmp 0x4ce6
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x4d20
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpl $0x1, -0x14(%rbp)
jne 0x4cb6
xorl %eax, %eax
movl %eax, -0x64(%rbp)
jmp 0x4cc4
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x4dc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_stem
static inline JFT_Stem JFT_stem(const JFT *trie) {
  if (JFT_is_special(trie))
    return (JFT_Stem) {
      .pre = JFT_BToSp(*(trie + sizeof(JFT_Head))),
      .size = JFT_stem_size(trie),
      .data = (uint8_t *)(trie + sizeof(JFT_Head) + 1)
    };
  return (JFT_Stem) {
    .size = JFT_stem_size(trie),
    .data = (uint8_t *)(trie + sizeof(JFT_Head))
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7350
cmpl $0x0, %eax
je 0x4d7e
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl 0x8(%rcx), %ecx
orq $-0x100, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7370
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x4da9
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7370
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: JFT_cursor_step
JFT_Symbol JFT_cursor_step(JFT_Cursor *cursor, JFT_Direction direction) {
  if (cursor->symbol == JFT_SYMBOL_NIL)
    return cursor->symbol;
  if (++cursor->point >= cursor->stem.size)
    switch (JFT_node_type(cursor->node)) {
      case Leaf:
        return cursor->symbol = JFT_SYMBOL_ANY;
      default:
        return JFT_cursor_init(cursor, In, JFT_child(cursor->node, JFT_SYMBOL_NIL, direction));
    }
  return cursor->symbol = JFT_cursor_symbol_at_point(cursor);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $-0x2, 0x30(%rax)
jne 0x4edb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f6d
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rax
addq $0x1, %rax
movq %rax, 0x28(%rcx)
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
cmpq %rcx, %rax
jl 0x4f58
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4d00
subl $0x3, %eax
jne 0x4f22
jmp 0x4f0c
movq -0x10(%rbp), %rax
movq $-0x1, 0x30(%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x4f6d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %edx
movq $-0x2, %rsi
callq 0x4f80
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0x4bd0
movq %rax, -0x8(%rbp)
jmp 0x4f6d
movq -0x10(%rbp), %rdi
callq 0x4dc0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: JFT_cursor_next
JFT_Symbol JFT_cursor_next(JFT_Cursor *cursor, JFT_Direction direction) {
  if (cursor->symbol == JFT_SYMBOL_ANY)
    return cursor->symbol;
  if (cursor->point == 0)
    return JFT_cursor_init(cursor, In, JFT_child(JFT_parent(cursor->node), cursor->symbol, direction));
  if (cursor->symbol == JFT_SYMBOL_NIL && cursor->point < cursor->stem.size)
    return cursor->symbol = JFT_cursor_symbol_at_point(cursor);
  return cursor->symbol = JFT_SYMBOL_NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x30(%rax)
jne 0x4ffb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5090
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x5045
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4e70
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
movl -0x14(%rbp), %edx
callq 0x4f80
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movl $0x1, %esi
callq 0x4bd0
movq %rax, -0x8(%rbp)
jmp 0x5090
movq -0x10(%rbp), %rax
cmpq $-0x2, 0x30(%rax)
jne 0x507c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
cmpq %rcx, %rax
jge 0x507c
movq -0x10(%rbp), %rdi
callq 0x4dc0
movq -0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
movq %rax, -0x8(%rbp)
jmp 0x5090
movq -0x10(%rbp), %rax
movq $-0x2, 0x30(%rax)
movq $-0x2, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: max_key_size
static JFT_KeySize max_key_size(JFT_Cursor *cursors, JFT_Amount num) {
  JFT_KeySize cur, max = 0;
  for (JFT_Amount i = 0; i < num; i++)
    if ((cur = JFT_root(cursors[i].node)->maxKeySize) > max)
      max = cur;
  return max + 1; // + top
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x55e8
movq -0x8(%rbp), %rax
imulq $0x38, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x79b0
movw 0x2c(%rax), %ax
movw %ax, -0x12(%rbp)
movzwl %ax, %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jle 0x55d8
movw -0x12(%rbp), %ax
movw %ax, -0x14(%rbp)
jmp 0x55da
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x559e
movzwl -0x14(%rbp), %eax
addl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: back_into_frame
static JFT_MergeFrame *back_into_frame(JFT_Cursor *cursors,
                                       JFT_MergeFrame *frame,
                                       JFT_Direction direction) {
  // back out all of the cursors which were active in the frame
  // frame is assumed to be the parent frame
  JFT_Mask active = frame->active;
  for (JFT_Amount b = ffsll(active); b; b = ffsll(active &= active - 1))
    JFT_cursor_back(&cursors[b - 1], direction);
  return frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
cltq
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5829
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
subq $0x1, %rax
imulq $0x38, %rax, %rax
addq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x4df0
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
andq -0x20(%rbp), %rdx
movq %rdx, -0x20(%rbp)
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
cltq
movq %rax, -0x28(%rbp)
jmp 0x57dc
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: JFT_cursor_merge_new
JFT *JFT_cursor_merge_new(JFT_Cursor *cursors,
                          JFT_Amount num,
                          JFT_Buffer *output,
                          int flags) {
  // perform a cursor merge to produce a new trie
  // if 'atoms' are the base case, this is the induction step
  JFT_Cons cons = (JFT_Cons) {.buffer = JFT_buffer_reset(output)};
  JFT_Status result = JFT_cursor_merge(cursors, num, splice_new, &cons, flags);
  free(cons.stem.data);
  free(cons.iters);
  if (cons.TLBs) {
    for (JFT_Amount k = 0; k < num; k++)
      free(cons.TLBs[k]);
    free(cons.TLBs);
  }
  free(cons.TLBSizes);
  if (result != Ok)
    return NULL;
  return (JFT *)output->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x10f0
movq -0x20(%rbp), %rdi
callq 0x5940
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %r8d
leaq 0xd0(%rip), %rdx        # 0x5960
leaq -0x98(%rbp), %rcx
callq 0x5270
movl %eax, -0x9c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1030
movq -0x40(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x38(%rbp)
je 0x5904
movq $0x0, -0xa8(%rbp)
movq -0xa8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x58fb
movq -0x38(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x58c6
movq -0x38(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
cmpl $0x0, -0x9c(%rbp)
je 0x5920
movq $0x0, -0x8(%rbp)
jmp 0x592c
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: make_root
static inline JFT_Offset make_root(JFT_Buffer *buf) {
  // just make space, as a root head initializes to nil (technically an impl detail)
  if (!JFT_buffer_ample(buf, sizeof(JFT_Root)))
    return 0;
  return JFT_buffer_equal(buf, JFT_Root, (JFT_Root) {.head = JFT_head(Root, False, 0, 0, 0)});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x30, %esi
callq 0x80b0
cmpq $0x0, %rax
jne 0x66aa
movq $0x0, -0x8(%rbp)
jmp 0x670a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10f0
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %ecx, %edi
movl %ecx, %esi
movl %ecx, %edx
callq 0x7a00
movq -0x48(%rbp), %rdi
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x1140
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
addq $0x30, %rax
movq %rax, 0x10(%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: make_leaf
static inline JFT_Offset make_leaf(JFT_Buffer *buf,
                                   JFT_Offset parentPos,
                                   const JFT_Stem *stem,
                                   const JFT_Leaf *leaf) {
  // write the node and copy all the leaf data words into the buffer
  JFT_Offset size = prep_leaf(buf, parentPos, stem, leaf->size);
  for (int i = 0; i < leaf->size; i++)
    JFT_buffer_equal(buf, JFT_Word, leaf->data[i]);
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
callq 0x7c00
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x67a4
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x675a
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_buffer_write
static inline JFT_Buffer *JFT_buffer_write(JFT_Buffer *buf, void *ptr, size_t size) {
  if (!JFT_buffer_ample(buf, size))
    return NULL;
  JFT_buffer_paste(buf, ptr, size);
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x80b0
cmpq $0x0, %rax
jne 0x67e1
movq $0x0, -0x8(%rbp)
jmp 0x67fa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7d40
movq -0x10(%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/jflatow[P]jfdb/src/trie.c
// Function: JFT_membuf_ensure
int JFT_membuf_ensure(JFT_Buffer *buf, size_t more) {
  size_t minSize = buf->mark + more;
  if (buf->size < minSize) {
    size_t newSize = buf->factor * minSize;
    uint8_t *data = realloc(buf->data, newSize);
    if (data == NULL)
      return ENoMem;
    buf->size = newSize;
    buf->data = data;
  }
  return Ok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jae 0x72ab
movq -0x10(%rbp), %rax
movslq (%rax), %rax
imulq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x1160
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7293
movl $0x5, -0x4(%rbp)
jmp 0x72b2
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: JFT_membuf
JFT_Buffer *JFT_membuf() {
  JFT_Buffer *buf = calloc(1, sizeof(JFT_Buffer));
  if (buf == NULL)
    return NULL;
  buf->factor = 2;
  buf->ensure = JFT_membuf_ensure;
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x28, %esi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x72ec
movq $0x0, -0x8(%rbp)
jmp 0x730d
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
leaq -0xd1(%rip), %rcx       # 0x7230
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_symbol_at_point
static inline JFT_Symbol JFT_symbol_at_point(const JFT_Stem *stem, JFT_StemPos point) {
  // NB: assumes point is valid
  if (stem->pre)
    return point == 0 ? stem->pre : stem->data[point - 1];
  return stem->data[point];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x73dc
cmpq $0x0, -0x18(%rbp)
jne 0x73ba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x73d2
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x73f0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_child_offset
static inline JFT_Offset JFT_child_offset(const JFT *trie,
                                          JFT_Symbol symbol,
                                          int delta) {
  switch (JFT_node_type(trie)) {
    case Root:      return JFT_maybe_offset(JFT_jump_child_slot(trie, symbol, delta));
    case ScanList:  return JFT_maybe_offset(JFT_scan_child_slot(trie, symbol, delta));
    case JumpTable: return JFT_maybe_offset(JFT_jump_child_slot(trie, symbol, delta));
    case Leaf:      return 0;
    default:        return 0; // no other types, impossible
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d00
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x74bf
movq -0x28(%rbp), %rax
leaq 0x1f3e(%rip), %rcx      # 0x9390
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x7510
movq %rax, %rdi
callq 0x74e0
movq %rax, -0x8(%rbp)
jmp 0x74c7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x7700
movq %rax, %rdi
callq 0x74e0
movq %rax, -0x8(%rbp)
jmp 0x74c7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x7510
movq %rax, %rdi
callq 0x74e0
movq %rax, -0x8(%rbp)
jmp 0x74c7
movq $0x0, -0x8(%rbp)
jmp 0x74c7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_head
static inline JFT_Head JFT_head(JFT_NodeType nodeType,
                                JFT_Boolean isSpecial,
                                JFT_KeySize stemSize,
                                JFT_TypeInfo typeInfo,
                                JFT_Offset parentOffset) {
  return ((((JFT_Head)(nodeType)) << 62) |
          (((JFT_Head)(isSpecial > 0)) << 61) |
          (((JFT_Head)(stemSize & 0b111111111111)) << 48) |
          (((JFT_Head)(typeInfo & 0b11111111)) << 40) |
          (((JFT_Head)(parentOffset & 0xFFFFFFFFFF))));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movl -0x4(%rbp), %eax
shlq $0x3e, %rax
cmpl $0x0, -0x8(%rbp)
seta %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
shlq $0x3d, %rcx
orq %rcx, %rax
movzwl -0xa(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movslq %ecx, %rcx
shlq $0x30, %rcx
orq %rcx, %rax
movl -0x10(%rbp), %ecx
andl $0xff, %ecx
movl %ecx, %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movabsq $0xffffffffff, %rcx     # imm = 0xFFFFFFFFFF
andq -0x18(%rbp), %rcx
orq %rcx, %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_iter_trans
static inline JFT_Iter JFT_iter_trans(JFT_Leaf leaf, JFT_Offset *TLB, JFT_Count TLBSize) {
  return (JFT_Iter) {
    .next = JFT_iter_trans_next,
    .sub = {
      .trans = {
        .leaf = leaf,
        .TLB = TLB,
        .TLBSize = TLBSize,
        .lower = 0,
        .upper = -1,
      }
    }
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %esi, %esi
movl $0xc8, %edx
callq 0x10f0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
leaq -0x12fd(%rip), %rcx     # 0x6870
movq %rcx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa0(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0xa8(%rdi)
movq -0x18(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
movl -0x1c(%rbp), %ecx
movl %ecx, 0xb8(%rdi)
movl $0xffffffff, 0xc4(%rdi) # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_iter_leaf
static inline JFT_Iter JFT_iter_leaf(JFT_Leaf leaf) {
  return (JFT_Iter) {
    .next = JFT_iter_leaf_next,
    .batch = (JFT_Batch) {
      .position = 0,
      .size = leaf.size,
      .data = leaf.data
    }
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
xorl %esi, %esi
movl $0xc8, %edx
callq 0x10f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
leaq -0x1385(%rip), %rcx     # 0x6860
movq %rcx, (%rdi)
movl -0x10(%rbp), %ecx
movl %ecx, 0xc(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: prep_leaf
static inline JFT_Offset prep_leaf(JFT_Buffer *buf,
                                   JFT_Offset parentPos,
                                   const JFT_Stem *stem,
                                   JFT_Count maxWords) {
  // write the node, although it may be updated later
  // ensure space for maxWords and return a pointer where one can write words
  JFT_Offset size = JFT_leaf_size(stem->size, maxWords);
  if (!JFT_buffer_ample(buf, size))
    return 0;

  JFT_Offset parentOffset = offset_parent(buf, parentPos, stem);

  if (maxWords < 0xFF) {
    write_node(buf, Leaf, stem, maxWords, parentOffset);
  } else {
    write_node(buf, Leaf, stem, 0xFF, parentOffset);
    JFT_buffer_equal(buf, JFT_Count, maxWords);
  }

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %edi
movl -0x24(%rbp), %esi
callq 0x8070
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x80b0
cmpq $0x0, %rax
jne 0x7c4b
movq $0x0, -0x8(%rbp)
jmp 0x7ccd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8100
movq %rax, -0x38(%rbp)
cmpl $0xff, -0x24(%rbp)
jae 0x7c84
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %r8
movl $0x3, %esi
callq 0x8150
jmp 0x7cc5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %r8
movl $0x3, %esi
movl $0xff, %ecx
callq 0x8150
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_iter_any
static inline JFT_Iter JFT_iter_any(JFT_Iter *iters, JFT_Mask active) {
  return (JFT_Iter) {
    .next = JFT_iter_any_next,
    .sub = {
      .many = {
        .iters = iters,
        .exists = active,
        .active = active
      }
    }
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %esi, %esi
movl $0xc8, %edx
callq 0x10f0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
leaq -0x1276(%rip), %rcx     # 0x6aa0
movq %rcx, (%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0xa0(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0xb0(%rdi)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: edit_leaf
static inline void edit_leaf(JFT_Buffer *buf,
                             JFT_Offset pos,
                             const JFT_Stem *stem,
                             JFT_Count maxWords,
                             JFT_Count numWords) {
  // correct the actual number of words written
  // if we were using the overflow size area, we will continue to use it
  // even if the actual number of words is small enough to fit now
  if (maxWords < 0xFF)
    JFT_set_type_info(buf->data + pos, numWords);
  else
    *(JFT_Count *)(buf->data + pos + sizeof(JFT_Head) + stem->size) = numWords;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpl $0xff, -0x1c(%rbp)
jae 0x7dca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
addq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x8330
jmp 0x7de8
movl -0x20(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
movslq %ecx, %rcx
movl %edx, 0x8(%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_cursor_mark_subsequent
static inline int JFT_cursor_mark_subsequent(const JFT_Cursor *cursor,
                                             JFT_Range *range,
                                             JFT_SymbolSet *set) {
  // NB: assumes stem is not empty
  if (cursor->point == cursor->stem.size - 1)
    return JFT_mark_children(cursor->node, range, set);
  return JFT_mark_symbol(range, set, JFT_symbol_at_point(&cursor->stem, cursor->point + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0x7e39
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8370
movl %eax, -0x4(%rbp)
jmp 0x7e75
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
addq $0x1, %rsi
callq 0x7390
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
callq 0x83e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_symbol_set_count
static inline int JFT_symbol_set_count(JFT_SymbolSet *set) {
  return (JFT_count_bits((*set)[0]) +
          JFT_count_bits((*set)[1]) +
          JFT_count_bits((*set)[2]) +
          JFT_count_bits((*set)[3]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8590
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8590
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8590
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8590
movl %eax, %ecx
movl -0xc(%rbp), %eax
addl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: make_branch
static inline JFT_Offset make_branch(JFT_Buffer *buf,
                                     JFT_Offset parentPos,
                                     const JFT_Stem *stem,
                                     const JFT_Range *range,
                                     JFT_SymbolSet *symbols,
                                     int numSymbols) {
  // figure out what kind of branch to make
  if (numSymbols < 16)
    return make_scan_list(buf, parentPos, stem, symbols, numSymbols);

  for (int i = 1; i < JFT_JUMP_TABLE_BIG; i++)
    if (range->min >= JumpTableRanges[i].min &&
        range->max <= JumpTableRanges[i].max)
      return make_jump_table(buf, parentPos, stem, i);

  if (numSymbols < 32)
    return make_scan_list(buf, parentPos, stem, symbols, numSymbols);

  for (int i = JFT_JUMP_TABLE_BIG; i < JFT_JUMP_TABLE_END; i++)
    if (range->min >= JumpTableRanges[i].min &&
        range->max <= JumpTableRanges[i].max)
      return make_jump_table(buf, parentPos, stem, i);

  return make_scan_list(buf, parentPos, stem, symbols, numSymbols);

}

// 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 %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jge 0x7f38
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x8620
movq %rax, -0x8(%rbp)
jmp 0x8064
movl $0x1, -0x38(%rbp)
cmpl $0x5, -0x38(%rbp)
jge 0x7fad
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rdx
leaq 0x1459(%rip), %rcx      # 0x93b0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jb 0x7fa0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x38(%rbp), %rdx
leaq 0x143a(%rip), %rcx      # 0x93b0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
ja 0x7fa0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x38(%rbp), %ecx
callq 0x87a0
movq %rax, -0x8(%rbp)
jmp 0x8064
jmp 0x7fa2
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x7f3f
cmpl $0x20, -0x34(%rbp)
jge 0x7fd5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x8620
movq %rax, -0x8(%rbp)
jmp 0x8064
movl $0x5, -0x3c(%rbp)
cmpl $0xb, -0x3c(%rbp)
jge 0x8047
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rdx
leaq 0x13bc(%rip), %rcx      # 0x93b0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jb 0x803a
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rdx
leaq 0x139d(%rip), %rcx      # 0x93b0
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
ja 0x803a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x87a0
movq %rax, -0x8(%rbp)
jmp 0x8064
jmp 0x803c
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7fdc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
callq 0x8620
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_leaf_size
static inline JFT_Offset JFT_leaf_size(JFT_Count stemSize, JFT_Count leafSize) {
  return ((sizeof(JFT_Head)) +
          (stemSize) +
          (leafSize < 0xFF ? 0 : sizeof(JFT_Count)) +
          (leafSize * sizeof(JFT_Word)));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
addq $0x8, %rax
movl -0x8(%rbp), %esi
movl $0x4, %ecx
xorl %edx, %edx
cmpl $0xff, %esi
cmovbq %rdx, %rcx
addq %rcx, %rax
movl -0x8(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: offset_parent
static inline JFT_Offset offset_parent(JFT_Buffer *buf,
                                       JFT_Offset parentPos,
                                       const JFT_Stem *stem) {
  // once we are ready to write the child, its parent slot can be updated, so do so
  return JFT_set_child_offset(buf->data + parentPos,
                              JFT_symbol_at_point(stem, 0),
                              buf->mark - parentPos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7390
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
subq -0x10(%rbp), %rdx
callq 0x8280
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: write_node
static inline void write_node(JFT_Buffer *buf,
                              JFT_NodeType nodeType,
                              const JFT_Stem *stem,
                              JFT_TypeInfo typeInfo,
                              JFT_Offset parentOffset) {
  // take care of the common node head + stem details for leaves & branches
  if (stem->pre) {
    JFT_buffer_equal(buf, JFT_Head, JFT_head(nodeType, stem->pre, stem->size, typeInfo, parentOffset));
    JFT_buffer_equal(buf, uint8_t, JFT_SpToB(stem->pre));
    JFT_buffer_paste(buf, stem->data, stem->size - 1);
  } else {
    JFT_buffer_equal(buf, JFT_Head, JFT_head(nodeType, stem->pre, stem->size, typeInfo, parentOffset));
    JFT_buffer_paste(buf, stem->data, stem->size);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x820f
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
movw 0x8(%rax), %ax
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movzwl %ax, %edx
callq 0x7a00
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x7d40
jmp 0x8274
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, %esi
movq -0x18(%rbp), %rax
movw 0x8(%rax), %ax
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movzwl %ax, %edx
callq 0x7a00
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, %edx
callq 0x7d40
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_set_child_offset
static inline JFT_Offset JFT_set_child_offset(JFT *trie,
                                              JFT_Symbol symbol,
                                              JFT_Offset offset) {
  JFT_Offset *slot = NULL;
  switch (JFT_node_type(trie)) {
    case Root:      slot = JFT_jump_child_slot(trie, symbol, 0); break;
    case ScanList:  slot = JFT_scan_child_slot(trie, symbol, 0); break;
    case JumpTable: slot = JFT_jump_child_slot(trie, symbol, 0); break;
    case Leaf:      /* leaf has no children, shouldn't happen */ break;
  }
  if (slot)
    *slot = offset;
  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4d00
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x8305
movq -0x28(%rbp), %rax
leaq 0x10e5(%rip), %rcx      # 0x93a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x7510
movq %rax, -0x20(%rbp)
jmp 0x8305
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x7700
movq %rax, -0x20(%rbp)
jmp 0x8305
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x7510
movq %rax, -0x20(%rbp)
jmp 0x8305
jmp 0x8305
cmpq $0x0, -0x20(%rbp)
je 0x8317
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_mark_children
static inline int JFT_mark_children(const JFT *trie,
                                    JFT_Range *range,
                                    JFT_SymbolSet *set) {
  switch (JFT_node_type(trie)) {
    case ScanList:  return JFT_mark_scan_children(trie, range, set);
    case JumpTable: return JFT_mark_jump_children(trie, range, set);
    default:        return -1; /* should not happen: error */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4d00
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $0x1, %eax
je 0x83a3
jmp 0x8399
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x83b9
jmp 0x83cf
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8440
movl %eax, -0x4(%rbp)
jmp 0x83d6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x84b0
movl %eax, -0x4(%rbp)
jmp 0x83d6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop