LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/reader.c
// Function: cx_reader_query_thread
static void *cx_reader_query_thread(void *ptr)
{
    struct cx_reader_query_context *context = ptr;
    struct cx_row_group *row_group = NULL;
    struct cx_row_cursor *cursor = NULL;
    for (;;) {
        pthread_mutex_lock(&context->mutex);
        size_t position = context->position++;
        pthread_mutex_unlock(&context->mutex);
        if (position >= context->row_group_count)
            break;
        row_group = cx_row_group_reader_get(context->reader, position);
        if (!row_group)
            goto error;
        cursor = cx_row_cursor_new(row_group, context->predicate);
        if (!cursor)
            goto error;
        context->iter(cursor, &context->mutex, context->data);
        if (cx_row_cursor_error(cursor))
            goto error;
        cx_row_group_free(row_group);
        cx_row_cursor_free(cursor);
        row_group = NULL;
        cursor = NULL;
    }
    return NULL;
error:
    if (row_group)
        cx_row_group_free(row_group);
    if (cursor)
        cx_row_cursor_free(cursor);
    pthread_mutex_lock(&context->mutex);
    context->error = true;
    pthread_mutex_unlock(&context->mutex);
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
xorl %r12d, %r12d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x59c0
movq 0x10(%r14), %r13
leaq 0x1(%r13), %rax
movq %rax, 0x10(%r14)
movq %rbx, %rdi
callq 0x5570
movl $0x2, %ebp
cmpq 0x18(%r14), %r13
jae 0x9108
movq (%r14), %rdi
movq %r13, %rsi
callq 0x5a10
movl $0x4, %ebp
testq %rax, %rax
je 0x9100
movq %rax, %r12
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x52d0
testq %rax, %rax
je 0x9105
movq %rax, %r15
movq 0x28(%r14), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x20(%r14)
movq %r15, %rdi
callq 0x55f0
testb %al, %al
jne 0x9108
movq %r12, %rdi
callq 0x5860
movq %r15, %rdi
callq 0x5690
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %ebp, %ebp
jmp 0x9108
xorl %r12d, %r12d
jmp 0x9108
xorl %r15d, %r15d
testl %ebp, %ebp
je 0x9079
cmpl $0x2, %ebp
je 0x9149
cmpl $0x6, %ebp
je 0x9149
testq %r12, %r12
je 0x9127
movq %r12, %rdi
callq 0x5860
testq %r15, %r15
je 0x9134
movq %r15, %rdi
callq 0x5690
movq %rbx, %rdi
callq 0x59c0
movb $0x1, 0x30(%r14)
movq %rbx, %rdi
callq 0x5570
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/reader.c
// Function: cx_row_group_reader_column_compression
enum cx_compression_type cx_row_group_reader_column_compression(
    const struct cx_row_group_reader *reader, size_t column, int *level)
{
    assert(column < reader->columns.count);
    const struct cx_column_descriptor *descriptor =
        &reader->columns.descriptors[column];
    if (level)
        *level = descriptor->compression_level;
    return descriptor->compression;
}

// Assembly:
cmpq %rsi, 0x30(%rdi)
jbe 0x9296
leaq (%rsi,%rsi,2), %rax
shlq $0x3, %rax
addq 0x28(%rdi), %rax
testq %rdx, %rdx
je 0x9292
movl 0x10(%rax), %ecx
movl %ecx, (%rdx)
movl 0xc(%rax), %eax
retq
pushq %rax
leaq 0x3df8(%rip), %rdi      # 0xd096
leaq 0x3d4f(%rip), %rsi      # 0xcff4
leaq 0x3ecf(%rip), %rcx      # 0xd17b
movl $0x20d, %edx            # imm = 0x20D
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
callq 0x5470
cmpl $0x5, %eax
jne 0x9588
movq 0x20(%r14), %rdi
callq 0x50c0
testl %eax, %eax
jne 0x95a7
movq 0x20(%r14), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x5140
movq %rax, %r14
movq (%r15), %rax
movq %r14, %r15
addq %rax, %r15
testq %rbx, %rbx
setne %cl
testq %rax, %rax
setg %al
andb %cl, %al
cmpb $0x1, %al
jne 0x9564
movq %rbx, %r12
movq %r14, %rdi
callq 0x5250
addq %rax, %r14
incq %r14
decq %rbx
cmpq $0x1, %r12
je 0x9564
cmpq %r15, %r14
jb 0x9545
cmpq %r15, %r14
ja 0x95c6
xorl %eax, %eax
cmpq %r15, %r14
cmoveq %rax, %r14
testq %rbx, %rbx
cmovneq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3a34(%rip), %rdi      # 0xcfc3
leaq 0x3a5e(%rip), %rsi      # 0xcff4
leaq 0x3a60(%rip), %rcx      # 0xcffd
movl $0x1db, %edx            # imm = 0x1DB
callq 0x5350
leaq 0x3aa2(%rip), %rdi      # 0xd050
leaq 0x3a3f(%rip), %rsi      # 0xcff4
leaq 0x3a41(%rip), %rcx      # 0xcffd
movl $0x1dc, %edx            # imm = 0x1DC
callq 0x5350
leaq 0x3abb(%rip), %rdi      # 0xd088
leaq 0x3a20(%rip), %rsi      # 0xcff4
leaq 0x3a22(%rip), %rcx      # 0xcffd
movl $0x1e1, %edx            # imm = 0x1E1
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, %edi
movl $0x38, %esi
callq 0x5450
testq %rax, %rax
je 0x97c0
movq %rax, %rbx
movq %r14, (%rax)
movq %r14, %rdi
callq 0x5610
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x97b8
movq %rax, %r12
movq %r15, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5180
movl %eax, 0x30(%rbx)
movq $0x0, 0x20(%rbx)
movq $0x40, 0x28(%rbx)
movq %r12, %rdi
callq 0x5850
movb $0x0, 0x35(%rbx)
jmp 0x97c2
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq $0x0, 0x20(%rdi)
movq $0x40, 0x28(%rdi)
movq 0x8(%rdi), %rdi
callq 0x5850
movb $0x0, 0x35(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq $0x3e, %rax
ja 0x9833
movq 0x20(%rbx), %rdx
leal 0x1(%rax), %ecx
shrq %cl, %rdx
testq %rdx, %rdx
je 0x9833
bsfq %rdx, %rcx
addq %rcx, %rax
incq %rax
jmp 0x9848
movq %rbx, %rdi
callq 0x9854
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x9850
bsfq %rax, %rax
movq %rax, 0x28(%rbx)
movb $0x1, %al
jmp 0x9852
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
leaq 0x8(%rsp), %r15
movq 0x8(%rbx), %rdi
callq 0x5930
testb %al, %al
je 0x98d4
cmpl $0x1, 0x30(%rbx)
jne 0x98b3
movq 0x8(%rbx), %rdi
callq 0x59f0
movq %rax, 0x8(%rsp)
movq $-0x1, (%rsp)
cmpq $0x3f, %rax
ja 0x98cd
movq $-0x1, %rdx
movl %eax, %ecx
shlq %cl, %rdx
notq %rdx
movq %rdx, (%rsp)
jmp 0x98cd
movq 0x10(%rbx), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x5670
testb %al, %al
je 0x98e2
cmpq $0x0, (%rsp)
je 0x986f
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, 0x35(%rbx)
xorl %eax, %eax
jmp 0x98d8
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x30(%rdi), %eax
cmpl $-0x1, %eax
je 0x991f
movq %rdi, %rbx
cmpl $0x1, %eax
jne 0x9927
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5430
xorl %r14d, %r14d
jmp 0x99b8
movq $0x0, 0x20(%rbx)
movq $0x40, 0x28(%rbx)
movq 0x8(%rbx), %rdi
callq 0x5850
movb $0x0, 0x35(%rbx)
xorl %r14d, %r14d
movabsq $0x5555555555555555, %r15 # imm = 0x5555555555555555
movabsq $0x3333333333333333, %r12 # imm = 0x3333333333333333
movabsq $0xf0f0f0f0f0f0f0f, %r13 # imm = 0xF0F0F0F0F0F0F0F
movabsq $0x101010101010101, %rbp # imm = 0x101010101010101
movq %rbx, %rdi
callq 0x9854
testq %rax, %rax
je 0x99b3
movq %rax, %rcx
shrq %rcx
andq %r15, %rcx
movq %rax, %rdx
subq %rcx, %rdx
movq %rdx, %rcx
andq %r12, %rcx
shrq $0x2, %rdx
andq %r12, %rdx
addq %rcx, %rdx
movq %rdx, %rcx
shrq $0x4, %rcx
addq %rdx, %rcx
andq %r13, %rcx
imulq %rbp, %rcx
shrq $0x38, %rcx
addq %rcx, %r14
testq %rax, %rax
jne 0x996f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9a1f
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x50d0
movq %rax, %rcx
cmpq $0x0, (%r15)
setne %dl
testq %rax, %rax
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0x9a15
movq (%rcx), %rcx
movl 0x28(%r14), %edx
btq %rdx, %rcx
setb (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x37c8(%rip), %rdi      # 0xd1ee
leaq 0x37d2(%rip), %rsi      # 0xd1ff
leaq 0x37d1(%rip), %rcx      # 0xd205
movl $0x71, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9a93
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5500
movq %rax, %rcx
cmpq $0x0, (%r15)
setne %dl
testq %rax, %rax
setne %al
andb %dl, %al
cmpb $0x1, %al
jne 0x9a89
movq (%rcx), %rcx
movl 0x28(%r14), %edx
btq %rdx, %rcx
setb (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3754(%rip), %rdi      # 0xd1ee
leaq 0x375e(%rip), %rsi      # 0xd1ff
leaq 0x37a9(%rip), %rcx      # 0xd251
movl $0x7f, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9b02
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5800
testq %rax, %rax
setne %dl
cmpq $0x0, (%r15)
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x9af6
movq 0x28(%r14), %rdx
movl (%rax,%rdx,4), %eax
movl %eax, (%rbx)
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x36e5(%rip), %rdi      # 0xd1ee
leaq 0x36ef(%rip), %rsi      # 0xd1ff
leaq 0x3785(%rip), %rcx      # 0xd29c
movl $0x8d, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9b73
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x58b0
testq %rax, %rax
setne %dl
cmpq $0x0, (%r15)
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x9b67
movq 0x28(%r14), %rdx
movq (%rax,%rdx,8), %rax
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3674(%rip), %rdi      # 0xd1ee
leaq 0x367e(%rip), %rsi      # 0xd1ff
leaq 0x3761(%rip), %rcx      # 0xd2e9
movl $0x9a, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9be6
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5810
testq %rax, %rax
setne %dl
cmpq $0x0, (%r15)
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x9bda
movq 0x28(%r14), %rdx
movss (%rax,%rdx,4), %xmm0
movss %xmm0, (%rbx)
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3601(%rip), %rdi      # 0xd1ee
leaq 0x360b(%rip), %rsi      # 0xd1ff
leaq 0x373b(%rip), %rcx      # 0xd336
movl $0xa7, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9c59
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x5600
testq %rax, %rax
setne %dl
cmpq $0x0, (%r15)
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x9c4d
movq 0x28(%r14), %rdx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rbx)
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x358e(%rip), %rdi      # 0xd1ee
leaq 0x3598(%rip), %rsi      # 0xd1ff
leaq 0x3713(%rip), %rcx      # 0xd381
movl $0xb4, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x20(%rdi)
je 0x9cd7
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x55d0
testq %rax, %rax
setne %dl
cmpq $0x0, (%r15)
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x9ccb
movq 0x28(%r14), %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %rsi
movq %rsi, (%rbx)
movq 0x8(%rax,%rdx), %rax
movq %rax, 0x8(%rbx)
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3510(%rip), %rdi      # 0xd1ee
leaq 0x351a(%rip), %rsi      # 0xd1ff
leaq 0x36e1(%rip), %rcx      # 0xd3cd
movl $0xc1, %edx
callq 0x5350
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl $0x20, %edi
callq 0x5590
testq %rax, %rax
je 0x9d37
movq %rax, %rbx
movl $0x480, %edi            # imm = 0x480
callq 0x5590
movq %rax, (%rbx)
testq %rax, %rax
je 0x9d2f
movq $0x0, 0x8(%rbx)
movq $0x8, 0x10(%rbx)
jmp 0x9d39
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x9da7
movl $0x88, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
cmpb $0x1, (%r12,%r14)
jne 0x9d83
movq -0x78(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x9d72
callq 0x58f0
movq -0x38(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x9d97
callq 0x58f0
jmp 0x9d97
movq -0x80(%r12,%r14), %rdi
callq 0x54f0
movq -0x40(%r12,%r14), %rdi
callq 0x54f0
incq %r15
addq $0x90, %r14
cmpq 0x8(%rbx), %r15
jb 0x9d59
movq (%rbx), %rdi
callq 0x5080
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_add_column
bool cx_row_group_add_column(struct cx_row_group *row_group,
                             struct cx_column *column, struct cx_column *nulls)
{
    if (!column)
        return false;
    size_t row_count = cx_column_count(column);
    if (row_count != cx_column_count(nulls) ||
        cx_column_type(nulls) != CX_COLUMN_BIT)
        return false;
    if (row_group->count && row_group->row_count != row_count)
        return false;
    struct cx_index *index = cx_index_new(column);
    struct cx_index *nulls_index = cx_index_new(nulls);
    if (!index || !nulls_index)
        goto error;
    if (!cx_row_group_ensure_column_size(row_group))
        goto error;
    struct cx_row_group_column *row_group_column =
        &row_group->columns[row_group->count++];
    row_group_column->type = cx_column_type(column);
    row_group_column->encoding = cx_column_encoding(column);
    row_group_column->values.column = column;
    row_group_column->values.index = index;
    row_group_column->lazy = false;
    row_group_column->nulls.column = nulls;
    row_group_column->nulls.index = nulls_index;
    row_group->row_count = row_count;
    return true;
error:
    if (index)
        cx_index_free(index);
    if (nulls_index)
        cx_index_free(nulls_index);
    return false;
}

// Assembly:
testq %rsi, %rsi
je 0x9e13
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x53d0
movq %rax, %r12
movq %r14, %rdi
callq 0x53d0
cmpq %rax, %r12
jne 0x9e02
movq %r14, %rdi
callq 0x5470
testl %eax, %eax
je 0x9e16
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
cmpq $0x0, 0x8(%rbx)
je 0x9e23
cmpq %r12, 0x18(%rbx)
jne 0x9e02
movq %r15, %rdi
callq 0x5300
movq %rax, %rbp
movq %r14, %rdi
callq 0x5300
movq %rax, %r13
testq %rbp, %rbp
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9ec9
movq %rbx, %rdi
callq 0x9eec
testb %al, %al
je 0x9ec9
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %r13, 0x10(%rsp)
leaq (%rax,%rax,8), %r13
shlq $0x4, %r13
movq %r15, %rdi
callq 0x5470
movq 0x8(%rsp), %rcx
movl %eax, (%rcx,%r13)
movq %r15, %rdi
callq 0x50c0
movq 0x8(%rsp), %rcx
movl %eax, 0x4(%rcx,%r13)
movq %r15, 0x10(%rcx,%r13)
movq %rbp, 0x8(%rcx,%r13)
movb $0x0, 0x88(%rcx,%r13)
movq %r14, 0x50(%rcx,%r13)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rcx,%r13)
movq %r12, 0x18(%rbx)
movb $0x1, %al
jmp 0x9e04
testq %rbp, %rbp
je 0x9ed6
movq %rbp, %rdi
callq 0x54f0
testq %r13, %r13
je 0x9e02
movq %r13, %rdi
callq 0x54f0
jmp 0x9e02
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
movb $0x1, %bl
cmpq %rax, 0x8(%rdi)
jne 0x9f2d
testq %rax, %rax
jle 0x9f35
movq %rax, %r15
addq %rax, %r15
je 0x9f35
movq %rdi, %r14
movq (%rdi), %rdi
shlq $0x5, %rax
leaq (%rax,%rax,8), %rsi
callq 0x56d0
testq %rax, %rax
je 0x9f2b
movq %rax, (%r14)
movq %r15, 0x10(%r14)
jmp 0x9f2d
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x371e(%rip), %rdi      # 0xd65a
leaq 0x3516(%rip), %rsi      # 0xd459
leaq 0x3737(%rip), %rcx      # 0xd681
movl $0x5b, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
movq (%rax), %r12
movq 0x10(%rdx), %rax
cmpq (%rax), %r12
jne 0x9f74
movq %rdx, %r14
cmpl $0x0, (%rdx)
je 0x9f82
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x9f95
cmpq %r12, 0x18(%rbx)
jne 0x9f74
movq %rbx, %rdi
callq 0x9eec
testb %al, %al
je 0x9f74
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
movl (%r15), %edx
movl %edx, (%rax,%rcx)
movl 0x4(%r15), %edx
movl %edx, 0x4(%rax,%rcx)
movq 0x10(%r15), %rdx
movq %rdx, 0x8(%rax,%rcx)
xorl %edx, %edx
movq %rdx, 0x10(%rax,%rcx)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm0, 0x18(%rax,%rcx)
movups %xmm1, 0x28(%rax,%rcx)
movups %xmm2, 0x38(%rax,%rcx)
movb $0x1, 0x88(%rax,%rcx)
movq %rdx, 0x50(%rax,%rcx)
movq 0x10(%r14), %rdx
movq %rdx, 0x48(%rax,%rcx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, 0x58(%rax,%rcx)
movups %xmm1, 0x68(%rax,%rcx)
movups %xmm2, 0x78(%rax,%rcx)
movq %r12, 0x18(%rbx)
movb $0x1, %al
jmp 0x9f76
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpq %rsi, 0x8(%rdi)
jbe 0xa162
movq (%rdi), %rax
leaq (%rsi,%rsi,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rbx
cmpb $0x1, 0x88(%rax,%rcx)
jne 0xa158
cmpq $0x0, 0x10(%rbx)
jne 0xa158
leaq 0x8(%rbx), %rdi
callq 0xa181
testb %al, %al
je 0xa15e
movq 0x10(%rbx), %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0xa15c
leaq 0x32d7(%rip), %rdi      # 0xd440
leaq 0x32e9(%rip), %rsi      # 0xd459
leaq 0x3442(%rip), %rcx      # 0xd5b9
movl $0xee, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
je 0xa1d3
cmpq $0x0, 0x30(%rbx)
je 0xa1d3
movl 0x10(%rbx), %edi
movl 0x14(%rbx), %esi
movq 0x38(%rbx), %rcx
movq (%rbx), %rax
movq (%rax), %r8
movq %rsp, %rdx
callq 0x5a20
movq %rax, %r14
testq %rax, %rax
je 0xa1ff
movl 0x18(%rbx), %edi
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq (%rsp), %rcx
movq 0x38(%rbx), %r8
callq 0x5550
testb %al, %al
jne 0xa1f4
jmp 0xa1ff
movl 0x10(%rbx), %edi
movl 0x14(%rbx), %esi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rcx
movq (%rbx), %rax
movq (%rax), %r8
callq 0x56a0
movq %rax, %r14
testq %rax, %rax
je 0xa1fc
movq %r14, 0x8(%rbx)
movb $0x1, %al
jmp 0xa20e
xorl %r14d, %r14d
testq %r14, %r14
je 0xa20c
movq %r14, %rdi
callq 0x58f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
cmpq %rsi, 0x8(%rdi)
jbe 0xa254
movq (%rdi), %rax
leaq (%rsi,%rsi,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rbx
cmpb $0x1, 0x88(%rax,%rcx)
jne 0xa24a
cmpq $0x0, 0x50(%rbx)
jne 0xa24a
leaq 0x48(%rbx), %rdi
callq 0xa181
testb %al, %al
je 0xa250
movq 0x50(%rbx), %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0xa24e
leaq 0x31e5(%rip), %rdi      # 0xd440
leaq 0x31f7(%rip), %rsi      # 0xd459
leaq 0x33a1(%rip), %rcx      # 0xd60a
movl $0xf9, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq %r14, %rsi
shlq $0x6, %rsi
orq $0x28, %rsi
movl $0x1, %edi
callq 0x5450
testq %rax, %rax
je 0xa2b0
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
testq %r14, %r14
je 0xa2b4
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
jmp 0xa2b6
xorl %eax, %eax
jmp 0xa2ba
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb $0x0, 0x20(%rdi)
movq $0x0, 0x18(%rdi)
cmpq $0x0, 0x8(%rdi)
je 0xa334
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorl %r15d, %r15d
movq -0x20(%r14), %rdi
testq %rdi, %rdi
je 0xa304
callq 0x5870
leaq -0x20(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa31b
callq 0x5870
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
incq %r15
addq $0x40, %r14
cmpq 0x8(%rbx), %r15
jb 0xa2f6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x0, 0x20(%rdi)
je 0xa342
addq $0x40, 0x18(%rdi)
jmp 0xa346
movb $0x1, 0x20(%rdi)
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
setb %al
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq %rsi, 0x8(%rdi)
jbe 0xa3dc
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %r12
shlq $0x6, %r12
leaq (%rdi,%r12), %r15
addq $0x48, %r15
cmpq $0x0, (%r15)
je 0xa3df
movq 0x18(%r14), %rsi
subq 0x50(%r14,%r12), %rsi
jb 0xa3cf
movq (%r15), %rdi
callq 0x5340
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5620
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa3fe
xorl %eax, %eax
retq
movq (%r14), %rdi
callq 0x5640
testq %rax, %rax
je 0xa3fc
movq %rax, %rdi
callq 0x53b0
movq %rax, (%r15)
testq %rax, %rax
jne 0xa3a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa467
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa45a
movq (%r15), %rdi
callq 0x5340
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5620
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa469
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq %rsi, 0x8(%rdi)
jbe 0xa4b4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
shlq $0x6, %r14
movb $0x1, %al
cmpq $0x0, 0x28(%rdi,%r14)
jne 0xa4b9
movq (%rbx), %rdi
callq 0x5330
testq %rax, %rax
je 0xa4b7
addq %r14, %rbx
addq $0x28, %rbx
movq %rax, %rdi
callq 0x53b0
movq %rax, (%rbx)
testq %rax, %rax
setne %al
jmp 0xa4b9
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa51e
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa511
movq (%r15), %rdi
callq 0x5110
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x53f0
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa520
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_i64
const int64_t *cx_row_group_cursor_batch_i64(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_i64(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_i64(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa583
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa576
movq (%r15), %rdi
callq 0x5070
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5260
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa585
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_flt
const float *cx_row_group_cursor_batch_flt(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_flt(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_flt(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa5e8
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa5db
movq (%r15), %rdi
callq 0x5160
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5370
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa5ea
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_dbl
const double *cx_row_group_cursor_batch_dbl(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_dbl(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_dbl(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa64d
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa640
movq (%r15), %rdi
callq 0x52b0
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x51b0
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa64f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_batch_str
const struct cx_string *cx_row_group_cursor_batch_str(
    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_str(
            column->values.cursor, cursor->position - column->values.position);
        column->values.position += skipped;
        column->values.batch = cx_column_cursor_next_batch_str(
            column->values.cursor, &column->values.count);
        column->values.position += column->values.count;
    }
    *count = column->values.count;
    return column->values.batch;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0xa46f
testb %al, %al
je 0xa6b2
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jb 0xa6a5
movq (%r15), %rdi
callq 0x5130
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5400
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rax
addq %rax, 0x8(%r15)
movq 0x18(%r15), %rax
movq %rax, (%rbx)
movq 0x10(%r15), %rax
jmp 0xa6b4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/writer.c
// Function: cx_writer_new
struct cx_writer *cx_writer_new(const char *path, size_t row_group_size)
{
    struct cx_writer *writer = calloc(1, sizeof(*writer));
    if (!writer)
        return NULL;
    writer->writer = cx_row_group_writer_new(path);
    if (!writer->writer)
        goto error;
    writer->row_group_size = row_group_size;
    return writer;
error:
    free(writer);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x5450
testq %rax, %rax
je 0xa6fc
movq %rax, %rbx
movq %r15, %rdi
callq 0x5910
movq %rax, (%rbx)
testq %rax, %rax
je 0xa6f4
movq %r14, 0x10(%rbx)
jmp 0xa6fe
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_new
struct cx_row_group_writer *cx_row_group_writer_new(const char *path)
{
    struct cx_row_group_writer *writer = calloc(1, sizeof(*writer));
    if (!writer)
        return NULL;
    writer->strings.column = cx_column_new(CX_COLUMN_STR, CX_ENCODING_NONE);
    if (!writer->strings.column)
        goto error;
    writer->file = fopen(path, "wb");
    if (!writer->file)
        goto error;
    return writer;
error:
    if (writer->strings.column)
        cx_column_free(writer->strings.column);
    free(writer);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x60, %esi
callq 0x5450
testq %rax, %rax
je 0xa76a
movq %rax, %rbx
movl $0x5, %edi
xorl %esi, %esi
callq 0x57f0
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0xa762
movq %rax, %r15
leaq 0x2f79(%rip), %rsi      # 0xd6be
movq %r14, %rdi
callq 0x54c0
movq %rax, (%rbx)
testq %rax, %rax
jne 0xa76c
testq %r15, %r15
je 0xa762
movq %r15, %rdi
callq 0x58f0
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/chriso[P]columnix/lib/writer.c
// Function: cx_writer_free
void cx_writer_free(struct cx_writer *writer)
{
    if (writer->columns) {
        for (size_t i = 0; i < writer->column_count; i++) {
            cx_column_free(writer->columns[i].values);
            cx_column_free(writer->columns[i].nulls);
        }
        free(writer->columns);
    }
    cx_row_group_writer_free(writer->writer);
    free(writer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xa7c2
cmpq $0x0, 0x18(%rbx)
je 0xa7b9
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x58f0
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x58f0
incq %r15
addq $0x10, %r14
cmpq 0x18(%rbx), %r15
jb 0xa791
movq 0x8(%rbx), %rdi
callq 0x5080
movq (%rbx), %rdi
callq 0x5030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5080