LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Lifo.c
// Function: LifoPush
void LifoPush(
    Lifo *      pLifo,          /* pointer to LIFO buffer */
    void *      pObject)        /* object being added */
{
    assert(pLifo != NULL && pObject != NULL);

    if (pLifo->pointer == pLifo->size) {
        pLifo->size += INCR_SIZE;
        pLifo->pObjects = realloc(pLifo->pObjects,
                                  pLifo->size * sizeof(void *));
    }
    pLifo->pObjects[pLifo->pointer++] = pObject;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2900
cmpq $0x0, -0x10(%rbp)
je 0x2900
jmp 0x2925
leaq 0x5929(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x29cd(%rip), %rdx      # 0x52e0
leaq 0x29bf(%rip), %rcx      # 0x52d9
movl $0x83, %r8d
callq 0x2d10
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2964
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x20, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x10e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Lifo.c
// Function: LifoPeek
void * LifoPeek(
    Lifo *      pLifo,          /* pointer to LIFO buffer */
    int         number)         /* object number to get (1: top) */
{
    assert(pLifo != NULL);
    validate(pLifo->pointer > 0, NULL);
    validate(number > 0 && number <= pLifo->pointer, NULL);

    return pLifo->pObjects[pLifo->pointer - number];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ad8
jmp 0x2afd
leaq 0x5751(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x27e0(%rip), %rdx      # 0x52cb
leaq 0x27e7(%rip), %rcx      # 0x52d9
movl $0xc1, %r8d
callq 0x2d10
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x2b0c
jmp 0x2bc0
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x2b18
jmp 0x2b3d
leaq 0x5711(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x27d6(%rip), %rdx      # 0x5301
leaq 0x27a7(%rip), %rcx      # 0x52d9
movl $0xc2, %r8d
callq 0x2d10
leaq 0x56ec(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x2bb3
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x56c2(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x2ba8
leaq 0x5692(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x2bb1
movq -0x20(%rbp), %rdi
callq 0x1040
jmp 0x2bb3
movq $0x0, -0x8(%rbp)
jmp 0x2cac
cmpl $0x0, -0x14(%rbp)
jle 0x2bd7
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x2bd7
jmp 0x2c90
cmpl $0x0, -0x14(%rbp)
jle 0x2beb
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jg 0x2beb
jmp 0x2c10
leaq 0x563e(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2716(%rip), %rdx      # 0x5314
leaq 0x26d4(%rip), %rcx      # 0x52d9
movl $0xc3, %r8d
callq 0x2d10
leaq 0x5619(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x2c86
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x55ef(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x2c7b
leaq 0x55bf(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x2c84
movq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x2c86
movq $0x0, -0x8(%rbp)
jmp 0x2cac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Assert.c
// Function: AssertAction
void AssertAction(
    Context *   pC,             /* pointer to thread exception context */
    int         doAbort,        /* flag if abort() must be invoked */
    char *      expr,           /* failed expression string */
    char *      file,           /* name of source file where failed */
    int         line)           /* source file line number */
{
    Scope       scope = ExceptGetScope(pC);

    if (scope == TRY || scope == CATCH || scope == FINALLY)
    {
        if (pC == NULL)
            pC = ExceptGetContext(NULL);        /* should never return NULL */

        ExceptThrow(pC, FailedAssertion, expr, file, line);
    }
    else
    {
        fprintf(stderr, "Assertion failed %s: %s, file \"%s\", line %d.\n",
                doAbort ? "" : "(no abort)", expr, file, line);

        if (doAbort)
            abort();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17b0
movl %eax, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
je 0x2d49
cmpl $0x2, -0x28(%rbp)
je 0x2d49
cmpl $0x3, -0x28(%rbp)
jne 0x2d7b
cmpq $0x0, -0x8(%rbp)
jne 0x2d5d
xorl %eax, %eax
movl %eax, %edi
callq 0x1810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq 0x53ac(%rip), %rsi      # 0x8120
callq 0x1dd0
jmp 0x2dc4
movq 0x5276(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movl -0xc(%rbp), %ecx
leaq 0x25da(%rip), %rdx      # 0x5369
leaq 0x25d2(%rip), %rax      # 0x5368
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
leaq 0x258b(%rip), %rsi      # 0x533b
movb $0x0, %al
callq 0x10a0
cmpl $0x0, -0xc(%rbp)
je 0x2dc2
callq 0x1050
jmp 0x2dc4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Alloc.c
// Function: AllocCalloc
void * AllocCalloc(
    Context *   pC,             /* pointer to thread exception context */
    int         number,         /* number of elements */
    int         size,           /* size of one element */
    char *      file,           /* name of source file where invoked */
    int         line)           /* source file line number */
{
    void *      pMem;

    pMem = calloc(number, size);
    if (pMem == NULL)
        ExceptThrow(pC, OutOfMemoryError, NULL, file, line);

    return pMem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movslq -0xc(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x1080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2e1e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
leaq 0x52eb(%rip), %rsi      # 0x8100
xorl %eax, %eax
movl %eax, %edx
callq 0x1dd0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Alloc.c
// Function: AllocMalloc
void * AllocMalloc(
    Context *   pC,             /* pointer to thread exception context */
    int         size,           /* size of one element */
    char *      file,           /* name of source file where invoked */
    int         line)           /* source file line number */
{
    void *      pMem;

    pMem = malloc(size);
    if (pMem == NULL)
        ExceptThrow(pC, OutOfMemoryError, NULL, file, line);

    return pMem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movslq -0xc(%rbp), %rdi
callq 0x10d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2e76
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
leaq 0x5293(%rip), %rsi      # 0x8100
xorl %eax, %eax
movl %eax, %edx
callq 0x1dd0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Alloc.c
// Function: AllocRealloc
void * AllocRealloc(
    Context *   pC,             /* pointer to thread exception context */
    void *      p,              /* pointer to original block */
    int         size,           /* size of one element */
    char *      file,           /* name of source file where invoked */
    int         line)           /* source file line number */
{
    void *      pMem;

    pMem = realloc(p, size);
    if (pMem == NULL)
        ExceptThrow(pC, OutOfMemoryError, NULL, file, line);

    return pMem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x10e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2ecf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq 0x523a(%rip), %rsi      # 0x8100
xorl %eax, %eax
movl %eax, %edx
callq 0x1dd0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashCreate
Hash * HashCreate(void)
{
    Hash *      pHash;
    int         n;

    pHash = malloc(sizeof(Hash));

    pHash->count = 0;

    pHash->pNodeLists = malloc(HASH_SIZE * sizeof(List *));
    for (n = 0; n < HASH_SIZE; n++)
        pHash->pNodeLists[n] = ListCreate();

    return pHash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x10d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x800, %edi            # imm = 0x800
callq 0x10d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x2f47
callq 0x3420
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f1c
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashDestroy
void HashDestroy(
    Hash *      pHash)          /* pointer to hash table */
{
    int         n;

    assert(pHash != NULL);

    for (n = 0; n < HASH_SIZE; n++)
        ListDestroyData(pHash->pNodeLists[n]);

    free(pHash->pNodeLists);
    free(pHash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2f75
jmp 0x2f9a
leaq 0x52b4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x23ec(%rip), %rdx      # 0x5374
leaq 0x23f3(%rip), %rcx      # 0x5382
movl $0x58, %r8d
callq 0x2d10
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x2fc9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3520
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fa1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashDestroyData
void HashDestroyData(
    Hash *      pHash)          /* pointer to hash table */
{
    int         n;

    assert(pHash != NULL);

    for (n = 0; n < HASH_SIZE; n++)
    {
        HashNode *      pNode;

        pNode = ListHead(pHash->pNodeLists[n]);
        while (pNode != NULL)
        {
            free(pNode->pData);

            pNode = ListNext(pHash->pNodeLists[n]);
        }

        ListDestroyData(pHash->pNodeLists[n]);
    }

    free(pHash->pNodeLists);
    free(pHash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3005
jmp 0x302a
leaq 0x5224(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x235c(%rip), %rdx      # 0x5374
leaq 0x2363(%rip), %rcx      # 0x5382
movl $0x78, %r8d
callq 0x2d10
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x309e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3fe0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x307f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4150
movq %rax, -0x18(%rbp)
jmp 0x3052
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3520
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3031
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashLookup
void * HashLookup(
    Hash *      pHash,          /* pointer to hash table */
    int         key)            /* key number */
{
    List *      nodeList;
    HashNode *  pNode;

    assert(pHash != NULL);

    nodeList = pHash->pNodeLists[HashValue(pHash, key)];

    pNode = ListHead(nodeList);
    while (pNode != NULL)
    {
        if (pNode->key == key)
        {
            return pNode->pData;
        }

        pNode = ListNext(nodeList);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x30d8
jmp 0x30fd
leaq 0x5151(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2289(%rip), %rdx      # 0x5374
leaq 0x2290(%rip), %rcx      # 0x5382
movl $0xd5, %r8d
callq 0x2d10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3180
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3161
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x3152
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3169
movq -0x20(%rbp), %rdi
callq 0x4150
movq %rax, -0x28(%rbp)
jmp 0x3132
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashValue
static int HashValue(
    Hash *      pHash,          /* pointer to hash table */
    unsigned    key)            /* key number */
{
    int value;

    assert(pHash != NULL);

    value = (HASH_SIZE * ((key * 40503) & 65535)) >> 16;
    
    if (value >= HASH_SIZE || value < 0)
        fprintf(stderr, "INVALID HashValue: %d\n", value);

    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3198
jmp 0x31bd
leaq 0x5091(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x21c9(%rip), %rdx      # 0x5374
leaq 0x21d0(%rip), %rcx      # 0x5382
movl $0xb3, %r8d
callq 0x2d10
imull $0x9e37, -0xc(%rbp), %eax # imm = 0x9E37
andl $0xffff, %eax           # imm = 0xFFFF
shll $0x8, %eax
shrl $0x10, %eax
movl %eax, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jge 0x31e1
cmpl $0x0, -0x10(%rbp)
jge 0x31fc
movq 0x4e10(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0x219f(%rip), %rsi      # 0x5394
movb $0x0, %al
callq 0x10a0
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashAdd
void HashAdd(
    Hash *      pHash,          /* pointer to hash table */
    int         key,            /* key number */
    void *      pData)          /* user data to be stored */
{
    HashNode *  pNode;

    assert(pHash != NULL);
    validate(pData != 0, NOTHING);

    pNode = malloc(sizeof(HashNode));
    pNode->key   = key;
    pNode->pData = pData;

    ListAddHead(pHash->pNodeLists[HashValue(pHash, key)], pNode);
    pHash->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x322c
jmp 0x3251
leaq 0x4ffd(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2135(%rip), %rdx      # 0x5374
leaq 0x213c(%rip), %rcx      # 0x5382
movl $0x101, %r8d            # imm = 0x101
callq 0x2d10
cmpq $0x0, -0x18(%rbp)
je 0x325a
jmp 0x328a
cmpq $0x0, -0x18(%rbp)
je 0x3263
jmp 0x3288
leaq 0x4fc6(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2113(%rip), %rdx      # 0x5389
leaq 0x2105(%rip), %rcx      # 0x5382
movl $0x102, %r8d            # imm = 0x102
callq 0x2d10
jmp 0x32e7
movl $0x10, %edi
callq 0x10d0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3180
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x35c0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/Hash.c
// Function: HashRemove
void * HashRemove(
    Hash *      pHash,          /* pointer to hash table */
    int         key)            /* key number */
{
    List *      nodeList;
    HashNode *  pNode;
    void *      pData;

    assert(pHash != NULL);

    nodeList = pHash->pNodeLists[HashValue(pHash, key)];

    pNode = ListHead(nodeList);
    while (pNode != NULL)
    {
        if (pNode->key == key)
        {
            ListRemoveLast(nodeList);
            pData = pNode->pData;
            free(pNode);
            pHash->count--;

            return pData;
        }

        pNode = ListNext(nodeList);
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3308
jmp 0x332d
leaq 0x4f21(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x2059(%rip), %rdx      # 0x5374
leaq 0x2060(%rip), %rcx      # 0x5382
movl $0x127, %r8d            # imm = 0x127
callq 0x2d10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3180
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x33b8
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x33a9
movq -0x20(%rbp), %rdi
callq 0x3e50
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x33c0
movq -0x20(%rbp), %rdi
callq 0x4150
movq %rax, -0x28(%rbp)
jmp 0x3362
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListCreate
List * ListCreate(void)
    {
        List *      pList;

        pList = malloc(sizeof(List));

        pList->pHead = malloc(sizeof(ListNode));

        pList->pHead->pNext = pList->pHead->pPrev = pList->pHead;

        pList->pNodeLast = NULL;
        pList->count = 0;

        return pList;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x10d0
movq %rax, -0x8(%rbp)
movl $0x18, %edi
callq 0x10d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListDestroy
void ListDestroy(
        List *      pList)          /* pointer to list */
    {
        ListNode *  pNode;

        assert(pList != NULL);

        pNode = pList->pHead->pNext;
        while (pNode != pList->pHead)
        {
            ListNode *      pNext;

            pNext = pNode->pNext;
            free(pNode);
            pNode = pNext;
        }

        free(pList->pHead);
        free(pList);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34a5
jmp 0x34ca
leaq 0x4d84(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1f04(%rip), %rdx      # 0x53bc
leaq 0x1f0b(%rip), %rcx      # 0x53ca
movl $0x82, %r8d
callq 0x2d10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x3503
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x34d8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListDestroyData
void ListDestroyData(
        List *      pList)          /* pointer to list */
    {
        ListNode *  pNode;

        assert(pList != NULL);

        pNode = pList->pHead->pNext;
        while (pNode != pList->pHead)
        {
            ListNode *      pNext;

            pNext = pNode->pNext;
            free(pNode->pData);
            free(pNode);
            pNode = pNext;
        }

        free(pList->pHead);
        free(pList);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3535
jmp 0x355a
leaq 0x4cf4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1e74(%rip), %rdx      # 0x53bc
leaq 0x1e7b(%rip), %rcx      # 0x53ca
movl $0xa8, %r8d
callq 0x2d10
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x35a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3568
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListAddHead
void ListAddHead(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

        assert(pList != NULL);

        pNode = malloc(sizeof(ListNode));

        pNode->pData = pData;
        (pNode->pNext = pList->pHead->pNext)->pPrev = pNode;
        (pList->pHead->pNext = pNode)->pPrev = pList->pHead;

        pList->pNodeLast = pNode;
        pList->count++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x35d9
jmp 0x35fe
leaq 0x4c50(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1dd0(%rip), %rdx      # 0x53bc
leaq 0x1dd7(%rip), %rcx      # 0x53ca
movl $0xd0, %r8d
callq 0x2d10
movl $0x18, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListAddTail
void ListAddTail(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

        assert(pList != NULL);

        pNode = malloc(sizeof(ListNode));

        pNode->pData = pData;
        (pNode->pPrev = pList->pHead->pPrev)->pNext = pNode;
        (pList->pHead->pPrev = pNode)->pNext = pList->pHead;

        pList->pNodeLast = pNode;
        pList->count++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3689
jmp 0x36ae
leaq 0x4ba0(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1d20(%rip), %rdx      # 0x53bc
leaq 0x1d27(%rip), %rcx      # 0x53ca
movl $0xf3, %r8d
callq 0x2d10
movl $0x18, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListAddBefore
void ListAddBefore(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

        assert(pList != NULL);
        validate(pList->pNodeLast != NULL, NOTHING);

        pNode = malloc(sizeof(ListNode));

        pNode->pData = pData;
        (pNode->pPrev = pList->pNodeLast->pPrev)->pNext = pNode;
        (pList->pNodeLast->pPrev = pNode)->pNext = pList->pNodeLast;

        pList->pNodeLast = pNode;
        pList->count++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3739
jmp 0x375e
leaq 0x4af0(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1c70(%rip), %rdx      # 0x53bc
leaq 0x1c77(%rip), %rcx      # 0x53ca
movl $0x11b, %r8d            # imm = 0x11B
callq 0x2d10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x376b
jmp 0x379f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3778
jmp 0x379d
leaq 0x4ab1(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1c46(%rip), %rdx      # 0x53d1
leaq 0x1c38(%rip), %rcx      # 0x53ca
movl $0x11c, %r8d            # imm = 0x11C
callq 0x2d10
jmp 0x3808
movl $0x18, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListAddAfter
void ListAddAfter(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

        assert(pList != NULL);
        validate(pList->pNodeLast != NULL, NOTHING);

        pNode = malloc(sizeof(ListNode));

        pNode->pData = pData;
        (pNode->pNext = pList->pNodeLast->pNext)->pPrev = pNode;
        (pList->pNodeLast->pNext = pNode)->pPrev = pList->pNodeLast;

        pList->pNodeLast = pNode;
        pList->count++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3829
jmp 0x384e
leaq 0x4a00(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1b80(%rip), %rdx      # 0x53bc
leaq 0x1b87(%rip), %rcx      # 0x53ca
movl $0x144, %r8d            # imm = 0x144
callq 0x2d10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x385b
jmp 0x388f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3868
jmp 0x388d
leaq 0x49c1(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1b56(%rip), %rdx      # 0x53d1
leaq 0x1b48(%rip), %rcx      # 0x53ca
movl $0x145, %r8d            # imm = 0x145
callq 0x2d10
jmp 0x38f7
movl $0x18, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListRemoveHead
void * ListRemoveHead(
        List *      pList)          /* pointer to list */
    {
        void *      pData;
        ListNode *  pNode;

        assert(pList != NULL);
        validate(pList->count > 0, NULL);

        pNode = pList->pHead->pNext;

        pData = pNode->pData;
        (pList->pHead->pNext = pNode->pNext)->pPrev = pList->pHead;
        free(pNode);

        pList->pNodeLast = NULL;
        pList->count--;

        return pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3915
jmp 0x393a
leaq 0x4914(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1a94(%rip), %rdx      # 0x53bc
leaq 0x1a9b(%rip), %rcx      # 0x53ca
movl $0x169, %r8d            # imm = 0x169
callq 0x2d10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3949
jmp 0x39fa
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3955
jmp 0x397a
leaq 0x48d4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1a88(%rip), %rdx      # 0x53f0
leaq 0x1a5b(%rip), %rcx      # 0x53ca
movl $0x16a, %r8d            # imm = 0x16A
callq 0x2d10
leaq 0x48af(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x39f0
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x4885(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x39e5
leaq 0x4855(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x39ee
movq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x39f0
movq $0x0, -0x8(%rbp)
jmp 0x3a5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListRemoveTail
void * ListRemoveTail(
        List *      pList)          /* pointer to list */
    {
        void *      pData;
        ListNode *  pNode;

        assert(pList != NULL);
        validate(pList->count > 0, NULL);

        pNode = pList->pHead->pPrev;

        pData = pNode->pData;
        (pList->pHead->pPrev = pNode->pPrev)->pNext = pList->pHead;
        free(pNode);

        pList->pNodeLast = NULL;
        pList->count--;

        return pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3a85
jmp 0x3aaa
leaq 0x47a4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1924(%rip), %rdx      # 0x53bc
leaq 0x192b(%rip), %rcx      # 0x53ca
movl $0x190, %r8d            # imm = 0x190
callq 0x2d10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3ab9
jmp 0x3b6a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x3ac5
jmp 0x3aea
leaq 0x4764(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1918(%rip), %rdx      # 0x53f0
leaq 0x18eb(%rip), %rcx      # 0x53ca
movl $0x191, %r8d            # imm = 0x191
callq 0x2d10
leaq 0x473f(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x3b60
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x4715(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x3b55
leaq 0x46e5(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x3b5e
movq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x3b60
movq $0x0, -0x8(%rbp)
jmp 0x3bcc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq %rax, 0x8(%rdx)
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x1040
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListRemoveLast
void * ListRemoveLast(
        List *      pList)          /* pointer to list */
    {
        void *      pData;
        ListNode *  pNext;

        assert(pList != NULL);
        validate(pList->pNodeLast != NULL, NULL);

        pData = pList->pNodeLast->pData;

        pNext = pList->pNodeLast->pNext;

        pList->pNodeLast->pNext->pPrev = pList->pNodeLast->pPrev;
        pList->pNodeLast->pPrev->pNext = pList->pNodeLast->pNext;
        free(pList->pNodeLast);

        pList->pNodeLast = pNext;
        pList->count--;

        return pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3e65
jmp 0x3e8a
leaq 0x43c4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1544(%rip), %rdx      # 0x53bc
leaq 0x154b(%rip), %rcx      # 0x53ca
movl $0x1e5, %r8d            # imm = 0x1E5
callq 0x2d10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3e9a
jmp 0x3f4f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ea7
jmp 0x3ecc
leaq 0x4382(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1517(%rip), %rdx      # 0x53d1
leaq 0x1509(%rip), %rcx      # 0x53ca
movl $0x1e6, %r8d            # imm = 0x1E6
callq 0x2d10
leaq 0x435d(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x3f42
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x4333(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x3f37
leaq 0x4303(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x3f40
movq -0x28(%rbp), %rdi
callq 0x1040
jmp 0x3f42
movq $0x0, -0x8(%rbp)
jmp 0x3fd1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListHead
void * ListHead(
        List *      pList)          /* pointer to list */
    {
        assert(pList != NULL);

        if (pList->count == 0)
            return NULL;
        else
            return 0, (pList->pNodeLast = pList->pHead->pNext)->pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3ff5
jmp 0x401a
leaq 0x4234(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x13b4(%rip), %rdx      # 0x53bc
leaq 0x13bb(%rip), %rcx      # 0x53ca
movl $0x20a, %r8d            # imm = 0x20A
callq 0x2d10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x402e
movq $0x0, -0x8(%rbp)
jmp 0x4048
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListTail
void * ListTail(
        List *      pList)          /* pointer to list */
    {
        assert(pList != NULL);

        if (pList->count == 0)
            return NULL;
        else
            return 0, (pList->pNodeLast = pList->pHead->pPrev)->pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4075
jmp 0x409a
leaq 0x41b4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1334(%rip), %rdx      # 0x53bc
leaq 0x133b(%rip), %rcx      # 0x53ca
movl $0x226, %r8d            # imm = 0x226
callq 0x2d10
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x40ae
movq $0x0, -0x8(%rbp)
jmp 0x40c9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListLast
void * ListLast(
        List *      pList)          /* pointer to list */
    {
        assert(pList != NULL);

        if (pList->pNodeLast == NULL)
            return NULL;
        else
            return pList->pNodeLast->pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x40f5
jmp 0x411a
leaq 0x4134(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x12b4(%rip), %rdx      # 0x53bc
leaq 0x12bb(%rip), %rcx      # 0x53ca
movl $0x245, %r8d            # imm = 0x245
callq 0x2d10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x412f
movq $0x0, -0x8(%rbp)
jmp 0x413f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListNext
void * ListNext(
        List *      pList)          /* pointer to list */
    {
        assert(pList != NULL);
        validate(pList->pNodeLast != NULL, NULL);

        if ((pList->pNodeLast = pList->pNodeLast->pNext) == pList->pHead)
        {
            pList->pNodeLast = NULL;
            return NULL;
        }
        else        
            return pList->pNodeLast->pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4165
jmp 0x418a
leaq 0x40c4(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1244(%rip), %rdx      # 0x53bc
leaq 0x124b(%rip), %rcx      # 0x53ca
movl $0x264, %r8d            # imm = 0x264
callq 0x2d10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x419a
jmp 0x424c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x41a7
jmp 0x41cc
leaq 0x4082(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x1217(%rip), %rdx      # 0x53d1
leaq 0x1209(%rip), %rcx      # 0x53ca
movl $0x265, %r8d            # imm = 0x265
callq 0x2d10
leaq 0x405d(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x4242
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x4033(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x20(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x4237
leaq 0x4003(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x4240
movq -0x18(%rbp), %rdi
callq 0x1040
jmp 0x4242
movq $0x0, -0x8(%rbp)
jmp 0x428e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x427e
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x428e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListPrev
void * ListPrev(
        List *      pList)          /* pointer to list */
    {
        assert(pList != NULL);
        validate(pList->pNodeLast != NULL, NULL);

        if ((pList->pNodeLast = pList->pNodeLast->pPrev) == pList->pHead)
        {
            pList->pNodeLast = NULL;
            return NULL;
        }
        else        
            return pList->pNodeLast->pData;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42b5
jmp 0x42da
leaq 0x3f74(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x10f4(%rip), %rdx      # 0x53bc
leaq 0x10fb(%rip), %rcx      # 0x53ca
movl $0x287, %r8d            # imm = 0x287
callq 0x2d10
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42ea
jmp 0x439c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42f7
jmp 0x431c
leaq 0x3f32(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0x10c7(%rip), %rdx      # 0x53d1
leaq 0x10b9(%rip), %rcx      # 0x53ca
movl $0x288, %r8d            # imm = 0x288
callq 0x2d10
leaq 0x3f0d(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x17b0
cmpl $-0x1, %eax
je 0x4392
movl $0xc8, %edi
callq 0x10d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x3ee3(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x1810
movq -0x20(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x1a0(%rax)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
cmpl $0x0, %eax
jne 0x4387
leaq 0x3eb3(%rip), %rax      # 0x8230
movq (%rax), %rdi
callq 0x2470
jmp 0x4390
movq -0x18(%rbp), %rdi
callq 0x1040
jmp 0x4392
movq $0x0, -0x8(%rbp)
jmp 0x43df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rax, 0x8(%rcx)
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x43cf
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x43df
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/meaning-matters[P]Except/List.c
// Function: ListFind
void * ListFind(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

        assert(pList != NULL);

        pNode = pList->pHead->pNext;
        while (pNode != pList->pHead && pNode->pData != pData)
            pNode = pNode->pNext;

        if (pNode->pData == pData)
        {
            pList->pNodeLast = pNode;
            return pData;
        }
        else
            return NULL;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4459
jmp 0x447e
leaq 0x3dd0(%rip), %rax      # 0x8230
movq (%rax), %rdi
xorl %esi, %esi
leaq 0xf50(%rip), %rdx       # 0x53bc
leaq 0xf57(%rip), %rcx       # 0x53ca
movl $0x2c1, %r8d            # imm = 0x2C1
callq 0x2d10
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x21(%rbp)
je 0x44b0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x44b9
jmp 0x44c6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x448c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x44ea
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x44f2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pencode-lab[P]Shoit/shoit.c
// Function: shoit_show_copyright
void shoit_show_copyright()
{
    fprintf(stderr,"\r\n");
    fprintf(stderr,"%s\r\n\r\n",VERSION);
    fprintf(stderr,"***************Warning, Warning, Warning************************\r\n\r\n");
    fprintf(stderr,"%s","SHOIT - A toolkit for High Performance Data transmission.\n");
    fprintf(stderr,"%s","Copyright (C) 2019 Pencode.net\r\n\r\n");
    fprintf(stderr,"*****************************************************************\r\n\r\n");

    fprintf(stderr,"\r\n\r\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x95dd(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x69e2(%rip), %rsi      # 0x9407
movb $0x0, %al
callq 0x2250
movq 0x95c5(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x68b9(%rip), %rsi      # 0x92f6
leaq 0x68b9(%rip), %rdx      # 0x92fd
movb $0x0, %al
callq 0x2250
movq 0x95a6(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x68c2(%rip), %rsi      # 0x931e
movb $0x0, %al
callq 0x2250
movq 0x958e(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x68ef(%rip), %rsi      # 0x9363
leaq 0x68eb(%rip), %rdx      # 0x9366
movb $0x0, %al
callq 0x2250
movq 0x956f(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x68d0(%rip), %rsi      # 0x9363
leaq 0x6907(%rip), %rdx      # 0x93a1
movb $0x0, %al
callq 0x2250
movq 0x9550(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x6912(%rip), %rsi      # 0x93c4
movb $0x0, %al
callq 0x2250
movq 0x9538(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x693b(%rip), %rsi      # 0x9405
movb $0x0, %al
callq 0x2250
popq %rbp
retq
nopw %cs:(%rax,%rax)