LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/match.c
// Function: fmd_smem
int fmd_smem(const rld_t *e, const uint8_t *q, fmdsmem_v *mem, int min_occ, rldintv_v *curr, rldintv_v *prev)
{
	int x = 0, len;
	mem->n = 0;
	len = strlen((char*)q);
	do {
		x = fmd_smem1_core(e, min_occ, len, q, x, mem, curr, prev);
	} while (x < len);
	return mem->n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x20f0
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x38(%rbp), %edx
movq -0x10(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq -0x18(%rbp), %r9
movq -0x28(%rbp), %r10
movq -0x30(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x27490
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jl 0x27eed
movq -0x18(%rbp), %rax
movq (%rax), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/match.c
// Function: fm_exact
void fm_exact(const rld_t *e, const char *s, int64_t *_l, int64_t *_u)
{
	extern unsigned char seq_nt6_table[128];
	int64_t i, l = 0, u = e->mcnt[0];
	for (i = strlen(s) - 1; i >= 0; --i) {
		int c = (uint8_t)s[i];
		c = c < 6? c : c < 128? seq_nt6_table[c] : 5;
		l = e->cnt[c] + rld_rank11(e, l, c);
		u = e->cnt[c] + rld_rank11(e, u, c);
		if (l >= u) break;
	}
	*_l = l, *_u = u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20f0
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x2805e
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x6, -0x3c(%rbp)
jge 0x27fa8
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x27fd5
cmpl $0x80, -0x3c(%rbp)
jge 0x27fc5
movslq -0x3c(%rbp), %rcx
leaq 0xb234(%rip), %rax      # 0x331f0
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
jmp 0x27fcf
movl $0x5, %eax
movl %eax, -0x44(%rbp)
jmp 0x27fcf
movl -0x44(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x3ee0
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x3ee0
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jl 0x2804b
jmp 0x2805e
jmp 0x2804d
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x27f80
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/console.c
// Function: console_init
void _console_init(void) {
    tcgetattr(0, &_old_term);
    
    _new_term = _old_term;
    
    _new_term.c_lflag &= ~ICANON; /* Input available immediately (no EOL needed) */
    _new_term.c_lflag &= ~ECHO; /* Do not echo input characters */
    _new_term.c_lflag &= ~ISIG; /* ^C and ^Z do not generate signals */
    _new_term.c_iflag &= INLCR; /* Translate NL to CR on input */
    
    tcsetattr(0, TCSANOW, &_new_term); /* Apply changes immediately */
    
    setvbuf(stdout, (char *)NULL, _IONBF, 0); /* Disable stdout buffering */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
leaq 0x177ff(%rip), %rsi     # 0x209dc
callq 0x90a0
leaq 0x1782f(%rip), %rdi     # 0x20a18
leaq 0x177ec(%rip), %rsi     # 0x209dc
movl $0x3c, %edx
callq 0x9080
movl 0x17824(%rip), %eax     # 0x20a24
andl $-0x3, %eax
movl %eax, 0x1781b(%rip)     # 0x20a24
movl 0x17815(%rip), %eax     # 0x20a24
andl $-0x9, %eax
movl %eax, 0x1780c(%rip)     # 0x20a24
movl 0x17806(%rip), %eax     # 0x20a24
andl $-0x2, %eax
movl %eax, 0x177fd(%rip)     # 0x20a24
movl 0x177eb(%rip), %eax     # 0x20a18
andl $0x40, %eax
movl %eax, 0x177e2(%rip)     # 0x20a18
xorl %esi, %esi
leaq 0x177d9(%rip), %rdx     # 0x20a18
movl %esi, %edi
callq 0x90b0
movq 0x14d93(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %edx
movq %rcx, %rsi
callq 0x9090
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/z80.c
// Function: z80_new
z80 *z80_new() {
    _console_init();
    z80 *cpu = calloc(1, sizeof(z80));
    z80_reset(cpu);
    return cpu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x91d0
movl $0x1, %edi
movl $0x10060, %esi          # imm = 0x10060
callq 0x9060
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9460
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/z80.c
// Function: z80_reset
void z80_reset(z80 *cpu) {
    PC = 0;
    IFF = 0;
    IR = 0;
    cpu->status = 0;
    cpu->debug = 0;
    cpu->brk = -1;
    cpu->step = -1;
#if defined(DEBUG) || defined(iDEBUG)
    cpu->watch = -1;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x44(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x4c(%rax) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/z80.c
// Function: watchprint
void watchprint(z80 *cpu, uint16_t pos) {
    uint8_t I, J;
    _puts("\r\n");
    _puts("  Watch : "); _puthex16(cpu->watch);
    _puts(" = "); _puthex8(_RamRead(cpu->watch)); _putcon(':'); _puthex8(_RamRead(cpu->watch + 1));
    _puts(" / ");
    for (J = 0, I = _RamRead(cpu->watch); J < 8; ++J, I <<= 1) _putcon(I & 0x80 ? '1' : '0');
    _putcon(':');
    for (J = 0, I = _RamRead(cpu->watch + 1); J < 8; ++J, I <<= 1) _putcon(I & 0x80 ? '1' : '0');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
leaq 0x1081d(%rip), %rdi     # 0x19d37
callq 0x92f0
leaq 0x106ea(%rip), %rdi     # 0x19c10
callq 0x92f0
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
movzwl %ax, %edi
callq 0x93b0
leaq 0x106da(%rip), %rdi     # 0x19c1b
callq 0x92f0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4c(%rcx), %rcx
movzbl 0x60(%rax,%rcx), %edi
callq 0x9330
movl $0x3a, %edi
callq 0x92c0
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4c(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl 0x60(%rax,%rcx), %edi
callq 0x9330
leaq 0x10697(%rip), %rdi     # 0x19c1f
callq 0x92f0
movb $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x4c(%rcx), %rcx
movb 0x60(%rax,%rcx), %al
movb %al, -0xb(%rbp)
movzbl -0xc(%rbp), %eax
cmpl $0x8, %eax
jge 0x95e2
movzbl -0xb(%rbp), %edx
andl $0x80, %edx
movl $0x30, %eax
movl $0x31, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movzbl %al, %edi
callq 0x92c0
movb -0xc(%rbp), %al
addb $0x1, %al
movb %al, -0xc(%rbp)
movzbl -0xb(%rbp), %eax
shll %eax
movb %al, -0xb(%rbp)
jmp 0x95a4
movl $0x3a, %edi
callq 0x92c0
movb $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x4c(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb 0x60(%rax,%rcx), %al
movb %al, -0xb(%rbp)
movzbl -0xc(%rbp), %eax
cmpl $0x8, %eax
jge 0x9646
movzbl -0xb(%rbp), %edx
andl $0x80, %edx
movl $0x30, %eax
movl $0x31, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movzbl %al, %edi
callq 0x92c0
movb -0xc(%rbp), %al
addb $0x1, %al
movb %al, -0xc(%rbp)
movzbl -0xb(%rbp), %eax
shll %eax
movb %al, -0xb(%rbp)
jmp 0x9608
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/z80.c
// Function: memdump
void memdump(z80 *cpu, uint16_t pos) {
    uint16_t h = pos;
    uint16_t c = pos;
    uint8_t l, i;
    uint8_t ch = pos & 0xff;

    _puts("       ");
    for (i = 0; i < 16; ++i) {
        _puthex8(ch++ & 0x0f);
        _puts(" ");
    }
    _puts("\r\n");
    _puts("       ");
    for (i = 0; i < 16; ++i)
        _puts("---");
    _puts("\r\n");
    for (l = 0; l < 16; ++l) {
        _puthex16(h);
        _puts(" : ");
        for (i = 0; i < 16; ++i) {
            _puthex8(_RamRead(h++));
            _puts(" ");
        }
        for (i = 0; i < 16; ++i) {
            ch = _RamRead(c++);
            _putcon(ch > 31 && ch < 127 ? ch : '.');
        }
        _puts("\r\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xc(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xe(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
leaq 0x1059d(%rip), %rdi     # 0x19c23
callq 0x92f0
movb $0x0, -0x10(%rbp)
movzbl -0x10(%rbp), %eax
cmpl $0x10, %eax
jge 0x96c7
movb -0x11(%rbp), %al
movb %al, %cl
addb $0x1, %cl
movb %cl, -0x11(%rbp)
movzbl %al, %eax
andl $0xf, %eax
movzbl %al, %edi
callq 0x9330
leaq 0x10571(%rip), %rdi     # 0x19c29
callq 0x92f0
movb -0x10(%rbp), %al
addb $0x1, %al
movb %al, -0x10(%rbp)
jmp 0x968f
leaq 0x10669(%rip), %rdi     # 0x19d37
callq 0x92f0
leaq 0x10549(%rip), %rdi     # 0x19c23
callq 0x92f0
movb $0x0, -0x10(%rbp)
movzbl -0x10(%rbp), %eax
cmpl $0x10, %eax
jge 0x9702
leaq 0x10538(%rip), %rdi     # 0x19c2b
callq 0x92f0
movb -0x10(%rbp), %al
addb $0x1, %al
movb %al, -0x10(%rbp)
jmp 0x96e3
leaq 0x1062e(%rip), %rdi     # 0x19d37
callq 0x92f0
movb $0x0, -0xf(%rbp)
movzbl -0xf(%rbp), %eax
cmpl $0x10, %eax
jge 0x97f4
movzwl -0xc(%rbp), %edi
callq 0x93b0
leaq 0x10546(%rip), %rdi     # 0x19c75
callq 0x92f0
movb $0x0, -0x10(%rbp)
movzbl -0x10(%rbp), %eax
cmpl $0x10, %eax
jge 0x9777
movq -0x8(%rbp), %rax
movw -0xc(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0xc(%rbp)
movzwl %cx, %ecx
movzbl 0x60(%rax,%rcx), %edi
callq 0x9330
leaq 0x104c1(%rip), %rdi     # 0x19c29
callq 0x92f0
movb -0x10(%rbp), %al
addb $0x1, %al
movb %al, -0x10(%rbp)
jmp 0x9738
movb $0x0, -0x10(%rbp)
movzbl -0x10(%rbp), %eax
cmpl $0x10, %eax
jge 0x97db
movq -0x8(%rbp), %rax
movw -0xe(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0xe(%rbp)
movzwl %cx, %ecx
movb 0x60(%rax,%rcx), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x1f, %eax
jle 0x97bc
movzbl -0x11(%rbp), %eax
cmpl $0x7f, %eax
jge 0x97bc
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x97c6
movl $0x2e, %eax
movl %eax, -0x18(%rbp)
jmp 0x97c6
movl -0x18(%rbp), %eax
movzbl %al, %edi
callq 0x92c0
movb -0x10(%rbp), %al
addb $0x1, %al
movb %al, -0x10(%rbp)
jmp 0x977b
leaq 0x10555(%rip), %rdi     # 0x19d37
callq 0x92f0
movb -0xf(%rbp), %al
addb $0x1, %al
movb %al, -0xf(%rbp)
jmp 0x9712
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/main.c
// Function: main
int main(int argc, char *argv[])
{
    /*
     * Instantiate the CPU, activate the debug mode, set the intercept
     * function and run the virtual CPU until the termination criteria
     * set by the intercept function, if any, are met.
     */
    z80 *cpu = z80_new();
    cpu->debug = 1;
    z80_set_intercept(cpu, cpu, intercept);
    z80_run(cpu);
    z80_destroy(cpu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x9420
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2c(%rip), %rdx        # 0x156e0
callq 0x94d0
movq -0x18(%rbp), %rdi
callq 0xa2e0
movq -0x18(%rbp), %rdi
callq 0x15660
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/algodesigner[P]z80/main.c
// Function: intercept
static void intercept(void *ctx)
{
    z80 *cpu = ctx;
    if (PC == 5) {
        puts("\nReached address: 5, terminating the simulation...");
        cpu->status = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x5, 0x1c(%rax)
jne 0x15715
leaq 0x67ff(%rip), %rdi      # 0x1bf04
callq 0x9050
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Seabug";

    scg_app_t app;
    scg_app_init(&app, config);

    seabug_t seabug;
    init(&app, &seabug);

    float32_t animation_time = 0.0f;

    while (scg_app_process_events(&app)) {
        animation_time += SEABUG_ANIMATION_SPEED * app.delta_time;
        update(&seabug, animation_time);

        draw(app.draw_target, seabug);

        scg_app_present(&app);
    }

    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xbd0, %rsp            # imm = 0xBD0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49f0
leaq 0x1e93(%rip), %rax      # 0x85ac
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a40
leaq -0xa0(%rbp), %rdi
leaq -0x630(%rbp), %rsi
callq 0x6800
xorps %xmm0, %xmm0
movss %xmm0, -0x634(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x56c0
testb $0x1, %al
jne 0x6773
jmp 0x67e9
movss -0x9c(%rbp), %xmm0
movss -0x634(%rbp), %xmm1
movss 0x18ad(%rip), %xmm2     # 0x8038
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x634(%rbp)
movss -0x634(%rbp), %xmm0
leaq -0x630(%rbp), %rdi
callq 0x6980
movq -0x68(%rbp), %rax
movq %rax, -0x640(%rbp)
movq %rsp, %rdi
movl $0xb2, %ecx
leaq -0x630(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq -0x640(%rbp), %rdi
callq 0x6a70
leaq -0xa0(%rbp), %rdi
callq 0x5810
jmp 0x6761
leaq -0xa0(%rbp), %rdi
callq 0x5cc0
xorl %eax, %eax
addq $0xbd0, %rsp            # imm = 0xBD0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: update
static void update(seabug_t *seabug, float32_t animation_time) {
    const float32_t lissajous_scale = 100.0f;
    const float32_t lissajous_a = 3.0f;
    const float32_t lissajous_b = 4.0f;
    float32_t lissajous_t = animation_time * 0.01f;

    seabug->x = lissajous_scale * cosf(lissajous_a * lissajous_t);
    seabug->y = lissajous_scale * sinf(lissajous_b * lissajous_t);

    for (int i = 0; i < SEABUG_NUM_LEGS; i++) {
        seabug_leg_update(&seabug->legs[i], animation_time + i);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss 0x16a3(%rip), %xmm0     # 0x803c
movss %xmm0, -0x10(%rbp)
movss 0x169e(%rip), %xmm0     # 0x8044
movss %xmm0, -0x14(%rbp)
movss 0x168d(%rip), %xmm0     # 0x8040
movss %xmm0, -0x18(%rbp)
movss 0x1688(%rip), %xmm0     # 0x8048
mulss -0xc(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss 0x1672(%rip), %xmm0     # 0x8044
mulss -0x1c(%rbp), %xmm0
callq 0x2180
movaps %xmm0, %xmm1
movss 0x1655(%rip), %xmm0     # 0x803c
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, (%rax)
movss 0x1645(%rip), %xmm0     # 0x8040
mulss -0x1c(%rbp), %xmm0
callq 0x21d0
movaps %xmm0, %xmm1
movss 0x162c(%rip), %xmm0     # 0x803c
mulss %xmm1, %xmm0
movq -0x8(%rbp), %rax
movss %xmm0, 0x4(%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x20, -0x20(%rbp)
jge 0x6a5b
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movslq -0x20(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rdi
movss -0xc(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm1
addss %xmm1, %xmm0
callq 0x6e70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6a24
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: draw
static void draw(scg_image_t *draw_target, seabug_t seabug) {
    float32_t x = seabug.origin_x + seabug.x;
    float32_t y = seabug.origin_y + seabug.y;

    draw_background(draw_target, x, y);

    for (int i = 0; i < SEABUG_NUM_LEGS; i++) {
        seabug_leg_draw(draw_target, x, y, &seabug.legs[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movss 0x8(%rax), %xmm0
addss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss 0xc(%rax), %xmm0
addss 0x4(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
callq 0x7100
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x6af2
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rdi
movss -0xc(%rbp), %xmm0
movss -0x10(%rbp), %xmm1
addq $0x10, %rsi
movslq -0x14(%rbp), %rax
imulq $0x24, %rax, %rax
addq %rax, %rsi
callq 0x7280
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6abb
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: linear_gradient_colors
static void linear_gradient_colors(scg_pixel_t *out, int stops,
                                   scg_pixel_t start, scg_pixel_t end) {
    float32_t step_factor = 1.0f / (float32_t)(stops - 1);

    for (int i = 0; i < stops; i++) {
        float32_t t = step_factor * (float32_t)i;
        out[i] = scg_pixel_lerp_rgb(start, end, t);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edx, -0x4(%rbp)
movl %ecx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
cvtsi2ss %eax, %xmm1
movss 0x1211(%rip), %xmm0     # 0x8008
divss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6e60
movss -0x18(%rbp), %xmm0
cvtsi2ssl -0x1c(%rbp), %xmm1
mulss %xmm1, %xmm0
movss %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movss -0x20(%rbp), %xmm0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2a20
movq -0x38(%rbp), %rcx
movl %eax, %edx
movq -0x30(%rbp), %rax
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e07
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: draw_background
static void draw_background(scg_image_t *draw_target, float32_t cx,
                            float32_t cy) {
    float32_t w = draw_target->width;
    float32_t h = draw_target->height;

    float32_t d = sqrtf(w * w + h * h);

    for (int y = 0; y < h; y++) {
        for (int x = 0; x < w; x++) {
            float32_t dx = cx - (float32_t)x;
            float32_t dy = cy - (float32_t)y;
            float32_t dist = sqrtf(dx * dx + dy * dy);

            float32_t t = (dist / d) * 2.0f;
            scg_pixel_t color = scg_pixel_lerp_rgb(BACKGROUND_GRADIENT_START,
                                                   BACKGROUND_GRADIENT_END, t);

            int i = scg_pixel_index_from_xy(x, y, w);
            draw_target->pixels[i] = color.packed;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl (%rax), %xmm0
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
movss -0x18(%rbp), %xmm1
mulss -0x18(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x23b0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm1
movss -0x18(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7273
movl $0x0, -0x24(%rbp)
cvtsi2ssl -0x24(%rbp), %xmm1
movss -0x14(%rbp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x7263
movss -0xc(%rbp), %xmm0
cvtsi2ssl -0x24(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x28(%rbp)
movss -0x10(%rbp), %xmm0
cvtsi2ssl -0x20(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x28(%rbp), %xmm0
movss -0x28(%rbp), %xmm2
movss -0x2c(%rbp), %xmm1
mulss -0x2c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
callq 0x23b0
movss %xmm0, -0x30(%rbp)
movss -0x30(%rbp), %xmm0
divss -0x1c(%rbp), %xmm0
movss 0xe27(%rip), %xmm1      # 0x8010
mulss %xmm1, %xmm0
movss %xmm0, -0x34(%rbp)
movb $-0x5f, -0x3c(%rbp)
movb $0x47, -0x3b(%rbp)
movb $0xd, -0x3a(%rbp)
movb $-0x1, -0x39(%rbp)
movb $0x26, -0x40(%rbp)
movb $0x11, -0x3f(%rbp)
movb $0xd, -0x3e(%rbp)
movb $-0x1, -0x3d(%rbp)
movss -0x34(%rbp), %xmm0
movl -0x3c(%rbp), %edi
movl -0x40(%rbp), %esi
callq 0x2a20
movl %eax, -0x38(%rbp)
cvtsi2ssl -0x20(%rbp), %xmm0
movss -0x14(%rbp), %xmm2
cvtsi2ssl -0x24(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x44(%rbp)
movl -0x38(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7178
jmp 0x7265
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x715e
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/seabug.c
// Function: seabug_leg_draw
static void seabug_leg_draw(scg_image_t *draw_target, float32_t tx,
                            float32_t ty, seabug_leg_t *leg) {
    float32_t x0 = tx + leg->x0;
    float32_t y0 = ty + leg->y0;
    float32_t x1 = tx + leg->x1;
    float32_t y1 = ty + leg->y1;
    float32_t x2 = tx + leg->x2;
    float32_t y2 = ty + leg->y2;

    scg_pixel_t left_side_color = leg->left_side_color;
    scg_pixel_t right_side_color = leg->right_side_color;

    scg_image_draw_line(draw_target, x0, y0, x1, y1, left_side_color);
    scg_image_draw_line(draw_target, x0, y0, x2, y2, right_side_color);

    int r = leg->point_radius;
    scg_image_fill_circle(draw_target, x0, y0, r, SCG_COLOR_WHITE);
    scg_image_fill_circle(draw_target, x1, y1, r, left_side_color);
    scg_image_fill_circle(draw_target, x2, y2, r, right_side_color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x8(%rax), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0xc(%rax), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x10(%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movss -0xc(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x14(%rax), %xmm0
movss %xmm0, -0x2c(%rbp)
movss -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
addss 0x18(%rax), %xmm0
movss %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
cvttss2si -0x1c(%rbp), %esi
cvttss2si -0x20(%rbp), %edx
cvttss2si -0x24(%rbp), %ecx
cvttss2si -0x28(%rbp), %r8d
movl -0x34(%rbp), %r9d
callq 0x3a90
movq -0x8(%rbp), %rdi
cvttss2si -0x1c(%rbp), %esi
cvttss2si -0x20(%rbp), %edx
cvttss2si -0x2c(%rbp), %ecx
cvttss2si -0x30(%rbp), %r8d
movl -0x38(%rbp), %r9d
callq 0x3a90
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
cvttss2si -0x1c(%rbp), %esi
cvttss2si -0x20(%rbp), %edx
movl -0x3c(%rbp), %ecx
movb $-0x1, -0x40(%rbp)
movb $-0x1, -0x3f(%rbp)
movb $-0x1, -0x3e(%rbp)
movb $-0x1, -0x3d(%rbp)
movl -0x40(%rbp), %r8d
callq 0x3f20
movq -0x8(%rbp), %rdi
cvttss2si -0x24(%rbp), %esi
cvttss2si -0x28(%rbp), %edx
movl -0x3c(%rbp), %ecx
movl -0x34(%rbp), %r8d
callq 0x3f20
movq -0x8(%rbp), %rdi
cvttss2si -0x2c(%rbp), %esi
cvttss2si -0x30(%rbp), %edx
movl -0x3c(%rbp), %ecx
movl -0x38(%rbp), %r8d
callq 0x3f20
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pyk[P]simple-nn/deps/pcg/sample/pcg32x2-demo.c
// Function: pcg32x2_srandom_r
void pcg32x2_srandom_r(pcg32x2_random_t* rng, uint64_t seed1, uint64_t seed2,
                       uint64_t seq1,  uint64_t seq2)
{
    uint64_t mask = ~0ull >> 1;
    // The stream for each of the two generators *must* be distinct
    if ((seq1 & mask) == (seq2 & mask)) 
        seq2 = ~seq2;
    pcg32_srandom_r(rng->gen,   seed1, seq1);
    pcg32_srandom_r(rng->gen+1, seed2, seq2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
andq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
andq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jne 0x11eb
movq -0x28(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1b30
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1b30
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixclip/fixclip.c
// Function: dip
static void
dip(RRA *r,int channel,int start,int finish)
    {
    int mid = (start + finish) / 2;
    if (r->data[channel][mid] > 0)
        {
        r->data[channel][mid] =
            r->data[channel][mid] - DipFactor * (finish - start);
        assert(r->data[channel][mid] <= Max);
        }
    else
        {
        r->data[channel][mid] =
            r->data[channel][mid] + DipFactor * (finish - start);
        assert(r->data[channel][mid] >= Min);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x1c88
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movl 0x6513(%rip), %eax      # 0x8134
movl -0x14(%rbp), %ecx
subl -0x10(%rbp), %ecx
imull %ecx, %eax
subl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x64f0(%rip), %eax      # 0x8150
jg 0x1c64
jmp 0x1c83
leaq 0x3487(%rip), %rdi      # 0x50f2
leaq 0x349d(%rip), %rsi      # 0x510f
movl $0x21, %edx
leaq 0x349b(%rip), %rcx      # 0x5119
callq 0x10b0
jmp 0x1d09
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movl 0x648f(%rip), %eax      # 0x8134
movl -0x14(%rbp), %ecx
subl -0x10(%rbp), %ecx
imull %ecx, %eax
addl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x6468(%rip), %eax      # 0x814c
jl 0x1ce8
jmp 0x1d07
leaq 0x3449(%rip), %rdi      # 0x5138
leaq 0x3419(%rip), %rsi      # 0x510f
movl $0x27, %edx
leaq 0x3417(%rip), %rcx      # 0x5119
callq 0x10b0
jmp 0x1d09
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop.c
// Function: hw_warmup
static void
hw_warmup(cache_line_t* cl, const size_t warmup_reps, barrier2_t* barrier2, const int tid, mctop_prof_t* profiler)
{
  for (size_t rep = 0; rep < (warmup_reps + 1); rep++)
    {
      if (tid == 0)
	{
	  barrier2_cross(barrier2, tid, rep);
	  ATOMIC_OP(cl, rep, profiler);
	}
      else
	{
	  ATOMIC_OP(cl, rep, profiler);
	  barrier2_cross(barrier2, tid, rep);      
	}
    }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2efe
cmpl $0x0, -0x1c(%rbp)
jne 0x2ecd
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x74a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2f10
jmp 0x2eee
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x2f10
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x74a0
jmp 0x2ef0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2e93
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop.c
// Function: cas_prof
UNUSED static uint64_t
cas_prof(cache_line_t* cl, const size_t reps, mctop_prof_t* profiler)
{
  volatile uint64_t c = 0;
  MCTOP_PROF_START(profiler, ticks_start);
  c = CAS_U64(cl->word, 0, 1);
  MCTOP_PROF_STOP(profiler, ticks_start, reps);
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x66f0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl $0x1, %edx
lock
cmpxchgq %rdx, (%rcx)
sete %cl
movq %rax, -0x20(%rbp)
callq 0x66f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
subq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
subq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop.c
// Function: lat_table_normalized_create
ticks**
lat_table_normalized_create(ticks* lat_table, const size_t n, cdf_cluster_t* cc)
{
  ticks** lat_table_norm = malloc_assert(n * sizeof(ticks*));
  for (int i = 0; i < n ; i++)
    {
      lat_table_norm[i] = malloc_assert(n * sizeof(ticks));
    }

  for (size_t x = 0; x < n; x++)
    {
      for (size_t y = 0; y < n; y++)
	{
	  ticks lat = lat_table_2d_get(lat_table, n, x, y);
	  lat_table_norm[x][y] = cdf_cluster_value_to_cluster_median(cc, lat);
	}
    }

  return lat_table_norm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2da0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x564d
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2da0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x561c
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x56d2
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x56c2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movq -0x30(%rbp), %rax
movl %eax, %edx
movq -0x38(%rbp), %rax
movl %eax, %ecx
callq 0x2fb0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8020
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5667
jmp 0x56c4
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5655
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop.c
// Function: lat_table_get_hwc_with_lat
int
lat_table_get_hwc_with_lat(ticks** lat_table, const size_t n, ticks target_lat, int* hwcs)
{
  for (int x = 0; x < n; x++)
    {
      for (int y = 0; y < n; y++)
	{
	  if (lat_table[x][y] == target_lat)
	    {
	      hwcs[0] = x;
	      hwcs[1] = y;
	      return 1;
	    }
	}
    }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5766
movl $0x0, -0x30(%rbp)
movslq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5759
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x20(%rbp), %rax
jne 0x574c
movl -0x2c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x576d
jmp 0x574e
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x570c
jmp 0x575b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x56fb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop.c
// Function: print_cache_info
void 
print_cache_info(mctop_cache_info_t* mci, test_format_t test_format, const char* hostname)
{
  if (test_format == MCT_FILE)
    {
      printf("## Cache info ############################################################\n");
      char out_file[50];
      sprintf(out_file, "./desc/%s.mct", hostname);
      printf("## MCTOP output in: %s\n", out_file);

      int ofp_open = 1;
      FILE* ofp = fopen(out_file, "a");
      if (ofp == NULL) 
	{
	  ofp_open = 0;
	  fprintf(stderr, "MCTOP Error: Cannot open output file %s! Using stderr instead.\n", out_file);
	  ofp = stderr;
	}

      fprintf(ofp, "#Cache_levels %d\n", mci->n_levels);
      for (int i = 0; i < mci->n_levels; i++)
	{
	  fprintf(ofp, "Cache_level %d   Latency %-5zu  SizeOS %-5zu SizeEst %-5zu\n",
		  i, mci->latencies[i], mci->sizes_OS[i], mci->sizes_estimated[i]);
	}
      if (ofp_open)
	{
	  fclose(ofp);
	}
      printf("##########################################################################\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x3, -0xc(%rbp)
jne 0x634d
leaq 0xa2d7(%rip), %rdi      # 0x1050b
movb $0x0, %al
callq 0x20d0
leaq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa1dc(%rip), %rsi      # 0x10426
movb $0x0, %al
callq 0x2280
leaq -0x50(%rbp), %rsi
leaq 0xa1d8(%rip), %rdi      # 0x10434
movb $0x0, %al
callq 0x20d0
movl $0x1, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
leaq 0xa2e2(%rip), %rsi      # 0x10557
callq 0x2210
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x62b6
movl $0x0, -0x54(%rbp)
movq 0xed65(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq -0x50(%rbp), %rdx
leaq 0xa1ae(%rip), %rsi      # 0x1044f
movb $0x0, %al
callq 0x2140
movq 0xed49(%rip), %rax      # 0x14ff8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0xa292(%rip), %rsi      # 0x10559
movb $0x0, %al
callq 0x2140
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x6330
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x64(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x64(%rbp), %rsi
movq (%rax,%rsi,8), %r8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x64(%rbp), %rsi
movq (%rax,%rsi,8), %r9
leaq 0xa24d(%rip), %rsi      # 0x1056b
movb $0x0, %al
callq 0x2140
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x62d5
cmpl $0x0, -0x54(%rbp)
je 0x633f
movq -0x60(%rbp), %rdi
callq 0x20b0
leaq 0xa179(%rip), %rdi      # 0x104bf
movb $0x0, %al
callq 0x20d0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_mem.c
// Function: mctop_mem_alloc_local
void*
mctop_mem_alloc_local(size_t size, int node) 
{
  void* mem;
  if (node >= 0)
    {
      mem = numa_alloc_onnode(size, node);
    }
  else
    {
      mem = malloc(size);
/*       mem = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); */
/* #ifdef __sparc__ */
/*       if (mem != MAP_FAILED) */
/* 	{ */
/* 	  int r = madvise((caddr_t) mem, size, MADV_ACCESS_LWP); */
/* 	  assert(r == 0 && "madvise failed"); */
/* 	} */
/* #endif */
//      assert(mem != MAP_FAILED);
    }

  assert(mem != NULL);
  bzero(mem, size);
  return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x6737
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x21c0
movq %rax, -0x18(%rbp)
jmp 0x6744
movq -0x8(%rbp), %rdi
callq 0x21a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x674d
jmp 0x676c
leaq 0xadd2(%rip), %rdi      # 0x11526
leaq 0xa1e7(%rip), %rsi      # 0x10942
movl $0x23, %edx
leaq 0xa1eb(%rip), %rcx      # 0x10952
callq 0x20e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x20f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_profiler.c
// Function: mctop_prof_create
mctop_prof_t*
mctop_prof_create(size_t num_entries)
{
  mctop_prof_t* prof = malloc_assert(sizeof(mctop_prof_t) + (num_entries * sizeof(ticks)));

  prof->size = num_entries;
  prof->correction = 0;
  prof->correction = mctop_prof_correction_calc(prof, num_entries);
  return prof;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
addq $0x40, %rdi
callq 0x6830
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6880
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_profiler.c
// Function: mctop_prof_correction_calc
static ticks
mctop_prof_correction_calc(mctop_prof_t* prof, const size_t num_entries)
{
  dvfs_scale_up(1e6, 0.95, NULL);
  size_t std_dev_perc_lim = mctop_prof_correction_stdp_limit;
  mctop_prof_stats_t stats;
  do
    {
      for (volatile size_t i = 0; i < num_entries; i++)
	{
	  MCTOP_PROF_START(prof, ts);
	  COMPILER_BARRIER();
	  MCTOP_PROF_STOP(prof, ts, i);
	}

      mctop_prof_stats_calc(prof, &stats);
    }
  while (stats.std_dev_perc > std_dev_perc_lim++);
  return stats.median;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xf4240, %edi          # imm = 0xF4240
movsd 0xa0e3(%rip), %xmm0     # 0x10980
xorl %eax, %eax
movl %eax, %esi
callq 0x7160
movq $0x8, -0x18(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x68fd
callq 0x6d00
movq %rax, -0x50(%rbp)
callq 0x6d00
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdx
subq -0x50(%rbp), %rdx
movq -0x8(%rbp), %rax
subq 0x8(%rax), %rdx
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x68b6
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6990
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %xmm1
movaps 0x8727(%rip), %xmm2     # 0xf050
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x872b(%rip), %xmm2     # 0xf060
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
ja 0x68ae
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_profiler.c
// Function: mctop_prof_comp_ticks
static int
mctop_prof_comp_ticks(const void *elem1, const void *elem2) 
{
  ticks f = *((ticks*)elem1);
  ticks s = *((ticks*)elem2);
  if (f > s) return  1;
  if (f < s) return -1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x6bf5
movl $0x1, -0x4(%rbp)
jmp 0x6c0f
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x6c08
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c0f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_profiler.c
// Function: mctop_prof_stats_print
void
mctop_prof_stats_print(mctop_prof_stats_t* stats)
{
  printf("## mctop_prof stats #######\n");
  printf("# #Values       = %zu\n", stats->num_vals);
  printf("# Average       = %zu\n", stats->avg);
  printf("# Median        = %zu\n", stats->median);
  printf("# Std dev       = %.2f\n", stats->std_dev);
  printf("# Std dev%%      = %.2f%%\n", stats->std_dev_perc);
  printf("###########################\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9d25(%rip), %rdi      # 0x10998
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x9d2d(%rip), %rdi      # 0x109b5
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x9d2e(%rip), %rdi      # 0x109cc
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x9d2f(%rip), %rdi      # 0x109e3
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
leaq 0x9d2f(%rip), %rdi      # 0x109fa
movb $0x1, %al
callq 0x20d0
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm0
leaq 0x9d30(%rip), %rdi      # 0x10a12
movb $0x1, %al
callq 0x20d0
leaq 0x9ed1(%rip), %rdi      # 0x10bc1
movb $0x0, %al
callq 0x20d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/helper.c
// Function: get_num_hw_ctx
int
get_num_hw_ctx()
{
#ifdef __x86_64__
  cpu_set_t mask;
  CPU_ZERO(&mask);
#endif

  int nc = 0;
  while (1)
    {
      if (!mctop_set_cpu(NULL, nc))
  	{
  	  break;
  	}
#ifdef __x86_64__
      CPU_SET(nc, &mask);
#endif
      nc++;
    }

#ifdef __x86_64__
  sched_setaffinity(0, sizeof(cpu_set_t), &mask);
#elif defined(__sparc)
  processor_bind(P_LWPID, P_MYID, PBIND_NONE, NULL);
#endif
  
  return nc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x20f0
movl $0x0, -0x84(%rbp)
movl -0x84(%rbp), %esi
xorl %eax, %eax
movl %eax, %edi
callq 0xc9b0
cmpl $0x0, %eax
jne 0x6d5b
jmp 0x6dda
movslq -0x84(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x6dad
movq -0x90(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x90(%rbp), %rcx
shrq $0x6, %rcx
orq -0x80(%rbp,%rcx,8), %rax
movq %rax, -0x80(%rbp,%rcx,8)
movq %rax, -0xa0(%rbp)
jmp 0x6db8
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x6db8
movq -0xa0(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0x6d45
xorl %edi, %edi
movl $0x80, %esi
leaq -0x80(%rbp), %rdx
callq 0x2100
movl -0x84(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/helper.c
// Function: timespec_diff
struct timespec
timespec_diff(struct timespec start, struct timespec end)
{
  struct timespec temp;
  if ((end.tv_nsec-start.tv_nsec) < 0)
    {
      temp.tv_sec = end.tv_sec-start.tv_sec-1;
      temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
    }
  else
    {
      temp.tv_sec = end.tv_sec-start.tv_sec;
      temp.tv_nsec = end.tv_nsec-start.tv_nsec;
    }
  return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
cmpq $0x0, %rax
jge 0x6e46
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6e5e
movq -0x30(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/helper.c
// Function: ll_random_traverse
ticks
ll_random_traverse(volatile uint64_t* list, const size_t reps)
{
  volatile ticks __s = getticks();
  for (size_t r = 0; r < reps; r++)
    {
      list = (uint64_t*) *list;
    }
  volatile ticks __e = getticks();
  assert(list != NULL);
  return (__e - __s) / reps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x6f00
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x6eb4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6e91
callq 0x6f00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6ec6
jmp 0x6ee5
leaq 0x9b6b(%rip), %rdi      # 0x10a38
leaq 0x9b71(%rip), %rsi      # 0x10a45
movl $0x41, %edx
leaq 0x9b72(%rip), %rcx      # 0x10a52
callq 0x20e0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/helper.c
// Function: ll_random_create
void
ll_random_create(volatile uint64_t* mem, const size_t size)
{
  const size_t size_cl = size / CACHE_LINE_SIZE;
  const size_t per_cl = CACHE_LINE_SIZE / sizeof(uint64_t);
  uint8_t* used = calloc_assert(size_cl, sizeof(uint8_t));
  unsigned long* seeds = seeds_create();
  seeds[0] = 0x0123456789ABCDLL;
  seeds[1] = 0xA023457689BAC0LL;
  seeds[2] = 0xB0245736F9BAC1LL;

  size_t idx = 0;
  size_t used_num = 0;
  while (used_num < size_cl - 1)
    {
      used[idx] = 1;
      used_num++;

      size_t nxt;
      do
	{
	  nxt = (marsaglia_rand(seeds) % size_cl);
	}
      while (used[nxt]);

      size_t nxt_8 = (nxt * per_cl);
      size_t idx_8 = (idx * per_cl);
      mem[idx_8] = (uint64_t) (mem + nxt_8);
      idx = nxt;
    }

  mem[idx * per_cl] = (volatile uint64_t) mem;
  /* mem[idx * per_cl] = 0; */

  free(seeds);
  free(used);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x6, %rax
movq %rax, -0x18(%rbp)
movq $0x8, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x7060
movq %rax, -0x28(%rbp)
callq 0x7350
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movabsq $0x123456789abcd, %rcx  # imm = 0x123456789ABCD
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movabsq $0xa023457689bac0, %rcx # imm = 0xA023457689BAC0
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movabsq $0xb0245736f9bac1, %rcx # imm = 0xB0245736F9BAC1
movq %rcx, 0x10(%rax)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x7030
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x70c0
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq %rdx, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq -0x48(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x6fcd
movq -0x48(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdx
movq -0x50(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x6fa4
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
shlq $0x3, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)