LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_GetCPIN
void test_modem_GetCPIN(){
    cmError_t retValue = CM_FAIL;
    char getCode[32]={0};

    MockResponseExpected = CM_CMD_MOCK_CPIN_RESPONSE;
    retValue = cellModem_GetCPIN(&cmData,getCode);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_STRING("READY",getCode);

    memset(getCode,0,sizeof(getCode));
    MockResponseExpected = CM_CMD_MOCK_CPIN_RESPONSE_BAD;
    retValue = cellModem_GetCPIN(&cmData,getCode);
    TEST_ASSERT_EQUAL_INT32(CM_ERR_INVALID_RESPONSE,retValue);
    //TEST_ASSERT_EQUAL_STRING("READY",getCode);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
leaq 0x5e36(%rip), %rax      # 0xab0c
movq %rax, 0xa4b3(%rip)      # 0xf190
leaq -0x30(%rbp), %rsi
leaq 0xa438(%rip), %rdi      # 0xf120
callq 0x2a80
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xcc, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x30(%rbp), %rsi
leaq 0x5e0d(%rip), %rdi      # 0xab23
xorl %eax, %eax
movl %eax, %edx
movl $0xcd, %ecx
callq 0x8680
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
leaq 0x5dee(%rip), %rax      # 0xab29
movq %rax, 0xa44e(%rip)      # 0xf190
leaq -0x30(%rbp), %rsi
leaq 0xa3d3(%rip), %rdi      # 0xf120
callq 0x2a80
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xd2, %ecx
movl $0x14, %r8d
callq 0x7460
leaq 0xa3a7(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xd4, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SetApn
void test_modem_SetApn(){
    //TEST_IGNORE_MESSAGE("This Test Was Ignored, This Function Has Not Been Tested, Needs To Be Implemented");
    cmError_t retValue = CM_FAIL;
    cellModemConfig_t config =CELLMODEMCONFIG_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    config.apn ="VATIA.COMCEL.COM.CO";
    config.apnPassw = "CLARO";
    config.apnUser ="COMCEL";
    retValue = cellModem_SetApn(&cmData,&config);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
leaq 0x5f8c(%rip), %rax      # 0xad52
movq %rax, 0xa3c3(%rip)      # 0xf190
leaq 0x5d71(%rip), %rax      # 0xab45
movq %rax, -0x40(%rbp)
leaq 0x5d7a(%rip), %rax      # 0xab59
movq %rax, -0x30(%rbp)
leaq 0x5d75(%rip), %rax      # 0xab5f
movq %rax, -0x38(%rbp)
leaq 0xa32b(%rip), %rdi      # 0xf120
leaq -0x40(%rbp), %rsi
callq 0x1e40
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xe2, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xa2fd(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xe3, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_SetContextProfile
void test_modem_SetContextProfile(){
    //TEST_IGNORE_MESSAGE("This Test Was Ignored, This Function Has Not Been Tested, Needs To Be Implemented");
    cmError_t retValue = CM_FAIL;
    cellModemConfig_t config =CELLMODEMCONFIG_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_GENERAL_RESPONSE;
    config.contextId = 1;
    retValue = cellModem_SetContextProfile(&cmData,&config);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
leaq 0x5edc(%rip), %rax      # 0xad52
movq %rax, 0xa313(%rip)      # 0xf190
movl $0x1, -0x24(%rbp)
leaq 0xa295(%rip), %rdi      # 0xf120
leaq -0x40(%rbp), %rsi
callq 0x1fc0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xee, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xa267(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xef, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
leaq 0x5c60(%rip), %rax      # 0xab66
movq %rax, 0xa283(%rip)      # 0xf190
leaq 0xa20c(%rip), %rdi      # 0xf120
leaq -0x40(%rbp), %rsi
callq 0x2b70
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xf8, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x24(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xfa, %ecx
movl $0x14, %r8d
callq 0x7460
movslq -0x20(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xfb, %ecx
movl $0x14, %r8d
callq 0x7460
movslq -0x1c(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xfc, %ecx
movl $0x14, %r8d
callq 0x7460
leaq -0x40(%rbp), %rsi
addq $0x28, %rsi
leaq 0x5bed(%rip), %rdi      # 0xab8e
xorl %eax, %eax
movl %eax, %edx
movl $0xfd, %ecx
callq 0x8680
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
leaq 0x5d8c(%rip), %rax      # 0xad52
movq %rax, 0xa1c3(%rip)      # 0xf190
leaq 0xa14c(%rip), %rdi      # 0xf120
leaq -0x40(%rbp), %rsi
callq 0x2b70
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x103, %ecx            # imm = 0x103
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xa11e(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x104, %ecx            # imm = 0x104
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5d0c(%rip), %rax      # 0xad52
movq %rax, 0xa143(%rip)      # 0xf190
leaq 0xa0cc(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x2cf0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x10c, %ecx            # imm = 0x10C
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x5b19(%rip), %rax      # 0xab9c
movq %rax, 0xa106(%rip)      # 0xf190
leaq 0xa08f(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x2cf0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x110, %ecx            # imm = 0x110
movl $0x14, %r8d
callq 0x7460
leaq 0xa05e(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x111, %ecx            # imm = 0x111
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5c4c(%rip), %rax      # 0xad52
movq %rax, 0xa083(%rip)      # 0xf190
leaq 0xa00c(%rip), %rdi      # 0xf120
xorl %esi, %esi
callq 0x2da0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x11a, %ecx            # imm = 0x11A
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x5c12(%rip), %rax      # 0xad52
movq %rax, 0xa049(%rip)      # 0xf190
leaq 0x9fd2(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x2da0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x11f, %ecx            # imm = 0x11F
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9fa3(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x120, %ecx            # imm = 0x120
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5b8c(%rip), %rax      # 0xad52
movq %rax, 0x9fc3(%rip)      # 0xf190
leaq 0x9f4c(%rip), %rdi      # 0xf120
callq 0x2e50
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x129, %ecx            # imm = 0x129
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9f22(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x12a, %ecx            # imm = 0x12A
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5b0c(%rip), %rax      # 0xad52
movq %rax, 0x9f43(%rip)      # 0xf190
leaq 0x9ecc(%rip), %rdi      # 0xf120
callq 0x2eb0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x133, %ecx            # imm = 0x133
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9ea2(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x134, %ecx            # imm = 0x134
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5f57(%rip), %rax      # 0xb21d
movq %rax, 0x9ec3(%rip)      # 0xf190
leaq 0x9e4c(%rip), %rdi      # 0xf120
leaq 0x58cb(%rip), %rsi      # 0xaba6
callq 0x2f10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x13d, %ecx            # imm = 0x13D
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9e1b(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x13e, %ecx            # imm = 0x13E
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x5a0c(%rip), %rax      # 0xad52
movq %rax, 0x9e43(%rip)      # 0xf190
leaq 0x9dcc(%rip), %rdi      # 0xf120
leaq 0x5856(%rip), %rsi      # 0xabb1
callq 0x2ff0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x147, %ecx            # imm = 0x147
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9d9b(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x148, %ecx            # imm = 0x148
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10a0
leaq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x10a0
leaq 0x57d3(%rip), %rax      # 0xabbf
movq %rax, 0x9d9d(%rip)      # 0xf190
movl $0x0, -0x68(%rbp)
movl $0x1, -0x24(%rbp)
movl $0x1, -0x60(%rbp)
movl $0x3, -0x28(%rbp)
movl $0x3, -0x64(%rbp)
leaq 0x57b9(%rip), %rax      # 0xabd6
movq %rax, -0x90(%rbp)
leaq -0xb0(%rbp), %rdi
leaq 0x57a8(%rip), %rsi      # 0xabda
callq 0x1050
leaq -0xb0(%rbp), %rdi
addq $0x10, %rdi
leaq 0x5921(%rip), %rsi      # 0xad6a
callq 0x1050
leaq -0xb0(%rbp), %rdi
addq $0x18, %rdi
leaq 0x5784(%rip), %rsi      # 0xabe4
callq 0x1050
leaq 0x9cb4(%rip), %rdi      # 0xf120
leaq -0xb0(%rbp), %rsi
callq 0x30e0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x159, %ecx            # imm = 0x159
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x9c83(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x15a, %ecx            # imm = 0x15A
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
leaq 0x8f3a(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movslq %eax, %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x215, %ecx            # imm = 0x215
movl $0x14, %r8d
callq 0x7460
leaq 0x8f0f(%rip), %rdi      # 0xf120
leaq -0x24(%rbp), %rsi
callq 0x3c30
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x217, %ecx            # imm = 0x217
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x20(%rbp), %rsi
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x218, %ecx            # imm = 0x218
movl $0x14, %r8d
callq 0x7460
movslq -0x1c(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x219, %ecx            # imm = 0x219
movl $0x14, %r8d
callq 0x7460
movzwl -0x8(%rbp), %eax
movslq %eax, %rsi
movl $0xf8e1, %edi           # imm = 0xF8E1
xorl %eax, %eax
movl %eax, %edx
movl $0x21a, %ecx            # imm = 0x21A
movl $0x14, %r8d
callq 0x7460
leaq -0x24(%rbp), %rsi
addq $0xc, %rsi
leaq 0x49f6(%rip), %rdi      # 0xac97
xorl %eax, %eax
movl %eax, %edx
movl $0x21b, %ecx            # imm = 0x21B
callq 0x8680
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x8e4a(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movslq %eax, %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x222, %ecx            # imm = 0x222
movl $0x14, %r8d
callq 0x7460
leaq 0x8e1f(%rip), %rdi      # 0xf120
leaq -0xc(%rbp), %rsi
callq 0x3e10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x224, %ecx            # imm = 0x224
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x8(%rbp), %rsi
movl $0xa, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x225, %ecx            # imm = 0x225
movl $0x14, %r8d
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x8dba(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movslq %eax, %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x22c, %ecx            # imm = 0x22C
movl $0x14, %r8d
callq 0x7460
leaq 0x8d8f(%rip), %rdi      # 0xf120
leaq -0xc(%rbp), %rsi
callq 0x3f40
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x22e, %ecx            # imm = 0x22E
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x8(%rbp), %rsi
movl $0xa, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x22f, %ecx            # imm = 0x22F
movl $0x14, %r8d
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x495c(%rip), %rax      # 0xad52
movq %rax, 0x8d93(%rip)      # 0xf190
leaq 0x8d1c(%rip), %rdi      # 0xf120
movl $0xa, %esi
callq 0x4070
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x236, %ecx            # imm = 0x236
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x10a0
leaq -0x480(%rbp), %rdi
leaq 0x4dd0(%rip), %rsi      # 0xb240
movl $0x400, %edx            # imm = 0x400
callq 0x10c0
leaq 0x4d9c(%rip), %rax      # 0xb21d
movq %rax, 0x8d08(%rip)      # 0xf190
movl $0x1, -0x2c(%rbp)
leaq -0x480(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x8c7f(%rip), %rdi      # 0xf120
leaq -0x78(%rbp), %rsi
callq 0x39f0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x242, %ecx            # imm = 0x242
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq 0x3c10(%rip), %rax      # 0xa0e6
movq %rax, 0x8cb3(%rip)      # 0xf190
leaq 0x8c3c(%rip), %rdi      # 0xf120
leaq -0x78(%rbp), %rsi
callq 0x3b10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x247, %ecx            # imm = 0x247
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x686f
jmp 0x684d
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x686d
movq -0x10(%rbp), %rdi
callq 0x6880
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x684d
jmp 0x686f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityPrintChar
static void UnityPrintChar(const char* pch)
{
    /* printable characters plus CR & LF are printed */
    if ((*pch <= 126) && (*pch >= 32))
    {
        UNITY_OUTPUT_CHAR(*pch);
    }
    /* write escaped carriage returns */
    else if (*pch == 13)
    {
        UNITY_OUTPUT_CHAR('\\');
        UNITY_OUTPUT_CHAR('r');
    }
    /* write escaped line feeds */
    else if (*pch == 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)*pch, 2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7e, %eax
jg 0x68b2
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x68b2
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x1030
jmp 0x6920
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
jne 0x68d4
movl $0x5c, %edi
callq 0x1030
movl $0x72, %edi
callq 0x1030
jmp 0x691e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x68f6
movl $0x5c, %edi
callq 0x1030
movl $0x6e, %edi
callq 0x1030
jmp 0x691c
movl $0x5c, %edi
callq 0x1030
movl $0x78, %edi
callq 0x1030
movq -0x8(%rbp), %rax
movsbq (%rax), %rdi
movl $0x2, %esi
callq 0x6a40
jmp 0x691e
jmp 0x6920
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x10, %eax
jbe 0x6a65
movb $0x10, -0x11(%rbp)
jmp 0x6a67
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jle 0x6ab4
movb -0x11(%rbp), %al
addb $-0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movsbl -0x11(%rbp), %ecx
shll $0x2, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andl $0xf, %eax
movl %eax, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jg 0x6aa4
movl -0x10(%rbp), %eax
addl $0x30, %eax
movsbl %al, %edi
callq 0x1030
jmp 0x6ab2
movl -0x10(%rbp), %eax
addl $0x37, %eax
movsbl %al, %edi
callq 0x1030
jmp 0x6a67
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x10, %eax
jne 0x6b87
cmpl $0x91, -0xc(%rbp)
jne 0x6b7c
movl $0x27, %edi
callq 0x1030
cmpq $0x7e, -0x8(%rbp)
jg 0x6b10
cmpq $0x20, -0x8(%rbp)
jl 0x6b10
movq -0x8(%rbp), %rax
movl %eax, %edi
callq 0x1030
jmp 0x6b70
cmpq $0xd, -0x8(%rbp)
jne 0x6b2d
movl $0x5c, %edi
callq 0x1030
movl $0x72, %edi
callq 0x1030
jmp 0x6b6e
cmpq $0xa, -0x8(%rbp)
jne 0x6b4a
movl $0x5c, %edi
callq 0x1030
movl $0x6e, %edi
callq 0x1030
jmp 0x6b6c
movl $0x5c, %edi
callq 0x1030
movl $0x78, %edi
callq 0x1030
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x6a40
jmp 0x6b6e
jmp 0x6b70
movl $0x27, %edi
callq 0x1030
jmp 0x6b85
movq -0x8(%rbp), %rdi
callq 0x6bd0
jmp 0x6bc7
movl -0xc(%rbp), %eax
andl $0x20, %eax
cmpl $0x20, %eax
jne 0x6b9d
movq -0x8(%rbp), %rdi
callq 0x6c20
jmp 0x6bc5
movl $0x30, %edi
callq 0x1030
movl $0x78, %edi
callq 0x1030
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
andl $0xf, %eax
shll %eax
movsbl %al, %esi
callq 0x6a40
jmp 0x6bc7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/unity.c
// Function: UnityPrintNumber
void UnityPrintNumber(const UNITY_INT number_to_print)
{
    UNITY_UINT number = (UNITY_UINT)number_to_print;

    if (number_to_print < 0)
    {
        /* A negative number, including MIN negative */
        UNITY_OUTPUT_CHAR('-');
        number = (~number) + 1;
    }
    UnityPrintNumberUnsigned(number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x6c05
movl $0x2d, %edi
callq 0x1030
movq -0x10(%rbp), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6c20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7458
leaq 0x4854(%rip), %rdi      # 0xbc4e
callq 0x6830
cmpq $0x0, 0x8609(%rip)      # 0xfa10
je 0x744f
leaq 0x4829(%rip), %rdi      # 0xbc39
callq 0x6830
movq 0x85f4(%rip), %rdi      # 0xfa10
callq 0x6830
cmpq $0x0, 0x85ef(%rip)      # 0xfa18
je 0x7443
leaq 0x4811(%rip), %rdi      # 0xbc43
callq 0x6830
movq 0x85da(%rip), %rdi      # 0xfa18
callq 0x6830
leaq 0x4804(%rip), %rdi      # 0xbc4e
callq 0x6830
movq -0x8(%rbp), %rdi
callq 0x6830
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x6ab8(%rip)      # 0xfa40
jne 0x8f94
cmpq $0x0, 0x6ab6(%rip)      # 0xfa48
je 0x8fa9
leaq 0x6a65(%rip), %rdi      # 0xfa00
addq $0x50, %rdi
movl $0x1, %esi
callq 0x10d0
movq 0x6a50(%rip), %rdi      # 0xfa00
movq -0x10(%rbp), %rsi
callq 0x7270
leaq 0x2a78(%rip), %rdi      # 0xba38
callq 0x6830
cmpq $0x0, -0x8(%rbp)
je 0x9045
movl $0x3a, %edi
callq 0x1030
cmpq $0x0, 0x6a32(%rip)      # 0xfa10
je 0x9026
leaq 0x2c52(%rip), %rdi      # 0xbc39
callq 0x6830
movq 0x6a1d(%rip), %rdi      # 0xfa10
callq 0x6830
cmpq $0x0, 0x6a18(%rip)      # 0xfa18
je 0x901a
leaq 0x2c3a(%rip), %rdi      # 0xbc43
callq 0x6830
movq 0x6a03(%rip), %rdi      # 0xfa18
callq 0x6830
leaq 0x2c2d(%rip), %rdi      # 0xbc4e
callq 0x6830
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x903c
movl $0x20, %edi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x6830
movq $0x1, 0x69f0(%rip) # 0xfa40
leaq 0x69a9(%rip), %rdi      # 0xfa00
addq $0x50, %rdi
movl $0x1, %esi
callq 0x10d0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x68d9(%rip), %rdi      # 0xfa00
movq -0x10(%rbp), %rsi
callq 0x7270
leaq 0x2baf(%rip), %rdi      # 0xbce6
callq 0x6830
cmpq $0x0, -0x8(%rbp)
je 0x9160
movl $0x3a, %edi
callq 0x1030
movl $0x20, %edi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x6830
movl $0xa, %edi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x687a(%rip)      # 0xfa08
movslq -0x14(%rbp), %rax
movq %rax, 0x6887(%rip)      # 0xfa20
movq 0x6888(%rip), %rax      # 0xfa28
addq $0x1, %rax
movq %rax, 0x687d(%rip)      # 0xfa28
movq $0x0, 0x685a(%rip) # 0xfa10
movq $0x0, 0x6857(%rip) # 0xfa18
jmp 0x91c3
leaq 0x6836(%rip), %rdi      # 0xfa00
addq $0x50, %rdi
callq 0x10b0
cmpl $0x0, %eax
jne 0x91e0
callq 0x4140
callq *-0x8(%rbp)
leaq 0x6819(%rip), %rdi      # 0xfa00
addq $0x50, %rdi
callq 0x10b0
cmpl $0x0, %eax
jne 0x91fa
callq 0x4150
jmp 0x91fc
jmp 0x91fe
callq 0x71e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x5bb6(%rip), %rdi      # 0x71a1
movb $0x0, %al
callq 0x10e0
leaq 0x5bc9(%rip), %rdi      # 0x71c2
movb $0x0, %al
callq 0x10e0
leaq 0x5bd0(%rip), %rdi      # 0x71d7
movb $0x0, %al
callq 0x10e0
leaq 0x5bd9(%rip), %rdi      # 0x71ee
movb $0x0, %al
callq 0x10e0
leaq 0x5be7(%rip), %rdi      # 0x720a
movb $0x0, %al
callq 0x10e0
leaq 0x5bf6(%rip), %rdi      # 0x7227
movb $0x0, %al
callq 0x10e0
leaq 0x5c04(%rip), %rdi      # 0x7243
movb $0x0, %al
callq 0x10e0
leaq 0x5c0c(%rip), %rdi      # 0x7259
movb $0x0, %al
callq 0x10e0
leaq 0x5c1a(%rip), %rdi      # 0x7275
movb $0x0, %al
callq 0x10e0
leaq 0x5c22(%rip), %rdi      # 0x728b
movb $0x0, %al
callq 0x10e0
leaq 0x5c33(%rip), %rdi      # 0x72aa
movb $0x0, %al
callq 0x10e0
leaq 0x5c40(%rip), %rdi      # 0x72c5
movb $0x0, %al
callq 0x10e0
leaq 0x5c43(%rip), %rdi      # 0x72d6
movb $0x0, %al
callq 0x10e0
leaq 0x5c4d(%rip), %rdi      # 0x72ee
movb $0x0, %al
callq 0x10e0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: process_path
static unsigned int
process_path(struct compress_args * const args)
{
	struct stat st;
	int ret;

	if (args->filename[0] == '-' && args->filename[1] == 0) {
		ret = process_stdin(args);
		goto out;
	}

	ret = stat(args->filename, &st);
	if (ret < 0) {
		ret = errno;
		fprintf(stderr, "File %s: cannot stat: %s\n",
		    args->filename, strerror(ret));
		goto out;
	}

	if (S_ISDIR(st.st_mode)) {
		if (args->recurse == false) {
			ret = EISDIR;
			fprintf(stderr, "File %s: is a directory\n",
			    args->filename);
			goto out;
		}

		ret = process_dir(args);
		goto out;
	}

	if (!S_ISREG(st.st_mode)) {
		ret = EINVAL;
		fprintf(stderr, "File %s: not a regular file\n",
		    args->filename);
		goto out;
	}

	args->st = &st;
	ret = process_file(args);

 out:
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x16f4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x16f4
movq -0x8(%rbp), %rdi
callq 0x1840
movl %eax, -0x9c(%rbp)
jmp 0x1824
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x98(%rbp), %rsi
callq 0x11a0
movl %eax, -0x9c(%rbp)
cmpl $0x0, -0x9c(%rbp)
jge 0x1773
callq 0x1040
movl (%rax), %eax
movl %eax, -0x9c(%rbp)
movq 0x88cd(%rip), %rax      # 0x9ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
movl -0x9c(%rbp), %edi
callq 0x1250
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0x5bb3(%rip), %rsi      # 0x731a
movb $0x0, %al
callq 0x1190
jmp 0x1824
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x17cc
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1028(%rax)
jne 0x17bb
movl $0x15, -0x9c(%rbp)
movq 0x8858(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x5b82(%rip), %rsi      # 0x7334
movb $0x0, %al
callq 0x1190
jmp 0x1824
movq -0x8(%rbp), %rdi
callq 0x1910
movl %eax, -0x9c(%rbp)
jmp 0x1824
movl -0x80(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x1807
movl $0x16, -0x9c(%rbp)
movq 0x880c(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x5b4f(%rip), %rsi      # 0x734d
movb $0x0, %al
callq 0x1190
jmp 0x1824
movq -0x8(%rbp), %rax
leaq -0x98(%rbp), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1ad0
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: process_stdin
static unsigned int
process_stdin(struct compress_args * const args)
{
	int fd_in = -1;
	int fd_out = -1;
	int ret;

	fd_in = STDIN_FILENO;
	if (isatty(fd_in)) {
		ret = EIO;
		fprintf(stderr, "Will not read from terminal\n");
		goto out;
	}
	args->filename = "(stdin)";

	if (args->test == false) {
		fd_out = STDOUT_FILENO;
		if (isatty(fd_out)) {
			ret = EIO;
			fprintf(stderr, "Will not write to terminal\n");
			goto out;
		}
		strcpy(args->filename_out, "(stdout)");
	}

	ret = process_data(fd_in, fd_out, args);

 out:
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1080
cmpl $0x0, %eax
je 0x188f
movl $0x5, -0x14(%rbp)
movq 0x877c(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x5ae4(%rip), %rsi      # 0x736a
movb $0x0, %al
callq 0x1190
jmp 0x1906
movq -0x8(%rbp), %rax
leaq 0x5aed(%rip), %rcx      # 0x7387
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1038(%rax)
jne 0x18f4
movl $0x1, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x1080
cmpl $0x0, %eax
je 0x18e0
movl $0x5, -0x14(%rbp)
movq 0x872b(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
leaq 0x5ab8(%rip), %rsi      # 0x738f
movb $0x0, %al
callq 0x1190
jmp 0x1906
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq 0x5abc(%rip), %rsi      # 0x73ab
callq 0x1070
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x2040
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: process_data
static unsigned int
process_data(const int fd_in, const int fd_out,
    struct compress_args * const args)
{
	int ret;

	if (args->compress == true && args->test == false)
		ret = compress_fd(fd_in, fd_out, args);
	else
		ret = decompress_fd(fd_in, fd_out, args);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x1010(%rax)
jne 0x2080
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1038(%rax)
jne 0x2080
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x20a0
movl %eax, -0x14(%rbp)
jmp 0x2092
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2690
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: write_data
static inline unsigned int
write_data(int fd, const void *buffer, const size_t size)
{
	unsigned int resid;
	int ret;

	resid = size;
	while (resid > 0) {
		ret = write(fd, buffer, resid);
		if (ret < 0)
			return errno;
		resid -= ret;
		buffer = (char *)buffer + ret;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x2ec2
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x10a0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x2ea6
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ec9
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x2e7a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lmcilroy[P]lzm/lzm.c
// Function: read_data
static inline unsigned int
read_data(int fd, void *buffer, unsigned int *size)
{
	unsigned int resid;
	int ret;

	resid = *size;
	while (resid > 0) {
		ret = read(fd, buffer, resid);
		if (ret < 0)
			return errno;
		if (ret == 0)
			break;
		resid -= ret;
		buffer = (char *)buffer + ret;
	}

	*size -= resid;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jbe 0x2f4c
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x1150
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x2f28
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f60
cmpl $0x0, -0x20(%rbp)
jne 0x2f30
jmp 0x2f4c
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x2efc
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)