LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/WereCatf[P]Gonzales/fast-gpio.c
// Function: readPull
uint8_t readPull(int port, int pin)
{
	volatile uint32_t *pioMem32, *configRegister;
	pioMem32=(uint32_t *)(memmap+port*0x24+0x1c); //0x1c == pull-register
	configRegister=pioMem32+(pin >> 4);
	return *configRegister >> ((pin & 15) * 2) & 3;
}

// Assembly:
movslq %edi, %rax
imulq $0x24, %rax, %rax
addq 0x486e(%rip), %rax      # 0x7ad0
leal (%rsi,%rsi), %ecx
movl %esi, %edx
sarl $0x4, %edx
movslq %edx, %rdx
movl 0x1c(%rax,%rdx,4), %eax
shrl %cl, %eax
andb $0x3, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %edi, %rax
imulq $0x24, %rax, %rax
addq 0x484c(%rip), %rax      # 0x7ad0
leal (%rsi,%rsi), %ecx
sarl $0x4, %esi
movslq %esi, %rsi
pushq $0x3
popq %rdi
shll %cl, %edi
notl %edi
andl %edi, 0x1c(%rax,%rsi,4)
andl $0x3, %edx
shll %cl, %edx
orl %edx, 0x1c(%rax,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %ecx
movq 0x4782(%rip), %rax      # 0x7ad0
movslq %edi, %rsi
leaq 0x4766(%rip), %rdi      # 0x7abe
movzbl (%rsi,%rdi), %esi
pushq $0x1
popq %rdi
shll %cl, %edi
pushq $-0x2
popq %r8
roll %cl, %r8d
andl %r8d, (%rax,%rsi)
testb $0x1, %dl
je 0x3374
orl %edi, (%rax,%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/Haswell/KeccakP-1600-AVX2.cpp
// Function: KeccakP1600_AddBytes
void KeccakP1600_AddBytes(void *state, const UINT8 *data, size_t offset, size_t length)
//*****************************************************************************
{
    keccak_state_t  &s = *(keccak_state_t *)state;
    UINT64      *d = (UINT64 *)data;
    UINT8       *t1, *d1;
    UINT64      t[25];
    UINT64      *t0;
    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));

/*
    // "trailingBits + 256" is passed as offset to do "state ^ trailingBits".
    if (offset >= 256)
    {
        if (length < sizeof(t))
            ((UINT8 *)t)[length] ^= (UINT8)offset;
        offset = 0;
    }
*/

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

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

    if (byte_n)
    {
        t1 = (UINT8 *)(t0 + i);
        d1 = (UINT8 *)(d + i);

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

    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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, %r13
shrq $0x3, %r13
xorl %ebp, %ebp
movq %rsp, %rsi
movl $0xc8, %ecx
xorl %edx, %edx
callq 0x5060
leaq (%rsp,%r12), %rax
cmpq %rbp, %r13
je 0x5841
movq (%r15,%rbp,8), %rcx
xorq %rcx, (%rax,%rbp,8)
incq %rbp
jmp 0x582f
andq $0x7, %r14
je 0x5863
leaq (%rax,%r13,8), %rax
leaq (%r15,%r13,8), %rcx
xorl %edx, %edx
cmpq %rdx, %r14
je 0x5863
movb (%rcx,%rdx), %sil
xorb %sil, (%rax,%rdx)
incq %rdx
jmp 0x5851
vmovups (%rsp), %ymm0
vmovaps %ymm0, (%rbx)
vmovups 0x28(%rsp), %ymm0
vmovaps %ymm0, 0x20(%rbx)
vmovups 0x50(%rsp), %ymm0
vmovaps %ymm0, 0x40(%rbx)
vmovups 0x78(%rsp), %ymm0
vmovaps %ymm0, 0x60(%rbx)
vmovups 0xa0(%rsp), %ymm0
vmovaps %ymm0, 0x80(%rbx)
vmovdqa 0x20(%rsp), %xmm0
vpinsrq $0x1, 0x48(%rsp), %xmm0, %xmm0
vpbroadcastq 0x70(%rsp), %ymm1
vpblendd $0x30, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3],ymm1[4,5],ymm0[6,7]
vpbroadcastq 0x98(%rsp), %ymm1
vpblendd $0xc0, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4,5],ymm1[6,7]
vmovdqa %ymm0, 0xa0(%rbx)
vbroadcastsd 0xc0(%rsp), %ymm0
vmovaps %ymm0, 0xc0(%rbx)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r14
movl $0xc8, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x5060
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x5050
vmovups (%r14), %ymm0
vmovaps %ymm0, (%rbx)
vmovups 0x28(%r14), %ymm0
vmovaps %ymm0, 0x20(%rbx)
vmovups 0x50(%r14), %ymm0
vmovaps %ymm0, 0x40(%rbx)
vmovups 0x78(%r14), %ymm0
vmovaps %ymm0, 0x60(%rbx)
vmovups 0xa0(%r14), %ymm0
vmovaps %ymm0, 0x80(%rbx)
vmovdqa 0x20(%r14), %xmm0
vpinsrq $0x1, 0x48(%r14), %xmm0, %xmm0
vpbroadcastq 0x70(%r14), %ymm1
vpblendd $0x30, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3],ymm1[4,5],ymm0[6,7]
vpbroadcastq 0x98(%r14), %ymm1
vpblendd $0xc0, %ymm1, %ymm0, %ymm0 # ymm0 = ymm0[0,1,2,3,4,5],ymm1[6,7]
vmovdqa %ymm0, 0xa0(%rbx)
vbroadcastsd 0xc0(%r14), %ymm0
vmovaps %ymm0, 0xc0(%rbx)
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %r8, %r13
shrq $0x3, %r13
xorl %ebp, %ebp
movq %rsp, %rsi
movl $0xc8, %ecx
xorl %edx, %edx
callq 0x5060
leaq (%rsp,%r12), %rax
cmpq %rbp, %r13
je 0x5bce
movq (%rax,%rbp,8), %rcx
xorq (%r15,%rbp,8), %rcx
movq %rcx, (%r14,%rbp,8)
incq %rbp
jmp 0x5bb8
andq $0x7, %rbx
je 0x5bf8
leaq (%rax,%r13,8), %rax
leaq (%r15,%r13,8), %rcx
leaq (%r14,%r13,8), %rdx
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x5bf8
movb (%rax,%rsi), %dil
xorb (%rcx,%rsi), %dil
movb %dil, (%rdx,%rsi)
incq %rsi
jmp 0x5be2
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
pushq $-0x1
popq %rbx
movsbq (%r14), %r15
testq %r15, %r15
je 0x1225
callq 0x1120
movq (%rax), %rax
incq %r14
testb $0x8, 0x1(%rax,%r15,2)
jne 0x1207
jmp 0x1227
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strrep
int strrep(char* src, char* haystack, char* needle)
{
    short   status  = 0;

    char*   bak     = NULL,
        *   find    = NULL;

    if (src == NULL || haystack == NULL || needle == NULL) {
        status = -1; goto ERR;
    }

    /* seach strings */
    if ((find = strstr(src, haystack)) == NULL) {
        status = -2; goto ERR;
    }

    if (strlen(haystack) < strlen(needle)) {
        /* reallocate memory */
        bak = src;
        if ((src = (char*)
                    realloc(src, strlen(src) + strlen(needle) + 1 - strlen(haystack))) == NULL) {
            status = -3; goto ERR;
        }

        /* move match word to specified location in memory */
        memmove(
            find + strlen(needle),
            find + strlen(haystack),
            strlen(src) - strlen(haystack) - (find - src) + 1
        );
        memcpy(find, haystack, strlen(needle));
    } else {
        memcpy(find, needle, strlen(needle));
        /* move match word to specified location in memory */
        if (strlen(haystack) > strlen(needle)) {
            memmove(
                find + strlen(needle),
                find + strlen(haystack),
                strlen(src) - strlen(haystack) - (find - src) + 1
            );
        }
    }

    return 0;

ERR:
    switch (status) {
        case    -1:
        case    -2:
            break;
        case    -3:
            if (bak != NULL) {
                free(bak);
                free(bak);
            }
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testq %rdx, %rdx
sete %al
orb %cl, %al
je 0x1259
pushq $-0x1
jmp 0x1368
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
callq 0x1110
testq %rax, %rax
je 0x1302
movq %rax, %r15
movq %rbx, %rdi
callq 0x1070
movq %rax, %r13
movq %r14, %rdi
callq 0x1070
movq %rax, %rbp
subq %r13, %rbp
jbe 0x1306
movq %r12, %rdi
callq 0x1070
leaq (%rax,%rbp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x10c0
testq %rax, %rax
je 0x1356
movq %rax, %r13
movq %r14, %rdi
callq 0x1070
leaq (%rax,%r15), %r12
movq %rbx, %rdi
callq 0x1070
movq %r15, %rbp
addq %rax, %rbp
movq %r13, %rdi
callq 0x1070
subq %rbp, %r13
leaq (%rax,%r13), %rdx
incq %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10e0
movq %r14, %rdi
callq 0x1070
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1080
xorl %ebx, %ebx
jmp 0x1369
pushq $-0x2
jmp 0x1368
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1080
movq %rbx, %rdi
callq 0x1070
movq %rax, %r13
movq %r14, %rdi
callq 0x1070
xorl %ebx, %ebx
cmpq %rax, %r13
jbe 0x1369
movq %rax, %r14
addq %r15, %r14
addq %r15, %r13
movq %r12, %rdi
callq 0x1070
subq %r13, %r12
leaq (%r12,%rax), %rdx
incq %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x10e0
jmp 0x1369
movq %r12, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
pushq $-0x3
popq %rbx
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/sasairc[P]yasuna/src/libbenly/src/string.c
// Function: strlion
char* strlion(int argnum, ...)
{
    int     i       = 0;

    size_t  destlen = 0,
            blklen  = 0,
            arglen  = 0;

    char*   dest    = NULL,
        **  argmnt  = NULL;

    va_list list;       /* list of variable arguments */

    if ((argmnt = (char**)
                malloc(sizeof(char*) * argnum)) == NULL)
        goto ERR;

    /* processing of variable arguments */
    va_start(list, argnum);
    while (i < argnum) {
        *(argmnt + i) = va_arg(list, char*);
        arglen += strlen(*(argmnt + i));
        i++;
    }
    va_end(list);

    /* memory allocation */
    if ((dest = (char*)
                malloc(sizeof(char) * (arglen + 1))) == NULL)
        goto ERR;

    /* concat strings */
    i = destlen = blklen = 0;
    blklen = strlen(*(argmnt + i));
    memcpy(dest, *(argmnt + i), blklen);
    destlen += blklen;

    i++;
    while(i < argnum) {
        blklen = strlen(*(argmnt + i));
        memcpy(dest + destlen, *(argmnt + i), blklen);
        destlen += blklen;
        i++;
    }
    *(dest + destlen) = '\0';

    free(argmnt);

    return dest;

ERR:
    if (argmnt != NULL) {
        free(argmnt);
        argmnt = NULL;
    }
    if (dest != NULL) {
        free(dest);
        dest = NULL;
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %edi, %r14d
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x58(%rsp)
testb %al, %al
je 0x13e5
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movslq %edi, %rax
movq %rax, 0x8(%rsp)
leaq (,%rax,8), %rdi
callq 0x1090
movq %rax, %rbx
testq %rax, %rax
je 0x14e0
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x120(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000008, %rcx     # imm = 0x3000000008
movq %rcx, 0x10(%rsp)
pushq $0x8
popq %r13
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
xorl %r15d, %r15d
cmpq %r12, %r14
je 0x1481
cmpl $0x28, %r13d
ja 0x1461
movq %rax, %rbp
movl %r13d, %eax
leaq 0x30(%rsp), %rcx
addq %rcx, %rax
addl $0x8, %r13d
movl %r13d, 0x10(%rsp)
jmp 0x146a
leaq 0x8(%rax), %rbp
movq %rbp, 0x18(%rsp)
movq (%rax), %rdi
movq %rdi, (%rbx,%r12,8)
callq 0x1070
addq %rax, %r15
incq %r12
movq %rbp, %rax
jmp 0x143d
incq %r15
movq %r15, %rdi
callq 0x1090
testq %rax, %rax
je 0x14e0
movq %rax, %r14
movq (%rbx), %r12
movq %r12, %rdi
callq 0x1070
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1080
pushq $0x1
popq %rbp
cmpq 0x8(%rsp), %rbp
jge 0x14ed
movq (%rbx,%rbp,8), %r12
movq %r12, %rdi
callq 0x1070
movq %rax, %r13
leaq (%r14,%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1080
addq %r13, %r15
incq %rbp
jmp 0x14b3
movq %rbx, %rdi
callq 0x1030
xorl %r14d, %r14d
jmp 0x14fa
movb $0x0, (%r14,%r15)
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0xadc(%rip), %rsi       # 0x2000
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x10d0
pushq $0x1
popq %r13
pushq $0x2
popq %r15
cmpb $0x0, (%r14)
je 0x158d
callq 0x1060
movq %r14, %rdi
movq %rax, %rsi
callq 0x1040
testl %eax, %eax
js 0x158b
movl %eax, %ebp
movl %r13d, %r12d
cmpl $0x2, %eax
jb 0x1581
movq %r14, %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x10f0
movl (%rax), %ecx
movl $0xffff009b, %edx       # imm = 0xFFFF009B
addl %edx, %ecx
cmpl $0x3b, %ecx
movl %r15d, %r12d
sbbl $0x0, %r12d
movq %rax, %rdi
callq 0x1050
addl %r12d, %ebx
movl %ebp, %eax
addq %rax, %r14
jmp 0x1535
xorl %ebx, %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/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %edi, %r15
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq %r15, %r14
jge 0x15fd
leaq -0x1(%r15), %r12
movq (%rbx,%r14,8), %rdi
callq 0x1100
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq -0x8(%rbx,%r15,8), %rdi
callq 0x1100
cmpl %ebp, %eax
cmovgl %eax, %ebp
incq %r14
movq %r12, %r15
jmp 0x15cf
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x1818
movq 0x2890(%rip), %rbx      # 0x40a8
testq %rbx, %rbx
je 0x1849
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
testq %rax, %rax
je 0x1840
movq %rax, %r15
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x1070
addq %r15, %rax
jmp 0x1842
xorl %eax, %eax
movq %rax, 0x285f(%rip)      # 0x40a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0x100000000, %r15     # imm = 0xFFFFFFFF00000000
callq 0x1070
movq %rax, %r14
movl %r14d, %r12d
callq 0x1120
shlq $0x20, %r14
addq %r15, %r14
decq %r12
movq %r14, %rcx
testl %r12d, %r12d
js 0x18a8
movq (%rax), %rdx
movl %r12d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movsbq (%rbx,%rsi), %rsi
leaq (%rcx,%r15), %r14
decq %r12
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x1881
sarq $0x20, %rcx
movb $0x0, 0x1(%rbx,%rcx)
movq (%rax), %rdx
xorl %eax, %eax
movsbq (%rbx,%rax), %rcx
incq %rax
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x18b6
cmpq $0x1, %rax
je 0x18e6
xorl %edx, %edx
testb %cl, %cl
je 0x18e0
leaq (%rbx,%rdx), %rsi
movb %cl, (%rbx,%rdx)
incq %rdx
movb (%rax,%rsi), %cl
jmp 0x18cd
movl %edx, %eax
movb $0x0, (%rbx,%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x1909
pushq $-0x1
popq %rcx
jmp 0x1953
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1070
movq %rax, %r15
movq %rbx, %rdi
callq 0x1070
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
testb %dl, %dl
je 0x1940
movb (%r14,%rcx), %sil
testb %sil, %sil
je 0x1940
cmpb %dl, %sil
jne 0x1940
incq %rcx
jmp 0x1926
xorq %rcx, %r15
xorq %rcx, %rax
xorl %ecx, %ecx
orq %r15, %rax
setne %cl
popq %rbx
popq %r14
popq %r15
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movslq %edi, %r12
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %r12, %r15
jge 0x1a6f
leaq -0x1(%r12), %r13
movq (%r14,%r15,8), %rdi
movq %rbx, %rsi
callq 0x10a0
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq -0x8(%r14,%r12,8), %rdi
movq %rbx, %rsi
callq 0x10a0
cmpl %ebp, %eax
cmovgl %eax, %ebp
incq %r15
movq %r13, %r12
jmp 0x1a3a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x50, %rsp
andl $0x0, 0xc(%rsp)
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x24ab
callq 0x6ac4
cmpl $0x3, %ebp
jne 0x253f
leaq 0x5b69(%rip), %rax      # 0x8024
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%rcx)
leaq 0x5b57(%rip), %rax      # 0x8029
movq %rax, 0x10(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x18(%rsp)
movq $0x1, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
leaq 0x5b30(%rip), %rsi      # 0x802d
movq %rsp, %rdi
xorl %eax, %eax
callq 0x595c
cmpl $-0x1, %eax
je 0x25fd
movq (%rsp), %rdi
callq 0x5c4c
testq %rax, %rax
jne 0x255a
callq 0x2090
cmpl $0x0, (%rax)
movq (%rsp), %rsi
jne 0x25a7
leaq 0x5b00(%rip), %rdi      # 0x8033
xorl %eax, %eax
callq 0x6cd0
jmp 0x25f4
leaq 0x5abe(%rip), %rdi      # 0x8004
xorl %eax, %eax
callq 0x6cd0
callq 0x2090
andl $0x0, (%rax)
jmp 0x25fd
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x2040
andq $0x0, (%rsp)
leaq 0x93(%rip), %rcx        # 0x2605
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %r14
movl $0xf4240, %edx          # imm = 0xF4240
movq %rbx, %rdi
movq %r14, %r8
callq 0x382c
movq %r14, %rdi
callq 0x294f
testl %eax, %eax
jne 0x25bd
movq %rbx, %rdi
callq 0x624b
xorl %edi, %edi
callq 0x2300
movq %rax, %rbx
leaq 0x5a82(%rip), %rdi      # 0x8033
xorl %eax, %eax
callq 0x6b41
andl $0x0, (%rbx)
jmp 0x25f4
callq 0x2090
cmpl $0x0, (%rax)
jne 0x25d7
leaq 0x5a77(%rip), %rdi      # 0x8045
xorl %eax, %eax
callq 0x6cd0
jmp 0x25ec
movq %rax, %r14
leaq 0x5a64(%rip), %rdi      # 0x8045
xorl %eax, %eax
callq 0x6b41
andl $0x0, (%r14)
movq %rbx, %rdi
callq 0x624b
movq (%rsp), %rdi
callq 0x2040
pushq $0x1
popq %rdi
callq 0x2300
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/perftests/http/main.c
// Function: donereq
static int
donereq(void * cookie, struct http_response * R)
{
	int * done = cookie;
	size_t i;

	/* This request is over. */
	*done = 1;

	/* Did we succeed? */
	if (R == NULL) {
		warn0("HTTP request failed");
		return (-1);
	}

	/* Print status and headers. */
	printf("HTTP status = %d\n", R->status);
	for (i = 0; i < R->nheaders; i++)
		printf("%s\n\t%s\n",
		    R->headers[i].header, R->headers[i].value);

	/* Print the body received. */
	fwrite(R->body, 1, R->bodylen, stdout);

	/* Free the body. */
	free(R->body);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, (%rdi)
testq %rsi, %rsi
je 0x2686
movq %rsi, %rbx
movl (%rsi), %esi
leaq 0x5a49(%rip), %rdi      # 0x806d
xorl %eax, %eax
callq 0x2130
pushq $0x8
popq %r15
leaq 0x5a49(%rip), %r14      # 0x807f
xorl %r12d, %r12d
cmpq 0x8(%rbx), %r12
jae 0x265f
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x2130
incq %r12
addq $0x10, %r15
jmp 0x2639
movq 0x18(%rbx), %rdx
movq 0x20(%rbx), %rdi
movq 0xa96a(%rip), %rax      # 0xcfd8
movq (%rax), %rcx
pushq $0x1
popq %rsi
callq 0x2320
movq 0x20(%rbx), %rdi
callq 0x2040
xorl %eax, %eax
jmp 0x269f
leaq 0x59cc(%rip), %rdi      # 0x8059
xorl %eax, %eax
callq 0x6cd0
callq 0x2090
andl $0x0, (%rax)
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/main.c
// Function: main
int
main(int argc, char *argv[])
{
	struct sigaction sa;
	FILE *fp = NULL;
	char ch;

	while ((ch = getopt(argc, argv, "")) != -1) {
		switch (ch) {
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;

	/* assign action for SIGFPE */
	sa.sa_handler = sigfpehand;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	if (sigaction(SIGFPE, &sa, NULL) == -1)
		err(1, "sigaction");

	/* open input file */
	if (argc) {
		if (strcmp(*argv, "-") != 0)
			if ((fp = fopen(*argv, "r")) == NULL)
				err(1, "%s", *argv);
		if (fp)
			yyin = fp;
	}

	/* initialize machine */
	init(argc, argv);

	/* parse and execute input until EOF */
	setjmp(begin);
	while (prepare(), yyparse()) {
		if (DEBUG)
			debug();
		execute(NULL);
	}

	/* cleanup machine and close input file */
	cleanup();
	if (fp)
		fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movl %edi, %ebx
leaq 0x6c0b(%rip), %rdx      # 0x9020
callq 0x2270
cmpb $-0x1, %al
jne 0x24f9
movq 0xbba7(%rip), %rax      # 0xdfd0
movslq (%rax), %r15
leaq 0x10f(%rip), %rax       # 0x2542
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
andl $0x0, 0x80(%rdi)
callq 0x21d0
xorl %eax, %eax
movl %eax, %edx
pushq $0x8
popq %rdi
movq %rsp, %rsi
callq 0x2090
cmpl $-0x1, %eax
je 0x251d
movl %r15d, %ebp
leaq (%r14,%r15,8), %r14
cmpl %r15d, %ebx
jne 0x2473
xorl %eax, %eax
movl %eax, %r15d
jmp 0x24a3
movq (%r14), %rdi
cmpb $0x2d, (%rdi)
jne 0x2481
cmpb $0x0, 0x1(%rdi)
je 0x246c
leaq 0x6ed0(%rip), %rsi      # 0x9358
callq 0x2260
testq %rax, %rax
je 0x252e
movq %rax, %r15
leaq 0xded0(%rip), %rcx      # 0x10370
movq %rax, (%rcx)
subl %ebp, %ebx
movl %ebx, %edi
movq %r14, %rsi
callq 0x2850
leaq 0xbd1a(%rip), %rdi      # 0xe1d0
callq 0x21a0
xorl %eax, %eax
movl %eax, %ebx
callq 0x2941
callq 0x49fc
testl %eax, %eax
je 0x24d7
movq %rbx, %rdi
callq 0x2c63
jmp 0x24bf
callq 0x2a58
testq %r15, %r15
je 0x24e9
movq %r15, %rdi
callq 0x20e0
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xbaf0(%rip), %rax      # 0xdff0
movq (%rax), %rcx
leaq 0x6b04(%rip), %rdi      # 0x900e
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
pushq $0x1
popq %rdi
callq 0x2290
leaq 0x6ae0(%rip), %rsi      # 0x9004
xorl %eax, %eax
pushq $0x1
popq %rdi
callq 0x2220
movq (%r14), %rdx
leaq 0x6bfa(%rip), %rsi      # 0x9132
xorl %eax, %eax
pushq $0x1
popq %rdi
callq 0x2220
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/error.c
// Function: warning
void
warning(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x25c3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xbcb6(%rip), %rbx      # 0xe2a0
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20b0
leaq 0xbb8f(%rip), %rax      # 0xe190
movl (%rax), %esi
leaq 0x6a30(%rip), %rdi      # 0x903a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
callq 0x2050
andl $0x0, (%rax)
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/error.c
// Function: yyerror
void
yyerror(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
	longjmp(begin, 1);
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x2684
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rdi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rcx)
leaq 0xbbf5(%rip), %rbx      # 0xe2a0
movl $0x1fff, %esi           # imm = 0x1FFF
movq %rbx, %rdi
movq %r10, %rdx
callq 0x20b0
leaq 0xbace(%rip), %rax      # 0xe190
movl (%rax), %esi
leaq 0x696f(%rip), %rdi      # 0x903a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2120
callq 0x2050
andl $0x0, (%rax)
leaq 0xbaec(%rip), %rdi      # 0xe1d0
pushq $0x1
popq %rsi
callq 0x2250
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: installglobalname
Name *
installglobalname(const char *s, int t)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = t;
	name->next = nametab;
	nametab = name;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x275c
movq %rax, %r15
movq %r14, %rdi
callq 0x277d
movq %rax, 0x8(%r15)
movl %ebx, 0x10(%r15)
movq 0xdb57(%rip), %rax      # 0x102a0
movq %rax, (%r15)
movq %r15, 0xdb4d(%rip)      # 0x102a0
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: installlocalname
Name *
installlocalname(const char *s, Name *tab)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = VAR;
	name->next = tab;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x275c
movq %rax, %r15
movq %r14, %rdi
callq 0x277d
movq %rax, 0x8(%r15)
movl $0x105, 0x10(%r15)      # imm = 0x105
movq %rbx, (%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: addstr
String *
addstr(char *s, int final)
{
	String **list;
	String *p;

	if ((p = malloc(sizeof *p)) == NULL) {
		free(s);
		yyerror("out of memory");
	}
	if (final) {
		list = &finalstrings;
		p->orig = FINAL;
	} else {
		list = &autostrings;
		p->orig = AUTO;
	}
	p->s = s;
	if (*list)
		(*list)->prev = p;
	p->next = *list;
	p->prev = NULL;
	p->count = 1;
	*list = p;
	return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2803
movq %r14, %rdi
callq 0x2030
leaq 0x6904(%rip), %rdi      # 0x9100
xorl %eax, %eax
callq 0x2625
xorl %ecx, %ecx
testl %ebp, %ebp
sete %cl
leaq 0xda9f(%rip), %rdx      # 0x102b0
leaq 0xda90(%rip), %rax      # 0x102a8
cmoveq %rdx, %rax
movl %ecx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x2833
movq %rbx, (%rcx)
movq (%rax), %rcx
jmp 0x2835
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
andq $0x0, (%rbx)
movq $0x1, 0x20(%rbx)
movq %rbx, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: init
void
init(int c, char *v[])
{
	Name *name;
	int i;

	argc = c;
	argvstrings = emalloc(argc * sizeof *argvstrings);
	for (i = 0; i < argc; i++) {
		argvstrings[i].s = v[i];
		argvstrings[i].orig = ARGV;
	}

	/* initialize program memory */
	prog.head = emalloc(sizeof *prog.head);
	prog.head->next = NULL;
	prog.base = prog.progp = prog.head;

	/* initialize frame stack */
	frame.head = emalloc(sizeof *frame.head);
	frame.head->next = NULL;
	frame.head->prev = NULL;
	frame.next = frame.head;

	/* initialize random function */
	srand(time(NULL));

	/* initialize symbol table with keyword and builtin names */
	for (i = 0; keywords[i].s; i++)
		installglobalname(keywords[i].s, keywords[i].v);
	for (i = 0; bltins[i].s; i++) {
		name = installglobalname(bltins[i].s, BLTIN);
		name->u.bltin = i;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, 0xda5b(%rip)      # 0x102b8
movslq %edi, %rax
imulq $0x28, %rax, %rdi
callq 0x275c
movq %rax, 0xda50(%rip)      # 0x102c0
movl 0xda42(%rip), %ecx      # 0x102b8
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
addq $0x18, %rax
cmpq %rdx, %rcx
je 0x289d
movq (%rbx,%rdx,8), %rsi
movq %rsi, (%rax)
movl $0x2, -0x8(%rax)
incq %rdx
addq $0x28, %rax
jmp 0x2881
pushq $0x18
popq %rdi
callq 0x275c
andq $0x0, (%rax)
movq %rax, 0xda18(%rip)      # 0x102c8
movq %rax, 0xda21(%rip)      # 0x102d8
movq %rax, 0xda22(%rip)      # 0x102e0
pushq $0x30
popq %rdi
callq 0x275c
movq %rax, 0xda23(%rip)      # 0x102f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0xda2e(%rip)      # 0x10308
xorl %edi, %edi
callq 0x2200
movl %eax, %edi
callq 0x2180
pushq $0x8
popq %rbx
leaq 0xaf1e(%rip), %r14      # 0xd810
cmpq $0xe8, %rbx
je 0x290f
movq -0x8(%rbx,%r14), %rdi
movl (%rbx,%r14), %esi
callq 0x271d
addq $0x10, %rbx
jmp 0x28f2
leaq 0xafea(%rip), %rbx      # 0xd900
xorl %r14d, %r14d
cmpq $0x11, %r14
je 0x2939
movq (%rbx), %rdi
movl $0x106, %esi            # imm = 0x106
callq 0x271d
movl %r14d, 0x18(%rax)
incq %r14
addq $0x18, %rbx
jmp 0x2919
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: prepare
void
prepare(void)
{
	Frame *fp;

	continuing = breaking = returning = 0;
	prog.tail = NULL;
	prog.progp = prog.base;
	currsymtab = NULL;
	for (fp = frame.head; fp && fp != frame.tail; fp = fp->next)
		if (fp->local)
			freesymtab(&(fp->local));
	frame.tail = frame.next = frame.head;
	frame.curr = NULL;
	freestrings(&autostrings);
	freestack();
}

// Assembly:
pushq %rbx
xorl %eax, %eax
movb %al, 0xd9c6(%rip)       # 0x10310
movb %al, 0xd9c4(%rip)       # 0x10314
andq $0x0, 0xd978(%rip)      # 0x102d0
movb %al, 0xd9ba(%rip)       # 0x10318
andq $0x0, 0xd9ba(%rip)      # 0x10320
movq 0xd973(%rip), %rax      # 0x102e0
movq %rax, 0xd964(%rip)      # 0x102d8
leaq 0xd975(%rip), %rbx      # 0x102f0
movq 0xd976(%rip), %rax      # 0x102f8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x29ac
cmpq %rax, %rbx
je 0x29ac
cmpq $0x0, 0x10(%rbx)
je 0x29a6
leaq 0x10(%rbx), %rdi
callq 0x29d8
movq 0xd952(%rip), %rax      # 0x102f8
addq $0x8, %rbx
jmp 0x2982
movq 0xd93d(%rip), %rax      # 0x102f0
movq %rax, 0xd94e(%rip)      # 0x10308
movq %rax, 0xd937(%rip)      # 0x102f8
andq $0x0, 0xd937(%rip)      # 0x10300
leaq 0xd8e0(%rip), %rdi      # 0x102b0
callq 0x2a00
popq %rbx
jmp 0x2a34
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: freesymtab
static void
freesymtab(Symbol **symtab)
{
	Symbol *tmp, *p;

	p = *symtab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED SYMBOL: %s\n", tmp->name);
		free(tmp);
	}
	*symtab = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x29f4
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
jmp 0x29e2
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: freestrings
static void
freestrings(String **strings)
{
	String *tmp, *p;

	p = *strings;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED STRING: %s\n", tmp->s);
		free(tmp->s);
		free(tmp);
	}
	*strings = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2a2a
movq 0x8(%r14), %r15
movq 0x18(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
jmp 0x2a0b
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: cleanup
void
cleanup(void)
{
	freesymtab(&global);
	freestrings(&autostrings);
	freestrings(&finalstrings);
	freenametab(&nametab);
	freestack();
}

// Assembly:
pushq %rax
leaq 0xd8c8(%rip), %rdi      # 0x10328
callq 0x29d8
leaq 0xd844(%rip), %rdi      # 0x102b0
callq 0x2a00
leaq 0xd830(%rip), %rdi      # 0x102a8
callq 0x2a00
leaq 0xd81c(%rip), %rdi      # 0x102a0
callq 0x2a8c
popq %rax
jmp 0x2a34
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: freenametab
static void
freenametab(Name **nametab)
{
	Name *tmp, *p;

	p = *nametab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED NAME: %s\n", tmp->s);
		if (tmp->type == FUNCTION || tmp->type == PROCEDURE)
			freenametab(&(tmp->u.fun->params));
		free(tmp->s);
		free(tmp);
	}
	*nametab = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl $0xfffffeeb, %ebp       # imm = 0xFFFFFEEB
testq %r14, %r14
je 0x2ad4
movq (%r14), %r15
movl 0x10(%r14), %eax
addl %ebp, %eax
cmpl $0x1, %eax
ja 0x2abe
movq 0x18(%r14), %rdi
addq $0x8, %rdi
callq 0x2a8c
movq 0x8(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
jmp 0x2a9e
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: debug
void
debug(void)
{
	Inst *p;
	size_t n;

	for (n = 0, p = prog.base; p && p != prog.progp; n++, p = p->next) {
		fprintf(stderr, "CODE %03zu: ", n);
		switch (p->type) {
		case NARG:
			fprintf(stderr, "NARG %d", p->u.narg);
			break;
		case VAL:
			fprintf(stderr, "VAL  %.8g", p->u.val);
			break;
		case NAME:
			fprintf(stderr, "SYM  %s", p->u.name->s);
			break;
		case OPR:
			fprintf(stderr, "OPR  %s", oprname(p->u.opr));
			break;
		case STR:
			fprintf(stderr, "STR  %s", p->u.str->s);
			break;
		case IP:
			if (p->u.ip == NULL)
				fprintf(stderr, "IP -> NULL");
			else
				fprintf(stderr, "IP -> %03td", n + (p->u.ip - p));
			break;
		}
		fprintf(stderr, "\n");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xd7eb(%rip), %r15      # 0x102e0
movq 0xb4f4(%rip), %r13      # 0xdff0
leaq 0x660b(%rip), %rbx      # 0x910e
pushq $0xa
popq %rbp
leaq 0xafa3(%rip), %r14      # 0xdab0
xorl %r12d, %r12d
movq (%r15), %r15
testq %r15, %r15
je 0x2c54
cmpq 0xd7b5(%rip), %r15      # 0x102d8
je 0x2c54
movq (%r13), %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x21c0
movl 0x8(%r15), %eax
cmpq $0x5, %rax
jbe 0x2b54
movq (%r13), %rsi
movl %ebp, %edi
callq 0x2150
incq %r12
jmp 0x2b10
leaq 0x64ed(%rip), %rcx      # 0x9048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r13), %rdi
movsd 0x10(%r15), %xmm0
leaq 0x65ae(%rip), %rsi      # 0x9123
movb $0x1, %al
callq 0x21c0
jmp 0x2b44
movq 0x10(%r15), %rax
movq (%r13), %rcx
testq %rax, %rax
jne 0x2c1b
leaq 0x65af(%rip), %rdi      # 0x9145
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
callq 0x22a0
jmp 0x2b44
movq (%r13), %rdi
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
leaq 0x6577(%rip), %rsi      # 0x912d
jmp 0x2c48
movq 0x10(%r15), %rax
leaq 0x6759(%rip), %rdx      # 0x931f
testq %rax, %rax
je 0x2c3d
pushq $-0x10
popq %rcx
leaq 0x10(%rcx), %rdx
cmpq $0x2f0, %rdx            # imm = 0x2F0
je 0x2c36
cmpq %rax, 0x18(%rcx,%r14)
movq %rdx, %rcx
jne 0x2bce
movq (%rdx,%r14), %rdx
jmp 0x2c3d
movq (%r13), %rdi
movq 0x10(%r15), %rax
movq 0x18(%rax), %rdx
leaq 0x653f(%rip), %rsi      # 0x913d
jmp 0x2c48
movq (%r13), %rdi
movl 0x10(%r15), %edx
leaq 0x650c(%rip), %rsi      # 0x911b
xorl %eax, %eax
callq 0x21c0
jmp 0x2b44
subq %r15, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
leaq (%rax,%r12), %rdx
movq %rcx, %rdi
leaq 0x651c(%rip), %rsi      # 0x9150
jmp 0x2c48
leaq 0x66e7(%rip), %rdx      # 0x9324
movq (%r13), %rdi
leaq 0x64ed(%rip), %rsi      # 0x9135
xorl %eax, %eax
callq 0x21c0
jmp 0x2b44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: execute
void
execute(Inst *ip)
{
	Inst *opc;

	if (ip == NULL)
		prog.pc = prog.base;
	else
		prog.pc = ip;
	while (prog.pc->u.opr && !breaking && !continuing) {
		opc = prog.pc;
		prog.pc = prog.pc->next;
		opc->u.opr();
	}
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x2c70
movq 0xd670(%rip), %rdi      # 0x102e0
movq %rdi, 0xd671(%rip)      # 0x102e8
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2ca7
testb $0x1, 0xd68d(%rip)      # 0x10314
jne 0x2ca7
testb $0x1, 0xd688(%rip)      # 0x10318
jne 0x2ca7
movq (%rdi), %rcx
movq %rcx, 0xd64c(%rip)      # 0x102e8
callq *%rax
movq 0xd643(%rip), %rdi      # 0x102e8
jmp 0x2c77
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: code
Inst *
code(Inst inst)
{
	Inst *ip;

	ip = prog.progp->next;
	prog.tail = prog.progp;
	*prog.tail = inst;
	prog.tail->next = ip;
	if (!prog.tail->next) {
		ip = emalloc(sizeof *ip);
		ip->next = NULL;
		prog.tail->next = ip;
	}
	prog.progp = prog.tail->next;
	return prog.tail;
}

// Assembly:
pushq %rax
movq 0xd627(%rip), %rcx      # 0x102d8
movq (%rcx), %rax
movq %rcx, 0xd615(%rip)      # 0x102d0
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rcx)
movq 0x20(%rsp), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, (%rcx)
testq %rax, %rax
jne 0x2cea
pushq $0x18
popq %rdi
callq 0x275c
andq $0x0, (%rax)
movq 0xd5e9(%rip), %rcx      # 0x102d0
movq %rax, (%rcx)
movq %rax, 0xd5e7(%rip)      # 0x102d8
movq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: pop
static Datum
pop(void)
{
	Datum *tmp, d;

	if (stack == NULL)
		yyerror("stack underflow");
	tmp = stack;
	d = *stack;
	stack = stack->next;
	free(tmp);
	return d;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd616(%rip), %rdi      # 0x10330
testq %rdi, %rdi
jne 0x2d34
leaq 0x6707(%rip), %rdi      # 0x942d
xorl %eax, %eax
callq 0x2625
movq 0xd5fc(%rip), %rdi      # 0x10330
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
movq (%rdi), %rax
movq %rax, 0xd5e4(%rip)      # 0x10330
callq 0x2030
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: prevpush
static void
push(Datum d)
{
	Datum *p;

	p = emalloc(sizeof *p);
	*p = d;
	p->next = stack;
	stack = p;
}

// Assembly:
subq $0x18, %rsp
movq 0xd5a2(%rip), %rax      # 0x10348
movq %rax, 0x10(%rsp)
movups 0xd586(%rip), %xmm0     # 0x10338
movaps %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0xd55b(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd551(%rip)      # 0x10330
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: movstr
void
movstr(String *str)
{
	if (str->orig == FINAL) {
		str->count++;
	} else if (str->orig == AUTO) {
		if (str->next)
			str->next->prev = str->prev;
		if (str->prev)
			str->prev->next = str->next;
		else
			autostrings = str->next;
		if (finalstrings)
			finalstrings->prev = str;
		str->next = finalstrings;
		str->prev = NULL;
		str->orig = FINAL;
		str->count = 1;
		finalstrings = str;
	}
}

// Assembly:
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x2e31
testl %eax, %eax
jne 0x2e30
incq 0x20(%rdi)
retq
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2e40
movq %rcx, (%rax)
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xd462(%rip), %rcx      # 0x102b0
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq 0xd44c(%rip), %rax      # 0x102a8
testq %rax, %rax
je 0x2e6d
movq %rdi, (%rax)
movq 0xd43d(%rip), %rax      # 0x102a8
jmp 0x2e6f
xorl %eax, %eax
movq %rax, 0x8(%rdi)
andq $0x0, (%rdi)
andl $0x0, 0x10(%rdi)
movq $0x1, 0x20(%rdi)
movq %rdi, 0xd41e(%rip)      # 0x102a8
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: add
void
add(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val += d2.u.val;
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movq 0x10(%rbx), %r14
movsd 0x8(%rsp), %xmm0
addsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xd446(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd43c(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: popnum
static Datum
popnum(void)
{
	Datum d;
	double v;

	d = pop();
	if (d.isstr) {
		v = atof(d.u.str->s);
		d.u.val = v;
	}
	d.isstr = 0;
	return d;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2d0f
cmpl $0x0, 0x10(%rbx)
je 0x2f1d
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x20c0
movsd %xmm0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: sub
void
sub(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val -= d2.u.val;
	push(d1);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rbx
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xd3b1(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd3a7(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: divd
void
divd(void)
{
	Datum d1, d2;

	d2 = popnum();
	if (d2.u.val == 0.0)
		yyerror("division by zero");
	d1 = popnum();
	d1.u.val /= d2.u.val;
	push(d1);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jne 0x3036
jp 0x3036
leaq 0x612d(%rip), %rdi      # 0x915c
xorl %eax, %eax
callq 0x2625
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
divsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xd2bd(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd2b3(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq