LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_put_unit
bool cx_column_put_unit(struct cx_column *column)
{
    switch (column->type) {
        case CX_COLUMN_BIT:
            return cx_column_put_bit(column, false);
        case CX_COLUMN_I32:
            return cx_column_put_i32(column, 0);
        case CX_COLUMN_I64:
            return cx_column_put_i64(column, 0);
        case CX_COLUMN_FLT:
            return cx_column_put_flt(column, 0.0);
        case CX_COLUMN_DBL:
            return cx_column_put_dbl(column, 0.0);
        case CX_COLUMN_STR:
            return cx_column_put_str(column, "");
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x623a
movq -0x18(%rbp), %rax
leaq 0x9e44(%rip), %rcx      # 0x10000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x5530
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x55b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5740
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x5810
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movq -0x10(%rbp), %rdi
xorps %xmm0, %xmm0
callq 0x54f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movq -0x10(%rbp), %rdi
leaq 0xb1e6(%rip), %rsi      # 0x11414
callq 0x5250
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x623e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_new
struct cx_column_cursor *cx_column_cursor_new(const struct cx_column *column)
{
    struct cx_column_cursor *cursor = malloc(sizeof(*cursor));
    if (!cursor)
        return NULL;
    cursor->column = column;
    cursor->start = cx_column_head(column);
    cursor->end = cx_column_tail(column);
    if (!cx_column_madvise(column, MADV_SEQUENTIAL))
        goto error;
    cx_column_cursor_rewind(cursor);
    return cursor;
error:
    free(cursor);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x420, %edi            # imm = 0x420
callq 0x5630
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x627b
movq $0x0, -0x8(%rbp)
jmp 0x62e6
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x5e20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x62f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6320
testb $0x1, %al
jne 0x62c2
jmp 0x62d5
movq -0x18(%rbp), %rdi
callq 0x54b0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x62e6
movq -0x18(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_madvise
static bool cx_column_madvise(const struct cx_column *column, int advice)
{
    if (!column->mmapped || !column->size)
        return true;
    size_t page_size = getpagesize();
    uintptr_t addr = (uintptr_t)column->buffer.mmapped;
    size_t offset = addr % page_size;
    return !madvise((void *)(addr - offset), (column->size + offset), advice);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x6344
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x634a
movb $0x1, -0x1(%rbp)
jmp 0x6399
callq 0x5930
cltq
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x20(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
subq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
addq -0x30(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x5800
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip_bit
size_t cx_column_cursor_skip_bit(struct cx_column_cursor *cursor, size_t count)
{
    assert(count % 64 == 0);
    size_t skipped = cx_column_cursor_skip(cursor, CX_COLUMN_BIT,
                                           sizeof(uint64_t), count / 64);
    skipped *= 64;
    if (!cx_column_cursor_valid(cursor)) {
        size_t trailing_bits = cursor->column->count % 64;
        if (trailing_bits)
            skipped -= 64 - trailing_bits;
    }
    return skipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
jne 0x6430
jmp 0x644f
leaq 0x9be1(%rip), %rdi      # 0x10018
leaq 0x9bea(%rip), %rsi      # 0x10028
movl $0x13b, %edx            # imm = 0x13B
leaq 0x9be7(%rip), %rcx      # 0x10031
callq 0x53a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
shrq $0x6, %rcx
xorl %esi, %esi
movl $0x8, %edx
callq 0x64c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x64b4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $0x3f, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x64b2
movl $0x40, %ecx
subq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x64b4
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip
static size_t cx_column_cursor_skip(struct cx_column_cursor *cursor,
                                    enum cx_column_type type, size_t size,
                                    size_t count)
{
    assert(cursor->column->type == type);
    size_t remaining =
        ((uintptr_t)cursor->end - (uintptr_t)cursor->position) / size;
    if (remaining < count)
        count = remaining;
    cx_column_cursor_advance(cursor, size * count);
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x64e8
jmp 0x6507
leaq 0x9c90(%rip), %rdi      # 0x1017f
leaq 0x9b32(%rip), %rsi      # 0x10028
movl $0x130, %edx            # imm = 0x130
leaq 0x9c9a(%rip), %rcx      # 0x1019c
callq 0x53a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x6538
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x66d0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_skip_str
size_t cx_column_cursor_skip_str(struct cx_column_cursor *cursor, size_t count)
{
    assert(cursor->column->type == CX_COLUMN_STR);
    size_t skipped = 0;
    // TODO: vectorise this
    for (; skipped < count && cx_column_cursor_valid(cursor); skipped++)
        cx_column_cursor_advance(cursor, cx_strlen(cursor->position) + 1);
    return skipped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, 0x20(%rax)
jne 0x663f
jmp 0x665e
leaq 0x9a2f(%rip), %rdi      # 0x10075
leaq 0x99db(%rip), %rsi      # 0x10028
movl $0x171, %edx            # imm = 0x171
leaq 0x9a42(%rip), %rcx      # 0x1009b
callq 0x53a0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0x6681
movq -0x8(%rbp), %rdi
callq 0x5300
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x668a
jmp 0x66bd
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6730
movq -0x28(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x66d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6666
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_cursor_next_batch_str
const struct cx_string *cx_column_cursor_next_batch_str(
    struct cx_column_cursor *cursor, size_t *available)
{
    assert(cursor->column->type == CX_COLUMN_STR);
    size_t i = 0;
    struct cx_string *strings = (struct cx_string *)cursor->buffer;
    for (; i < CX_BATCH_SIZE && cx_column_cursor_valid(cursor); i++) {
        strings[i].ptr = cursor->position;
        strings[i].len = cx_strlen(cursor->position);
        cx_column_cursor_advance(cursor, strings[i].len + 1);
    }
    *available = i;
    return strings;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x5, 0x20(%rax)
jne 0x68af
jmp 0x68ce
leaq 0x97bf(%rip), %rdi      # 0x10075
leaq 0x976b(%rip), %rsi      # 0x10028
movl $0x1a4, %edx            # imm = 0x1A4
leaq 0x9816(%rip), %rcx      # 0x100df
callq 0x53a0
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x40, -0x18(%rbp)
movb %al, -0x21(%rbp)
jae 0x68fa
movq -0x8(%rbp), %rdi
callq 0x5300
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6903
jmp 0x6971
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x6730
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x66d0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x68e2
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_resize
__attribute__((noinline)) static bool cx_column_resize(struct cx_column *column,
                                                       size_t alloc_size)
{
    size_t size = column->size;
    size_t required_size = column->offset + alloc_size;
#ifdef CX_COLUMN_OVER_ALLOC
    required_size += CX_COLUMN_OVER_ALLOC;
#endif
    while (size < required_size) {
        assert(size * 2 > size);
        size *= 2;
    }
    void *buffer = realloc(column->buffer.mutable, size);
    if (!buffer)
        return false;
#ifdef CX_COLUMN_OVER_ALLOC
    memset((void *)((uintptr_t)buffer + column->offset), 0,
           size - column->offset);
#endif
    column->buffer.mutable = buffer;
    column->size = size;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6a01
movq -0x20(%rbp), %rax
shlq %rax
cmpq -0x20(%rbp), %rax
jbe 0x69d5
jmp 0x69f4
leaq 0x9760(%rip), %rdi      # 0x1013c
leaq 0x9645(%rip), %rsi      # 0x10028
movl $0xa1, %edx
leaq 0x975d(%rip), %rcx      # 0x1014c
callq 0x53a0
movq -0x20(%rbp), %rax
shlq %rax
movq %rax, -0x20(%rbp)
jmp 0x69bc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5760
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6a22
movb $0x0, -0x1(%rbp)
jmp 0x6a3d
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/compress.c
// Function: cx_compress
void *cx_compress(enum cx_compression_type type, int level, const void *src,
                  size_t src_size, size_t *dest_size)
{
    if (type == CX_COMPRESSION_LZ4)
        return cx_compress_lz4(level, src, src_size, dest_size);
    else if (type == CX_COMPRESSION_LZ4HC)
        return cx_compress_lz4hc(level, src, src_size, dest_size);
    else if (type == CX_COMPRESSION_ZSTD)
        return cx_compress_zstd(level, src, src_size, dest_size);
    else
        return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x1, -0xc(%rbp)
jne 0x6a8a
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6ae0
movq %rax, -0x8(%rbp)
jmp 0x6ad2
cmpl $0x2, -0xc(%rbp)
jne 0x6aaa
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6ba0
movq %rax, -0x8(%rbp)
jmp 0x6ad2
cmpl $0x3, -0xc(%rbp)
jne 0x6aca
movl -0x10(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6c60
movq %rax, -0x8(%rbp)
jmp 0x6ad2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/compress.c
// Function: cx_compress_lz4
static void *cx_compress_lz4(int level, const void *src, size_t src_size,
                             size_t *dest_size)
{
    if (src_size > INT_MAX)
        return NULL;
    int max_size = LZ4_compressBound(src_size);
    if (!max_size)
        return NULL;
    void *compressed = malloc(max_size);
    if (!compressed)
        return NULL;
    int result = LZ4_compress_fast(src, compressed, src_size, max_size, level);
    if (!result)
        goto error;
    *dest_size = result;
    return compressed;
error:
    free(compressed);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jbe 0x6b0e
movq $0x0, -0x8(%rbp)
jmp 0x6b95
movq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x51a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6b2c
movq $0x0, -0x8(%rbp)
jmp 0x6b95
movslq -0x2c(%rbp), %rdi
callq 0x5630
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6b4a
movq $0x0, -0x8(%rbp)
jmp 0x6b95
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
movl -0x2c(%rbp), %ecx
movl -0xc(%rbp), %r8d
callq 0x57c0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x6b6f
jmp 0x6b84
movslq -0x3c(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6b95
movq -0x38(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/compress.c
// Function: cx_compress_lz4hc
static void *cx_compress_lz4hc(int level, const void *src, size_t src_size,
                               size_t *dest_size)
{
    if (src_size > INT_MAX)
        return NULL;
    int max_size = LZ4_compressBound(src_size);
    if (!max_size)
        return NULL;
    void *compressed = malloc(max_size);
    if (!compressed)
        return NULL;
    int result = LZ4_compress_HC(src, compressed, src_size, max_size, level);
    if (!result)
        goto error;
    *dest_size = result;
    return compressed;
error:
    free(compressed);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jbe 0x6bce
movq $0x0, -0x8(%rbp)
jmp 0x6c55
movq -0x20(%rbp), %rax
movl %eax, %edi
callq 0x51a0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6bec
movq $0x0, -0x8(%rbp)
jmp 0x6c55
movslq -0x2c(%rbp), %rdi
callq 0x5630
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6c0a
movq $0x0, -0x8(%rbp)
jmp 0x6c55
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rax
movl %eax, %edx
movl -0x2c(%rbp), %ecx
movl -0xc(%rbp), %r8d
callq 0x5060
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x6c2f
jmp 0x6c44
movslq -0x3c(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6c55
movq -0x38(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/compress.c
// Function: cx_compress_zstd
static void *cx_compress_zstd(int level, const void *src, size_t src_size,
                              size_t *dest_size)
{
    int max_size = ZSTD_compressBound(src_size);
    if (!max_size)
        return NULL;
    void *compressed = malloc(max_size);
    if (!compressed)
        return NULL;
    size_t result = ZSTD_compress(compressed, max_size, src, src_size, level);
    if (ZSTD_isError(result))
        goto error;
    *dest_size = result;
    return compressed;
error:
    free(compressed);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5850
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x6c93
movq $0x0, -0x8(%rbp)
jmp 0x6d04
movslq -0x2c(%rbp), %rdi
callq 0x5630
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6cb1
movq $0x0, -0x8(%rbp)
jmp 0x6d04
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %r8d
callq 0x5240
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5180
cmpl $0x0, %eax
je 0x6cde
jmp 0x6cf3
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6d04
movq -0x38(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/compress.c
// Function: cx_decompress
bool cx_decompress(enum cx_compression_type type, const void *src,
                   size_t src_size, void *dest, size_t dest_size)
{
    if (type == CX_COMPRESSION_LZ4 || type == CX_COMPRESSION_LZ4HC)
        return cx_decompress_lz4(src, src_size, dest, dest_size);
    else if (type == CX_COMPRESSION_ZSTD)
        return cx_decompress_zstd(src, src_size, dest, dest_size);
    else
        return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0x6d37
cmpl $0x2, -0x8(%rbp)
jne 0x6d53
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6d90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6d79
cmpl $0x3, -0x8(%rbp)
jne 0x6d75
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x6df0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6d79
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_new
struct cx_index *cx_index_new(const struct cx_column *column)
{
    struct cx_index *index = calloc(1, sizeof(*index));
    if (!index)
        return NULL;
    struct cx_column_cursor *cursor = cx_column_cursor_new(column);
    if (!cursor)
        goto error;
    switch (cx_column_type(column)) {
        case CX_COLUMN_BIT:
            index->min.bit = true;
            cx_index_update_bit(index, cursor);
            break;
        case CX_COLUMN_I32:
            index->min.i32 = INT32_MAX;
            cx_index_update_i32(index, cursor);
            break;
        case CX_COLUMN_I64:
            index->min.i64 = INT64_MAX;
            cx_index_update_i64(index, cursor);
            break;
        case CX_COLUMN_FLT:
            index->min.flt = FLT_MAX;
            cx_index_update_flt(index, cursor);
            break;
        case CX_COLUMN_DBL:
            index->min.dbl = DBL_MAX;
            cx_index_update_dbl(index, cursor);
            break;
        case CX_COLUMN_STR:
            index->min.len = UINT64_MAX;
            cx_index_update_str(index, cursor);
            break;
    }
    cx_column_cursor_free(cursor);
    return index;
error:
    free(index);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x54d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6e83
movq $0x0, -0x8(%rbp)
jmp 0x6f9a
movq -0x10(%rbp), %rdi
callq 0x5410
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6e9c
jmp 0x6f89
movq -0x10(%rbp), %rdi
callq 0x5500
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x5, %eax
ja 0x6f76
movq -0x28(%rbp), %rax
leaq 0x93ad(%rip), %rcx      # 0x1026c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6fb0
jmp 0x6f76
movq -0x18(%rbp), %rax
movl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x70b0
jmp 0x6f76
movq -0x18(%rbp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7180
jmp 0x6f76
movq -0x18(%rbp), %rax
movss 0x933f(%rip), %xmm0     # 0x10268
movss %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7260
jmp 0x6f76
movq -0x18(%rbp), %rax
movsd 0x9317(%rip), %xmm0     # 0x10260
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7350
jmp 0x6f76
movq -0x18(%rbp), %rax
movq $-0x1, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7440
movq -0x20(%rbp), %rdi
callq 0x5910
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6f9a
movq -0x18(%rbp), %rdi
callq 0x50a0
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/chriso[P]columnix/lib/index.c
// Function: cx_index_update_bit
static void cx_index_update_bit(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const uint64_t *bitset =
            cx_column_cursor_next_batch_bit(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            bool value = *bitset & ((uint64_t)1 << i);
            index->min.bit = index->min.bit && value;
            index->max.bit = index->max.bit || value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x6fd2
jmp 0x70aa
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x56c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6fec
jmp 0x700b
leaq 0xa104(%rip), %rdi      # 0x110f7
leaq 0x928a(%rip), %rsi      # 0x10284
movl $0x45, %edx
leaq 0x9286(%rip), %rcx      # 0x1028c
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x70a5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x8(%rcx)
movb %al, -0x2a(%rbp)
je 0x7065
movb -0x29(%rbp), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rcx
movb $0x1, %al
testb $0x1, 0x10(%rcx)
movb %al, -0x2b(%rbp)
jne 0x7087
movb -0x29(%rbp), %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7021
jmp 0x6fc0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_update_i32
static void cx_index_update_i32(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const int32_t *values = cx_column_cursor_next_batch_i32(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            int32_t value = values[i];
            if (value > index->max.i32)
                index->max.i32 = value;
            if (value < index->min.i32)
                index->min.i32 = value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x70d2
jmp 0x717a
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5450
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x70ec
jmp 0x710b
leaq 0xa004(%rip), %rdi      # 0x110f7
leaq 0x918a(%rip), %rsi      # 0x10284
movl $0x55, %edx
leaq 0x91cd(%rip), %rcx      # 0x102d3
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7175
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x714f
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x7165
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x7167
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7121
jmp 0x70c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_update_i64
static void cx_index_update_i64(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const int64_t *values = cx_column_cursor_next_batch_i64(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            int64_t value = values[i];
            if (value > index->max.i64)
                index->max.i64 = value;
            if (value < index->min.i64)
                index->min.i64 = value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x71a2
jmp 0x7254
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x52a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x71bc
jmp 0x71db
leaq 0x9f34(%rip), %rdi      # 0x110f7
leaq 0x90ba(%rip), %rsi      # 0x10284
movl $0x67, %edx
leaq 0x9144(%rip), %rcx      # 0x1031a
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x724f
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0x7225
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x723f
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7241
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x71f1
jmp 0x7190
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_update_flt
static void cx_index_update_flt(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const float *values = cx_column_cursor_next_batch_flt(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            float value = values[i];
            if (value > index->max.flt)
                index->max.flt = value;
            if (value < index->min.flt)
                index->min.flt = value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x7282
jmp 0x7340
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x53c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x729c
jmp 0x72bb
leaq 0x9e54(%rip), %rdi      # 0x110f7
leaq 0x8fda(%rip), %rsi      # 0x10284
movl $0x79, %edx
leaq 0x90ab(%rip), %rcx      # 0x10361
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x733b
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomiss 0x10(%rax), %xmm0
jbe 0x730a
movss -0x2c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x10(%rax)
movss -0x2c(%rbp), %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x732b
movss -0x2c(%rbp), %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x8(%rax)
jmp 0x732d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x72d1
jmp 0x7270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_update_dbl
static void cx_index_update_dbl(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const double *values = cx_column_cursor_next_batch_dbl(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            double value = values[i];
            if (value > index->max.dbl)
                index->max.dbl = value;
            if (value < index->min.dbl)
                index->min.dbl = value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x7372
jmp 0x7432
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x51e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x738c
jmp 0x73ab
leaq 0x9d64(%rip), %rdi      # 0x110f7
leaq 0x8eea(%rip), %rsi      # 0x10284
movl $0x8b, %edx
leaq 0x9002(%rip), %rcx      # 0x103a8
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x742d
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x10(%rax), %xmm0
jbe 0x73fb
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x30(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x741d
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
jmp 0x741f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x73c1
jmp 0x7360
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_update_str
static void cx_index_update_str(struct cx_index *index,
                                struct cx_column_cursor *cursor)
{
    while (cx_column_cursor_valid(cursor)) {
        size_t count;
        const struct cx_string *values =
            cx_column_cursor_next_batch_str(cursor, &count);
        assert(count);
        index->count += count;
        for (size_t i = 0; i < count; i++) {
            uint64_t value = values[i].len;
            if (value > index->max.len)
                index->max.len = value;
            if (value < index->min.len)
                index->min.len = value;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5300
testb $0x1, %al
jne 0x7462
jmp 0x751b
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5460
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x747c
jmp 0x749b
leaq 0x9c74(%rip), %rdi      # 0x110f7
leaq 0x8dfa(%rip), %rsi      # 0x10284
movl $0x9e, %edx
leaq 0x8f59(%rip), %rcx      # 0x103ef
callq 0x53a0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x7516
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x74ec
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x7506
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x7508
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x74b1
jmp 0x7450
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_bit_eq
enum cx_index_match cx_index_match_bit_eq(const struct cx_index *index,
                                          bool value)
{
    if (index->min.bit && index->max.bit)
        return value ? CX_INDEX_MATCH_ALL : CX_INDEX_MATCH_NONE;
    if (!index->min.bit && !index->max.bit)
        return value ? CX_INDEX_MATCH_NONE : CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x758c
movq -0x10(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x758c
movb -0x11(%rbp), %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x75bf
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
jne 0x75b8
movq -0x10(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x75b8
movb -0x11(%rbp), %dl
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x75bf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_i32_eq
enum cx_index_match cx_index_match_i32_eq(const struct cx_index *index,
                                          int32_t value)
{
    if (index->min.i32 > value || index->max.i32 < value)
        return CX_INDEX_MATCH_NONE;
    if (index->min.i32 == value && index->max.i32 == value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jg 0x75f3
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x75fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7624
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x761d
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x761d
movl $0x1, -0x4(%rbp)
jmp 0x7624
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_i32_lt
enum cx_index_match cx_index_match_i32_lt(const struct cx_index *index,
                                          int32_t value)
{
    if (index->min.i32 >= value)
        return CX_INDEX_MATCH_NONE;
    if (index->max.i32 < value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jl 0x7650
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x766c
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x7665
movl $0x1, -0x4(%rbp)
jmp 0x766c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_i64_eq
enum cx_index_match cx_index_match_i64_eq(const struct cx_index *index,
                                          int64_t value)
{
    if (index->min.i64 > value || index->max.i64 < value)
        return CX_INDEX_MATCH_NONE;
    if (index->min.i64 == value && index->max.i64 == value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jg 0x76f8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jge 0x7701
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x772d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x7726
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x7726
movl $0x1, -0x4(%rbp)
jmp 0x772d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_i64_lt
enum cx_index_match cx_index_match_i64_lt(const struct cx_index *index,
                                          int64_t value)
{
    if (index->min.i64 >= value)
        return CX_INDEX_MATCH_NONE;
    if (index->max.i64 < value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jl 0x7763
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7781
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jge 0x777a
movl $0x1, -0x4(%rbp)
jmp 0x7781
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_i64_gt
enum cx_index_match cx_index_match_i64_gt(const struct cx_index *index,
                                          int64_t value)
{
    if (index->min.i64 > value)
        return CX_INDEX_MATCH_ALL;
    if (index->max.i64 <= value)
        return CX_INDEX_MATCH_NONE;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jle 0x77b3
movl $0x1, -0x4(%rbp)
jmp 0x77d1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jg 0x77ca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x77d1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_flt_eq
enum cx_index_match cx_index_match_flt_eq(const struct cx_index *index,
                                          float value)
{
    if (index->min.flt > value || index->max.flt < value)
        return CX_INDEX_MATCH_NONE;
    if (index->min.flt == value && index->max.flt == value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss -0x14(%rbp), %xmm0
ja 0x780f
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7818
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x784a
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss -0x14(%rbp), %xmm0
jne 0x7843
jp 0x7843
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm0
ucomiss -0x14(%rbp), %xmm0
jne 0x7843
jp 0x7843
movl $0x1, -0x4(%rbp)
jmp 0x784a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_flt_lt
enum cx_index_match cx_index_match_flt_lt(const struct cx_index *index,
                                          float value)
{
    if (index->min.flt >= value)
        return CX_INDEX_MATCH_NONE;
    if (index->max.flt < value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss -0x14(%rbp), %xmm0
jb 0x7875
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7898
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7891
movl $0x1, -0x4(%rbp)
jmp 0x7898
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_flt_gt
enum cx_index_match cx_index_match_flt_gt(const struct cx_index *index,
                                          float value)
{
    if (index->min.flt > value)
        return CX_INDEX_MATCH_ALL;
    if (index->max.flt <= value)
        return CX_INDEX_MATCH_NONE;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movss 0x8(%rax), %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x78c5
movl $0x1, -0x4(%rbp)
jmp 0x78e8
movq -0x10(%rbp), %rax
movss 0x10(%rax), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jb 0x78e1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x78e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_dbl_eq
enum cx_index_match cx_index_match_dbl_eq(const struct cx_index *index,
                                          double value)
{
    if (index->min.dbl > value || index->max.dbl < value)
        return CX_INDEX_MATCH_NONE;
    if (index->min.dbl == value && index->max.dbl == value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
ja 0x7921
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x792a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x795e
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x7957
jp 0x7957
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x7957
jp 0x7957
movl $0x1, -0x4(%rbp)
jmp 0x795e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_dbl_lt
enum cx_index_match cx_index_match_dbl_lt(const struct cx_index *index,
                                          double value)
{
    if (index->min.dbl >= value)
        return CX_INDEX_MATCH_NONE;
    if (index->max.dbl < value)
        return CX_INDEX_MATCH_ALL;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x7996
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x79ba
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x79b3
movl $0x1, -0x4(%rbp)
jmp 0x79ba
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/index.c
// Function: cx_index_match_dbl_gt
enum cx_index_match cx_index_match_dbl_gt(const struct cx_index *index,
                                          double value)
{
    if (index->min.dbl > value)
        return CX_INDEX_MATCH_ALL;
    if (index->max.dbl <= value)
        return CX_INDEX_MATCH_NONE;
    return CX_INDEX_MATCH_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x79e6
movl $0x1, -0x4(%rbp)
jmp 0x7a0a
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7a03
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7a0a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_free
void cx_predicate_free(struct cx_predicate *predicate)
{
    if (predicate->operands) {
        for (size_t i = 0; i < predicate->operand_count; i++)
            if (predicate->operands[i])
                cx_predicate_free(predicate->operands[i]);
        free(predicate->operands);
    }
    if (predicate->string)
        free(predicate->string);
    free(predicate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x8ff2
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x8fe5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8fd5
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5440
jmp 0x8fd7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8f9f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x900a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_true
struct cx_predicate *cx_predicate_new_true()
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->type = CX_PREDICATE_TRUE;
    return predicate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xb490
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9042
movq $0x0, -0x8(%rbp)
jmp 0x9054
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/predicate.c
// Function: cx_predicate_new_null
struct cx_predicate *cx_predicate_new_null(size_t column)
{
    struct cx_predicate *predicate = cx_predicate_new();
    if (!predicate)
        return NULL;
    predicate->type = CX_PREDICATE_NULL;
    predicate->column = column;
    return predicate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0xb490
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9086
movq $0x0, -0x8(%rbp)
jmp 0x90a4
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop