LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/reader.c
// Function: cx_row_group_reader_string
const char *cx_row_group_reader_string(const struct cx_row_group_reader *reader,
                                       size_t index)
{
    size_t size;
    assert(cx_column_type(reader->strings) == CX_COLUMN_STR);
    assert(cx_column_encoding(reader->strings) == CX_ENCODING_NONE);
    const char *string = cx_column_export(reader->strings, &size);
    const char *end = string + size;
    for (; index && string < end; index--)
        string += strlen(string) + 1;
    assert(string <= end);
    return index == 0 && string != end ? string : NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x5500
cmpl $0x5, %eax
jne 0xc834
jmp 0xc853
leaq 0x47d0(%rip), %rdi      # 0x1100b
leaq 0x47fa(%rip), %rsi      # 0x1103c
movl $0x1db, %edx            # imm = 0x1DB
leaq 0x47f7(%rip), %rcx      # 0x11045
callq 0x53a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x50f0
cmpl $0x0, %eax
jne 0xc867
jmp 0xc886
leaq 0x482a(%rip), %rdi      # 0x11098
leaq 0x47c7(%rip), %rsi      # 0x1103c
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x47c4(%rip), %rcx      # 0x11045
callq 0x53a0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0xc8c1
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xc8ca
jmp 0xc8ed
movq -0x20(%rbp), %rdi
callq 0x5290
addq $0x1, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc8a7
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xc8f9
jmp 0xc918
leaq 0x47d0(%rip), %rdi      # 0x110d0
leaq 0x4735(%rip), %rsi      # 0x1103c
movl $0x1e1, %edx            # imm = 0x1E1
leaq 0x4732(%rip), %rcx      # 0x11045
callq 0x53a0
cmpq $0x0, -0x10(%rbp)
jne 0xc933
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xc933
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xc93b
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0xc93b
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_new
struct cx_row_cursor *cx_row_cursor_new(struct cx_row_group *row_group,
                                        const struct cx_predicate *predicate)
{
    struct cx_row_cursor *cursor = calloc(1, sizeof(*cursor));
    if (!cursor)
        return NULL;
    cursor->row_group = row_group;
    cursor->cursor = cx_row_group_cursor_new(row_group);
    if (!cursor->cursor)
        goto error;
    cursor->predicate = predicate;
    cursor->index_match =
        cx_index_match_indexes(cursor->predicate, cursor->row_group);
    cx_row_cursor_rewind(cursor);
    return cursor;
error:
    free(cursor);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x54d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcbd4
movq $0x0, -0x8(%rbp)
jmp 0xcc4d
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x56b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xcc00
jmp 0xcc3c
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x51b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rdi
callq 0x50b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcc4d
movq -0x20(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_rewind
void cx_row_cursor_rewind(struct cx_row_cursor *cursor)
{
    cursor->row_mask = 0;
    cursor->position = 64;
    cx_row_group_cursor_rewind(cursor->cursor);
    cursor->error = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x40, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x58f0
movq -0x8(%rbp), %rax
movb $0x0, 0x35(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_next
bool cx_row_cursor_next(struct cx_row_cursor *cursor)
{
    if (cursor->position < 63) {
        uint64_t mask = cursor->row_mask >> (cursor->position + 1);
        if (mask) {
            cursor->position += __builtin_ctzll(mask) + 1;
            return true;
        }
    }
    cursor->row_mask = cx_row_cursor_load_row_mask(cursor);
    if (!cursor->row_mask)
        return false;
    cursor->position = __builtin_ctzll(cursor->row_mask);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x3f, 0x28(%rax)
jae 0xcd2c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
addq $0x1, %rcx
shrq %cl, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcd2a
movq -0x18(%rbp), %rax
tzcntq %rax, %rax
addl $0x1, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xcd6d
jmp 0xcd2c
movq -0x10(%rbp), %rdi
callq 0xcd80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xcd51
movb $0x0, -0x1(%rbp)
jmp 0xcd6d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
tzcntq %rax, %rax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_load_row_mask
static uint64_t cx_row_cursor_load_row_mask(struct cx_row_cursor *cursor)
{
    uint64_t row_mask = 0;
    while (!row_mask && cx_row_group_cursor_next(cursor->cursor)) {
        size_t count;
        if (cursor->index_match == CX_INDEX_MATCH_ALL) {
            count = cx_row_group_cursor_batch_count(cursor->cursor);
            row_mask = (uint64_t)-1;
            if (count < 64)
                row_mask &= ((uint64_t)1 << count) - 1;
        } else if (!cx_index_match_rows(cursor->predicate, cursor->row_group,
                                        cursor->cursor, &row_mask, &count))
            goto error;
    }
    return row_mask;
error:
    cursor->error = true;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
jne 0xcdb0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x59d0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xcdb9
jmp 0xce2e
movq -0x10(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xcdfd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5ab0
movq %rax, -0x20(%rbp)
movq $-0x1, -0x18(%rbp)
cmpq $0x40, -0x20(%rbp)
jae 0xcdfb
movq -0x20(%rbp), %rcx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xce29
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x18(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq 0x5700
testb $0x1, %al
jne 0xce27
jmp 0xce38
jmp 0xce29
jmp 0xcd94
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xce48
movq -0x10(%rbp), %rax
movb $0x1, 0x35(%rax)
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/row.c
// Function: cx_row_cursor_count
size_t cx_row_cursor_count(struct cx_row_cursor *cursor)
{
    if (cursor->index_match == CX_INDEX_MATCH_NONE)
        return 0;
    else if (cursor->index_match == CX_INDEX_MATCH_ALL)
        return cx_row_group_row_count(cursor->row_group);
    cx_row_cursor_rewind(cursor);
    size_t count = 0;
    for (;;) {
        uint64_t row_mask = cx_row_cursor_load_row_mask(cursor);
        if (!row_mask)
            break;
        count += __builtin_popcountll(row_mask);
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x30(%rax)
jne 0xcea3
movq $0x0, -0x8(%rbp)
jmp 0xcf5c
movq -0x10(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0xcec2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x54a0
movq %rax, -0x8(%rbp)
jmp 0xcf5c
jmp 0xcec4
movq -0x10(%rbp), %rdi
callq 0x50b0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcd80
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xceeb
jmp 0xcf54
movq -0x20(%rbp), %rcx
movq %rcx, %rax
shrq %rax
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rax
subq %rax, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
movq %rcx, %rax
andq %rdx, %rax
shrq $0x2, %rcx
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rcx # imm = 0x101010101010101
imulq %rcx, %rax
shrq $0x38, %rax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xced5
movq -0x18(%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/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_get_null
bool cx_row_cursor_get_null(const struct cx_row_cursor *cursor,
                            size_t column_index, bool *value)
{
    assert(cursor->row_mask);
    size_t count;
    const uint64_t *nulls =
        cx_row_group_cursor_batch_nulls(cursor->cursor, column_index, &count);
    uint64_t row_bit = (uint64_t)1 << cursor->position;
    if (!count || !nulls)
        return false;
    *value = *nulls & row_bit;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xcf91
jmp 0xcfb0
leaq 0x429e(%rip), %rdi      # 0x11236
leaq 0x42a8(%rip), %rsi      # 0x11247
movl $0x71, %edx
leaq 0x42a2(%rip), %rcx      # 0x1124d
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5100
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcfeb
cmpq $0x0, -0x30(%rbp)
jne 0xcff1
movb $0x0, -0x1(%rbp)
jmp 0xd010
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
setne %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_get_bit
bool cx_row_cursor_get_bit(const struct cx_row_cursor *cursor,
                           size_t column_index, bool *value)
{
    assert(cursor->row_mask);
    size_t count;
    const uint64_t *bitset =
        cx_row_group_cursor_batch_bit(cursor->cursor, column_index, &count);
    uint64_t row_bit = (uint64_t)1 << cursor->position;
    if (!count || !bitset)
        return false;
    *value = *bitset & row_bit;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd041
jmp 0xd060
leaq 0x41ee(%rip), %rdi      # 0x11236
leaq 0x41f8(%rip), %rsi      # 0x11247
movl $0x7f, %edx
leaq 0x423e(%rip), %rcx      # 0x11299
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5590
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd09b
cmpq $0x0, -0x30(%rbp)
jne 0xd0a1
movb $0x0, -0x1(%rbp)
jmp 0xd0c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq -0x38(%rbp), %rax
cmpq $0x0, %rax
setne %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row.c
// Function: cx_row_cursor_get_i32
bool cx_row_cursor_get_i32(const struct cx_row_cursor *cursor,
                           size_t column_index, int32_t *value)
{
    assert(cursor->row_mask);
    size_t count;
    const int32_t *batch =
        cx_row_group_cursor_batch_i32(cursor->cursor, column_index, &count);
    if (!batch || !count)
        return false;
    *value = batch[cursor->position];
    return true;
}

// 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
cmpq $0x0, 0x20(%rax)
je 0xd0f1
jmp 0xd110
leaq 0x413e(%rip), %rdi      # 0x11236
leaq 0x4148(%rip), %rsi      # 0x11247
movl $0x8d, %edx
leaq 0x41d9(%rip), %rcx      # 0x112e4
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x58a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd137
cmpq $0x0, -0x28(%rbp)
jne 0xd13d
movb $0x0, -0x1(%rbp)
jmp 0xd156
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -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/row.c
// Function: cx_row_cursor_get_i64
bool cx_row_cursor_get_i64(const struct cx_row_cursor *cursor,
                           size_t column_index, int64_t *value)
{
    assert(cursor->row_mask);
    size_t count;
    const int64_t *batch =
        cx_row_group_cursor_batch_i64(cursor->cursor, column_index, &count);
    if (!batch || !count)
        return false;
    *value = batch[cursor->position];
    return true;
}

// 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
cmpq $0x0, 0x20(%rax)
je 0xd191
jmp 0xd1b0
leaq 0x409e(%rip), %rdi      # 0x11236
leaq 0x40a8(%rip), %rsi      # 0x11247
movl $0x9a, %edx
leaq 0x4186(%rip), %rcx      # 0x11331
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5950
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd1d7
cmpq $0x0, -0x28(%rbp)
jne 0xd1dd
movb $0x0, -0x1(%rbp)
jmp 0xd1f8
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -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/row.c
// Function: cx_row_cursor_get_flt
bool cx_row_cursor_get_flt(const struct cx_row_cursor *cursor,
                           size_t column_index, float *value)
{
    assert(cursor->row_mask);
    size_t count;
    const float *batch =
        cx_row_group_cursor_batch_flt(cursor->cursor, column_index, &count);
    if (!batch || !count)
        return false;
    *value = batch[cursor->position];
    return true;
}

// 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
cmpq $0x0, 0x20(%rax)
je 0xd231
jmp 0xd250
leaq 0x3ffe(%rip), %rdi      # 0x11236
leaq 0x4008(%rip), %rsi      # 0x11247
movl $0xa7, %edx
leaq 0x4133(%rip), %rcx      # 0x1137e
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x58b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd277
cmpq $0x0, -0x28(%rbp)
jne 0xd27d
movb $0x0, -0x1(%rbp)
jmp 0xd29a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
movb $0x1, -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/row.c
// Function: cx_row_cursor_get_dbl
bool cx_row_cursor_get_dbl(const struct cx_row_cursor *cursor,
                           size_t column_index, double *value)
{
    assert(cursor->row_mask);
    size_t count;
    const double *batch =
        cx_row_group_cursor_batch_dbl(cursor->cursor, column_index, &count);
    if (!batch || !count)
        return false;
    *value = batch[cursor->position];
    return true;
}

// 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
cmpq $0x0, 0x20(%rax)
je 0xd2d1
jmp 0xd2f0
leaq 0x3f5e(%rip), %rdi      # 0x11236
leaq 0x3f68(%rip), %rsi      # 0x11247
movl $0xb4, %edx
leaq 0x40de(%rip), %rcx      # 0x113c9
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x56a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd317
cmpq $0x0, -0x28(%rbp)
jne 0xd31d
movb $0x0, -0x1(%rbp)
jmp 0xd33a
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x1, -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/row.c
// Function: cx_row_cursor_get_str
bool cx_row_cursor_get_str(const struct cx_row_cursor *cursor,
                           size_t column_index, struct cx_string *value)
{
    assert(cursor->row_mask);
    size_t count;
    const struct cx_string *batch =
        cx_row_group_cursor_batch_str(cursor->cursor, column_index, &count);
    if (!batch || !count)
        return false;
    const struct cx_string *string = &batch[cursor->position];
    value->ptr = string->ptr;
    value->len = string->len;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd371
jmp 0xd390
leaq 0x3ebe(%rip), %rdi      # 0x11236
leaq 0x3ec8(%rip), %rsi      # 0x11247
movl $0xc1, %edx
leaq 0x408a(%rip), %rcx      # 0x11415
callq 0x53a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5670
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd3b7
cmpq $0x0, -0x28(%rbp)
jne 0xd3bd
movb $0x0, -0x1(%rbp)
jmp 0xd3f6
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_new
struct cx_row_group *cx_row_group_new()
{
    struct cx_row_group *row_group = malloc(sizeof(*row_group));
    if (!row_group)
        return NULL;
    row_group->columns =
        malloc(cx_row_group_column_initial_size * sizeof(*row_group->columns));
    if (!row_group->columns)
        goto error;
    row_group->count = 0;
    row_group->size = cx_row_group_column_initial_size;
    return row_group;
error:
    free(row_group);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x5630
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd437
movq $0x0, -0x8(%rbp)
jmp 0xd48a
movl $0x480, %edi            # imm = 0x480
callq 0x5630
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd457
jmp 0xd479
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x8, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd48a
movq -0x10(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_free
void cx_row_group_free(struct cx_row_group *row_group)
{
    for (size_t i = 0; i < row_group->count; i++) {
        struct cx_row_group_column *row_group_column = &row_group->columns[i];
        if (row_group_column->lazy) {
            if (row_group_column->values.column)
                cx_column_free(row_group_column->values.column);
            if (row_group_column->nulls.column)
                cx_column_free(row_group_column->nulls.column);
        } else {
            cx_index_free(row_group_column->values.index);
            cx_index_free(row_group_column->nulls.index);
        }
    }
    free(row_group->columns);
    free(row_group);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd548
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq $0x90, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0xd51b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd501
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5990
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd519
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5990
jmp 0xd535
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5580
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x5580
jmp 0xd537
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd4b4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_ensure_column_size
static bool cx_row_group_ensure_column_size(struct cx_row_group *row_group)
{
    if (row_group->count == row_group->size) {
        size_t new_size = row_group->size * 2;
        assert(new_size && new_size > row_group->size);
        struct cx_row_group_column *columns =
            realloc(row_group->columns, new_size * sizeof(*columns));
        if (!columns)
            return false;
        row_group->columns = columns;
        row_group->size = new_size;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xd7a3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd748
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0xd748
jmp 0xd767
leaq 0x3f36(%rip), %rdi      # 0x11685
leaq 0x3d2e(%rip), %rsi      # 0x11484
movl $0x5b, %edx
leaq 0x3f4a(%rip), %rcx      # 0x116ac
callq 0x53a0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
imulq $0x90, -0x18(%rbp), %rsi
callq 0x5760
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd78c
movb $0x0, -0x1(%rbp)
jmp 0xd7a7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_add_lazy_column
bool cx_row_group_add_lazy_column(struct cx_row_group *row_group,
                                  const struct cx_lazy_column *column,
                                  const struct cx_lazy_column *nulls)
{
    size_t row_count = column->index->count;
    if (row_count != nulls->index->count || nulls->type != CX_COLUMN_BIT)
        return false;
    if (row_group->count && row_group->row_count != row_count)
        return false;
    if (!cx_row_group_ensure_column_size(row_group))
        return false;
    struct cx_row_group_column *row_group_column =
        &row_group->columns[row_group->count++];
    row_group_column->type = column->type;
    row_group_column->encoding = column->encoding;
    row_group_column->values.index = (struct cx_index *)column->index;
    row_group_column->values.column = NULL;
    memcpy(&row_group_column->values.lazy_column, column, sizeof(*column));
    row_group_column->lazy = true;
    row_group_column->nulls.column = NULL;
    row_group_column->nulls.index = (struct cx_index *)nulls->index;
    memcpy(&row_group_column->nulls.lazy_column, nulls, sizeof(*nulls));
    row_group->row_count = row_count;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0xd7fd
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0xd806
movb $0x0, -0x1(%rbp)
jmp 0xd907
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd828
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
je 0xd828
movb $0x0, -0x1(%rbp)
jmp 0xd907
movq -0x10(%rbp), %rdi
callq 0xd700
testb $0x1, %al
jne 0xd83e
movb $0x0, -0x1(%rbp)
jmp 0xd907
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movl $0x30, %edx
callq 0x5570
movq -0x30(%rbp), %rax
movb $0x1, 0x88(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rsi
movl $0x30, %edx
callq 0x5570
movq -0x28(%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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_row_count
size_t cx_row_group_row_count(const struct cx_row_group *row_group)
{
    if (!row_group->count)
        return 0;
    const struct cx_index *index = cx_row_group_column_index(row_group, 0);
    return index->count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd961
movq $0x0, -0x8(%rbp)
jmp 0xd97d
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5110
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_column
const struct cx_column *cx_row_group_column(
    const struct cx_row_group *row_group, size_t index)
{
    assert(index < row_group->count);
    struct cx_row_group_column *row_group_column = &row_group->columns[index];
    if (row_group_column->lazy && !row_group_column->values.column)
        if (!cx_row_group_lazy_column_init(&row_group_column->values))
            return NULL;
    return row_group_column->values.column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xdb30
jmp 0xdb4f
leaq 0x3934(%rip), %rdi      # 0x1146b
leaq 0x3946(%rip), %rsi      # 0x11484
movl $0xee, %edx
leaq 0x3a9a(%rip), %rcx      # 0x115e4
callq 0x53a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x90, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0xdb9a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xdb9a
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xdbb0
testb $0x1, %al
jne 0xdb98
movq $0x0, -0x8(%rbp)
jmp 0xdba6
jmp 0xdb9a
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_lazy_column_init
static bool cx_row_group_lazy_column_init(
    struct cx_row_group_physical_column *row_group_column)
{
    struct cx_lazy_column *lazy = &row_group_column->lazy_column;
    struct cx_column *column = NULL;
    if (lazy->compression && lazy->size) {
        void *dest;
        column = cx_column_new_compressed(lazy->type, lazy->encoding, &dest,
                                          lazy->decompressed_size,
                                          row_group_column->index->count);
        if (!column)
            goto error;
        if (!cx_decompress(lazy->compression, lazy->ptr, lazy->size, dest,
                           lazy->decompressed_size))
            goto error;
    } else {
        column =
            cx_column_new_mmapped(lazy->type, lazy->encoding, lazy->ptr,
                                  lazy->size, row_group_column->index->count);
        if (!column)
            goto error;
    }
    row_group_column->column = column;
    return true;
error:
    if (column)
        cx_column_free(column);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xdc4a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xdc4a
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %r8
leaq -0x28(%rbp), %rdx
callq 0x5ae0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xdc1a
jmp 0xdc97
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x28(%rax), %r8
callq 0x55e0
testb $0x1, %al
jne 0xdc48
jmp 0xdc97
jmp 0xdc85
movq -0x18(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %r8
callq 0x5730
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xdc83
jmp 0xdc97
jmp 0xdc85
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xdcab
cmpq $0x0, -0x20(%rbp)
je 0xdca7
movq -0x20(%rbp), %rdi
callq 0x5990
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/row_group.c
// Function: cx_row_group_nulls
const struct cx_column *cx_row_group_nulls(const struct cx_row_group *row_group,
                                           size_t index)
{
    assert(index < row_group->count);
    struct cx_row_group_column *row_group_column = &row_group->columns[index];
    if (row_group_column->lazy && !row_group_column->nulls.column)
        if (!cx_row_group_lazy_column_init(&row_group_column->nulls))
            return NULL;
    return row_group_column->nulls.column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xdce0
jmp 0xdcff
leaq 0x3784(%rip), %rdi      # 0x1146b
leaq 0x3796(%rip), %rsi      # 0x11484
movl $0xf9, %edx
leaq 0x393b(%rip), %rcx      # 0x11635
callq 0x53a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
imulq $0x90, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0xdd4a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xdd4a
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0xdbb0
testb $0x1, %al
jne 0xdd48
movq $0x0, -0x8(%rbp)
jmp 0xdd56
jmp 0xdd4a
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_new
struct cx_row_group_cursor *cx_row_group_cursor_new(
    struct cx_row_group *row_group)
{
    size_t column_count = cx_row_group_column_count(row_group);
    size_t size = sizeof(struct cx_row_group_cursor) +
                  column_count * sizeof(struct cx_row_group_cursor_column);
    struct cx_row_group_cursor *cursor = calloc(1, size);
    if (!cursor)
        return NULL;
    cursor->row_group = row_group;
    cursor->column_count = column_count;
    cursor->row_count = cx_row_group_row_count(row_group);
    return cursor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x6, %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x1, %edi
callq 0x54d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xddac
movq $0x0, -0x8(%rbp)
jmp 0xdddf
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x54a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -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/row_group.c
// Function: cx_row_group_cursor_rewind
void cx_row_group_cursor_rewind(struct cx_row_group_cursor *cursor)
{
    cursor->initialized = false;
    cursor->position = 0;
    for (size_t i = 0; i < cursor->column_count; i++) {
        cx_row_group_cursor_rewind_columns(&cursor->columns[i].values);
        cx_row_group_cursor_rewind_columns(&cursor->columns[i].nulls);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xde98
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0xdea0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
addq $0x20, %rdi
callq 0xdea0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xde48
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_rewind_columns
static void cx_row_group_cursor_rewind_columns(
    struct cx_row_group_cursor_physical_column *column)
{
    if (column->cursor)
        cx_column_cursor_free(column->cursor);
    column->cursor = NULL;
    column->position = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdec2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5910
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_next
bool cx_row_group_cursor_next(struct cx_row_group_cursor *cursor)
{
    if (!cursor->initialized)
        cursor->initialized = true;
    else
        cursor->position += CX_BATCH_SIZE;
    return cursor->position < cursor->row_count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x20(%rax)
jne 0xdefc
movq -0x8(%rbp), %rax
movb $0x1, 0x20(%rax)
jmp 0xdf0c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x40, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
setb %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_count
size_t cx_row_group_cursor_batch_count(const struct cx_row_group_cursor *cursor)
{
    if (cursor->position >= cursor->row_count)
        return 0;
    size_t remaining = cursor->row_count - cursor->position;
    return remaining < CX_BATCH_SIZE ? remaining : CX_BATCH_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0xdf54
movq $0x0, -0x8(%rbp)
jmp 0xdf8c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x18(%rbp)
cmpq $0x40, -0x18(%rbp)
jae 0xdf79
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xdf84
movl $0x40, %eax
movq %rax, -0x20(%rbp)
jmp 0xdf84
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_nulls
const uint64_t *cx_row_group_cursor_batch_nulls(
    struct cx_row_group_cursor *cursor, size_t column_index, size_t *count)
{
    if (!cx_row_group_cursor_lazy_nulls_init(cursor, column_index))
        return NULL;
    struct cx_row_group_cursor_column *column = &cursor->columns[column_index];
    if (column->nulls.position <= cursor->position) {
        size_t skipped = cx_column_cursor_skip_bit(
            column->nulls.cursor, cursor->position - column->nulls.position);
        column->nulls.position += skipped;
        column->nulls.batch = cx_column_cursor_next_batch_bit(
            column->nulls.cursor, &column->nulls.count);
        column->nulls.position += column->nulls.count;
    }
    *count = column->nulls.count;
    return column->nulls.batch;
}

// 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
movq -0x18(%rbp), %rsi
callq 0xe090
testb $0x1, %al
jne 0xdfd2
movq $0x0, -0x8(%rbp)
jmp 0xe07f
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe064
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x28(%rax), %rsi
callq 0x5390
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
addq $0x18, %rsi
callq 0x56c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -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/row_group.c
// Function: cx_row_group_cursor_lazy_nulls_init
static bool cx_row_group_cursor_lazy_nulls_init(
    struct cx_row_group_cursor *cursor, size_t column_index)
{
    if (column_index >= cursor->column_count)
        return false;
    if (cursor->columns[column_index].nulls.cursor)
        return true;
    const struct cx_column *column =
        cx_row_group_nulls(cursor->row_group, column_index);
    if (!column)
        return false;
    cursor->columns[column_index].nulls.cursor = cx_column_cursor_new(column);
    return cursor->columns[column_index].nulls.cursor != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe0b7
movb $0x0, -0x1(%rbp)
jmp 0xe13b
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
je 0xe0d7
movb $0x1, -0x1(%rbp)
jmp 0xe13b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x56d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe0f8
movb $0x0, -0x1(%rbp)
jmp 0xe13b
movq -0x20(%rbp), %rdi
callq 0x5410
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, 0x20(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_bit
const uint64_t *cx_row_group_cursor_batch_bit(
    struct cx_row_group_cursor *cursor, size_t column_index, size_t *count)
{
    if (!cx_row_group_cursor_lazy_column_init(cursor, column_index))
        return NULL;
    struct cx_row_group_cursor_column *column = &cursor->columns[column_index];
    if (column->values.position <= cursor->position) {
        size_t skipped = cx_column_cursor_skip_bit(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_bit(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// 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
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe182
movq $0x0, -0x8(%rbp)
jmp 0xe229
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe20e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x5390
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x56c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_lazy_column_init
static bool cx_row_group_cursor_lazy_column_init(
    struct cx_row_group_cursor *cursor, size_t column_index)
{
    if (column_index >= cursor->column_count)
        return false;
    if (cursor->columns[column_index].values.cursor)
        return true;
    const struct cx_column *column =
        cx_row_group_column(cursor->row_group, column_index);
    if (!column)
        return false;
    cursor->columns[column_index].values.cursor = cx_column_cursor_new(column);
    return cursor->columns[column_index].values.cursor != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe267
movb $0x0, -0x1(%rbp)
jmp 0xe2e8
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0xe286
movb $0x1, -0x1(%rbp)
jmp 0xe2e8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5380
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe2a7
movb $0x0, -0x1(%rbp)
jmp 0xe2e8
movq -0x20(%rbp), %rdi
callq 0x5410
movq %rax, %rcx
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rdx
shlq $0x6, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_i32
const int32_t *cx_row_group_cursor_batch_i32(struct cx_row_group_cursor *cursor,
                                             size_t column_index, size_t *count)
{
    if (!cx_row_group_cursor_lazy_column_init(cursor, column_index))
        return NULL;
    struct cx_row_group_cursor_column *column = &cursor->columns[column_index];
    if (column->values.position <= cursor->position) {
        size_t skipped = cx_column_cursor_skip_i32(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_i32(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// 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
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe332
movq $0x0, -0x8(%rbp)
jmp 0xe3d9
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe3be
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x5140
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x5450
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)