LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: read_symbol
struct value*
read_symbol(struct vm* vm, FILE* fp)
{
    // temp buffer to hold the symbol's contents
    char buf[MAX_STRING_SIZE] = { 0 };
    long i = 0;

    // grab the first character
    int c = advance(fp);
    buf[i++] = c;

    // check for peculiar identifier
    if (is_peculiar_identifier(c)) {
        if (c == '+' || c == '-') {
            peek_expect_delimiter(fp);
            return vm_make_symbol(vm, buf);
        }

        // only other peculiar identifier left at this point is "..."
        buf[i++] = advance(fp);
        buf[i++] = advance(fp);
        if (strcmp(buf, "...") == 0) {
            peek_expect_delimiter(fp);
            return vm_make_symbol(vm, buf);
        }

        fprintf(stderr, "reader: invalid symbol: %s\n", buf);
        exit(EXIT_FAILURE);
    }

    // at this point, the first char in buf must be an 'initial'

    // read characters into the buffer until:
    // EOF is reached, non-subsequent char is read, or buffer is filled
    while ((c = advance(fp)) != EOF) {
        if (!is_subsequent(c)) break;

        // "- 2" here to account for terminator
        if (i >= MAX_SYMBOL_SIZE - 2) {
            fprintf(stderr, "reader: symbol larger than %d characters\n", MAX_SYMBOL_SIZE);
            exit(EXIT_FAILURE);
        }

        buf[i++] = c;
    }

    // put non-symbol char back and ensure it was a delimiter
    rollback(fp, c);
    peek_expect_delimiter(fp);
    return vm_make_symbol(vm, buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r14, %rdi
callq 0x1240
movb %al, (%r15)
cmpb $0x2e, %al
ja 0x654c
movzbl %al, %ecx
movabsq $0x680000000000, %rdx   # imm = 0x680000000000
btq %rcx, %rdx
jae 0x654c
cmpl $0x2b, %eax
je 0x65de
cmpl $0x2d, %eax
je 0x65de
movq %r14, %rdi
callq 0x1240
movb %al, 0x1(%rsp)
movq %r14, %rdi
callq 0x1240
movb %al, 0x2(%rsp)
cmpl $0x2e2e2e, (%rsp)       # imm = 0x2E2E2E
je 0x65de
movq %rsp, %rdi
callq 0x2f5b
movq %r14, %rdi
callq 0x1240
cmpl $-0x1, %eax
je 0x65cd
movl %eax, %r15d
movl $0x1, %r13d
leaq 0x26c8(%rip), %r12      # 0x8c31
movl %r15d, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x65ad
movsbl %r15b, %ebp
movl $0xf, %edx
movq %r12, %rdi
movl %ebp, %esi
callq 0x1170
leal -0x30(%r15), %ecx
cmpb $0xa, %cl
jb 0x65ad
testq %rax, %rax
jne 0x65ad
movl $0x5, %edx
leaq 0x268b(%rip), %rdi      # 0x8c2c
movl %ebp, %esi
callq 0x1170
testq %rax, %rax
je 0x65d3
cmpq $0xfe, %r13
je 0x6603
movb %r15b, (%rsp,%r13)
incq %r13
movq %r14, %rdi
callq 0x1240
movl %eax, %r15d
cmpl $-0x1, %eax
jne 0x6569
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %edi
movq %r14, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x633c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x71ce
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f7f
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: read_pair
struct value*
read_pair(struct vm* vm, FILE* fp)
{
    eat_whitespace(fp);

    // return the empty list upon finding a closing paren
    if (peek(fp) == ')') {
        advance(fp);
        return vm_make_empty_list(vm);
    }

    // read the first half of the pair
    struct value* car = reader_read(vm, fp);
    eat_whitespace(fp);

    // check for an "improper" list
    if (peek(fp) == '.') {
        advance(fp);
        peek_expect_delimiter(fp);

        // read the last expr
        struct value* cdr = reader_read(vm, fp);
        eat_whitespace(fp);

        // ensure a closing paren comes next
        if (peek(fp) != ')') {
            fprintf(stderr, "reader: expected closing paren after last expr in improper list\n");
            exit(EXIT_FAILURE);
        }

        // consume the closing paren
        advance(fp);
        return vm_make_pair(vm, car, cdr);
    }

    // read the next expr in a "normal" list
    struct value* cdr = read_pair(vm, fp);
    return vm_make_pair(vm, car, cdr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x66f6
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x29, %ebp
jne 0x664f
movq %r14, %rdi
callq 0x1240
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7071
movq %rbx, %rdi
movq %r14, %rsi
callq 0x675f
movq %rax, %r15
movq %r14, %rdi
callq 0x66f6
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x2e, %ebp
jne 0x66d0
movq %r14, %rdi
callq 0x1240
movq %r14, %rdi
callq 0x633c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x675f
movq %rax, %r12
movq %r14, %rdi
callq 0x66f6
movq %r14, %rdi
callq 0x1240
movl %eax, %ebp
movl %eax, %edi
movq %r14, %rsi
callq 0x1090
cmpl $0x29, %ebp
jne 0x66f1
movq %r14, %rdi
callq 0x1240
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0x66e4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6608
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7232
callq 0x2fa5
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/reader.c
// Function: eat_whitespace
static void
eat_whitespace(FILE* fp)
{
    int c;
    while ((c = advance(fp)) != EOF) {
        // if whitespace, eat and advance
        if (is_whitespace(c)) continue;

        // if comment found, eat til end of line
        if (c == ';') {
            while (((c = advance(fp)) != EOF) && (c != '\n'));
            continue;
        }

        // found a non-whitespace char at this point (put it back and break)
        rollback(fp, c);
        break;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1240
cmpl $-0x1, %eax
je 0x674c
movl %eax, %ebp
leaq 0x2515(%rip), %r14      # 0x8c25
movsbl %bpl, %esi
movl $0x7, %edx
movq %r14, %rdi
callq 0x1170
testq %rax, %rax
jne 0x673d
cmpl $0x3b, %ebp
jne 0x6751
movq %rbx, %rdi
callq 0x1240
cmpl $0xa, %eax
je 0x673d
cmpl $-0x1, %eax
jne 0x672b
movq %rbx, %rdi
callq 0x1240
movl %eax, %ebp
cmpl $-0x1, %eax
jne 0x6710
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1090
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/value.c
// Function: value_is_equal
bool
value_is_equal(const struct value* a, const struct value* b)
{
    if (a->type != b->type) return false;

    switch (a->type) {
        case VALUE_EMPTY_LIST:
            // all instances of the empty list are the same
            return true;
        case VALUE_BOOLEAN:
            return a->as.boolean == b->as.boolean;
        case VALUE_CHARACTER:
            return a->as.character == b->as.character;
        case VALUE_NUMBER:
            return a->as.number == b->as.number;
        case VALUE_STRING:
            return strcmp(a->as.string, b->as.string) == 0;
        case VALUE_SYMBOL:
            return strcmp(a->as.symbol, b->as.symbol) == 0;
        case VALUE_PAIR:
            return value_is_equal(a->as.pair.car, b->as.pair.car) &&
                   value_is_equal(a->as.pair.cdr, b->as.pair.cdr);
        case VALUE_BUILTIN:
            // direct pointer compare
            return a->as.builtin == b->as.builtin;
        case VALUE_LAMBDA:
            return value_is_equal(a->as.lambda.params, b->as.lambda.params) &&
                   value_is_equal(a->as.lambda.body, b->as.lambda.body) &&
                   value_is_equal(a->as.lambda.env, b->as.lambda.env);
        case VALUE_INPUT_PORT:
        case VALUE_OUTPUT_PORT:
            // direct pointer compare
            return a->as.port == b->as.port;
        case VALUE_WINDOW:
            // direct pointer compare
            return a->as.window.window == b->as.window.window &&
                   a->as.window.renderer == b->as.window.renderer;
        case VALUE_EVENT:
            // two events are never equal?
            return false;
        case VALUE_EOF:
            // all instances of EOF are the same
            return true;
    }

    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl (%rdi), %ecx
cmpl (%rsi), %ecx
jne 0x6db8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1f5d(%rip), %r15      # 0x8c78
xorl %eax, %eax
decl %ecx
cmpl $0xd, %ecx
ja 0x6dc7
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x6cff
movl $0x18, %ecx
jmp 0x6d68
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x6cff
testb %al, %al
je 0x6db8
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x6cff
movl $0x20, %ecx
testb %al, %al
je 0x6db8
movq (%rbx,%rcx), %rbx
movq (%r14,%rcx), %r14
movl (%r14), %ecx
cmpl (%rbx), %ecx
je 0x6d1b
jmp 0x6db8
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
jmp 0x6dc4
movb $0x1, %al
jmp 0x6dc7
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x11f0
testl %eax, %eax
jmp 0x6dc4
movl 0x10(%r14), %eax
cmpl 0x10(%rbx), %eax
jmp 0x6dc4
movb 0x10(%r14), %al
cmpb 0x10(%rbx), %al
jmp 0x6dc4
movq 0x10(%r14), %rax
cmpq 0x10(%rbx), %rax
je 0x6dbc
xorl %eax, %eax
jmp 0x6dc7
movq 0x18(%r14), %rax
cmpq 0x18(%rbx), %rax
sete %al
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_init
void
vm_init(struct vm* vm)
{
    assert(vm != NULL);

    vm->capacity = 1024 * 1024;
    vm->heap = calloc(vm->capacity, sizeof(struct value));

    // init the allocation free list
    vm->free = &vm->heap[0];
    for (long i = 0; i < vm->capacity - 1; i++) {
        vm->heap[i].next = &vm->heap[i + 1];
    }
    vm->heap[vm->capacity - 1].next = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6eaa
movq %rdi, %rbx
movq $0x100000, (%rdi)       # imm = 0x100000
movl $0x100000, %edi         # imm = 0x100000
movl $0x28, %esi
callq 0x1100
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movdqa 0x209d(%rip), %xmm0     # 0x8ea0
movl $0x30, %ecx
movdqa 0x20a0(%rip), %xmm1     # 0x8eb0
movdqa 0x20a8(%rip), %xmm2     # 0x8ec0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
pcmpeqd %xmm4, %xmm4
movdqa 0x20a7(%rip), %xmm5     # 0x8ed0
movdqa %xmm0, %xmm6
pxor %xmm1, %xmm6
movdqa %xmm2, %xmm8
pcmpgtd %xmm6, %xmm8
pshufd $0xf5, %xmm6, %xmm7     # xmm7 = xmm6[1,1,3,3]
pcmpeqd %xmm3, %xmm7
pand %xmm8, %xmm7
movdqa %xmm0, %xmm6
psubq %xmm4, %xmm6
movd %xmm7, %edx
testb $0x1, %dl
je 0x6e6c
movq %xmm6, %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rax,%rdx,8), %rdx
movq %rdx, -0x28(%rax,%rcx)
pextrw $0x4, %xmm7, %edx
testb $0x1, %dl
je 0x6e8c
pshufd $0xee, %xmm6, %xmm6     # xmm6 = xmm6[2,3,2,3]
movq %xmm6, %rdx
leaq (%rdx,%rdx,4), %rdx
leaq (%rax,%rdx,8), %rdx
movq %rdx, (%rax,%rcx)
paddq %xmm5, %xmm0
addq $0x50, %rcx
cmpq $0x2800030, %rcx        # imm = 0x2800030
jne 0x6e29
movq $0x0, 0x27fffe0(%rax)
popq %rbx
retq
leaq 0x2053(%rip), %rdi      # 0x8f04
leaq 0x2057(%rip), %rsi      # 0x8f0f
leaq 0x2059(%rip), %rcx      # 0x8f18
movl $0x30, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_free
void
vm_free(struct vm* vm)
{
    assert(vm != NULL);

    vm_gc(vm, NULL);
    free(vm->heap);

    vm->capacity = 0;
    vm->heap = NULL;
    vm->free = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x6ef2
movq %rdi, %rbx
xorl %esi, %esi
callq 0x6f11
movq 0x8(%rbx), %rdi
callq 0x11a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
leaq 0x200b(%rip), %rdi      # 0x8f04
leaq 0x200f(%rip), %rsi      # 0x8f0f
leaq 0x202b(%rip), %rcx      # 0x8f32
movl $0x40, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: gc_mark
static void
gc_mark(struct vm* vm, struct value* root)
{
    if (root == NULL) return;
    if (root->gc_mark == GC_MARKED) return;

    // mark everything reachable from a given root node
    root->gc_mark = GC_MARKED;

    // recursively mark the contents of a lambda
    if (value_is_lambda(root)) {
        gc_mark(vm, root->as.lambda.params);
        gc_mark(vm, root->as.lambda.body);
        gc_mark(vm, root->as.lambda.env);
    }

    // recursively mark pairs / lists
    if (value_is_pair(root)) {
        gc_mark(vm, root->as.pair.car);
        gc_mark(vm, root->as.pair.cdr);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x7070
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x4(%rbx)
je 0x706f
movl $0x1, 0x4(%rbx)
movl (%rbx), %eax
cmpl $0x9, %eax
jne 0x7058
movq 0x10(%rbx), %rdi
callq 0x701e
movq 0x18(%rbx), %rdi
callq 0x701e
movq 0x20(%rbx), %rdi
callq 0x701e
movl (%rbx), %eax
cmpl $0x7, %eax
jne 0x706f
movq 0x10(%rbx), %rdi
callq 0x701e
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0x7027
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_empty_list
struct value*
vm_make_empty_list(struct vm* vm)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_EMPTY_LIST;
    return value;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7084
callq 0x70a3
movl $0x1, (%rax)
popq %rcx
retq
leaq 0x1e79(%rip), %rdi      # 0x8f04
leaq 0x1e7d(%rip), %rsi      # 0x8f0f
leaq 0x1edb(%rip), %rcx      # 0x8f74
movl $0x90, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_boolean
struct value*
vm_make_boolean(struct vm* vm, bool boolean)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_BOOLEAN;
    value->as.boolean = boolean;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x70db
movl %esi, %ebx
callq 0x70a3
movl $0x2, (%rax)
movb %bl, 0x10(%rax)
popq %rbx
retq
leaq 0x1e22(%rip), %rdi      # 0x8f04
leaq 0x1e26(%rip), %rsi      # 0x8f0f
leaq 0x1eb2(%rip), %rcx      # 0x8fa2
movl $0x9a, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_character
struct value*
vm_make_character(struct vm* vm, int character)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_CHARACTER;
    value->as.character = character;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7112
movl %esi, %ebx
callq 0x70a3
movl $0x3, (%rax)
movl %ebx, 0x10(%rax)
popq %rbx
retq
leaq 0x1deb(%rip), %rdi      # 0x8f04
leaq 0x1def(%rip), %rsi      # 0x8f0f
leaq 0x1ead(%rip), %rcx      # 0x8fd4
movl $0xa5, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_number
struct value*
vm_make_number(struct vm* vm, long number)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_NUMBER;
    value->as.number = number;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x714b
movq %rsi, %rbx
callq 0x70a3
movl $0x4, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1db2(%rip), %rdi      # 0x8f04
leaq 0x1db6(%rip), %rsi      # 0x8f0f
leaq 0x1ea6(%rip), %rcx      # 0x9006
movl $0xb0, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_string
struct value*
vm_make_string(struct vm* vm, const char* string)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_STRING;
    value->as.string = malloc(strlen(string) + 1);
    strcpy(value->as.string, string);
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x71af
movq %rsi, %rbx
callq 0x70a3
movq %rax, %r14
movl $0x5, (%rax)
movq %rbx, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11d0
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1d4e(%rip), %rdi      # 0x8f04
leaq 0x1d52(%rip), %rsi      # 0x8f0f
leaq 0x1e72(%rip), %rcx      # 0x9036
movl $0xbb, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_symbol
struct value*
vm_make_symbol(struct vm* vm, const char* symbol)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_SYMBOL;
    value->as.symbol = malloc(strlen(symbol) + 1);
    strcpy(value->as.symbol, symbol);
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7213
movq %rsi, %rbx
callq 0x70a3
movq %rax, %r14
movl $0x6, (%rax)
movq %rbx, %rdi
callq 0x10c0
leaq 0x1(%rax), %rdi
callq 0x11d0
movq %rax, 0x10(%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1140
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1cea(%rip), %rdi      # 0x8f04
leaq 0x1cee(%rip), %rsi      # 0x8f0f
leaq 0x1e46(%rip), %rcx      # 0x906e
movl $0xc7, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_pair
struct value*
vm_make_pair(struct vm* vm, struct value* car, struct value* cdr)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_PAIR;
    value->as.pair.car = car;
    value->as.pair.cdr = cdr;
    return value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x725c
movq %rdx, %rbx
movq %rsi, %r14
callq 0x70a3
movl $0x7, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1ca1(%rip), %rdi      # 0x8f04
leaq 0x1ca5(%rip), %rsi      # 0x8f0f
leaq 0x1e35(%rip), %rcx      # 0x90a6
movl $0xd3, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_builtin
struct value*
vm_make_builtin(struct vm* vm, builtin_func builtin)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_BUILTIN;
    value->as.builtin = builtin;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7295
movq %rsi, %rbx
callq 0x70a3
movl $0x8, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1c68(%rip), %rdi      # 0x8f04
leaq 0x1c6c(%rip), %rsi      # 0x8f0f
leaq 0x1e44(%rip), %rcx      # 0x90ee
movl $0xdf, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_lambda
struct value*
vm_make_lambda(struct vm* vm, struct value* params, struct value* body, struct value* env)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_LAMBDA;
    value->as.lambda.params = params;
    value->as.lambda.body = body;
    value->as.lambda.env = env;
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x72e4
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x70a3
movl $0x9, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1c19(%rip), %rdi      # 0x8f04
leaq 0x1c1d(%rip), %rsi      # 0x8f0f
leaq 0x1e2e(%rip), %rcx      # 0x9127
movl $0xea, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_input_port
struct value*
vm_make_input_port(struct vm* vm, FILE* port)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_INPUT_PORT;
    value->as.port = port;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x731d
movq %rsi, %rbx
callq 0x70a3
movl $0xa, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1be0(%rip), %rdi      # 0x8f04
leaq 0x1be4(%rip), %rsi      # 0x8f0f
leaq 0x1e4f(%rip), %rcx      # 0x9181
movl $0xf7, %edx
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_output_port
struct value*
vm_make_output_port(struct vm* vm, FILE* port)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_OUTPUT_PORT;
    value->as.port = port;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7356
movq %rsi, %rbx
callq 0x70a3
movl $0xb, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1ba7(%rip), %rdi      # 0x8f04
leaq 0x1bab(%rip), %rsi      # 0x8f0f
leaq 0x1e4c(%rip), %rcx      # 0x91b7
movl $0x102, %edx            # imm = 0x102
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_window
struct value*
vm_make_window(struct vm* vm, const char* title, long width, long height)
{
    assert(vm != NULL);

    SDL_Window* window = SDL_CreateWindow(
        title,
        SDL_WINDOWPOS_UNDEFINED,
        SDL_WINDOWPOS_UNDEFINED,
        width,
        height,
        0);
    if (window == NULL) {
        fprintf(stderr, "failed to create SDL2 window: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        fprintf(stderr, "failed to create SDL2 renderer: %s\n", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    struct value* value = next_available_value(vm);
    value->type = VALUE_WINDOW;
    value->as.window.window = window;
    value->as.window.renderer = renderer;
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x73db
movq %rcx, %r8
movq %rdx, %rcx
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
xorl %r9d, %r9d
callq 0x1060
testq %rax, %rax
je 0x73fa
movq %rax, %r14
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x1040
testq %rax, %rax
je 0x73ff
movq %rax, %r15
movq %rbx, %rdi
callq 0x70a3
movl $0xc, (%rax)
movq %r14, 0x10(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1b22(%rip), %rdi      # 0x8f04
leaq 0x1b26(%rip), %rsi      # 0x8f0f
leaq 0x1dfe(%rip), %rcx      # 0x91ee
movl $0x10d, %edx            # imm = 0x10D
callq 0x10f0
callq 0x3065
callq 0x3039
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_event
struct value*
vm_make_event(struct vm* vm, SDL_Event* event)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_EVENT;
    value->as.event = event;
    return value;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x741e
movq %rsi, %rbx
callq 0x70a3
movl $0xd, (%rax)
movq %rbx, 0x10(%rax)
popq %rbx
retq
leaq 0x1adf(%rip), %rdi      # 0x8f04
leaq 0x1ae3(%rip), %rsi      # 0x8f0f
leaq 0x1e45(%rip), %rcx      # 0x9278
movl $0x12b, %edx            # imm = 0x12B
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/theandrew168[P]squeaky/src/vm.c
// Function: vm_make_eof
struct value*
vm_make_eof(struct vm* vm)
{
    assert(vm != NULL);

    struct value* value = next_available_value(vm);
    value->type = VALUE_EOF;
    return value;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x7450
callq 0x70a3
movl $0xe, (%rax)
popq %rcx
retq
leaq 0x1aad(%rip), %rdi      # 0x8f04
leaq 0x1ab1(%rip), %rsi      # 0x8f0f
leaq 0x1e49(%rip), %rcx      # 0x92ae
movl $0x136, %edx            # imm = 0x136
callq 0x10f0
// File: /workspace/github_c_makefile_star2_O3/zpole[P]IICV/src/test_threads.c
// Function: main
int
main(int argc VL_UNUSED, char** argv VL_UNUSED)
{
#ifndef VL_DISABLE_THREADS
#if defined(VL_THREADS_POSIX)
  vl_uindex i ;
  pthread_t threads [5] ;
  int threadIds [5] ;
  for (i = 0 ; i < sizeof(threads) / sizeof(threads[0]) ; ++i) {
    threadIds [i] = i ;
    pthread_create (threads + i, NULL, testThread, threadIds + i) ;
  }
  for (i = 0 ; i < sizeof(threads) / sizeof(threads[0]) ; ++i) {
    pthread_join (threads[i], NULL) ;
  }
#elif defined(VL_THREADS_WIN)
  int i ;
  DWORD threadIds [5] ;
  HANDLE threadHandles [5] ;
  for (i = 0 ; i < sizeof(threadHandles) / sizeof(threadHandles[0]) ; ++i) {
    threadHandles [i] = CreateThread (
      NULL, 0,
      testThread, threadIds + i,
      0, threadIds + i) ;
  }
  for (i = 0 ; i < sizeof(threadHandles) / sizeof(threadHandles[0]) ; ++i) {
    WaitForSingleObject (threadHandles[i], INFINITE);
  }
#endif
/* VL_DISABLE_THREADS */
#else
  printf("VLFeat was compiled without threading support\n") ;
#endif
  {
    char * string = vl_configuration_to_string_copy() ;
    printf("%s", string) ;
    vl_free(string) ;
  }
  return 0 ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
xorl %r12d, %r12d
leaq -0x89(%rip), %r15       # 0x11cc
movl %r12d, (%r14)
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0x10a0
incq %r12
addq $0x8, %rbx
addq $0x4, %r14
cmpq $0x5, %r12
jne 0x1255
xorl %ebx, %ebx
movq 0x20(%rsp,%rbx,8), %rdi
xorl %esi, %esi
callq 0x10c0
incq %rbx
cmpq $0x5, %rbx
jne 0x127b
callq 0x1040
movq %rax, %rbx
leaq 0xd97(%rip), %rdi       # 0x2036
movq %rax, %rsi
xorl %eax, %eax
callq 0x1070
movq %rbx, %rdi
callq 0x1080
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/jd.c
// Function: main
int main(int argc, char **argv) {
    int modified = 0; /* use Modified Julian Date */
    for (int i = 1; i < argc; i ++) {
        if (strcmp(argv[i], "-m") == 0) {
            modified = 1;
        }
        else {
            usage_error(argv[0]);
        }
    }
    struct timeval tp;
    if (gettimeofday(&tp, NULL) != 0) {
        perror("gettimeofday");
        exit(EXIT_FAILURE);
    }
    const long double unix_time = tp.tv_sec + tp.tv_usec/1000000.0;
    const long double jd = unix_time / 86400.0 + (modified ? 40587.0 : 2440587.5);
    printf("%.9Lf\n", jd);
    return 0;
}

// Assembly:
subq $0x38, %rsp
flds 0xe5e(%rip)             # 0x2004
cmpl $0x2, %edi
jl 0x11d7
fstp %st(0)
movl %edi, %eax
movl $0x1, %ecx
flds 0xe4e(%rip)             # 0x2008
movq (%rsi,%rcx,8), %rdx
cmpb $0x2d, (%rdx)
jne 0x1237
cmpb $0x6d, 0x1(%rdx)
jne 0x1237
cmpb $0x0, 0x2(%rdx)
jne 0x1237
incq %rcx
cmpq %rcx, %rax
jne 0x11ba
fstpt 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1050
testl %eax, %eax
jne 0x1278
cvtsi2sdq 0x28(%rsp), %xmm0
cvtsi2sdq 0x30(%rsp), %xmm1
divsd 0xe0b(%rip), %xmm1      # 0x2010
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
fldl 0x10(%rsp)
fdivs 0xdf3(%rip)             # 0x200c
fldt 0x1c(%rsp)
faddp %st, %st(1)
fstpt (%rsp)
leaq 0xdfc(%rip), %rdi       # 0x2025
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
addq $0x38, %rsp
retq
fstp %st(0)
movq (%rsi), %rsi
leaq 0xde9(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x1040
leaq 0xdeb(%rip), %rdi       # 0x203c
callq 0x1030
leaq 0xe02(%rip), %rdi       # 0x205f
callq 0x1030
leaq 0xe1c(%rip), %rdi       # 0x2085
callq 0x1030
movl $0x1, %edi
callq 0x1070
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/zmakebas/zmakebas.c
// Function: grok_hex
unsigned long grok_hex(unsigned char **ptrp,int textlinenum)
{
static char *hexits="0123456789abcdefABCDEF",*lookup;
unsigned char *ptr=*ptrp;
unsigned long v=0,n;

/* we know the number starts with "0x" and we're pointing to it */

ptr+=2;
if(strchr(hexits,*ptr)==NULL)
  {
  fprintf(stderr,"line %d: bad BIN 0x... number\n",textlinenum);
  exit(1);
  }

while(*ptr && (lookup=strchr(hexits,*ptr))!=NULL)
  {
  n=lookup-hexits;
  if(n>15) n-=6;
  v=v*16+n;
  ptr++;
  }

*ptrp=ptr;
return(v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r12
movb 0x2(%r12), %r13b
movzbl %r13b, %esi
leaq 0x1c16(%rip), %r15      # 0x528e
movl $0x17, %edx
movq %r15, %rdi
callq 0x3130
testq %rax, %rax
je 0x36f8
addq $0x2, %r12
testb %r13b, %r13b
je 0x36e0
xorl %ebp, %ebp
xorl %r14d, %r14d
movzbl %r13b, %esi
movl $0x17, %edx
movq %r15, %rdi
callq 0x3130
testq %rax, %rax
je 0x36d7
movq %rax, %rcx
subq %r15, %rcx
leaq -0x6(%rcx), %rdx
cmpq $0x10, %rcx
cmovbq %rcx, %rdx
shlq $0x4, %r14
addq %rdx, %r14
movb 0x1(%r12), %r13b
incq %r12
testb %r13b, %r13b
jne 0x3698
movq %rax, %rbp
movq %rbp, 0x504a(%rip)      # 0x8728
jmp 0x36e3
xorl %r14d, %r14d
movq %r12, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/zmakebas/zmakebas.c
// Function: grok_binary
unsigned long grok_binary(unsigned char **ptrp,int textlinenum)
{
unsigned long v=0;
unsigned char *ptr=*ptrp;

while(isspace(*ptr)) ptr++;

if(*ptr!='0' && *ptr!='1')
  {
  fprintf(stderr,"line %d: bad BIN number\n",textlinenum);
  exit(1);
  }

if(ptr[1]=='x' || ptr[1]=='X')
  {
  *ptrp=ptr;
  return(grok_hex(ptrp,textlinenum));
  }

while(*ptr=='0' || *ptr=='1')
  {
  v*=2;
  v+=*ptr-'0';
  ptr++;
  }

*ptrp=ptr;
return(v);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %r14
callq 0x3110
movq (%rax), %rax
decq %r14
movzbl 0x1(%r14), %ecx
incq %r14
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x3716
movl %ecx, %eax
andb $-0x2, %al
cmpb $0x30, %al
jne 0x3771
movzbl 0x1(%r14), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x374b
movq %r14, (%rbx)
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3655
xorl %eax, %eax
movzbl %cl, %ecx
leaq (%rcx,%rax,2), %rax
addq $-0x30, %rax
movb 0x1(%r14), %cl
incq %r14
movl %ecx, %edx
andb $-0x2, %dl
cmpb $0x30, %dl
je 0x374d
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movl %ebp, %edi
callq 0x3223
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/zmakebas/zmakebas.c
// Function: usage_help
void usage_help()
{
printf("zmakebas - public domain by Russell Marks.\n\n");

printf("usage: zmakebas [-hlr] [-a line] [-i incr] [-n speccy_filename]\n");
printf("                [-o output_file] [-s line] [input_file]\n\n");

printf("        -a      set auto-start line of basic file (default none).\n");
printf("        -h      give this usage help.\n");
printf("        -i      in labels mode, set line number incr. (default 2).\n");
printf("        -l      use labels rather than line numbers.\n");
printf("        -n      set Spectrum filename (to be given in tape header).");
printf("\n        -o      specify output file (default `%s').\n",
						DEFAULT_OUTPUT);
printf("        -r      output raw headerless file (default is .tap file).\n");
printf("        -s      in labels mode, set starting line number ");
printf("(default 10).\n");
}

// Assembly:
pushq %rax
leaq 0x211c(%rip), %rdi      # 0x589c
callq 0x31a0
leaq 0x213c(%rip), %rdi      # 0x58c8
callq 0x31a0
leaq 0x2170(%rip), %rdi      # 0x5908
callq 0x31a0
leaq 0x219d(%rip), %rdi      # 0x5941
callq 0x31a0
leaq 0x21d3(%rip), %rdi      # 0x5983
callq 0x31a0
leaq 0x21ed(%rip), %rdi      # 0x59a9
callq 0x31a0
leaq 0x2224(%rip), %rdi      # 0x59ec
callq 0x31a0
leaq 0x1b09(%rip), %rdi      # 0x52dd
xorl %eax, %eax
callq 0x3030
leaq 0x1b3f(%rip), %rdi      # 0x5321
leaq 0x1b6e(%rip), %rsi      # 0x5357
xorl %eax, %eax
callq 0x3030
leaq 0x222a(%rip), %rdi      # 0x5a21
callq 0x31a0
leaq 0x1b5c(%rip), %rdi      # 0x535f
xorl %eax, %eax
callq 0x3030
leaq 0x2253(%rip), %rdi      # 0x5a64
popq %rax
jmp 0x31a0
// File: /workspace/github_c_makefile_star2_O3/salextpuru[P]speccy-toochain/src/zmakebas/zmakebas.c
// Function: grok_block
int grok_block(unsigned char *ptr,int textlinenum)
{
static char *lookup[]=
  {
  "  ", " '", "' ", "''", " .", " :", "'.", "':",
  ". ", ".'", ": ", ":'", "..", ".:", ":.", "::",
  NULL
  };
char **lptr;
int f=128,v=-1;
            
for(lptr=lookup;*lptr!=NULL;lptr++,f++)
  {
  if(strncmp(ptr+1,*lptr,2)==0)
    {
    v=f;
    break;
    }
  }

if(v==-1)
  {
  fprintf(stderr,"line %d: invalid block graphics escape\n",textlinenum);
  exit(1);
  }

return(v);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
incq %r15
leaq 0x1b01(%rip), %rsi      # 0x5543
xorl %r14d, %r14d
leaq 0x42d4(%rip), %r12      # 0x7d20
movl $0x2, %edx
movq %r15, %rdi
callq 0x3090
testl %eax, %eax
je 0x3a72
movq 0x8(%r12,%r14,8), %rsi
incq %r14
cmpl $0x10, %r14d
jne 0x3a4c
movl %ebx, %edi
callq 0x3343
subl $-0x80, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/batman.c
// Function: get_gw_class
unsigned char get_gw_class(int down, int up)
{
	int mdown = 0, tdown, tup, difference = 0x0FFFFFFF;
	unsigned char gw_class = 0, sbit, part;


	/* test all downspeeds */
	for (sbit = 0; sbit < 2; sbit++) {

		for (part = 0; part < 16; part++) {

			tdown = 32 * (sbit + 2) * (1 << part);

			if ( abs(tdown - down) < difference) {

				gw_class = (sbit << 7) + (part << 3);
				difference = abs(tdown - down);
				mdown = tdown;

			}

		}

	}

	/* test all upspeeds */
	difference = 0x0FFFFFFF;

	for (part = 0; part < 8; part++) {

		tup = ((part + 1) * (mdown)) / 8;

		if (abs(tup - up) < difference) {

			gw_class = (gw_class & 0xF8) | part;
			difference = abs(tup - up);

		}

	}

	return gw_class;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl $0xfffffff, %r10d       # imm = 0xFFFFFFF
xorl %r8d, %r8d
movb $0x1, %r9b
xorl %eax, %eax
xorl %edx, %edx
movl %r8d, %r11d
shll $0x5, %r11d
orl $0x40, %r11d
shlb $0x7, %r8b
xorl %ecx, %ecx
movl %r11d, %ebx
shll %cl, %ebx
movl %r10d, %ebp
movl %ebx, %r14d
subl %edi, %r14d
movl %r14d, %r10d
negl %r10d
cmovsl %r14d, %r10d
cmpl %ebp, %r10d
cmovll %ebx, %edx
cmovgel %ebp, %r10d
movzbl %r8b, %r8d
movzbl %al, %eax
cmovll %r8d, %eax
incl %ecx
addb $0x8, %r8b
cmpl $0x10, %ecx
jne 0x3434
movl $0x1, %r8d
xorl %ecx, %ecx
testb $0x1, %r9b
movl $0x0, %r9d
jne 0x3423
movl $0xfffffff, %edi        # imm = 0xFFFFFFF
movl %edx, %r8d
leal 0x7(%r8), %r9d
testl %r8d, %r8d
cmovnsl %r8d, %r9d
sarl $0x3, %r9d
subl %esi, %r9d
movl %r9d, %r10d
negl %r10d
cmovsl %r9d, %r10d
movzbl %al, %r9d
movl %r9d, %eax
andl $0xf8, %eax
addl %ecx, %eax
cmpl %edi, %r10d
cmovll %r10d, %edi
cmovgel %r9d, %eax
leal 0x1(%rcx), %r9d
addl %edx, %r8d
movl %r9d, %ecx
cmpl $0x8, %r9d
jne 0x3488
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/batman.c
// Function: count_real_packets
static uint8_t count_real_packets(struct bat_packet *in, uint32_t neigh, struct batman_if *if_incoming)
{
	struct list_head *list_pos;
	struct orig_node *orig_node;
	struct neigh_node *tmp_neigh_node;
	uint8_t is_duplicate = 0;


	orig_node = get_orig_node( in->orig );

	/*char orig_str[ADDR_STR_LEN], neigh_str[ADDR_STR_LEN];

	addr_to_string( in->orig, orig_str, ADDR_STR_LEN );
	addr_to_string( neigh, neigh_str, ADDR_STR_LEN );

	debug_output( 3, "count_real_packets: orig = %s, neigh = %s, seq = %i, last seq = %i\n", orig_str, neigh_str, in->seqno, orig_node->last_real_seqno );*/

	list_for_each( list_pos, &orig_node->neigh_list ) {

		tmp_neigh_node = list_entry( list_pos, struct neigh_node, list );

		if ( !is_duplicate )
			is_duplicate = get_bit_status( tmp_neigh_node->real_bits, orig_node->last_real_seqno, in->seqno );

		if ( ( tmp_neigh_node->addr == neigh ) && ( tmp_neigh_node->if_incoming == if_incoming ) ) {

			bit_get_packet( tmp_neigh_node->real_bits, in->seqno - orig_node->last_real_seqno, 1 );
			/*debug_output( 3, "count_real_packets (yes): neigh = %s, is_new = %s, seq = %i, last seq = %i\n", neigh_str, ( is_new_seqno ? "YES" : "NO" ), in->seqno, orig_node->last_real_seqno );*/

		} else {

			bit_get_packet( tmp_neigh_node->real_bits, in->seqno - orig_node->last_real_seqno, 0 );
			/*debug_output( 3, "count_real_packets (no): neigh = %s, is_new = %s, seq = %i, last seq = %i\n", neigh_str, ( is_new_seqno ? "YES" : "NO" ), in->seqno, orig_node->last_real_seqno );*/

		}

		tmp_neigh_node->real_packet_count = bit_packet_count( tmp_neigh_node->real_bits );

	}

	if ( !is_duplicate ) {

		debug_output( 4, "updating last_seqno: old %d, new %d \n", orig_node->last_real_seqno, in->seqno );
		orig_node->last_real_seqno = in->seqno;

	}

	return is_duplicate;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %edi
callq 0x43c8
movq %rax, %r14
movq 0x48(%rax), %r13
movq %rax, %r15
addq $0x48, %r15
cmpq %r15, %r13
je 0x427f
xorl %r12d, %r12d
testb %r12b, %r12b
jne 0x4234
movq 0x20(%r13), %rdi
movzwl 0x42(%r14), %esi
movzwl 0x4(%rbx), %edx
callq 0x6442
movl %eax, %r12d
cmpl %ebp, 0x8(%r13)
jne 0x4244
movq (%rsp), %rax
cmpq %rax, 0x30(%r13)
je 0x4276
xorl %eax, %eax
movq 0x20(%r13), %rdi
movzwl 0x4(%rbx), %ecx
subw 0x42(%r14), %cx
movswl %cx, %esi
movzbl %al, %edx
callq 0x652d
movq 0x20(%r13), %rdi
callq 0x6630
movb %al, 0xc(%r13)
movq (%r13), %r13
cmpq %r15, %r13
jne 0x421a
jmp 0x427a
movb $0x1, %al
jmp 0x4246
testb %r12b, %r12b
jne 0x42a7
movzwl 0x42(%r14), %edx
movzwl 0x4(%rbx), %ecx
leaq 0xbca8(%rip), %rsi      # 0xff37
xorl %r12d, %r12d
movl $0x4, %edi
xorl %eax, %eax
callq 0xd88c
movzwl 0x4(%rbx), %eax
movw %ax, 0x42(%r14)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/originator.c
// Function: create_neighbor
struct neigh_node * create_neighbor(struct orig_node *orig_node, struct orig_node *orig_neigh_node, uint32_t neigh, struct batman_if *if_incoming) {

	struct neigh_node *neigh_node;

	debug_output( 4, "Creating new last-hop neighbour of originator\n" );

	neigh_node = debugMalloc( sizeof(struct neigh_node), 403 );
	memset( neigh_node, 0, sizeof(struct neigh_node) );
	INIT_LIST_HEAD(&neigh_node->list);

	neigh_node->addr = neigh;
	neigh_node->orig_node = orig_neigh_node;
	neigh_node->if_incoming = if_incoming;

	neigh_node->tq_recv = debugMalloc(sizeof(uint16_t) * global_win_size, 406);
	memset(neigh_node->tq_recv, 0, sizeof(uint16_t) * global_win_size);

	neigh_node->real_bits = debugMalloc(sizeof(TYPE_OF_WORD) * num_words, 407);
	memset(neigh_node->real_bits, 0, sizeof(TYPE_OF_WORD) * num_words);

	list_add_tail(&neigh_node->list, &orig_node->neigh_list);

	return neigh_node;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xbd23(%rip), %rsi      # 0xfff9
movl $0x4, %edi
xorl %eax, %eax
callq 0xd88c
movl $0x38, %edi
movl $0x193, %esi            # imm = 0x193
callq 0x5d52
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %rax, (%rax)
movl %ebp, 0x8(%rax)
movq %r12, 0x28(%rax)
movq %r15, 0x30(%rax)
leaq 0x12f82(%rip), %r15     # 0x17296
movzbl (%r15), %edi
addl %edi, %edi
movl $0x196, %esi            # imm = 0x196
callq 0x5d52
movq %rax, 0x10(%r14)
movzbl (%r15), %edx
addl %edx, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x21c0
leaq 0x12f59(%rip), %r15     # 0x17298
movzbl (%r15), %edi
shll $0x3, %edi
movl $0x197, %esi            # imm = 0x197
callq 0x5d52
movq %rax, 0x20(%r14)
movzbl (%r15), %edx
shll $0x3, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x21c0
addq $0x48, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5bcd
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/allocate.c
// Function: checkIntegrity
void checkIntegrity(void)
{
	struct chunkHeader *walker;
	struct chunkTrailer *chunkTrailer;
	unsigned char *memory;


#if defined MEMORY_USAGE

	struct memoryUsage *memoryWalker;

	debug_output( 5, " \nMemory usage information:\n" );

	pthread_mutex_lock(&memory_mutex);
	for ( memoryWalker = memoryList; memoryWalker != NULL; memoryWalker = memoryWalker->next ) {

		if ( memoryWalker->counter != 0 )
			debug_output( 5, "   tag: %4i, num malloc: %4i, bytes per malloc: %4i, total: %6i\n", memoryWalker->tag, memoryWalker->counter, memoryWalker->length, memoryWalker->counter * memoryWalker->length );

	}
	pthread_mutex_unlock(&memory_mutex);

#endif

	pthread_mutex_lock(&chunk_mutex);

	for (walker = chunkList; walker != NULL; walker = walker->next)
	{
		if (walker->magicNumber != MAGIC_NUMBER)
		{
			debug_output( 0, "checkIntegrity - invalid magic number in header: %08x, malloc tag = %d\n", walker->magicNumber, walker->tag );
			pthread_mutex_unlock(&chunk_mutex);
			restore_and_exit(0);
		}

		memory = (unsigned char *)walker;

		chunkTrailer = (struct chunkTrailer *)(memory + sizeof(struct chunkHeader) + getHeaderPad() + walker->length + getTrailerPad(walker->length));

		if (chunkTrailer->magicNumber != MAGIC_NUMBER)
		{
			debug_output( 0, "checkIntegrity - invalid magic number in trailer: %08x, malloc tag = %d\n", chunkTrailer->magicNumber, walker->tag );
			pthread_mutex_unlock(&chunk_mutex);
			restore_and_exit(0);
		}
	}

	pthread_mutex_unlock(&chunk_mutex);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xaaf1(%rip), %rsi      # 0x10700
movl $0x5, %edi
xorl %eax, %eax
callq 0xd88c
leaq 0x11886(%rip), %rdi     # 0x174a8
callq 0x24c0
movq 0x11872(%rip), %r14     # 0x174a0
testq %r14, %r14
je 0x5c68
leaq 0xaae3(%rip), %rbx      # 0x1071d
movl 0xc(%r14), %ecx
testl %ecx, %ecx
je 0x5c60
movl 0x8(%r14), %r8d
movl 0x10(%r14), %edx
movl %r8d, %r9d
imull %ecx, %r9d
movl $0x5, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xd88c
movq (%r14), %r14
testq %r14, %r14
jne 0x5c3a
leaq 0x11839(%rip), %rdi     # 0x174a8
callq 0x22d0
leaq 0x11855(%rip), %rdi     # 0x174d0
callq 0x24c0
leaq 0x11811(%rip), %rax     # 0x17498
movq (%rax), %rax
testq %rax, %rax
je 0x5ccb
movl 0x10(%rax), %edx
cmpl $0x12345678, %edx       # imm = 0x12345678
jne 0x5cde
movl 0x8(%rax), %ecx
leaq (%rax,%rcx), %rdx
andl $0x7, %ecx
movl $0x8, %esi
subq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
movl 0x18(%rsi,%rdx), %edx
cmpl $0x12345678, %edx       # imm = 0x12345678
je 0x5c87
movl 0xc(%rax), %ecx
leaq 0xaadd(%rip), %rsi      # 0x107a6
jmp 0x5ce8
leaq 0x117fe(%rip), %rdi     # 0x174d0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0
movl 0xc(%rax), %ecx
leaq 0xaa76(%rip), %rsi      # 0x1075e
xorl %edi, %edi
xorl %eax, %eax
callq 0xd88c
leaq 0x117d8(%rip), %rdi     # 0x174d0
callq 0x22d0
xorl %edi, %edi
callq 0xc084
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/allocate.c
// Function: checkLeak
void checkLeak(void)
{
	struct chunkHeader *walker;

	pthread_mutex_lock(&chunk_mutex);
	for (walker = chunkList; walker != NULL; walker = walker->next)
		debug_output( 0, "Memory leak detected, malloc tag = %d\n", walker->tag );

	pthread_mutex_unlock(&chunk_mutex);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x117c1(%rip), %rdi     # 0x174d0
callq 0x24c0
movq 0x1177d(%rip), %r14     # 0x17498
testq %r14, %r14
je 0x5d3f
leaq 0xaac8(%rip), %rbx      # 0x107ef
movl 0xc(%r14), %edx
xorl %edi, %edi
movq %rbx, %rsi
xorl %eax, %eax
callq 0xd88c
movq (%r14), %r14
testq %r14, %r14
jne 0x5d27
leaq 0x1178a(%rip), %rdi     # 0x174d0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/allocate.c
// Function: debugRealloc
void *debugRealloc(void *memoryParameter, uint32_t length, int32_t tag)
{
	unsigned char *memory;
	struct chunkHeader *chunkHeader=NULL;
	struct chunkTrailer *chunkTrailer;
	unsigned char *result;
	uint32_t copyLength;

	if (memoryParameter) { /* if memoryParameter==NULL, realloc() should work like malloc() !! */
		memory = memoryParameter;
		chunkHeader = (struct chunkHeader *)(memory - sizeof(struct chunkHeader) - getHeaderPad());

		if (chunkHeader->magicNumber != MAGIC_NUMBER)
		{
			debug_output( 0, "debugRealloc - invalid magic number in header: %08x, malloc tag = %d\n", chunkHeader->magicNumber, chunkHeader->tag );
			restore_and_exit(0);
		}

		if (checkPadding(memory - getHeaderPad(), getHeaderPad()) == 0) {
			debug_output( 0, "debugRealloc - invalid magic padding in header, malloc tag = %d\n", chunkHeader->tag );
			restore_and_exit(0);
		}

		chunkTrailer = (struct chunkTrailer *)(memory + chunkHeader->length + getTrailerPad(chunkHeader->length));

		if (chunkTrailer->magicNumber != MAGIC_NUMBER)
		{
			debug_output( 0, "debugRealloc - invalid magic number in trailer: %08x, malloc tag = %d\n", chunkTrailer->magicNumber, chunkHeader->tag );
			restore_and_exit(0);
		}

		if (checkPadding(memory + chunkHeader->length, getTrailerPad(chunkHeader->length)) == 0) {
			debug_output( 0, "debugRealloc - invalid magic padding in trailer, malloc tag = %d\n", chunkHeader->tag );
			restore_and_exit(0);
		}
	}


	result = debugMalloc(length, tag);
	if (memoryParameter) {
		copyLength = length;

		if (copyLength > chunkHeader->length)
			copyLength = chunkHeader->length;

		memcpy(result, memoryParameter, copyLength);
		debugFree(memoryParameter, 9999);
	}

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
testq %rdi, %rdi
je 0x623f
movq %rdi, %rbx
movl -0x8(%rdi), %eax
cmpl $0x12345678, %eax       # imm = 0x12345678
jne 0x6268
movl -0x10(%rbx), %edi
leaq (%rbx,%rdi), %rcx
andl $0x7, %edi
movl $0x8, %esi
subq %rdi, %rsi
testq %rdi, %rdi
cmoveq %rdi, %rsi
movl (%rsi,%rcx), %eax
cmpl $0x12345678, %eax       # imm = 0x12345678
jne 0x6274
testq %rdi, %rdi
je 0x6204
xorl %eax, %eax
xorl %edi, %edi
addb $-0x59, %dil
cmpb (%rcx,%rax), %dil
jne 0x624e
incq %rax
cmpq %rax, %rsi
jne 0x61f2
movl %r14d, %edi
movl %edx, %esi
callq 0x5d52
movq %rax, %r15
movl -0x10(%rbx), %eax
cmpl %r14d, %eax
cmovbl %eax, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2290
movq %rbx, %rdi
movl $0x270f, %esi           # imm = 0x270F
callq 0x628b
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movl %r14d, %edi
movl %edx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x5d52
movl -0xc(%rbx), %edx
leaq 0xa676(%rip), %rsi      # 0x108ce
xorl %edi, %edi
xorl %eax, %eax
callq 0xd88c
xorl %edi, %edi
callq 0xc084
movl -0xc(%rbx), %ecx
leaq 0xa5cf(%rip), %rsi      # 0x10841
jmp 0x627e
movl -0xc(%rbx), %ecx
leaq 0xa609(%rip), %rsi      # 0x10887
xorl %edi, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0xd88c
jmp 0x6261
// File: /workspace/github_c_makefile_star2_O3/open-mesh-mirror[P]batmand/bitarray.c
// Function: bit_shift
void bit_shift( TYPE_OF_WORD *seq_bits, int32_t n ) {
	int32_t word_offset, word_num;
	int32_t i;

/*	bit_print( seq_bits );*/
	if( n<=0 ) return;

	word_offset= n%WORD_BIT_SIZE;	/* shift how much inside each word */
	word_num   = n/WORD_BIT_SIZE;	/* shift over how much (full) words */

	for ( i=num_words-1; i>word_num; i-- ) {
		/* going from old to new, so we can't overwrite the data we copy from. *
 		 * left is high, right is low: FEDC BA98 7654 3210
		 *	                                  ^^ ^^
		 *                             vvvv
		 * ^^^^ = from, vvvvv =to, we'd have word_num==1 and
		 * word_offset==WORD_BIT_SIZE/2 ????? in this example. (=24 bits)
		 *
		 * our desired output would be: 9876 5432 1000 0000
		 * */

		seq_bits[i]=
			(seq_bits[i - word_num] << word_offset) +
					/* take the lower port from the left half, shift it left to its final position */
			(seq_bits[i - word_num - 1] >>	(WORD_BIT_SIZE-word_offset));
					/* and the upper part of the right half and shift it left to it's position */
		/* for our example that would be: word[0] = 9800 + 0076 = 9876 */
	}
	/* now for our last word, i==word_num, we only have the it's "left" half. that's the 1000 word in
	 * our example.*/

	seq_bits[i]= (seq_bits[i - word_num] << word_offset);

	/* pad the rest with 0, if there is anything */
	i--;

	for (; i>=0; i--) {
		seq_bits[i]= 0;
	}
/*	bit_print( seq_bits ); */
}

// Assembly:
testl %esi, %esi
jle 0x652c
movl %esi, %eax
andl $0x3f, %eax
shrl $0x6, %esi
leaq 0x10ded(%rip), %rcx     # 0x17298
movzbl (%rcx), %edx
leal -0x1(%rdx), %ecx
cmpl %esi, %ecx
jle 0x6505
pushq %rbx
movl $0x40, %r8d
subl %eax, %r8d
movl %edx, %edx
movl %esi, %r9d
leal (,%rsi,8), %ecx
movq %rdi, %r10
subq %rcx, %r10
addq $-0x8, %r10
movq %rdx, %r11
movq -0x8(%r10,%rdx,8), %rdx
movq (%r10,%r11,8), %rbx
movl %eax, %ecx
shlq %cl, %rbx
movl %r8d, %ecx
shrq %cl, %rdx
addq %rbx, %rdx
movq %rdx, -0x8(%rdi,%r11,8)
leaq -0x1(%r11), %rdx
addq $-0x2, %r11
cmpq %r9, %r11
jg 0x64d5
leal -0x1(%rdx), %ecx
popq %rbx
movslq %ecx, %r8
subl %esi, %ecx
movslq %ecx, %rcx
movq (%rdi,%rcx,8), %rsi
movl %eax, %ecx
shlq %cl, %rsi
movq %rsi, (%rdi,%r8,8)
cmpl $0x2, %edx
jl 0x652c
decl %edx
shlq $0x3, %rdx
xorl %esi, %esi
jmp 0x21c0
retq