LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe422
movq $0x0, -0x8(%rbp)
jmp 0xe4c9
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe4ae
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x5090
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x52a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe512
movq $0x0, -0x8(%rbp)
jmp 0xe5b9
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe59e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x5190
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x53c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe602
movq $0x0, -0x8(%rbp)
jmp 0xe6a9
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe68e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x52f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x51e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/row_group.c
// Function: cx_row_group_cursor_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe240
testb $0x1, %al
jne 0xe6f2
movq $0x0, -0x8(%rbp)
jmp 0xe799
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
ja 0xe77e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rax
subq 0x8(%rax), %rsi
callq 0x5160
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x18, %rsi
callq 0x5460
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x54d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe7e4
movq $0x0, -0x8(%rbp)
jmp 0xe82a
movq -0x10(%rbp), %rdi
callq 0x59b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe803
jmp 0xe819
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe82a
movq -0x20(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x60, %esi
callq 0x54d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xe870
movq $0x0, -0x8(%rbp)
jmp 0xe8ed
movl $0x5, %edi
xorl %esi, %esi
callq 0x5890
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xe894
jmp 0xe8c4
movq -0x10(%rbp), %rdi
leaq 0x2e4a(%rip), %rsi      # 0x116e9
callq 0x5550
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe8ba
jmp 0xe8c4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe8ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xe8dc
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x5990
movq -0x18(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe97f
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xe972
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x5990
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x5990
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe91f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5040
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe9c4
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x5990
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe9e9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xea01
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x50a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5220
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5290
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xea93
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5760
movq %rax, -0x28(%rbp)
jmp 0xeaa0
movq -0x20(%rbp), %rdi
callq 0x5630
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xeaad
movb $0x0, -0x1(%rbp)
jmp 0xeace
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5570
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/writer.c
// Function: cx_writer_add_column
bool cx_writer_add_column(struct cx_writer *writer, const char *name,
                          enum cx_column_type type,
                          enum cx_encoding_type encoding,
                          enum cx_compression_type compression, int level)
{
    if (!cx_row_group_writer_add_column(writer->writer, name, type, encoding,
                                        compression, level))
        return false;
    writer->column_count++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
callq 0x5050
testb $0x1, %al
jne 0xeb26
movb $0x0, -0x1(%rbp)
jmp 0xeb3a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xed0e
movb $0x0, -0x1(%rbp)
jmp 0xed83
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x5530
testb $0x1, %al
jne 0xed3b
movb $0x0, -0x1(%rbp)
jmp 0xed83
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xed63
movb $0x0, -0x1(%rbp)
jmp 0xed83
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xedb4
movb $0x0, -0x1(%rbp)
jmp 0xee06
cmpq $0x0, -0x18(%rbp)
jne 0xede2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xede2
movq -0x10(%rbp), %rdi
callq 0xf290
testb $0x1, %al
jne 0xede0
movb $0x0, -0x1(%rbp)
jmp 0xee06
jmp 0xede2
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xee02
movq -0x10(%rbp), %rdi
callq 0xfd20
testb $0x1, %al
jne 0xee00
movb $0x0, -0x1(%rbp)
jmp 0xee06
jmp 0xee02
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xee4a
movb $0x0, -0x1(%rbp)
jmp 0xeeba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x55b0
testb $0x1, %al
jne 0xee72
movb $0x0, -0x1(%rbp)
jmp 0xeeba
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xee9a
movb $0x0, -0x1(%rbp)
jmp 0xeeba
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xeefb
movb $0x0, -0x1(%rbp)
jmp 0xef6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5740
testb $0x1, %al
jne 0xef24
movb $0x0, -0x1(%rbp)
jmp 0xef6c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xef4c
movb $0x0, -0x1(%rbp)
jmp 0xef6c
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xefac
movb $0x0, -0x1(%rbp)
jmp 0xf01e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movss -0x1c(%rbp), %xmm0
callq 0x5810
testb $0x1, %al
jne 0xefd6
movb $0x0, -0x1(%rbp)
jmp 0xf01e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xeffe
movb $0x0, -0x1(%rbp)
jmp 0xf01e
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xf05c
movb $0x0, -0x1(%rbp)
jmp 0xf0ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movsd -0x20(%rbp), %xmm0
callq 0x54f0
testb $0x1, %al
jne 0xf086
movb $0x0, -0x1(%rbp)
jmp 0xf0ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xf0ae
movb $0x0, -0x1(%rbp)
jmp 0xf0ce
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xf10b
movb $0x0, -0x1(%rbp)
jmp 0xf17c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x5250
testb $0x1, %al
jne 0xf134
movb $0x0, -0x1(%rbp)
jmp 0xf17c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x5530
testb $0x1, %al
jne 0xf15c
movb $0x0, -0x1(%rbp)
jmp 0xf17c
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed90
testb $0x1, %al
jne 0xf1b7
movb $0x0, -0x1(%rbp)
jmp 0xf227
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x5200
testb $0x1, %al
jne 0xf1dc
movb $0x0, -0x1(%rbp)
jmp 0xf227
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x5530
testb $0x1, %al
jne 0xf207
movb $0x0, -0x1(%rbp)
jmp 0xf227
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/writer.c
// Function: cx_writer_flush_row_group
static bool cx_writer_flush_row_group(struct cx_writer *writer)
{
    if (!writer->columns)
        return true;
    struct cx_row_group *row_group = cx_row_group_new();
    if (!row_group)
        return false;
    for (size_t i = 0; i < writer->column_count; i++)
        if (!cx_row_group_add_column(row_group, writer->columns[i].values,
                                     writer->columns[i].nulls))
            goto error;
    if (!cx_row_group_writer_put(writer->writer, row_group))
        goto error;
    cx_row_group_free(row_group);
    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);
    writer->columns = NULL;
    writer->position = 0;
    return true;
error:
    cx_row_group_free(row_group);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xf2b0
movb $0x1, -0x1(%rbp)
jmp 0xf3e3
callq 0x5830
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf2c9
movb $0x0, -0x1(%rbp)
jmp 0xf3e3
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xf32e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x5660
testb $0x1, %al
jne 0xf31e
jmp 0xf3d6
jmp 0xf320
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xf2d1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x52d0
testb $0x1, %al
jne 0xf347
jmp 0xf3d6
movq -0x18(%rbp), %rdi
callq 0x5900
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0xf3ab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x5990
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x5990
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xf358
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x50a0
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xf3e3
movq -0x18(%rbp), %rdi
callq 0x5900
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_add_string
static bool cx_row_group_writer_add_string(struct cx_row_group_writer *writer,
                                           const char *string, uint32_t *id)
{
    if (!cx_column_put_str(writer->strings.column, string))
        return false;
    *id = writer->strings.count;
    writer->strings.count++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5250
testb $0x1, %al
jne 0xf62f
movb $0x0, -0x1(%rbp)
jmp 0xf653
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_ensure_header
static bool cx_row_group_writer_ensure_header(
    struct cx_row_group_writer *writer)
{
    if (writer->header_written)
        return true;
    struct cx_header header = {CX_FILE_MAGIC, CX_FILE_VERSION, 0};
    if (!cx_row_group_writer_write(writer, &header, sizeof(header)))
        goto error;
    writer->header_written = true;
    return true;
error:
    rewind(writer->file);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x58(%rax)
je 0xfa3c
movb $0x1, -0x1(%rbp)
jmp 0xfa88
movq 0x1e5d(%rip), %rax      # 0x118a0
movq %rax, -0x20(%rbp)
movq 0x1e5a(%rip), %rax      # 0x118a8
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0xfc60
testb $0x1, %al
jne 0xfa6a
jmp 0xfa78
movq -0x10(%rbp), %rax
movb $0x1, 0x58(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xfa88
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5350
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_write
static bool cx_row_group_writer_write(const struct cx_row_group_writer *writer,
                                      const void *buf, size_t size)
{
    if (!size)
        return true;
    size_t offset = cx_row_group_writer_offset(writer);
    size_t aligned_offset = cx_write_align(offset);
    if (offset != aligned_offset &&
        !cx_row_group_writer_seek(writer, aligned_offset))
        return false;
    return fwrite(buf, size, 1, writer->file) == 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xfc81
movb $0x1, -0x1(%rbp)
jmp 0xfce1
movq -0x10(%rbp), %rdi
callq 0xfaa0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xfc20
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0xfcbc
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfcf0
testb $0x1, %al
jne 0xfcbc
movb $0x0, -0x1(%rbp)
jmp 0xfce1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %edx
callq 0x5960
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_web.c
// Function: main
int
main(int argc, char *argv[])
{
	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	if (argc > 1)
		strlcpy(basehref, argv[1], sizeof(basehref));

	parser.xmlattr = xmlattr;
	parser.xmltagstart = xmltagstart;
	parser.xmltagstartparsed = xmltagstartparsed;

	/* NOTE: getnext is defined in xml.h for inline optimization */
	xml_parse(&parser);

	return found > 0 ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x12d5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x4e35(%rip), %rdi      # 0x6100
movl $0x1000, %edx           # imm = 0x1000
callq 0x3850
leaq 0x54(%rip), %rax        # 0x1330
movq %rax, 0x5e1d(%rip)      # 0x7100
leaq 0x176(%rip), %rax       # 0x1460
movq %rax, 0x5e87(%rip)      # 0x7178
leaq 0x1f8(%rip), %rax       # 0x14f0
movq %rax, 0x5e81(%rip)      # 0x7180
leaq 0x5dfa(%rip), %rdi      # 0x7100
callq 0x2500
movl 0x8687(%rip), %edx      # 0x9998
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmoval %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_web.c
// Function: xmlattr
static void
xmlattr(XMLParser *p, const char *t, size_t tl, const char *n, size_t nl,
	const char *v, size_t vl)
{
	if (nl != 4) /* optimization */
		return;

	if (isbase) {
		if (!strcasecmp(n, "href"))
			strlcpy(basehref, v, sizeof(basehref));
	} else if (islink) {
		if (!strcasecmp(n, "type")) {
			if (!strncasecmp(v, STRP("application/atom")) ||
			    !strncasecmp(v, STRP("application/xml"))  ||
			    !strncasecmp(v, STRP("application/rss"))) {
				isfeedlink = 1;
				strlcpy(feedtype, v, sizeof(feedtype));
			}
		} else if (!strcasecmp(n, "href")) {
			strlcpy(feedlink, v, sizeof(feedlink));
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x4, -0x28(%rbp)
je 0x1360
jmp 0x1459
cmpl $0x0, 0x8635(%rip)      # 0x999c
je 0x1398
movq -0x20(%rbp), %rdi
leaq 0x2c90(%rip), %rsi      # 0x4004
callq 0x1040
cmpl $0x0, %eax
jne 0x1393
movq -0x30(%rbp), %rsi
leaq 0x4d77(%rip), %rdi      # 0x6100
movl $0x1000, %edx           # imm = 0x1000
callq 0x3850
jmp 0x1459
cmpl $0x0, 0x8601(%rip)      # 0x99a0
je 0x1457
movq -0x20(%rbp), %rdi
leaq 0x2c59(%rip), %rsi      # 0x4009
callq 0x1040
cmpl $0x0, %eax
jne 0x1429
movq -0x30(%rbp), %rdi
leaq 0x2c49(%rip), %rsi      # 0x400e
movl $0x10, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x1408
movq -0x30(%rbp), %rdi
leaq 0x2c40(%rip), %rsi      # 0x401f
movl $0xf, %edx
callq 0x1160
cmpl $0x0, %eax
je 0x1408
movq -0x30(%rbp), %rdi
leaq 0x2c36(%rip), %rsi      # 0x402f
movl $0xf, %edx
callq 0x1160
cmpl $0x0, %eax
jne 0x1427
movl $0x1, 0x8592(%rip)      # 0x99a4
movq -0x30(%rbp), %rsi
leaq 0x8593(%rip), %rdi      # 0x99b0
movl $0x100, %edx            # imm = 0x100
callq 0x3850
jmp 0x1455
movq -0x20(%rbp), %rdi
leaq 0x2bd0(%rip), %rsi      # 0x4004
callq 0x1040
cmpl $0x0, %eax
jne 0x1453
movq -0x30(%rbp), %rsi
leaq 0x8667(%rip), %rdi      # 0x9ab0
movl $0x1000, %edx           # imm = 0x1000
callq 0x3850
jmp 0x1455
jmp 0x1457
jmp 0x1459
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_web.c
// Function: xmltagstart
static void
xmltagstart(XMLParser *p, const char *t, size_t tl)
{
	isbase = islink = isfeedlink = 0;
	if (tl != 4) /* optimization */
		return;

	if (!strcasecmp(t, "base"))
		isbase = 1;
	else if (!strcasecmp(t, "link"))
		islink = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, 0x8526(%rip)      # 0x99a4
movl $0x0, 0x8518(%rip)      # 0x99a0
movl $0x0, 0x850a(%rip)      # 0x999c
cmpq $0x4, -0x18(%rbp)
je 0x149b
jmp 0x14dd
movq -0x10(%rbp), %rdi
leaq 0x2b99(%rip), %rsi      # 0x403f
callq 0x1040
cmpl $0x0, %eax
jne 0x14bc
movl $0x1, 0x84e2(%rip)      # 0x999c
jmp 0x14dd
movq -0x10(%rbp), %rdi
leaq 0x2b7d(%rip), %rsi      # 0x4044
callq 0x1040
cmpl $0x0, %eax
jne 0x14db
movl $0x1, 0x84c5(%rip)      # 0x99a0
jmp 0x14dd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_web.c
// Function: xmltagstartparsed
static void
xmltagstartparsed(XMLParser *p, const char *t, size_t tl, int isshort)
{
	if (!isfeedlink)
		return;

	if (absuri(abslink, sizeof(abslink), feedlink, basehref) != -1)
		fputs(abslink, stdout);
	else
		fputs(feedlink, stdout);
	putchar('\t');
	printfeedtype(feedtype, stdout);
	putchar('\n');
	found++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, 0x8496(%rip)      # 0x99a4
jne 0x1515
jmp 0x15a0
leaq 0x9594(%rip), %rdi      # 0xaab0
movl $0x1000, %esi           # imm = 0x1000
leaq 0x8588(%rip), %rdx      # 0x9ab0
leaq 0x4bd1(%rip), %rcx      # 0x6100
callq 0x1a50
cmpl $-0x1, %eax
je 0x1551
movq 0x4aa0(%rip), %rax      # 0x5fe0
movq (%rax), %rsi
leaq 0x9566(%rip), %rdi      # 0xaab0
callq 0x10b0
jmp 0x1567
movq 0x4a88(%rip), %rax      # 0x5fe0
movq (%rax), %rsi
leaq 0x854e(%rip), %rdi      # 0x9ab0
callq 0x10b0
movl $0x9, %edi
callq 0x1030
movq 0x4a68(%rip), %rax      # 0x5fe0
movq (%rax), %rsi
leaq 0x842e(%rip), %rdi      # 0x99b0
callq 0x15b0
movl $0xa, %edi
callq 0x1030
movl 0x8401(%rip), %eax      # 0x9998
addl $0x1, %eax
movl %eax, 0x83f8(%rip)      # 0x9998
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/autosync.c
// Function: jfs_autosync_start
int jfs_autosync_start(struct jfs *fs, time_t max_sec, size_t max_bytes)
{
	struct autosync_cfg *cfg;

	if (fs->as_cfg != NULL)
		return -1;

	cfg = malloc(sizeof(struct autosync_cfg));
	if (cfg == NULL)
		return -1;

	cfg->fs = fs;
	cfg->max_sec = max_sec;
	cfg->max_bytes = max_bytes;
	cfg->must_die = 0;
	pthread_cond_init(&cfg->cond, NULL);
	pthread_mutex_init(&cfg->mutex, NULL);

	fs->as_cfg = cfg;

	return pthread_create(&cfg->tid, NULL, &autosync_thread, cfg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x270e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27aa
movl $0x80, %edi
callq 0x23c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x272c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27aa
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2370
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25d0
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x1e(%rip), %rdx        # 0x27c0
callq 0x2450
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/autosync.c
// Function: autosync_thread
static void *autosync_thread(void *arg)
{
	int rv;
	void *had_errors;
	struct timespec ts;
	struct autosync_cfg *cfg;

	cfg = (struct autosync_cfg *) arg;

	/* had_errors is a void * just to avoid weird casts, since we want to
	 * return it, but it's used as a boolean */
	had_errors = (void *) 0;

	pthread_mutex_lock(&cfg->mutex);
	for (;;) {
		clock_gettime(CLOCK_REALTIME, &ts);
		ts.tv_sec += cfg->max_sec;

		rv = pthread_cond_timedwait(&cfg->cond, &cfg->mutex, &ts);
		if (rv != 0 && rv != ETIMEDOUT)
			break;

		if (cfg->must_die)
			break;

		/* cover from spurious wakeups */
		if (rv != ETIMEDOUT && cfg->fs->ltrans_len < cfg->max_bytes)
			continue;

		rv = jsync(cfg->fs);
		if (rv != 0)
			had_errors = (void *) 1;

	}
	pthread_mutex_unlock(&cfg->mutex);

	pthread_exit(had_errors);
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
callq 0x25f0
xorl %edi, %edi
leaq -0x28(%rbp), %rsi
callq 0x2110
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq -0x30(%rbp), %rsi
addq $0x58, %rsi
leaq -0x28(%rbp), %rdx
callq 0x24b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x282e
cmpl $0x6e, -0xc(%rbp)
je 0x282e
jmp 0x287a
movq -0x30(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x283a
jmp 0x287a
cmpl $0x6e, -0xc(%rbp)
je 0x2857
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x2857
jmp 0x27e9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2320
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2875
movl $0x1, %eax
movq %rax, -0x18(%rbp)
jmp 0x27e9
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
callq 0x23a0
movq -0x18(%rbp), %rdi
callq 0x23b0
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/autosync.c
// Function: jfs_autosync_stop
int jfs_autosync_stop(struct jfs *fs)
{
	int rv = 0;
	void *had_errors;

	if (fs->as_cfg == NULL)
		return 0;

	fs->as_cfg->must_die = 1;
	pthread_cond_signal(&fs->as_cfg->cond);
	pthread_join(fs->as_cfg->tid, &had_errors);

	if (had_errors)
		rv = -1;

	pthread_cond_destroy(&fs->as_cfg->cond);
	pthread_mutex_destroy(&fs->as_cfg->mutex);
	free(fs->as_cfg);
	fs->as_cfg = NULL;

	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x28bd
movl $0x0, -0x4(%rbp)
jmp 0x2956
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movl $0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x28, %rdi
callq 0x2290
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x25a0
cmpq $0x0, -0x20(%rbp)
je 0x2909
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x28, %rdi
callq 0x24f0
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x58, %rdi
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movq $0x0, 0x90(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/autosync.c
// Function: autosync_check
void autosync_check(struct jfs *fs)
{
	if (fs->as_cfg == NULL)
		return;

	if (fs->ltrans_len > fs->as_cfg->max_bytes)
		pthread_cond_signal(&fs->as_cfg->cond);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
jne 0x297c
jmp 0x29a9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x29a9
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
addq $0x28, %rdi
callq 0x2290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/checksum.c
// Function: checksum_buf
uint32_t checksum_buf(uint32_t crc32, const unsigned char *buf, size_t count)
{
	crc32 = ~crc32;

	while (count--) {
		crc32 = (crc32 >> 8) ^ table[(crc32 ^ *buf) & 0xFFL];
		buf++;
	}

	return ~crc32;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2a15
movl -0x4(%rbp), %eax
shrl $0x8, %eax
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
xorl %edx, %ecx
movl %ecx, %ecx
movl %ecx, %edx
andq $0xff, %rdx
leaq 0x691f(%rip), %rcx      # 0x9320
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x29c8
movl -0x4(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albertito[P]libjio/libjio/common.c
// Function: plockf
off_t plockf(int fd, int cmd, off_t offset, off_t len)
{
	struct flock fl;
	int op;

	op = -1;
	fl.l_type = -1;

	if (cmd & _F_READ) {
		fl.l_type = F_RDLCK;
	} else if (cmd & _F_WRITE) {
		fl.l_type = F_WRLCK;
	}

	if (cmd & _F_LOCK) {
		op = F_SETLKW;
	} else if (cmd & _F_TLOCK) {
		op = F_SETLK;
	} else if (cmd & F_UNLOCK) {
		fl.l_type = F_UNLCK;
		op = F_SETLKW; /* not very relevant */
	}

	fl.l_whence = SEEK_SET;
	fl.l_start = offset;
	fl.l_len = len;

	return fcntl(fd, op, &fl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movw $0xffff, -0x38(%rbp)    # imm = 0xFFFF
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2a56
movw $0x0, -0x38(%rbp)
jmp 0x2a69
movl -0x8(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x2a67
movw $0x1, -0x38(%rbp)
jmp 0x2a69
movl -0x8(%rbp), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x2a7f
movl $0x7, -0x3c(%rbp)
jmp 0x2ab3
movl -0x8(%rbp), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x2a95
movl $0x6, -0x3c(%rbp)
jmp 0x2ab1
movl -0x8(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x2aaf
movw $0x2, -0x38(%rbp)
movl $0x7, -0x3c(%rbp)
jmp 0x2ab1
jmp 0x2ab3
movw $0x0, -0x36(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movl -0x3c(%rbp), %esi
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x2100
cltq
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)