LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x9d07
testb %al, %al
je 0x9cd6
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9cda
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9cfe
xorl %eax, %eax
jmp 0x9d01
movq (%r15), %rdi
callq 0x5370
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5660
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_O2/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 0x9d4c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
shlq $0x6, %r14
movb $0x1, %al
cmpq $0x0, 0x28(%rdi,%r14)
jne 0x9d51
movq (%rbx), %rdi
callq 0x5360
testq %rax, %rax
je 0x9d4f
addq %r14, %rbx
addq $0x28, %rbx
movq %rax, %rdi
callq 0x53e0
movq %rax, (%rbx)
testq %rax, %rax
setne %al
jmp 0x9d51
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9d07
testb %al, %al
je 0x9d8f
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9d93
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9db7
xorl %eax, %eax
jmp 0x9dba
movq (%r15), %rdi
callq 0x5130
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5420
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_O2/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 0x9d07
testb %al, %al
je 0x9df6
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9dfa
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9e1e
xorl %eax, %eax
jmp 0x9e21
movq (%r15), %rdi
callq 0x5080
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5290
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_O2/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 0x9d07
testb %al, %al
je 0x9e5d
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9e61
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9e85
xorl %eax, %eax
jmp 0x9e88
movq (%r15), %rdi
callq 0x5180
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x53a0
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_O2/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 0x9d07
testb %al, %al
je 0x9ec4
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9ec8
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9eec
xorl %eax, %eax
jmp 0x9eef
movq (%r15), %rdi
callq 0x52e0
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x51d0
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_O2/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 0x9d07
testb %al, %al
je 0x9f2b
shlq $0x6, %r15
addq %r14, %r15
addq $0x28, %r15
movq 0x18(%r14), %rsi
subq 0x8(%r15), %rsi
jae 0x9f2f
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
jmp 0x9f53
xorl %eax, %eax
jmp 0x9f56
movq (%r15), %rdi
callq 0x5150
addq %rax, 0x8(%r15)
movq (%r15), %rdi
leaq 0x18(%r15), %rsi
callq 0x5430
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_O2/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
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x5480
testq %rax, %rax
je 0x9f98
movq %rax, %rbx
movq %r15, %rdi
callq 0x5960
movq %rax, (%rbx)
testq %rax, %rax
je 0x9f90
movq %r14, 0x10(%rbx)
jmp 0x9f9a
movq %rbx, %rdi
callq 0x5090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
callq 0x5480
testq %rax, %rax
je 0x9ffb
movq %rax, %rbx
pushq $0x5
popq %rdi
xorl %esi, %esi
callq 0x5840
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x9ff3
movq %rax, %r15
leaq 0x26e6(%rip), %rsi      # 0xc6c1
movq %r14, %rdi
callq 0x5500
movq %rax, (%rbx)
testq %rax, %rax
jne 0x9ffd
movq %r15, %rdi
callq 0x5940
movq %rbx, %rdi
callq 0x5090
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/writer.c
// Function: cx_writer_free
void cx_writer_free(struct cx_writer *writer)
{
    if (writer->columns) {
        for (size_t i = 0; i < writer->column_count; i++) {
            cx_column_free(writer->columns[i].values);
            cx_column_free(writer->columns[i].nulls);
        }
        free(writer->columns);
    }
    cx_row_group_writer_free(writer->writer);
    free(writer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xa04a
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rdi
cmpq 0x18(%rbx), %r15
jae 0xa045
movq (%rdi,%r14), %rdi
callq 0x5940
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r14), %rdi
callq 0x5940
incq %r15
addq $0x10, %r14
jmp 0xa01b
callq 0x5090
movq (%rbx), %rdi
callq 0x5040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5090
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x5090
movq 0x38(%rbx), %rdi
callq 0x5940
movq 0x8(%rbx), %rdi
callq 0x5090
movq 0x20(%rbx), %rdi
callq 0x5090
movq (%rbx), %rdi
callq 0x5210
movq %rbx, %rdi
popq %rbx
jmp 0x5090
// File: /workspace/github_c_makefile_star2_O2/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 0x5280
movq %rax, %r15
incq %r15
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xa0cf
movq %r15, %rsi
callq 0x5710
jmp 0xa0d7
movq %r15, %rdi
callq 0x55d0
movq %rax, %r12
testq %rax, %rax
je 0xa0f1
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5520
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_O2/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
pushq %rax
cmpb $0x0, 0x58(%rdi)
je 0xa13b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0xa198
cmpq 0x18(%r15), %rcx
jne 0xa1c1
movl %r9d, 0x4(%rsp)
testq %rcx, %rcx
jle 0xa20e
movq %rcx, %rbx
addq %rcx, %rbx
je 0xa20e
movq 0x8(%r15), %rdi
imulq $0x30, %rcx, %rsi
callq 0x5710
testq %rax, %rax
movl 0x4(%rsp), %r9d
je 0xa12a
movq %rax, 0x8(%r15)
movq %rbx, 0x18(%r15)
movq 0x10(%r15), %rcx
jmp 0xa1c5
movl $0xc0, %edi
movl %r9d, %ebx
callq 0x55d0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0xa12a
movl %ebx, %r9d
movq $0x8, 0x18(%r15)
xorl %ecx, %ecx
jmp 0xa1c5
movq 0x8(%r15), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
imulq $0x18, %rcx, %rcx
leaq (%rax,%rcx), %rdx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
movl %r13d, 0x4(%rax,%rcx)
movl %r12d, 0x8(%rax,%rcx)
movl %ebp, 0xc(%rax,%rcx)
movl %r9d, 0x10(%rax,%rcx)
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa888
leaq 0x24af(%rip), %rdi      # 0xc6c4
leaq 0x24d4(%rip), %rsi      # 0xc6f0
leaq 0x24d6(%rip), %rcx      # 0xc6f9
movl $0x149, %edx            # imm = 0x149
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa285
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movzbl %bpl, %esi
callq 0x54e0
testb %al, %al
je 0xa285
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa287
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa287
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rsi, 0x18(%rdi)
jbe 0xa3a2
movq %rdi, %rbx
testq %rsi, %rsi
jne 0xa2cb
movq 0x20(%rbx), %rax
cmpq 0x10(%rbx), %rax
jne 0xa2cb
movq %rbx, %rdi
callq 0xa661
testb %al, %al
je 0xa3a2
movb $0x1, %bpl
cmpq $0x0, 0x8(%rbx)
jne 0xa3a4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xa3b5
pushq $0x10
popq %rsi
callq 0x5480
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xa3a2
pushq $0x8
popq %r14
pushq $-0x1
popq %r15
xorl %r12d, %r12d
incq %r15
cmpq 0x18(%rbx), %r15
jae 0xa3a4
movq (%rbx), %rax
movq 0x8(%rax), %rax
movl -0x4(%rax,%r14), %edi
movl (%rax,%r14), %esi
callq 0x5840
movq 0x8(%rbx), %rdi
movq %rax, (%rdi,%r12)
testq %rax, %rax
je 0xa358
leaq 0x10(%r12), %r13
addq $0x18, %r14
xorl %edi, %edi
xorl %esi, %esi
callq 0x5840
movq 0x8(%rbx), %rdi
movq %rax, 0x8(%rdi,%r12)
movq %r13, %r12
testq %rax, %rax
jne 0xa306
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x18(%rbx), %r15
jae 0xa398
movq (%rdi,%r14), %rax
testq %rax, %rax
je 0xa379
movq %rax, %rdi
callq 0x5940
movq 0x8(%rbx), %rdi
movq 0x8(%rdi,%r14), %rax
testq %rax, %rax
je 0xa38f
movq %rax, %rdi
callq 0x5940
movq 0x8(%rbx), %rdi
incq %r15
addq $0x10, %r14
jmp 0xa35e
callq 0x5090
andq $0x0, 0x8(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x245b(%rip), %rdi      # 0xc817
leaq 0x232d(%rip), %rsi      # 0xc6f0
leaq 0x2476(%rip), %rcx      # 0xc840
movl $0x80, %edx
callq 0x5380
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa42a
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movl %ebp, %esi
callq 0x5560
testb %al, %al
je 0xa42a
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa42c
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa42c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa492
movq 0x8(%rbx), %rax
movq %r14, %r12
shlq $0x4, %r12
movq (%rax,%r12), %rdi
movq %r15, %rsi
callq 0x56f0
testb %al, %al
je 0xa492
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa494
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa494
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa4fd
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movss 0x4(%rsp), %xmm0
callq 0x57c0
testb %al, %al
je 0xa4fd
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa4ff
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa4ff
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa568
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movsd (%rsp), %xmm0
callq 0x54a0
testb %al, %al
je 0xa568
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa56a
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa56a
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa5d0
movq 0x8(%rbx), %rax
movq %r14, %r12
shlq $0x4, %r12
movq (%rax,%r12), %rdi
movq %r15, %rsi
callq 0x5240
testb %al, %al
je 0xa5d0
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r12), %rdi
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x54e0
testb %al, %al
je 0xa5d2
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %bpl
jmp 0xa5d2
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa294
testb %al, %al
je 0xa62b
movq 0x8(%rbx), %rax
movq %r14, %r15
shlq $0x4, %r15
movq (%rax,%r15), %rdi
callq 0x51f0
testb %al, %al
je 0xa62b
movq 0x8(%rbx), %rax
movq 0x8(%rax,%r15), %rdi
pushq $0x1
popq %rsi
callq 0x54e0
testb %al, %al
je 0xa62b
cmpq $0x1, %r14
adcq $0x0, 0x20(%rbx)
movb $0x1, %al
jmp 0xa62d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpq $0x0, 0x8(%rdi)
je 0xa70e
movq %rdi, %r14
callq 0x57e0
testq %rax, %rax
je 0xa70c
movq %rax, %r15
pushq $0x8
popq %rcx
pushq $-0x1
popq %r12
incq %r12
cmpq 0x18(%r14), %r12
jae 0xa6bd
leaq 0x10(%rcx), %r13
movq 0x8(%r14), %rax
movq -0x8(%rax,%rcx), %rsi
movq (%rax,%rcx), %rdx
movq %r15, %rdi
callq 0x5600
movq %r13, %rcx
testb %al, %al
jne 0xa692
jmp 0xa704
movq (%r14), %rdi
movq %r15, %rsi
callq 0x52c0
testb %al, %al
je 0xa704
movq %r15, %rdi
callq 0x58b0
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
cmpq 0x18(%r14), %r12
jae 0xa71a
movq (%rdi,%r15), %rdi
callq 0x5940
movq 0x8(%r14), %rax
movq 0x8(%rax,%r15), %rdi
callq 0x5940
incq %r12
addq $0x10, %r15
jmp 0xa6da
movq %r15, %rdi
callq 0x58b0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5090
andq $0x0, 0x8(%r14)
andq $0x0, 0x20(%r14)
jmp 0xa70e
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bpl
cmpb $0x0, 0x58(%rdi)
jne 0xab86
movq %rdi, %rbx
movups 0x1d14(%rip), %xmm0     # 0xc878
movq %rsp, %rsi
movaps %xmm0, (%rsi)
pushq $0x10
popq %rdx
callq 0xacae
movl %eax, %ebp
testb %al, %al
je 0xab7e
movb $0x1, 0x58(%rbx)
jmp 0xab86
movq (%rbx), %rdi
callq 0x5340
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chriso[P]columnix/lib/writer.c
// Function: cx_row_group_writer_put_column
static bool cx_row_group_writer_put_column(struct cx_row_group_writer *writer,
                                           const struct cx_column *column,
                                           const struct cx_index *index,
                                           struct cx_column_header *header,
                                           enum cx_compression_type compression,
                                           int compression_level)
{
    size_t column_size;
    const void *buffer = cx_column_export(column, &column_size);
    header->decompressed_size = column_size;
    header->offset = cx_write_align(cx_row_group_writer_offset(writer));
    header->encoding = cx_column_encoding(column);
    memcpy(&header->index, index, sizeof(*index));
    size_t compressed_size = 0;
    void *compressed = NULL;
    if (compression && column_size) {
        compressed = cx_compress(compression, compression_level, buffer,
                                 column_size, &compressed_size);
        if (!compressed)
            goto error;
        // fallback if the compression leads to an increase in size
        if (compressed_size >= column_size) {
            header->compression = CX_COMPRESSION_NONE;
        } else {
            header->compression = compression;
            buffer = compressed;
            column_size = compressed_size;
        }
    }
    header->size = column_size;
    if (!cx_row_group_writer_write(writer, buffer, column_size))
        goto error;
    if (compressed)
        free(compressed);
    return true;
error:
    if (compressed)
        free(compressed);
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, 0x4(%rsp)
movl %r8d, %r14d
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbp
leaq 0x18(%rsp), %r13
movq %rsi, %rdi
movq %r13, %rsi
callq 0x5160
movq %rax, 0x8(%rsp)
movq (%r13), %rax
movq %rax, 0x10(%rbx)
movq %rbp, 0x20(%rsp)
movq %rbp, %rdi
movl %r14d, %ebp
callq 0xab8f
addq $0x7, %rax
andq $-0x8, %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x50e0
movl %eax, 0x1c(%rbx)
movq 0x10(%r12), %rax
movq %rax, 0x30(%rbx)
movups (%r12), %xmm0
movups %xmm0, 0x20(%rbx)
andq $0x0, 0x10(%rsp)
testl %r14d, %r14d
setne %al
movq (%r13), %rcx
testq %rcx, %rcx
setne %dl
andb %al, %dl
cmpb $0x1, %dl
jne 0xac6a
leaq 0x10(%rsp), %r8
movl %ebp, %edi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x5890
testq %rax, %rax
je 0xac74
movq %rax, %r12
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0xac7b
movl %ebp, 0x18(%rbx)
movq %rax, 0x18(%rsp)
movq %rax, %rcx
movq %r12, %rsi
jmp 0xac82
xorl %r12d, %r12d
movq 0x8(%rsp), %rsi
jmp 0xac82
xorl %r12d, %r12d
xorl %ebx, %ebx
jmp 0xac95
movq %r14, %rsi
andl $0x0, 0x18(%rbx)
movq %rcx, 0x8(%rbx)
movq 0x20(%rsp), %rdi
movq %rcx, %rdx
callq 0xacae
movl %eax, %ebx
movq %r12, %rdi
callq 0x5090
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0xacf9
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xab8f
leaq 0x7(%rax), %rsi
andq $-0x8, %rsi
cmpq %rsi, %rax
je 0xacdf
movq %r15, %rdi
callq 0xad04
testb %al, %al
je 0xacfc
movq (%r15), %rcx
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5910
cmpq $0x1, %rax
sete %al
jmp 0xacfe
movb $0x1, %al
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpl $0x2, %edi
jl 0x12b7
movq 0x8(%rsi), %rsi
leaq 0x3e43(%rip), %rdi      # 0x50f0
movl $0x1000, %edx           # imm = 0x1000
callq 0x28bc
leaq 0x3d(%rip), %rax        # 0x12fb
movq %rax, 0x4e2b(%rip)      # 0x60f0
leaq 0x4e24(%rip), %rdi      # 0x60f0
leaq 0x109(%rip), %rax       # 0x13dc
movq %rax, 0x4e8e(%rip)      # 0x6168
leaq 0x154(%rip), %rax       # 0x1435
movq %rax, 0x4e88(%rip)      # 0x6170
callq 0x1d47
xorl %eax, %eax
cmpl $0x0, 0x7692(%rip)      # 0x8988
sete %al
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
cmpq $0x4, %r8
jne 0x1362
movq %r9, %rbx
movq %rcx, %r14
cmpb $0x1, 0x767a(%rip)      # 0x898c
jne 0x1333
leaq 0x1ce9(%rip), %rsi      # 0x3004
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
jne 0x1362
leaq 0x3dc2(%rip), %rdi      # 0x50f0
jmp 0x13c8
cmpb $0x1, 0x7656(%rip)      # 0x8990
jne 0x1362
leaq 0x1cc6(%rip), %rsi      # 0x3009
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x136a
leaq 0x1cae(%rip), %rsi      # 0x3004
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x13c1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1c9d(%rip), %rsi      # 0x300e
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
je 0x13ac
leaq 0x1c98(%rip), %rsi      # 0x301f
pushq $0xf
popq %rdx
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
je 0x13ac
leaq 0x1c92(%rip), %rsi      # 0x302f
pushq $0xf
popq %rdx
movq %rbx, %rdi
callq 0x1160
testl %eax, %eax
jne 0x1362
movb $0x1, 0x75e1(%rip)      # 0x8994
leaq 0x75e6(%rip), %rdi      # 0x89a0
movl $0x100, %edx            # imm = 0x100
jmp 0x13cd
leaq 0x76d8(%rip), %rdi      # 0x8aa0
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28bc
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movb %al, 0x75b0(%rip)       # 0x8994
movb %al, 0x75a6(%rip)       # 0x8990
movb %al, 0x759c(%rip)       # 0x898c
cmpq $0x4, %rdx
jne 0x1434
pushq %rbx
movq %rsi, %rbx
leaq 0x1c3e(%rip), %rsi      # 0x303f
movq %rbx, %rdi
callq 0x1040
testl %eax, %eax
je 0x1429
leaq 0x1c30(%rip), %rsi      # 0x3044
movq %rbx, %rdi
callq 0x1040
testl %eax, %eax
jne 0x1433
leaq 0x7569(%rip), %rax      # 0x8990
jmp 0x1430
leaq 0x755c(%rip), %rax      # 0x898c
movb $0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, 0x7558(%rip)      # 0x8994
jne 0x14d4
pushq %r15
pushq %r14
pushq %rbx
leaq 0x8652(%rip), %rbx      # 0x9aa0
leaq 0x764b(%rip), %r14      # 0x8aa0
leaq 0x3c94(%rip), %rcx      # 0x50f0
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r14, %rdx
callq 0x173d
cmpl $-0x1, %eax
movq 0x3b6a(%rip), %r15      # 0x4fe0
movq (%r15), %rsi
cmoveq %r14, %rbx
movq %rbx, %rdi
callq 0x10b0
pushq $0x9
popq %rdi
callq 0x1030
movq (%r15), %rbx
leaq 0x7509(%rip), %r14      # 0x89a0
movzbl (%r14), %r15d
testq %r15, %r15
je 0x14c1
callq 0x1190
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
jne 0x14bc
movsbl %r15b, %edi
movq %rbx, %rsi
callq 0x10d0
incq %r14
jmp 0x1497
pushq $0xa
popq %rdi
callq 0x1030
incl 0x74b9(%rip)            # 0x8988
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x90(%rdi)
je 0x26ad
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x80, %edi
callq 0x2390
testq %rax, %rax
je 0x269e
movq %rax, %r14
movq %rbx, (%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
andl $0x0, 0x20(%rax)
leaq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x2340
leaq 0x58(%r14), %rdi
xorl %esi, %esi
callq 0x2580
movq %r14, 0x90(%rbx)
movq %r14, %rdi
addq $0x8, %rdi
leaq 0x15(%rip), %rdx        # 0x2717
xorl %esi, %esi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2410
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x58(%rdi), %rbx
movq %rbx, %rdi
callq 0x25a0
leaq 0x28(%r14), %r12
xorl %r15d, %r15d
leaq 0x8(%rsp), %r13
pushq $0x1
popq %rbp
xorl %edi, %edi
movq %r13, %rsi
callq 0x2110
movq 0x10(%r14), %rax
addq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2460
cmpl $0x6e, %eax
je 0x276d
testl %eax, %eax
jne 0x2793
cmpl $0x0, 0x20(%r14)
jne 0x2793
movq (%r14), %rdi
cmpl $0x6e, %eax
je 0x2786
movq 0x38(%rdi), %rax
cmpq 0x18(%r14), %rax
jb 0x2743
callq 0x22f0
testl %eax, %eax
cmovneq %rbp, %r15
jmp 0x2743
movq %rbx, %rdi
callq 0x2370
movq %r15, %rdi
callq 0x2380
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
testq %rdi, %rdi
je 0x2822
movl $0x1, 0x20(%rdi)
addq $0x28, %rdi
callq 0x2270
movq 0x90(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2560
xorl %r14d, %r14d
cmpq (%r15), %r14
sbbl %r14d, %r14d
movq 0x90(%rbx), %rdi
addq $0x28, %rdi
callq 0x24a0
movq 0x90(%rbx), %rdi
addq $0x58, %rdi
callq 0x21a0
movq 0x90(%rbx), %rdi
callq 0x2040
andq $0x0, 0x90(%rbx)
jmp 0x2825
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %edi, %eax
notl %eax
xorl %ecx, %ecx
leaq 0x279b(%rip), %rdi      # 0x5000
cmpq %rcx, %rdx
je 0x2883
movl %eax, %r8d
shrl $0x8, %r8d
xorb (%rsi,%rcx), %al
movzbl %al, %eax
xorl (%rdi,%rax,4), %r8d
incq %rcx
movl %r8d, %eax
jmp 0x2865
notl %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x28, %rsp
movl %esi, %eax
orw $-0x1, 0x8(%rsp)
testb $0x1, %al
jne 0x28a5
testb $0x10, %al
je 0x28ab
movw $0x1, 0x8(%rsp)
jmp 0x28ab
andw $0x0, 0x8(%rsp)
pushq $0x7
popq %rsi
btl $0x8, %eax
jb 0x28d0
btl $0xc, %eax
jb 0x28c4
btl $0x10, %eax
jb 0x28c9
pushq $-0x1
jmp 0x28c6
pushq $0x6
popq %rsi
jmp 0x28d0
movw $0x2, 0x8(%rsp)
leaq 0x8(%rsp), %rax
andw $0x0, 0x2(%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
xorl %eax, %eax
callq 0x2100
cltq
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/albertito[P]libjio/libjio/common.c
// Function: spread
ssize_t spread(int fd, void *buf, size_t count, off_t offset)
{
	ssize_t rv;
	size_t c;

	c = 0;

	while (c < count) {
		rv = pread(fd, (char *) buf + c, count - c, offset + c);

		if (rv < 0)
			/* error */
			return rv;
		else if (rv == 0)
			/* got EOF */
			return c;

		/* incomplete read, keep on reading */
		c += rv;
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
xorl %r12d, %r12d
movq %rbx, %rdx
subq %r12, %rdx
jbe 0x2934
leaq (%r15,%r12), %rsi
leaq (%r12,%r14), %rcx
movl %ebp, %edi
callq 0x2500
testq %rax, %rax
js 0x292c
je 0x2931
addq %rax, %r12
jmp 0x2909
movq %rax, %rbx
jmp 0x2934
movq %r12, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albertito[P]libjio/libjio/common.c
// Function: spwrite
ssize_t spwrite(int fd, const void *buf, size_t count, off_t offset)
{
	ssize_t rv;
	size_t c;

	c = 0;

	while (c < count) {
		rv = pwrite(fd, (char *) buf + c, count - c, offset + c);

		if (rv < 0)
			return rv;

		/* incomplete write, keep on writing */
		c += rv;
	}

	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
xorl %r12d, %r12d
movq %rbx, %rdx
subq %r12, %rdx
jbe 0x297a
leaq (%r15,%r12), %rsi
leaq (%r12,%r14), %rcx
movl %ebp, %edi
callq 0x23f0
testq %rax, %rax
js 0x2977
addq %rax, %r12
jmp 0x2956
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/albertito[P]libjio/libjio/common.c
// Function: swritev
ssize_t swritev(int fd, struct iovec *iov, int iovcnt)
{
	int i;
	ssize_t rv;
	size_t c, t, total;

	total = 0;
	for (i = 0; i < iovcnt; i++)
		total += iov[i].iov_len;

	c = 0;
	while (c < total) {
		rv = writev(fd, iov, iovcnt);

		if (rv < 0)
			return rv;

		c += rv;

		/* avoid going into the complex calculations for the common
		 * case of writev() doing a complete write */
		if (c == total)
			break;

		/* incomplete write, advance iov and try again */
		t = 0;
		for (i = 0; i < iovcnt; i++) {
			if (t + iov[i].iov_len > rv) {
				iov[i].iov_base = (char *)
					iov[i].iov_base + rv - t;
				iov[i].iov_len -= rv - t;
				break;
			} else {
				t += iov[i].iov_len;
			}
		}

		iovcnt -= i;
		iov = iov + i;
	}

	return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
shlq $0x4, %rcx
xorl %r12d, %r12d
cmpq %rax, %rcx
je 0x29b8
addq 0x8(%r14,%rax), %r12
addq $0x10, %rax
jmp 0x29a8
xorl %r15d, %r15d
cmpq %r12, %r15
jae 0x2a39
movl %ebp, %edi
movq %r14, %rsi
movl %ebx, %edx
callq 0x20c0
testq %rax, %rax
js 0x2a31
addq %rax, %r15
cmpq %r12, %r15
je 0x2a36
testl %ebx, %ebx
movl $0x0, %edx
cmovgl %ebx, %edx
leaq 0x8(%r14), %rsi
xorl %ecx, %ecx
xorl %edi, %edi
cmpq %rcx, %rdx
je 0x2a08
movq (%rsi), %r8
leaq (%r8,%rdi), %r9
cmpq %rax, %r9
ja 0x2a0d
incq %rcx
addq $0x10, %rsi
movq %r9, %rdi
jmp 0x29eb
movq %rdx, %rcx
jmp 0x2a26
movq -0x8(%rsi), %rdx
addq %rax, %rdx
subq %rdi, %rdx
movq %rdx, -0x8(%rsi)
subq %rax, %rdi
addq %r8, %rdi
movq %rdi, (%rsi)
movl %ecx, %edx
subl %edx, %ebx
shlq $0x4, %rcx
addq %rcx, %r14
jmp 0x29bb
movq %rax, %r15
jmp 0x2a39
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq