LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SmsSendTextMessage
void test_modem_SmsSendTextMessage(){
    cmError_t retValue = CM_FAIL;
    
    /*GSM default alphabet */
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSendTextMessage(&cmData,"Hellow world!");
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbx
leaq 0x4239(%rip), %rax      # 0x7d52
movq %rax, 0x8670(%rip)      # 0xc190
leaq 0x85f9(%rip), %rbx      # 0xc120
leaq 0x4083(%rip), %rsi      # 0x7bb1
movq %rbx, %rdi
callq 0x21ed
movslq %eax, %rsi
movl $0x147, %ecx            # imm = 0x147
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movq %rbx, %rdi
callq 0x1584
movzbl %al, %esi
movl $0x148, %ecx            # imm = 0x148
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x540d
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SocketOpen
void test_modem_SocketOpen(){
    cmError_t retValue = CM_FAIL;
    cellModemConfig_t config =CELLMODEMCONFIG_INITIALIZER;
    socketData_t configSocket =SOCKETDATA_INITIALIZER;
    MockResponseExpected = CM_CMD_MOCK_QIOPEN_RESPONSE;
    configSocket.accessMode = 0;
    configSocket.contextId = config.contextId = 1;
    configSocket.connectId = config.connectId = 3;
    configSocket.serviceType = CELLMODEM_SOCKET_SRV_TYPE_UDP;
    strcpy(configSocket.remip , "127.0.0.1");
    strcpy(configSocket.remPort , "0");
    strcpy(configSocket.locPort , "2020" );
    retValue = cellModem_SocketOpen(&cmData,&configSocket);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
    
}

// Assembly:
pushq %rbx
subq $0x70, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x30(%rsi)
leaq 0x4025(%rip), %rax      # 0x7bbf
movq %rax, 0x85ef(%rip)      # 0xc190
movabsq $0x300000000, %rax      # imm = 0x300000000
movq %rax, 0x48(%rsi)
movl $0x1, 0x50(%rsi)
leaq 0x4019(%rip), %rax      # 0x7bd6
movq %rax, 0x20(%rsi)
movabsq $0x2e302e302e373231, %rax # imm = 0x2E302E302E373231
movq %rax, (%rsi)
movw $0x31, 0x8(%rsi)
movw $0x30, 0x10(%rsi)
movl $0x30323032, 0x18(%rsi) # imm = 0x30323032
movb $0x0, 0x1c(%rsi)
leaq 0x8534(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x2284
movslq %eax, %rsi
movl $0x159, %ecx            # imm = 0x159
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movq %rbx, %rdi
callq 0x1584
movzbl %al, %esi
movl $0x15a, %ecx            # imm = 0x15A
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_QIURC_incomingConnection
void test_modem_QIURC_incomingConnection(){
    cmError_t retValue = CM_FAIL; 
    asynEventIncomingConn_t getDataIncomingConn = ASYNCEVENT_INCOMING_CONN_INITIALIZER;

    TEST_ASSERT_EQUAL_INT32(1 ,cmIsAsyncEvent(&cmData));
    retValue = cellModem_UrcGetDataIncomingConnection(&cmData, &getDataIncomingConn);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT32(11, getDataIncomingConn.info.connectId);
    TEST_ASSERT_EQUAL_INT32(1, getDataIncomingConn.serverId);
    TEST_ASSERT_EQUAL_INT32(63713, getDataIncomingConn.remotePort);
    TEST_ASSERT_EQUAL_STRING("192.168.32.68", getDataIncomingConn.remoteIp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq 0x7b07(%rip), %r14      # 0xc120
movq %r14, %rdi
callq 0x1584
movzbl %al, %esi
movl $0x1, %edi
movl $0x215, %ecx            # imm = 0x215
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28ed
movslq %eax, %rsi
movl $0x217, %ecx            # imm = 0x217
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movslq 0x4(%rbx), %rsi
movl $0xb, %edi
movl $0x218, %ecx            # imm = 0x218
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movslq 0x8(%rbx), %rsi
movl $0x1, %edi
movl $0x219, %ecx            # imm = 0x219
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movzwl 0x1c(%rbx), %esi
movl $0xf8e1, %edi           # imm = 0xF8E1
movl $0x21a, %ecx            # imm = 0x21A
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
leaq 0xc(%rsp), %rsi
leaq 0x35dd(%rip), %rdi      # 0x7c97
movl $0x21b, %ecx            # imm = 0x21B
xorl %edx, %edx
callq 0x5dd3
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_QIURC_closedConnection
void test_modem_QIURC_closedConnection(){
    cmError_t retValue = CM_FAIL; 
    asynEventURC_t getDataClosedConn ;

    TEST_ASSERT_EQUAL_INT32(1 ,cmIsAsyncEvent(&cmData));
    retValue = cellModem_UrcGetClosedConnection(&cmData, &getDataClosedConn);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT32(10, getDataClosedConn.connectId);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7a47(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x1584
movzbl %al, %esi
movl $0x1, %edi
movl $0x222, %ecx            # imm = 0x222
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a94
movslq %eax, %rsi
movl $0x224, %ecx            # imm = 0x224
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movslq 0x4(%r14), %rsi
movl $0xa, %edi
movl $0x225, %ecx            # imm = 0x225
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_QIURC_RecvConnection
void test_modem_QIURC_RecvConnection(){
    cmError_t retValue = CM_FAIL; 
    asynEventURC_t getRecvConn ;

    TEST_ASSERT_EQUAL_INT32(1 ,cmIsAsyncEvent(&cmData));
    retValue = cellModem_UrcGetRecvConnection(&cmData, &getRecvConn);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT32(10, getRecvConn.connectId);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x79d2(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x1584
movzbl %al, %esi
movl $0x1, %edi
movl $0x22c, %ecx            # imm = 0x22C
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b50
movslq %eax, %rsi
movl $0x22e, %ecx            # imm = 0x22E
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
movslq 0x4(%r14), %rsi
movl $0xa, %edi
movl $0x22f, %ecx            # imm = 0x22F
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SocketClose
void test_modem_SocketClose(){
    cmError_t retValue = CM_FAIL;
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SocketClose(&cmData,10);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
}

// Assembly:
pushq %rax
leaq 0x3592(%rip), %rax      # 0x7d52
movq %rax, 0x79c9(%rip)      # 0xc190
leaq 0x7952(%rip), %rdi      # 0xc120
movl $0xa, %esi
callq 0x2c0c
movslq %eax, %rsi
movl $0x236, %ecx            # imm = 0x236
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rax
jmp 0x540d
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SocketSendData
void test_modem_SocketSendData(){
    cmError_t retValue = CM_FAIL;
    socketData_t socketData = SOCKETDATA_INITIALIZER;
    char data[1024] = "hola lalala";
    MockResponseExpected = ">";//CM_CMD_MOCK_GENERAL_RESPONSE;
    socketData.connectId = 1;
    //socketData.serviceType = cellModem_SOCKET_SRV_TYPE_TCP;
    socketData.dataToSend = data;
    retValue = cellModem_SocketConfigSendData(&cmData,&socketData);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    retValue = CM_FAIL;
    MockResponseExpected = CM_CMD_MOCK_QISEND_OK_RESPONSE;
    retValue = cellModem_SocketSendData(&cmData,&socketData);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x60(%rbx)
movaps %xmm0, 0x50(%rbx)
movaps %xmm0, 0x40(%rbx)
movaps %xmm0, 0x30(%rbx)
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
leaq 0x3a1e(%rip), %rsi      # 0x8240
leaq 0x70(%rsp), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
callq 0x10c0
leaq 0x39e2(%rip), %rax      # 0x821d
movq %rax, 0x794e(%rip)      # 0xc190
movl $0x1, 0x4c(%rbx)
movq %r14, 0x28(%rbx)
leaq 0x78cc(%rip), %r14      # 0xc120
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27b0
movslq %eax, %rsi
movl $0x242, %ecx            # imm = 0x242
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
leaq 0x28b0(%rip), %rax      # 0x712d
movq %rax, 0x790c(%rip)      # 0xc190
movq %r14, %rdi
movq %rbx, %rsi
callq 0x284f
movslq %eax, %rsi
movl $0x247, %ecx            # imm = 0x247
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x540d
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityPrint
void UnityPrint(const char* string)
{
    const char* pch = string;

    if (pch != NULL)
    {
        while (*pch)
        {
#ifdef UNITY_OUTPUT_COLOR
            /* print ANSI escape code */
            if ((*pch == 27) && (*(pch + 1) == '['))
            {
                pch += UnityPrintAnsiEscapeString(pch);
                continue;
            }
#endif
            UnityPrintChar(pch);
            pch++;
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4c25
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %r14b
testb %r14b, %r14b
je 0x4c21
incq %rbx
leal -0x20(%r14), %eax
movzbl %r14b, %ebp
cmpb $0x5e, %al
ja 0x4bd3
movl %ebp, %edi
jmp 0x4bf4
movl $0x5c, %edi
callq 0x1030
cmpb $0xa, %r14b
je 0x4bef
cmpl $0xd, %ebp
jne 0x4c06
movl $0x72, %edi
jmp 0x4bf4
movl $0x6e, %edi
callq 0x1030
movb (%rbx), %r14b
incq %rbx
testb %r14b, %r14b
jne 0x4bc3
jmp 0x4c21
movl $0x78, %edi
callq 0x1030
movsbq -0x1(%rbx), %rdi
movl $0x2, %esi
callq 0x4cc7
jmp 0x4bf9
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityPrintNumberHex
void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print)
{
    int nibble;
    char nibbles = nibbles_to_print;

    if ((unsigned)nibbles > UNITY_MAX_NIBBLES)
    {
        nibbles = UNITY_MAX_NIBBLES;
    }

    while (nibbles > 0)
    {
        nibbles--;
        nibble = (int)(number >> (nibbles * 4)) & 0x0F;
        if (nibble <= 9)
        {
            UNITY_OUTPUT_CHAR((char)('0' + nibble));
        }
        else
        {
            UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
        }
    }
}

// Assembly:
testb %sil, %sil
je 0x4d25
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl %sil, %eax
cmpb $0x10, %sil
movl $0x10, %ecx
cmovbl %eax, %ecx
movzbl %cl, %r14d
leaq -0x4(,%r14,4), %r15
incq %r14
movl %r15d, %ecx
andb $-0x4, %cl
movq %rbx, %rax
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x1030
decq %r14
addq $-0x4, %r15
cmpq $0x1, %r14
jg 0x4cf3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityPrintNumberByStyle
void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style)
{
    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
    {
        if (style == UNITY_DISPLAY_STYLE_CHAR)
        {
            /* printable characters plus CR & LF are printed */
            UNITY_OUTPUT_CHAR('\'');
            if ((number <= 126) && (number >= 32))
            {
                UNITY_OUTPUT_CHAR((int)number);
            }
            /* write escaped carriage returns */
            else if (number == 13)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('r');
            }
            /* write escaped line feeds */
            else if (number == 10)
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('n');
            }
            /* unprintable characters are shown as codes */
            else
            {
                UNITY_OUTPUT_CHAR('\\');
                UNITY_OUTPUT_CHAR('x');
                UnityPrintNumberHex((UNITY_UINT)number, 2);
            }
            UNITY_OUTPUT_CHAR('\'');
        }
        else
        {
            UnityPrintNumber(number);
        }
    }
    else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
    {
        UnityPrintNumberUnsigned((UNITY_UINT)number);
    }
    else
    {
        UNITY_OUTPUT_CHAR('0');
        UNITY_OUTPUT_CHAR('x');
        UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2));
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x10, %bpl
jne 0x4d67
testb $0x20, %bpl
jne 0x4d87
movl $0x30, %edi
callq 0x1030
movl $0x78, %edi
callq 0x1030
addb %bpl, %bpl
andb $0x1e, %bpl
movzbl %bpl, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4cc7
cmpl $0x91, %ebp
jne 0x4d95
movl $0x27, %edi
callq 0x1030
leaq -0x20(%rbx), %rax
cmpq $0x5e, %rax
ja 0x4da3
movl %ebx, %edi
jmp 0x4dc5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4e12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4df3
movl $0x5c, %edi
callq 0x1030
cmpq $0xa, %rbx
je 0x4dc0
cmpq $0xd, %rbx
jne 0x4dda
movl $0x72, %edi
jmp 0x4dc5
movl $0x6e, %edi
callq 0x1030
movl $0x27, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
movl $0x78, %edi
callq 0x1030
movq %rbx, %rdi
movl $0x2, %esi
callq 0x4cc7
jmp 0x4dca
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityAddMsgIfSpecified
static void UnityAddMsgIfSpecified(const char* msg)
{
    if (msg)
    {
        UnityPrint(UnityStrSpacer);

#ifdef UNITY_PRINT_TEST_CONTEXT
        UNITY_PRINT_TEST_CONTEXT();
#endif
#ifndef UNITY_EXCLUDE_DETAILS
        if (Unity.CurrentDetail1)
        {
            UnityPrint(UnityStrDetail1Name);
            UnityPrint(Unity.CurrentDetail1);
            if (Unity.CurrentDetail2)
            {
                UnityPrint(UnityStrDetail2Name);
                UnityPrint(Unity.CurrentDetail2);
            }
            UnityPrint(UnityStrSpacer);
        }
#endif
        UnityPrint(msg);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x540c
pushq %rbx
movq %rdi, %rbx
leaq 0x3860(%rip), %rdi      # 0x8c0e
callq 0x4bac
cmpq $0x0, 0x7645(%rip)      # 0xca00
je 0x5403
leaq 0x3835(%rip), %rdi      # 0x8bf9
callq 0x4bac
movq 0x7630(%rip), %rdi      # 0xca00
callq 0x4bac
cmpq $0x0, 0x762b(%rip)      # 0xca08
je 0x53f7
leaq 0x381d(%rip), %rdi      # 0x8c03
callq 0x4bac
movq 0x7616(%rip), %rdi      # 0xca08
callq 0x4bac
leaq 0x3810(%rip), %rdi      # 0x8c0e
callq 0x4bac
movq %rbx, %rdi
popq %rbx
jmp 0x4bac
retq
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityAssertGreaterOrLessOrEqualNumber
void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
                                           const UNITY_INT actual,
                                           const UNITY_COMPARISON_T compare,
                                           const char *msg,
                                           const UNITY_LINE_TYPE lineNumber,
                                           const UNITY_DISPLAY_STYLE_T style)
{
    int failed = 0;
    RETURN_IF_FAIL_OR_IGNORE;

    if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; }
    if ((threshold == actual))                               { failed = 1; }

    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
    {
        if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
        if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
    }
    else /* UINT or HEX */
    {
        if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
        if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
    }

    if (failed)
    {
        UnityTestResultsFailBegin(lineNumber);
        UnityPrint(UnityStrExpected);
        UnityPrintNumberByStyle(actual, style);
        if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt);       }
        if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt);       }
        if (compare & UNITY_EQUAL_TO)     { UnityPrint(UnityStrOrEqual);  }
        if (compare == UNITY_NOT_EQUAL)   { UnityPrint(UnityStrNotEqual); }
        UnityPrintNumberByStyle(threshold, style);
        UnityAddMsgIfSpecified(msg);
        UNITY_FAIL_AND_BAIL;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x7591(%rip), %rax      # 0xca38
orq 0x7582(%rip), %rax      # 0xca30
jne 0x559f
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
cmpq %rsi, %rdi
sete %al
testb %r15b, %al
jne 0x5514
movl %r9d, %ebp
movq %rcx, %rbx
testb $0x4, %r15b
sete %al
movl %r15d, %edx
andl $0x2, %edx
shrl %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %ecx, %ecx
xorl %r9d, %r9d
cmpq %r14, %r12
setbe %sil
setae %dil
setle %cl
setge %r9b
testb $0x10, %bpl
cmovel %edi, %r9d
notb %r9b
cmovel %esi, %ecx
testb %dl, %r9b
jne 0x551d
orb %al, %cl
je 0x551d
cmpq %r12, %r14
je 0x551d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rdi
callq 0x5377
leaq 0x3582(%rip), %rdi      # 0x8aae
callq 0x4bac
movq %r12, %rdi
movl %ebp, %esi
callq 0x4d26
testb $0x2, %r15b
je 0x554d
leaq 0x3578(%rip), %rdi      # 0x8ac0
callq 0x4bac
testb $0x4, %r15b
je 0x555f
leaq 0x3586(%rip), %rdi      # 0x8ae0
callq 0x4bac
testb $0x1, %r15b
je 0x5571
leaq 0x3586(%rip), %rdi      # 0x8af2
callq 0x4bac
testl %r15d, %r15d
jne 0x5582
leaq 0x3583(%rip), %rdi      # 0x8b00
callq 0x4bac
movq %r14, %rdi
movl %ebp, %esi
callq 0x4d26
movq %rbx, %rdi
callq 0x539e
movq $0x1, 0x7491(%rip) # 0xca30
leaq 0x749a(%rip), %rdi      # 0xca40
movl $0x1, %esi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityFail
void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
{
    RETURN_IF_FAIL_OR_IGNORE;

    UnityTestResultsBegin(Unity.TestFile, line);
    UnityPrint(UnityStrFail);
    if (msg != NULL)
    {
        UNITY_OUTPUT_CHAR(':');

#ifdef UNITY_PRINT_TEST_CONTEXT
        UNITY_PRINT_TEST_CONTEXT();
#endif
#ifndef UNITY_EXCLUDE_DETAILS
        if (Unity.CurrentDetail1)
        {
            UnityPrint(UnityStrDetail1Name);
            UnityPrint(Unity.CurrentDetail1);
            if (Unity.CurrentDetail2)
            {
                UnityPrint(UnityStrDetail2Name);
                UnityPrint(Unity.CurrentDetail2);
            }
            UnityPrint(UnityStrSpacer);
        }
#endif
        if (msg[0] != ' ')
        {
            UNITY_OUTPUT_CHAR(' ');
        }
        UnityPrint(msg);
    }

    UNITY_FAIL_AND_BAIL;
}

// Assembly:
pushq %rbx
movq 0x66ba(%rip), %rax      # 0xca38
orq 0x66ab(%rip), %rax      # 0xca30
jne 0x6427
movq %rdi, %rbx
movq 0x665b(%rip), %rdi      # 0xc9f0
callq 0x52a6
leaq 0x2667(%rip), %rdi      # 0x8a08
callq 0x4bac
testq %rbx, %rbx
je 0x641c
movl $0x3a, %edi
callq 0x1030
cmpq $0x0, 0x6643(%rip)      # 0xca00
je 0x6405
leaq 0x2833(%rip), %rdi      # 0x8bf9
callq 0x4bac
movq 0x662e(%rip), %rdi      # 0xca00
callq 0x4bac
cmpq $0x0, 0x6629(%rip)      # 0xca08
je 0x63f9
leaq 0x281b(%rip), %rdi      # 0x8c03
callq 0x4bac
movq 0x6614(%rip), %rdi      # 0xca08
callq 0x4bac
leaq 0x280e(%rip), %rdi      # 0x8c0e
callq 0x4bac
cmpb $0x20, (%rbx)
je 0x6414
movl $0x20, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x4bac
movq $0x1, 0x6609(%rip) # 0xca30
leaq 0x6612(%rip), %rdi      # 0xca40
movl $0x1, %esi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityMessage
void UnityMessage(const char* msg, const UNITY_LINE_TYPE line)
{
    UnityTestResultsBegin(Unity.TestFile, line);
    UnityPrint("INFO");
    if (msg != NULL)
    {
      UNITY_OUTPUT_CHAR(':');
      UNITY_OUTPUT_CHAR(' ');
      UnityPrint(msg);
    }
    UNITY_PRINT_EOL();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x6544(%rip), %rdi      # 0xc9f0
callq 0x52a6
leaq 0x27ee(%rip), %rdi      # 0x8ca6
callq 0x4bac
testq %rbx, %rbx
je 0x64de
movl $0x3a, %edi
callq 0x1030
movl $0x20, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x4bac
movl $0xa, %edi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityDefaultTestRun
void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
{
    Unity.CurrentTestName = FuncName;
    Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
    Unity.NumberOfTests++;
    UNITY_CLR_DETAILS();
    UNITY_EXEC_TIME_START();
    if (TEST_PROTECT())
    {
        setUp();
        Func();
    }
    if (TEST_PROTECT())
    {
        tearDown();
    }
    UNITY_EXEC_TIME_STOP();
    UnityConcludeTest();
}

// Assembly:
pushq %rbx
movq %rsi, 0x6507(%rip)      # 0xc9f8
movslq %edx, %rax
movq %rax, 0x6515(%rip)      # 0xca10
incq 0x6516(%rip)            # 0xca18
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x64f1(%rip)     # 0xca00
leaq 0x652a(%rip), %rdi      # 0xca40
callq 0x10b0
testl %eax, %eax
jne 0x6526
callq 0x2c94
callq *%rbx
leaq 0x6513(%rip), %rdi      # 0xca40
callq 0x10b0
testl %eax, %eax
jne 0x653b
callq 0x2c95
callq 0x5248
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzm.c
// Function: usage
static void
usage(void)
{
	printf("usage: lzm [options] <files...>\n");
	printf("	-0		no compression\n");
	printf("	-1		fast compression\n");
	printf("	-2 .. -6	high compression\n");
	printf("	-c		write output to stdout\n");
	printf("	-b <tests>	benchmark mode\n");
	printf("	-d		decompress file\n");
	printf("	-f		overwrite output file\n");
	printf("	-k		keep input file\n");
	printf("	-r		recurse into directories\n");
	printf("	-t		test compressed file\n");
	printf("	-v		be verbose\n");
	printf("	-h		this help message\n");
	printf("	-x <size>	chunk size for compression (KB)\n");
}

// Assembly:
pushq %rax
leaq 0x33b1(%rip), %rdi      # 0x65df
callq 0x1080
leaq 0x33c5(%rip), %rdi      # 0x65ff
callq 0x1080
leaq 0x33cd(%rip), %rdi      # 0x6613
callq 0x1080
leaq 0x33d7(%rip), %rdi      # 0x6629
callq 0x1080
leaq 0x33e6(%rip), %rdi      # 0x6644
callq 0x1080
leaq 0x33f6(%rip), %rdi      # 0x6660
callq 0x1080
leaq 0x3405(%rip), %rdi      # 0x667b
callq 0x1080
leaq 0x340e(%rip), %rdi      # 0x6690
callq 0x1080
leaq 0x341d(%rip), %rdi      # 0x66ab
callq 0x1080
leaq 0x3426(%rip), %rdi      # 0x66c0
callq 0x1080
leaq 0x3438(%rip), %rdi      # 0x66de
callq 0x1080
leaq 0x3446(%rip), %rdi      # 0x66f8
callq 0x1080
leaq 0x344a(%rip), %rdi      # 0x6708
callq 0x1080
leaq 0x3455(%rip), %rdi      # 0x671f
popq %rax
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode_none
static unsigned int
lzm_encode_none(
    const struct lzm_state * const state,
    const unsigned char * const buffer_in,
    const unsigned int size_in,
    unsigned char * const buffer_out,
    unsigned int * const size_out)
{
	unsigned char *curr_out;

	(void)state;

	curr_out = output_literals(buffer_out, buffer_in, size_in,
	    buffer_out + *size_out);
	if (curr_out == NULL)
		return EOVERFLOW;

	*size_out = curr_out - buffer_out;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl (%r8), %eax
addq %rcx, %rax
movl %edx, %r15d
addq %r15, %rcx
addq $0x11, %rcx
cmpq %rax, %rcx
jbe 0x4ae1
xorl %r12d, %r12d
jmp 0x4b2e
movb $0x0, (%r14)
movl $0x1, 0x1(%r14)
leaq 0x2(%r14), %r12
testl %edx, %edx
je 0x4b2e
cmpl $0xe, %edx
ja 0x4b0a
shlb $0x4, %dl
movb %dl, (%r14)
movups (%rsi), %xmm0
movups %xmm0, (%r12)
jmp 0x4b2b
movb $-0x10, (%r14)
leal -0xf(%rdx), %eax
cmpl $0xfb, %eax
ja 0x4b4e
leaq 0x3(%r14), %r12
movb %al, 0x2(%r14)
movq %r12, %rdi
movq %r15, %rdx
callq 0x11c0
addq %r15, %r12
testq %r12, %r12
je 0x4b3d
subl %r14d, %r12d
movl %r12d, (%rbx)
xorl %eax, %eax
jmp 0x4b42
movl $0x4b, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1fb, %eax            # imm = 0x1FB
ja 0x4b66
movb $-0x4, 0x2(%r14)
addb $0x4, %al
leaq 0x4(%r14), %r12
movb %al, 0x3(%r14)
jmp 0x4b20
cmpl $0x100fc, %eax          # imm = 0x100FC
ja 0x4b82
movb $-0x3, 0x2(%r14)
addl $0xffffff03, %eax       # imm = 0xFFFFFF03
movw %ax, 0x3(%r14)
leaq 0x5(%r14), %r12
jmp 0x4b20
cmpl $0x10000fd, %eax        # imm = 0x10000FD
ja 0x4b9e
movb $-0x2, 0x2(%r14)
addl $0xfffffef3, %edx       # imm = 0xFFFFFEF3
movl %edx, 0x3(%r14)
leaq 0x6(%r14), %r12
jmp 0x4b20
movb $-0x1, 0x2(%r14)
addl $0xfffffef2, %edx       # imm = 0xFFFFFEF2
movl %edx, 0x3(%r14)
leaq 0x7(%r14), %r12
jmp 0x4b20
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode_init
unsigned int
lzm_encode_init(struct lzm_state ** const state, const unsigned int format,
    const unsigned int level)
{
	struct lzm_state *statep;
	unsigned int ilevel = level;
	int error = 0;

	*state = NULL;

	/* Currently only support the one format */
	if (format != LZM_FORMAT_1)
		return EINVAL;

	if (ilevel == LZM_LEVEL_DEF)
		ilevel = LZM_LEVEL_FAST;

	if (ilevel >= LZM_LEVEL_COUNT)
		return EINVAL;

	error = lzm_malloc((void **)&statep, sizeof(*statep));
	if (error != 0)
		goto out;

	statep->level = ilevel;
	statep->format = format;
	statep->hash_order = lzm_encode_config[statep->level].hash_order;
	statep->hash_buckets = 1 << statep->hash_order;
	statep->chain_order = lzm_encode_config[statep->level].chain_order;
	statep->chain_mask = (1 << statep->chain_order) - 1;
	statep->last_ht = NULL;
	statep->chains = NULL;

	if (statep->hash_order > 0) {
		error = lzm_malloc((void **)&statep->last_ht,
		    sizeof(*statep->last_ht) << statep->hash_order);
		if (error != 0)
			goto out;
	}

	if (statep->chain_order > 0) {
		error = lzm_malloc((void **)&statep->chains,
		    sizeof(*statep->chains) << statep->chain_order);
		if (error != 0)
			goto out;
	}

	*state = statep;

 out:
	if (error != 0)
		lzm_encode_finish(statep);

	return error;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, (%rdi)
movl $0x16, %ebp
cmpl $0x1, %esi
jne 0x4c13
cmpl $-0x1, %edx
movl $0x1, %r14d
cmovnel %edx, %r14d
cmpl $0x7, %r14d
ja 0x4c13
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x40, %esi
movl $0x28, %edx
callq 0x1250
movl $0xc, %ebp
testl %eax, %eax
cmovel %eax, %ebp
je 0x4c1e
testl %ebp, %ebp
je 0x4c13
movq 0x8(%rsp), %rdi
callq 0x4cda
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %rax
movl %r14d, 0x20(%rax)
movl $0x1, %edx
movl %edx, 0x24(%rax)
movl %r14d, %esi
shlq $0x4, %rsi
leaq 0x4583(%rip), %rdi      # 0x91c0
movl 0x8(%rsi,%rdi), %ecx
movl %ecx, 0x10(%rax)
shll %cl, %edx
movl %edx, 0x14(%rax)
movl 0xc(%rsi,%rdi), %ecx
movl %ecx, 0x18(%rax)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
shll %cl, %edx
notl %edx
movl %edx, 0x1c(%rax)
xorl %ecx, %ecx
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
movq %rcx, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x4c96
movl $0x8, %eax
shlq %cl, %rax
movl %eax, %edx
movl $0x40, %esi
callq 0x1250
movl $0xc, %ebp
testl %eax, %eax
cmovel %eax, %ebp
jne 0x4c05
movq 0x8(%rsp), %rdi
movl 0x18(%rdi), %ecx
testq %rcx, %rcx
je 0x4ccb
addq $0x8, %rdi
movl $0x8, %eax
shlq %cl, %rax
movl %eax, %edx
movl $0x40, %esi
callq 0x1250
movl $0xc, %ebp
testl %eax, %eax
cmovel %eax, %ebp
jne 0x4c05
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
jmp 0x4c05
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode_finish
unsigned int
lzm_encode_finish(const struct lzm_state * const state)
{
	if (state != NULL) {
		if (state->last_ht != NULL)
			free(state->last_ht);
		if (state->chains != NULL)
			free(state->chains);
		free((void *)state);
	}

	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x4d07
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4cf0
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4cfe
callq 0x1030
movq %rbx, %rdi
callq 0x1030
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: lzm_encode
unsigned int
lzm_encode(const struct lzm_state * const state,
    const unsigned char * const buffer_in,
    const unsigned int size_in, unsigned char * const buffer_out,
    unsigned int * const size_out)
{
	int error;

	if (buffer_in == NULL || buffer_out == NULL)
		return EINVAL;

	if (size_in <= 16) {
		error = lzm_encode_none(state, buffer_in, size_in,
		    buffer_out, size_out);
	} else {
		error = lzm_encode_config[state->level].codec(state,
		    buffer_in, size_in, buffer_out, size_out);

		if (error == EOVERFLOW && state->level != LZM_LEVEL_NONE)
			error = lzm_encode_none(state, buffer_in, size_in,
			    buffer_out, size_out);
	}

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
movl $0x16, %eax
je 0x4d33
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rbx
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x11, %edx
jb 0x4d6d
movq %rdi, %r12
movl 0x20(%rdi), %eax
shlq $0x4, %rax
leaq 0x446f(%rip), %r9       # 0x91c0
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq *(%rax,%r9)
cmpl $0x4b, %eax
jne 0x4d2a
cmpl $0x0, 0x20(%r12)
je 0x4d85
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4ab9
movl $0x4b, %eax
jmp 0x4d2a
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: matchlen
static inline int
matchlen(const unsigned char * const start, const unsigned char * const match,
    const unsigned char * const end)
{
	const unsigned char *curr = start;
	const unsigned char *last = match;
	unsigned long currval, lastval;
	const unsigned int off = start - match;

	if (off <= 8)
		return matchlen_run(start, match, end, run[off]);

	if (likely(curr < (end - 7))) {
		lastval = readmem64(last);
		currval = readmem64(curr);
		if (likely(lastval != currval))
			return (__builtin_ctzl(lastval ^ currval) >> 3);
		last += 8;
		curr += 8;
	}
	while (curr < (end - 7)) {
		lastval = readmem64(last);
		currval = readmem64(curr);
		if (lastval != currval) {
			return (curr - start) +
			    (__builtin_ctzl(lastval ^ currval) >> 3);
		}
		last += 8;
		curr += 8;
	}
	if (curr < (end - 3)) {
		lastval = readmem32(last);
		currval = readmem32(curr);
		if (lastval != currval) {
			return (curr - start) +
			    (__builtin_ctz(lastval ^ currval) >> 3);
		}
		last += 4;
		curr += 4;
	}
	if (curr < (end - 1) && readmem16(last) == readmem16(curr)) {
		last += 2;
		curr += 2;
	}
	if (curr < end && *last == *curr)
		curr++;

	return curr - start;
}

// Assembly:
movq %rdi, %rcx
subq %rsi, %rcx
cmpl $0x8, %ecx
ja 0x4df9
leaq -0x7(%rdx), %r8
cmpq %rsi, %r8
jbe 0x4e1e
movl %ecx, %eax
andl $0xf, %eax
leaq 0x43d4(%rip), %r9       # 0x9180
movzbl (%rax,%r9), %r9d
movq (%rsi), %rsi
movq %rdi, %rax
cmpq %rdi, %r8
jbe 0x4dcc
movq (%rdi), %rax
cmpq %rax, %rsi
jne 0x4e69
leaq (%rdi,%r9), %rax
cmpq %r8, %rax
jae 0x4dee
movl %eax, %r10d
subl %edi, %r10d
movq (%rax), %r11
cmpq %r11, %rsi
jne 0x4e85
addq %r9, %rax
addl %r9d, %r10d
cmpq %r8, %rax
jb 0x4dd7
andl $0xf, %ecx
movq %rax, %rsi
subq %rcx, %rsi
jmp 0x4e21
leaq -0x7(%rdx), %rcx
cmpq %rdi, %rcx
jbe 0x4e93
movq (%rsi), %rax
movq (%rdi), %r8
cmpq %r8, %rax
je 0x4e98
xorq %rax, %r8
bsfq %r8, %rax
jmp 0x4e70
movq %rdi, %rax
leaq -0x3(%rdx), %rcx
cmpq %rcx, %rax
jae 0x4e3c
movl (%rsi), %ecx
movl (%rax), %r8d
cmpl %r8d, %ecx
jne 0x4e74
addq $0x4, %rsi
addq $0x4, %rax
leaq -0x1(%rdx), %rcx
cmpq %rcx, %rax
jae 0x4e55
movzwl (%rsi), %ecx
cmpw (%rax), %cx
jne 0x4e55
addq $0x2, %rsi
addq $0x2, %rax
cmpq %rdx, %rax
jae 0x4e66
movb (%rsi), %cl
xorl %edx, %edx
cmpb (%rax), %cl
sete %dl
addq %rdx, %rax
subl %edi, %eax
retq
xorq %rsi, %rax
bsfq %rax, %rax
shrl $0x3, %eax
retq
subl %edi, %eax
xorl %ecx, %r8d
bsfl %r8d, %ecx
shrl $0x3, %ecx
addl %eax, %ecx
movl %ecx, %eax
retq
xorq %rsi, %r11
bsfq %r11, %rax
shrl $0x3, %eax
addl %r10d, %eax
retq
movq %rdi, %rax
jmp 0x4ea0
addq $0x8, %rsi
leaq 0x8(%rdi), %rax
cmpq %rcx, %rax
jae 0x4e21
movl %eax, %r8d
subl %edi, %r8d
movq (%rsi), %r9
movq (%rax), %r10
cmpq %r10, %r9
jne 0x4ed0
addq $0x8, %rsi
addq $0x8, %rax
addl $0x8, %r8d
cmpq %rcx, %rax
jb 0x4eaf
jmp 0x4e21
xorq %r9, %r10
bsfq %r10, %rax
shrl $0x3, %eax
addl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/lmcilroy[P]lzm/lzmencode.c
// Function: output_match_last
static inline unsigned char *
output_match_last(struct prev_match * const prev, unsigned char *out,
    const unsigned char * const out_limit)
{
	out = output_match(out, prev->lit_start,
	    prev->start - prev->lit_start, prev->start - prev->last,
	    prev->length, out_limit);
	prev->lit_start = prev->start + prev->length;

	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
movl %eax, %r12d
leaq (%r15,%r12), %rcx
addq $0x17, %rcx
cmpq %rdx, %rcx
jbe 0x4f14
xorl %r14d, %r14d
jmp 0x4fb0
movl 0x18(%rbx), %r13d
subl 0x10(%rbx), %edi
movb $0x0, (%r15)
xorl %ecx, %ecx
testl %edi, %edi
sete %cl
orl %edi, %ecx
bsrl %ecx, %edx
xorl $0x1f, %edx
leaq 0x184b(%rip), %r8       # 0x6780
movl (%r8,%rdx,8), %ecx
shll %cl, %edi
orl 0x4(%r8,%rdx,8), %edi
leal -0x4(%r13), %ebp
movl %edi, 0x1(%r15)
leaq (%r15,%rcx), %r14
incq %r14
testl %eax, %eax
je 0x4f8a
cmpl $0xe, %eax
ja 0x4f67
shlb $0x4, %al
movb %al, (%r15)
movups (%rsi), %xmm0
movups %xmm0, (%r14)
jmp 0x4f87
movb $-0x10, (%r15)
leal -0xf(%rax), %ecx
cmpl $0xfb, %ecx
ja 0x4fe3
movb %cl, (%r14)
incq %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x11c0
addq %r12, %r14
movb (%r15), %al
cmpl $0xe, %ebp
ja 0x4f9a
orb %bpl, %al
movb %al, (%r15)
jmp 0x4fb0
orb $0xf, %al
movb %al, (%r15)
leal -0x13(%r13), %eax
cmpl $0xfb, %eax
ja 0x4fcc
movb %al, (%r14)
incq %r14
movl 0x18(%rbx), %eax
addq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1fb, %eax            # imm = 0x1FB
ja 0x4ffc
movb $-0x4, (%r14)
addb $0x4, %al
movb %al, 0x1(%r14)
addq $0x2, %r14
jmp 0x4fb0
cmpl $0x1fb, %ecx            # imm = 0x1FB
ja 0x5017
movb $-0x4, (%r14)
addb $0x4, %cl
movb %cl, 0x1(%r14)
addq $0x2, %r14
jmp 0x4f7c
cmpl $0x100fc, %eax          # imm = 0x100FC
ja 0x5037
movb $-0x3, (%r14)
addl $0xffffff03, %eax       # imm = 0xFFFFFF03
movw %ax, 0x1(%r14)
addq $0x3, %r14
jmp 0x4fb0
cmpl $0x100fc, %ecx          # imm = 0x100FC
ja 0x5056
movb $-0x3, (%r14)
addl $0xffffff03, %ecx       # imm = 0xFFFFFF03
movw %cx, 0x1(%r14)
addq $0x3, %r14
jmp 0x4f7c
cmpl $0x10000fd, %eax        # imm = 0x10000FD
ja 0x5074
movb $-0x2, (%r14)
addl $0xfffffeef, %r13d      # imm = 0xFFFFFEEF
movl %r13d, 0x1(%r14)
addq $0x4, %r14
jmp 0x4fb0
cmpl $0x10000fd, %ecx        # imm = 0x10000FD
ja 0x508c
movb $-0x2, (%r14)
addl $0xfffffef3, %eax       # imm = 0xFFFFFEF3
movl %eax, 0x1(%r14)
addq $0x4, %r14
jmp 0x4f7c
movb $-0x1, (%r14)
addl $0xfffffeee, %r13d      # imm = 0xFFFFFEEE
movl %r13d, 0x1(%r14)
addq $0x5, %r14
jmp 0x4fb0
movb $-0x1, (%r14)
addl $0xfffffef2, %eax       # imm = 0xFFFFFEF2
movl %eax, 0x1(%r14)
addq $0x5, %r14
jmp 0x4f7c
nop
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: km_stat_print
void km_stat_print(const void *km)
{
	km_stat_t st;
	km_stat(km, &st);
	fprintf(stderr, "[km_stat] cap=%ld, avail=%ld, largest=%ld, n_core=%ld, n_block=%ld\n",
			st.capacity, st.available, st.largest, st.n_blocks, st.n_cores);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x33bd
movq 0x2fc1f(%rip), %rax     # 0x31ff8
movq (%rax), %rdi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %r8
movq 0x10(%rbx), %r9
movq 0x18(%rbx), %rax
movq %rax, (%rsp)
leaq 0x25cbf(%rip), %rsi     # 0x280b9
xorl %eax, %eax
callq 0x2210
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: km_init2
void *km_init2(void *km_par, size_t min_core_size)
{
	kmem_t *km;
	km = (kmem_t*)kcalloc(km_par, 1, sizeof(kmem_t));
	km->par = km_par;
	if (km_par) km->min_core_size = min_core_size > 0? min_core_size : ((kmem_t*)km_par)->min_core_size - 2;
	else km->min_core_size = min_core_size > 0? min_core_size : 0x80000;
	return (void*)km;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
movl $0x30, %edx
callq 0x3054
movq %r14, (%rax)
testq %r14, %r14
je 0x303c
testq %rbx, %rbx
jne 0x3048
movq 0x8(%r14), %rbx
addq $-0x2, %rbx
jmp 0x3048
testq %rbx, %rbx
movl $0x80000, %ecx          # imm = 0x80000
cmoveq %rcx, %rbx
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: kcalloc
void *kcalloc(void *_km, size_t count, size_t size)
{
	kmem_t *km = (kmem_t*)_km;
	void *p;
	if (size == 0 || count == 0) return 0;
	if (km == NULL) return calloc(count, size);
	p = kmalloc(km, count * size);
	memset(p, 0, count * size);
	return p;
}

// Assembly:
pushq %rbx
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x3069
xorl %eax, %eax
popq %rbx
retq
movq %rdx, %rbx
testq %rdi, %rdi
je 0x308b
imulq %rsi, %rbx
movq %rbx, %rsi
callq 0x31c1
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x2180
movq %rsi, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x21e0
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: km_destroy
void km_destroy(void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	void *km_par;
	header_t *p, *q;
	if (km == NULL) return;
	km_par = km->par;
	for (p = km->core_head; p != NULL;) {
		q = p->ptr;
		kfree(km_par, p);
		p = q;
	}
	kfree(km_par, km);
}

// Assembly:
testq %rdi, %rdi
je 0x30f5
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x30e5
movq 0x8(%rsi), %r15
movq %r14, %rdi
callq 0x30f6
movq %r15, %rsi
testq %r15, %r15
jne 0x30d1
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x30f6
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: kmalloc
void *kmalloc(void *_km, size_t n_bytes)
{
	kmem_t *km = (kmem_t*)_km;
	size_t n_units;
	header_t *p, *q;

	if (n_bytes == 0) return 0;
	if (km == NULL) return malloc(n_bytes);
	n_units = (n_bytes + sizeof(size_t) + sizeof(header_t) - 1) / sizeof(header_t); /* header+n_bytes requires at least this number of units */

	if (!(q = km->loop_head)) /* the first time when kmalloc() is called, intialize it */
		q = km->loop_head = km->base.ptr = &km->base;
	for (p = q->ptr;; q = p, p = p->ptr) { /* search for a suitable block */
		if (p->size >= n_units) { /* p->size if the size of current block. This line means the current block is large enough. */
			if (p->size == n_units) q->ptr = p->ptr; /* no need to split the block */
			else { /* split the block. NB: memory is allocated at the end of the block! */
				p->size -= n_units; /* reduce the size of the free block */
				p += p->size; /* p points to the allocated block */
				*(size_t*)p = n_units; /* set the size */
			}
			km->loop_head = q; /* set the end of chain */
			return (size_t*)p + 1;
		}
		if (p == km->loop_head) { /* then ask for more "cores" */
			if ((p = morecore(km, n_units)) == 0) return 0;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x3280
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x3284
addq $0x17, %r14
shrq $0x4, %r14
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
jne 0x31fb
leaq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq 0x8(%rcx), %rsi
movq (%rsi), %rdx
cmpq %r14, %rdx
jae 0x3291
cmpq 0x20(%rbx), %rsi
jne 0x326c
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, %r15
addq %r14, %r15
movq %r15, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r15
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x31c1
testq %rax, %rax
je 0x32bf
movq 0x28(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rax)
movq %rax, 0x28(%rbx)
decq %r15
movq %r15, 0x10(%rax)
addq $0x18, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30f6
movq 0x20(%rbx), %rsi
testq %rsi, %rsi
je 0x3280
movq 0x8(%rsi), %rax
movq (%rax), %rdx
movq %rsi, %rcx
movq %rax, %rsi
cmpq %r14, %rdx
jb 0x320b
jmp 0x3294
xorl %eax, %eax
jmp 0x32b9
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2280
movq %rsi, %rax
subq %r14, %rdx
jne 0x32a3
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rcx)
jmp 0x32b1
movq %rdx, (%rax)
shlq $0x4, %rdx
movq %r14, (%rax,%rdx)
addq %rdx, %rax
movq %rcx, 0x20(%rbx)
addq $0x8, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2451
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: krealloc
void *krealloc(void *_km, void *ap, size_t n_bytes) // TODO: this can be made more efficient in principle
{
	kmem_t *km = (kmem_t*)_km;
	size_t cap, *p, *q;

	if (n_bytes == 0) {
		kfree(km, ap); return 0;
	}
	if (km == NULL) return realloc(ap, n_bytes);
	if (ap == NULL) return kmalloc(km, n_bytes);
	p = (size_t*)ap - 1;
	cap = (*p) * sizeof(header_t) - sizeof(size_t);
	if (cap >= n_bytes) return ap; /* TODO: this prevents shrinking */
	q = (size_t*)kmalloc(km, n_bytes);
	memcpy(q, ap, cap);
	kfree(km, ap);
	return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x331e
testq %r14, %r14
je 0x333a
testq %rbx, %rbx
je 0x3350
movq -0x8(%rbx), %r15
shlq $0x4, %r15
addq $-0x8, %r15
cmpq %rdx, %r15
jae 0x332b
movq %r14, %rdi
movq %rdx, %rsi
callq 0x31c1
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30f6
movq %r12, %rbx
jmp 0x332b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30f6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22b0
movq %r14, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31c1
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: krelocate
void *krelocate(void *km, void *ap, size_t n_bytes)
{
	void *p;
	if (km == 0 || ap == 0) return ap;
	p = kmalloc(km, n_bytes);
	memcpy(p, ap, n_bytes);
	kfree(km, ap);
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x33ae
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x31c1
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30f6
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kalloc.c
// Function: km_stat
void km_stat(const void *_km, km_stat_t *s)
{
	kmem_t *km = (kmem_t*)_km;
	header_t *p;
	memset(s, 0, sizeof(km_stat_t));
	if (km == NULL || km->loop_head == NULL) return;
	for (p = km->loop_head;; p = p->ptr) {
		s->available += p->size * sizeof(header_t);
		if (p->size != 0) ++s->n_blocks; /* &kmem_t::base is always one of the cores. It is zero-sized. */
		if (p->ptr > p && p + p->size > p->ptr)
			panic("[km_stat] The end of a free block enters another free block.");
		if (p->ptr == km->loop_head) break;
	}
	for (p = km->core_head; p != NULL; p = p->ptr) {
		size_t size = p->size * sizeof(header_t);
		++s->n_cores;
		s->capacity += size;
		s->largest = s->largest > size? s->largest : size;
	}
}

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
movups %xmm0, (%rsi)
movq $0x0, 0x20(%rsi)
testq %rdi, %rdi
je 0x346c
movq 0x20(%rdi), %rdx
testq %rdx, %rdx
je 0x346c
leaq 0x8(%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rdx, %r8
movq (%r8), %r10
testq %r10, %r10
je 0x33fd
incq 0x10(%rsi)
shlq $0x4, %r10
addq %r10, %rcx
movq 0x8(%r8), %r9
cmpq %r8, %r9
seta %r11b
addq %r8, %r10
cmpq %r9, %r10
seta %r8b
andb %r11b, %r8b
cmpb $0x1, %r8b
je 0x346e
movq %r9, %r8
cmpq %rdx, %r9
jne 0x33f1
movq %rcx, (%rax)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x346c
movq (%rsi), %rcx
movq 0x18(%rsi), %rdi
movq 0x20(%rsi), %rdx
movq %rdx, %r8
movq (%rax), %rdx
movq 0x8(%rax), %rax
shlq $0x4, %rdx
incq %rdi
addq %rdx, %rcx
cmpq %rdx, %r8
cmovaq %r8, %rdx
testq %rax, %rax
jne 0x3441
movq %rdi, 0x18(%rsi)
movq %rcx, (%rsi)
movq %rdx, 0x20(%rsi)
popq %rax
retq
movq %rcx, %rdi
movq %rax, %rsi
callq 0x2476
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/lh3[P]minigraph/kthread.c
// Function: kt_for
void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
{
	if (n_threads > 1) {
		int i;
		kt_for_t t;
		pthread_t *tid;
		t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
		t.w = (ktf_worker_t*)calloc(n_threads, sizeof(ktf_worker_t));
		tid = (pthread_t*)calloc(n_threads, sizeof(pthread_t));
		for (i = 0; i < n_threads; ++i)
			t.w[i].t = &t, t.w[i].i = i;
		for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
		for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
		free(tid); free(t.w);
	} else {
		long j;
		for (j = 0; j < n; ++j) func(data, j, 0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
cmpl $0x1, %edi
jle 0x355b
movl %edi, %ebx
movq %rsp, %r13
movq %r12, 0x18(%r13)
movq %r15, 0x20(%r13)
movl %edi, (%r13)
movq %r14, 0x8(%r13)
movl %edi, %r15d
movl $0x10, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r12
movq %rax, 0x10(%r13)
movl $0x8, %esi
movq %r15, %rdi
callq 0x21e0
movq %rax, %r14
addq $0x8, %r12
xorl %eax, %eax
movq %r13, -0x8(%r12)
movq %rax, (%r12)
incq %rax
addq $0x10, %r12
cmpq %rax, %r15
jne 0x34de
shlq $0x4, %r15
xorl %ebp, %ebp
leaq 0x84(%rip), %r12        # 0x3584
movq %r14, %r13
movq 0x10(%rsp), %rcx
addq %rbp, %rcx
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x22c0
addq $0x10, %rbp
addq $0x8, %r13
cmpq %rbp, %r15
jne 0x3503
cmpl $0x2, %ebx
movl $0x1, %r15d
cmovgel %ebx, %r15d
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
xorl %esi, %esi
callq 0x2360
incq %rbx
cmpq %rbx, %r15
jne 0x3534
movq %r14, %rdi
callq 0x2040
movq 0x10(%rsp), %rdi
callq 0x2040
jmp 0x3575
testq %r14, %r14
jle 0x3575
xorl %ebx, %ebx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *%r12
incq %rbx
cmpq %rbx, %r14
jne 0x3562
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq