LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: do_addr_op
static void do_addr_op(void)
{
    Cell cell;
    unsigned reg = C & 7;

    switch (F) {
    case 0: cell = add(r[reg], M); break;
    case 1: cell = sub(r[reg], M); break;
    case 2: cell = M; break;
    case 3: cell = negative(M); break;
    case 4: check_master(); compare(M); return;
    default: error("Unknown extended opcode"); cell = zero;
    }
    if (reg - 1 < 6)        /* same as: 1 <= reg && reg <= 6 */
        if (INDEX_MAX < magnitude(cell))
            error("Magnitude too large for index register: %10o", 
              magnitude(cell));
    r[reg] = cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x941a(%rip), %eax      # 0x13e08
andl $0x7, %eax
movl %eax, -0xc(%rbp)
movl 0x9412(%rip), %eax      # 0x13e0c
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0xaa93
movq -0x18(%rbp), %rax
leaq 0x2445(%rip), %rcx      # 0xce58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x9358(%rip), %rax      # 0x13d80
movq (%rax,%rcx,8), %rdi
movq 0x93dd(%rip), %rsi      # 0x13e10
callq 0x3b50
movq %rax, -0x8(%rbp)
jmp 0xaaa9
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x9336(%rip), %rax      # 0x13d80
movq (%rax,%rcx,8), %rdi
movq 0x93bb(%rip), %rsi      # 0x13e10
callq 0x3c30
movq %rax, -0x8(%rbp)
jmp 0xaaa9
movq 0x93a9(%rip), %rax      # 0x13e10
movq %rax, -0x8(%rbp)
jmp 0xaaa9
movq 0x939c(%rip), %rax      # 0x13e10
xorq $0x40000000, %rax       # imm = 0x40000000
movq %rax, -0x8(%rbp)
jmp 0xaaa9
callq 0xadd0
movq 0x9384(%rip), %rdi      # 0x13e10
callq 0xb020
jmp 0xaafa
leaq 0x29ca(%rip), %rdi      # 0xd464
movb $0x0, %al
callq 0x74b0
movq $0x0, -0x8(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
cmpl $0x6, %eax
jae 0xaae6
movq 0x931d(%rip), %rax      # 0x13dd8
movq -0x8(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
cmpq %rcx, %rax
jge 0xaae4
movq -0x8(%rbp), %rsi
andq $0x3fffffff, %rsi       # imm = 0x3FFFFFFF
leaq 0x29f2(%rip), %rdi      # 0xd4cf
movb $0x0, %al
callq 0x74b0
jmp 0xaae6
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x928a(%rip), %rax      # 0x13d80
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: do_compare
static void do_compare(void)
{
    Cell cell = safe_fetch(cell_to_address(M));

    if (6 == F) {
        check_float();
        comparison_indicator = float_compare(r[A], cell);
        elapsed_time += 2;
    } else
        compare(cell);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9301(%rip), %rdi      # 0x13e10
callq 0x47c0
movl %eax, %edi
callq 0x94b0
movq %rax, -0x8(%rbp)
movl $0x6, %eax
cmpl 0x92e2(%rip), %eax      # 0x13e0c
jne 0xab5b
callq 0xab70
movq 0x9248(%rip), %rdi      # 0x13d80
movq -0x8(%rbp), %rsi
callq 0x4970
movl %eax, 0x921d(%rip)      # 0x13d64
movq 0x9202(%rip), %rax      # 0x13d50
addq $0x2, %rax
movq %rax, 0x91f7(%rip)      # 0x13d50
jmp 0xab64
movq -0x8(%rbp), %rdi
callq 0xb020
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: flip_char
static Cell flip_char(Cell cell)
{
    Cell ret = cell;
    Byte mix_char;

    mix_char = get_byte(5, ret);
    if ((9 < mix_char) && (mix_char < 20)) {
        mix_char = mix_char + 20;
        ret = set_byte(mix_char, 5, ret);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x5, %edi
callq 0x35c0
movl %eax, -0x14(%rbp)
movl $0x9, %eax
cmpl -0x14(%rbp), %eax
jae 0xac83
cmpl $0x14, -0x14(%rbp)
jae 0xac83
movl -0x14(%rbp), %eax
addl $0x14, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rdx
movl $0x5, %esi
callq 0x3730
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: restore_state
static void restore_state(void)
{
    Cell psw;
    Byte flags;
    int i;

    r[A] = control_memory[9];
    r[X] = control_memory[8];
    for (i = 1; i < 7; i++)
        r[i] = control_memory[8 - i];
    
    psw  = control_memory[1];
    r[J] = field(make_field_spec(4, 5), psw);
    pc   = cell_to_address(field(make_field_spec(1, 2), psw));

    flags  = get_byte(3, psw);
    overflow = flags > 7 ? true : false;
    flags &= 7;
    comparison_indicator = (int) flags - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x9111(%rip), %rax      # 0x13de0
movq 0x48(%rax), %rax
movq %rax, 0x90a6(%rip)      # 0x13d80
movq 0x90ff(%rip), %rax      # 0x13de0
movq 0x40(%rax), %rax
movq %rax, 0x90cc(%rip)      # 0x13db8
movl $0x1, -0x10(%rbp)
cmpl $0x7, -0x10(%rbp)
jge 0xad29
movq 0x90e0(%rip), %rax      # 0x13de0
movl $0x8, %ecx
subl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x10(%rbp), %rcx
leaq 0x9066(%rip), %rax      # 0x13d80
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xacf3
movq 0x90b0(%rip), %rax      # 0x13de0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x4, %edi
movl $0x5, %esi
callq 0x36d0
movl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x3620
movq %rax, 0x9067(%rip)      # 0x13dc0
movl $0x1, %edi
movl $0x2, %esi
callq 0x36d0
movl %eax, %edi
movq -0x8(%rbp), %rsi
callq 0x3620
movq %rax, %rdi
callq 0x47c0
movl %eax, 0x904f(%rip)      # 0x13dd0
movq -0x8(%rbp), %rsi
movl $0x3, %edi
callq 0x35c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x7, %edx
cmoval %eax, %ecx
leaq 0x7da7(%rip), %rax      # 0x12b50
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
andl $0x7, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, 0x8fa4(%rip)      # 0x13d64
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: branch
static void branch(unsigned condition, int sign, Cell cell)
{
    switch (condition) {
    case  0: jump(); break;
    case  1: pc = cell_to_address(M); break;
    case  2: if (overflow)  jump(); overflow = false; break;
    case  3: if (!overflow) jump(); overflow = false; break;
    case  4: if (sign <  0) jump(); break;
    case  5: if (sign == 0) jump(); break;
    case  6: if (sign  > 0) jump(); break;
    case  7: if (sign >= 0) jump(); break;
    case  8: if (sign != 0) jump(); break;
    case  9: if (sign <= 0) jump(); break;
    case 10: check_binary(); if (0 == (magnitude(cell) & 2)) jump(); break;
    case 11: check_binary(); if (1 == (magnitude(cell) & 2)) jump(); break;
    default: error("Bad branch condition");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0xafb9
movq -0x18(%rbp), %rax
leaq 0x1fbe(%rip), %rcx      # 0xce6c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0xae50
jmp 0xafc7
movq 0x8f48(%rip), %rdi      # 0x13e10
callq 0x47c0
movl %eax, 0x8efd(%rip)      # 0x13dd0
jmp 0xafc7
leaq 0x7c71(%rip), %rax      # 0x12b50
cmpl $0x0, (%rax)
je 0xaee9
callq 0xae50
leaq 0x7c60(%rip), %rax      # 0x12b50
movl $0x0, (%rax)
jmp 0xafc7
leaq 0x7c4e(%rip), %rax      # 0x12b50
cmpl $0x0, (%rax)
jne 0xaf0c
callq 0xae50
leaq 0x7c3d(%rip), %rax      # 0x12b50
movl $0x0, (%rax)
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
jge 0xaf29
callq 0xae50
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
jne 0xaf39
callq 0xae50
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
jle 0xaf49
callq 0xae50
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
jl 0xaf56
callq 0xae50
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
je 0xaf63
callq 0xae50
jmp 0xafc7
cmpl $0x0, -0x8(%rbp)
jg 0xaf70
callq 0xae50
jmp 0xafc7
callq 0xac90
movq -0x10(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
andq $0x2, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0xaf92
callq 0xae50
jmp 0xafc7
callq 0xac90
movq -0x10(%rbp), %rcx
andq $0x3fffffff, %rcx       # imm = 0x3FFFFFFF
andq $0x2, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
jne 0xafb7
callq 0xae50
jmp 0xafc7
leaq 0x253c(%rip), %rdi      # 0xd4fc
movb $0x0, %al
callq 0x74b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/run.c
// Function: compare
static void compare(Cell cell)
{
    Flag saved = overflow;

    Cell difference = sub(field(F, r[C & 7]), field(F, cell));
    comparison_indicator = sign_of_difference(difference);
    overflow = saved;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x7b1d(%rip), %rax      # 0x12b50
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl 0x8dce(%rip), %edi      # 0x13e0c
movl 0x8dc4(%rip), %eax      # 0x13e08
andl $0x7, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x8d2e(%rip), %rax      # 0x13d80
movq (%rax,%rcx,8), %rsi
callq 0x3620
movq %rax, -0x20(%rbp)
movl 0x8da7(%rip), %edi      # 0x13e0c
movq -0x8(%rbp), %rsi
callq 0x3620
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xafd0
movl %eax, 0x8cd7(%rip)      # 0x13d64
movl -0xc(%rbp), %ecx
leaq 0x7ab9(%rip), %rax      # 0x12b50
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: string_to_symbol
Symbol string_to_symbol(const char *name)
{
    Symbol *bucket = symbol_table + hash(name);
    Symbol p = *bucket;
    for (; p; p = p->next)
	    if (stricmp(name, p->name) == 0)
	        return p;
    {                   /* Symbol doesn't exist yet. */
	    Symbol result = allot(sizeof(struct Symbol));
	    strcpy(result->name = allot(strlen(name) + 1), name);
	    result->defined = false;
	    result->references = NULL;
	    result->next = *bucket;
	    result->cell = zero;
	    *bucket = result;
	    return result;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb3b0
movl %eax, %eax
movl %eax, %ecx
leaq 0x8c30(%rip), %rax      # 0x13f00
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xb31f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb420
cmpl $0x0, %eax
jne 0xb310
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb39a
jmp 0xb312
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb2e6
movl $0x28, %edi
callq 0xb4e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0xb4e0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, 0x8(%rax)
movq -0x10(%rbp), %rsi
callq 0x3070
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: hash
static unsigned hash(const char *s)
{
    unsigned h = 0;
    for (; *s; s++)
	    h = (h << 5) - h + toupper(*s);
    return h % (sizeof symbol_table / sizeof symbol_table[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb3fc
movl -0xc(%rbp), %eax
shll $0x5, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x3080
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb3c3
movl -0xc(%rbp), %eax
movl $0x11, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: stricmp
static int stricmp(const char *s, const char *t)
{
    while (*s && *t)
	if (tolower(*s) != tolower(*t))
	    return 1;
	else
	    s++, t++;
    return tolower(*s) != tolower(*t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xb451
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xb45a
jmp 0xb4a1
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x31a0
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x31a0
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
je 0xb487
movl $0x1, -0x4(%rbp)
jmp 0xb4ce
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb430
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x31a0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x31a0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: allot
static void *allot(size_t size)
{
    void *result = malloc(size);
    if (!result)
	    fatal_error("Out of heap space");
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x31b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb50e
leaq 0x211f(%rip), %rdi      # 0xd626
movb $0x0, %al
callq 0x7380
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: forward_reference
void forward_reference(Symbol symbol, Address address)
{
    assert(!symbol->defined);
    {
	    AddressList refs = allot(sizeof(struct AddressList));
	    refs->address = address;
	    refs->next = symbol->references;
	    symbol->references = refs;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xb5ab
jmp 0xb5ca
leaq 0x2004(%rip), %rdi      # 0xd5b6
leaq 0x1fda(%rip), %rsi      # 0xd593
movl $0x78, %edx
leaq 0x2002(%rip), %rcx      # 0xd5c7
callq 0x3100
movl $0x10, %edi
callq 0xb4e0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: define_symbol
void define_symbol(Symbol symbol, Cell cell)
{
    {   /* handle local symbols */
	    const char *name = symbol->name;
	    if (isdigit(name[0]) && strlen(name) == 2) {
            char c = toupper(name[1]);
            if (c == 'F' || c == 'B') {
                error("Definition of local ref: %s", name);
                return;
            } else if (c == 'H') {
                char new_name[3];
                Symbol nB, nF;
                strcpy(new_name, name);
                new_name[1] = 'B'; nB = string_to_symbol(new_name);
                nB->defined = true, nB->cell = cell;
                new_name[1] = 'F'; nF = string_to_symbol(new_name);
                resolve_references(nF, cell);
                nF->defined = false, nF->references = NULL;
                return;
            } else
                ;       /* not a local; fall through */
        }
    }
    if (symbol->defined)
	    warn("'%s' multiply-defined", symbol->name);
    else
	    resolve_references(symbol, cell);
    symbol->defined = true, symbol->cell = cell;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x3280
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xb717
movq -0x18(%rbp), %rdi
callq 0x30d0
cmpq $0x2, %rax
jne 0xb717
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x3080
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x46, %eax
je 0xb685
movsbl -0x19(%rbp), %eax
cmpl $0x42, %eax
jne 0xb69c
movq -0x18(%rbp), %rsi
leaq 0x1f5f(%rip), %rdi      # 0xd5ef
movb $0x0, %al
callq 0x74b0
jmp 0xb75d
movsbl -0x19(%rbp), %eax
cmpl $0x48, %eax
jne 0xb711
leaq -0x1c(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3070
movb $0x42, -0x1b(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xb2b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x46, -0x1b(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xb2b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb770
movq -0x30(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0xb75d
jmp 0xb713
jmp 0xb715
jmp 0xb717
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xb739
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1edb(%rip), %rdi      # 0xd60b
movb $0x0, %al
callq 0x7590
jmp 0xb746
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb770
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: resolve_references
static void resolve_references(Symbol symbol, Cell definition)
{
    AddressList refs, rest;
    assert(!symbol->defined);
    for (refs = symbol->references; refs; refs = rest) {
	    asm_store_field(refs->address, 0, 2, definition);
	    rest = refs->next;
	    free(refs);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xb78c
jmp 0xb7ab
leaq 0x1e23(%rip), %rdi      # 0xd5b6
leaq 0x1df9(%rip), %rsi      # 0xd593
movl $0x87, %edx
leaq 0x1e92(%rip), %rcx      # 0xd638
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb7f3
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rcx
xorl %esi, %esi
movl $0x2, %edx
callq 0x3400
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3030
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb7b7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: for_each_symbol
static void for_each_symbol(void (*proc)(Symbol))
{
    unsigned i;
    for (i = 0; i < sizeof symbol_table / sizeof symbol_table[0]; ++i) {
	    Symbol s = symbol_table[i];
	    for (; s; s = s->next)
	        proc(s);
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x11, %rax
jae 0xb8bb
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x8678(%rip), %rax      # 0x13f00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb8ae
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb890
jmp 0xb8b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb873
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pahihu[P]mixal/symbol.c
// Function: resolve_if_dangling
static void resolve_if_dangling(Symbol symbol)
{
    if (symbol->defined)
	    return;
    if (symbol->name[0] == '=') {   /* it's a generated symbol */
	    define_symbol(symbol, address_to_cell(here));
	    assemble(long_to_cell(atol(symbol->name + 1)));
    } else {    /* it's a user symbol */
	    if (symbol->references)
	        error("Unresolved reference: %s", symbol->name);
	    /* it would be nice to print the reference list, too */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0xb8e8
jmp 0xb958
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0xb935
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x6e3d(%rip), %rax      # 0x12744
movl (%rax), %edi
callq 0x47b0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0xb610
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
callq 0x3200
movq %rax, %rdi
callq 0x34a0
jmp 0xb958
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb956
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x1d0f(%rip), %rdi      # 0xd65e
movb $0x0, %al
callq 0x74b0
jmp 0xb958
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CBaquero[P]random/Random.cc
// Function: RandomDUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomDUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  long long start, end;
  if (
      (RedisModule_StringToLongLong(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToLongLong(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_int_distribution<long long> rdunif(start,end);
  RedisModule_ReplyWithLongLong(ctx,rdunif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0x66a1
movq 0x78b0(%rip), %rax      # 0xdf40
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x674c
movq 0x7878(%rip), %rax      # 0xdf20
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x66e5
movq 0x785b(%rip), %rax      # 0xdf20
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x66e5
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x6701
movq 0x7684(%rip), %rax      # 0xdd70
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq 0x3956(%rip), %rsi      # 0xa050
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x674c
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x60b0
movq 0x7857(%rip), %rax      # 0xdf70
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
movq 0x7865(%rip), %rsi      # 0xdf98
callq 0x62e0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq -0x48(%rbp), %rax
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CBaquero[P]random/Random.cc
// Function: RandomUnif_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomUnif_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  if (argc != 3) return RedisModule_WrongArity(ctx);
  double start, end;
  if (
      (RedisModule_StringToDouble(argv[1],&start) != REDISMODULE_OK) ||
      (RedisModule_StringToDouble(argv[2],&end) != REDISMODULE_OK) ||
      (start > end) 
      ) 
    return RedisModule_ReplyWithError(ctx,"ERR invalid range");

  std::uniform_real_distribution<double> runif(start,end);
  RedisModule_ReplyWithDouble(ctx,runif(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
je 0x6791
movq 0x77c0(%rip), %rax      # 0xdf40
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x683d
movq 0x7748(%rip), %rax      # 0xdee0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x67d7
movq 0x772b(%rip), %rax      # 0xdee0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x67d7
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x67f3
movq 0x7592(%rip), %rax      # 0xdd70
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq 0x3864(%rip), %rsi      # 0xa050
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x683d
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
leaq -0x40(%rbp), %rdi
callq 0x6110
movq 0x7403(%rip), %rax      # 0xdc10
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
movq 0x7771(%rip), %rsi      # 0xdf98
callq 0x64d0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rax
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CBaquero[P]random/Random.cc
// Function: RandomNorm_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomNorm_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double mean=0.0, sd=1.0;
  if (argc > 3) return RedisModule_WrongArity(ctx);
  if (argc >= 2) /* Get mean */
  {
    if (RedisModule_StringToDouble(argv[1],&mean) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid mean");
  }
  if (argc == 3) /* get stddev */
  {
    if (RedisModule_StringToDouble(argv[2],&sd) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid standard deviation");
  }

  std::normal_distribution<double> rnorm(mean,sd);
  RedisModule_ReplyWithDouble(ctx, rnorm(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x378d(%rip), %xmm0     # 0xa000
movsd %xmm0, -0x30(%rbp)
cmpl $0x3, -0x1c(%rbp)
jle 0x6896
movq 0x76bb(%rip), %rax      # 0xdf40
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x6965
cmpl $0x2, -0x1c(%rbp)
jl 0x68da
movq 0x763d(%rip), %rax      # 0xdee0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x68d8
movq 0x74b0(%rip), %rax      # 0xdd70
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq 0x3794(%rip), %rsi      # 0xa062
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x6965
jmp 0x68da
cmpl $0x3, -0x1c(%rbp)
jne 0x691b
movq 0x75f9(%rip), %rax      # 0xdee0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
leaq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x6919
movq 0x746c(%rip), %rax      # 0xdd70
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq 0x3761(%rip), %rsi      # 0xa073
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x6965
jmp 0x691b
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
leaq -0x50(%rbp), %rdi
callq 0x6510
movq 0x72db(%rip), %rax      # 0xdc10
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
movq 0x7649(%rip), %rsi      # 0xdf98
callq 0x6220
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CBaquero[P]random/Random.cc
// Function: RandomExp_RedisCommand(RedisModuleCtx*, RedisModuleString**, int)
int RandomExp_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
  double lambda;
  if (argc > 2) return RedisModule_WrongArity(ctx);
  if (argc == 2)
  {
    if (RedisModule_StringToDouble(argv[1],&lambda) != REDISMODULE_OK)
      return RedisModule_ReplyWithError(ctx,"ERR invalid lambda");
  }
  else // If no parameter, use default lambda of 1
    lambda=1.0;
  std::exponential_distribution<double> rexp(lambda);
  RedisModule_ReplyWithDouble(ctx, rexp(gen));
  return REDISMODULE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x2, -0x1c(%rbp)
jle 0x6e71
movq 0x70e0(%rip), %rax      # 0xdf40
movq (%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x6f04
cmpl $0x2, -0x1c(%rbp)
jne 0x6eb2
movq 0x7062(%rip), %rax      # 0xdee0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x28(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x6eb0
movq 0x6ed5(%rip), %rax      # 0xdd70
movq (%rax), %rax
movq -0x10(%rbp), %rdi
leaq 0x3265(%rip), %rsi      # 0xa10e
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x6f04
jmp 0x6ebf
movsd 0x3146(%rip), %xmm0     # 0xa000
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
leaq -0x30(%rbp), %rdi
callq 0x6330
movq 0x6d3c(%rip), %rax      # 0xdc10
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movq 0x70aa(%rip), %rsi      # 0xdf98
callq 0x6520
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_08/environ.c
// Function: main
int main(int argc, char *argv[])
{
	int n;

	for (n = 0; environ[n]; n++)
		printf("environ[%d]=\"%s\"\n", n, environ[n]);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x2e84(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11a0
movl -0x14(%rbp), %esi
movq 0x2e6c(%rip), %rax      # 0x3fe8
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xe76(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x115d
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: load_partial_block
void load_partial_block(block* dst, const unsigned char* m, int len, unsigned choice)
{
    unsigned char temp[16];
    if(choice == ZERO_APPEND){
        memcpy(temp, m, len);
        memset(temp+len, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == ZERO_PREPEND){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == PARAM_ZP){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len-1);
        temp[16-len-1] = PARAM;
        *dst = LOAD(temp);
    }
    else{
        // do nothing
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x20dc
movq %rsp, %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0x10b0
movq %rsp, %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
movl $0x10, %eax
subl 0x1c(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
movq %rsp, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x28(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x21af
cmpl $0x1, 0x18(%rsp)
jne 0x2138
movq %rsp, %rdi
addq $0x10, %rdi
movslq 0x1c(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0x10b0
movq %rsp, %rdi
movl $0x10, %eax
subl 0x1c(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
movq %rsp, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x28(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x21ad
cmpl $0x3, 0x18(%rsp)
jne 0x21a9
movq %rsp, %rdi
addq $0x10, %rdi
movslq 0x1c(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
callq 0x10b0
movq %rsp, %rdi
movl $0x10, %eax
subl 0x1c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
movl $0x10, %eax
subl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
movb $-0x40, (%rsp,%rax)
movq %rsp, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x28(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x21ab
jmp 0x21ab
jmp 0x21ad
jmp 0x21af
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n12t8silcv2/aesni/encrypt.c
// Function: xor_length
void xor_length(block* st, unsigned long long len)
{
    unsigned char temp[16] = { 0 };
    int i;
    for(i = 0;i < 8;i++){
        temp[15-i] = len & 0xff;
        len >>= 8;
    }
    (*st) = XOR((*st), LOAD(temp));
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x1030
movl $0x0, 0xc(%rsp)
cmpl $0x8, 0xc(%rsp)
jge 0x2225
movq 0x28(%rsp), %rax
andq $0xff, %rax
movb %al, %cl
movl $0xf, %eax
subl 0xc(%rsp), %eax
cltq
movb %cl, 0x10(%rsp,%rax)
movq 0x28(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x28(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x21e7
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm1
leaq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vpxor 0x40(%rsp), %xmm0, %xmm0
movq 0x30(%rsp), %rax
vmovdqa %xmm0, (%rax)
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit.c
// Function: critbit_init
void
critbit_init(struct critbit_tree *t, critbit_node_free_t *nfree,
    void *freearg, size_t keylen)
{
	t->ct_root = NULL;
	t->ct_keylen = keylen;
	t->ct_node_free = nfree;
	t->ct_free_arg = freearg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit.c
// Function: critbit_get_impl
static __inline struct critbit_key *
critbit_get_impl(struct critbit_tree *t, const void *key, size_t keylen,
    critbit_keycmp_t *keycmp, critbit_keybuf_t *keybuf)
{
	const uint8_t *ubytes = key;
	struct critbit_node *node;
	struct critbit_ref *ref;
	uint8_t c;

	ref = t->ct_root;
	if (ref == NULL)
		return (0);

	while (critbit_ref_is_internal(ref)) {
		node = critbit_ref_get_node(ref);

		c = 0;
		if (node->byte < keylen)
			c = ubytes[node->byte];

		const int direction = (1 + (node->otherbits | c)) >> 8;
		ref = node->child[direction];
	}

	if (keycmp(keybuf(critbit_ref_get_key(ref)), ubytes, keylen) == 0)
		return (critbit_ref_get_key(ref));

	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xd2c3
movq $0x0, -0x8(%rbp)
jmp 0xd37a
jmp 0xd2c5
movq -0x48(%rbp), %rdi
callq 0xdad0
cmpl $0x0, %eax
je 0xd32b
movq -0x48(%rbp), %rdi
callq 0xdaf0
movq %rax, -0x40(%rbp)
movb $0x0, -0x49(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
cmpq -0x20(%rbp), %rax
jae 0xd302
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0x10(%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x14(%rax), %eax
movzbl -0x49(%rbp), %ecx
orl %ecx, %eax
addl $0x1, %eax
sarl $0x8, %eax
movl %eax, -0x50(%rbp)
movq -0x40(%rbp), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0xd2c5
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
callq 0xdb10
movq %rax, %rdi
movq -0x60(%rbp), %rax
callq *%rax
movq %rax, %rdi
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0xd372
movq -0x48(%rbp), %rdi
callq 0xdb10
movq %rax, -0x8(%rbp)
jmp 0xd37a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit.c
// Function: critbit_remove_impl
static __inline struct critbit_key *
critbit_remove_impl(struct critbit_tree *t, const void *key, size_t keylen,
    critbit_keycmp_t *keycmp, critbit_keybuf_t *keybuf)
{
	const uint8_t *ubytes = key;
	struct critbit_ref *p = t->ct_root;
	struct critbit_node *q = NULL;
	struct critbit_ref **wherep = &t->ct_root;
	struct critbit_ref **whereq = NULL;
	int direction = 0;

	if (p == NULL)
		return (NULL);

	while (critbit_ref_is_internal(p)) {
		whereq = wherep;
		q = critbit_ref_get_node(p);
		uint8_t c = 0;
		if (q->byte < keylen)
			c = ubytes[q->byte];
		direction = (1 + (q->otherbits | c)) >> 8;
		wherep = q->child + direction;
		p = *wherep;
	}

	if (keycmp(keybuf(critbit_ref_get_key(p)), ubytes, keylen) != 0)
		return (NULL);

	/* Remove p */

	if (whereq == NULL) {
		t->ct_root = NULL;
		return (critbit_ref_get_key(p));
	}

	*whereq = q->child[1 - direction];
	critbit_node_free(t, q);

	return (critbit_ref_get_key(p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xd7e2
movq $0x0, -0x8(%rbp)
jmp 0xd8f7
jmp 0xd7e4
movq -0x40(%rbp), %rdi
callq 0xdad0
cmpl $0x0, %eax
je 0xd860
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rdi
callq 0xdaf0
movq %rax, -0x48(%rbp)
movb $0x0, -0x5d(%rbp)
movq -0x48(%rbp), %rax
movl 0x10(%rax), %eax
cmpq -0x20(%rbp), %rax
jae 0xd829
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movl 0x10(%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, -0x5d(%rbp)
movq -0x48(%rbp), %rax
movzbl 0x14(%rax), %eax
movzbl -0x5d(%rbp), %ecx
orl %ecx, %eax
addl $0x1, %eax
sarl $0x8, %eax
movl %eax, -0x5c(%rbp)
movq -0x48(%rbp), %rax
movslq -0x5c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xd7e4
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rdi
callq 0xdb10
movq %rax, %rdi
movq -0x70(%rbp), %rax
callq *%rax
movq %rax, %rdi
movq -0x68(%rbp), %rax
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, %eax
je 0xd8a2
movq $0x0, -0x8(%rbp)
jmp 0xd8f7
cmpq $0x0, -0x58(%rbp)
jne 0xd8c3
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0xdb10
movq %rax, -0x8(%rbp)
jmp 0xd8f7
movq -0x48(%rbp), %rax
movl $0x1, %ecx
subl -0x5c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x58(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xdb50
movq -0x40(%rbp), %rdi
callq 0xdb10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit.c
// Function: critbit_str_keycmp
static __inline int
critbit_str_keycmp(const uint8_t *a, const uint8_t *b, size_t blen)
{
	size_t alen;
	int rv;

	alen = strlen((char *)a);
	rv = alen - blen;
	if (rv != 0)
		return (rv);
	return (memcmp(a, b, blen));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd050
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xd9ca
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd9de
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xd090
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit.c
// Function: ms1b8
static __inline uint8_t ms1b8(uint8_t v) {
	uint32_t value = v;
#ifdef __GNUC__
	return value ? 1 << (31 - __builtin_clz(value)) : 0;
#else
	value |= value>>1;
	value |= value>>2;
	value |= value>>4;
	return value & ~(value>>1);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xdbb3
movl -0x8(%rbp), %eax
bsrl %eax, %eax
xorl $0x1f, %eax
movl $0x1f, %ecx
subl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0xdbba
xorl %eax, %eax
movl %eax, -0xc(%rbp)
jmp 0xdbba
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: main
int
main(void)
{
	test_contains();
	test_delete();
	test_benchmark_critbit_int();
	test_benchmark_critbit_hash_int();
	test_benchmark_rbtree_int();
	test_benchmark_nrbtree_int();
	test_benchmark_critbit();
	test_benchmark_rbtree();
#if 0
	// test_allprefixed();
#endif

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0xdc20
callq 0xdd10
callq 0xdeb0
callq 0xe060
callq 0xe270
callq 0xe400
callq 0xe5e0
callq 0xe7f0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: test_contains
static void
test_contains(void)
{
	CRITBIT_HEAD(eltree) tree;
	struct element *el;
	struct critbit_node *nnode;
	int i;

	CRITBIT_INIT(eltree, &tree, std_free, NULL);

	for (i = 0; elems[i]; ++i) {
		el = el_alloc();
		el->k = elems[i];
		nnode = malloc(critbit_node_size());
		CRITBIT_INSERT(eltree, &tree, nnode, el);
	}

	for (i = 0; elems[i]; ++i) {
		el = CRITBIT_GET(eltree, &tree, elems[i]);
		if (el == NULL)
			abort();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xea40
movq -0x40(%rbp), %rdi
movq %rax, %rcx
leaq 0xddd(%rip), %rsi       # 0xea20
xorl %eax, %eax
movl %eax, %edx
callq 0xd1d0
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x102a2(%rip), %rax     # 0x1df00
cmpq $0x0, (%rax,%rcx,8)
je 0xdcb2
callq 0xea50
movq %rax, -0x28(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x10287(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0xd1c0
movq %rax, %rdi
callq 0xd0b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xea60
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xdc53
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x1023c(%rip), %rax     # 0x1df00
cmpq $0x0, (%rax,%rcx,8)
je 0xdd00
movslq -0x34(%rbp), %rcx
leaq 0x1022a(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdi
callq 0xeac0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xdcf3
callq 0xd040
jmp 0xdcf5
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xdcb9
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/glk[P]critbit/critbit-test.c
// Function: test_delete
static void
test_delete(void)
{
	CRITBIT_HEAD(eltree) tree;
	struct element *el;
	struct critbit_node *nnode;
	int i, j;

	CRITBIT_INIT(eltree, &tree, std_free, NULL);

	for (i = 1; elems[i]; ++i) {

		for (j = 0; j < i; ++j) {
			el = el_alloc();
			el->k = elems[j];
			nnode = malloc(critbit_node_size());
			el = CRITBIT_INSERT(eltree, &tree, nnode, el);
			if (el != NULL)
				abort();
		}
		for (j = 0; j < i; ++j) {
			if (CRITBIT_GET(eltree, &tree, elems[j]) == NULL)
				abort();
		}
		for (j = 0; j < i; ++j) {
			el = CRITBIT_REMOVE(eltree, &tree, elems[j]);
			if (el == NULL)
				abort();
			free(el);
		}
		for (j = 0; j < i; ++j) {
			if (CRITBIT_GET(eltree, &tree, elems[j]) != NULL)
				abort();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0xea40
movq -0x40(%rbp), %rdi
movq %rax, %rcx
leaq 0xced(%rip), %rsi       # 0xea20
xorl %eax, %eax
movl %eax, %edx
callq 0xd1d0
movl $0x1, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x101b2(%rip), %rax     # 0x1df00
cmpq $0x0, (%rax,%rcx,8)
je 0xdea0
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xddc7
callq 0xea50
movq %rax, -0x28(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x10184(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0xd1c0
movq %rax, %rdi
callq 0xd0b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xea60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xddba
callq 0xd040
jmp 0xddbc
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xdd60
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xde06
movslq -0x38(%rbp), %rcx
leaq 0x1011f(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdi
callq 0xeac0
cmpq $0x0, %rax
jne 0xddf9
callq 0xd040
jmp 0xddfb
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xddce
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xde51
movslq -0x38(%rbp), %rcx
leaq 0x100e0(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdi
callq 0xeb10
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xde3d
callq 0xd040
movq -0x28(%rbp), %rdi
callq 0xd030
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xde0d
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xde90
movslq -0x38(%rbp), %rcx
leaq 0x10095(%rip), %rax     # 0x1df00
movq (%rax,%rcx,8), %rsi
leaq -0x20(%rbp), %rdi
callq 0xeac0
cmpq $0x0, %rax
je 0xde83
callq 0xd040
jmp 0xde85
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xde58
jmp 0xde92
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xdd43
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)