LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/kernel.c
// Function: kernel_address
int
kernel_address(int ifindex, const char *ifname,
               const struct in6_addr *address, int plen,
               int add)
{
    char b[INET6_ADDRSTRLEN];
    char c[INET6_ADDRSTRLEN + 80];
    int rc;

    if(memcmp(address, v4prefix, 12) == 0) {
        inet_ntop(AF_INET, (char*)address + 12, b, sizeof(b));
        plen -= 96;
    } else {
        inet_ntop(AF_INET6, address, b, sizeof(b));
    }

    rc = snprintf(c, sizeof(c), "ip addr %s %s/%d dev %s",
                  add ? "add" : "del", b, plen, ifname);
    if(rc < 1 || rc >= sizeof(c)) {
        errno = ENOSPC;
        return -1;
    }

    rc = system(c);
    if(rc >= 0 && WIFEXITED(rc) && WEXITSTATUS(rc) == 0)
        return 1;

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x40a8(%rip), %rsi      # 0x13420
movl $0xc, %edx
callq 0x21c0
cmpl $0x0, %eax
jne 0xf3ad
movq -0x18(%rbp), %rsi
addq $0xc, %rsi
leaq -0x50(%rbp), %rdx
movl $0x2, %edi
movl $0x2e, %ecx
callq 0x2030
movl -0x1c(%rbp), %eax
subl $0x60, %eax
movl %eax, -0x1c(%rbp)
jmp 0xf3c4
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0xa, %edi
movl $0x2e, %ecx
callq 0x2030
leaq -0xd0(%rbp), %rdi
movl -0x20(%rbp), %edx
leaq 0x4077(%rip), %rcx      # 0x1344c
leaq 0x406c(%rip), %rax      # 0x13448
cmpl $0x0, %edx
cmovneq %rax, %rcx
leaq -0x50(%rbp), %r8
movl -0x1c(%rbp), %r9d
movq -0x10(%rbp), %rax
movl $0x7e, %esi
leaq 0x4035(%rip), %rdx      # 0x13430
movq %rax, (%rsp)
movb $0x0, %al
callq 0x2140
movl %eax, -0xd4(%rbp)
cmpl $0x1, -0xd4(%rbp)
jl 0xf422
movslq -0xd4(%rbp), %rax
cmpq $0x7e, %rax
jb 0xf436
callq 0x2050
movl $0x1c, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf482
leaq -0xd0(%rbp), %rdi
callq 0x20f0
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jl 0xf47b
movl -0xd4(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xf47b
movl -0xd4(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x0, %eax
jne 0xf47b
movl $0x1, -0x4(%rbp)
jmp 0xf482
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/kernel.c
// Function: kernel_router
int
kernel_router()
{
    char buf[100];
    int fd, rc;
    int router;

    fd = open("/proc/sys/net/ipv6/conf/all/forwarding", O_RDONLY);
    if(fd < 0)
        return -1;

    rc = read(fd, buf, 99);
    if(rc < 0) {
        close(fd);
        return -1;
    }
    close(fd);

    buf[rc] = '\0';

    router = atoi(buf);

    if(!router)
        return 0;

    rc = system("ip -6 route show | grep -q '^default '");
    return WIFEXITED(rc) && WEXITSTATUS(rc) == 1 ? 1 : 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x3d31(%rip), %rdi      # 0x134c3
xorl %esi, %esi
movb $0x0, %al
callq 0x22f0
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jge 0xf7b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf850
movl -0x74(%rbp), %edi
leaq -0x70(%rbp), %rsi
movl $0x63, %edx
callq 0x21b0
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
jge 0xf7db
movl -0x74(%rbp), %edi
callq 0x21a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf850
movl -0x74(%rbp), %edi
callq 0x21a0
movslq -0x78(%rbp), %rax
movb $0x0, -0x70(%rbp,%rax)
leaq -0x70(%rbp), %rdi
callq 0x2330
movl %eax, -0x7c(%rbp)
cmpl $0x0, -0x7c(%rbp)
jne 0xf807
movl $0x0, -0x4(%rbp)
jmp 0xf850
leaq 0x3cdc(%rip), %rdi      # 0x134ea
callq 0x20f0
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %ecx
andl $0x7f, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x7d(%rbp)
jne 0xf83a
movl -0x78(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
cmpl $0x1, %eax
sete %al
movb %al, -0x7d(%rbp)
movb -0x7d(%rbp), %dl
movl $0x2, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: read_random_bytes
int
read_random_bytes(void *buf, int len)
{
    int fd, rc;

    fd = open("/dev/urandom", O_RDONLY);
    if(fd < 0) {
        errno = ENOSYS;
        return -1;
    }

    rc = read(fd, buf, len);
    if(rc < len)
        rc = -1;

    close(fd);

    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq 0x3c9b(%rip), %rdi      # 0x13511
xorl %esi, %esi
movb $0x0, %al
callq 0x22f0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xf89c
callq 0x2050
movl $0x26, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf8cc
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x21b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xf8be
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl -0x18(%rbp), %edi
callq 0x21a0
movl -0x1c(%rbp), %eax
movl %eax, -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/util.c
// Function: ts_compare
int
ts_compare(const struct timespec *s1, const struct timespec *s2)
{
    if(s1->tv_sec < s2->tv_sec)
        return -1;
    else if(s1->tv_sec > s2->tv_sec)
        return 1;
    else if(s1->tv_nsec < s2->tv_nsec)
        return -1;
    else if(s1->tv_nsec > s2->tv_nsec)
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0xf925
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf97b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jle 0xf93e
movl $0x1, -0x4(%rbp)
jmp 0xf97b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0xf959
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf97b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jle 0xf974
movl $0x1, -0x4(%rbp)
jmp 0xf97b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: ts_min
void
ts_min(struct timespec *d, const struct timespec *s)
{
    if(s->tv_sec == 0)
        return;

    if(d->tv_sec == 0 || ts_compare(d, s) > 0) {
        *d = *s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xf99c
jmp 0xf9ce
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf9b8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf900
cmpl $0x0, %eax
jle 0xf9ce
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: ts_minus
void
ts_minus(struct timespec *d,
         const struct timespec *s1, const struct timespec *s2)
{
    if(s1->tv_nsec >= s2->tv_nsec) {
        d->tv_nsec = s1->tv_nsec - s2->tv_nsec;
        d->tv_sec = s1->tv_sec - s2->tv_sec;
    } else {
        d->tv_nsec = s1->tv_nsec + 1000000000 - s2->tv_nsec;
        d->tv_sec = s1->tv_sec - s2->tv_sec - 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0xfa31
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
subq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfa69
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq -0x18(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
subq (%rax), %rcx
subq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: ts_add_nsec
static void
ts_add_nsec(struct timespec *d, const struct timespec *s, long long nsecs)
{
    *d = *s;

    while(nsecs + d->tv_nsec > 1000000000) {
        d->tv_sec += 1;
        nsecs -= 1000000000LL;
    }

    while(nsecs + d->tv_nsec < 0) {
        d->tv_sec -= 1;
        nsecs += 1000000000LL;
    }

    d->tv_nsec += nsecs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x8(%rcx), %rax
cmpq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
jle 0xfb58
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
subq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x18(%rbp)
jmp 0xfb26
jmp 0xfb5a
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq 0x8(%rcx), %rax
cmpq $0x0, %rax
jge 0xfb8a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x3b9aca00, %rax       # imm = 0x3B9ACA00
movq %rax, -0x18(%rbp)
jmp 0xfb5a
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: format_32
const char *
format_32(const unsigned char *data)
{
    static char buf[4][16];
    static int i = 0;
    i = (i + 1) % 4;
    snprintf(buf[i], 16, "%02x:%02x:%02x:%02x",
             data[0], data[1], data[2], data[3]);
    return buf[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xa89e(%rip), %eax      # 0x1a4f0
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, 0xa88d(%rip)      # 0x1a4f0
movslq 0xa886(%rip), %rax      # 0x1a4f0
leaq 0xa83f(%rip), %rdi      # 0x1a4b0
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %r8d
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %r9d
movq -0x8(%rbp), %rax
movzbl 0x3(%rax), %eax
movl $0x10, %esi
leaq 0x388d(%rip), %rdx      # 0x13532
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2140
movslq 0xa83a(%rip), %rcx      # 0x1a4f0
leaq 0xa7f3(%rip), %rax      # 0x1a4b0
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: format_64
const char *
format_64(const unsigned char *data)
{
    static char buf[4][28];
    static int i = 0;
    i = (i + 1) % 4;
    snprintf(buf[i], 28, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
             data[0], data[1], data[2], data[3],
             data[4], data[5], data[6], data[7]);
    return buf[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movl 0xa88b(%rip), %eax      # 0x1a570
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, 0xa87a(%rip)      # 0x1a570
movslq 0xa873(%rip), %rax      # 0x1a570
leaq 0xa7fc(%rip), %rdi      # 0x1a500
imulq $0x1c, %rax, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %r8d
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %r9d
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %r14d
movq -0x18(%rbp), %rax
movzbl 0x4(%rax), %ebx
movq -0x18(%rbp), %rax
movzbl 0x5(%rax), %r11d
movq -0x18(%rbp), %rax
movzbl 0x6(%rax), %r10d
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %eax
movl $0x1c, %esi
leaq 0x37c3(%rip), %rdx      # 0x1351e
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x2140
movslq 0xa7f1(%rip), %rcx      # 0x1a570
leaq 0xa77a(%rip), %rax      # 0x1a500
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: do_debugf
void
do_debugf(int level, const char *format, ...)
{
    va_list args;
    va_start(args, format);
    if(debug_level >= level) {
        vfprintf(stderr, format, args);
        fflush(stderr);
    }
    va_end(args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0xfdd8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x6442(%rip), %rax      # 0x16268
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jl 0xfe53
movq 0x61c4(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2320
movq 0x61ad(%rip), %rax      # 0x15ff8
movq (%rax), %rdi
callq 0x2270
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/util.c
// Function: allocate_buffer
void *
allocate_buffer(int size)
{
    void *p;
    p = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
             -1, 0);
    if(p == MAP_FAILED)
        return NULL;
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movslq -0xc(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x18(%rbp)
jne 0xfea7
movq $0x0, -0x8(%rbp)
jmp 0xfeaf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/md5.c
// Function: md5_init
void
md5_init(md5_state_t *pms)
{
    pms->count[0] = pms->count[1] = 0;
    pms->abcd[0] = 0x67452301;
    pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
    pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
    pms->abcd[3] = 0x10325476;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/md5.c
// Function: md5_append
void
md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
    const md5_byte_t *p = data;
    int left = nbytes;
    int offset = (pms->count[0] >> 3) & 63;
    md5_word_t nbits = (md5_word_t)(nbytes << 3);

    if (nbytes <= 0)
	return;

    /* Update the message length. */
    pms->count[1] += nbytes >> 29;
    pms->count[0] += nbits;
    if (pms->count[0] < nbits)
	pms->count[1]++;

    /* Process an initial partial block. */
    if (offset) {
	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

	memcpy(pms->buf + offset, p, copy);
	if (offset + copy < 64)
	    return;
	p += copy;
	left -= copy;
	md5_process(pms, pms->buf);
    }

    /* Process full blocks. */
    for (; left >= 64; p += 64, left -= 64)
	md5_process(pms, p);

    /* Process a final partial block. */
    if (left)
	memcpy(pms->buf, p, left);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0xff54
jmp 0x1004e
movl -0x14(%rbp), %ecx
sarl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jae 0xff87
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
cmpl $0x0, -0x28(%rbp)
je 0x10007
movl -0x28(%rbp), %eax
addl -0x14(%rbp), %eax
cmpl $0x40, %eax
jle 0xffa5
movl $0x40, %eax
subl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xffab
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movslq -0x30(%rbp), %rdx
callq 0x2230
movl -0x28(%rbp), %eax
addl -0x30(%rbp), %eax
cmpl $0x40, %eax
jge 0xffda
jmp 0x1004e
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x10060
jmp 0x10009
cmpl $0x40, -0x24(%rbp)
jl 0x10033
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10060
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
subl $0x40, %eax
movl %eax, -0x24(%rbp)
jmp 0x10009
cmpl $0x0, -0x24(%rbp)
je 0x1004e
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movq -0x20(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x2230
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jech[P]shncpd/md5.c
// Function: md5_finish
void
md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
    static const md5_byte_t pad[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    md5_byte_t data[8];
    int i;

    /* Save the length before padding. */
    for (i = 0; i < 8; ++i)
	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
    md5_append(pms, data, 8);
    for (i = 0; i < 16; ++i)
	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x10fad
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %cl
movslq -0x1c(%rbp), %rax
movb %cl, -0x18(%rbp,%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10f77
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
addl $0x1, %edx
leaq 0x2582(%rip), %rsi      # 0x13550
callq 0xff10
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0xff10
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x11026
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10fec
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sushant8421[P]create_your_own_shell/run_searchstring.c
// Function: main
int main(int argc , char *argv[]){	
	int x , stat_loc;
	pid_t ch ;
	struct dirent *de;  // Pointer for directory entry 
  
    // opendir() returns a pointer of DIR type.  
    DIR *dr = opendir(argv[3]); 
  
    if (dr == NULL)  // opendir returns NULL if couldn't open directory 
    { 
        printf("Could not open current directory\n" ); 
        return 0; 
    }
    
    while ((de = readdir(dr)) != NULL) {
     	char *args[] = {"./searchstring" , argv[1] ,  de->d_name, argv[2], NULL};
    	if((ch = fork()) < 0){
    		printf("child is not created\n") ;
    	}
    	else if(ch > 0){
    		waitpid(ch, &stat_loc, WUNTRACED);
    	}
    	else{
    		if(x=execv("./searchstring", args)<0)
    			printf("execution error");
		}
	}
    		
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11d8
leaq 0xe3f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x12a3
jmp 0x11da
movq -0x30(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x129c
leaq 0xe2e(%rip), %rax       # 0x2026
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x1080
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0x1245
leaq 0xdf9(%rip), %rdi       # 0x2035
movb $0x0, %al
callq 0x1040
jmp 0x1297
cmpl $0x0, -0x1c(%rbp)
jle 0x125e
movl -0x1c(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x1060
jmp 0x1295
leaq -0x60(%rbp), %rsi
leaq 0xdbd(%rip), %rdi       # 0x2026
callq 0x1070
cmpl $0x0, %eax
setl %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x14(%rbp)
testb $0x1, %al
jne 0x1285
jmp 0x1293
leaq 0xdbf(%rip), %rdi       # 0x204b
movb $0x0, %al
callq 0x1040
jmp 0x1295
jmp 0x1297
jmp 0x11da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/WereCatf[P]Gonzales/fast-gpio.c
// Function: initGpio
int initGpio()
{
	int fd = open("/dev/mem", O_RDWR|O_SYNC);
	if(fd < 0) return 1;
	// uint32_t addr = 0x01c20800 & ~(getpagesize() - 1);
	//Requires memmap to be on pagesize-boundary
	memmap=(uint8_t *)mmap(NULL, getpagesize()*2, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0x01c20000);
	if(memmap == NULL) return 1;
	close(fd);

	//Set memmap to point to PIO-registers
	memmap=memmap+0x800;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x165b(%rip), %rdi      # 0x4eba
movl $0x101002, %esi         # imm = 0x101002
movb $0x0, %al
callq 0x2080
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x387d
movl $0x1, -0x4(%rbp)
jmp 0x38e1
callq 0x20a0
shll %eax
movslq %eax, %rsi
movl -0x8(%rbp), %r8d
xorl %eax, %eax
movl %eax, %edi
movl $0x3, %edx
movl $0x1, %ecx
movl $0x1c20000, %r9d        # imm = 0x1C20000
callq 0x2040
movq %rax, 0x4215(%rip)      # 0x7ac0
cmpq $0x0, 0x420d(%rip)      # 0x7ac0
jne 0x38be
movl $0x1, -0x4(%rbp)
jmp 0x38e1
movl -0x8(%rbp), %edi
callq 0x2060
movq 0x41f3(%rip), %rax      # 0x7ac0
addq $0x800, %rax            # imm = 0x800
movq %rax, 0x41e6(%rip)      # 0x7ac0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WereCatf[P]Gonzales/fast-gpio.c
// Function: writeMux
void writeMux(int port, int pin, uint8_t mux)
{
	volatile uint32_t *pioMem32, *configRegister;
	uint32_t mask;

	pioMem32=(uint32_t *)(memmap+port*0x24);
	mux &= 7;
	configRegister=pioMem32+(pin >> 3);
	mask = ~(7 << ((pin & 7) * 4));
	*configRegister &= mask;
	*configRegister |= mux << ((pin & 7) * 4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x416a(%rip), %rax      # 0x7ac0
imull $0x24, -0x4(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x7, %eax
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %ecx
andl $0x7, %ecx
shll $0x2, %ecx
movl $0x7, %eax
shll %cl, %eax
xorl $-0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl %edx, %ecx
movl %ecx, (%rax)
movzbl -0x9(%rbp), %edx
movl -0x8(%rbp), %ecx
andl $0x7, %ecx
shll $0x2, %ecx
shll %cl, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WereCatf[P]Gonzales/fast-gpio.c
// Function: writePull
void writePull(int port, int pin, uint8_t value)
{
	value &= 3;
	volatile uint32_t *pioMem32, *configRegister;
	uint32_t mask;
	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
	configRegister=pioMem32+(pin >> 4);
	mask = ~(3 << ((pin & 15) * 2));
	*configRegister &= mask;
	*configRegister |= value << ((pin & 15) * 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x3, %eax
movb %al, -0x9(%rbp)
movq 0x4080(%rip), %rax      # 0x7ac0
imull $0x24, -0x4(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x1c, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0x8(%rbp), %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
movl $0x3, %eax
shll %cl, %eax
xorl $-0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl %edx, %ecx
movl %ecx, (%rax)
movzbl -0x9(%rbp), %edx
movl -0x8(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shll %cl, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/WereCatf[P]Gonzales/./include/fast-gpio.h
// Function: writePin
inline void writePin(int port, int pin, uint8_t value)
{
	value &= 1;
	volatile uint32_t *pioMem32;
	uint32_t mask;
	pioMem32=(uint32_t *)(memmap+portOffsetData[port]);
	mask = ~(1 << pin);
	*pioMem32 &= mask;
	if(value) *pioMem32 |= value << pin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x1, %eax
movb %al, -0x9(%rbp)
movq 0x3e70(%rip), %rax      # 0x7ac0
movslq -0x4(%rbp), %rdx
leaq 0x3e53(%rip), %rcx      # 0x7aae
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
xorl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
andl %edx, %ecx
movl %ecx, (%rax)
cmpb $0x0, -0x9(%rbp)
je 0x3c9f
movzbl -0x9(%rbp), %edx
movl -0x8(%rbp), %ecx
shll %cl, %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
orl %edx, %ecx
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_OverwriteWithZeroes
void KeccakP1600_OverwriteWithZeroes(void *state, size_t byteCount)
//*********************************************************
{
    keccak_state_t  &s = *(keccak_state_t *)state;
    UINT64      t[25];

    KeccakP1600_ExtractBytes(state, (UINT8 *)t, 0, sizeof(t));
    memset(t, 0, byteCount);

    s.a0 = LOAD(t + 0*5);
    s.a1 = LOAD(t + 1*5);
    s.a2 = LOAD(t + 2*5);
    s.a3 = LOAD(t + 3*5);
    s.a4 = LOAD(t + 4*5);
    s.c4 = SET(t[0*5 + 4], t[1*5 + 4], t[2*5 + 4], t[3*5 + 4]);
    s.a44 = _mm256_set1_epi64x(t[4*5 + 4]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xe8(%rsp), %rdi
xorl %eax, %eax
movl %eax, 0x4(%rsp)
movl %eax, %edx
leaq 0x10(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movl $0xc8, %ecx
callq 0x5060
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdi
movq 0xe0(%rsp), %rdx
callq 0x5050
movq 0x8(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
vmovdqu (%rax), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, (%rax)
leaq 0x38(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rax
vmovdqu (%rax), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0x20(%rax)
leaq 0x60(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
vmovdqu (%rax), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0x40(%rax)
leaq 0x88(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rax
vmovdqu (%rax), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0x60(%rax)
leaq 0xb0(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rax
vmovdqu (%rax), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0x80(%rax)
movq 0x30(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0xa8(%rsp), %rax
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq %rcx, 0xf8(%rsp)
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x100(%rsp), %rcx
movq 0x108(%rsp), %rax
movq %rsi, 0x1c8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1b8(%rsp)
movq %rax, 0x1b0(%rsp)
vmovq 0x1b8(%rsp), %xmm1
vmovq 0x1b0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovq 0x1c8(%rsp), %xmm2
vmovq 0x1c0(%rsp), %xmm1
vpunpcklqdq %xmm2, %xmm1, %xmm1 # xmm1 = xmm1[0],xmm2[0]
vmovdqa %xmm1, 0x190(%rsp)
vmovdqa %xmm0, 0x180(%rsp)
vmovdqa 0x180(%rsp), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0xa0(%rax)
movq 0xd0(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x178(%rsp)
movq %rax, 0x170(%rsp)
movq %rax, 0x168(%rsp)
movq %rax, 0x160(%rsp)
vmovq 0x178(%rsp), %xmm1
vmovq 0x170(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[0]
vmovq 0x168(%rsp), %xmm2
vmovq 0x160(%rsp), %xmm0
vpunpcklqdq %xmm2, %xmm0, %xmm2 # xmm2 = xmm0[0],xmm2[0]
vmovaps %xmm2, %xmm0
vinserti128 $0x1, %xmm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x140(%rsp)
vmovdqa 0x140(%rsp), %ymm0
movq 0xd8(%rsp), %rax
vmovdqa %ymm0, 0xc0(%rax)
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const UINT8 *input, UINT8 *output, size_t offset, size_t length)
//***************************************************************************************
{
    UINT64      t[25];
    UINT64      *t0;
    const UINT64 *dIn = (UINT64 *)input;
    UINT64      *dOut = (UINT64 *)output;
    UINT8       *t1, *dlIn, *dlOut;
    ptrdiff_t   lane_n = length / sizeof(UINT64);
    ptrdiff_t   byte_n = length % sizeof(UINT64);
    ptrdiff_t   i;

    KeccakP1600_ExtractBytes(state, (UINT8 *)t, 0, sizeof(t));

    t0 = (UINT64 *)((UINT8 *)t + offset);

    for (i = 0; i < lane_n; i++)
        dOut[i] = dIn[i] ^ t0[i];

    if (byte_n)
    {
        t1 = (UINT8 *)(t0 + i);
        dlIn = (UINT8 *)(dIn + i);
        dlOut = (UINT8 *)(dOut + i);

        for (i = 0; i < byte_n; i++)
            dlOut[i] = dlIn[i] ^ t1[i];
    }
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq %r8, 0x120(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x120(%rsp), %rax
shrq $0x3, %rax
movq %rax, 0x18(%rsp)
movq 0x120(%rsp), %rax
andq $0x7, %rax
movq %rax, 0x10(%rsp)
movq 0x140(%rsp), %rdi
leaq 0x50(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xc8, %ecx
callq 0x5060
leaq 0x50(%rsp), %rax
addq 0x128(%rsp), %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x73f7
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
xorq (%rax,%rcx,8), %rdx
movq 0x38(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x73b1
cmpq $0x0, 0x10(%rsp)
je 0x7499
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jge 0x7497
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x744e
jmp 0x7499
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strisdigit
int strisdigit(char* str)
{
    char*   p   = str;

    while (*p != '\0') {
        if (!isdigit(*p))
            return -1;
        p++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1257
callq 0x1120
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1249
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x125e
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1214
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: mbstrlen
int mbstrlen(char* src)
{
    int         ch      = 0,
                len     = 0;

    char*       p       = src;

    gunichar*   cpoints;

    setlocale(LC_CTYPE, LOCALE);
    while (*p != '\0') {
        /* get string length */
        if ((ch = mblen(p, MB_CUR_MAX)) < 0)
            return 0;

        if (ch > 1) {
            /* get unicode code point */
            cpoints = g_utf8_to_ucs4_fast(p, sizeof(*p), NULL);

            /*
             * multi byte
             * true : hankaku kana
             * false: other
             */
            if (*cpoints >= 0xff65 && *cpoints <= 0xff9f) {
                len++;
            } else {
                len += 2;
            }
            g_free(cpoints);
        } else {
            /* ascii */
            len++;
        }
        p += ch;
    }

    return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %edi, %edi
leaq 0x17a5(%rip), %rsi      # 0x3000
callq 0x10d0
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x190c
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x1060
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x189a
movl $0x0, -0x4(%rbp)
jmp 0x1912
cmpl $0x1, -0x14(%rbp)
jle 0x18ed
movq -0x20(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x10f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0xff65, (%rax)         # imm = 0xFF65
jb 0x18d9
movq -0x28(%rbp), %rax
cmpl $0xff9f, (%rax)         # imm = 0xFF9F
ja 0x18d9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18e2
movl -0x18(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1050
jmp 0x18f6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x1860
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strunesc
int strunesc(char* src)
{
    int     count   = 0;

    char*   p       = src;

    while (*p != '\0') {
        if (*p == '\t' || *p == '\b') {
            *p = ' ';
            count++;
        }
        p++;
    }

    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1979
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
je 0x195b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x8, %eax
jne 0x196b
movq -0x18(%rbp), %rax
movb $0x20, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1937
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strmax
int strmax(int val, char** src)
{
    int     i       = 0,
            j       = 0,
            len     = 0,
            max     = 0;

    j = val - 1;
    while (i <= j) {
        if ((len = mbstrlen(*(src + i))) > max)
            max = len;
        if ((len = mbstrlen(*(src + j))) > max)
            max = len;
        i++;
        j--;
    }

    return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1a0e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl -0x20(%rbp), %eax
jle 0x19db
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl -0x20(%rbp), %eax
jle 0x19fa
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x19b4
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strlftonull
int strlftonull(char* str)
{
    int     ret     = 0;

    char*   p       = str;

    while (*p != '\0') {
        if (*p == '\n') {
            *p = '\0';
            ret++;
        }
        p++;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a6d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1a5f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1a37
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: mbstrtok
char* mbstrtok(char* str, char* delimiter)
{
    static  char*   ptr = NULL;
            char*   bdy = NULL;

    if (!str)
        str = ptr;

    if (!str)
        return NULL;

    if ((bdy = strstr(str, delimiter)) != NULL) {
        *bdy = '\0';
        ptr = bdy + strlen(delimiter);
    } else {
        ptr = NULL;
    }

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e6a
movq 0x3242(%rip), %rax      # 0x50a8
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1e7b
movq $0x0, -0x8(%rbp)
jmp 0x1ed0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1ebd
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, 0x31ed(%rip)      # 0x50a8
jmp 0x1ec8
movq $0x0, 0x31e0(%rip) # 0x50a8
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: trim
int trim(char* str)
{
    int     i       = 0,
            j       = 0;

    i = strlen(str) - 1;
    while (i >= 0 && isspace(*(str + i))) {
        i--;
    }
    *(str + i + 1) = '\0';
    i = 0;
    while (isspace(*(str + i)))
        i++;

    if (i > 0) {
        j = 0;
        while (*(str + i))
            *(str + j++) = *(str + i++);
        *(str + j) = '\0';
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
subq $0x1, %rax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0x1f3e
callq 0x1120
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1f47
jmp 0x1f52
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f0a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, 0x1(%rax,%rcx)
movl $0x0, -0xc(%rbp)
callq 0x1120
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x1f96
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f66
cmpl $0x0, -0xc(%rbp)
jle 0x1fe9
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x1fdd
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1fa3
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strcmp_lite
int strcmp_lite(const char* str1, const char* str2)
{
    if (str1 == NULL || str2 == NULL)
        return -1;

    size_t  cnt     = 0,
            len1    = 0,
            len2    = 0;

    len1 = strlen(str1);
    len2 = strlen(str2);

    while (*str1 == *str2 && *str1 != '\0' && *str2 != '\0') {
        str1++;
        str2++;
        cnt++;
    }
    if (cnt == len1 && cnt == len2)
        return 0;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x201e
cmpq $0x0, -0x18(%rbp)
jne 0x202a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20e7
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1070
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movq -0x18(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x31(%rbp)
jne 0x2094
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x2094
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x209d
jmp 0x20c3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x205c
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x20e0
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x20e0
movl $0x0, -0x4(%rbp)
jmp 0x20e7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strmax_with_regex
int strmax_with_regex(int val, char** src, regex_t* reg)
{
    int     i       = 0,
            j       = 0,
            len     = 0,
            max     = 0;

    j = val - 1;
    while (i <= j) {
        if ((len = mbstrlen_with_regex(*(src + i), reg)) > max)
            max = len;
        if ((len = mbstrlen_with_regex(*(src + j), reg)) > max)
            max = len;
        i++;
        j--;
    }

    return max;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0x22ca
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movl %eax, -0x24(%rbp)
cmpl -0x28(%rbp), %eax
jle 0x2293
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movl %eax, -0x24(%rbp)
cmpl -0x28(%rbp), %eax
jle 0x22b6
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2268
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/perftests/http/main.c
// Function: main
int
main(int argc, char * argv[])
{
	struct http_header HH[1];
	struct http_request R;
	char * s;
	struct sock_addr ** sas;
	int done = 0;

	WARNP_INIT;

	/* Sanity-check. */
	if (argc != 3) {
		warn0("Need two arguments (host, path)");
		goto err0;
	}

	/* Construct headers. */
	HH[0].header = "Host";
	HH[0].value = argv[1];

	/* Construct request. */
	R.method = "GET";
	R.path = argv[2];
	R.nheaders = 1;
	R.headers = HH;
	R.bodylen = 0;
	R.body = NULL;

	/* Resolve target addresses. */
	if (asprintf(&s, "%s:80", argv[1]) == -1)
		goto err0;
	if ((sas = sock_resolve(s)) == NULL) {
		warnp("Cannot resolve %s", s);
		goto err1;
	}
	free(s);
	s = NULL;

	/* Send request. */
	(void)http_request(sas, &R, 1000000, donereq, &done);

	/* Wait for request to complete. */
	if (events_spin(&done)) {
		warnp("Error in event loop");
		goto err2;
	}

	/* Free address structures. */
	sock_addr_freelist(sas);

	/* Success! */
	exit(0);

err2:
	sock_addr_freelist(sas);
err1:
	free(s);
err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24e3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xa3c0
jmp 0x24e5
cmpl $0x3, -0x8(%rbp)
je 0x250b
jmp 0x24ed
leaq 0x9b10(%rip), %rdi      # 0xc004
movb $0x0, %al
callq 0xa6d0
callq 0x20a0
movl $0x0, (%rax)
jmp 0x266b
leaq 0x9b12(%rip), %rax      # 0xc024
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x9b00(%rip), %rax      # 0xc029
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x1, -0x40(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq -0x58(%rbp), %rdi
leaq 0x9ac1(%rip), %rsi      # 0xc02d
movb $0x0, %al
callq 0x83b0
cmpl $-0x1, %eax
jne 0x257d
jmp 0x266b
movq -0x58(%rbp), %rdi
callq 0x8810
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x25d4
jmp 0x2592
callq 0x20a0
cmpl $0x0, (%rax)
je 0x25bb
movq -0x58(%rbp), %rsi
leaq 0x9a8c(%rip), %rdi      # 0xc033
movb $0x0, %al
callq 0xa480
callq 0x20a0
movl $0x0, (%rax)
jmp 0x25cd
movq -0x58(%rbp), %rsi
leaq 0x9a6d(%rip), %rdi      # 0xc033
movb $0x0, %al
callq 0xa6d0
jmp 0x25cf
jmp 0x2662
movq -0x58(%rbp), %rdi
callq 0x2040
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0xf4240, %edx          # imm = 0xF4240
leaq 0x87(%rip), %rcx        # 0x2680
leaq -0x64(%rbp), %r8
callq 0x4620
leaq -0x64(%rbp), %rdi
callq 0x2a40
cmpl $0x0, %eax
je 0x2649
jmp 0x2612
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2637
leaq 0x9a22(%rip), %rdi      # 0xc045
movb $0x0, %al
callq 0xa480
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2645
leaq 0x9a07(%rip), %rdi      # 0xc045
movb $0x0, %al
callq 0xa6d0
jmp 0x2647
jmp 0x2659
movq -0x60(%rbp), %rdi
callq 0x9440
xorl %edi, %edi
callq 0x2320
movq -0x60(%rbp), %rdi
callq 0x9440
movq -0x58(%rbp), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x2320
nopw %cs:(%rax,%rax)