LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_GetIccid
cmError_t cellModem_GetIccid(cmData_t *obj,  char *getIccid){
    cmError_t retVal;
    char cmd[15]="AT+QCCID\r";
    char bufferRecv[60];
    char *ptr = NULL;

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) ) ? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE ,bufferRecv ,300);
    if(CM_OK == retVal){
        if( (ptr = strstr(bufferRecv,"+QCCID:")) != NULL ){
            if(getIccid != NULL){
                extractBetween(bufferRecv,' ','\r',getIccid,0);
            }
        
        }
    }
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7cf5(%rip), %rax      # 0xa1df
movq %rax, -0x23(%rbp)
movl 0x7cf3(%rip), %eax      # 0xa1e7
movl %eax, -0x1b(%rbp)
movw 0x7ced(%rip), %ax       # 0xa1eb
movw %ax, -0x17(%rbp)
movb 0x7ce5(%rip), %al       # 0xa1ed
movb %al, -0x15(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x23(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x8812(%rip), %rdx      # 0xad52
leaq 0x868b(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
leaq -0x60(%rbp), %rcx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x25a6
leaq -0x60(%rbp), %rdi
leaq 0x7af0(%rip), %rsi      # 0xa062
callq 0x1110
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x25a4
cmpq $0x0, -0x10(%rbp)
je 0x25a2
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
movl $0xd, %edx
xorl %r8d, %r8d
callq 0x1d10
jmp 0x25a4
jmp 0x25a6
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SetATE
cmError_t cellModem_SetATE(cmData_t *obj, uint8_t echoEn){
    cmError_t retVal;
    char cmd[8]="ATE";
    cmd[3] = (char)( (0 == echoEn ) ? (char)echoEn +'0' : '1');
    cmd[4]  = '\r';
    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) ) ? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE ,NULL ,300);
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x8217(%rip), %rax      # 0xa7f0
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x25f3
movsbl -0x9(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x1c(%rbp)
jmp 0x25fd
movl $0x31, %eax
movl %eax, -0x1c(%rbp)
jmp 0x25fd
movl -0x1c(%rbp), %eax
movb %al, -0x15(%rbp)
movb $0xd, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x871e(%rip), %rdx      # 0xad52
leaq 0x8597(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SetATV
cmError_t cellModem_SetATV(cmData_t *obj, uint8_t value){
    cmError_t retVal = CM_FAIL;
    char cmd[8]="ATV";
    cmd[3] = (char)( (0 == value ) ? (char)value +'0' : '1');
    cmd[4]  = '\r';

    cellModem_SetatvFormat(obj,value);
    cellModem_SetMatchResponseFromIsr(obj, (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE ); /*cambia la respuesta esperada de la Isr*/
    retVal = cmSendCmd(obj,cmd , (0 == value )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,NULL ,300);

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq 0x8178(%rip), %rax      # 0xa7f8
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x269a
movsbl -0x9(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26a4
movl $0x31, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26a4
movl -0x1c(%rbp), %eax
movb %al, -0x15(%rbp)
movb $0xd, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0x2730
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x28(%rbp), %rdi
movl %eax, %edx
xorl %ecx, %ecx
leaq 0x8677(%rip), %rsi      # 0xad52
leaq 0x84f0(%rip), %rax      # 0xabd2
cmpl %edx, %ecx
cmoveq %rax, %rsi
callq 0x2770
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movzbl -0x9(%rbp), %r8d
xorl %ecx, %ecx
leaq 0x864f(%rip), %rdx      # 0xad52
leaq 0x84c8(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_GetCREG
cmError_t cellModem_GetCREG(cmData_t *obj, netRegStatus_t *netRegStatus){
    cmError_t retVal;
    char bufferRecv[60];
    char cmd[10]="AT+CREG?\r";
    char *ptr =NULL;
    char  buffer[4] ={0};

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,bufferRecv ,300); 
    
    if(CM_OK == retVal){
        if( (ptr = strstr(bufferRecv,"+CREG:")) != NULL ){
            if(netRegStatus != NULL){
                extractBetween(bufferRecv,' ',',',buffer,0);
                netRegStatus->n = (int)atoi(buffer);
                memset(buffer,0,sizeof(buffer));
                extractBetween(bufferRecv,',','\r',buffer,1);
                netRegStatus->stat = (int)atoi(buffer);
            }
        }
    }
    
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x78b0(%rip), %rax      # 0xa06a
movq %rax, -0x5a(%rbp)
movw 0x78ad(%rip), %ax       # 0xa072
movw %ax, -0x52(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x6c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x10a0
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x5a(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x8544(%rip), %rdx      # 0xad52
leaq 0x83bd(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
leaq -0x50(%rbp), %rcx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x28c8
leaq -0x50(%rbp), %rdi
leaq 0x7830(%rip), %rsi      # 0xa074
callq 0x1110
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x28c6
cmpq $0x0, -0x10(%rbp)
je 0x28c4
leaq -0x50(%rbp), %rdi
leaq -0x6c(%rbp), %rcx
movl $0x20, %esi
movl $0x2c, %edx
xorl %r8d, %r8d
callq 0x1d10
leaq -0x6c(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
leaq -0x6c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x10a0
leaq -0x50(%rbp), %rdi
leaq -0x6c(%rbp), %rcx
movl $0x2c, %esi
movl $0xd, %edx
movl $0x1, %r8d
callq 0x1d10
leaq -0x6c(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x28c6
jmp 0x28c8
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_GetCPIN
cmError_t cellModem_GetCPIN(cmData_t *obj, char *getCode){
    cmError_t retVal;
    char bufferRecv[60]={0};
    char cmd[10]="AT+CPIN?\r";
    char *ptr = NULL;

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) ) ? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,bufferRecv ,150000); 
    
    if(CM_OK == retVal){
        if( (ptr = strstr(bufferRecv,"+CPIN:")) != NULL ){
            if(getCode != NULL){
                ptr = extractBetween(bufferRecv,' ','\r',getCode,0);
            }
        }
    }
    
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x10a0
movq 0x75e2(%rip), %rax      # 0xa08c
movq %rax, -0x5a(%rbp)
movw 0x75df(%rip), %ax       # 0xa094
movw %ax, -0x52(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x5a(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x8264(%rip), %rdx      # 0xad52
leaq 0x80dd(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
leaq -0x50(%rbp), %rcx
movl $0x249f0, %r8d          # imm = 0x249F0
callq 0x1390
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x2b58
leaq -0x50(%rbp), %rdi
leaq 0x7576(%rip), %rsi      # 0xa096
callq 0x1110
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x2b56
cmpq $0x0, -0x10(%rbp)
je 0x2b54
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x20, %esi
movl $0xd, %edx
xorl %r8d, %r8d
callq 0x1d10
movq %rax, -0x68(%rbp)
jmp 0x2b56
jmp 0x2b58
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_GetContextProfile
cmError_t cellModem_GetContextProfile(cmData_t *obj, cellModemConfig_t *config){  
    cmError_t retVal;
    char bufferRecv[60];
    char cmd[16]="AT+QIACT?\r";
    char *ptr = NULL;
    char  buffer[4] ={0};

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) ) ? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,bufferRecv ,150000); //150 sg
    
    if(CM_OK == retVal){
        if( (ptr = strstr(bufferRecv,"+QIACT:")) != NULL ){
            if(config != NULL){
                ptr = extractBetween(bufferRecv,' ',',',buffer,0);
                config->contextId = (int)atoi(buffer);
                ptr = extractBetween(bufferRecv,',',',',buffer,0);
                config->contextState = (int)atoi(buffer);
                ptr = extractBetween(ptr,',',',',buffer,0);
                config->contextType = (int)atoi(buffer);
                ptr = extractBetween(ptr,'"','"',config->contextIpAddres,0);
            }
        }else{
           // retVal = CM_ERR_INVALID_RESPONSE;
        }
    }
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x7c76(%rip), %rax      # 0xa800
movq %rax, -0x60(%rbp)
movq 0x7c73(%rip), %rax      # 0xa808
movq %rax, -0x58(%rbp)
movq $0x0, -0x68(%rbp)
leaq -0x6c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x10a0
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x8174(%rip), %rdx      # 0xad52
leaq 0x7fed(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
leaq -0x50(%rbp), %rcx
movl $0x249f0, %r8d          # imm = 0x249F0
callq 0x1390
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x2ce1
leaq -0x50(%rbp), %rdi
leaq 0x7489(%rip), %rsi      # 0xa09d
callq 0x1110
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x2cdd
cmpq $0x0, -0x10(%rbp)
je 0x2cdb
leaq -0x50(%rbp), %rdi
leaq -0x6c(%rbp), %rcx
movl $0x20, %esi
movl $0x2c, %edx
xorl %r8d, %r8d
callq 0x1d10
movq %rax, -0x68(%rbp)
leaq -0x6c(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
leaq -0x50(%rbp), %rdi
leaq -0x6c(%rbp), %rcx
movl $0x2c, %edx
xorl %r8d, %r8d
movl %edx, %esi
callq 0x1d10
movq %rax, -0x68(%rbp)
leaq -0x6c(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rcx
movl $0x2c, %edx
xorl %r8d, %r8d
movl %edx, %esi
callq 0x1d10
movq %rax, -0x68(%rbp)
leaq -0x6c(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
movl $0x22, %edx
xorl %r8d, %r8d
movl %edx, %esi
callq 0x1d10
movq %rax, -0x68(%rbp)
jmp 0x2cdf
jmp 0x2cdf
jmp 0x2ce1
movl -0x14(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SetDeactContextProfile
cmError_t cellModem_SetDeactContextProfile(cmData_t *obj, uint8_t contextID){
    cmError_t retVal;
    char cmd[16]="AT+QIDEACT=";
    cmd[11] = (char)( (0 == contextID ) ? (char)contextID +'0' : '1');
    cmd[12]  = '\r';

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE ,NULL ,40000);/*40 sg*/

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x7b07(%rip), %rax      # 0xa810
movq %rax, -0x20(%rbp)
movq 0x7b04(%rip), %rax      # 0xa818
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2d2e
movsbl -0x9(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d38
movl $0x31, %eax
movl %eax, -0x24(%rbp)
jmp 0x2d38
movl -0x24(%rbp), %eax
movb %al, -0x15(%rbp)
movb $0xd, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x7fe3(%rip), %rdx      # 0xad52
leaq 0x7e5c(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x9c40, %r8d           # imm = 0x9C40
callq 0x1390
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SmsSetMessageFormat
cmError_t cellModem_SmsSetMessageFormat(cmData_t *obj, uint8_t mode){
    cmError_t retVal;
    char cmd[16]="AT+CMGF=";
    cmd[8] = (char)( (0 == mode ) ? (char)mode +'0' : '1');
    cmd[9]  = '\r';

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE ,NULL ,300);

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq 0x7a67(%rip), %rax      # 0xa820
movq %rax, -0x20(%rbp)
movq 0x7a64(%rip), %rax      # 0xa828
movq %rax, -0x18(%rbp)
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2dde
movsbl -0x9(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x24(%rbp)
jmp 0x2de8
movl $0x31, %eax
movl %eax, -0x24(%rbp)
jmp 0x2de8
movl -0x24(%rbp), %eax
movb %al, -0x18(%rbp)
movb $0xd, -0x17(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x7f33(%rip), %rdx      # 0xad52
leaq 0x7dac(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SmsSendNumber
cmError_t cellModem_SmsSendNumber(cmData_t *obj, const char *number){
    cmError_t retVal;
    char cmd[256]="AT+CMGS=\"";  // max 160 char, pending controller
    char *ptr = NULL;

    ptr = strcat(cmd+9, number);
    ptr = strcat(ptr,"\"\r");

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :">" ,NULL ,12000);/*120 sg*/

    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x120(%rbp), %rdi
leaq 0x72bf(%rip), %rsi      # 0xa1f0
movl $0x100, %edx            # imm = 0x100
callq 0x10c0
movq $0x0, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
addq $0x9, %rdi
movq -0x10(%rbp), %rsi
callq 0x10f0
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rdi
leaq 0x7156(%rip), %rsi      # 0xa0c5
callq 0x10f0
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x138(%rbp)
leaq -0x120(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x8266(%rip), %rdx      # 0xb21d
leaq 0x7c14(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2ee0, %r8d           # imm = 0x2EE0
callq 0x1390
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SmsSendTextMessage
cmError_t cellModem_SmsSendTextMessage(cmData_t *obj, const char *msg){
    cmError_t retVal;
    char cmd[256] ={0};  // max 160 char, pending controller
    memcpy((void*)cmd,(void*)msg, strlen(msg));

    //\x1A  = ctrl+z = 0x1A para que salga el mensaje
    strcat(cmd, "\r");
   
    retVal = cmSendCmd(obj,(char*)cmd , NULL ,NULL ,12000);/*120 sg*/
    retVal = cmSendCmd(obj,"\x1A\r" , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,NULL ,12000);/*120 sg*/
    //cmSendDirectUart(obj,"\x1A");
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10a0
leaq -0x120(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
movq -0x138(%rbp), %rdi
movq -0x130(%rbp), %rsi
movq %rax, %rdx
callq 0x10c0
leaq -0x120(%rbp), %rdi
leaq 0x706d(%rip), %rsi      # 0xa0c9
callq 0x10f0
movq -0x8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movl $0x2ee0, %r8d           # imm = 0x2EE0
movq %rcx, %rdx
callq 0x1390
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x128(%rbp), %rdi
movl %eax, %esi
xorl %ecx, %ecx
leaq 0x7cab(%rip), %rdx      # 0xad52
leaq 0x7b24(%rip), %rax      # 0xabd2
cmpl %esi, %ecx
cmoveq %rax, %rdx
leaq 0x700d(%rip), %rsi      # 0xa0c8
xorl %eax, %eax
movl %eax, %ecx
movl $0x2ee0, %r8d           # imm = 0x2EE0
callq 0x1390
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: intToStr
static char* intToStr(int value){
    static char buffer[16]={0};
    memset(buffer,0,16);
    sprintf(buffer,"%d",value);
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xc24e(%rip), %rdi      # 0xf5e0
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
movl -0x4(%rbp), %edx
leaq 0xc238(%rip), %rdi      # 0xf5e0
leaq 0x6ca6(%rip), %rsi      # 0xa055
movb $0x0, %al
callq 0x1100
leaq 0xc223(%rip), %rax      # 0xf5e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SocketConfigSendData
cmError_t cellModem_SocketConfigSendData(cmData_t *obj,socketData_t *config ){
    cmError_t retVal;
    char cmd[1024]="AT+QISEND=";  // max 160 char, pending controller
    char *ptr = NULL;
    char  buffer[32] ={0};

    if(config->dataToSend != NULL)
        sprintf(buffer,"%d,%d\r",config->connectId, strlen(config->dataToSend));

    ptr = strcat(cmd+9, buffer);
    //printf("ptr: [%s]",ptr);

    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :">" ,NULL ,300);/*120 sg*/
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x420(%rbp), %rdi
leaq 0x69df(%rip), %rsi      # 0xa3f0
movl $0x400, %edx            # imm = 0x400
callq 0x10c0
movq $0x0, -0x428(%rbp)
leaq -0x450(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3a8a
leaq -0x450(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x454(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1070
movq -0x460(%rbp), %rdi
movl -0x454(%rbp), %edx
movq %rax, %rcx
leaq 0x6655(%rip), %rsi      # 0xa0d8
movb $0x0, %al
callq 0x1100
leaq -0x420(%rbp), %rdi
addq $0x9, %rdi
leaq -0x450(%rbp), %rsi
callq 0x10f0
movq %rax, -0x428(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x470(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x468(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x470(%rbp), %rdi
movq -0x468(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x7739(%rip), %rdx      # 0xb21d
leaq 0x70e7(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x12c, %r8d            # imm = 0x12C
callq 0x1390
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SocketSendData
cmError_t cellModem_SocketSendData(cmData_t *obj, socketData_t *config){
    cmError_t retVal;
    char cmd[1024] ={0}; 
    if(config->dataToSend != NULL)
        memcpy((void*)cmd,(void*)config->dataToSend, strlen(config->dataToSend));

    //\x1A  = ctrl+z = 0x1A para que salga el mensaje
    strcat(cmd, "\r");

   /*is wait block*/
    retVal = cmSendCmd(obj,(char*)cmd , NULL ,NULL ,0);/*4 sg*/
    retVal = cmSendCmd(obj,"\x1A\r" , (0 == cellModem_GetatvFormat(obj) )? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :"SEND OK\r\n"  ,NULL ,4000);/*4 sg*/
    //cmSendDirectUart(obj,"\x1A");
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10a0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3b81
leaq -0x420(%rbp), %rax
movq %rax, -0x430(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1070
movq -0x430(%rbp), %rdi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
callq 0x10c0
leaq -0x420(%rbp), %rdi
leaq 0x653a(%rip), %rsi      # 0xa0c9
callq 0x10f0
movq -0x8(%rbp), %rdi
leaq -0x420(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0x1390
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x438(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x438(%rbp), %rdi
movl %eax, %esi
xorl %ecx, %ecx
leaq 0x650f(%rip), %rdx      # 0xa0e6
leaq 0x6ff4(%rip), %rax      # 0xabd2
cmpl %esi, %ecx
cmoveq %rax, %rdx
leaq 0x64dd(%rip), %rsi      # 0xa0c8
xorl %eax, %eax
movl %eax, %ecx
movl $0xfa0, %r8d            # imm = 0xFA0
callq 0x1390
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_UrcGetClosedConnection
cmError_t cellModem_UrcGetClosedConnection(cmData_t *obj, asynEventURC_t *getDataClosedConn){
    cmError_t retVal= CM_FAIL;
    char bufferRecv[CM_BUFFER_LEN_DEF] = {0};
    char *ptr=NULL;
    char bufferAux[32] = {0};

    if(cmIsAsyncEvent(obj)){
        ptr = cmGetBufferAsyncEvent(obj);
        memcpy(bufferRecv, ptr, strlen(ptr));        
        if( (ptr = strstr(bufferRecv,": \"closed\"")) != NULL ){
            ptr = extractBetween(ptr,',','\r', bufferAux, 0);
            getDataClosedConn->connectId = atoi(bufferAux);
            retVal = CM_OK;
        }else{
            retVal = CM_ERR_INVALID_RESPONSE;
        }
    }
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10a0
movq $0x0, -0x428(%rbp)
leaq -0x450(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x1900
cmpb $0x0, %al
je 0x3f28
movq -0x8(%rbp), %rdi
callq 0x1960
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x428(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x428(%rbp), %rdi
callq 0x1070
movq -0x460(%rbp), %rdi
movq -0x458(%rbp), %rsi
movq %rax, %rdx
callq 0x10c0
leaq -0x420(%rbp), %rdi
leaq 0x6235(%rip), %rsi      # 0xa0fd
callq 0x1110
movq %rax, -0x428(%rbp)
cmpq $0x0, %rax
je 0x3f1f
movq -0x428(%rbp), %rdi
leaq -0x450(%rbp), %rcx
movl $0x2c, %esi
movl $0xd, %edx
xorl %r8d, %r8d
callq 0x1d10
movq %rax, -0x428(%rbp)
leaq -0x450(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x14(%rbp)
jmp 0x3f26
movl $0x3, -0x14(%rbp)
jmp 0x3f28
movl -0x14(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_UrcGetRecvConnection
cmError_t cellModem_UrcGetRecvConnection(cmData_t *obj, asynEventURC_t *getRecvConn){
    cmError_t retVal= CM_FAIL;
    char bufferRecv[CM_BUFFER_LEN_DEF] = {0};
    char *ptr=NULL;
    char bufferAux[32] = {0};

    if(cmIsAsyncEvent(obj)){
        ptr = cmGetBufferAsyncEvent(obj);
        memcpy(bufferRecv, ptr, strlen(ptr));        
        if( (ptr = strstr(bufferRecv,": \"recv\"")) != NULL ){
            ptr = extractBetween(ptr,',','\r', bufferAux, 0);
            getRecvConn->connectId = atoi(bufferAux);
            retVal = CM_OK;
        }else{
            retVal = CM_ERR_INVALID_RESPONSE;
        }
    }
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x460, %rsp            # imm = 0x460
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10a0
movq $0x0, -0x428(%rbp)
leaq -0x450(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
movq -0x8(%rbp), %rdi
callq 0x1900
cmpb $0x0, %al
je 0x4058
movq -0x8(%rbp), %rdi
callq 0x1960
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x460(%rbp)
movq -0x428(%rbp), %rax
movq %rax, -0x458(%rbp)
movq -0x428(%rbp), %rdi
callq 0x1070
movq -0x460(%rbp), %rdi
movq -0x458(%rbp), %rsi
movq %rax, %rdx
callq 0x10c0
leaq -0x420(%rbp), %rdi
leaq 0x6110(%rip), %rsi      # 0xa108
callq 0x1110
movq %rax, -0x428(%rbp)
cmpq $0x0, %rax
je 0x404f
movq -0x428(%rbp), %rdi
leaq -0x450(%rbp), %rcx
movl $0x2c, %esi
movl $0xd, %edx
xorl %r8d, %r8d
callq 0x1d10
movq %rax, -0x428(%rbp)
leaq -0x450(%rbp), %rdi
callq 0x10e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, -0x14(%rbp)
jmp 0x4056
movl $0x3, -0x14(%rbp)
jmp 0x4058
movl -0x14(%rbp), %eax
addq $0x460, %rsp            # imm = 0x460
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/cellularModem/cellModem.c
// Function: cellModem_SocketClose
cmError_t cellModem_SocketClose(cmData_t *obj, int connectId){  
    cmError_t retVal = CM_FAIL;
    char cmd[32]="AT+QICLOSE=";
    char  buffer[8] ={0};
    
    sprintf(buffer,"%d\r",connectId );
    strcat(cmd,buffer);
    retVal = cmSendCmd(obj,cmd , (0 == cellModem_GetatvFormat(obj) ) ? CELLMODEM_CMD_GENERAL_RESPONSE_ATV0 :CELLMODEM_CMD_GENERAL_RESPONSE  ,NULL ,10000); //10 sg
    
    return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq 0x67e3(%rip), %rax      # 0xa870
movq %rax, -0x30(%rbp)
movq 0x67e0(%rip), %rax      # 0xa878
movq %rax, -0x28(%rbp)
movq 0x67dd(%rip), %rax      # 0xa880
movq %rax, -0x20(%rbp)
movq 0x67da(%rip), %rax      # 0xa888
movq %rax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10a0
leaq -0x38(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x600b(%rip), %rsi      # 0xa0db
movb $0x0, %al
callq 0x1100
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10f0
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %r8d
xorl %ecx, %ecx
leaq 0x6c41(%rip), %rdx      # 0xad52
leaq 0x6aba(%rip), %rax      # 0xabd2
cmpl %r8d, %ecx
cmoveq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2710, %r8d           # imm = 0x2710
callq 0x1390
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_initializer
void test_modem_initializer(){
    cmError_t retValue = CM_FAIL;
    /*lauch fail -1 because not initialize correctly*/
    retValue = cellModem_Init(&cmData,inputBuffer,CM_BUFFER_LEN_DEF,NULL,OutputFunction,NULL);
    TEST_ASSERT_EQUAL_INT32(CM_FAIL,retValue);

    retValue = cellModem_Init(NULL,inputBuffer,CM_BUFFER_LEN_DEF,NULL,OutputFunction,NULL);
    TEST_ASSERT_EQUAL_INT32(CM_FAIL,retValue);

    retValue = cellModem_Init(&cmData,inputBuffer,CM_BUFFER_LEN_DEF,GetTickCountMs,OutputFunction,NULL);
    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 0xafaa(%rip), %rdi      # 0xf120
leaq 0xb483(%rip), %rsi      # 0xf600
movl $0x400, %edx            # imm = 0x400
xorl %eax, %eax
movl %eax, %r9d
leaq 0xf2(%rip), %r8         # 0x4280
movq %r9, %rcx
callq 0x1b10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
movq $-0x1, %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x20, %ecx
movl $0x14, %r8d
callq 0x7460
xorl %eax, %eax
movl %eax, %r9d
leaq 0xb43c(%rip), %rsi      # 0xf600
movl $0x400, %edx            # imm = 0x400
leaq 0xb0(%rip), %r8         # 0x4280
movq %r9, %rdi
movq %r9, %rcx
callq 0x1b10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
movq $-0x1, %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x23, %ecx
movl $0x14, %r8d
callq 0x7460
leaq 0xaf1c(%rip), %rdi      # 0xf120
leaq 0xb3f5(%rip), %rsi      # 0xf600
movl $0x400, %edx            # imm = 0x400
leaq 0x129(%rip), %rcx       # 0x4340
leaq 0x62(%rip), %r8         # 0x4280
xorl %eax, %eax
movl %eax, %r9d
callq 0x1b10
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x26, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xaed3(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x27, %ecx
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: OutputFunction
void OutputFunction( void *sp, char c){
	int i = 0; 
    (void)sp;
   // char ResponseExpected[100] = {CM_CMD_MOCK_ATI_RESPONSE};//{CM_CMD_MOCK_GENERAL_RESPONSE};
	if(c != '\r')
    	printf(KYEL "%c",c); /*no print \r in console */
	
	if(c == '\r') {	 /*if send command to module*/
		printf(KWHT); /*black color */
       
        while(MockResponseExpected[i] != '\0') { /*then the module response is pass to isr char by char */
		 	// para nonblocking test colocar un wait pequeño
            cellModem_IsrRx(&cmData, MockResponseExpected[i]); 
			i++;
		}
        /*print command and response*/
        printf(" -->");
		printf(KGRN "%s",MockResponseExpected);  
        printf(KNRM); /*white color */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
je 0x42b4
movsbl -0x9(%rbp), %esi
leaq 0x6f5f(%rip), %rdi      # 0xb20c
movb $0x0, %al
callq 0x1090
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
jne 0x4336
leaq 0x6f50(%rip), %rdi      # 0xb214
movb $0x0, %al
callq 0x1090
movq 0xaebe(%rip), %rax      # 0xf190
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x4305
movq 0xaeaa(%rip), %rax      # 0xf190
movslq -0x10(%rbp), %rcx
leaq 0xae2f(%rip), %rdi      # 0xf120
movsbl (%rax,%rcx), %esi
callq 0x20a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x42cb
leaq 0x6f0e(%rip), %rdi      # 0xb21a
movb $0x0, %al
callq 0x1090
movq 0xae76(%rip), %rsi      # 0xf190
leaq 0x6efe(%rip), %rdi      # 0xb21f
movb $0x0, %al
callq 0x1090
leaq 0x7651(%rip), %rdi      # 0xb980
movb $0x0, %al
callq 0x1090
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_GetModuleInformation
void test_modem_GetModuleInformation(){
    cmError_t retValue = CM_FAIL;
    modemInfo_t getModemInfo = MODEMINFO_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_ATI_RESPONSE2_ECHO;//CM_CMD_MOCK_ATI_RESPONSE;
    retValue = cellModem_GetModuleInformation(&cmData, &getModemInfo);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    TEST_ASSERT_EQUAL_STRING("Quectel",getModemInfo.manufactorId);
    TEST_ASSERT_EQUAL_STRING("BG96",getModemInfo.deviceModel);
    TEST_ASSERT_EQUAL_STRING("Revision: BG96MAR02A07M1G",getModemInfo.firmwareVersion);

    MockResponseExpected = CM_CMD_MOCK_ATI_RESPONSE;
    retValue = cellModem_GetModuleInformation(&cmData, &getModemInfo);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    TEST_ASSERT_EQUAL_STRING("Quectel",getModemInfo.manufactorId);
    TEST_ASSERT_EQUAL_STRING("EC25",getModemInfo.deviceModel);
    TEST_ASSERT_EQUAL_STRING("Revision: EC25AUXGAR08A03M1G",getModemInfo.firmwareVersion);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0x44(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10a0
leaq 0x63d2(%rip), %rax      # 0xa938
movq %rax, 0xac23(%rip)      # 0xf190
leaq 0xabac(%rip), %rdi      # 0xf120
leaq -0x44(%rbp), %rsi
callq 0x2250
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x49, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x44(%rbp), %rsi
leaq 0x63c9(%rip), %rdi      # 0xa96f
xorl %eax, %eax
movl %eax, %edx
movl $0x4b, %ecx
callq 0x8680
leaq -0x44(%rbp), %rsi
addq $0x10, %rsi
leaq 0x63b4(%rip), %rdi      # 0xa977
xorl %eax, %eax
movl %eax, %edx
movl $0x4c, %ecx
callq 0x8680
leaq -0x44(%rbp), %rsi
addq $0x20, %rsi
leaq 0x639c(%rip), %rdi      # 0xa97c
xorl %eax, %eax
movl %eax, %edx
movl $0x4d, %ecx
callq 0x8680
leaq 0x63a1(%rip), %rax      # 0xa996
movq %rax, 0xab94(%rip)      # 0xf190
leaq 0xab1d(%rip), %rdi      # 0xf120
leaq -0x44(%rbp), %rsi
callq 0x2250
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x51, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x44(%rbp), %rsi
leaq 0x633a(%rip), %rdi      # 0xa96f
xorl %eax, %eax
movl %eax, %edx
movl $0x53, %ecx
callq 0x8680
leaq -0x44(%rbp), %rsi
addq $0x10, %rsi
leaq 0x637a(%rip), %rdi      # 0xa9cc
xorl %eax, %eax
movl %eax, %edx
movl $0x54, %ecx
callq 0x8680
leaq -0x44(%rbp), %rsi
addq $0x20, %rsi
leaq 0x6362(%rip), %rdi      # 0xa9d1
xorl %eax, %eax
movl %eax, %edx
movl $0x55, %ecx
callq 0x8680
leaq 0xaa9c(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x56, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_GetImei
void test_modem_GetImei(){
    cmError_t retValue = CM_FAIL;
    char getImei[32]="\0";

    MockResponseExpected = CM_CMD_MOCK_GSN_RESPONSE;

    retValue = cellModem_GetImei(&cmData, getImei);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_STRING("862708040783073",getImei);
    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 0x6318(%rip), %rax      # 0xa9ee
movq %rax, 0xaab3(%rip)      # 0xf190
leaq -0x30(%rbp), %rsi
leaq 0xaa38(%rip), %rdi      # 0xf120
callq 0x2350
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x60, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x30(%rbp), %rsi
leaq 0x62f2(%rip), %rdi      # 0xaa08
xorl %eax, %eax
movl %eax, %edx
movl $0x61, %ecx
callq 0x8680
leaq 0xa9f5(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x62, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
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_GetImsi
void test_modem_GetImsi(){
    cmError_t retValue = CM_FAIL;
    char getImsi[32]="\0";

    MockResponseExpected = CM_CMD_MOCK_IMSI_RESPONSE;

    retValue = cellModem_GetImsi(&cmData, getImsi);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_STRING("732101596840439",getImsi);
    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 0x6292(%rip), %rax      # 0xaa18
movq %rax, 0xaa03(%rip)      # 0xf190
leaq -0x30(%rbp), %rsi
leaq 0xa988(%rip), %rdi      # 0xf120
callq 0x2410
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x6c, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x30(%rbp), %rsi
leaq 0x626c(%rip), %rdi      # 0xaa32
xorl %eax, %eax
movl %eax, %edx
movl $0x6d, %ecx
callq 0x8680
leaq 0xa945(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x6e, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
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_GetIccid
void test_modem_GetIccid(){
    cmError_t retValue = CM_FAIL;
    char getIccid[32]="\0";

    MockResponseExpected = CM_CMD_MOCK_CCID_RESPONSE;

    retValue = cellModem_GetIccid(&cmData, getIccid);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_STRING("89571015025068994296",getIccid);
    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 0x620c(%rip), %rax      # 0xaa42
movq %rax, 0xa953(%rip)      # 0xf190
leaq -0x30(%rbp), %rsi
leaq 0xa8d8(%rip), %rdi      # 0xf120
callq 0x24d0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x78, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x30(%rbp), %rsi
leaq 0x61f3(%rip), %rdi      # 0xaa69
xorl %eax, %eax
movl %eax, %edx
movl $0x79, %ecx
callq 0x8680
leaq 0xa895(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x7a, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
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_GetSignalQuality
void test_modem_GetSignalQuality(){
    cmError_t retValue = CM_FAIL;
    uint8_t rssi = 0;

    MockResponseExpected = CM_CMD_MOCK_GSQ_RESPONSE;
    retValue = cellModem_GetSignalQuality(&cmData, &rssi);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);
    TEST_ASSERT_EQUAL_UINT8(28,rssi);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movb $0x0, -0x5(%rbp)
leaq 0x61a4(%rip), %rax      # 0xaa7e
movq %rax, 0xa8af(%rip)      # 0xf190
leaq 0xa838(%rip), %rdi      # 0xf120
leaq -0x5(%rbp), %rsi
callq 0x1be0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x83, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movzbl -0x5(%rbp), %eax
movl %eax, %esi
movl $0x1c, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x84, %ecx
movl $0x21, %r8d
callq 0x7460
leaq 0xa7eb(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x85, %ecx
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_SetATE
void test_modem_SetATE(){
    cmError_t retValue = CM_FAIL;

    MockResponseExpected = CM_CMD_MOCK_ATE1_RESPONSE;
    retValue = cellModem_SetATE(&cmData,1);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    MockResponseExpected = CM_CMD_MOCK_ATE0_RESPONSE;
    retValue = cellModem_SetATE(&cmData,0);
    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 0x611e(%rip), %rax      # 0xaa94
movq %rax, 0xa813(%rip)      # 0xf190
leaq 0xa79c(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x25c0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x8d, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x60f0(%rip), %rax      # 0xaaa3
movq %rax, 0xa7d6(%rip)      # 0xf190
leaq 0xa75f(%rip), %rdi      # 0xf120
xorl %esi, %esi
callq 0x25c0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x91, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xa733(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x92, %ecx
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_SetATV
void test_modem_SetATV(){
    cmError_t retValue = CM_FAIL;

    MockResponseExpected = CM_CMD_MOCK_ATV1_RESPONSE;
    retValue = cellModem_SetATV(&cmData,1);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    /*se cambia respuesta de la Irs por que se cambio el formato de respuesta a  ATV0*/
    //MockResponseExpected = CM_CMD_MOCK_ATV0_RESPONSE;
    //retValue = cellModem_SetATV(&cmData,0);
    //TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    /*vuelve init a respuesta ATV1 o enviar literal ATV1*/
    MockResponseExpected = CM_CMD_MOCK_ATV1_RESPONSE;
    retValue = cellModem_SetATV(&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 0x631c(%rip), %rax      # 0xad52
movq %rax, 0xa753(%rip)      # 0xf190
leaq 0xa6dc(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x2660
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0x9a, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0x62df(%rip), %rax      # 0xad52
movq %rax, 0xa716(%rip)      # 0xf190
leaq 0xa69f(%rip), %rdi      # 0xf120
movl $0x1, %esi
callq 0x2660
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xa4, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq 0xa670(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xa5, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/connycommy[P]atCmdDevice/src/test/TestProductionCode.c
// Function: test_modem_GetCREG
void test_modem_GetCREG(){
    cmError_t retValue = CM_FAIL;
    netRegStatus_t netRegSta=NETREGSTATUS_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_CREG_RESPONSE;
    retValue = cellModem_GetCREG(&cmData,&netRegSta);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    TEST_ASSERT_EQUAL_INT(0,netRegSta.n);
    TEST_ASSERT_EQUAL_INT(1,netRegSta.stat);
    TEST_ASSERT_EQUAL_INT(0, cmIsAsyncEvent(&cmData));  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x10a0
leaq 0x5fac(%rip), %rax      # 0xaab2
movq %rax, 0xa683(%rip)      # 0xf190
leaq 0xa60c(%rip), %rdi      # 0xf120
leaq -0xc(%rbp), %rsi
callq 0x27a0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xb0, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0xc(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xb2, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x8(%rbp), %rsi
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xb3, %ecx
movl $0x14, %r8d
callq 0x7460
leaq 0xa5a6(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xb4, %ecx
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_GetCOPS
void test_modem_GetCOPS(){
    cmError_t retValue = CM_FAIL;
    netOperatorStatus_t netOperatorStat = NETOPERATORSTATUS_INITIALIZER;

    MockResponseExpected = CM_CMD_MOCK_COPS_RESPONSE;
    retValue = cellModem_GetCOPS(&cmData,&netOperatorStat);
    TEST_ASSERT_EQUAL_INT32(CM_OK,retValue);

    TEST_ASSERT_EQUAL_INT(0,netOperatorStat.mode);
    TEST_ASSERT_EQUAL_INT(0,netOperatorStat.format);
    TEST_ASSERT_EQUAL_STRING("#CoberturaCLARO Claro",netOperatorStat.operator);
    TEST_ASSERT_EQUAL_INT(7,netOperatorStat.act);
    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 $0x2c, %edx
callq 0x10a0
leaq 0x5ef1(%rip), %rax      # 0xaac7
movq %rax, 0xa5b3(%rip)      # 0xf190
leaq 0xa53c(%rip), %rdi      # 0xf120
leaq -0x30(%rbp), %rsi
callq 0x28e0
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xbd, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xbf, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
movslq -0x2c(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movl $0xc0, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
leaq -0x30(%rbp), %rsi
addq $0xc, %rsi
leaq 0x5ea6(%rip), %rdi      # 0xaaf6
xorl %eax, %eax
movl %eax, %edx
movl $0xc1, %ecx
callq 0x8680
movslq -0x28(%rbp), %rsi
movl $0x7, %edi
xorl %eax, %eax
movl %eax, %edx
movl $0xc2, %ecx
movl $0x14, %r8d
callq 0x7460
leaq 0xa49e(%rip), %rdi      # 0xf120
callq 0x1900
movzbl %al, %eax
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0xc3, %ecx
movl $0x14, %r8d
movq %rdx, %rdi
callq 0x7460
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)