LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack13x7c16e5
static inline bool unpack13x7c16e5(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    *e    = (x & Mask(5));
    v[0]  = (x >> 5);
    x = base64dec3(s + 3);
    if (x < 0) return false;
    v[1]  = (x & Mask(13));
    v[2]  = (x >> 13);
    x = base64dec2(s + 6) | base64dec3(s + 8) << 12;
    if (x < 0) return false;
    v[2] |= (uint8_t) x << 5;
    v[3]  = (x & Mask(21)) >> 8;
    v[4]  = (x >> 21);
    x = base64dec2(s + 11) | base64dec3(s + 13) << 12;
    if (x < 0) return false;
    v[4] |= (x & Mask(4)) << 9;
    v[5]  = (x & Mask(17)) >> 4;
    v[6]  = (x >> 17);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x2cda
movl %eax, %ecx
andl $0x1f, %ecx
movl %ecx, (%r15)
shrl $0x5, %eax
movl %eax, (%rbx)
leaq 0x3(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x2cda
movl %eax, %r15d
andl $0x1fff, %eax           # imm = 0x1FFF
movl %eax, 0x4(%rbx)
shrl $0xd, %r15d
movl %r15d, 0x8(%rbx)
movzbl 0x6(%r14), %eax
movzbl 0x7(%r14), %ecx
leaq 0x6410(%rip), %r12      # 0x9050
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r13d
orl %eax, %r13d
leaq 0x8(%r14), %rdi
callq 0x89a5
movl %eax, %ebp
shll $0xc, %ebp
orl %r13d, %ebp
js 0x2cda
movzbl %r13b, %eax
shll $0x5, %eax
orl %r15d, %eax
movl %eax, 0x8(%rbx)
movl %ebp, %eax
shrl $0x8, %eax
andl $0x1fff, %eax           # imm = 0x1FFF
movl %eax, 0xc(%rbx)
shrl $0x15, %ebp
movl %ebp, 0x10(%rbx)
movzbl 0xb(%r14), %eax
movzbl 0xc(%r14), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r15d
orl %eax, %r15d
addq $0xd, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r15d, %eax
js 0x2cda
andl $0xf, %r15d
shll $0x9, %r15d
orl %ebp, %r15d
movl %r15d, 0x10(%rbx)
movl %eax, %ecx
shrl $0x4, %ecx
andl $0x1fff, %ecx           # imm = 0x1FFF
movl %ecx, 0x14(%rbx)
shrl $0x11, %eax
movl %eax, 0x18(%rbx)
movb $0x1, %al
jmp 0x2cdc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack13x6c13o1
static inline bool unpack13x6c13o1(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec3(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(13));
    v[1]  = (x >> 13) & Mask(13);
    v[2]  = (x >> 26);
    x = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (x < 0) return false;
    v[2] |= (x & Mask(9)) << 4;
    v[3]  = (x >> 9) & Mask(13);
    v[4]  = (x >> 22);
    x = base64dec3(s + 10);
    if (x < 0) return false;
    v[4] |= (x & Mask(5)) << 8;
    v[5]  = (x >> 5) & Mask(13);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x632c(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r12d
orl %eax, %r12d
addq $0x2, %rdi
callq 0x89a5
movl %eax, %ebp
shll $0xc, %ebp
orl %r12d, %ebp
js 0x2dec
movl $0x1fff, %eax           # imm = 0x1FFF
movl %ebp, %ecx
andl %eax, %ecx
movl %ecx, (%rbx)
movl %ebp, %ecx
shrl $0xd, %ecx
andl %eax, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x1a, %ebp
movl %ebp, 0x8(%rbx)
movzbl 0x5(%r14), %eax
movzbl 0x6(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r12d
orl %eax, %r12d
leaq 0x7(%r14), %rdi
callq 0x89a5
movl %eax, %r15d
shll $0xc, %r15d
orl %r12d, %r15d
js 0x2dec
shll $0x4, %r12d
andl $0x1ff0, %r12d          # imm = 0x1FF0
orl %ebp, %r12d
movl %r12d, 0x8(%rbx)
movl %r15d, %eax
shrl $0x9, %eax
andl $0x1fff, %eax           # imm = 0x1FFF
movl %eax, 0xc(%rbx)
shrl $0x16, %r15d
movl %r15d, 0x10(%rbx)
addq $0xa, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x2dec
movl %eax, %ecx
andl $0x1f, %ecx
shll $0x8, %ecx
orl %r15d, %ecx
movl %ecx, 0x10(%rbx)
shrl $0x5, %eax
andl $0x1fff, %eax           # imm = 0x1FFF
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x2dee
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack14x6c14
static inline bool unpack14x6c14(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec2(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(14));
    v[1]  = (x >> 14);
    x = base64dec3(s + 4);
    if (x < 0) return false;
    v[1] |= (x & Mask(4)) << 10;
    v[2]  = (x >> 4);
    x = base64dec2(s + 7) | base64dec2(s + 9) << 12;
    if (x < 0) return false;
    v[3]  = (x & Mask(14));
    v[4]  = (x >> 14);
    x = base64dec3(s + 11);
    if (x < 0) return false;
    v[4] |= (x & Mask(4)) << 10;
    v[5]  = (x >> 4);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x6227(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
movzbl 0x3(%rdi), %edx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rdx,2), %ebp
orl %eax, %ebp
shll $0xc, %ebp
orl %ecx, %ebp
js 0x2f07
movq %rsi, %rbx
movq %rdi, %r14
movl %ebp, %eax
andl $0x3fff, %eax           # imm = 0x3FFF
movl %eax, (%rsi)
shrl $0xe, %ebp
movl %ebp, 0x4(%rsi)
addq $0x4, %rdi
callq 0x89a5
testl %eax, %eax
js 0x2f07
movl %eax, %ecx
andl $0xf, %ecx
shll $0xa, %ecx
orl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x4, %eax
movl %eax, 0x8(%rbx)
movzbl 0x7(%r14), %eax
movzbl 0x8(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ecx
orl %eax, %ecx
movzbl 0x9(%r14), %eax
movzbl 0xa(%r14), %edx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rdx,2), %ebp
orl %eax, %ebp
shll $0xc, %ebp
orl %ecx, %ebp
js 0x2f07
movl %ebp, %eax
andl $0x3fff, %eax           # imm = 0x3FFF
movl %eax, 0xc(%rbx)
shrl $0xe, %ebp
movl %ebp, 0x10(%rbx)
addq $0xb, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x2f07
movl %eax, %ecx
andl $0xf, %ecx
shll $0xa, %ecx
orl %ebp, %ecx
movl %ecx, 0x10(%rbx)
shrl $0x4, %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x2f09
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack15x6c15
static inline bool unpack15x6c15(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec3(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(15));
    v[1]  = (x >> 15);
    x = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (x < 0) return false;
    v[2]  = (x & Mask(15));
    v[3]  = (x >> 15);
    x = base64dec2(s + 10) | base64dec3(s + 12) << 12;
    if (x < 0) return false;
    v[4]  = (x & Mask(15));
    v[5]  = (x >> 15);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x6104(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
addq $0x2, %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x2ffd
movl %eax, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl %ecx, (%rbx)
shrl $0xf, %eax
movl %eax, 0x4(%rbx)
movzbl 0x5(%r14), %eax
movzbl 0x6(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
leaq 0x7(%r14), %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x2ffd
movl %eax, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl %ecx, 0x8(%rbx)
shrl $0xf, %eax
movl %eax, 0xc(%rbx)
movzbl 0xa(%r14), %eax
movzbl 0xb(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x2ffd
movl %eax, %ecx
andl $0x7fff, %ecx           # imm = 0x7FFF
movl %ecx, 0x10(%rbx)
shrl $0xf, %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x2fff
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack17x5c15e5
static inline bool unpack17x5c15e5(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x, y;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[1]  = (x & Mask(10));
    *e    = (x >> 13);
    y = base64dec2(s + 3) | base64dec2(s + 5) << 12;
    if (y < 0) return false;
    v[0]  = (y >> 7);
    v[1] |= (y & Mask(7)) << 10;
    y = base64dec2(s + 7) | base64dec2(s + 9) << 12;
    if (y < 0) return false;
    v[2]  = (y & Mask(17));
    v[3]  = (y >> 17);
    y = base64dec2(s + 11) | base64dec2(s + 13) << 12;
    if (y < 0) return false;
    v[3] |= (y & Mask(10)) << 7;
    v[4]  = (y >> 10);
    v[4] |= (x & Mask(3)<<10) << 4;
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x329f
movl %eax, %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movl %ecx, 0x4(%rbx)
movl %eax, %ecx
shrl $0xd, %ecx
movl %ecx, (%r15)
movzbl 0x3(%r14), %edx
movzbl 0x4(%r14), %esi
leaq 0x5e98(%rip), %rcx      # 0x9050
movsbl (%rdx,%rcx), %edi
movswl 0x100(%rcx,%rsi,2), %edx
orl %edi, %edx
movzbl 0x5(%r14), %esi
movzbl 0x6(%r14), %edi
movsbl (%rsi,%rcx), %r8d
movswl 0x100(%rcx,%rdi,2), %esi
orl %r8d, %esi
shll $0xc, %esi
orl %edx, %esi
js 0x329f
shrl $0x7, %esi
movl %esi, (%rbx)
andl $0x7f, %edx
shll $0xa, %edx
orl %edx, 0x4(%rbx)
movzbl 0x7(%r14), %edx
movzbl 0x8(%r14), %esi
movsbl (%rdx,%rcx), %edx
movswl 0x100(%rcx,%rsi,2), %esi
orl %edx, %esi
movzbl 0x9(%r14), %edx
movzbl 0xa(%r14), %edi
movsbl (%rdx,%rcx), %r8d
movswl 0x100(%rcx,%rdi,2), %edx
orl %r8d, %edx
shll $0xc, %edx
orl %esi, %edx
js 0x329f
movl %edx, %esi
andl $0x1ffff, %esi          # imm = 0x1FFFF
movl %esi, 0x8(%rbx)
shrl $0x11, %edx
movl %edx, 0xc(%rbx)
movzbl 0xb(%r14), %esi
movzbl 0xc(%r14), %edi
movsbl (%rsi,%rcx), %r8d
movswl 0x100(%rcx,%rdi,2), %esi
orl %r8d, %esi
movzbl 0xd(%r14), %edi
movzbl 0xe(%r14), %r8d
movsbl (%rdi,%rcx), %edi
movswl 0x100(%rcx,%r8,2), %ecx
orl %edi, %ecx
shll $0xc, %ecx
orl %esi, %ecx
js 0x329f
shll $0x7, %esi
andl $0x1ff80, %esi          # imm = 0x1FF80
orl %edx, %esi
movl %esi, 0xc(%rbx)
shrl $0xa, %ecx
shll $0x4, %eax
andl $0x1c000, %eax          # imm = 0x1C000
orl %ecx, %eax
movl %eax, 0x10(%rbx)
movb $0x1, %al
jmp 0x32a1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack17x6c17
static inline bool unpack17x6c17(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec2(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(17));
    v[1]  = (x >> 17);
    x = base64dec2(s + 4) | base64dec2(s + 6) << 12;
    if (x < 0) return false;
    v[1] |= (x & Mask(10)) << 7;
    v[2]  = (x >> 10);
    x = base64dec3(s + 8);
    if (x < 0) return false;
    v[2] |= (x & Mask(3)) << 14;
    v[3]  = (x >> 3);
    x = base64dec3(s + 11);
    if (x < 0) return false;
    v[3] |= (x & Mask(2)) << 15;
    v[4]  = (x >> 2);
    x = base64dec3(s + 14);
    if (x < 0) return false;
    v[4] |= (x & Mask(1)) << 16;
    v[5]  = (x >> 1);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %edx
leaq 0x5d71(%rip), %rcx      # 0x9050
movsbl (%rax,%rcx), %eax
movswl 0x100(%rcx,%rdx,2), %edx
orl %eax, %edx
movzbl 0x2(%rdi), %eax
movzbl 0x3(%rdi), %esi
movsbl (%rax,%rcx), %edi
movswl 0x100(%rcx,%rsi,2), %eax
orl %edi, %eax
shll $0xc, %eax
orl %edx, %eax
js 0x33d3
movl %eax, %edx
andl $0x1ffff, %edx          # imm = 0x1FFFF
movl %edx, (%rbx)
shrl $0x11, %eax
movl %eax, 0x4(%rbx)
movzbl 0x4(%r14), %edx
movzbl 0x5(%r14), %esi
movsbl (%rdx,%rcx), %edi
movswl 0x100(%rcx,%rsi,2), %edx
orl %edi, %edx
movzbl 0x6(%r14), %esi
movzbl 0x7(%r14), %edi
movsbl (%rsi,%rcx), %esi
movswl 0x100(%rcx,%rdi,2), %ebp
orl %esi, %ebp
shll $0xc, %ebp
orl %edx, %ebp
js 0x33d3
shll $0x7, %edx
andl $0x1ff80, %edx          # imm = 0x1FF80
orl %eax, %edx
movl %edx, 0x4(%rbx)
shrl $0xa, %ebp
movl %ebp, 0x8(%rbx)
leaq 0x8(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x33d3
movl %eax, %r15d
andl $0x7, %eax
shll $0xe, %eax
orl %ebp, %eax
movl %eax, 0x8(%rbx)
shrl $0x3, %r15d
movl %r15d, 0xc(%rbx)
leaq 0xb(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x33d3
movl %eax, %ebp
andl $0x3, %eax
shll $0xf, %eax
orl %r15d, %eax
movl %eax, 0xc(%rbx)
shrl $0x2, %ebp
movl %ebp, 0x10(%rbx)
addq $0xe, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x33d3
movl %eax, %ecx
andl $0x1, %ecx
shll $0x10, %ecx
orl %ebp, %ecx
movl %ecx, 0x10(%rbx)
shrl %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x33d5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack18x5c15
static inline bool unpack18x5c15(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[0] = x;
    x = base64dec3(s + 3);
    if (x < 0) return false;
    v[1] = x;
    x = base64dec3(s + 6);
    if (x < 0) return false;
    v[2] = x;
    x = base64dec3(s + 9);
    if (x < 0) return false;
    v[3] = x;
    x = base64dec3(s + 12);
    if (x < 0) return false;
    v[4] = x;
    return (void) e, true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x3459
movl %eax, (%rbx)
leaq 0x3(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x3459
movl %eax, 0x4(%rbx)
leaq 0x6(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x3459
movl %eax, 0x8(%rbx)
leaq 0x9(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x3459
movl %eax, 0xc(%rbx)
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x3459
movl %eax, 0x10(%rbx)
movb $0x1, %al
jmp 0x345b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack19x4c13e2o1
static inline bool unpack19x4c13e2o1(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    *e    = (x & Mask(2));
    v[0]  = (x >> 2);
    x = base64dec3(s + 3);
    if (x < 0) return false;
    v[0] |= (x & Mask(3)) << 16;
    v[1]  = (x >> 3);
    x = base64dec3(s + 6);
    if (x < 0) return false;
    v[1] |= (x & Mask(4)) << 15;
    v[2]  = (x >> 4);
    x = base64dec2(s + 9) | base64dec2(s + 11) << 12;
    if (x < 0) return false;
    v[2] |= (x & Mask(5)) << 14;
    v[3]  = (x >> 5);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x3548
movl %eax, %r15d
andl $0x3, %eax
movl %eax, (%r12)
shrl $0x2, %r15d
movl %r15d, (%rbx)
leaq 0x3(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x3548
movl %eax, %ebp
andl $0x7, %eax
shll $0x10, %eax
orl %r15d, %eax
movl %eax, (%rbx)
shrl $0x3, %ebp
movl %ebp, 0x4(%rbx)
leaq 0x6(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x3548
movl %eax, %ecx
andl $0xf, %ecx
shll $0xf, %ecx
orl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x4, %eax
movl %eax, 0x8(%rbx)
movzbl 0x9(%r14), %ecx
movzbl 0xa(%r14), %edx
leaq 0x5b4c(%rip), %rsi      # 0x9050
movsbl (%rcx,%rsi), %edi
movswl 0x100(%rsi,%rdx,2), %ecx
orl %edi, %ecx
movzbl 0xb(%r14), %edx
movzbl 0xc(%r14), %edi
movsbl (%rdx,%rsi), %r8d
movswl 0x100(%rsi,%rdi,2), %edx
orl %r8d, %edx
shll $0xc, %edx
orl %ecx, %edx
js 0x3548
andl $0x1f, %ecx
shll $0xe, %ecx
orl %eax, %ecx
movl %ecx, 0x8(%rbx)
shrl $0x5, %edx
movl %edx, 0xc(%rbx)
movb $0x1, %al
jmp 0x354a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack19x5c16e1
static inline bool unpack19x5c16e1(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    *e    = (x & Mask(1));
    v[0]  = (x >> 1);
    x = base64dec3(s + 3);
    if (x < 0) return false;
    v[0] |= (x & Mask(2)) << 17;
    v[1]  = (x >> 2);
    x = base64dec3(s + 6);
    if (x < 0) return false;
    v[1] |= (x & Mask(3)) << 16;
    v[2]  = (x >> 3);
    x = base64dec3(s + 9);
    if (x < 0) return false;
    v[2] |= (x & Mask(4)) << 15;
    v[3]  = (x >> 4);
    x = base64dec2(s + 12) | base64dec2(s + 14) << 12;
    if (x < 0) return false;
    v[3] |= (x & Mask(5)) << 14;
    v[4]  = (x >> 5);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x365f
movl %eax, %r15d
andl $0x1, %eax
movl %eax, (%r12)
shrl %r15d
movl %r15d, (%rbx)
leaq 0x3(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x365f
movl %eax, %ebp
andl $0x3, %eax
shll $0x11, %eax
orl %r15d, %eax
movl %eax, (%rbx)
shrl $0x2, %ebp
movl %ebp, 0x4(%rbx)
leaq 0x6(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x365f
movl %eax, %r15d
andl $0x7, %eax
shll $0x10, %eax
orl %ebp, %eax
movl %eax, 0x4(%rbx)
shrl $0x3, %r15d
movl %r15d, 0x8(%rbx)
leaq 0x9(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x365f
movl %eax, %ecx
andl $0xf, %ecx
shll $0xf, %ecx
orl %r15d, %ecx
movl %ecx, 0x8(%rbx)
shrl $0x4, %eax
movl %eax, 0xc(%rbx)
movzbl 0xc(%r14), %ecx
movzbl 0xd(%r14), %edx
leaq 0x5a35(%rip), %rsi      # 0x9050
movsbl (%rcx,%rsi), %edi
movswl 0x100(%rsi,%rdx,2), %ecx
orl %edi, %ecx
movzbl 0xe(%r14), %edx
movzbl 0xf(%r14), %edi
movsbl (%rdx,%rsi), %r8d
movswl 0x100(%rsi,%rdi,2), %edx
orl %r8d, %edx
shll $0xc, %edx
orl %ecx, %edx
js 0x365f
andl $0x1f, %ecx
shll $0xe, %ecx
orl %eax, %ecx
movl %ecx, 0xc(%rbx)
shrl $0x5, %edx
movl %edx, 0x10(%rbx)
movb $0x1, %al
jmp 0x3661
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack20x6c20
static inline bool unpack20x6c20(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec5(s + 0);
    if (x < 0) return false;
    v[0]  = (x & Mask(20));
    v[1]  = (x >> 20);
    x = base64dec5(s + 5);
    if (x < 0) return false;
    v[1] |= (x & Mask(10)) << 10;
    v[2]  = (x >> 10);
    x = base64dec5(s + 10);
    if (x < 0) return false;
    v[3]  = (x & Mask(20));
    v[4]  = (x >> 20);
    x = base64dec5(s + 15);
    if (x < 0) return false;
    v[4] |= (x & Mask(10)) << 10;
    v[5]  = (x >> 10);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89cd
testl %eax, %eax
js 0x3847
movl %eax, %ebp
andl $0xfffff, %eax          # imm = 0xFFFFF
movl %eax, (%rbx)
shrl $0x14, %ebp
movl %ebp, 0x4(%rbx)
leaq 0x5(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x3847
movl %eax, %ecx
shll $0xa, %ecx
andl $0xffc00, %ecx          # imm = 0xFFC00
orl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0xa, %eax
movl %eax, 0x8(%rbx)
leaq 0xa(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x3847
movl %eax, %ebp
andl $0xfffff, %eax          # imm = 0xFFFFF
movl %eax, 0xc(%rbx)
shrl $0x14, %ebp
movl %ebp, 0x10(%rbx)
addq $0xf, %r14
movq %r14, %rdi
callq 0x89cd
testl %eax, %eax
js 0x3847
movl %eax, %ecx
shll $0xa, %ecx
andl $0xffc00, %ecx          # imm = 0xFFC00
orl %ebp, %ecx
movl %ecx, 0x10(%rbx)
shrl $0xa, %eax
movl %eax, 0x14(%rbx)
movb $0x1, %al
jmp 0x3849
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack21x4c14
static inline bool unpack21x4c14(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec2(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(21));
    v[1]  = (x >> 21);
    x = base64dec3(s + 4);
    if (x < 0) return false;
    v[1] |= (x << 3);
    x = base64dec2(s + 7) | base64dec2(s + 9) << 12;
    if (x < 0) return false;
    v[2]  = (x & Mask(21));
    v[3]  = (x >> 21);
    x = base64dec3(s + 11);
    if (x < 0) return false;
    v[3] |= (x << 3);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x57d0(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ecx
orl %eax, %ecx
movzbl 0x2(%rdi), %eax
movzbl 0x3(%rdi), %edx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rdx,2), %ebp
orl %eax, %ebp
shll $0xc, %ebp
orl %ecx, %ebp
js 0x3944
movq %rsi, %rbx
movq %rdi, %r14
movl %ebp, %eax
andl $0x1fffff, %eax         # imm = 0x1FFFFF
movl %eax, (%rsi)
shrl $0x15, %ebp
movl %ebp, 0x4(%rsi)
addq $0x4, %rdi
callq 0x89a5
testl %eax, %eax
js 0x3944
shll $0x3, %eax
orl %ebp, %eax
movl %eax, 0x4(%rbx)
movzbl 0x7(%r14), %eax
movzbl 0x8(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ecx
orl %eax, %ecx
movzbl 0x9(%r14), %eax
movzbl 0xa(%r14), %edx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rdx,2), %ebp
orl %eax, %ebp
shll $0xc, %ebp
orl %ecx, %ebp
js 0x3944
movl %ebp, %eax
andl $0x1fffff, %eax         # imm = 0x1FFFFF
movl %eax, 0x8(%rbx)
shrl $0x15, %ebp
movl %ebp, 0xc(%rbx)
addq $0xb, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x3944
shll $0x3, %eax
orl %ebp, %eax
movl %eax, 0xc(%rbx)
movb $0x1, %al
jmp 0x3946
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack22x4c15e2
static inline bool unpack22x4c15e2(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x, y;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[0]  = (x & Mask(10));
    *e    = (x >> 16);
    y = base64dec2(s + 3);
    if (y < 0) return false;
    v[0] |= (y << 10);
    y = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (y < 0) return false;
    v[1]  = (y & Mask(22));
    v[2]  = (y >> 22);
    y = base64dec2(s + 10) | base64dec3(s + 12) << 12;
    if (y < 0) return false;
    v[2] |= (y & Mask(14)) << 8;
    v[3]  = (y >> 14);
    v[3] |= (x & Mask(6)<<10) << 6;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x3a65
movl %eax, %ebp
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, (%rbx)
movl %ebp, %eax
shrl $0x10, %eax
movl %eax, (%r15)
movzbl 0x3(%r14), %eax
movzbl 0x4(%r14), %ecx
leaq 0x569f(%rip), %r12      # 0x9050
movsbl (%rax,%r12), %eax
orw 0x100(%r12,%rcx,2), %ax
js 0x3a65
movzwl %ax, %eax
shll $0xa, %eax
orl %eax, (%rbx)
movzbl 0x5(%r14), %eax
movzbl 0x6(%r14), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r13d
orl %eax, %r13d
leaq 0x7(%r14), %rdi
callq 0x89a5
movl %eax, %r15d
shll $0xc, %r15d
orl %r13d, %r15d
js 0x3a65
movl %r15d, %eax
andl $0x3fffff, %eax         # imm = 0x3FFFFF
movl %eax, 0x4(%rbx)
shrl $0x16, %r15d
movl %r15d, 0x8(%rbx)
movzbl 0xa(%r14), %eax
movzbl 0xb(%r14), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r12d
orl %eax, %r12d
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r12d, %eax
js 0x3a65
movl %eax, %ecx
shll $0x8, %ecx
andl $0x3fff00, %ecx         # imm = 0x3FFF00
orl %r15d, %ecx
movl %ecx, 0x8(%rbx)
shrl $0xe, %eax
shll $0x6, %ebp
andl $0x3f0000, %ebp         # imm = 0x3F0000
orl %eax, %ebp
movl %ebp, 0xc(%rbx)
movb $0x1, %al
jmp 0x3a67
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/main.c
// Function: main
void splash_screen(void)
{
	printf("\n--------------------------------------------------------------------------------\n");
	printf("Welcome to %s (game engine %s)\n",TITLE,ENGINE);
	printf("--------------------------------------------------------------------------------\n");
	printf("What lies in the mysterious forest on the edge of a small village? Myths and\n");
	printf("legends have been told for centuries, but no-one has yet figured it out. Will\n");
	printf("you be the one to finally solve this riddle? Good luck!\n");
	printf("--------------------------------------------------------------------------------\n");
	printf("To learn how to play, type: help\n");
	printf("--------------------------------------------------------------------------------\n");

}

// Assembly:
pushq %rbx
leaq 0x2c92(%rip), %rdi      # 0x6046
callq 0x3090
leaq 0x2c44(%rip), %rdi      # 0x6004
leaq 0x2c5d(%rip), %rsi      # 0x6024
leaq 0x2c6b(%rip), %rdx      # 0x6039
xorl %eax, %eax
callq 0x30f0
leaq 0x2c6b(%rip), %rbx      # 0x6047
movq %rbx, %rdi
callq 0x3090
leaq 0x2cad(%rip), %rdi      # 0x6098
callq 0x3090
leaq 0x2cee(%rip), %rdi      # 0x60e5
callq 0x3090
leaq 0x2d30(%rip), %rdi      # 0x6133
callq 0x3090
movq %rbx, %rdi
callq 0x3090
leaq 0x2d54(%rip), %rdi      # 0x616b
callq 0x3090
movq %rbx, %rdi
callq 0x3090
callq 0x3430
xorl %eax, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/input.c
// Function: completion
void completion(const char *buf, linenoiseCompletions *lc) {
	if (buf[0] == 'w') {
		linenoiseAddCompletion(lc,"walk ");
		linenoiseAddCompletion(lc,"west");
	} else if (buf[0] == 'g') {
		linenoiseAddCompletion(lc,"go ");
		linenoiseAddCompletion(lc,"get ");
	} else if (buf[0] == 'm') {
		linenoiseAddCompletion(lc,"move ");
	} else if (buf[0] == 'n') {
		linenoiseAddCompletion(lc,"north");
	} else if (buf[0] == 's') {
		linenoiseAddCompletion(lc,"south");
		linenoiseAddCompletion(lc,"search");
	} else if (buf[0] == 'l') {
		linenoiseAddCompletion(lc,"look");
	} else if (buf[0] == 't') {
		linenoiseAddCompletion(lc,"take ");
	} else if (buf[0] == 'd') {
		linenoiseAddCompletion(lc,"drop ");
	} else if (buf[0] == 'i') {
		linenoiseAddCompletion(lc,"inventory");
	} else if (buf[0] == 'u') {
		linenoiseAddCompletion(lc,"use ");
	} else if (buf[0] == 'q') {
		linenoiseAddCompletion(lc,"quit");
	} else if (buf[0] == 'h') {
		linenoiseAddCompletion(lc,"help");
	} else if (buf[0] == 'e') {
		linenoiseAddCompletion(lc,"exit");
		linenoiseAddCompletion(lc,"east");
	} else if (buf[0] == 'f') {
		linenoiseAddCompletion(lc,"find");
	}
}

// Assembly:
pushq %rbx
movzbl (%rdi), %eax
addl $-0x64, %eax
cmpl $0x13, %eax
ja 0x3c3e
movq %rsi, %rbx
leaq 0x261e(%rip), %rcx      # 0x618c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2709(%rip), %rsi      # 0x6287
jmp 0x3c35
leaq 0x26e2(%rip), %rsi      # 0x626c
movq %rbx, %rdi
callq 0x3c71
leaq 0x2674(%rip), %rsi      # 0x620d
jmp 0x3c35
leaq 0x423f(%rip), %rsi      # 0x7de4
movq %rbx, %rdi
callq 0x3c71
leaq 0x266c(%rip), %rsi      # 0x6220
jmp 0x3c35
leaq 0x25ca(%rip), %rsi      # 0x6187
jmp 0x3c35
leaq 0x26c7(%rip), %rsi      # 0x628d
jmp 0x3c35
leaq 0x265d(%rip), %rsi      # 0x622c
jmp 0x3c35
leaq 0x26a9(%rip), %rsi      # 0x6281
jmp 0x3c35
leaq 0x2691(%rip), %rsi      # 0x6272
movq %rbx, %rdi
callq 0x3c71
leaq 0x2686(%rip), %rsi      # 0x6276
jmp 0x3c35
leaq 0x262e(%rip), %rsi      # 0x6227
jmp 0x3c35
leaq 0x25ec(%rip), %rsi      # 0x61ee
movq %rbx, %rdi
callq 0x3c71
leaq 0x25f7(%rip), %rsi      # 0x6208
jmp 0x3c35
leaq 0x25d9(%rip), %rsi      # 0x61f3
jmp 0x3c35
leaq 0x2658(%rip), %rsi      # 0x627b
jmp 0x3c35
leaq 0x25bd(%rip), %rsi      # 0x61e9
jmp 0x3c35
leaq 0x25cd(%rip), %rsi      # 0x6202
movq %rbx, %rdi
popq %rbx
jmp 0x3c71
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/rooms.c
// Function: move
extern void move(char *direction)
{
	int dir;

	putchar('\n');

	/* figure out direction */
	if (direction == NULL) {
		printf("Walk where?\n");
		return;
	} else if (strcmp(direction,"north") == 0) {
		dir = 0;
	} else if (strcmp(direction,"east") == 0) {
		dir = 1;
	} else if (strcmp(direction,"south") == 0) {
		dir = 2;
	} else if (strcmp(direction,"west") == 0) {
		dir = 3;
	} else {
		printf("Walk where?\n");
		return;
	}

	/* move */
	if (locations[current_room].walk_to[dir] != -1) {
		printf("%s\n",locations[current_room].walk_desc[dir]);
		current_room = locations[current_room].walk_to[dir];
		room_name();
		look_room();
	} else {
		printf("You cannot walk %s.\n",direction);
	}

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0xa
popq %rdi
callq 0x3050
testq %rbx, %rbx
je 0x533a
leaq 0xf0d(%rip), %rsi       # 0x6202
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x534b
leaq 0xf00(%rip), %rsi       # 0x6208
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x5350
leaq 0x2ac9(%rip), %rsi      # 0x7de4
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x5354
leaq 0xedf(%rip), %rsi       # 0x620d
movq %rbx, %rdi
callq 0x3180
testl %eax, %eax
je 0x5358
leaq 0x37d0(%rip), %rdi      # 0x8b11
popq %rbx
popq %r14
popq %r15
jmp 0x3090
xorl %r14d, %r14d
jmp 0x535c
pushq $0x1
jmp 0x535a
pushq $0x2
jmp 0x535a
pushq $0x3
popq %r14
movslq 0x98c9(%rip), %rax      # 0xec2c
imulq $0x50, %rax, %rax
leaq 0x7e12(%rip), %r15      # 0xd180
addq %r15, %rax
cmpl $-0x1, 0x18(%rax,%r14,4)
je 0x53ab
movq 0x28(%rax,%r14,8), %rdi
callq 0x3090
movslq 0x98a2(%rip), %rax      # 0xec2c
imulq $0x50, %rax, %rax
addq %rax, %r15
movl 0x18(%r15,%r14,4), %eax
movl %eax, 0x9890(%rip)      # 0xec2c
callq 0x5203
popq %rbx
popq %r14
popq %r15
jmp 0x5228
leaq 0x15a3(%rip), %rdi      # 0x6955
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: room_items
extern void room_items(int room_id)
{
	int i;
	for(i = 0; items[i].item_id != -1; i++) {
		if (items[i].location == room_id && items[i].hidden == NO)
			printf("%s\n",items[i].item_desc_floor);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x8833(%rip), %r14      # 0xdc50
cmpl $-0x1, -0x30(%r14)
je 0x543f
cmpl %ebx, (%r14)
jne 0x5439
cmpl $0x0, -0x8(%r14)
jne 0x5439
movq -0x18(%r14), %rdi
callq 0x3090
addq $0x38, %r14
jmp 0x541d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: search
extern void search(int room_id)
{
	int i;
	int count;

	putchar('\n');

	if (search_desc())
		printf("You carefully search the area. ");

	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (items[i].location == room_id && items[i].hidden == YES) {
			if (count > 0)
				printf("\nYou also found the ");
			else
				printf("You found the ");
			count++;
			if (items[i].item_adj != NULL)
				printf("%s ",items[i].item_adj);
			printf("%s! ",items[i].item_name);
			items[i].hidden = NO;
			items[i].location = -1;
			inventory[i] = 1;
		}
	}
	if (count == 0)
		printf("You didn't find anything.\n");
	else
		putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0xa
popq %rdi
callq 0x3050
callq 0x53c1
testl %eax, %eax
je 0x5473
leaq 0x43d2(%rip), %rdi      # 0x983e
xorl %eax, %eax
callq 0x30f0
leaq 0x97b6(%rip), %r12      # 0xec30
leaq 0x87cf(%rip), %r13      # 0xdc50
leaq 0x43eb(%rip), %r15      # 0x9873
leaq 0x43f3(%rip), %r14      # 0x9882
xorl %ebp, %ebp
cmpl $-0x1, -0x30(%r13)
je 0x54fb
cmpl %ebx, (%r13)
jne 0x54f2
cmpl $0x1, -0x8(%r13)
jne 0x54f2
testl %ebp, %ebp
movq %r15, %rdi
leaq 0x43ad(%rip), %rax      # 0x985e
cmovgq %rax, %rdi
xorl %eax, %eax
callq 0x30f0
movq -0x20(%r13), %rsi
testq %rsi, %rsi
je 0x54d3
leaq 0x149e(%rip), %rdi      # 0x696a
xorl %eax, %eax
callq 0x30f0
incl %ebp
movq -0x28(%r13), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
andl $0x0, -0x8(%r13)
orl $-0x1, (%r13)
movb $0x1, (%r12)
incq %r12
addq $0x38, %r13
jmp 0x5491
testl %ebp, %ebp
je 0x5515
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3050
leaq 0x440c(%rip), %rdi      # 0x9928
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: list_inv
extern void list_inv(void)
{
	int i;
	int count;

	printf("\nInventory:\n");
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (inventory[i] == YES) {
			count++;
			putchar('\t');
			if (items[i].item_adj != NULL)
				printf("%s ",items[i].item_adj);
			printf("%s\n",items[i].item_name);
		}
	}
	if (count == 0)
		printf("\tnothing.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x4404(%rip), %rdi      # 0x9942
callq 0x3090
leaq 0x96e6(%rip), %r15      # 0xec30
leaq 0x86df(%rip), %r12      # 0xdc30
pushq $0x9
popq %rbx
leaq 0x140f(%rip), %r14      # 0x696a
xorl %ebp, %ebp
cmpl $-0x1, -0x10(%r12)
je 0x559a
cmpb $0x1, (%r15)
jne 0x5591
movl %ebx, %edi
callq 0x3050
movq (%r12), %rsi
testq %rsi, %rsi
je 0x5585
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
incl %ebp
movq -0x8(%r12), %rdi
callq 0x3090
incq %r15
addq $0x38, %r12
jmp 0x555d
testl %ebp, %ebp
je 0x55a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x43a0(%rip), %rdi      # 0x994e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: take_item
extern void take_item(int room_id, char *word1, char *word2)
{
	char *adj;
	char *name;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Take what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);
		
	/* find out if given name is ambiguous */
	item_num = in_room(room_id, adj, name);
	
	/* if none were found, the item is not present */
	/* if only one was found, it's not ambiguous */
	if (item_num == -1) {
		printf("There is no ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s here.\n",name);
		return;
	} else if (item_num == -2) {
		printf("Which %s do you want to take?\n",name);
		return;
	}

	/* take item if possible */
	if (items[item_num].takeable == YES) {
		items[item_num].location = -1;
		inventory[item_num] = 1;
		printf("You took the ");
		if (items[item_num].item_adj != NULL)
			printf("%s ",items[item_num].item_adj);
		printf("%s.\n",name);
	} else {
		printf("You cannot take the %s!\n",name);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
pushq $0xa
popq %rdi
callq 0x3050
testq %r14, %r14
je 0x5629
testq %r15, %r15
movq %r14, %rsi
cmoveq %r15, %rsi
movq %r15, %rbx
cmoveq %r14, %rbx
movl %ebp, %edi
movq %rbx, %rdx
callq 0x56b9
cmpl $-0x2, %eax
je 0x563f
cmpl $-0x1, %eax
jne 0x5648
leaq 0x4284(%rip), %rdi      # 0x9887
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x5620
leaq 0x1354(%rip), %rdi      # 0x696a
movq %r14, %rsi
xorl %eax, %eax
callq 0x30f0
leaq 0x4375(%rip), %rdi      # 0x999c
jmp 0x56a5
leaq 0x4328(%rip), %rdi      # 0x9958
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
leaq 0x424e(%rip), %rdi      # 0x9894
jmp 0x56a5
cltq
imulq $0x38, %rax, %rcx
leaq 0x85cb(%rip), %r14      # 0xdc20
cmpl $0x1, 0x2c(%rcx,%r14)
jne 0x569e
addq %rcx, %r14
orl $-0x1, 0x30(%r14)
leaq 0x95c4(%rip), %rcx      # 0xec30
movb $0x1, (%rax,%rcx)
leaq 0x423c(%rip), %rdi      # 0x98b3
xorl %eax, %eax
callq 0x30f0
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x5695
leaq 0x12dc(%rip), %rdi      # 0x696a
xorl %eax, %eax
callq 0x30f0
leaq 0x12c9(%rip), %rdi      # 0x6965
jmp 0x56a5
leaq 0x421c(%rip), %rdi      # 0x98c1
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: in_room
static int in_room(int room_id, char *adj, char *name)
{
	int i;
	int item_num;
	int count;

	/* find out if given name is ambiguous */
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (strcmp(items[i].item_name,name) == 0 &&
			items[i].location == room_id && items[i].hidden == NO) {
			if (adj == NULL) {
				count++;
				item_num = i;
			} else if (items[i].item_adj != NULL &&
					strcmp(adj,items[i].item_adj) == 0) {
				count = 1;
				item_num = i;
				break;
			}
		}
	}

	/* return results */
	if (count == 0) {
		return -1;
	} else if (count > 1) {
		return -2;
	} else {
		return item_num;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
leaq 0x857b(%rip), %r12      # 0xdc50
xorl %r13d, %r13d
cmpl $-0x1, -0x30(%r12)
je 0x572d
movq -0x28(%r12), %rdi
movq %r14, %rsi
callq 0x3180
testl %eax, %eax
jne 0x56ff
cmpl %ebp, (%r12)
jne 0x56ff
cmpl $0x0, -0x8(%r12)
je 0x5707
incl %ebx
addq $0x38, %r12
jmp 0x56d8
testq %r15, %r15
je 0x5724
movq -0x20(%r12), %rsi
testq %rsi, %rsi
je 0x56ff
movq %r15, %rdi
callq 0x3180
testl %eax, %eax
jne 0x56ff
jmp 0x5745
incl %r13d
movl %ebx, 0x4(%rsp)
jmp 0x56ff
cmpl $0x2, %r13d
pushq $-0x2
popq %rax
movl 0x4(%rsp), %ecx
cmovgel %eax, %ecx
xorl %ebx, %ebx
cmpl $0x1, %r13d
sbbl %ebx, %ebx
orl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: unique_item
extern int unique_item(int room_id, char *adj, char *name)
{
	int room;
	int inv;

	if (name == NULL) return -1;

	room = in_room(room_id, adj,name);
	inv = in_inv(adj,name);

	if ((room >= 0 && inv >= 0) || room == -2 || inv == -2) {
		return -2;
	} else if (room == -1 && inv == -1) {
		return -1;
	} else {
		if (inv == -1) inv = room;
		return inv;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0x57a7
movq %rdx, %r14
movq %rsi, %r15
callq 0x56b9
movl %eax, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x57ba
movl %ebx, %ecx
orl %eax, %ecx
setns %cl
cmpl $-0x2, %ebx
sete %dl
cmpl $-0x2, %eax
sete %sil
orb %dl, %sil
orb %cl, %sil
je 0x57ac
pushq $-0x2
jmp 0x57a9
pushq $-0x1
popq %rbx
jmp 0x57b2
cmpl $-0x1, %eax
cmovnel %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: in_inv
static int in_inv(char *adj, char *name)
{
	int i;
	int item_num;
	int count;
	
	/* find out if given name is ambiguous */
	for (count = 0, i = 0; items[i].item_id != -1; i++) {
		if (strcmp(items[i].item_name,name) == 0 &&
			inventory[i] == YES) {
			if (adj == NULL) {
				count++;
				item_num = i;
			} else if (items[i].item_adj != NULL &&
				strcmp(adj,items[i].item_adj) == 0) {
				count = 1;
				item_num = i;
				break;
			}
		}
	}

	/* return results */
	if (count == 0) {
		return -1;
	} else if (count > 1) {
		return -2;
	} else {
		return item_num;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0x845c(%rip), %r13      # 0xdc30
leaq 0x9455(%rip), %rbp      # 0xec30
xorl %r12d, %r12d
cmpl $-0x1, -0x10(%r13)
je 0x5827
movq -0x8(%r13), %rdi
movq %r14, %rsi
callq 0x3180
testl %eax, %eax
jne 0x581e
cmpb $0x1, (%rbx,%rbp)
jne 0x581e
testq %r15, %r15
je 0x5817
movq (%r13), %rsi
testq %rsi, %rsi
je 0x581e
movq %r15, %rdi
callq 0x3180
testl %eax, %eax
jne 0x581e
jmp 0x583f
incl %r12d
movl %ebx, 0x4(%rsp)
incq %rbx
addq $0x38, %r13
jmp 0x57de
cmpl $0x2, %r12d
pushq $-0x2
popq %rax
movl 0x4(%rsp), %ecx
cmovgel %eax, %ecx
xorl %ebx, %ebx
cmpl $0x1, %r12d
sbbl %ebx, %ebx
orl %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: drop_item
extern void drop_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Drop what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);
	
	/* find out if given name is ambiguous */
	item_num = in_inv(adj, name);

	/* if none were found, the item is not in inventory */
	/* if only one was found, it's not ambiguous */
	if (item_num == -1) {
		printf("You do not have a ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s.\n",name);
		return;
	} else if (item_num == -2) {
		printf("Which %s do you want to drop?\n",name);
		return;
	}

	/* drop item */
	items[item_num].location = room_id;
	inventory[item_num] = NO;
	printf("You dropped the ");
	if (items[item_num].item_adj != NULL)
		printf("%s ",items[item_num].item_adj);
	printf("%s.\n",name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
pushq $0xa
popq %rdi
callq 0x3050
testq %r14, %r14
je 0x58ae
testq %r15, %r15
movq %r14, %rdi
cmoveq %r15, %rdi
movq %r15, %rbx
cmoveq %r14, %rbx
movq %rbx, %rsi
callq 0x57ba
cmpl $-0x2, %eax
je 0x58c4
cmpl $-0x1, %eax
jne 0x58cd
leaq 0x4044(%rip), %rdi      # 0x98da
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x5910
leaq 0x10c1(%rip), %rdi      # 0x696a
movq %r14, %rsi
jmp 0x5909
leaq 0x40ae(%rip), %rdi      # 0x9963
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
leaq 0x4022(%rip), %rdi      # 0x98ed
jmp 0x5917
cltq
imulq $0x38, %rax, %r14
leaq 0x8346(%rip), %r15      # 0xdc20
movl %ebp, 0x30(%r14,%r15)
leaq 0x934a(%rip), %rcx      # 0xec30
movb $0x0, (%rax,%rcx)
leaq 0x401b(%rip), %rdi      # 0x990c
xorl %eax, %eax
callq 0x30f0
movq 0x10(%r14,%r15), %rsi
testq %rsi, %rsi
je 0x5910
leaq 0x1061(%rip), %rdi      # 0x696a
xorl %eax, %eax
callq 0x30f0
leaq 0x104e(%rip), %rdi      # 0x6965
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
// File: /workspace/github_c_makefile_star2_O2/ethinethin[P]Secret/items.c
// Function: look_item
extern void look_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Look at what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);

	/* in location or inventory? */
	item_num = unique_item(room_id, adj, name);

	/* is it ambiguous? */
	if (item_num == -2) {
		printf("Which %s?\n",name);
		return;
	} else if (item_num == -1) {
		printf("There is no ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s here.\n",name);
		return;
	} 
	/* output description */
	printf("%s\n",items[item_num].item_desc_exam);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
pushq $0xa
popq %rdi
callq 0x3050
testq %r14, %r14
je 0x5975
testq %r15, %r15
movq %r14, %rsi
cmoveq %r15, %rsi
movq %r15, %rbx
cmoveq %r14, %rbx
movl %ebp, %edi
movq %rbx, %rdx
callq 0x5765
cmpl $-0x1, %eax
je 0x597e
cmpl $-0x2, %eax
jne 0x59bd
leaq 0x3faa(%rip), %rdi      # 0x991d
jmp 0x59a9
leaq 0x3ff2(%rip), %rdi      # 0x996e
jmp 0x59cf
leaq 0x3f02(%rip), %rdi      # 0x9887
xorl %eax, %eax
callq 0x30f0
testq %r15, %r15
je 0x59a2
leaq 0xfd2(%rip), %rdi       # 0x696a
movq %r14, %rsi
xorl %eax, %eax
callq 0x30f0
leaq 0x3ff3(%rip), %rdi      # 0x999c
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30f0
cltq
imulq $0x38, %rax, %rax
leaq 0x8256(%rip), %rcx      # 0xdc20
movq 0x20(%rax,%rcx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3090
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: compute
void compute(size_t HowManyKeys) {
  bool verbose = false;
  printf("Number of keys %zu \n", HowManyKeys);
  printf("Full cache line (512-bits) \n");
  assessBlockSize(HowManyKeys, 512, verbose);
  printf("3/4 cache line (384-bits) \n");
  assessBlockSize(HowManyKeys, 384, verbose);
  printf("Half cache line (256-bits) \n");
  assessBlockSize(HowManyKeys, 256, verbose);
  printf("Half cache line (128-bits) \n");
  assessBlockSize(HowManyKeys, 128, verbose);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x2113(%rip), %rdi      # 0x437d
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1080
leaq 0x2117(%rip), %rdi      # 0x4392
callq 0x1070
movl $0x200, %esi            # imm = 0x200
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15dc
leaq 0x2118(%rip), %rdi      # 0x43ae
callq 0x1070
movl $0x180, %esi            # imm = 0x180
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15dc
leaq 0x2118(%rip), %rdi      # 0x43c9
callq 0x1070
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
xorl %edx, %edx
callq 0x15dc
leaq 0x2119(%rip), %rdi      # 0x43e5
callq 0x1070
movl $0x80, %esi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
jmp 0x15dc
// File: /workspace/github_c_makefile_star2_O2/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: main
int main() {
  printf("bits per key indicates storage (bits used per key): smaller is "
         "better\n");
  printf("best bits per bucket indicates the number of bits to check per key: "
         "smaller is better\n");
  printf("collision rate is the false negative rate: smaller is better\n");
  printf("In the 'lane' model you have one bit set per lane.\n");
  printf("\n");
  for(size_t i = 10000; i < 1000000000; i*=10) {
    compute(i);
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbx
leaq 0x2118(%rip), %rdi      # 0x4401
callq 0x1070
leaq 0x2152(%rip), %rdi      # 0x4447
callq 0x1070
leaq 0x219c(%rip), %rdi      # 0x449d
callq 0x1070
leaq 0x21cd(%rip), %rdi      # 0x44da
callq 0x1070
pushq $0xa
popq %rdi
callq 0x1050
movl $0x2710, %ebx           # imm = 0x2710
cmpq $0x3b9aca00, %rbx       # imm = 0x3B9ACA00
jae 0x2336
movq %rbx, %rdi
callq 0x225f
imulq $0xa, %rbx, %rbx
jmp 0x231f
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/cirocosta[P]stress/src/consistent-forking.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	stress_parse_args(argc, argv, &args);
	_STRESS_MUST(args.n > 0, "'n' argument must be at least > 0");
	fork_so_much(args.n);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x8(%rsp), %r14
movl $0x2008, %edx           # imm = 0x2008
movq %r14, %rdi
xorl %esi, %esi
callq 0x10a0
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x12cd
cmpl $0x0, (%r14)
jle 0x1915
callq 0x169e
movq 0x26dc(%rip), %r14      # 0x3ff8
movq (%r14), %rcx
leaq 0x817(%rip), %rdi       # 0x213d
pushq $0x9
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1140
movq (%r14), %rcx
leaq 0x805(%rip), %rdi       # 0x2143
pushq $0x3
popq %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r14), %rcx
leaq 0x81e(%rip), %rdi       # 0x2171
pushq $0x21
popq %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r14), %rcx
leaq 0x6db(%rip), %rdi       # 0x2043
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq 0x1140
movq (%r14), %rdi
leaq 0x6c9(%rip), %rsi       # 0x2046
leaq 0x77a(%rip), %rdx       # 0x20fe
xorl %eax, %eax
callq 0x10d0
movq (%r14), %rdi
leaq 0x6cd(%rip), %rsi       # 0x2062
pushq $0x47
popq %rdx
xorl %eax, %eax
callq 0x10d0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x10b0
movq (%r14), %rcx
leaq 0x6bb(%rip), %rdi       # 0x206f
pushq $0xa
popq %rsi
movq %rbx, %rdx
callq 0x1140
pushq $0x1
popq %rdi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/Openvario[P]sensord/compdata.c
// Function: sigintHandler
static void sigintHandler(int sig_num)
{
	(void)sig_num;

	signal(SIGINT, sigintHandler);

	// if sensordata from file
	if (fp_sensordata != NULL)
		fclose(fp_sensordata);

	fprintf(stderr, "Exiting ...\n");

	exit(0);
}

// Assembly:
pushq %rax
leaq -0x8(%rip), %rsi        # 0x2abb
pushq $0x2
popq %rdi
callq 0x1140
leaq 0x30058e6(%rip), %rax   # 0x30083b8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2adf
callq 0x10b0
movq 0x5512(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2e2a(%rip), %rdi      # 0x591a
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
xorl %edi, %edi
callq 0x1210