LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_GetContextProfile
void test_modem_GetContextProfile(){
    cmError_t retValue = CM_FAIL;
    cellModemConfig_t config = CELLMODEMCONFIG_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_QIACT_GET_RESPONSE;
    retValue = cellModem_GetContextProfile(&cmData,&config);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
 
    TEST_ASSERT_EQUAL_INT32(1, config.contextId);
    TEST_ASSERT_EQUAL_INT32(1, config.contextState);
    TEST_ASSERT_EQUAL_INT32(1, config.contextType);
    TEST_ASSERT_EQUAL_STRING("10.101.234.65",config.contextIpAddres);

/*respuesta mala,no se usan datos*/
    memset(&config, 0 ,sizeof(config));
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_GetContextProfile(&cmData,&config);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
xorl %r12d, %r12d
movq %r12, 0x30(%r14)
leaq 0x43b7(%rip), %rax      # 0x7b66
movq %rax, 0x89da(%rip)      # 0xc190
leaq 0x8963(%rip), %rbx      # 0xc120
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f47
movslq %eax, %rsi
movl $0xf8, %ecx
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x1c(%r14), %rsi
movl $0x1, %edi
movl $0xfa, %ecx
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x20(%r14), %rsi
movl $0x1, %edi
movl $0xfb, %ecx
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x24(%r14), %rsi
movl $0x1, %edi
movl $0xfc, %ecx
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
leaq 0x28(%rsp), %r15
leaq 0x4352(%rip), %rdi      # 0x7b8e
movl $0xfd, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x5e70
movq %r12, 0x8(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%r15)
movaps %xmm0, -0x18(%r15)
movaps %xmm0, -0x28(%r15)
leaq 0x44ea(%rip), %rax      # 0x7d52
movq %rax, 0x8921(%rip)      # 0xc190
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f47
movslq %eax, %rsi
movl $0x103, %ecx            # imm = 0x103
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x104, %ecx            # imm = 0x104
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SetDeactContextProfile
void test_modem_SetDeactContextProfile(){
    cmError_t retValue = CM_FAIL;
  
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SetDeactContextProfile(&cmData, 1);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    MockResponseExpected = CM_CMD_MOCK_ERROR_GENERAL_RESPONSE;
    retValue = cellModem_SetDeactContextProfile(&cmData, 1);
    TEST_ASSERT_EQUAL_INT32(CM_ERR_INVALID_RESPONSE,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbx
leaq 0x448e(%rip), %rax      # 0x7d52
movq %rax, 0x88c5(%rip)      # 0xc190
leaq 0x884e(%rip), %rbx      # 0xc120
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2060
movslq %eax, %rsi
movl $0x10c, %ecx            # imm = 0x10C
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
leaq 0x429f(%rip), %rax      # 0x7b9c
movq %rax, 0x888c(%rip)      # 0xc190
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2060
movslq %eax, %rsi
movl $0x3, %edi
movl $0x110, %ecx            # imm = 0x110
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x111, %ecx            # imm = 0x111
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SmsSetMessageFormat
void test_modem_SmsSetMessageFormat(){
    cmError_t retValue = CM_FAIL;
    
    /*DPU format*/
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSetMessageFormat(&cmData, 0);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    /*text format*/
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSetMessageFormat(&cmData,1);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x43fc(%rip), %r14      # 0x7d52
movq %r14, 0x8833(%rip)      # 0xc190
leaq 0x87bc(%rip), %rbx      # 0xc120
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20ab
movslq %eax, %rsi
movl $0x11a, %ecx            # imm = 0x11A
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %r14, 0x8804(%rip)      # 0xc190
movq %rbx, %rdi
movl $0x1, %esi
callq 0x20ab
movslq %eax, %rsi
movl $0x11f, %ecx            # imm = 0x11F
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x120, %ecx            # imm = 0x120
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SmsSetTextModeParam
void test_modem_SmsSetTextModeParam(){
    cmError_t retValue = CM_FAIL;
    
    /*text format*/
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSetTextModeParam(&cmData);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbx
leaq 0x4374(%rip), %rax      # 0x7d52
movq %rax, 0x87ab(%rip)      # 0xc190
leaq 0x8734(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x20f6
movslq %eax, %rsi
movl $0x129, %ecx            # imm = 0x129
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x12a, %ecx            # imm = 0x12A
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SmsSetTeCharacterGsm
void test_modem_SmsSetTeCharacterGsm(){
    cmError_t retValue = CM_FAIL;
    
    /*GSM default alphabet */
    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSetTeCharacterGsm(&cmData);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbx
leaq 0x431f(%rip), %rax      # 0x7d52
movq %rax, 0x8756(%rip)      # 0xc190
leaq 0x86df(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x2120
movslq %eax, %rsi
movl $0x133, %ecx            # imm = 0x133
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x134, %ecx            # imm = 0x134
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SmsSendNumber
void test_modem_SmsSendNumber(){
    cmError_t retValue = CM_FAIL;
    
    /*GSM default alphabet */
    MockResponseExpected = ">";//CM_CMD_MOCK_GENERAL_RESPONSE;
    retValue = cellModem_SmsSendNumber(&cmData,"3146644565");
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbx
leaq 0x4795(%rip), %rax      # 0x821d
movq %rax, 0x8701(%rip)      # 0xc190
leaq 0x868a(%rip), %rbx      # 0xc120
leaq 0x4109(%rip), %rsi      # 0x7ba6
movq %rbx, %rdi
callq 0x214a
movslq %eax, %rsi
movl $0x13d, %ecx            # imm = 0x13D
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x13e, %ecx            # imm = 0x13E
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/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 0x426e(%rip), %rax      # 0x7d52
movq %rax, 0x86a5(%rip)      # 0xc190
leaq 0x862e(%rip), %rbx      # 0xc120
leaq 0x40b8(%rip), %rsi      # 0x7bb1
movq %rbx, %rdi
callq 0x21d1
movslq %eax, %rsi
movl $0x147, %ecx            # imm = 0x147
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x148, %ecx            # imm = 0x148
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rbx
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/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
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
movq $0x0, 0x68(%rsi)
leaq 0x4055(%rip), %rax      # 0x7bbf
movq %rax, 0x861f(%rip)      # 0xc190
movabsq $0x100000003, %rax      # imm = 0x100000003
movq %rax, 0x4c(%rsi)
leaq 0x4050(%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 0x856b(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x2268
movslq %eax, %rsi
movl $0x159, %ecx            # imm = 0x159
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x15a, %ecx            # imm = 0x15A
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7b3e(%rip), %r14      # 0xc120
movq %r14, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x1, %edi
movl $0x215, %ecx            # imm = 0x215
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28c3
movslq %eax, %rsi
movl $0x217, %ecx            # imm = 0x217
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x4(%rbx), %rsi
movl $0xb, %edi
movl $0x218, %ecx            # imm = 0x218
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x8(%rbx), %rsi
movl $0x1, %edi
movl $0x219, %ecx            # imm = 0x219
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movzwl 0x1c(%rbx), %esi
movl $0xf8e1, %edi           # imm = 0xF8E1
movl $0x21a, %ecx            # imm = 0x21A
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
leaq 0xc(%rsp), %rsi
leaq 0x3614(%rip), %rdi      # 0x7c97
movl $0x21b, %ecx            # imm = 0x21B
xorl %edx, %edx
callq 0x5e70
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a7e(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x1, %edi
movl $0x222, %ecx            # imm = 0x222
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a6a
movslq %eax, %rsi
movl $0x224, %ecx            # imm = 0x224
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x4(%r14), %rsi
movl $0xa, %edi
movl $0x225, %ecx            # imm = 0x225
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7a09(%rip), %rbx      # 0xc120
movq %rbx, %rdi
callq 0x1563
movzbl %al, %esi
movl $0x1, %edi
movl $0x22c, %ecx            # imm = 0x22C
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b26
movslq %eax, %rsi
movl $0x22e, %ecx            # imm = 0x22E
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
movslq 0x4(%r14), %rsi
movl $0xa, %edi
movl $0x22f, %ecx            # imm = 0x22F
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x35c9(%rip), %rax      # 0x7d52
movq %rax, 0x7a00(%rip)      # 0xc190
leaq 0x7989(%rip), %rdi      # 0xc120
movl $0xa, %esi
callq 0x2be2
movslq %eax, %rsi
movl $0x236, %ecx            # imm = 0x236
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
popq %rax
jmp 0x5480
// File: /workspace/github_c_makefile_star2_O3/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 0x3a55(%rip), %rsi      # 0x8240
leaq 0x70(%rsp), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
callq 0x10c0
leaq 0x3a19(%rip), %rax      # 0x821d
movq %rax, 0x7985(%rip)      # 0xc190
movl $0x1, 0x4c(%rbx)
movq %r14, 0x28(%rbx)
leaq 0x7903(%rip), %r14      # 0xc120
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2786
movslq %eax, %rsi
movl $0x242, %ecx            # imm = 0x242
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
leaq 0x28e7(%rip), %rax      # 0x712d
movq %rax, 0x7943(%rip)      # 0xc190
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2825
movslq %eax, %rsi
movl $0x247, %ecx            # imm = 0x247
xorl %edi, %edi
xorl %edx, %edx
movl $0x14, %r8d
callq 0x5480
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4c1f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %r14b
testb %r14b, %r14b
je 0x4c17
leal -0x20(%r14), %eax
movzbl %r14b, %ebp
cmpb $0x5e, %al
jbe 0x4bc1
movl $0x5c, %edi
callq 0x1030
cmpb $0xd, %r14b
je 0x4bbc
cmpl $0xa, %ebp
jne 0x4bd1
movl $0x6e, %ebp
jmp 0x4bc1
movl $0x72, %ebp
movl %ebp, %edi
callq 0x1030
movb 0x1(%rbx), %r14b
incq %rbx
jmp 0x4b8b
movl $0x78, %edi
callq 0x1030
movsbq (%rbx), %r15
movl $0x3, %r12d
movl $0x4, %r14d
movq %r15, %rax
movl %r14d, %ecx
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x1030
decq %r12
addq $-0x4, %r14
cmpq $0x1, %r12
ja 0x4beb
jmp 0x4bc8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d4f
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzbl %sil, %eax
cmpb $0x10, %sil
movl $0x10, %ecx
cmovbl %eax, %ecx
movzbl %cl, %r15d
leaq -0x4(,%r15,4), %r14
incq %r15
movq %rbx, %rax
movl %r14d, %ecx
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x1030
decq %r15
addq $-0x4, %r14
cmpq $0x1, %r15
ja 0x4d20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testb $0x10, %bpl
jne 0x4d99
testb $0x20, %bpl
jne 0x4dd2
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 %r14
popq %r15
popq %rbp
jmp 0x4cf4
cmpl $0x91, %ebp
jne 0x4de4
movl $0x27, %edi
callq 0x1030
leaq -0x20(%rbx), %rax
cmpq $0x5e, %rax
jbe 0x4dfb
movl $0x5c, %edi
callq 0x1030
cmpq $0xd, %rbx
je 0x4df6
cmpq $0xa, %rbx
jne 0x4e16
movl $0x6e, %ebx
jmp 0x4dfb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e77
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4e58
movl $0x72, %ebx
movl %ebx, %edi
callq 0x1030
movl $0x27, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1030
movl $0x78, %edi
callq 0x1030
movl $0x3, %r15d
movl $0x4, %r14d
movq %rbx, %rax
movl %r14d, %ecx
shrq %cl, %rax
andl $0xf, %eax
leal 0x37(%rax), %ecx
leal 0x30(%rax), %edi
cmpl $0xa, %eax
cmovael %ecx, %edi
callq 0x1030
decq %r15
addq $-0x4, %r14
cmpq $0x1, %r15
ja 0x4e2c
jmp 0x4e02
// File: /workspace/github_c_makefile_star2_O3/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 0x547f
pushq %rbx
movq %rdi, %rbx
leaq 0x37ed(%rip), %rdi      # 0x8c0e
callq 0x4b74
cmpq $0x0, 0x75d2(%rip)      # 0xca00
je 0x5476
leaq 0x37c2(%rip), %rdi      # 0x8bf9
callq 0x4b74
movq 0x75bd(%rip), %rdi      # 0xca00
callq 0x4b74
cmpq $0x0, 0x75b8(%rip)      # 0xca08
je 0x546a
leaq 0x37aa(%rip), %rdi      # 0x8c03
callq 0x4b74
movq 0x75a3(%rip), %rdi      # 0xca08
callq 0x4b74
leaq 0x379d(%rip), %rdi      # 0x8c0e
callq 0x4b74
movq %rbx, %rdi
popq %rbx
jmp 0x4b74
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6639(%rip), %rax      # 0xca38
orq 0x662a(%rip), %rax      # 0xca30
jne 0x64a8
movq %rdi, %rbx
movq 0x65da(%rip), %rdi      # 0xc9f0
callq 0x5319
leaq 0x25e6(%rip), %rdi      # 0x8a08
callq 0x4b74
testq %rbx, %rbx
je 0x649d
movl $0x3a, %edi
callq 0x1030
cmpq $0x0, 0x65c2(%rip)      # 0xca00
je 0x6486
leaq 0x27b2(%rip), %rdi      # 0x8bf9
callq 0x4b74
movq 0x65ad(%rip), %rdi      # 0xca00
callq 0x4b74
cmpq $0x0, 0x65a8(%rip)      # 0xca08
je 0x647a
leaq 0x279a(%rip), %rdi      # 0x8c03
callq 0x4b74
movq 0x6593(%rip), %rdi      # 0xca08
callq 0x4b74
leaq 0x278d(%rip), %rdi      # 0x8c0e
callq 0x4b74
cmpb $0x20, (%rbx)
je 0x6495
movl $0x20, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x4b74
movq $0x1, 0x6588(%rip) # 0xca30
leaq 0x6591(%rip), %rdi      # 0xca40
movl $0x1, %esi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O3/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 0x64c3(%rip), %rdi      # 0xc9f0
callq 0x5319
leaq 0x276d(%rip), %rdi      # 0x8ca6
callq 0x4b74
testq %rbx, %rbx
je 0x655f
movl $0x3a, %edi
callq 0x1030
movl $0x20, %edi
callq 0x1030
movq %rbx, %rdi
callq 0x4b74
movl $0xa, %edi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/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, 0x6486(%rip)      # 0xc9f8
movslq %edx, %rax
movq %rax, 0x6494(%rip)      # 0xca10
incq 0x6495(%rip)            # 0xca18
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x6470(%rip)     # 0xca00
leaq 0x64a9(%rip), %rdi      # 0xca40
callq 0x10b0
testl %eax, %eax
jne 0x65a7
callq 0x2c68
callq *%rbx
leaq 0x6492(%rip), %rdi      # 0xca40
callq 0x10b0
testl %eax, %eax
jne 0x65bc
callq 0x2c69
callq 0x52bb
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3355(%rip), %rdi      # 0x65e7
callq 0x1080
leaq 0x3369(%rip), %rdi      # 0x6607
callq 0x1080
leaq 0x3371(%rip), %rdi      # 0x661b
callq 0x1080
leaq 0x337b(%rip), %rdi      # 0x6631
callq 0x1080
leaq 0x338a(%rip), %rdi      # 0x664c
callq 0x1080
leaq 0x339a(%rip), %rdi      # 0x6668
callq 0x1080
leaq 0x33a9(%rip), %rdi      # 0x6683
callq 0x1080
leaq 0x33b2(%rip), %rdi      # 0x6698
callq 0x1080
leaq 0x33c1(%rip), %rdi      # 0x66b3
callq 0x1080
leaq 0x33ca(%rip), %rdi      # 0x66c8
callq 0x1080
leaq 0x33dc(%rip), %rdi      # 0x66e6
callq 0x1080
leaq 0x33ea(%rip), %rdi      # 0x6700
callq 0x1080
leaq 0x33ee(%rip), %rdi      # 0x6710
callq 0x1080
leaq 0x33f9(%rip), %rdi      # 0x6727
popq %rax
jmp 0x1080
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl (%r8), %eax
addq %rcx, %rax
movl %edx, %r15d
addq %r15, %rcx
addq $0x11, %rcx
movl $0x4b, %ebp
cmpq %rax, %rcx
ja 0x4b4b
movq %r8, %rbx
movl $0x1, 0x1(%r14)
leaq 0x2(%r14), %r12
xorl %ebp, %ebp
testl %edx, %edx
je 0x4b18
cmpl $0xe, %edx
ja 0x4b1c
shlb $0x4, %dl
movb %dl, (%r14)
movups (%rsi), %xmm0
movups %xmm0, (%r12)
jmp 0x4b3f
xorl %edx, %edx
jmp 0x4b42
movb $-0x10, (%r14)
leal -0xf(%rdx), %eax
cmpl $0xfb, %eax
ja 0x4b56
leaq 0x3(%r14), %r12
movb %al, 0x2(%r14)
movq %r12, %rdi
movq %r15, %rdx
callq 0x11c0
movb $-0x10, %dl
addq %r15, %r12
movb %dl, (%r14)
subl %r14d, %r12d
movl %r12d, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1fb, %eax            # imm = 0x1FB
ja 0x4b6e
movb $-0x4, 0x2(%r14)
addb $0x4, %al
leaq 0x4(%r14), %r12
movb %al, 0x3(%r14)
jmp 0x4b32
cmpl $0x100fc, %eax          # imm = 0x100FC
ja 0x4b8a
movb $-0x3, 0x2(%r14)
addl $0xffffff03, %eax       # imm = 0xFFFFFF03
movw %ax, 0x3(%r14)
leaq 0x5(%r14), %r12
jmp 0x4b32
cmpl $0x10000fd, %eax        # imm = 0x10000FD
ja 0x4ba6
movb $-0x2, 0x2(%r14)
addl $0xfffffef3, %edx       # imm = 0xFFFFFEF3
movl %edx, 0x3(%r14)
leaq 0x6(%r14), %r12
jmp 0x4b32
movb $-0x1, 0x2(%r14)
addl $0xfffffef2, %edx       # imm = 0xFFFFFEF2
movl %edx, 0x3(%r14)
leaq 0x7(%r14), %r12
jmp 0x4b32
// File: /workspace/github_c_makefile_star2_O3/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:
movq $0x0, (%rdi)
movl $0x16, %eax
cmpl $0x1, %esi
jne 0x4c0f
pushq %rbp
pushq %rbx
pushq %rax
cmpl $-0x1, %edx
movl $0x1, %ebp
cmovnel %edx, %ebp
cmpl $0x7, %ebp
ja 0x4c09
movq %rdi, %rbx
movq %rsp, %rdi
movl $0x40, %esi
movl $0x28, %edx
callq 0x1250
testl %eax, %eax
je 0x4c10
movq (%rsp), %rdi
callq 0x4cb2
movl $0xc, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rsp), %rax
movl %ebp, 0x20(%rax)
movl $0x1, %edx
movl %edx, 0x24(%rax)
movl %ebp, %esi
shlq $0x4, %rsi
leaq 0x4594(%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 (%rsp), %rdi
movq %rcx, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x4c7c
movl $0x8, %eax
shlq %cl, %rax
movl %eax, %edx
movl $0x40, %esi
callq 0x1250
testl %eax, %eax
jne 0x4bfb
movq (%rsp), %rdi
movl 0x18(%rdi), %ecx
testq %rcx, %rcx
je 0x4ca8
addq $0x8, %rdi
movl $0x8, %eax
shlq %cl, %rax
movl %eax, %edx
movl $0x40, %esi
callq 0x1250
testl %eax, %eax
jne 0x4bfb
movq (%rsp), %rdi
movq %rdi, (%rbx)
xorl %eax, %eax
jmp 0x4c09
// File: /workspace/github_c_makefile_star2_O3/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 0x4cdf
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4cc8
callq 0x1030
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4cd6
callq 0x1030
movq %rbx, %rdi
callq 0x1030
popq %rbx
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4d0b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r8, %rbx
movl %edx, %ebp
movq %rsi, %r15
cmpl $0x10, %edx
jbe 0x4d45
movq %rdi, %r12
movl 0x20(%rdi), %eax
shlq $0x4, %rax
leaq 0x4497(%rip), %r9       # 0x91c0
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
callq *(%rax,%r9)
cmpl $0x4b, %eax
jne 0x4d02
cmpl $0x0, 0x20(%r12)
je 0x4d5d
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4ac9
movl $0x4b, %eax
jmp 0x4d02
// File: /workspace/github_c_makefile_star2_O3/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 0x4dcc
leaq -0x7(%rdx), %r8
cmpq %rsi, %r8
jbe 0x4df1
andl $0xf, %ecx
leaq 0x43fe(%rip), %rax      # 0x9180
movzbl (%rcx,%rax), %r9d
movq (%rsi), %rsi
movq %rdi, %rax
cmpq %rdi, %r8
jbe 0x4da2
movq (%rdi), %rax
cmpq %rax, %rsi
jne 0x4e3c
leaq (%rdi,%r9), %rax
cmpq %r8, %rax
jae 0x4dc4
movl %eax, %r10d
subl %edi, %r10d
movq (%rax), %r11
cmpq %r11, %rsi
jne 0x4e58
addq %r9, %rax
addl %r9d, %r10d
cmpq %r8, %rax
jb 0x4dad
movq %rax, %rsi
subq %rcx, %rsi
jmp 0x4df4
leaq -0x7(%rdx), %rcx
cmpq %rdi, %rcx
jbe 0x4e66
movq (%rsi), %rax
movq (%rdi), %r8
cmpq %r8, %rax
je 0x4e6b
xorq %rax, %r8
bsfq %r8, %rax
jmp 0x4e43
movq %rdi, %rax
leaq -0x3(%rdx), %rcx
cmpq %rcx, %rax
jae 0x4e0f
movl (%rsi), %ecx
movl (%rax), %r8d
cmpl %r8d, %ecx
jne 0x4e47
addq $0x4, %rsi
addq $0x4, %rax
leaq -0x1(%rdx), %rcx
cmpq %rcx, %rax
jae 0x4e28
movzwl (%rsi), %ecx
cmpw (%rax), %cx
jne 0x4e28
addq $0x2, %rsi
addq $0x2, %rax
cmpq %rdx, %rax
jae 0x4e39
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 0x4e73
addq $0x8, %rsi
leaq 0x8(%rdi), %rax
cmpq %rcx, %rax
jae 0x4df4
movl %eax, %r8d
subl %edi, %r8d
movq (%rsi), %r9
movq (%rax), %r10
cmpq %r10, %r9
jne 0x4ea3
addq $0x8, %rsi
addq $0x8, %rax
addl $0x8, %r8d
cmpq %rcx, %rax
jb 0x4e82
jmp 0x4df4
xorq %r9, %r10
bsfq %r10, %rax
shrl $0x3, %eax
addl %r8d, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ee7
xorl %r14d, %r14d
jmp 0x4f83
subl 0x10(%rbx), %edi
xorl %ecx, %ecx
testl %edi, %edi
sete %cl
orl %edi, %ecx
bsrl %ecx, %edx
xorl $0x1f, %edx
leaq 0x1880(%rip), %r8       # 0x6780
movl (%r8,%rdx,8), %ecx
shll %cl, %edi
movl 0x18(%rbx), %r13d
orl 0x4(%r8,%rdx,8), %edi
leal -0x4(%r13), %ebp
movl %edi, 0x1(%r15)
leaq (%r15,%rcx), %r14
incq %r14
testl %eax, %eax
je 0x4f36
cmpl $0xe, %eax
ja 0x4f3a
shlb $0x4, %al
movb %al, (%r15)
movups (%rsi), %xmm0
movups %xmm0, (%r14)
jmp 0x4f5d
xorl %eax, %eax
jmp 0x4f60
movb $-0x10, (%r15)
leal -0xf(%rax), %ecx
cmpl $0xfb, %ecx
ja 0x4fb6
movb %cl, (%r14)
incq %r14
movq %r14, %rdi
movq %r12, %rdx
callq 0x11c0
movb (%r15), %al
addq %r12, %r14
cmpl $0xe, %ebp
ja 0x4f6d
orb %bpl, %al
movb %al, (%r15)
jmp 0x4f83
orb $0xf, %al
movb %al, (%r15)
leal -0x13(%r13), %eax
cmpl $0xfb, %eax
ja 0x4f9f
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 0x4fcf
movb $-0x4, (%r14)
addb $0x4, %al
movb %al, 0x1(%r14)
addq $0x2, %r14
jmp 0x4f83
cmpl $0x1fb, %ecx            # imm = 0x1FB
ja 0x4fea
movb $-0x4, (%r14)
addb $0x4, %cl
movb %cl, 0x1(%r14)
addq $0x2, %r14
jmp 0x4f4f
cmpl $0x100fc, %eax          # imm = 0x100FC
ja 0x500a
movb $-0x3, (%r14)
addl $0xffffff03, %eax       # imm = 0xFFFFFF03
movw %ax, 0x1(%r14)
addq $0x3, %r14
jmp 0x4f83
cmpl $0x100fc, %ecx          # imm = 0x100FC
ja 0x5029
movb $-0x3, (%r14)
addl $0xffffff03, %ecx       # imm = 0xFFFFFF03
movw %cx, 0x1(%r14)
addq $0x3, %r14
jmp 0x4f4f
cmpl $0x10000fd, %eax        # imm = 0x10000FD
ja 0x5047
movb $-0x2, (%r14)
addl $0xfffffeef, %r13d      # imm = 0xFFFFFEEF
movl %r13d, 0x1(%r14)
addq $0x4, %r14
jmp 0x4f83
cmpl $0x10000fd, %ecx        # imm = 0x10000FD
ja 0x505f
movb $-0x2, (%r14)
addl $0xfffffef3, %eax       # imm = 0xFFFFFEF3
movl %eax, 0x1(%r14)
addq $0x4, %r14
jmp 0x4f4f
movb $-0x1, (%r14)
addl $0xfffffeee, %r13d      # imm = 0xFFFFFEEE
movl %r13d, 0x1(%r14)
addq $0x5, %r14
jmp 0x4f83
movb $-0x1, (%r14)
addl $0xfffffef2, %eax       # imm = 0xFFFFFEF2
movl %eax, 0x1(%r14)
addq $0x5, %r14
jmp 0x4f4f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x2f84
movq %r14, (%rax)
testq %r14, %r14
je 0x2f6c
testq %rbx, %rbx
jne 0x2f78
movq 0x8(%r14), %rbx
addq $-0x2, %rbx
jmp 0x2f78
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_O3/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 0x2f99
xorl %eax, %eax
popq %rbx
retq
movq %rdx, %rbx
testq %rdi, %rdi
je 0x2fbb
imulq %rsi, %rbx
movq %rbx, %rsi
callq 0x30e5
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_O3/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 0x301e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x28(%rdi), %rsi
testq %rsi, %rsi
je 0x300e
movq 0x8(%rsi), %r15
movq %r14, %rdi
callq 0x301f
movq %r15, %rsi
testq %r15, %r15
jne 0x2ffa
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x301f
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31a6
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x31aa
addq $0x17, %r14
shrq $0x4, %r14
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
jne 0x311f
leaq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
movq 0x8(%rcx), %rsi
movq (%rsi), %rdi
cmpq %r14, %rdi
jae 0x31b7
cmpq %rcx, %rsi
jne 0x3192
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 0x30e5
testq %rax, %rax
je 0x31e8
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 0x301f
movq 0x20(%rbx), %rcx
movq %rcx, %rsi
testq %rcx, %rcx
je 0x31a6
movq 0x8(%rsi), %rax
movq (%rax), %rdi
movq %rsi, %rdx
movq %rax, %rsi
cmpq %r14, %rdi
jb 0x312f
jmp 0x31bd
xorl %eax, %eax
jmp 0x31e2
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2280
movq %rcx, %rdx
movq %rsi, %rax
subq %r14, %rdi
jne 0x31cc
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdx)
jmp 0x31da
movq %rdi, (%rax)
shlq $0x4, %rdi
movq %r14, (%rax,%rdi)
addq %rdi, %rax
movq %rdx, 0x20(%rbx)
addq $0x8, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2451
// File: /workspace/github_c_makefile_star2_O3/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 0x3247
testq %r14, %r14
je 0x3263
testq %rbx, %rbx
je 0x3279
movq -0x8(%rbx), %r15
shlq $0x4, %r15
addq $-0x8, %r15
cmpq %rdx, %r15
jae 0x3254
movq %r14, %rdi
movq %rdx, %rsi
callq 0x30e5
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x301f
movq %r12, %rbx
jmp 0x3254
movq %r14, %rdi
movq %rbx, %rsi
callq 0x301f
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 0x30e5
// File: /workspace/github_c_makefile_star2_O3/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 0x32d7
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x30e5
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2230
movq %r14, %rdi
movq %rbx, %rsi
callq 0x301f
movq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq