LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x9aca
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 0x9abe
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 0x373d(%rip), %rdi      # 0xd20e
leaq 0x3747(%rip), %rsi      # 0xd21f
leaq 0x3877(%rip), %rcx      # 0xd356
movl $0xa7, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/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 0x9b3d
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 0x9b31
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 0x36ca(%rip), %rdi      # 0xd20e
leaq 0x36d4(%rip), %rsi      # 0xd21f
leaq 0x384f(%rip), %rcx      # 0xd3a1
movl $0xb4, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/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 0x9bbb
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 0x9baf
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 0x364c(%rip), %rdi      # 0xd20e
leaq 0x3656(%rip), %rsi      # 0xd21f
leaq 0x381d(%rip), %rcx      # 0xd3ed
movl $0xc1, %edx
callq 0x5350
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x9c1b
movq %rax, %rbx
movl $0x480, %edi            # imm = 0x480
callq 0x5590
movq %rax, (%rbx)
testq %rax, %rax
je 0x9c13
movq $0x0, 0x8(%rbx)
movq $0x8, 0x10(%rbx)
jmp 0x9c1d
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9c8b
movl $0x88, %r14d
xorl %r15d, %r15d
movq (%rbx), %r12
cmpb $0x1, (%r12,%r14)
jne 0x9c67
movq -0x78(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x9c56
callq 0x58f0
movq -0x38(%r12,%r14), %rdi
testq %rdi, %rdi
je 0x9c7b
callq 0x58f0
jmp 0x9c7b
movq -0x80(%r12,%r14), %rdi
callq 0x54f0
movq -0x40(%r12,%r14), %rdi
callq 0x54f0
incq %r15
addq $0x90, %r14
cmpq 0x8(%rbx), %r15
jb 0x9c3d
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_O3/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 0x9cf7
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 0x9ce6
movq %r14, %rdi
callq 0x5470
testl %eax, %eax
je 0x9cfa
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 0x9d07
cmpq %r12, 0x18(%rbx)
jne 0x9ce6
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 0x9dad
movq %rbx, %rdi
callq 0x9dd0
testb %al, %al
je 0x9db2
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 0x9ce8
testq %rbp, %rbp
je 0x9dba
movq %rbp, %rdi
callq 0x54f0
testq %r13, %r13
je 0x9ce6
movq %r13, %rdi
callq 0x54f0
jmp 0x9ce6
// File: /workspace/github_c_makefile_star2_O3/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 0x8(%rdi), %rax
movb $0x1, %bl
cmpq 0x10(%rdi), %rax
jne 0x9e11
testq %rax, %rax
jle 0x9e19
movq %rax, %r15
addq %rax, %r15
je 0x9e19
movq %rdi, %r14
movq (%rdi), %rdi
shlq $0x5, %rax
leaq (%rax,%rax,8), %rsi
callq 0x56d0
testq %rax, %rax
je 0x9e0f
movq %rax, (%r14)
movq %r15, 0x10(%r14)
jmp 0x9e11
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x385a(%rip), %rdi      # 0xd67a
leaq 0x3652(%rip), %rsi      # 0xd479
leaq 0x3873(%rip), %rcx      # 0xd6a1
movl $0x5b, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/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 0x9e58
movq %rdx, %r14
cmpl $0x0, (%rdx)
je 0x9e66
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 0x9e79
cmpq %r12, 0x18(%rbx)
jne 0x9e58
movq %rbx, %rdi
callq 0x9dd0
testb %al, %al
je 0x9e58
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
leaq (%rcx,%rcx,8), %rcx
shlq $0x4, %rcx
movq (%r15), %rdx
movq %rdx, (%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 0x9e5a
// File: /workspace/github_c_makefile_star2_O3/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 0xa03f
movq (%rdi), %rax
leaq (%rsi,%rsi,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rbx
cmpb $0x1, 0x88(%rax,%rcx)
jne 0xa035
cmpq $0x0, 0x10(%rbx)
jne 0xa035
leaq 0x8(%rbx), %rdi
callq 0xa05e
testb %al, %al
je 0xa03b
movq 0x10(%rbx), %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0xa039
leaq 0x341a(%rip), %rdi      # 0xd460
leaq 0x342c(%rip), %rsi      # 0xd479
leaq 0x3585(%rip), %rcx      # 0xd5d9
movl $0xee, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/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)
movq 0x30(%rdi), %rcx
je 0xa0bc
testq %rcx, %rcx
je 0xa0ba
movl 0x10(%rbx), %edi
movl 0x14(%rbx), %esi
movq 0x38(%rbx), %rcx
movq (%rbx), %rax
movq (%rax), %r8
movq %rsp, %rdx
callq 0x5a20
testq %rax, %rax
je 0xa0e1
movq %rax, %r14
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 0xa0d9
movq %r14, %rdi
callq 0x58f0
jmp 0xa0e1
xorl %ecx, %ecx
movl 0x10(%rbx), %edi
movl 0x14(%rbx), %esi
movq 0x28(%rbx), %rdx
movq (%rbx), %rax
movq (%rax), %r8
callq 0x56a0
movq %rax, %r14
testq %rax, %rax
je 0xa0e1
movq %r14, 0x8(%rbx)
movb $0x1, %al
jmp 0xa0e3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa129
movq (%rdi), %rax
leaq (%rsi,%rsi,8), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rbx
cmpb $0x1, 0x88(%rax,%rcx)
jne 0xa11f
cmpq $0x0, 0x50(%rbx)
jne 0xa11f
leaq 0x48(%rbx), %rdi
callq 0xa05e
testb %al, %al
je 0xa125
movq 0x50(%rbx), %rax
popq %rbx
retq
xorl %eax, %eax
jmp 0xa123
leaq 0x3330(%rip), %rdi      # 0xd460
leaq 0x3342(%rip), %rsi      # 0xd479
leaq 0x34ec(%rip), %rcx      # 0xd62a
movl $0xf9, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/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 0xa18b
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
testq %r14, %r14
je 0xa185
movq (%rbx), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
jmp 0xa187
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa205
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
xorl %r15d, %r15d
movq -0x20(%r14), %rdi
testq %rdi, %rdi
je 0xa1d5
callq 0x5870
leaq -0x20(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xa1ec
callq 0x5870
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
incq %r15
addq $0x40, %r14
cmpq 0x8(%rbx), %r15
jb 0xa1c7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa21a
movq 0x18(%rdi), %rax
addq $0x40, %rax
movq %rax, 0x18(%rdi)
jmp 0xa222
movb $0x1, 0x20(%rdi)
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
setb %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa28b
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rax
shlq $0x6, %rax
leaq (%rdi,%rax), %r15
addq $0x48, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa2b4
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa28e
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa2af
xorl %eax, %eax
retq
callq 0x5340
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5620
movq %rax, 0x10(%r15)
movq 0x18(%r15), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
jmp 0xa2d6
movq (%r14), %rdi
callq 0x5640
testq %rax, %rax
je 0xa2d4
movq %rax, %rdi
callq 0x53b0
movq %rax, %rdi
movq %rax, (%r15)
testq %rax, %rax
jne 0xa277
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa312
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa316
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa33a
xorl %eax, %eax
jmp 0xa33d
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa388
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
shlq $0x6, %r14
movb $0x1, %al
cmpq $0x0, 0x28(%rdi,%r14)
jne 0xa38d
movq (%rbx), %rdi
callq 0x5330
testq %rax, %rax
je 0xa38b
addq %r14, %rbx
addq $0x28, %rbx
movq %rax, %rdi
callq 0x53b0
movq %rax, (%rbx)
testq %rax, %rax
setne %al
jmp 0xa38d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa3cb
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa3cf
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa3f3
xorl %eax, %eax
jmp 0xa3f6
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa432
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa436
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa45a
xorl %eax, %eax
jmp 0xa45d
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa499
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa49d
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa4c1
xorl %eax, %eax
jmp 0xa4c4
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa500
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa504
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa528
xorl %eax, %eax
jmp 0xa52b
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa343
testb %al, %al
je 0xa567
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0xa56b
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0xa58f
xorl %eax, %eax
jmp 0xa592
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), %rcx
addq %rcx, 0x8(%r15)
movq %rcx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa5d8
movq %rax, %rbx
movq %r15, %rdi
callq 0x5910
movq %rax, (%rbx)
testq %rax, %rax
je 0xa5d0
movq %r14, 0x10(%rbx)
jmp 0xa5da
movq %rbx, %rdi
callq 0x5080
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa641
movq %rax, %rbx
movl $0x5, %edi
xorl %esi, %esi
callq 0x57f0
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0xa639
movq %rax, %r15
leaq 0x30bd(%rip), %rsi      # 0xd6de
movq %r14, %rdi
callq 0x54c0
movq %rax, (%rbx)
testq %rax, %rax
jne 0xa643
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_O3/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
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xa69b
cmpq $0x0, 0x18(%rbx)
je 0xa696
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 0xa66a
movq 0x8(%rbx), %rdi
callq 0x5080
movq (%rbx), %rdi
callq 0x5030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_free
void cx_row_group_writer_free(struct cx_row_group_writer *writer)
{
    if (writer->strings.metadata)
        free(writer->strings.metadata);
    cx_column_free(writer->strings.column);
    if (writer->columns.descriptors)
        free(writer->columns.descriptors);
    if (writer->row_groups.headers)
        free(writer->row_groups.headers);
    fclose(writer->file);
    free(writer);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0xa6c2
callq 0x5080
movq 0x38(%rbx), %rdi
callq 0x58f0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xa6d9
callq 0x5080
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xa6e7
callq 0x5080
movq (%rbx), %rdi
callq 0x51f0
movq %rbx, %rdi
popq %rbx
jmp 0x5080
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_metadata
bool cx_row_group_writer_metadata(struct cx_row_group_writer *writer,
                                  const char *metadata)
{
    size_t size = strlen(metadata) + 1;
    char *buf;
    if (writer->strings.metadata)
        buf = realloc(writer->strings.metadata, size);
    else
        buf = malloc(size);
    if (!buf)
        return false;
    memcpy(buf, metadata, size);
    writer->strings.metadata = buf;
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5250
movq %rax, %r15
incq %r15
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xa72f
movq %r15, %rsi
callq 0x56d0
jmp 0xa737
movq %r15, %rdi
callq 0x5590
movq %rax, %r12
testq %rax, %rax
je 0xa751
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x54e0
movq %r12, 0x48(%rbx)
testq %r12, %r12
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_add_column
bool cx_row_group_writer_add_column(struct cx_row_group_writer *writer,
                                    const char *name, enum cx_column_type type,
                                    enum cx_encoding_type encoding,
                                    enum cx_compression_type compression,
                                    int level)
{
    if (writer->header_written)
        return false;

    if (!writer->columns.count) {
        writer->columns.descriptors =
            malloc(sizeof(*writer->columns.descriptors) * 8);
        if (!writer->columns.descriptors)
            return false;
        writer->columns.size = 8;
    } else if (writer->columns.count == writer->columns.size) {
        size_t new_size = writer->columns.size * 2;
        assert(new_size && new_size > writer->columns.size);
        struct cx_column_descriptor *descriptors = realloc(
            writer->columns.descriptors, new_size * sizeof(*descriptors));
        if (!descriptors)
            return false;
        writer->columns.descriptors = descriptors;
        writer->columns.size = new_size;
    }

    struct cx_column_descriptor *descriptor =
        &writer->columns.descriptors[writer->columns.count++];
    memset(descriptor, 0, sizeof(*descriptor));
    descriptor->type = type;
    descriptor->encoding = encoding;
    descriptor->compression = compression;
    descriptor->compression_level = level;

    return cx_row_group_writer_add_string(writer, name, &descriptor->name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0x58(%rdi)
jne 0xa888
movl %r8d, %r15d
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xa7ff
cmpq 0x18(%rbx), %rax
jne 0xa831
movl %r9d, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
testq %rax, %rax
jle 0xa899
movq %rax, %rbp
addq %rax, %rbp
je 0xa899
movq 0x8(%rbx), %rdi
shlq $0x4, %rax
leaq (%rax,%rax,2), %rsi
callq 0x56d0
testq %rax, %rax
je 0xa888
movq %rax, %r14
movq %rax, 0x8(%rbx)
movq %rbp, 0x18(%rbx)
movq 0x10(%rbx), %rax
movq 0x10(%rsp), %rsi
jmp 0xa82a
movl %r9d, 0xc(%rsp)
movq %rsi, %rbp
movl $0xc0, %edi
callq 0x5590
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xa888
movq %rax, %r14
movq $0x8, 0x18(%rbx)
xorl %eax, %eax
movq %rbp, %rsi
movl 0xc(%rsp), %r9d
jmp 0xa835
movq 0x8(%rbx), %r14
leaq 0x1(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq (%rax,%rax,2), %rbp
xorps %xmm0, %xmm0
movups %xmm0, (%r14,%rbp,8)
movq $0x0, 0x10(%r14,%rbp,8)
movl %r13d, 0x4(%r14,%rbp,8)
movl %r12d, 0x8(%r14,%rbp,8)
movl %r15d, 0xc(%r14,%rbp,8)
movl %r9d, 0x10(%r14,%rbp,8)
movq 0x38(%rbx), %rdi
callq 0x5210
testb %al, %al
je 0xa888
leaq (%r14,%rbp,8), %rax
movq 0x40(%rbx), %rcx
movl %ecx, (%rax)
incq %rcx
movq %rcx, 0x40(%rbx)
movb $0x1, %al
jmp 0xa88a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e41(%rip), %rdi      # 0xd6e1
leaq 0x2e66(%rip), %rsi      # 0xd70d
leaq 0x2e68(%rip), %rcx      # 0xd716
movl $0x149, %edx            # imm = 0x149
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_bit
bool cx_writer_put_bit(struct cx_writer *writer, size_t column_index,
                       bool value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xa910
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movzbl %bpl, %esi
callq 0x54a0
testb %al, %al
je 0xa910
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xa912
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa912
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_check
static bool cx_writer_put_check(struct cx_writer *writer, size_t column_index)
{
    if (column_index >= writer->column_count)
        return false;
    if (column_index == 0 && writer->position == writer->row_group_size)
        if (!cx_writer_flush_row_group(writer))
            return false;
    if (!writer->columns)
        if (!cx_writer_ensure_columns(writer))
            return false;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq %rsi, 0x18(%rdi)
jbe 0xaa2d
movq %rdi, %rbx
testq %rsi, %rsi
jne 0xa953
movq 0x20(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0xa953
movq %rbx, %rdi
callq 0xace8
testb %al, %al
je 0xaa2d
movb $0x1, %bpl
cmpq $0x0, 0x8(%rbx)
jne 0xaa2f
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xaa3a
movl $0x10, %esi
callq 0x5450
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xaa2d
movl $0x8, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rax), %rax
movl -0x4(%rax,%r14), %edi
movl (%rax,%r14), %esi
callq 0x57f0
movq 0x8(%rbx), %rdi
movq %rax, (%rdi,%r15)
testq %rax, %rax
je 0xa9dd
xorl %edi, %edi
xorl %esi, %esi
callq 0x57f0
movq 0x8(%rbx), %rdi
movq %rax, 0x8(%rdi,%r15)
testq %rax, %rax
je 0xa9dd
incq %r12
addq $0x10, %r15
addq $0x18, %r14
cmpq 0x18(%rbx), %r12
jb 0xa991
jmp 0xaa2f
cmpq $0x0, 0x18(%rbx)
je 0xaa20
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0xaa00
callq 0x58f0
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
testq %rdi, %rdi
je 0xaa0f
callq 0x58f0
incq %r15
addq $0x10, %r14
cmpq 0x18(%rbx), %r15
jb 0xa9ea
movq 0x8(%rbx), %rdi
callq 0x5080
movq $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2df3(%rip), %rdi      # 0xd834
leaq 0x2cc5(%rip), %rsi      # 0xd70d
leaq 0x2e0e(%rip), %rcx      # 0xd85d
movl $0x80, %edx
callq 0x5350
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_i32
bool cx_writer_put_i32(struct cx_writer *writer, size_t column_index,
                       int32_t value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_i32(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xaaaf
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movl %ebp, %esi
callq 0x5520
testb %al, %al
je 0xaaaf
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xaab1
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xaab1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_i64
bool cx_writer_put_i64(struct cx_writer *writer, size_t column_index,
                       int64_t value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_i64(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xab17
movq 0x8(%rbx), %rax
movq %r14, %r12
shlq $0x4, %r12
movq (%rax,%r12), %rdi
movq %r15, %rsi
callq 0x56b0
testb %al, %al
je 0xab17
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xab19
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xab19
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_flt
bool cx_writer_put_flt(struct cx_writer *writer, size_t column_index,
                       float value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_flt(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movss %xmm0, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xab82
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movss 0x4(%rsp), %xmm0
callq 0x5780
testb %al, %al
je 0xab82
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xab84
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xab84
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_dbl
bool cx_writer_put_dbl(struct cx_writer *writer, size_t column_index,
                       double value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_dbl(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xabed
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movsd (%rsp), %xmm0
callq 0x5460
testb %al, %al
je 0xabed
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xabef
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xabef
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_str
bool cx_writer_put_str(struct cx_writer *writer, size_t column_index,
                       const char *value)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_str(writer->columns[column_index].values, value))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, false))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xac55
movq 0x8(%rbx), %rax
movq %r14, %r12
shlq $0x4, %r12
movq (%rax,%r12), %rdi
movq %r15, %rsi
callq 0x5210
testb %al, %al
je 0xac55
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54a0
testb %al, %al
je 0xac57
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xac57
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chriso[P]columnix/lib/writer.c
// Function: cx_writer_put_null
bool cx_writer_put_null(struct cx_writer *writer, size_t column_index)
{
    if (!cx_writer_put_check(writer, column_index))
        return false;
    if (!cx_column_put_unit(writer->columns[column_index].values))
        return false;
    if (!cx_column_put_bit(writer->columns[column_index].nulls, true))
        return false;
    writer->position += (column_index == 0);
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa91f
testb %al, %al
je 0xacb2
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
callq 0x51d0
testb %al, %al
je 0xacb2
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
movl $0x1, %esi
callq 0x54a0
testb %al, %al
je 0xacb2
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0xacb4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq