LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x2581
leaq 0x4b8f(%rip), %rsi      # 0x7100
movq %r12, %rdi
xorl %edx, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1a8d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25ce
leaq 0x4b42(%rip), %rsi      # 0x7100
movq %r12, %rdi
xorl %edx, %edx
movq %r14, %rcx
movl %ebx, %r8d
callq 0x1a8d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x10c0
movq %rax, %rbx
movl $0x0, 0x8(%rax)
movl $0x800, %edi            # imm = 0x800
callq 0x10c0
movq %rax, %r14
movq %rax, (%rbx)
xorl %r15d, %r15d
callq 0x28fc
movq %rax, (%r14,%r15,8)
incq %r15
cmpq $0x100, %r15            # imm = 0x100
jne 0x260c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x265b
leaq 0x4bf3(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1d0d(%rip), %rdx      # 0x4354
leaq 0x1d14(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x58, %r8d
callq 0x2468
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2998
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x265e
movq (%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x26be
leaq 0x4b90(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1caa(%rip), %rdx      # 0x4354
leaq 0x1cb1(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x78, %r8d
callq 0x2468
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2fd4
testq %rax, %rax
je 0x26e8
movq (%rax), %rdi
callq 0x1040
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x30a6
jmp 0x26cd
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2998
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0x26c1
movq (%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x274b
leaq 0x4b03(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1c1d(%rip), %rdx      # 0x4354
leaq 0x1c24(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0xd5, %r8d
callq 0x2468
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 0x2fd4
xorl %r14d, %r14d
testq %rax, %rax
je 0x2783
cmpl %ebx, 0x8(%rax)
je 0x2780
movq %r15, %rdi
callq 0x30a6
jmp 0x276c
movq (%rax), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x27c2
leaq 0x4a8c(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1ba6(%rip), %rdx      # 0x4354
leaq 0x1bad(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x101, %r8d            # imm = 0x101
callq 0x2468
testq %r14, %r14
je 0x27fd
movl $0x10, %edi
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 0x2a06
incl 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4a2c(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1b5b(%rip), %rdx      # 0x4369
leaq 0x1b4d(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x102, %r8d            # imm = 0x102
popq %rbx
popq %r14
popq %rbp
jmp 0x2468
// File: /workspace/github_c_makefile_star2_O1/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 0x285d
leaq 0x49f1(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1b0b(%rip), %rdx      # 0x4354
leaq 0x1b12(%rip), %rcx      # 0x4362
xorl %esi, %esi
movl $0x127, %r8d            # imm = 0x127
callq 0x2468
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 0x2fd4
testq %rax, %rax
je 0x289f
movq %rax, %r12
xorl %r14d, %r14d
cmpl %ebp, 0x8(%r12)
je 0x28a4
movq %r15, %rdi
callq 0x30a6
movq %rax, %r12
testq %rax, %rax
jne 0x2886
jmp 0x28bb
xorl %r14d, %r14d
jmp 0x28bb
movq %r15, %rdi
callq 0x2ef0
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_O1/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 %rbx
movl $0x18, %edi
callq 0x10c0
movq %rax, %rbx
movl $0x18, %edi
callq 0x10c0
movq %rax, (%rbx)
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2963
leaq 0x48eb(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1a25(%rip), %rdx      # 0x4374
leaq 0x1a2c(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x82, %r8d
callq 0x2468
movq (%rbx), %rax
movq (%rax), %rdi
cmpq %rax, %rdi
je 0x2981
movq (%rdi), %r14
callq 0x1040
movq (%rbx), %rax
movq %r14, %rdi
cmpq %rax, %r14
jne 0x296e
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x29ca
leaq 0x4884(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x19be(%rip), %rdx      # 0x4374
leaq 0x19c5(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xa8, %r8d
callq 0x2468
movq (%rbx), %rdi
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x29f4
movq (%r14), %r15
movq 0x10(%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq (%rbx), %rdi
movq %r15, %r14
cmpq %rdi, %r15
jne 0x29d5
callq 0x1040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x2a3a
leaq 0x4814(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x194e(%rip), %rdx      # 0x4374
leaq 0x1955(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xd0, %r8d
callq 0x2468
movl $0x18, %edi
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_O1/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 0x2a9f
leaq 0x47af(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x18e9(%rip), %rdx      # 0x4374
leaq 0x18f0(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0xf3, %r8d
callq 0x2468
movl $0x18, %edi
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_O1/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 0x2b06
leaq 0x4748(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1882(%rip), %rdx      # 0x4374
leaq 0x1889(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x11b, %r8d            # imm = 0x11B
callq 0x2468
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2b3c
movl $0x18, %edi
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 0x46ed(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x183c(%rip), %rdx      # 0x4389
leaq 0x182e(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x11c, %r8d            # imm = 0x11C
popq %rbx
popq %r14
popq %r15
jmp 0x2468
// File: /workspace/github_c_makefile_star2_O1/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 0x2b9b
leaq 0x46b3(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x17ed(%rip), %rdx      # 0x4374
leaq 0x17f4(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x144, %r8d            # imm = 0x144
callq 0x2468
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x2bd0
movl $0x18, %edi
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 0x4659(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x17a8(%rip), %rdx      # 0x4389
leaq 0x179a(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x145, %r8d            # imm = 0x145
popq %rbx
popq %r14
popq %r15
jmp 0x2468
// File: /workspace/github_c_makefile_star2_O1/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 0x2c2b
leaq 0x4623(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x175d(%rip), %rdx      # 0x4374
leaq 0x1764(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x169, %r8d            # imm = 0x169
callq 0x2468
cmpl $0x0, 0x10(%rbx)
jle 0x2c5a
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rcx
movq 0x10(%rdi), %r14
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
callq 0x1040
movq $0x0, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2cd6
leaq 0x45cf(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x173d(%rip), %rdx      # 0x43a8
leaq 0x1710(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x16a, %r8d            # imm = 0x16A
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x2cc8
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x2ccc
movq %rbx, %rdi
callq 0x1040
jmp 0x2cd4
movl %ebx, %eax
jmp 0x2cd6
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d0f
leaq 0x453f(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1679(%rip), %rdx      # 0x4374
leaq 0x1680(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x190, %r8d            # imm = 0x190
callq 0x2468
cmpl $0x0, 0x10(%rbx)
jle 0x2d40
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %r14
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
callq 0x1040
movq $0x0, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2dbc
leaq 0x44e9(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1657(%rip), %rdx      # 0x43a8
leaq 0x162a(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x191, %r8d            # imm = 0x191
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x2dae
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x2db2
movq %rbx, %rdi
callq 0x1040
jmp 0x2dba
movl %ebx, %eax
jmp 0x2dbc
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2df8
leaq 0x4456(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1590(%rip), %rdx      # 0x4374
leaq 0x1597(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x1b8, %r8d            # imm = 0x1B8
callq 0x2468
cmpl $0x0, 0x10(%r14)
jle 0x2e44
movq (%r14), %rax
movq %rax, %rcx
movq (%rcx), %rdi
cmpq %rax, %rdi
je 0x2e16
movq %rdi, %rcx
cmpq %rbx, 0x10(%rdi)
jne 0x2e05
cmpq %rbx, 0x10(%rdi)
je 0x2eb6
leaq 0x4409(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1588(%rip), %rdx      # 0x43b9
leaq 0x154a(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1be, %r8d            # imm = 0x1BE
jmp 0x2e66
leaq 0x43e5(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1553(%rip), %rdx      # 0x43a8
leaq 0x1526(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1b9, %r8d            # imm = 0x1B9
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x2eb2
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x2ede
movq %rbx, %rdi
callq 0x1040
jmp 0x2ee6
movl %ebx, %eax
jmp 0x2ee8
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rdi), %rcx
movq %rax, (%rcx)
callq 0x1040
movq $0x0, 0x8(%r14)
decl 0x10(%r14)
movq %rbx, %rax
jmp 0x2ee8
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2f22
leaq 0x432c(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x1466(%rip), %rdx      # 0x4374
leaq 0x146d(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x1e5, %r8d            # imm = 0x1E5
callq 0x2468
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2f52
movq 0x10(%rdi), %r14
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
movq 0x8(%rdi), %rax
movq %r15, (%rax)
callq 0x1040
movq %r15, 0x8(%rbx)
decl 0x10(%rbx)
movq %r14, %rax
jmp 0x2fce
leaq 0x42d7(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1426(%rip), %rdx      # 0x4389
leaq 0x1418(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x1e6, %r8d            # imm = 0x1E6
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x2fc0
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x2fc4
movq %rbx, %rdi
callq 0x1040
jmp 0x2fcc
movl %ebx, %eax
jmp 0x2fce
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30d7
leaq 0x4177(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x12b1(%rip), %rdx      # 0x4374
leaq 0x12b8(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x264, %r8d            # imm = 0x264
callq 0x2468
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x30f5
movq (%rax), %rax
movq %rax, 0x8(%rbx)
cmpq (%rbx), %rax
je 0x3163
movq 0x10(%rax), %rax
jmp 0x317b
leaq 0x4134(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x1283(%rip), %rdx      # 0x4389
leaq 0x1275(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x265, %r8d            # imm = 0x265
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x316d
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3171
movq %rbx, %rdi
callq 0x1040
jmp 0x3179
movq $0x0, 0x8(%rbx)
jmp 0x3179
movl %ebx, %eax
jmp 0x317b
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x31b4
leaq 0x409a(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x11d4(%rip), %rdx      # 0x4374
leaq 0x11db(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x287, %r8d            # imm = 0x287
callq 0x2468
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x31d3
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
cmpq (%rbx), %rax
je 0x3241
movq 0x10(%rax), %rax
jmp 0x3259
leaq 0x4056(%rip), %r14      # 0x7230
movq (%r14), %rdi
leaq 0x11a5(%rip), %rdx      # 0x4389
leaq 0x1197(%rip), %rcx      # 0x4382
xorl %ebx, %ebx
movl %ebx, %esi
movl $0x288, %r8d            # imm = 0x288
callq 0x2468
movq (%r14), %rdi
callq 0x1678
cmpl $-0x1, %eax
je 0x324b
movl $0xc8, %edi
callq 0x10c0
movq %rax, %rbx
movq (%r14), %rdi
callq 0x16ae
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x324f
movq %rbx, %rdi
callq 0x1040
jmp 0x3257
movq $0x0, 0x8(%rbx)
jmp 0x3257
movl %ebx, %eax
jmp 0x3259
movq (%r14), %rdi
callq 0x1eed
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32c8
leaq 0x3f86(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0x10c0(%rip), %rdx      # 0x4374
leaq 0x10c7(%rip), %rcx      # 0x4382
xorl %esi, %esi
movl $0x2c1, %r8d            # imm = 0x2C1
callq 0x2468
movq (%r14), %rcx
movq %rcx, %rax
movq (%rax), %rax
cmpq %rcx, %rax
je 0x32dc
cmpq %rbx, 0x10(%rax)
jne 0x32ce
cmpq %rbx, 0x10(%rax)
je 0x32e6
xorl %ebx, %ebx
jmp 0x32ea
movq %rax, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x364e
leaq 0x3c00(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0xddc(%rip), %rdx       # 0x4416
leaq 0xd41(%rip), %rcx       # 0x4382
xorl %esi, %esi
movl $0x372, %r8d            # imm = 0x372
callq 0x2468
testq %r14, %r14
jne 0x3678
leaq 0x3bd6(%rip), %rax      # 0x7230
movq (%rax), %rdi
leaq 0xdc3(%rip), %rdx       # 0x4427
leaq 0xd17(%rip), %rcx       # 0x4382
xorl %esi, %esi
movl $0x373, %r8d            # imm = 0x373
callq 0x2468
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 $0x3, %edx
je 0x36b8
cmpl $0x2, %edx
jne 0x36de
movq (%r14), %rdx
movq (%rdx), %rsi
movq (%rbx), %rdi
movq %rsi, (%rdi)
movq %rdi, 0x8(%rsi)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rdi)
movq %rdi, (%rdx)
jmp 0x36de
movq (%rbx), %rdx
movq (%r14), %rsi
movq 0x8(%rsi), %rdi
movq %rdx, (%rdi)
movq (%rsi), %rdi
movq 0x8(%rdx), %r8
movq %rdi, (%r8)
movq (%rsi), %rdi
movq %r8, 0x8(%rdi)
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rdx)
movq $0x0, 0x8(%rbx)
addl %eax, %ecx
movl %ecx, 0x10(%rbx)
movq (%r14), %rdi
callq 0x1040
movq %r14, %rdi
callq 0x1040
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/cirocosta[P]stress/src/locks.c
// Function: create_file
void
create_file(const char* base, const int i)
{
	FILE* fp;
	char* filename;

	_STRESS_MUST(asprintf(&filename, "%s/file%d", base, i) > 0,
	             "Couldn't create name for file %d",
	             i);
	_STRESS_MUST(
	  (fp = fopen(filename, "a")), "Couldn't create file %s", filename);

	_STRESS_MUST_P(!flock(fileno(fp), LOCK_EX),
	               "flock",
	               "Couldn't acquire lock on %s",
	               filename);

	fprintf(fp, "dummy");
	free(filename);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %rdx
leaq 0x581(%rip), %rsi       # 0x210d
leaq 0x8(%rsp), %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1140
testl %eax, %eax
jle 0x1bf8
movq 0x8(%rsp), %rdi
leaq 0x59a(%rip), %rsi       # 0x2144
callq 0x1150
testq %rax, %rax
je 0x1bff
movq %rax, %rbx
movq %rax, %rdi
callq 0x1130
movl %eax, %edi
movl $0x2, %esi
callq 0x1180
testl %eax, %eax
jne 0x1c09
leaq 0x5bb(%rip), %rdi       # 0x2191
movl $0x5, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11b0
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbx
retq
movl %ebx, %edi
callq 0x141c
leaq 0x8(%rsp), %rdi
callq 0x15d3
leaq 0x8(%rsp), %rdi
callq 0x14d2
// File: /workspace/github_c_makefile_star2_O1/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 0x6ae8(%rip), %r14      # 0x8ff8
movq (%r14), %rcx
leaq 0x3e22(%rip), %rdi      # 0x633c
pushq $0x2
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rdi
leaq 0x3cfc(%rip), %rsi      # 0x622e
leaq 0x3cfc(%rip), %rdx      # 0x6235
xorl %eax, %eax
callq 0x2250
movq (%r14), %rcx
leaq 0x3d0c(%rip), %rdi      # 0x6256
pushq $0x44
popq %rsi
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rsi
leaq 0x3d3c(%rip), %rdi      # 0x629b
callq 0x2180
movq (%r14), %rsi
leaq 0x3d68(%rip), %rdi      # 0x62d6
callq 0x2180
movq (%r14), %rcx
leaq 0x3d7c(%rip), %rdi      # 0x62f9
pushq $0x45
popq %rsi
movq %rbx, %rdx
callq 0x2410
movq (%r14), %rcx
leaq 0x3da8(%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_O1/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 0x2b86
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 0x41aa(%rip), %rdi      # 0x6d37
callq 0x2390
jmp 0x2b66
// File: /workspace/github_c_makefile_star2_O1/pencode-lab[P]Shoit/shoit.c
// Function: shoit_destory_synch
void shoit_destory_synch(shoit_core_t *shoit)
{
    sem_destroy(&shoit->progSem);
    sem_destroy(&shoit->dataSem);
    close(shoit->pipe[0]);
    close(shoit->pipe[1]); 
    pthread_mutex_destroy(&shoit->sendBlockLock);
    pthread_cond_destroy(&shoit->sendBlockCond);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x100, %rdi            # imm = 0x100
callq 0x2470
leaq 0x120(%rbx), %rdi
callq 0x2470
movl 0x140(%rbx), %edi
callq 0x21b0
movl 0x144(%rbx), %edi
callq 0x21b0
leaq 0x178(%rbx), %rdi
callq 0x2120
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
popq %rbx
jmp 0x2360
// File: /workspace/github_c_makefile_star2_O1/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), %rsi
leaq (,%rsi,8), %rdx
subq %rdx, %rcx
leaq 0x10(%rcx), %rdx
testq %rsi, %rsi
je 0x2c25
xorl %esi, %esi
movb $0x0, 0x1e(%rax,%rsi)
incq %rsi
cmpq 0xd8(%rdi), %rsi
jb 0x2c14
cmpq $0x7, %rdx
ja 0x2c4c
leaq 0x3737(%rip), %rdx      # 0x6369
movb 0x10(%rcx,%rdx), %sil
movq 0xd8(%rdi), %r8
orb %sil, 0x1d(%rax,%r8)
incq %rcx
cmpq $-0x8, %rcx
jne 0x2c32
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rax
shrq $0x3, %rax
movq 0xd8(%rdi), %rcx
leaq -0x1(%rcx), %rdx
cmpq %rdx, %rax
jae 0x2c82
movq 0xd0(%rdi), %rcx
andl $0x7, %esi
leaq 0x36f4(%rip), %rdx      # 0x6369
movb (%rsi,%rdx), %dl
orb %dl, 0x1f(%rcx,%rax)
movl $0x1, %eax
retq
xorl %eax, %eax
cmpl $0x0, 0x5c(%rdi)
jne 0x2c8b
retq
pushq %rax
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x25a4
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x2, 0xd8(%rdi)
jb 0x2cf9
movl $0x1, %edx
xorl %r8d, %r8d
leaq 0x36b1(%rip), %r9       # 0x6369
xorl %eax, %eax
xorl %r10d, %r10d
movb (%r10,%r9), %r11b
testb %r11b, 0x1e(%rcx,%rdx)
jne 0x2cde
testl %esi, %esi
je 0x2cdb
leaq (%r8,%r10), %r11
movq 0xc8(%rdi), %rbx
movq %r11, (%rbx,%rax,8)
incq %rax
incq %r10
cmpq $0x8, %r10
jne 0x2cbd
incq %rdx
addq $0x8, %r8
cmpq 0xd8(%rdi), %rdx
jb 0x2cba
jmp 0x2cfb
xorl %eax, %eax
testl %esi, %esi
je 0x2d08
testq %rax, %rax
jne 0x2d08
movb $0x1, 0x1e(%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %r13
movq $0x0, (%r13)
leaq 0x4155(%rip), %rdx      # 0x6e94
movl $0x7, %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2130
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %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 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2420
testl %eax, %eax
jne 0x2dc9
movq 0x8(%rsp), %r12
testq %r12, %r12
je 0x2dc9
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 0x6228(%rip), %rcx      # 0x8ff8
movq (%rcx), %r14
testl %eax, %eax
je 0x2de3
movl %eax, %edi
callq 0x2140
movq %rax, %r8
jmp 0x2dea
leaq 0x35ca(%rip), %r8       # 0x63b4
leaq 0x359f(%rip), %rsi      # 0x6390
movq %rsp, %rcx
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2dba
// File: /workspace/github_c_makefile_star2_O1/pencode-lab[P]Shoit/shoit_network.c
// Function: shoit_network_set_socket_buffer
void shoit_network_set_socket_buffer(int udpSockfd, int sockbufsize, int verbose )
{
    int oldsend = -1, oldrecv = -1;
    int newsend = -1, newrecv = -1;
    socklen_t olen = sizeof(int);

    if(getsockopt(udpSockfd,SOL_SOCKET,SO_SNDBUF,&oldsend,&olen) < 0)
        perror("getsockopt: SO_SNDBUF");

    if(getsockopt(udpSockfd,SOL_SOCKET,SO_RCVBUF,&oldrecv,&olen) < 0)
        perror("getsockopt: SO_RCVBUF");

    if(sockbufsize > 0) {
        if(setsockopt(udpSockfd,SOL_SOCKET,SO_SNDBUF,&sockbufsize,sizeof(sockbufsize)) < 0)
            perror("setsockopt: SO_SNDBUF");
        if(setsockopt(udpSockfd,SOL_SOCKET,SO_RCVBUF,&sockbufsize,sizeof(sockbufsize)) < 0)
            perror("setsockopt: SO_RCVBUF");
        if(getsockopt(udpSockfd,SOL_SOCKET,SO_SNDBUF,&newsend,&olen) < 0)
            perror("getsockopt: SO_SNDBUF");
        if(getsockopt(udpSockfd,SOL_SOCKET,SO_RCVBUF,&newrecv,&olen) < 0)
            perror("getsockopt: SO_RCVBUF");
    }
    if(verbose>1) 
        fprintf(stderr, "UDP sockbufsize was %d/%d now %d/%d (send/recv)\n",oldsend, oldrecv, newsend, newrecv);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movl %edi, %ebp
movl %esi, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movq %rsp, %r8
movl $0x4, (%r8)
movl $0x1, %esi
movl $0x7, %edx
callq 0x2210
testl %eax, %eax
js 0x2f5c
leaq 0x10(%rsp), %rcx
movq %rsp, %r8
movl %ebp, %edi
movl $0x1, %esi
movl $0x8, %edx
callq 0x2210
testl %eax, %eax
js 0x2f6d
cmpl $0x0, 0x4(%rsp)
jle 0x2f50
leaq 0x4(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0x7, %edx
movl $0x4, %r8d
callq 0x2090
testl %eax, %eax
js 0x2faa
leaq 0x4(%rsp), %rcx
movl %ebp, %edi
movl $0x1, %esi
movl $0x8, %edx
movl $0x4, %r8d
callq 0x2090
testl %eax, %eax
js 0x2fbb
leaq 0xc(%rsp), %rcx
movq %rsp, %r8
movl %ebp, %edi
movl $0x1, %esi
movl $0x7, %edx
callq 0x2210
testl %eax, %eax
js 0x2fcc
leaq 0x8(%rsp), %rcx
movq %rsp, %r8
movl %ebp, %edi
movl $0x1, %esi
movl $0x8, %edx
callq 0x2210
testl %eax, %eax
js 0x2fdd
cmpl $0x2, %ebx
jge 0x2f7e
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x346b(%rip), %rdi      # 0x63ce
callq 0x2390
jmp 0x2e9a
leaq 0x3470(%rip), %rdi      # 0x63e4
callq 0x2390
jmp 0x2ebb
movq 0x6073(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %r8d
movl 0x8(%rsp), %r9d
leaq 0x3485(%rip), %rsi      # 0x6426
xorl %eax, %eax
callq 0x2250
jmp 0x2f55
leaq 0x3449(%rip), %rdi      # 0x63fa
callq 0x2390
jmp 0x2eea
leaq 0x344e(%rip), %rdi      # 0x6410
callq 0x2390
jmp 0x2f0e
leaq 0x33fb(%rip), %rdi      # 0x63ce
callq 0x2390
jmp 0x2f2f
leaq 0x3400(%rip), %rdi      # 0x63e4
callq 0x2390
jmp 0x2f50
// File: /workspace/github_c_makefile_star2_O1/pencode-lab[P]Shoit/shoit_network.c
// Function: shoit_network_connect_udp
int shoit_network_connect_udp(struct sockaddr_in *udpServerAddr,int localPort,char *remoteHost,int remoteHostPort)
{
    static struct sockaddr_in udpClientAddr;
    struct hostent *phe;
    int udpSockfd;

    // Fill in the structure whith the address of the server that we want to send to
    // udpServerAddr is class global variable, will be used to send data

    bzero(udpServerAddr, sizeof(struct sockaddr_in));
    udpServerAddr->sin_family = AF_INET;

    if ((phe = gethostbyname(remoteHost)))
        memcpy(&udpServerAddr->sin_addr, phe->h_addr, phe->h_length);
    else if ((udpServerAddr->sin_addr.s_addr = inet_addr(remoteHost)) == INADDR_NONE)
    {   
        perror("can't get host entry");
        return -1;
    }
    udpServerAddr->sin_port = htons(remoteHostPort);

    /* Open a UDP socket */
    if ((udpSockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
    {
        perror("socket error");
        return -1;
    }

    // Allow the port to be reused.
    int yes = 1;
    if (setsockopt(udpSockfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) {
        perror("setsockopt");
        close(udpSockfd);
        return -1;
    } 

    /* Bind any local address for us */
    bzero(&udpClientAddr, sizeof(udpClientAddr));
    udpClientAddr.sin_family = AF_INET;
    udpClientAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    udpClientAddr.sin_port = htons(localPort);
    if((bind(udpSockfd, (struct sockaddr *)&udpClientAddr, sizeof(udpClientAddr))) < 0) {
        perror("UDP client bind error");
        close(udpSockfd);
        return -1;
    }

    return udpSockfd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movw $0x2, (%rdi)
movq %rdx, %rdi
callq 0x2240
testq %rax, %rax
je 0x302d
leaq 0x4(%r14), %rdi
movq 0x18(%rax), %rcx
movq (%rcx), %rsi
movslq 0x14(%rax), %rdx
callq 0x2280
jmp 0x3042
movq %r15, %rdi
callq 0x2220
movl %eax, 0x4(%r14)
cmpl $-0x1, %eax
je 0x30fc
rolw $0x8, %bp
movw %bp, 0x2(%r14)
movl $0x2, %edi
movl $0x2, %esi
xorl %edx, %edx
callq 0x24c0
testl %eax, %eax
js 0x30d5
movl %eax, %ebp
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2090
cmpl $-0x1, %eax
je 0x30de
xorps %xmm0, %xmm0
movups %xmm0, 0x61e9(%rip)     # 0x927c
leaq 0x61e2(%rip), %rsi      # 0x927c
movw $0x2, 0x61d9(%rip)      # 0x927c
movl $0x0, 0x61d3(%rip)      # 0x9280
rolw $0x8, %bx
movw %bx, 0x61c6(%rip)       # 0x927e
movl %ebp, %edi
movl $0x10, %edx
callq 0x2330
testl %eax, %eax
js 0x30e7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3390(%rip), %rdi      # 0x646c
jmp 0x3103
leaq 0x3394(%rip), %rdi      # 0x6479
jmp 0x30ee
leaq 0x3396(%rip), %rdi      # 0x6484
callq 0x2390
movl %ebp, %edi
callq 0x21b0
jmp 0x3108
leaq 0x3354(%rip), %rdi      # 0x6457
callq 0x2390
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x30c8