LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: prefix_list_within
int
prefix_list_within(const struct prefix *p, const struct prefix_list *pl)
{
    int i;

    if(pl == NULL)
        return 0;

    for(i = 0; i < pl->numprefixes; i++) {
        if(prefix_within(p, &pl->prefixes[i]))
            return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc920
movl $0x0, -0x4(%rbp)
jmp 0xc973
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xc96c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x1c(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rsi
callq 0xc730
cmpl $0x0, %eax
je 0xc95f
movl $0x1, -0x4(%rbp)
jmp 0xc973
jmp 0xc961
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc927
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: prefix_list_within_v4
int
prefix_list_within_v4(const unsigned char *p4, const struct prefix_list *pl)
{
    struct prefix p;
    memset(&p, 0, sizeof(p));
    memcpy(&p.p, v4prefix, 12);
    memcpy((char*)&p.p + 12, p4, 4);
    p.plen = 128;

    return prefix_list_within(&p, pl);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2170
movq 0x6969(%rip), %rax      # 0x13310
movq %rax, -0x2c(%rbp)
movl 0x6967(%rip), %eax      # 0x13318
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movb $-0x80, -0x1c(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x2c(%rbp), %rdi
callq 0xc900
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: prefix_list_overlap
int
prefix_list_overlap(const struct prefix *p, const struct prefix_list *pl,
                    int respect_precedence)
{
    unsigned char pp[16];
    int i;

    memcpy(pp, &p->p, 16);

    if(pl == NULL)
        return 0;

    for(i = 0; i < pl->numprefixes; i++) {
        struct prefix *q = &pl->prefixes[i];
        int plen = min(p->plen, q->plen);
        unsigned char qq[16];

        if(respect_precedence &&
           ((id_eq(p->id, q->id) && p->eid == q->eid) ||
            prefix_takes_precedence(p, q)))
            continue;

        memcpy(qq, &q->p, 16);

        if(memcmp(pp, qq, plen / 8) != 0)
            continue;

        if(plen % 8 == 0) {
            return 1;
        } else {
            int i = plen / 8 + 1;
            unsigned char mask = (0xFF << (plen % 8)) & 0xFF;
            if((pp[i] & mask) == (qq[i] & mask)) {
                return 1;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xca19
movl $0x0, -0x4(%rbp)
jmp 0xcb67
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xcb60
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %edi
movq -0x40(%rbp), %rax
movzbl 0x10(%rax), %esi
callq 0xcb70
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xcaa8
movq -0x10(%rbp), %rdi
addq $0x14, %rdi
movq -0x40(%rbp), %rsi
addq $0x14, %rsi
callq 0xcba0
cmpl $0x0, %eax
je 0xca91
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x40(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0xcaa3
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc6b0
cmpl $0x0, %eax
je 0xcaa8
jmp 0xcb52
movq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x60(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl -0x44(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movslq %eax, %rdx
callq 0x21c0
cmpl $0x0, %eax
je 0xcadd
jmp 0xcb52
movl -0x44(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xcaf6
movl $0x1, -0x4(%rbp)
jmp 0xcb67
movl -0x44(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
addl $0x1, %eax
movl %eax, -0x64(%rbp)
movl -0x44(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0xff, %eax
shll %cl, %eax
andl $0xff, %eax
movb %al, -0x65(%rbp)
movslq -0x64(%rbp), %rax
movzbl -0x30(%rbp,%rax), %eax
movzbl -0x65(%rbp), %ecx
andl %ecx, %eax
movslq -0x64(%rbp), %rcx
movzbl -0x60(%rbp,%rcx), %ecx
movzbl -0x65(%rbp), %edx
andl %edx, %ecx
cmpl %ecx, %eax
jne 0xcb4e
movl $0x1, -0x4(%rbp)
jmp 0xcb67
jmp 0xcb50
jmp 0xcb52
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xca20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: filter_included
struct prefix_list *
filter_included(struct prefix_list *pl)
{
    int i, j;

    i = 0;
 again:
    while(i < pl->numprefixes) {
        for(j = 0; j < pl->numprefixes; j++) {
            if(i != j && prefix_within(&pl->prefixes[i], &pl->prefixes[j])) {
                pl = prefix_list_remove(pl, i);
                goto again;
            }
        }
        i++;
    }
    return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0xcbe5
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xcc6d
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xcc5f
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xcc52
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movslq -0x10(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rsi
callq 0xc730
cmpl $0x0, %eax
je 0xcc52
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc480
movq %rax, -0x8(%rbp)
jmp 0xcbe3
jmp 0xcc54
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcbfb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcbe5
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: prefix_valid
int
prefix_valid(const struct prefix *p,
             const struct prefix_list *pl1, const struct prefix_list *pl2)
{
    if(pl1 && prefix_list_overlap(p, pl1, 1))
        return 0;
    if(pl2 && prefix_list_overlap(p, pl2, 1))
        return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xccbb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0xc9e0
cmpl $0x0, %eax
je 0xccbb
movl $0x0, -0x4(%rbp)
jmp 0xcce9
cmpq $0x0, -0x20(%rbp)
je 0xcce2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0xc9e0
cmpl $0x0, %eax
je 0xcce2
movl $0x0, -0x4(%rbp)
jmp 0xcce9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: random_bits
void
random_bits(unsigned char *buf, int first, int len)
{
    int i;

    if(first % 8 != 0) {
        unsigned char mask = (0xFF >> (first % 8)) ^ 0xFF;
        buf[first / 8] &= mask;
        buf[first / 8] |= random() & (0xFF ^ mask);
    }

    for(i = (first + 7) / 8; i < (first + len) / 8; i++)
        buf[i] = random() % 0xFF;

    if((first + len) % 8 != 0) {
        unsigned char mask = 0xFF >> ((first + len) % 8);
        buf[(first + len) / 8] &= mask;
        buf[(first + len) / 8] |= random() & (0xFF ^ mask);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xcda7
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0xff, %eax
sarl %cl, %eax
xorl $0xff, %eax
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %esi
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
callq 0x2250
movq %rax, %rsi
movzbl -0x15(%rbp), %eax
xorl $0xff, %eax
cltq
andq %rax, %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x7, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0xcdfa
callq 0x2250
movl $0xff, %ecx
cqto
idivq %rcx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcdb8
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xce96
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl $0xff, %eax
sarl %cl, %eax
movb %al, -0x16(%rbp)
movzbl -0x16(%rbp), %esi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
andl %esi, %edx
movb %dl, (%rax,%rcx)
callq 0x2250
movq %rax, %rsi
movzbl -0x16(%rbp), %eax
xorl $0xff, %eax
cltq
andq %rax, %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
orq %rsi, %rdx
movb %dl, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: random_prefix
int
random_prefix(struct prefix *res,
              int plen, int zero_bits, int tweak_v6,
              const struct prefix *in, const struct prefix_list *out)
{
    unsigned char pp[16];
    int i;
    struct prefix p;

    if(plen > 128)
        plen = 128;

    if(in->plen + zero_bits > plen)
        return 0;

    for(i = 0; i < 20; i++) {
        memset(pp, 0, 16);
        memcpy(pp, &in->p, 16);
        random_bits(pp, in->plen + zero_bits, (plen - (in->plen + zero_bits)));
        if(tweak_v6 && in->plen <= 68)
            pp[8] &= ~3;

        memcpy(&p.p, pp, 16);
        p.plen = plen;
        if(!prefix_list_overlap(&p, out, 0)) {
            *res = p;
            return 1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x80, -0x14(%rbp)
jle 0xcecd
movl $0x80, -0x14(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
addl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0xcee9
movl $0x0, -0x4(%rbp)
jmp 0xcfc9
movl $0x0, -0x44(%rbp)
cmpl $0x14, -0x44(%rbp)
jge 0xcfc2
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %esi
addl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
addl -0x18(%rbp), %eax
subl %eax, %edx
callq 0xcd00
cmpl $0x0, -0x1c(%rbp)
je 0xcf5e
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x44, %eax
jg 0xcf5e
movzbl -0x38(%rbp), %eax
andl $-0x4, %eax
movb %al, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x50(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x60(%rbp), %rdi
xorl %edx, %edx
callq 0xc9e0
cmpl $0x0, %eax
jne 0xcfb2
movq -0x10(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x48(%rbp), %ecx
movl %ecx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xcfc9
jmp 0xcfb4
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xcef0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: generate_random_v4
int
generate_random_v4(unsigned char *ip, const struct prefix_list *pl)
{
    int start, i, rc;
    struct prefix p;

    if(pl == NULL)
        return -1;

    start = random() % pl->numprefixes;

    for(i = 0; i < pl->numprefixes; i++) {
        int j = (start + i) % pl->numprefixes;
        if(prefix_v4(&pl->prefixes[j]) && pl->prefixes[j].plen <= 126) {
            rc = random_prefix(&p, 128, 0, 0, &pl->prefixes[j], NULL);
            if(rc >= 0) {
                memcpy(ip, (unsigned char*)&p.p + 12, 4);
                return 1;
            }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd093
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd16d
callq 0x2250
movq -0x18(%rbp), %rcx
movswq 0x8(%rcx), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd166
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cltd
idivl %ecx
movl %edx, -0x44(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x44(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rdi
callq 0xcfe0
cmpl $0x0, %eax
je 0xd156
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x44(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movzbl 0x10(%rax), %eax
cmpl $0x7e, %eax
jg 0xd156
movq -0x18(%rbp), %rax
movq (%rax), %r8
movslq -0x44(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %r8
leaq -0x40(%rbp), %rdi
movl $0x80, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
movl %ecx, %edx
callq 0xcea0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xd154
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xd16d
jmp 0xd156
jmp 0xd158
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd0b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: interface_v4
int
interface_v4(struct interface *interface, unsigned char *v4_return)
{
    int i;

    for(i = 0; i < interface->numassigned; i++) {
        struct in6_addr *a = &interface->assigned[i].assigned_address;
        if(IN6_IS_ADDR_V4MAPPED(a)) {
            memcpy(v4_return, (char*)a + 12, 4);
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x68(%rcx), %eax
jge 0xd23f
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x35(%rbp)
jne 0xd208
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
movb %al, -0x35(%rbp)
jne 0xd208
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
movl $0xffff, %edi           # imm = 0xFFFF
callq 0x2160
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xd22f
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xd246
jmp 0xd231
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd197
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: all_assigned_prefixes
struct prefix_list *
all_assigned_prefixes()
{
    int i, j;
    struct prefix_list *pl = create_prefix_list(), *pl2;
    if(pl == NULL)
        return NULL;

    for(i = 0; i < numnodes; i++) {
        if(nodes[i].assigned == NULL)
            continue;
        for(j = 0; j < nodes[i].assigned->numprefixes; j++) {
            pl2 = prefix_list_cons_prefix(pl, &nodes[i].assigned->prefixes[j]);
            if(pl2 == NULL) {
                destroy_prefix_list(pl);
                return NULL;
            }
            pl = pl2;
        }
    }
    return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0xc2b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd275
movq $0x0, -0x8(%rbp)
jmp 0xd34a
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x902e(%rip), %rcx      # 0x162b4
cmpl (%rcx), %eax
jge 0xd342
movslq -0xc(%rbp), %rcx
leaq 0xa607(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x50(%rax)
jne 0xd2ac
jmp 0xd334
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0xa5df(%rip), %rcx      # 0x178a0
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movq 0x50(%rcx), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd332
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xa5bd(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rax
movq (%rax), %rsi
movslq -0x10(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rsi
callq 0xc300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd31f
movq -0x18(%rbp), %rdi
callq 0xc2d0
movq $0x0, -0x8(%rbp)
jmp 0xd34a
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd2b3
jmp 0xd334
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd27c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: all_delegated_prefixes
struct prefix_list *
all_delegated_prefixes()
{
    int i, j, k;
    struct prefix_list *pl = create_prefix_list(), *pl2;
    if(pl == NULL)
        return NULL;

    for(i = 0; i < numnodes; i++) {
        for(j = 0; j < nodes[i].numexts; j++) {
            if(nodes[i].exts[j]->delegated == NULL)
                continue;
            for(k = 0; k < nodes[i].exts[j]->delegated->numprefixes; k++) {
                struct prefix *p = &nodes[i].exts[j]->delegated->prefixes[k];
                pl2 = prefix_list_cons_prefix(pl, p);
                if(pl2 == NULL) {
                    destroy_prefix_list(pl);
                    return NULL;
                }
                pl = pl2;
            }
        }
    }
    return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xc2b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd5a5
movq $0x0, -0x8(%rbp)
jmp 0xd6db
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x8cfe(%rip), %rcx      # 0x162b4
cmpl (%rcx), %eax
jge 0xd6d3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0xa2cd(%rip), %rcx      # 0x178a0
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x68(%rcx), %eax
jge 0xd6c3
movslq -0xc(%rbp), %rcx
leaq 0xa2b2(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x60(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
jne 0xd60c
jmp 0xd6b5
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0xa27f(%rip), %rcx      # 0x178a0
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movq 0x60(%rcx), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd6b3
movslq -0xc(%rbp), %rcx
leaq 0xa256(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x60(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc300
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xd69d
movq -0x20(%rbp), %rdi
callq 0xc2d0
movq $0x0, -0x8(%rbp)
jmp 0xd6db
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd613
jmp 0xd6b5
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd5c5
jmp 0xd6c5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd5ac
movq -0x20(%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/jech[P]shncpd/prefix.c
// Function: all_node_addresses
struct prefix_list *
all_node_addresses()
{
    int i, j;
    struct prefix_list *pl = create_prefix_list(), *pl2;
    if(pl == NULL)
        return NULL;

    for(i = 0; i < numnodes; i++) {
        if(nodes[i].addresses == NULL || id_eq(nodes[i].id, myid))
            continue;
        for(j = 0; j < nodes[i].addresses->numprefixes; j++) {
            struct prefix *p = &nodes[i].addresses->prefixes[j];
            pl2 = prefix_list_cons_prefix(pl, p);
            if(pl2 == NULL) {
                destroy_prefix_list(pl);
                return NULL;
            }
            pl = pl2;
        }
    }
    return pl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0xc2b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xd715
movq $0x0, -0x8(%rbp)
jmp 0xd81c
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x8b8e(%rip), %rcx      # 0x162b4
cmpl (%rcx), %eax
jge 0xd814
movslq -0xc(%rbp), %rcx
leaq 0xa167(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x58(%rax)
je 0xd76e
movslq -0xc(%rbp), %rax
leaq 0xa14e(%rip), %rdi      # 0x178a0
imulq $0x70, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
leaq 0x8b2c(%rip), %rsi      # 0x16290
callq 0xcba0
cmpl $0x0, %eax
je 0xd773
jmp 0xd806
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq -0xc(%rbp), %rdx
leaq 0xa118(%rip), %rcx      # 0x178a0
imulq $0x70, %rdx, %rdx
addq %rdx, %rcx
movq 0x58(%rcx), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd804
movslq -0xc(%rbp), %rcx
leaq 0xa0fa(%rip), %rax      # 0x178a0
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc300
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd7ee
movq -0x18(%rbp), %rdi
callq 0xc2d0
movq $0x0, -0x8(%rbp)
jmp 0xd81c
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd77a
jmp 0xd806
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd71c
movq -0x18(%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/jech[P]shncpd/prefix.c
// Function: best_prefix
int
best_prefix(const struct prefix *delegated, int eid,
            const struct prefix *assigned,
            const struct prefix_list *link_assigned,
            struct prefix *best_return)
{
    struct prefix *best = NULL;
    int i;

    if(link_assigned) {
        for(i = 0; i < link_assigned->numprefixes; i++) {
            struct prefix *p = &link_assigned->prefixes[i];
            if(!prefix_within(p, delegated) && !prefix_within(delegated, p))
                continue;
            if(best && prefix_takes_precedence(best, p))
                continue;

            best = p;
        }
    }

    if(!best)
        return 0;

    if(assigned && prefix_takes_precedence(assigned, best))
        return 0;

    *best_return = *best;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd8e0
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd8de
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc730
cmpl $0x0, %eax
jne 0xd8b0
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xc730
cmpl $0x0, %eax
jne 0xd8b0
jmp 0xd8d3
cmpq $0x0, -0x38(%rbp)
je 0xd8cb
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xc6b0
cmpl $0x0, %eax
je 0xd8cb
jmp 0xd8d3
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xd865
jmp 0xd8e0
cmpq $0x0, -0x38(%rbp)
jne 0xd8f0
movl $0x0, -0x4(%rbp)
jmp 0xd93d
cmpq $0x0, -0x20(%rbp)
je 0xd912
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc6b0
cmpl $0x0, %eax
je 0xd912
movl $0x0, -0x4(%rbp)
jmp 0xd93d
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: publish_prefix
int
publish_prefix(struct interface *interface, struct assigned_prefix *ap,
               int publish)
{
    if(publish) {
        memcpy(ap->assigned.id, myid, 4);
        ap->published = 1;
    } else {
        ap->published = 0;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xd982
movq -0x10(%rbp), %rax
leaq 0x8920(%rip), %rcx      # 0x16290
movl (%rcx), %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x38(%rax)
jmp 0xd98d
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: route_externals
int
route_externals(struct external **ext, int numexternals, int add)
{
    int i, j, rc = 1;
    struct in6_addr def;
    struct in6_addr v4_def;
    memset(&def, 0, sizeof(def));
    memcpy(&v4_def, v4prefix, 16);
    for(i = 0; i < numexternals; i++) {
        for(j = 0; j < ext[i]->delegated->numprefixes; j++) {
            struct prefix *p = &ext[i]->delegated->prefixes[j];
            int rrc;
            if(prefix_v4(p)) {
                rrc = kernel_route(0, NULL, &v4_def, 96, NULL, 0, add);
                rrc = kernel_route(0, NULL, &p->p, p->plen, NULL, 0, add);
            } else {
                rrc = kernel_route(0, NULL, &def, 0, &p->p, p->plen, add);
                rrc = kernel_route(0, NULL, &p->p, p->plen, NULL, 0, add);
            }
            if(rrc < 0)
                rc = rrc;
        }
    }
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq 0x5940(%rip), %rax      # 0x13310
movq %rax, -0x3c(%rbp)
movq 0x593d(%rip), %rax      # 0x13318
movq %rax, -0x34(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xdb10
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rcx), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xdb00
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xcfe0
cmpl $0x0, %eax
je 0xda95
movl -0x10(%rbp), %eax
xorl %r9d, %r9d
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0x3c(%rbp), %rdx
movl $0x60, %ecx
movl %r9d, %edi
movq %r8, %rsi
movl %eax, (%rsp)
callq 0xf490
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdx
movq -0x48(%rbp), %rax
movzbl 0x10(%rax), %ecx
movl -0x10(%rbp), %eax
xorl %r9d, %r9d
xorl %esi, %esi
movl %esi, %r8d
movl %r9d, %edi
movq %r8, %rsi
movl %eax, (%rsp)
callq 0xf490
movl %eax, -0x4c(%rbp)
jmp 0xdae4
movq -0x48(%rbp), %r8
movq -0x48(%rbp), %rax
movzbl 0x10(%rax), %r9d
movl -0x10(%rbp), %eax
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %esi
leaq -0x2c(%rbp), %rdx
movl %ecx, %edi
movl %eax, (%rsp)
callq 0xf490
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdx
movq -0x48(%rbp), %rax
movzbl 0x10(%rax), %ecx
movl -0x10(%rbp), %eax
xorl %r9d, %r9d
xorl %esi, %esi
movl %esi, %r8d
movl %r9d, %edi
movq %r8, %rsi
movl %eax, (%rsp)
callq 0xf490
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jge 0xdaf0
movl -0x4c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xdaf2
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xd9f9
jmp 0xdb02
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd9e6
movl -0x1c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: destroy_assigned_address
int
destroy_assigned_address(struct interface *interface,
                         struct assigned_prefix *ap)
{
    int rc = 0;

    if(IN6_IS_ADDR_UNSPECIFIED(&ap->assigned_address))
        return 0;

    debugf("Removing address ");
    debug_address(&ap->assigned_address);
    debugf(" from %s.\n", interface->ifname);

    assert(ap->assigned.plen > 0 && ap->applied);

    if(interface->ifindex > 0) {
        rc = kernel_address(interface->ifindex, interface->ifname,
                            &ap->assigned_address, ap->assigned.plen, 0);
        if(rc < 0)
            fprintf(stderr, "Couldn't remove address.\n");
    }

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x2d(%rbp)
jne 0xdb7d
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x4(%rcx)
movb %al, -0x2d(%rbp)
jne 0xdb7d
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x8(%rcx)
movb %al, -0x2d(%rbp)
jne 0xdb7d
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xdb9a
movl $0x0, -0x4(%rbp)
jmp 0xdc83
jmp 0xdb9c
leaq 0x86c5(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0xdbbb
movl $0x2, %edi
leaq 0x5526(%rip), %rsi      # 0x130da
movb $0x0, %al
callq 0xfda0
jmp 0xdbbd
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0xbf70
leaq 0x8697(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0xdbf0
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x2, %edi
leaq 0x5503(%rip), %rsi      # 0x130ec
movb $0x0, %al
callq 0xfda0
jmp 0xdbf2
movq -0x18(%rbp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x0, %eax
jle 0xdc0b
movq -0x18(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0xdc0b
jmp 0xdc2a
leaq 0x54e5(%rip), %rdi      # 0x130f7
leaq 0x5476(%rip), %rsi      # 0x1308f
movl $0x2e2, %edx            # imm = 0x2E2
leaq 0x54f7(%rip), %rcx      # 0x1311c
callq 0x2150
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0xdc7d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
addq $0x60, %rdx
movq -0x18(%rbp), %rax
movzbl 0x2c(%rax), %ecx
xorl %r8d, %r8d
callq 0xf350
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xdc7b
movq 0x838e(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
leaq 0x54f3(%rip), %rsi      # 0x13167
movb $0x0, %al
callq 0x21f0
jmp 0xdc7d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: destroy_assigned
int
destroy_assigned(struct interface *interface, struct assigned_prefix *ap)
{
    if(ap->applied) {
        destroy_assigned_address(interface, ap);

        debugf("Removing prefix ");
        debug_prefix(&ap->assigned);
        debugf(" from %s.\n", interface->ifname);

        assert(ap->assigned.plen > 0);
        if(interface->ifindex > 0)
            kernel_route(interface->ifindex, interface->ifname,
                         &ap->assigned.p, ap->assigned.plen, NULL, 0, 0);
        ap->applied = 0;
        ra_retract(&ap->assigned);
        schedule_ra(NULL, 1, 0);
    }
    ts_zero(&ap->apply_timer);
    publish_prefix(interface, ap, 0);
    memset(&ap->assigned, 0, sizeof(ap->assigned));
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0xdda3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdb20
leaq 0x85a6(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0xdcda
movl $0x2, %edi
leaq 0x54ae(%rip), %rsi      # 0x13181
movb $0x0, %al
callq 0xfda0
jmp 0xdcdc
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
callq 0xc010
leaq 0x8578(%rip), %rax      # 0x16268
cmpl $0x2, (%rax)
jl 0xdd0f
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x2, %edi
leaq 0x53e4(%rip), %rsi      # 0x130ec
movb $0x0, %al
callq 0xfda0
jmp 0xdd11
movq -0x10(%rbp), %rax
movzbl 0x2c(%rax), %eax
cmpl $0x0, %eax
jle 0xdd20
jmp 0xdd3f
leaq 0x546b(%rip), %rdi      # 0x13192
leaq 0x5361(%rip), %rsi      # 0x1308f
movl $0x2f8, %edx            # imm = 0x2F8
leaq 0x546e(%rip), %rcx      # 0x131a8
callq 0x2150
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0xdd7b
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rdx
addq $0x1c, %rdx
movq -0x10(%rbp), %rax
movzbl 0x2c(%rax), %ecx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0xf490
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
callq 0x8ab0
xorl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8b60
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xfc10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xd950
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x2170
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: find_assigned
struct assigned_prefix *
find_assigned(struct interface *interface, const struct prefix *delegated,
              int create)
{
    struct assigned_prefix *new;
    int i;

    for(i = 0; i < interface->numassigned; i++) {
        if(prefix_eq(&interface->assigned[i].delegated, delegated))
            return &interface->assigned[i];
    }

    if(!create)
        return NULL;

    new = realloc(interface->assigned,
                  (interface->numassigned + 1) *
                  sizeof(struct assigned_prefix));
    if(new == NULL)
        return NULL;
    interface->assigned = new;

    memset(&interface->assigned[interface->numassigned], 0,
           sizeof(struct assigned_prefix));
    interface->assigned[interface->numassigned].delegated = *delegated;
    return &interface->assigned[interface->numassigned++];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x68(%rcx), %eax
jge 0xde50
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x2c(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5c0
cmpl $0x0, %eax
je 0xde43
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xdf23
jmp 0xde45
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xddfa
cmpl $0x0, -0x1c(%rbp)
jne 0xde63
movq $0x0, -0x8(%rbp)
jmp 0xdf23
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
addl $0x1, %eax
cltq
imulq $0x70, %rax, %rsi
callq 0x2290
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xde98
movq $0x0, -0x8(%rbp)
jmp 0xdf23
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x68(%rax), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x68(%rcx), %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x68(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x68(%rdx)
movslq %ecx, %rcx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: flush_assigned
void
flush_assigned(struct interface *interface, struct assigned_prefix *ap)
{
    int n = ap - interface->assigned;
    assert(n >= 0 && n < interface->numassigned);

    destroy_assigned(interface, ap);
    if(n < interface->numassigned - 1)
        interface->assigned[n] =
            interface->assigned[interface->numassigned - 1];
    interface->numassigned--;

    if(interface->numassigned == 0) {
        free(interface->assigned);
        interface->assigned = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rcx
subq %rcx, %rax
movl $0x70, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xdf70
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x68(%rcx), %eax
jge 0xdf70
jmp 0xdf8f
leaq 0x5274(%rip), %rdi      # 0x131eb
leaq 0x5111(%rip), %rsi      # 0x1308f
movl $0x326, %edx            # imm = 0x326
leaq 0x5286(%rip), %rcx      # 0x13210
callq 0x2150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xdc90
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x68(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xdfe5
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x70, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
subl $0x1, %eax
cltq
imulq $0x70, %rax, %rax
addq %rax, %rsi
movl $0x70, %edx
callq 0x2230
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x68(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x68(%rax)
jne 0xe015
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: select_plen
static int
select_plen(struct prefix *delegated, enum interface_type type)
{
    if(type == INTERFACE_MESH)
        return 128;

    if(prefix_v4(delegated))
        return min(126, max(120, delegated->plen + 4));
    else if(delegated->plen <= 62)
        return 64;
    else
        return 80;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0xe3be
movl $0x80, -0x4(%rbp)
jmp 0xe40f
movq -0x10(%rbp), %rdi
callq 0xcfe0
cmpl $0x0, %eax
je 0xe3f2
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %esi
addl $0x4, %esi
movl $0x78, %edi
callq 0xec30
movl %eax, %esi
movl $0x7e, %edi
callq 0xcb70
movl %eax, -0x4(%rbp)
jmp 0xe40f
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x3e, %eax
jg 0xe408
movl $0x40, -0x4(%rbp)
jmp 0xe40f
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/prefix.c
// Function: prefix_assignment_cleanup
void
prefix_assignment_cleanup()
{
    int i;
    for(i = 0; i < numinterfaces; i++) {
        while(interfaces[i].numassigned > 0)
            flush_assigned(&interfaces[i], &interfaces[i].assigned[0]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
leaq 0x76f7(%rip), %rcx      # 0x162b0
cmpl (%rcx), %eax
jge 0xec1c
jmp 0xebbf
movslq -0x4(%rbp), %rcx
leaq 0x76f6(%rip), %rax      # 0x162c0
imulq $0x98, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x68(%rax)
jle 0xec0f
movslq -0x4(%rbp), %rax
leaq 0x76db(%rip), %rdi      # 0x162c0
imulq $0x98, %rax, %rax
addq %rax, %rdi
movslq -0x4(%rbp), %rcx
leaq 0x76c6(%rip), %rax      # 0x162c0
imulq $0x98, %rcx, %rcx
addq %rcx, %rax
movq 0x60(%rax), %rsi
callq 0xdf30
jmp 0xebbf
jmp 0xec11
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xebaf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/local.c
// Function: set_config_var
static int
set_config_var(const char *name, const struct prefix_list *pl, int v4)
{
    char buf[(INET6_ADDRSTRLEN + 1) * 20];

    if(pl && pl->prefixes > 0) {
        int i;
        buf[0] = '\0';
        for(i = 0; i < pl->numprefixes; i++) {
            char a[INET6_ADDRSTRLEN];
            if(v4)
                inet_ntop(AF_INET, (char*)&pl->prefixes[i].p + 12,
                          a, sizeof(a));
            else
                inet_ntop(AF_INET6, &pl->prefixes[i].p, a, sizeof(a));
            if(i > 0)
                strncat(buf, " ", sizeof(buf) - strlen(a));
            strncat(buf, a, sizeof(buf) - strlen(a));
        }
        return setenv(name, buf, 1);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xf047
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0xf047
movb $0x0, -0x3d0(%rbp)
movl $0x0, -0x3d4(%rbp)
movl -0x3d4(%rbp), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0xf02d
cmpl $0x0, -0x1c(%rbp)
je 0xef6d
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x3d4(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rsi
addq $0xc, %rsi
leaq -0x410(%rbp), %rdx
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x2030
jmp 0xef98
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movslq -0x3d4(%rbp), %rax
imulq $0x1c, %rax, %rax
addq %rax, %rsi
leaq -0x410(%rbp), %rdx
movl $0xa, %edi
movl $0x2e, %ecx
callq 0x2030
cmpl $0x0, -0x3d4(%rbp)
jle 0xefd6
leaq -0x3d0(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x20d0
movq -0x418(%rbp), %rdi
movl $0x3ac, %edx            # imm = 0x3AC
subq %rax, %rdx
leaq 0x3dd7(%rip), %rsi      # 0x12da8
callq 0x2190
leaq -0x3d0(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x20d0
movq -0x428(%rbp), %rdi
movq -0x420(%rbp), %rsi
movl $0x3ac, %edx            # imm = 0x3AC
subq %rax, %rdx
callq 0x2190
movl -0x3d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3d4(%rbp)
jmp 0xef20
movq -0x10(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
movl $0x1, %edx
callq 0x20c0
movl %eax, -0x4(%rbp)
jmp 0xf04e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/trickle.c
// Function: trickle_init
void
trickle_init(struct trickle_state *s, int I_min, int I_max, int k)
{
    memset(s, 0, sizeof(*s));
    s->I_min = I_min;
    s->I_max = I_max;
    s->k = k;

    s->I = I_min + (random() % (I_max - I_min));
    trickle_new_interval(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2170
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2250
movl -0x10(%rbp), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
movq -0x20(%rbp), %rax
addq %rdx, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0xf0e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/trickle.c
// Function: trickle_new_interval
void
trickle_new_interval(struct trickle_state *s)
{
    s->c = 0;
    trickle_new_t(s);
    s->I_start = now;
    s->triggered = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0xf130
movq -0x8(%rbp), %rax
leaq 0x7175(%rip), %rcx      # 0x16280
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/trickle.c
// Function: trickle_trigger
int
trickle_trigger(struct trickle_state *s)
{
    if(!s->triggered) {
        struct timespec tt;
        ts_add_msec(&tt, &s->I_start, s->t);
        if(ts_compare(&now, &tt) >= 0) {
            s->triggered = 1;
            return s->c < s->k;
        }
    } else {
        struct timespec tI;
        ts_add_msec(&tI, &s->I_start, s->I);
        if(ts_compare(&now, &tI) >= 0) {
            s->I = min(2 * s->I, s->I_max);
            trickle_new_interval(s);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xf24b
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edx
leaq -0x20(%rbp), %rdi
callq 0xfac0
leaq 0x706b(%rip), %rdi      # 0x16280
leaq -0x20(%rbp), %rsi
callq 0xf900
cmpl $0x0, %eax
jl 0xf249
movq -0x10(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xf2a8
jmp 0xf2a1
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rdi
callq 0xfac0
leaq 0x7016(%rip), %rdi      # 0x16280
leaq -0x30(%rbp), %rsi
callq 0xf900
cmpl $0x0, %eax
jl 0xf29f
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
shll %edi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xf2c0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0xf0e0
jmp 0xf2a1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/trickle.c
// Function: trickle_reset
void
trickle_reset(struct trickle_state *s, int consistent)
{
    if(consistent) {
        s->c++;
    } else if(s->I > s->I_min) {
        s->I = s->I_min;
        trickle_new_interval(s);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xf314
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0xf33b
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xf339
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rdi
callq 0xf0e0
jmp 0xf33b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)