LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecCsrrsi
void ExecCsrrsi(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t zimm = instr >> 15 & SetNBits(5);
    uint32_t csr = instr >> 20 & SetNBits(12);

    int64_t t = state->csr[csr];
    state->csr[csr] = t | zimm;
    state->x[rd] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0xc, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movzbl -0xe(%rbp), %eax
orq %rax, %rdx
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecMiscMem
void ExecMiscMem(State *state, uint32_t instr) {
    uint8_t funct3 = instr >> 12 & SetNBits(3);
    if (funct3 == 0x0) {
        ExecFence(state, instr);
    } else if (funct3 == 0x1) {
        ExecFencei(state, instr);
    } else {
        Error("Invalid instruction: MISC-MEM.");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xc, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl $0x3, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x0, %eax
jne 0xb539
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb4d0
jmp 0xb560
movzbl -0xd(%rbp), %eax
cmpl $0x1, %eax
jne 0xb550
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xb4e0
jmp 0xb55e
leaq 0x40f3(%rip), %rdi      # 0xf64a
movb $0x0, %al
callq 0xd690
jmp 0xb560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecAmoaddw
void ExecAmoaddw(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rs2 = instr >> 20 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    int64_t t = Sext(Read32(state, state->x[rs1]), 31);
    Write32(state, state->x[rs1], (uint32_t)(t + state->x[rs2]));
    state->x[rd] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x3100
movl %eax, %eax
movl %eax, %edi
movl $0x1f, %esi
callq 0x4470
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl -0xf(%rbp), %edx
addq 0x8008(%rcx,%rdx,8), %rax
movl %eax, %edx
callq 0x4310
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecLrw
void ExecLrw(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    state->x[rd] = Sext(Read32(state, state->x[rs1]), 31);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x3100
movl %eax, %eax
movl %eax, %edi
movl $0x1f, %esi
callq 0x4470
movq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecScw
void ExecScw(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rs2 = instr >> 20 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    Write32(state, state->x[rs1], (uint32_t)(state->x[rs2]));
    state->x[rd] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
andq %rcx, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzbl -0xf(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rax
movl %eax, %edx
callq 0x4310
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq $0x0, 0x8008(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecAmoaddd
void ExecAmoaddd(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rs2 = instr >> 20 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    int64_t t = Read64(state, state->x[rs1]);
    Write64(state, state->x[rs1], (uint64_t)(t + state->x[rs2]));
    state->x[rd] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x30a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xf(%rbp), %ecx
addq 0x8008(%rax,%rcx,8), %rdx
callq 0x4360
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecLrd
void ExecLrd(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    int64_t t = Read64(state, state->x[rs1]);
    state->x[rd] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x30a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecScd
void ExecScd(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rs2 = instr >> 20 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    int64_t t = Read64(state, state->x[rs1]);
    Write64(state, state->x[rs1], (uint64_t)(state->x[rs2]));
    state->x[rd] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x30a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzbl -0xf(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rdx
callq 0x4360
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq $0x0, 0x8008(%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cpu.c
// Function: ExecAmomind
void ExecAmomind(State *state, uint32_t instr) {
    uint8_t rd = instr >> 7 & SetNBits(5);
    uint8_t rs1 = instr >> 15 & SetNBits(5);
    uint8_t rs2 = instr >> 20 & SetNBits(5);
    uint8_t rl = instr >> 25 & SetNBits(1);
    uint8_t aq = instr >> 26 & SetNBits(1);

    int64_t t = Read64(state, state->x[rs1]);
    if (t < state->x[rs2]) {
        Write64(state, state->x[rs1], (uint64_t)t);
    } else {
        Write64(state, state->x[rs1], (uint64_t)(state->x[rs2]));
    }
    state->x[rd] = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x7, %eax
movl %eax, %eax
movq %rax, -0x48(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
andq %rcx, %rax
movb %al, -0xd(%rbp)
movl -0xc(%rbp), %eax
shrl $0xf, %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x40(%rbp), %rax
andq %rcx, %rax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x14, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x5, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x38(%rbp), %rax
andq %rcx, %rax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x19, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
andq %rcx, %rax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x12b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
andq %rcx, %rax
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
callq 0x30a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl -0xf(%rbp), %edx
cmpq 0x8008(%rcx,%rdx,8), %rax
jge 0xcc40
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rdx
callq 0x4360
jmp 0xcc69
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzbl -0xe(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movzbl -0xf(%rbp), %ecx
movq 0x8008(%rax,%rcx,8), %rdx
callq 0x4360
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl -0xd(%rbp), %ecx
movq %rdx, 0x8008(%rax,%rcx,8)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cutils.c
// Function: CreateVec
Vec *CreateVec() {
    Vec *v = malloc(sizeof(Vec));
    v->cap = sizeof(void *);
    v->len = 0;
    v->data = malloc(sizeof(void *));
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1140
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x8, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x8, %edi
callq 0x1140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cutils.c
// Function: GrowVec
void GrowVec(Vec *v, int n) {
    int size = (v->len + n) * sizeof(void *);
    if (v->cap >= size)
        return;

    while (v->cap < size)
        v->cap *= 2;
    v->data = realloc(v->data, v->cap);
    if (v->data == NULL)
        Error("Failed to allocate memory");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0xc(%rbp), %eax
cltq
shlq $0x3, %rax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jl 0xd36f
jmp 0xd3c0
jmp 0xd371
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x10(%rbp), %eax
jge 0xd388
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
jmp 0xd371
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
callq 0x1160
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd3c0
leaq 0x22e6(%rip), %rdi      # 0xf69f
movb $0x0, %al
callq 0xd690
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/cutils.c
// Function: SetVec
void SetVec(Vec *v, int idx, void *item) {
    if (v->len <= idx || idx < 0) {
        Error("Index out of range in SetVec: %d", idx);
    }

    free(v->data[idx]);
    v->data[idx] = item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jle 0xd495
cmpl $0x0, -0xc(%rbp)
jge 0xd4a6
movl -0xc(%rbp), %esi
leaq 0x2238(%rip), %rdi      # 0xf6d7
movb $0x0, %al
callq 0xd690
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: Error
void Error(const char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "Error: ");
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
    va_end(ap);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0xd6c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x58e1(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x2019(%rip), %rsi      # 0xf73a
movb $0x0, %al
callq 0x1100
movq 0x58c9(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1180
movq 0x58b2(%rip), %rax      # 0x12ff8
movq (%rax), %rdi
leaq 0x1ed0(%rip), %rsi      # 0xf620
movb $0x0, %al
callq 0x1100
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x11a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: NewUart
Uart *NewUart() {
    Uart *uart = calloc(1, sizeof(Uart));
    WINDOW *w = initscr();
    cbreak();
    nodelay(w, true);
    noecho();
    scrollok(w, true);
    uart->lsr |= 0x20;
    return uart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10b, %esi            # imm = 0x10B
callq 0x10e0
movq %rax, -0x8(%rbp)
callq 0x10c0
movq %rax, -0x10(%rbp)
callq 0x1130
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1030
callq 0x1090
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1050
movq -0x8(%rbp), %rax
movzbl 0x6(%rax), %ecx
orl $0x20, %ecx
movb %cl, 0x6(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: NewVirtio
Virtio *NewVirtio() {
    Virtio *virtio = calloc(1, sizeof(Virtio));
    virtio->queue_align = 0x1000;
    virtio->queue_notify = 0x1234;
    return virtio;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x48, %esi
callq 0x10e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1000, 0x14(%rax)     # imm = 0x1000
movq -0x8(%rbp), %rax
movl $0x1234, 0x1c(%rax)     # imm = 0x1234
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: ResetState
void ResetState(State *state) {
    memset(state->x, 0, sizeof(state->x));
    state->pc = 0;
    state->excepted = false;
    state->exception_code = 0;
    memset(state->csr, 0, sizeof(state->csr));
    state->mode = MACHINE;
    state->uart = NewUart();
    state->clint = NewClint();
    state->plic = NewPlic();
    state->virtio = NewVirtio();
    WriteCSR(state, SSTATUS, 32, 33, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8008, %rdi           # imm = 0x8008
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10d0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x8138(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8140(%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x10d0
movq -0x8(%rbp), %rax
movb $0x3, 0x8148(%rax)
callq 0xd770
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8118(%rax)
callq 0xd7e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8120(%rax)
callq 0xd810
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8128(%rax)
callq 0xd840
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8130(%rax)
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
movl $0x21, %ecx
movl $0x2, %r8d
callq 0x1690
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: ReadBinaryFile
size_t ReadBinaryFile(const char *name, uint8_t **buf) {
    FILE *fp = fopen(name, "rb");
    if (fp == NULL) {
        Error("Can't open the file: %s.", name);
    }

    fseek(fp, 0, SEEK_END);
    size_t size = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    uint8_t *result = malloc(size);
    fread(result, size, 1, fp);
    *buf = result;
    fclose(fp);
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1d37(%rip), %rsi      # 0xf742
callq 0x1170
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xda2d
movq -0x8(%rbp), %rsi
leaq 0x1d1f(%rip), %rdi      # 0xf745
movb $0x0, %al
callq 0xd690
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1150
movq -0x18(%rbp), %rdi
callq 0x1110
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1150
movq -0x20(%rbp), %rdi
callq 0x1140
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1060
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x1080
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/main.c
// Function: CPUMain
void CPUMain(State *state, uint64_t start_addr, size_t code_size,
             bool is_debug) {
    uint64_t count = 0;
    state->pc = start_addr;
    for (;;) {
        uint64_t bpc = state->pc;
        count++;
        if (is_debug && count >= 10000)
            return;
        
        // printf("pc: %llx\n", state->pc);
        Tick(state);
        if (state->pc == 0) {
            // printf("pc: %llx -> 0, sp: %llx\n", Translate(state, bpc, AccessInstruction), state->x[2]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
testb $0x1, -0x19(%rbp)
je 0xdafb
cmpq $0x2710, -0x28(%rbp)    # imm = 0x2710
jb 0xdafb
addq $0x30, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x2220
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xdb10
jmp 0xdb10
jmp 0xdace
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hobo0xcc[P]rve/src/test.c
// Function: mulhu
uint64_t mulhu(uint64_t a, uint64_t b)
{
  uint64_t t;
  uint32_t y1, y2, y3;
  uint64_t a0 = (uint32_t)a, a1 = a >> 32;
  uint64_t b0 = (uint32_t)b, b1 = b >> 32;

  t = a1*b0 + ((a0*b0) >> 32);
  y1 = t;
  y2 = t >> 32;

  t = a0*b1 + y1;
  y1 = t;

  t = a1*b1 + y2 + (t >> 32);
  y2 = t;
  y3 = t >> 32;

  return ((uint64_t)y3 << 32) | y2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
imulq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
imulq -0x40(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
imulq -0x48(%rbp), %rax
movl -0x1c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x38(%rbp), %rax
imulq -0x48(%rbp), %rax
movl -0x20(%rbp), %ecx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
shrq $0x20, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
shrq $0x20, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shlq $0x20, %rax
movl -0x20(%rbp), %ecx
orq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/benchmark.c
// Function: benchmark_init
void benchmark_init() {
  db_ = NULL;
  db_num_ = 0;
  num_ = FLAGS_num;
  reads_ = FLAGS_reads < 0 ? FLAGS_num : FLAGS_reads;
  bytes_ = 0;
  rand_gen_init(&gen_, FLAGS_compression_ratio);
  rand_init(&rand_, 301);;

  struct dirent* ep;
  DIR* test_dir = opendir(FLAGS_db);
  if (!FLAGS_use_existing_db) {
    while ((ep = readdir(test_dir)) != NULL) {
      if (starts_with(ep->d_name, "dbbench_sqlite3")) {
        char file_name[1000];
        strcpy(file_name, FLAGS_db);
        strcat(file_name, ep->d_name);
        remove(file_name);
      }
    }
  }
  closedir(test_dir);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq $0x0, 0x1d0b2a(%rip) # 0x5d28f0
movl $0x0, 0x1d0b28(%rip)    # 0x5d28f8
movq $0x5d2948, %rax         # imm = 0x5D2948
movl (%rax), %eax
movl %eax, 0x1d0b1d(%rip)    # 0x5d28fc
movq $0x5d294c, %rax         # imm = 0x5D294C
cmpl $0x0, (%rax)
jge 0x401dfc
movq $0x5d2948, %rax         # imm = 0x5D2948
movl (%rax), %eax
movl %eax, -0x404(%rbp)
jmp 0x401e0b
movq $0x5d294c, %rax         # imm = 0x5D294C
movl (%rax), %eax
movl %eax, -0x404(%rbp)
movl -0x404(%rbp), %eax
movl %eax, 0x1d0ae9(%rip)    # 0x5d2900
movq $0x0, 0x1d0ae6(%rip) # 0x5d2908
movq $0x5d2958, %rax         # imm = 0x5D2958
movsd (%rax), %xmm0
leaq 0x1d0adc(%rip), %rdi    # 0x5d2910
callq 0x4047d0
leaq 0x1d0ae8(%rip), %rdi    # 0x5d2928
movl $0x12d, %esi            # imm = 0x12D
callq 0x404700
movq $0x5d2970, %rax         # imm = 0x5D2970
movq (%rax), %rdi
callq 0x511190
movq %rax, -0x10(%rbp)
movq $0x5d2968, %rax         # imm = 0x5D2968
testb $0x1, (%rax)
jne 0x401ed2
jmp 0x401e6b
movq -0x10(%rbp), %rdi
callq 0x5113f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x401ed0
movq -0x8(%rbp), %rdi
addq $0x13, %rdi
leaq 0x1751f6(%rip), %rsi    # 0x577083
callq 0x4a9f80
testb $0x1, %al
jne 0x401e98
jmp 0x401ece
leaq -0x400(%rbp), %rdi
movq $0x5d2970, %rax         # imm = 0x5D2970
movq (%rax), %rsi
callq 0x401020
leaq -0x400(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x13, %rsi
callq 0x401060
leaq -0x400(%rbp), %rdi
callq 0x4b4300
jmp 0x401e6b
jmp 0x401ed2
movq -0x10(%rbp), %rdi
callq 0x5113c0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/benchmark.c
// Function: print_header
static void print_header() {
  const int kKeySize = 16;
  print_environment();
  fprintf(stderr, "Keys:       %d bytes each\n", kKeySize);
  fprintf(stderr, "Values:     %d bytes each\n", FLAGS_value_size);  
  fprintf(stderr, "Entries:    %d\n", num_);
  fprintf(stderr, "RawSize:    %.1f MB (estimated)\n",
            (((int64_t)(kKeySize + FLAGS_value_size) * num_)
            / 1048576.0));
  print_warnings();
  fprintf(stderr, "------------------------------------------------\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, -0x4(%rbp)
callq 0x403270
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
leaq 0x174ecc(%rip), %rsi    # 0x577351
movl $0x10, %edx
movb $0x0, %al
callq 0x4b40c0
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
movq $0x5d2950, %rax         # imm = 0x5D2950
movl (%rax), %edx
leaq 0x174ec1(%rip), %rsi    # 0x57736c
movb $0x0, %al
callq 0x4b40c0
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
movl 0x1d043a(%rip), %edx    # 0x5d28fc
leaq 0x174ebe(%rip), %rsi    # 0x577387
movb $0x0, %al
callq 0x4b40c0
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
movq $0x5d2950, %rax         # imm = 0x5D2950
movl (%rax), %eax
addl $0x10, %eax
cltq
movslq 0x1d040d(%rip), %rcx    # 0x5d28fc
imulq %rcx, %rax
cvtsi2sd %rax, %xmm0
movsd 0x174b20(%rip), %xmm1   # 0x577020
divsd %xmm1, %xmm0
leaq 0x174e8c(%rip), %rsi    # 0x577397
movb $0x1, %al
callq 0x4b40c0
callq 0x403510
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
leaq 0x17554c(%rip), %rsi    # 0x577a74
movb $0x0, %al
callq 0x4b40c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/benchmark.c
// Function: start
static void start() {
  start_ =  now_micros() * 1e-6;
  bytes_ = 0;
  message_ = malloc(sizeof(char) * 10000);
  strcpy(message_, "");
  last_op_finish_ = start_;
  histogram_clear(&hist_);
  raw_clear(&raw_);
  done_ = 0;
  next_report_ = 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x4a9f50
movq %rax, %xmm0
movaps 0x17481b(%rip), %xmm1   # 0x577030
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x17481f(%rip), %xmm1   # 0x577040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x1747d8(%rip), %xmm1   # 0x577010
mulsd %xmm1, %xmm0
movsd %xmm0, 0x1d00f4(%rip)   # 0x5d2938
movq $0x0, 0x1d00b9(%rip) # 0x5d2908
movl $0x2710, %edi           # imm = 0x2710
callq 0x4d4850
movq %rax, 0x1d00d0(%rip)    # 0x5d2930
movq 0x1d00c9(%rip), %rdi    # 0x5d2930
leaq 0x19d69f(%rip), %rsi    # 0x59ff0d
callq 0x401020
movsd 0x1d00bd(%rip), %xmm0   # 0x5d2938
movsd %xmm0, 0x1cfb4d(%rip)   # 0x5d23d0
leaq 0x1cfb4e(%rip), %rdi    # 0x5d23d8
callq 0x403550
leaq 0x1d003a(%rip), %rdi    # 0x5d28d0
callq 0x404aa0
movl $0x0, 0x1d0043(%rip)    # 0x5d28e8
movl $0x64, 0x1d003d(%rip)   # 0x5d28ec
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/benchmark.c
// Function: exec_error_check
inline
static void exec_error_check(int status, char *err_msg) {
  if (status != SQLITE_OK) {
    fprintf(stderr, "SQL error: %s\n", err_msg);
    sqlite3_free(err_msg);
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x403224
movq $0x5d07a8, %rax         # imm = 0x5D07A8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1742ea(%rip), %rsi    # 0x5774f4
movb $0x0, %al
callq 0x4b40c0
movq -0x10(%rbp), %rdi
callq 0x406240
movl $0x1, %edi
callq 0x4b3590
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/histogram.c
// Function: histogram_clear
void histogram_clear(Histogram* hist_) {
  hist_->min_ = bucket_limit[kNumBuckets - 1];
  hist_->max_ = 0;
  hist_->num_ = 0;
  hist_->sum_ = 0;
  hist_->sum_squares_ = 0;
  for (int i = 0; i < kNumBuckets; i++) {
    hist_->buckets_[i] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd 0x1744b8(%rip), %xmm0   # 0x577a18
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x9a, -0xc(%rbp)
jge 0x4035c4
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40359f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/histogram.c
// Function: histogram_add
void histogram_add(Histogram* hist_, double value) {
  int b = 0;
  while (b < kNumBuckets - 1 && bucket_limit[b] <= value) {
    b++;
  }
  hist_->buckets_[b] += 1.0;
  if (hist_->min_ > value) hist_->min_ = value;
  if (hist_->max_ < value) hist_->max_ = value;
  hist_->num_++;
  hist_->sum_ += value;
  hist_->sum_squares_ += (value * value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x99, -0x14(%rbp)
movb %al, -0x15(%rbp)
jge 0x403611
movslq -0x14(%rbp), %rcx
leaq 0x173f53(%rip), %rax    # 0x577550
movsd (%rax,%rcx,8), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x40361a
jmp 0x403625
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4035e4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd 0x173eeb(%rip), %xmm0   # 0x577520
addsd 0x28(%rax,%rcx,8), %xmm0
movsd %xmm0, 0x28(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x40365d
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x40367f
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd 0x173e95(%rip), %xmm0   # 0x577520
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/histogram.c
// Function: histogram_merge
void histogram_merge(Histogram* hist_, const Histogram* other_) {
  if (other_->min_ < hist_->min_) hist_->min_ = other_->min_;
  if (other_->max_ > hist_->max_) hist_->max_ = other_->max_;
  hist_->num_ += other_->num_;
  hist_->sum_ += other_->sum_;
  hist_->sum_squares_ += other_->sum_squares_;
  for (int b = 0; b < kNumBuckets; b++) {
    hist_->buckets_[b] += other_->buckets_[b];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x403702
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x403728
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x9a, -0x14(%rbp)
jge 0x4037aa
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd 0x28(%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
addsd 0x28(%rax,%rcx,8), %xmm0
movsd %xmm0, 0x28(%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x403774
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/histogram.c
// Function: percentile
static double percentile(Histogram* hist_, double p) {
  double threshold = hist_->num_ * (p / 100.0);
  double sum = 0;
  for (int b = 0; b < kNumBuckets; b++) {
    sum += hist_->buckets_[b];
    if (sum >= threshold) {
      /* Scale linearly within this bucket */
      double left_point = (b == 0) ? 0 : bucket_limit[b - 1];
      double right_point = bucket_limit[b];
      double left_sum = sum - hist_->buckets_[b];
      double right_sum = sum;
      double pos = (threshold - left_sum) / (right_sum - left_sum);
      double r = left_point + (right_point - left_point) * pos;
      if (r < hist_->min_) r = hist_->min_;
      if (r > hist_->max_) r = hist_->max_;
      return r;
    }
  }
  return hist_->max_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x173725(%rip), %xmm2   # 0x577528
divsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x9a, -0x2c(%rbp)
jge 0x403f57
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd 0x28(%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x403f47
cmpl $0x0, -0x2c(%rbp)
jne 0x403e64
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
jmp 0x403e7e
movl -0x2c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x1736dc(%rip), %rax    # 0x577550
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x1736bd(%rip), %rax    # 0x577550
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
subsd 0x28(%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x20(%rbp), %xmm0
subsd -0x48(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
subsd -0x48(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd -0x38(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
subsd -0x38(%rbp), %xmm0
movsd -0x58(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm1
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x403f1d
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movq -0x10(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jbe 0x403f3b
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x60(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x403f65
jmp 0x403f49
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x403e1f
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: rand_init
void rand_init(Random* rand_, uint32_t s) {
  rand_->seed_ = s & 0x7fffffffu;
  /* Avoid bad seeds. */
  if (rand_->seed_ == 0 || rand_->seed_ == 2147483647L) {
    rand_->seed_ = 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x404731
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x40473b
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: rand_next
uint32_t rand_next(Random* rand_) {
  static const uint32_t M = 2147483647L;
  static const uint64_t A = 16807;

  uint64_t product = rand_->seed_ * A;

  rand_->seed_ = (uint32_t)((product >> 31) + (product & M));

  if (rand_->seed_ > M) {
    rand_->seed_ -= M;
  }

  return rand_->seed_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x1f, %rax
movq -0x10(%rbp), %rcx
andq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rcx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
jbe 0x404791
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: rand_gen_init
void rand_gen_init(RandomGenerator* gen_, double compression_ratio) {
  Random rnd;
  char* piece;
  
  gen_->data_ = malloc(sizeof(char) * 1048576);
  gen_->data_size_ = 0;
  gen_->pos_ = 0;
  (gen_->data_)[0] = '\0';

  rand_init(&rnd, 301);
  while (gen_->data_size_ < 1048576) {
    piece = compressible_string(&rnd, compression_ratio, 100);
    strcat(gen_->data_, piece);
    gen_->data_size_ += strlen(piece);
  }

  free(piece);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movl $0x100000, %edi         # imm = 0x100000
callq 0x4d4850
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
leaq -0x14(%rbp), %rdi
movl $0x12d, %esi            # imm = 0x12D
callq 0x404700
movq -0x8(%rbp), %rax
cmpq $0x100000, 0x8(%rax)    # imm = 0x100000
jae 0x404873
movsd -0x10(%rbp), %xmm0
leaq -0x14(%rbp), %rdi
movl $0x64, %esi
callq 0x404890
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x401060
movq -0x20(%rbp), %rdi
callq 0x4010f8
movq %rax, %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x404824
movq -0x20(%rbp), %rdi
callq 0x4d4b90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: compressible_string
static char *compressible_string(Random* rnd, double compressed_fraction,
                                  size_t len) {
  int raw = (int)(len * compressed_fraction);
  if (raw < 1) raw = 1;
  char* raw_data = random_string(rnd, raw);
  size_t raw_data_len = strlen(raw_data);

  int pos = 0;
  char* dst = malloc(sizeof(char) * (len + 1));
  dst[0] = '\0';
  while (pos < len) {
    strcat(dst, raw_data);
    pos += raw_data_len;
  }

  return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movaps 0x172784(%rip), %xmm1   # 0x577030
movq -0x18(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x172783(%rip), %xmm1   # 0x577040
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
mulsd -0x10(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jge 0x4048e5
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x404a20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4010f8
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x4d4850
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movb $0x0, (%rax)
movslq -0x34(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x40494c
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x401060
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x34(%rbp)
jmp 0x404925
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: rand_gen_generate
char* rand_gen_generate(RandomGenerator* gen_, int len) {
  if (gen_->pos_ + len > gen_->data_size_) {
    gen_->pos_ = 0;
    assert(len < gen_->data_size_);
  }
  gen_->pos_ += len;
  char* substr = malloc(sizeof(char) * (len + 1));
  strncpy(substr, (gen_->data_) + gen_->pos_ - len, len);

  return substr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl -0xc(%rbp), %eax
cltq
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4049c1
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x4049a0
jmp 0x4049bf
leaq 0x173829(%rip), %rdi    # 0x5781d0
leaq 0x173839(%rip), %rsi    # 0x5781e7
movl $0x5b, %edx
leaq 0x173836(%rip), %rcx    # 0x5781f0
callq 0x4ace30
jmp 0x4049c1
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x4d4850
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movslq -0xc(%rbp), %rdx
callq 0x401090
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/random.c
// Function: random_string
static char *random_string(Random* rnd, int len) {
  char* dst = malloc(sizeof(char) * (size_t)(len + 1));
  for (int i = 0; i < len; i++) {
    dst[i] = (char)(' ' + rand_uniform(rnd, 95));
  }
  dst[len] = '\0';

  return dst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x4d4850
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x404a7d
movq -0x8(%rbp), %rdi
movl $0x5f, %esi
callq 0x4047a0
addl $0x20, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x404a4c
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ukontainer[P]sqlite-bench/raw.c
// Function: raw_add
void raw_add(Raw *raw_, double value) {
  if (!raw_->data_)
    raw_calloc(raw_);
  if (raw_->data_size_ < raw_->pos_ + 1)
    raw_realloc(raw_);
  raw_->data_[raw_->pos_] = value;
  raw_->pos_++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x404b54
movq -0x8(%rbp), %rdi
callq 0x404ae0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x404b77
movq -0x8(%rbp), %rdi
callq 0x404bb0
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)