LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Except.c
// Function: ExceptThrowSignal
static void ExceptThrowSignal(
    int         number)         /* signal number */
{
    ClassRef    class;

    ExceptPrintDebug(pC, "ExceptThrowSignal");

    switch (number)
    {
    case SIGABRT: class = AbnormalTermination; break;
    case SIGFPE:  class = ArithmeticException; break;
    case SIGILL:  class = IllegalInstruction;  break;
    case SIGSEGV: class = SegmentationFault;   break;
#ifdef  SIGBUS
    case SIGBUS:  class = BusError;            break;
#endif
    }

    signal(number, ExceptThrowSignal);

    class->signalNumber = number;       /* redundant after first time */
        
    ExceptThrow(NULL, class, NULL, "?", 0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x4(%rbx), %eax
cmpl $0x7, %eax
ja 0x2082
movl %eax, %eax
leaq 0x4d34(%rip), %rcx      # 0x6db0
movq (%rcx,%rax,8), %r14
jmp 0x2089
leaq 0x50d7(%rip), %r14      # 0x7160
leaq -0x2b(%rip), %rsi       # 0x2065
movl %ebx, %edi
callq 0x1090
movl %ebx, 0x18(%r14)
leaq 0x21ad(%rip), %rcx      # 0x424f
xorl %edi, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %r8d, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a40
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Lifo.c
// Function: LifoCreate
Lifo * LifoCreate(void)
{
    Lifo *      pLifo;

    pLifo = malloc(sizeof(Lifo));
    pLifo->pObjects = malloc(INIT_SIZE * sizeof(void *));
    pLifo->size = INIT_SIZE;
    pLifo->pointer = 0;
    return pLifo;
}

// Assembly:
pushq %rbx
pushq $0x10
popq %rdi
callq 0x10c0
movq %rax, %rbx
movl $0x100, %edi            # imm = 0x100
callq 0x10c0
movq %rax, (%rbx)
movq $0x20, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/Lifo.c
// Function: LifoDestroyData
void LifoDestroyData(
    Lifo *      pLifo)          /* pointer to LIFO buffer */
{
    assert(pLifo != NULL);

    while(pLifo->pointer > 0)
        free(pLifo->pObjects[pLifo->pointer--]);

    free(pLifo->pObjects);
    free(pLifo);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2158
leaq 0x5105(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x2176(%rip), %rdx      # 0x42ab
leaq 0x217d(%rip), %rcx      # 0x42b9
pushq $0x67
popq %r8
xorl %esi, %esi
callq 0x23ec
jmp 0x2158
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
movq (%rdi,%rax,8), %rdi
callq 0x1040
movslq 0xc(%rbx), %rax
movq (%rbx), %rdi
testq %rax, %rax
jg 0x2149
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x21b1
leaq 0x509d(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x2123(%rip), %rdx      # 0x42c0
leaq 0x2115(%rip), %rcx      # 0x42b9
xorl %esi, %esi
movl $0x83, %r8d
callq 0x23ec
movl 0xc(%r14), %ecx
movq (%r14), %rax
cmpl 0x8(%r14), %ecx
jne 0x21e0
movslq %ecx, %rcx
leaq 0x20(%rcx), %rdx
movl %edx, 0x8(%r14)
leaq 0x100(,%rcx,8), %rsi
movq %rax, %rdi
callq 0x10d0
movq %rax, (%r14)
movl 0xc(%r14), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xc(%r14)
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x22f1
leaq 0x4f5d(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1fce(%rip), %rdx      # 0x42ab
leaq 0x1fd5(%rip), %rcx      # 0x42b9
xorl %esi, %esi
movl $0xc1, %r8d
callq 0x23ec
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x232e
testl %ebp, %ebp
setg %cl
subl %ebp, %eax
setge %dl
testb %dl, %cl
jne 0x239a
leaq 0x4f1f(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1fd9(%rip), %rdx      # 0x42f4
leaq 0x1f97(%rip), %rcx      # 0x42b9
xorl %ebx, %ebx
movl %ebx, %esi
movl $0xc3, %r8d
jmp 0x2350
leaq 0x4efb(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1fa2(%rip), %rdx      # 0x42e1
leaq 0x1f73(%rip), %rcx      # 0x42b9
xorl %ebx, %ebx
movl %ebx, %esi
movl $0xc2, %r8d
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x23a5
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x23a9
movq %rbx, %rdi
callq 0x1040
jmp 0x23b1
movq (%rbx), %rcx
cltq
movq (%rcx,%rax,8), %rax
jmp 0x23b3
movl %ebx, %eax
jmp 0x23b3
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0x1618
decl %eax
cmpl $0x2, %eax
ja 0x243d
testq %r12, %r12
jne 0x241d
xorl %edi, %edi
callq 0x164c
movq %rax, %r12
leaq 0x4cfc(%rip), %rsi      # 0x7120
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1a40
movq 0x4bb4(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
testl %ebp, %ebp
leaq 0x1ef9(%rip), %rax      # 0x4349
leaq 0x1ef1(%rip), %rdx      # 0x4348
cmoveq %rax, %rdx
leaq 0x1eb9(%rip), %rsi      # 0x431b
movq %r15, %rcx
movq %r14, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq 0x10a0
testl %ebp, %ebp
jne 0x247f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r12
movslq %esi, %rdi
movslq %edx, %rsi
callq 0x1080
movq %rax, %r15
testq %rax, %rax
jne 0x24bf
leaq 0x4c51(%rip), %rsi      # 0x7100
movq %r12, %rdi
xorl %edx, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1a40
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r12
movslq %esi, %rdi
callq 0x10c0
movq %rax, %r15
testq %rax, %rax
jne 0x2505
leaq 0x4c0b(%rip), %rsi      # 0x7100
movq %r12, %rdi
xorl %edx, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1a40
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %rax
movq %rdi, %r12
movslq %edx, %rsi
movq %rax, %rdi
callq 0x10d0
movq %rax, %r15
testq %rax, %rax
jne 0x2552
leaq 0x4bbe(%rip), %rsi      # 0x7100
movq %r12, %rdi
xorl %edx, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1a40
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq $0x10
popq %rdi
callq 0x10c0
movq %rax, %rbx
andl $0x0, 0x8(%rax)
movl $0x800, %edi            # imm = 0x800
callq 0x10c0
movq %rax, %r14
movq %rax, (%rbx)
xorl %r15d, %r15d
cmpq $0x100, %r15            # imm = 0x100
je 0x25a2
callq 0x286c
movq %rax, (%r14,%r15,8)
incq %r15
jmp 0x258b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x25da
leaq 0x4c72(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1d8c(%rip), %rdx      # 0x4354
leaq 0x1d93(%rip), %rcx      # 0x4362
pushq $0x58
popq %r8
xorl %esi, %esi
callq 0x23ec
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq $0x100, %r14            # imm = 0x100
je 0x25f7
movq (%rdi,%r14,8), %rdi
callq 0x2908
incq %r14
jmp 0x25dd
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x263a
leaq 0x4c12(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1d2c(%rip), %rdx      # 0x4354
leaq 0x1d33(%rip), %rcx      # 0x4362
pushq $0x78
popq %r8
xorl %esi, %esi
callq 0x23ec
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq $0x100, %r14            # imm = 0x100
je 0x267e
movq (%rdi,%r14,8), %rdi
callq 0x2f23
testq %rax, %rax
je 0x266d
movq (%rax), %rdi
callq 0x1040
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2ff5
jmp 0x2652
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2908
incq %r14
jmp 0x263d
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x26c6
leaq 0x4b88(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1ca2(%rip), %rdx      # 0x4354
leaq 0x1ca9(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0xd5, %r8d
callq 0x23ec
movq (%r14), %rax
imull $0x9e3700, %ebx, %ecx   # imm = 0x9E3700
shrl $0xd, %ecx
andl $0x7f8, %ecx            # imm = 0x7F8
movq (%rax,%rcx), %r15
movq %r15, %rdi
callq 0x2f23
xorl %r14d, %r14d
testq %rax, %rax
je 0x26fe
cmpl %ebx, 0x8(%rax)
je 0x26fb
movq %r15, %rdi
callq 0x2ff5
jmp 0x26e7
movq (%rax), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x273d
leaq 0x4b11(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1c2b(%rip), %rdx      # 0x4354
leaq 0x1c32(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x101, %r8d            # imm = 0x101
callq 0x23ec
testq %r14, %r14
je 0x2776
pushq $0x10
popq %rdi
callq 0x10c0
movl %ebp, 0x8(%rax)
movq %r14, (%rax)
movq (%rbx), %rcx
imull $0x9e3700, %ebp, %edx   # imm = 0x9E3700
shrl $0xd, %edx
andl $0x7f8, %edx            # imm = 0x7F8
movq (%rcx,%rdx), %rdi
movq %rax, %rsi
callq 0x2973
incl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4ab3(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1be2(%rip), %rdx      # 0x4369
leaq 0x1bd4(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x102, %r8d            # imm = 0x102
popq %rbx
popq %r14
popq %rbp
jmp 0x23ec
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x27d6
leaq 0x4a78(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1b92(%rip), %rdx      # 0x4354
leaq 0x1b99(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x127, %r8d            # imm = 0x127
callq 0x23ec
movq (%rbx), %rax
imull $0x9e3700, %ebp, %ecx   # imm = 0x9E3700
shrl $0xd, %ecx
andl $0x7f8, %ecx            # imm = 0x7F8
movq (%rax,%rcx), %r15
movq %r15, %rdi
callq 0x2f23
movq %rax, %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0x282a
cmpl %ebp, 0x8(%r12)
je 0x2813
movq %r15, %rdi
callq 0x2ff5
movq %rax, %r12
jmp 0x27fa
movq %r15, %rdi
callq 0x2e45
movq (%r12), %r14
movq %r12, %rdi
callq 0x1040
decl 0x8(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
pushq $0x18
popq %rbx
movq %rbx, %rdi
callq 0x10c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x10c0
movq %rax, (%r14)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x8(%r14)
andl $0x0, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x28d6
leaq 0x4978(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1ab2(%rip), %rdx      # 0x4374
leaq 0x1ab9(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x82, %r8d
callq 0x23ec
movq (%rbx), %rdi
movq (%rdi), %rax
cmpq %rdi, %rax
je 0x28f4
movq (%rax), %r14
movq %rax, %rdi
callq 0x1040
movq (%rbx), %rdi
movq %r14, %rax
jmp 0x28dc
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x293a
leaq 0x4914(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1a4e(%rip), %rdx      # 0x4374
leaq 0x1a55(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xa8, %r8d
callq 0x23ec
movq (%rbx), %rdi
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x2961
movq (%r14), %r15
movq 0x10(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq (%rbx), %rdi
movq %r15, %r14
jmp 0x2940
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x29a7
leaq 0x48a7(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x19e1(%rip), %rdx      # 0x4374
leaq 0x19e8(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xd0, %r8d
callq 0x23ec
pushq $0x18
popq %rdi
callq 0x10c0
movq %r14, 0x10(%rax)
movq (%rbx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%rbx)
incl 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2a0a
leaq 0x4844(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x197e(%rip), %rdx      # 0x4374
leaq 0x1985(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xf3, %r8d
callq 0x23ec
pushq $0x18
popq %rdi
callq 0x10c0
movq %r14, 0x10(%rax)
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rdx)
movq %rax, 0x8(%rcx)
movq %rcx, (%rax)
movq %rax, 0x8(%rbx)
incl 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2a6f
leaq 0x47df(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1919(%rip), %rdx      # 0x4374
leaq 0x1920(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x11b, %r8d            # imm = 0x11B
callq 0x23ec
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2aa3
pushq $0x18
popq %rdi
callq 0x10c0
movq %r14, 0x10(%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %rax, 0x8(%r15)
movq %r15, (%rax)
movq %rax, 0x8(%rbx)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4786(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x18d5(%rip), %rdx      # 0x4389
leaq 0x18c7(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x11c, %r8d            # imm = 0x11C
popq %rbx
popq %r14
popq %r15
jmp 0x23ec
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2b02
leaq 0x474c(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1886(%rip), %rdx      # 0x4374
leaq 0x188d(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x144, %r8d            # imm = 0x144
callq 0x23ec
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2b35
pushq $0x18
popq %rdi
callq 0x10c0
movq %r14, 0x10(%rax)
movq (%r15), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq %rax, (%r15)
movq %r15, 0x8(%rax)
movq %rax, 0x8(%rbx)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x46f4(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1843(%rip), %rdx      # 0x4389
leaq 0x1835(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x145, %r8d            # imm = 0x145
popq %rbx
popq %r14
popq %r15
jmp 0x23ec
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2b90
leaq 0x46be(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x17f8(%rip), %rdx      # 0x4374
leaq 0x17ff(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x169, %r8d            # imm = 0x169
callq 0x23ec
cmpl $0x0, 0x10(%rbx)
jle 0x2bbc
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rcx
movq 0x10(%rdi), %r14
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
callq 0x1040
andq $0x0, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2c36
leaq 0x466d(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x17db(%rip), %rdx      # 0x43a8
leaq 0x17ae(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x16a, %r8d            # imm = 0x16A
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x2c28
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x2c2c
movq %rbx, %rdi
callq 0x1040
jmp 0x2c34
movl %ebx, %eax
jmp 0x2c36
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2c6f
leaq 0x45df(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1719(%rip), %rdx      # 0x4374
leaq 0x1720(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x190, %r8d            # imm = 0x190
callq 0x23ec
cmpl $0x0, 0x10(%rbx)
jle 0x2c9d
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r14
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
callq 0x1040
andq $0x0, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2d17
leaq 0x458c(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x16fa(%rip), %rdx      # 0x43a8
leaq 0x16cd(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x191, %r8d            # imm = 0x191
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x2d09
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x2d0d
movq %rbx, %rdi
callq 0x1040
jmp 0x2d15
movl %ebx, %eax
jmp 0x2d17
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/List.c
// Function: ListRemove
void * ListRemove(
        List *      pList,          /* pointer to list */
        void *      pData)          /* data object value */
    {
        ListNode *  pNode;

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

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

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

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

        return pData;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x2d53
leaq 0x44fb(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1635(%rip), %rdx      # 0x4374
leaq 0x163c(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x1b8, %r8d            # imm = 0x1B8
callq 0x23ec
cmpl $0x0, 0x10(%r14)
jle 0x2d79
movq (%r14), %rax
movq %rax, %rdx
movq (%rdx), %rdi
movq 0x10(%rdi), %rcx
cmpq %rax, %rdi
je 0x2d9d
movq %rdi, %rdx
cmpq %rbx, %rcx
jne 0x2d60
jmp 0x2e0e
leaq 0x44b0(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x161e(%rip), %rdx      # 0x43a8
leaq 0x15f1(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1b9, %r8d            # imm = 0x1B9
jmp 0x2dc4
cmpq %rbx, %rcx
je 0x2e0e
leaq 0x4487(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1606(%rip), %rdx      # 0x43b9
leaq 0x15c8(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1be, %r8d            # imm = 0x1BE
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x2e2f
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x2e33
movq %rbx, %rdi
callq 0x1040
jmp 0x2e3b
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
callq 0x1040
andq $0x0, 0x8(%r14)
decl 0x10(%r14)
movq %rbx, %rax
jmp 0x2e3d
movl %ebx, %eax
jmp 0x2e3d
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x2e77
leaq 0x43d7(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1511(%rip), %rdx      # 0x4374
leaq 0x1518(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x1e5, %r8d            # imm = 0x1E5
callq 0x23ec
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2ea3
movq 0x10(%rdi), %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
movq %r15, (%rax)
callq 0x1040
movq %r15, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2f1d
leaq 0x4386(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x14d5(%rip), %rdx      # 0x4389
leaq 0x14c7(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1e6, %r8d            # imm = 0x1E6
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x2f0f
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x2f13
movq %rbx, %rdi
callq 0x1040
jmp 0x2f1b
movl %ebx, %eax
jmp 0x2f1d
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x3026
leaq 0x4228(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1362(%rip), %rdx      # 0x4374
leaq 0x1369(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x264, %r8d            # imm = 0x264
callq 0x23ec
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3044
movq (%rax), %rax
movq %rax, 0x8(%rbx)
cmpq (%rbx), %rax
je 0x30b0
movq 0x10(%rax), %rax
jmp 0x30c5
leaq 0x41e5(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1334(%rip), %rdx      # 0x4389
leaq 0x1326(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x265, %r8d            # imm = 0x265
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x30b7
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x30bb
movq %rbx, %rdi
callq 0x1040
jmp 0x30c3
andq $0x0, 0x8(%rbx)
jmp 0x30c3
movl %ebx, %eax
jmp 0x30c5
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x30fe
leaq 0x4150(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x128a(%rip), %rdx      # 0x4374
leaq 0x1291(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x287, %r8d            # imm = 0x287
callq 0x23ec
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x311d
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
cmpq (%rbx), %rax
je 0x3189
movq 0x10(%rax), %rax
jmp 0x319e
leaq 0x410c(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x125b(%rip), %rdx      # 0x4389
leaq 0x124d(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x288, %r8d            # imm = 0x288
callq 0x23ec
movq (%r14), %rdi
callq 0x1618
cmpl $-0x1, %eax
je 0x3190
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x164c
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1130
testl %eax, %eax
je 0x3194
movq %rbx, %rdi
callq 0x1040
jmp 0x319c
andq $0x0, 0x8(%rbx)
jmp 0x319c
movl %ebx, %eax
jmp 0x319e
movq (%r14), %rdi
callq 0x1ea8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
jne 0x320d
leaq 0x4041(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x117b(%rip), %rdx      # 0x4374
leaq 0x1182(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x2c1, %r8d            # imm = 0x2C1
callq 0x23ec
movq (%r14), %rcx
movq %rcx, %rax
movq (%rax), %rax
movq 0x10(%rax), %rdx
cmpq %rcx, %rax
je 0x3226
cmpq %rbx, %rdx
jne 0x3213
jmp 0x322f
cmpq %rbx, %rdx
je 0x322f
xorl %ebx, %ebx
jmp 0x3233
movq %rax, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/meaning-matters[P]Except/List.c
// Function: ListConcat
List * ListConcat(
        List *      pListDst,       /* pointer to destination list */
        List *      pListAdd)       /* pointer to list to be added at tail */
    {
        assert(pListDst != NULL);
        assert(pListAdd != NULL);

        switch (((pListAdd->count > 0) << 1) | (pListDst->count > 0))
        {
        case 0:
            /* both lists empty */

            break;

        case 1:
            /* destination list not empty and add list empty */

            break;

        case 2:
            /* destination list empty and add list not empty */

            pListDst->pHead->pNext = pListAdd->pHead->pNext;
            pListDst->pHead->pNext->pPrev = pListDst->pHead;
            pListDst->pHead->pPrev = pListAdd->pHead->pPrev;
            pListDst->pHead->pPrev->pNext = pListDst->pHead;
            break;

        case 3:
            /* both lists not empty */

            pListAdd->pHead->pPrev->pNext = pListDst->pHead;
            pListDst->pHead->pPrev->pNext = pListAdd->pHead->pNext;
            pListAdd->pHead->pNext->pPrev = pListDst->pHead->pPrev;
            pListDst->pHead->pPrev = pListAdd->pHead->pPrev;
            break;
        }

        pListDst->pNodeLast = NULL;
        pListDst->count += pListAdd->count;

        free(pListAdd->pHead);
        free(pListAdd);

        return pListDst;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
jne 0x356d
leaq 0x3ce1(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0xebd(%rip), %rdx       # 0x4416
leaq 0xe22(%rip), %rcx       # 0x4382
xorl %esi, %esi
movl $0x372, %r8d            # imm = 0x372
callq 0x23ec
testq %r14, %r14
jne 0x3597
leaq 0x3cb7(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0xea4(%rip), %rdx       # 0x4427
leaq 0xdf8(%rip), %rcx       # 0x4382
xorl %esi, %esi
movl $0x373, %r8d            # imm = 0x373
callq 0x23ec
movl 0x10(%r14), %eax
xorl %edx, %edx
testl %eax, %eax
setg %dl
movl 0x10(%rbx), %ecx
xorl %esi, %esi
testl %ecx, %ecx
setg %sil
leal (%rsi,%rdx,2), %edx
cmpl $0x2, %edx
je 0x35df
cmpl $0x3, %edx
jne 0x35fc
movq (%rbx), %rdx
movq (%r14), %rdi
movq 0x8(%rdi), %rsi
movq %rdx, (%rsi)
movq (%rdi), %rsi
movq 0x8(%rdx), %r8
movq %rsi, (%r8)
movq %r8, 0x8(%rsi)
movq 0x8(%rdi), %rsi
movq %rsi, 0x8(%rdx)
jmp 0x35ff
movq (%r14), %rdi
movq (%rdi), %rdx
movq (%rbx), %rsi
movq %rdx, (%rsi)
movq %rsi, 0x8(%rdx)
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rsi)
movq %rsi, (%rdx)
jmp 0x35ff
movq (%r14), %rdi
andq $0x0, 0x8(%rbx)
addl %eax, %ecx
movl %ecx, 0x10(%rbx)
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0x6799(%rip), %r14      # 0x8ff8
movq (%r14), %rcx
leaq 0x3ad3(%rip), %rdi      # 0x633c
pushq $0x2
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rdi
leaq 0x39ad(%rip), %rsi      # 0x622e
leaq 0x39ad(%rip), %rdx      # 0x6235
xorl %eax, %eax
callq 0x2250
movq (%r14), %rcx
leaq 0x39bd(%rip), %rdi      # 0x6256
pushq $0x44
popq %rsi
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rsi
leaq 0x39ed(%rip), %rdi      # 0x629b
callq 0x2180
movq (%r14), %rsi
leaq 0x3a19(%rip), %rdi      # 0x62d6
callq 0x2180
movq (%r14), %rcx
leaq 0x3a2d(%rip), %rdi      # 0x62f9
pushq $0x45
popq %rsi
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rcx
leaq 0x3a59(%rip), %rdi      # 0x633a
pushq $0x4
popq %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2410
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/shoit.c
// Function: shoit_init_synch
void shoit_init_synch(shoit_core_t *shoit)
{
    sem_init(&shoit->progSem,0,0);
    sem_init(&shoit->dataSem,0,0);
    if(pipe(shoit->pipe)==-1) perror("pipe");
    pthread_mutex_init(&shoit->sendBlockLock, NULL);
    pthread_cond_init(&shoit->sendBlockCond, NULL);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
xorl %esi, %esi
xorl %edx, %edx
callq 0x2320
leaq 0x120(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2320
leaq 0x140(%rbx), %rdi
callq 0x21c0
cmpl $-0x1, %eax
je 0x2961
leaq 0x178(%rbx), %rdi
xorl %esi, %esi
callq 0x2460
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x22b0
leaq 0x43bf(%rip), %rdi      # 0x6d27
callq 0x2390
jmp 0x2941
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/shoit.c
// Function: shoit_init_error_bitmap
void shoit_init_error_bitmap(shoit_core_t *shoit)
{
    uint64_t i;
    char *errorBitmap = (char*)(shoit->errorBitmap + sizeof(shoit_control_t));

    memset(shoit->errorBitmap,0,sizeof(shoit_control_t));
    // the first byte is 0 if there is error.  1 if all done.
    uint64_t startOfLastByte = shoit->totalNumberOfPackets - (shoit->sizeofErrorBitmap-2)*8;
    char bits[8] = {0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080};

    /* The first byte is for judging all_done */
    for (i=0;i<shoit->sizeofErrorBitmap;i++)
        errorBitmap[i] = 0;

    /* Preset those bits unused */
    for (i=startOfLastByte;i<8;i++)
        errorBitmap[shoit->sizeofErrorBitmap-1] |= bits[i];
}

// Assembly:
movq 0xd0(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xe(%rax)
movups %xmm0, (%rax)
movq 0x38(%rdi), %rcx
movq 0xd8(%rdi), %r8
leaq (,%r8,8), %rdx
xorl %esi, %esi
cmpq %r8, %rsi
jae 0x29f9
movb $0x0, 0x1e(%rax,%rsi)
incq %rsi
movq 0xd8(%rdi), %r8
jmp 0x29e3
subq %rdx, %rcx
addq $0x10, %rcx
leaq 0x3962(%rip), %rdx      # 0x6369
cmpq $0x7, %rcx
ja 0x2a22
movb (%rcx,%rdx), %sil
movq 0xd8(%rdi), %r8
orb %sil, 0x1d(%rax,%r8)
incq %rcx
jmp 0x2a07
retq
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/shoit.c
// Function: shoit_update_error_bitmap
bool shoit_update_error_bitmap(shoit_core_t *shoit,uint64_t seq)
{
    char *errorBitmap = (char*)(shoit->errorBitmap + sizeof(shoit_control_t));
    uint64_t index_in_list, offset_in_index;

    char bits[8] = {0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080};
    if(seq < 0 || (seq >> 3) >= shoit->sizeofErrorBitmap-1) {
        if(shoit->verbose) {
            fprintf(stderr, "seqno <%ld> wrong,out of range:0 ... %ld\n",seq,shoit->sizeofErrorBitmap);
            exit(0);
        }
        return false;
    }
    // seq starts with 0
    index_in_list = seq >> 3; /*8bit*/
    index_in_list ++;
    offset_in_index = seq%8;
    errorBitmap[index_in_list] |= bits[offset_in_index];

    return true;
}

// Assembly:
movq %rsi, %rdx
movq %rsi, %rax
shrq $0x3, %rax
movq 0xd8(%rdi), %rcx
leaq -0x1(%rcx), %rsi
cmpq %rsi, %rax
jae 0x2a59
movq 0xd0(%rdi), %rcx
andl $0x7, %edx
leaq 0x391b(%rip), %rsi      # 0x6369
movb (%rdx,%rsi), %dl
orb %dl, 0x1f(%rcx,%rax)
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpl $0x0, 0x5c(%rdi)
jne 0x2a62
retq
pushq %rax
movq 0x658e(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x38cb(%rip), %rsi      # 0x633f
xorl %eax, %eax
callq 0x2250
xorl %edi, %edi
callq 0x23f0
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/shoit.c
// Function: shoit_update_hash_table
uint64_t shoit_update_hash_table(shoit_core_t *shoit,bool update)
{
    uint64_t count = 0;
    uint64_t i,j;
    char bits[8] = {0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080};
    char *errorBitmap = (char*)(shoit->errorBitmap + sizeof(shoit_control_t));

    for (i=1;i<shoit->sizeofErrorBitmap; i++)
    {
        for (j=0;j<8;j++)
        {
            if ((errorBitmap[i] & bits[j]) == 0)
            {
                if(update)
                    shoit->hashTable[count] = (i-1)*8+j;
                count ++;
            }
        }
    }
    // set the first byte to let the sender know "all done"
    if (count == 0 && update)
        errorBitmap[0] = 1;

    return count;
}

// Assembly:
pushq %rbx
movq 0xd0(%rdi), %rcx
movabsq $0x1, %rdx
xorl %r8d, %r8d
leaq 0x38cb(%rip), %r9       # 0x6369
xorl %eax, %eax
cmpq 0xd8(%rdi), %rdx
jae 0x2ae1
xorl %r10d, %r10d
cmpq $0x8, %r10
je 0x2ad8
movb (%r10,%r9), %r11b
testb %r11b, 0x1e(%rcx,%rdx)
jne 0x2ad3
testl %esi, %esi
je 0x2ad0
leaq (%r8,%r10), %r11
movq 0xc8(%rdi), %rbx
movq %r11, (%rbx,%rax,8)
incq %rax
incq %r10
jmp 0x2aac
incq %rdx
addq $0x8, %r8
jmp 0x2aa0
testq %rax, %rax
setne %dl
testl %esi, %esi
sete %sil
orb %dl, %sil
jne 0x2af6
movb $0x1, 0x1e(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pencode-lab[P]Shoit/shoit_network.c
// Function: shoit_network_resolve_address
int shoit_network_resolve_address(struct sockaddr *sa, socklen_t *salen, const char *host, const int port, int family, int type,int proto)
{
    struct addrinfo hints, *res;
    int err;
    char sport[8]={0};

    memset(sport,0,8);
    snprintf(sport,7,"%d",port);

    memset(&hints, 0, sizeof(hints));
    hints.ai_family = family;
    hints.ai_socktype = type;
    hints.ai_protocol = proto;
    hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV | AI_PASSIVE;
    if ((err = getaddrinfo(host, sport, &hints, &res)) != 0 || res == NULL) {
        fprintf(stderr, "failed to resolve address:%s:%s:%s\n", host, sport,
                err != 0 ? gai_strerror(err) : "getaddrinfo returned NULL");
        return -1;
    }
    memcpy(sa, res->ai_addr, res->ai_addrlen);
    *salen = res->ai_addrlen;                                                                                                        
    freeaddrinfo(res);                                                                                                               
    return 0;                                                                                                                        
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %r13
andq $0x0, (%r13)
leaq 0x435a(%rip), %rdx      # 0x6e84
pushq $0x7
popq %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2130
xorps %xmm0, %xmm0
leaq 0x18(%rsp), %rdx
movups %xmm0, 0x10(%rdx)
movups %xmm0, 0x20(%rdx)
movl %r12d, 0x4(%rdx)
movl %ebp, 0x8(%rdx)
movl 0x80(%rsp), %eax
movl %eax, 0xc(%rdx)
movl $0x421, (%rdx)          # imm = 0x421
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2420
testl %eax, %eax
jne 0x2baf
movq 0x10(%rsp), %r12
testq %r12, %r12
je 0x2baf
movq 0x18(%r12), %rsi
movl 0x10(%r12), %edx
movq %r15, %rdi
callq 0x2280
movl 0x10(%r12), %eax
movl %eax, (%r14)
movq %r12, %rdi
callq 0x24b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6442(%rip), %rcx      # 0x8ff8
movq (%rcx), %r14
testl %eax, %eax
je 0x2bc9
movl %eax, %edi
callq 0x2140
movq %rax, %r8
jmp 0x2bd0
leaq 0x37c5(%rip), %r8       # 0x6395
leaq 0x379a(%rip), %rsi      # 0x6371
leaq 0x8(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
pushq $-0x1
popq %rax
jmp 0x2ba0