LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_stack.c
// Function: create_stack_neg
int				create_stack_neg(int **unit, int **stack, int exposent,
					uint64_t mantissa)
{
	uint64_t	ll;
	int			i;

	if (!(*stack = (int*)malloc(sizeof(int) * (DBL_TAB + 1))))
		return (1);
	if (!(*unit = create_unit_neg(exposent, DBL_TAB)))
		return (free_and_return_int(*stack, 1));
	i = 0;
	while (i < DBL_TAB + 1)
		(*stack)[i++] = 0;
	ll = 1;
	if (exposent == -EXP_MAX)
		multiply_unit_neg(unit);
	while (ll < MTS_MAX)
	{
		if (ll & mantissa)
			add_unit_neg(unit, stack);
		multiply_unit_neg(unit);
		ll *= 2;
	}
	if (exposent != -EXP_MAX)
		add_unit_neg(unit, stack);
	while ((*stack)[(*stack)[0]] == 0 && (*stack)[0] != 0)
		(*stack)[0]--;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1e8, %edi            # imm = 0x1E8
callq 0x3690
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa9fa
movl $0x1, -0x4(%rbp)
jmp 0xab19
movl -0x1c(%rbp), %edi
movl $0x79, %esi
callq 0x3450
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaa2d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3400
movl %eax, -0x4(%rbp)
jmp 0xab19
movl $0x0, -0x34(%rbp)
cmpl $0x7a, -0x34(%rbp)
jge 0xaa58
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xaa34
movq $0x1, -0x30(%rbp)
cmpl $0xfffffc01, -0x1c(%rbp) # imm = 0xFFFFFC01
jne 0xaa72
movq -0x10(%rbp), %rdi
callq 0x31a0
jmp 0xaa74
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
cmpq %rax, -0x30(%rbp)
jae 0xaab5
movq -0x30(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0xaa9f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3080
movq -0x10(%rbp), %rdi
callq 0x31a0
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0xaa74
cmpl $0xfffffc01, -0x1c(%rbp) # imm = 0xFFFFFC01
je 0xaacb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3080
jmp 0xaacd
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq (%rax), %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x35(%rbp)
jne 0xaaf9
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xab02
jmp 0xab12
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xaacd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_free_precision.c
// Function: finalize_precision
void			finalize_precision(char **str, size_t j)
{
	char	*tmp;

	(*str)[j] = 0;
	if ((*str)[0] == '-' + 1 || (*str)[0] == '9' + 1)
	{
		if ((*str)[0] == '-' + 1)
			tmp = ft_strjoin("-1", (*str) + 1);
		else
			tmp = ft_strjoin("10", (*str) + 1);
		free(*str);
		if (!tmp)
			return ;
		*str = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0xabcd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xac34
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0xabf9
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
leaq 0x1770(%rip), %rdi      # 0xc35e
callq 0x3530
movq %rax, -0x18(%rbp)
jmp 0xac14
movq -0x8(%rbp), %rax
movq (%rax), %rsi
addq $0x1, %rsi
leaq 0x1756(%rip), %rdi      # 0xc361
callq 0x3530
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3110
cmpq $0x0, -0x18(%rbp)
jne 0xac29
jmp 0xac34
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_free_precision.c
// Function: handle_precision
void			handle_precision(char **str, size_t precision, uint32_t flags)
{
	size_t	i;
	size_t	j;
	size_t	b;
	size_t	len;

	len = ft_strlen(*str);
	b = ft_strchri(*str, '.');
	i = precision + b;
	if (i <= len)
	{
		j = i;
		(*str)[i] += 5;
		while (i > 0 && (*str)[i] > '9')
		{
			(*str)[i] -= 10;
			if ((*str)[i - 1] == '.' || (*str)[i - 1] == ',')
				i--;
			(*str)[--i] += 1;
		}
		finalize_precision(str, j);
	}
	if (precision == 0 && !(flags & F_SHARP))
		(*str)[b - 1] = 0;
	else if (precision == 0)
		(*str)[b] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3140
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x2e, %esi
callq 0x35b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0xad61
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
addl $0x5, %edx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
jbe 0xacd3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
setg %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xacdc
jmp 0xad54
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %edx
subl $0xa, %edx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0xad21
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0xad2d
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x20(%rbp)
movsbl -0x1(%rax,%rcx), %edx
addl $0x1, %edx
movb %dl, -0x1(%rax,%rcx)
jmp 0xacaf
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x36b0
cmpq $0x0, -0x10(%rbp)
jne 0xad8a
movl -0x14(%rbp), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
jne 0xad8a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
jmp 0xada2
cmpq $0x0, -0x10(%rbp)
jne 0xada0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xada2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_neg
void		ft_putnbr_neg(int n, int end, char **tmp)
{
	size_t			len;
	int				buf;
	char			c;

	buf = n;
	buf = 100000000;
	len = 9;
	if (end)
	{
		while (n % 10 == 0 && n != 0)
		{
			n /= 10;
			buf /= 10;
			len--;
		}
		if (n == 0)
			len = 6 * (len == 9);
	}
	while (len--)
	{
		c = n / buf + '0';
		((*tmp)++)[0] = c;
		n %= buf;
		buf /= 10;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x5f5e100, -0x1c(%rbp) # imm = 0x5F5E100
movq $0x9, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xae4b
jmp 0xaddb
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x1e(%rbp)
jne 0xadfa
cmpl $0x0, -0x4(%rbp)
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0xae03
jmp 0xae2d
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xaddb
cmpl $0x0, -0x4(%rbp)
jne 0xae49
cmpq $0x9, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
imull $0x6, %eax, %eax
cltq
movq %rax, -0x18(%rbp)
jmp 0xae4b
jmp 0xae4d
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0xaea1
movl -0x4(%rbp), %eax
cltd
idivl -0x1c(%rbp)
addl $0x30, %eax
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %cl
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x1c(%rbp), %ecx
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
jmp 0xae4d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_pos
void		ft_putnbr_pos(int **stack, char **tmp, int dbl_tab, uint32_t flags)
{
	int		i;
	char	*test;

	test = *tmp;
	i = 6 + (dbl_tab == LDBL_TAB);
	(*stack)[1] = i;
	i = dbl_tab - (*stack)[0] + 1;
	if ((*stack)[i - 1])
	{
		(*stack)[0]++;
		i--;
	}
	if (flags & F_QUOTE)
	{
		while (i <= dbl_tab)
			ft_putnbr_pos_addentum2(stack, &i, &test, dbl_tab);
	}
	else
	{
		while (i <= dbl_tab)
			ft_putnbr_pos_addentum(stack, &i, &test, dbl_tab);
	}
	test[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x73a, -0x14(%rbp)     # imm = 0x73A
sete %al
andb $0x1, %al
movzbl %al, %eax
addl $0x6, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subl (%rcx), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xb342
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
andl $0x8000000, %eax        # imm = 0x8000000
cmpl $0x0, %eax
je 0xb371
jmp 0xb351
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xb36f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq -0x1c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x3540
jmp 0xb351
jmp 0xb393
jmp 0xb373
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xb391
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %ecx
leaq -0x1c(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x34f0
jmp 0xb373
jmp 0xb393
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: QmiWwanDeInit
static int QmiWwanDeInit(void) {
    unsigned int i;
    for (i = 0; i < sizeof(qmiclientId)/sizeof(qmiclientId[0]); i++)
    {
        if (qmiclientId[i] != 0)
        {
                QmiWwanReleaseClientID(i, qmiclientId[i]);
                qmiclientId[i] = 0;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x1b, %rax
jae 0x5962
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x31bdc(%rip), %rax     # 0x37500
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x5955
movl -0x4(%rbp), %edi
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x31bc4(%rip), %rax     # 0x37500
movzbl (%rax,%rcx), %esi
callq 0x6b70
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x31baf(%rip), %rax     # 0x37500
movb $0x0, (%rax,%rcx)
jmp 0x5957
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x590f
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: libqmi_proxy_open
static int libqmi_proxy_open(const char *cdc_wdm) {
    int ret;
    PQCQMIMSG pResponse;

    ret = QmiThreadSendQMI(ComposeQCTLMsg(QMI_MESSAGE_CTL_INTERNAL_PROXY_OPEN,
        CtlLibQmiProxyOpenReq, (void *)cdc_wdm), &pResponse);
    if (!ret && pResponse
        && pResponse->CTLMsg.QMICTLMsgHdrRsp.QMUXResult == 0
        && pResponse->CTLMsg.QMICTLMsgHdrRsp.QMUXError == 0) {
        ret = 0;
    }
    else {
        return -1;
    }

    if (pResponse)
            free(pResponse);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movl $0xff00, %edi           # imm = 0xFF00
leaq 0x2b4(%rip), %rsi       # 0x6ea0
callq 0x6c70
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
movl $0x7530, %edx           # imm = 0x7530
leaq 0x24474(%rip), %rcx     # 0x2b078
callq 0xc670
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6c3c
cmpq $0x0, -0x20(%rbp)
je 0x6c3c
movq -0x20(%rbp), %rax
movzwl 0xf(%rax), %eax
cmpl $0x0, %eax
jne 0x6c3c
movq -0x20(%rbp), %rax
movzwl 0x11(%rax), %eax
cmpl $0x0, %eax
jne 0x6c3c
movl $0x0, -0x14(%rbp)
jmp 0x6c45
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6c5b
cmpq $0x0, -0x20(%rbp)
je 0x6c55
movq -0x20(%rbp), %rdi
callq 0x5040
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlGetVersionReq
static USHORT CtlGetVersionReq(PQMICTL_MSG QCTLMsg, void *arg)
{
    (void)arg;
    QCTLMsg->GetVersionReq.TLVType = QCTLV_TYPE_REQUIRED_PARAMETER;
    QCTLMsg->GetVersionReq.TLVLength = cpu_to_le16(0x0001);
    QCTLMsg->GetVersionReq.QMUXTypes = QMUX_TYPE_ALL;
    return sizeof(QMICTL_GET_VERSION_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x6(%rax)
movl $0x1, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x7(%rax)
movq -0x8(%rbp), %rax
movb $-0x1, 0x9(%rax)
movw $0xa, %ax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlLibQmiProxyOpenReq
static USHORT CtlLibQmiProxyOpenReq(PQMICTL_MSG QCTLMsg, void *arg)
{
    (void)arg;
    const char *device_path = (const char *)(arg);
    QCTLMsg->LibQmiProxyOpenReq.TLVType = 0x01;
    QCTLMsg->LibQmiProxyOpenReq.TLVLength = cpu_to_le16(strlen(device_path));
    //strcpy(QCTLMsg->LibQmiProxyOpenReq.device_path, device_path);
    //__builtin___strcpy_chk
    memcpy(QCTLMsg->LibQmiProxyOpenReq.device_path, device_path, strlen(device_path));
    return sizeof(QMICTL_LIBQMI_PROXY_OPEN_MSG) + (strlen(device_path));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x6(%rax)
movq -0x18(%rbp), %rdi
callq 0x5160
movzwl %ax, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x7(%rax)
movq -0x8(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5160
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x52f0
movq -0x18(%rbp), %rdi
callq 0x5160
addq $0x9, %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: GetQCTLTransactionId
static UCHAR GetQCTLTransactionId(void) {
    static int TransactionId = 0;
    if (++TransactionId > 0xFF)
        TransactionId = 1;
    return TransactionId;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x305f2(%rip), %eax     # 0x3751c
addl $0x1, %eax
movl %eax, 0x305e9(%rip)     # 0x3751c
cmpl $0xff, %eax
jle 0x6f44
movl $0x1, 0x305d8(%rip)     # 0x3751c
movl 0x305d2(%rip), %eax     # 0x3751c
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: qmi_proxy_read
static ssize_t qmi_proxy_read (int fd, void *buf, size_t size) {
    ssize_t nreads;
    PQCQMI_HDR pHdr = (PQCQMI_HDR)buf;

    nreads = read(fd, pHdr, sizeof(QCQMI_HDR));
    if (nreads == sizeof(QCQMI_HDR) && le16_to_cpu(pHdr->Length) < size) {
        nreads += read(fd, pHdr+1, le16_to_cpu(pHdr->Length) + 1 - sizeof(QCQMI_HDR));
    }

    return nreads;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movl $0x6, %edx
callq 0x5250
movq %rax, -0x20(%rbp)
cmpq $0x6, -0x20(%rbp)
jne 0x6fdd
movq -0x28(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movzwl %ax, %eax
cmpq -0x18(%rbp), %rax
jae 0x6fdd
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movzwl %ax, %eax
addl $0x1, %eax
movslq %eax, %rdx
subq $0x6, %rdx
callq 0x5250
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlGetClientIdReq
static USHORT CtlGetClientIdReq(PQMICTL_MSG QCTLMsg, void *arg) {
   QCTLMsg->GetClientIdReq.TLVType       = QCTLV_TYPE_REQUIRED_PARAMETER;
   QCTLMsg->GetClientIdReq.TLVLength     = cpu_to_le16(0x0001);
   QCTLMsg->GetClientIdReq.QMIType     = ((UCHAR *)arg)[0];
   return sizeof(QMICTL_GET_CLIENT_ID_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x6(%rax)
movl $0x1, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x7(%rax)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movw $0xa, %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlReleaseClientIdReq
static USHORT CtlReleaseClientIdReq(PQMICTL_MSG QCTLMsg, void *arg) {
   QCTLMsg->ReleaseClientIdReq.TLVType       = QCTLV_TYPE_REQUIRED_PARAMETER;
   QCTLMsg->ReleaseClientIdReq.TLVLength     = cpu_to_le16(0x0002);
   QCTLMsg->ReleaseClientIdReq.QMIType     = ((UCHAR *)arg)[0];
   QCTLMsg->ReleaseClientIdReq.ClientId = ((UCHAR *)arg)[1] ;
   return sizeof(QMICTL_RELEASE_CLIENT_ID_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x6(%rax)
movl $0x2, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x7(%rax)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movw $0xb, %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/GobiNetCM.c
// Function: GobiNetDeInit
static int GobiNetDeInit(void) {
    unsigned int i;
    for (i = 0; i < sizeof(qmiclientId)/sizeof(qmiclientId[0]); i++)
    {
        if (qmiclientId[i] != 0)
        {
            close(qmiclientId[i]);
            qmiclientId[i] = 0;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x1b, %rax
jae 0x70fe
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x3045c(%rip), %rax     # 0x37520
cmpl $0x0, (%rax,%rcx,4)
je 0x70f1
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x3044a(%rip), %rax     # 0x37520
movl (%rax,%rcx,4), %edi
callq 0x5230
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x30436(%rip), %rax     # 0x37520
movl $0x0, (%rax,%rcx,4)
jmp 0x70f3
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x70af
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: kill_data_call_pdp
static int kill_data_call_pdp(int pdp, char *self) {
    int pid;
    char *p = NULL;

    p = self;
    while (*self) {
        if (*self == '/')
            p = self+1;
        self++;
    }

    pid = getpid_by_pdp(pdp, p);
    if (pid > 0) {
        dbg_time("send SIGINT to process %d", pid);
        return kill(pid, SIGINT);
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8cce
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x8cc0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8c9f
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x14590
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x8d5c
jmp 0x8ce5
movq 0x2e2f4(%rip), %rax     # 0x36fe0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x13930
movq -0x28(%rbp), %rdi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
leaq 0x22f08(%rip), %rsi     # 0x2bc11
movb $0x0, %al
callq 0x52c0
leaq 0x2f151(%rip), %rax     # 0x37e68
cmpq $0x0, (%rax)
je 0x8d48
leaq 0x2f144(%rip), %rax     # 0x37e68
movq (%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x13930
movq -0x30(%rbp), %rdi
movq %rax, %rdx
movl -0x14(%rbp), %ecx
leaq 0x22ed0(%rip), %rsi     # 0x2bc11
movb $0x0, %al
callq 0x52c0
jmp 0x8d4a
movl -0x14(%rbp), %edi
movl $0x2, %esi
callq 0x5310
movl %eax, -0x4(%rbp)
jmp 0x8d63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: ql_sigaction
static void ql_sigaction(int signo) {
     if (SIGALRM == signo)
         send_signo_to_main(SIG_EVENT_START);
     else
     {
        g_donot_exit_when_modem_hangup = 0;
        send_signo_to_main(SIG_EVENT_STOP);
        main_send_event_to_qmidevice(SIG_EVENT_STOP); //main may be wating qmi response
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0xe, %eax
cmpl -0x4(%rbp), %eax
jne 0x8d8e
xorl %edi, %edi
callq 0x9a20
jmp 0x8dac
movl $0x0, 0x2e7f8(%rip)     # 0x37590
movl $0x2, %edi
callq 0x9a20
movl $0x2, %edi
callq 0x9a50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: kill_brothers
static int kill_brothers(const char *qmichannel)
{
    char myself[MAX_PATH];
    int filenamesize;
    void *argv[2] = {myself, (void *)qmichannel};

    filenamesize = readlink("/proc/self/exe", myself, MAX_PATH);
    if (filenamesize <= 0)
        return 0;
    myself[filenamesize] = 0;

    if (ls_dir("/proc", is_brother_process, argv))
        sleep(1);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x110(%rbp), %rsi
leaq 0x20f7f(%rip), %rdi     # 0x2beb5
movl $0x100, %edx            # imm = 0x100
callq 0x50d0
movl %eax, -0x114(%rbp)
cmpl $0x0, -0x114(%rbp)
jg 0xaf58
movl $0x0, -0x4(%rbp)
jmp 0xaf97
movslq -0x114(%rbp), %rax
movb $0x0, -0x110(%rbp,%rax)
leaq -0x130(%rbp), %rdx
leaq 0x20f4f(%rip), %rdi     # 0x2bec4
leaq 0x414(%rip), %rsi       # 0xb390
callq 0xb240
cmpl $0x0, %eax
je 0xaf90
movl $0x1, %edi
callq 0x5550
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: usbnet_link_change
static void usbnet_link_change(int link, PROFILE_T *profile) {
    if (s_link == link)
        return;

    s_link = link;

    if (!(link & (1<<IpFamilyV4)))
        memset(&profile->ipv4, 0, sizeof(IPV4_T));

    if (!(link & (1<<IpFamilyV6)))
        memset(&profile->ipv6, 0, sizeof(IPV6_T));

    if (link) {
        udhcpc_start(profile);
    } else {
        udhcpc_stop(profile);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x2c12f(%rip), %eax     # 0x372f4
cmpl -0x4(%rbp), %eax
jne 0xb1cc
jmp 0xb233
movl -0x4(%rbp), %eax
movl %eax, 0x2c11f(%rip)     # 0x372f4
movl -0x4(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xb1f7
movq -0x10(%rbp), %rdi
addq $0x126, %rdi            # imm = 0x126
xorl %esi, %esi
movl $0x18, %edx
callq 0x5200
movl -0x4(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xb219
movq -0x10(%rbp), %rdi
addq $0x13e, %rdi            # imm = 0x13E
xorl %esi, %esi
movl $0x56, %edx
callq 0x5200
cmpl $0x0, -0x4(%rbp)
je 0xb22a
movq -0x10(%rbp), %rdi
callq 0x29380
jmp 0xb233
movq -0x10(%rbp), %rdi
callq 0x2a700
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: ls_dir
static int ls_dir(const char *dir, int (*match)(const char *dir, const char *file, void *argv[]), void *argv[])
{
    DIR *pDir;
    struct dirent* ent = NULL;
    int match_times = 0;

    pDir = opendir(dir);
    if (pDir == NULL)  {
        dbg_time("Cannot open directory: %s, errno: %d (%s)", dir, errno, strerror(errno));
        return 0;
    }

    while ((ent = readdir(pDir)) != NULL)  {
        match_times += match(dir, ent->d_name, argv);
    }
    closedir(pDir);

    return match_times;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5140
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xb341
jmp 0xb27d
movq 0x2bd5c(%rip), %rax     # 0x36fe0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
callq 0x13930
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x5070
movl (%rax), %eax
movl %eax, -0x38(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5540
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %r8d
movq %rax, %r9
leaq 0x20bfe(%rip), %rsi     # 0x2beca
movb $0x0, %al
callq 0x52c0
leaq 0x2cb8e(%rip), %rax     # 0x37e68
cmpq $0x0, (%rax)
je 0xb336
leaq 0x2cb81(%rip), %rax     # 0x37e68
movq (%rax), %rax
movq %rax, -0x70(%rbp)
callq 0x13930
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x5070
movl (%rax), %eax
movl %eax, -0x54(%rbp)
callq 0x5070
movl (%rax), %edi
callq 0x5540
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
movl -0x54(%rbp), %r8d
movq %rax, %r9
leaq 0x20b9b(%rip), %rsi     # 0x2beca
movb $0x0, %al
callq 0x52c0
jmp 0xb338
movl $0x0, -0x4(%rbp)
jmp 0xb383
jmp 0xb343
movq -0x28(%rbp), %rdi
callq 0x5320
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb374
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x13, %rsi
movq -0x20(%rbp), %rdx
callq *%rax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xb343
movq -0x28(%rbp), %rdi
callq 0x5240
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/main.c
// Function: is_same_linkfile
static int is_same_linkfile(const char *dir, const char *file,  void *argv[])
{
    const char *qmichannel = (const char *)argv[1];
    char linkname[MAX_PATH];
    char filename[MAX_PATH];
    int linksize;

    snprintf(linkname, MAX_PATH, "%s/%s", dir, file);
    linksize = readlink(linkname, filename, MAX_PATH);
    if (linksize <= 0)
        return 0;

    filename[linksize] = 0;
    if (strcmp(filename, qmichannel))
        return 0;

    dbg_time("%s -> %s", linkname, filename);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movl $0x100, %esi            # imm = 0x100
leaq 0x20836(%rip), %rdx     # 0x2bf44
movb $0x0, %al
callq 0x51c0
leaq -0x130(%rbp), %rdi
leaq -0x230(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x50d0
movl %eax, -0x234(%rbp)
cmpl $0x0, -0x234(%rbp)
jg 0xb748
movl $0x0, -0x4(%rbp)
jmp 0xb808
movslq -0x234(%rbp), %rax
movb $0x0, -0x230(%rbp,%rax)
leaq -0x230(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x52a0
cmpl $0x0, %eax
je 0xb778
movl $0x0, -0x4(%rbp)
jmp 0xb808
jmp 0xb77a
movq 0x2b85f(%rip), %rax     # 0x36fe0
movq (%rax), %rax
movq %rax, -0x240(%rbp)
callq 0x13930
movq -0x240(%rbp), %rdi
movq %rax, %rdx
leaq -0x130(%rbp), %rcx
leaq -0x230(%rbp), %r8
leaq 0x2079b(%rip), %rsi     # 0x2bf4a
movb $0x0, %al
callq 0x52c0
leaq 0x2c6ab(%rip), %rax     # 0x37e68
cmpq $0x0, (%rax)
je 0xb7ff
leaq 0x2c69e(%rip), %rax     # 0x37e68
movq (%rax), %rax
movq %rax, -0x248(%rbp)
callq 0x13930
movq -0x248(%rbp), %rdi
movq %rax, %rdx
leaq -0x130(%rbp), %rcx
leaq -0x230(%rbp), %r8
leaq 0x20752(%rip), %rsi     # 0x2bf4a
movb $0x0, %al
callq 0x52c0
jmp 0xb801
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/MPQMUX.c
// Function: dump_tlv
void dump_tlv(PQCQMUX_MSG_HDR pQMUXMsgHdr) {
    int TLVFind = 0;
    int i;
    //dbg("QCQMUX_TLV-----------------------------------\n");
    //dbg("{Type,\tLength,\tValue}\n");

    while (1) {
        PQMI_TLV_HDR TLVHdr = GetTLV(pQMUXMsgHdr, 0x1000 + (++TLVFind));
        if (TLVHdr == NULL)
            break;

        //if ((TLVHdr->TLVType == 0x02) && ((USHORT *)(TLVHdr+1))[0])
        {        
            dbg("{%02x,\t%04x,\t", TLVHdr->TLVType, le16_to_cpu(TLVHdr->TLVLength));
            for (i = 0; i < le16_to_cpu(TLVHdr->TLVLength); i++) {
                dbg("%02x ", ((UCHAR *)(TLVHdr+1))[i]);
            }
            dbg("}\n");
        }
    }  // while
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
addl $0x1000, %esi           # imm = 0x1000
callq 0xc580
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb85b
jmp 0xb9de
jmp 0xb85d
leaq 0x2c11c(%rip), %rdi     # 0x37980
callq 0x5160
cmpq $0x400, %rax            # imm = 0x400
jae 0xb8dd
leaq 0x2c108(%rip), %rdi     # 0x37980
callq 0x5160
movq %rax, %rcx
leaq 0x2c0f9(%rip), %rax     # 0x37980
addq %rcx, %rax
movq %rax, -0x30(%rbp)
leaq 0x2c0eb(%rip), %rdi     # 0x37980
callq 0x5160
movq %rax, %rcx
movl $0x400, %eax            # imm = 0x400
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x1c(%rbp), %ecx
movzwl %ax, %r8d
leaq 0x20726(%rip), %rdx     # 0x2bffc
movb $0x0, %al
callq 0x51c0
jmp 0xb8df
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movw %ax, %cx
movl -0x34(%rbp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jge 0xb97e
jmp 0xb908
leaq 0x2c071(%rip), %rdi     # 0x37980
callq 0x5160
cmpq $0x400, %rax            # imm = 0x400
jae 0xb96c
leaq 0x2c05d(%rip), %rdi     # 0x37980
callq 0x5160
movq %rax, %rcx
leaq 0x2c04e(%rip), %rax     # 0x37980
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq 0x2c040(%rip), %rdi     # 0x37980
callq 0x5160
movq -0x40(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl 0x3(%rax,%rcx), %ecx
leaq 0x206a5(%rip), %rdx     # 0x2c00a
movb $0x0, %al
callq 0x51c0
jmp 0xb96e
jmp 0xb970
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb8e6
jmp 0xb980
leaq 0x2bff9(%rip), %rdi     # 0x37980
callq 0x5160
cmpq $0x400, %rax            # imm = 0x400
jae 0xb9d7
leaq 0x2bfe5(%rip), %rdi     # 0x37980
callq 0x5160
movq %rax, %rcx
leaq 0x2bfd6(%rip), %rax     # 0x37980
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq 0x2bfc8(%rip), %rdi     # 0x37980
callq 0x5160
movq -0x48(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
leaq 0x20640(%rip), %rdx     # 0x2c010
movb $0x0, %al
callq 0x51c0
jmp 0xb9d9
jmp 0xb833
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/MPQMUX.c
// Function: qmi_name_get
static const char * qmi_name_get(const QMI_NAME_T *table, size_t size, int type, const char *tag) {
    static char unknow[40];
    size_t i;

    if (qmux_CtlFlags == table) {
        if (!strcmp(tag, "_REQ"))
            tag = "_CMD";
        else  if (!strcmp(tag, "_RESP"))
            tag = "_RSP";
    }
    
    for (i = 0; i < size; i++) {
        if (table[i].type == (UINT)type) {
            if (!tag || (strstr(table[i].name, tag)))
                return table[i].name;
        }
    }
    sprintf(unknow, "unknow_%x", type);
    return unknow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
leaq 0x2a762(%rip), %rax     # 0x36370
cmpq -0x10(%rbp), %rax
jne 0xbc5a
movq -0x28(%rbp), %rdi
leaq 0x20a47(%rip), %rsi     # 0x2c666
callq 0x52a0
cmpl $0x0, %eax
jne 0xbc36
leaq 0x204a3(%rip), %rax     # 0x2c0d3
movq %rax, -0x28(%rbp)
jmp 0xbc58
movq -0x28(%rbp), %rdi
leaq 0x20a43(%rip), %rsi     # 0x2c684
callq 0x52a0
cmpl $0x0, %eax
jne 0xbc56
leaq 0x20498(%rip), %rax     # 0x2c0ea
movq %rax, -0x28(%rbp)
jmp 0xbc58
jmp 0xbc5a
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xbcd6
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xbcc6
cmpq $0x0, -0x28(%rbp)
je 0xbcab
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x5560
cmpq $0x0, %rax
je 0xbcc4
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xbcf9
jmp 0xbcc6
jmp 0xbcc8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xbc62
movl -0x1c(%rbp), %edx
leaq 0x2c0d0(%rip), %rdi     # 0x37db0
leaq 0x203d0(%rip), %rsi     # 0x2c0b7
movb $0x0, %al
callq 0x54f0
leaq 0x2c0bb(%rip), %rax     # 0x37db0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: GetTLV
PQMI_TLV_HDR GetTLV (PQCQMUX_MSG_HDR pQMUXMsgHdr, int TLVType) {
    int TLVFind = 0;
    USHORT Length = le16_to_cpu(pQMUXMsgHdr->Length);
    PQMI_TLV_HDR pTLVHdr = (PQMI_TLV_HDR)(pQMUXMsgHdr + 1);

    while (Length >= sizeof(QMI_TLV_HDR)) {
        TLVFind++;
        if (TLVType > 0x1000) {
            if ((TLVFind + 0x1000) == TLVType)
                return pTLVHdr;
        } else  if (pTLVHdr->TLVType == TLVType) {
            return pTLVHdr;
        }

        Length -= (le16_to_cpu((pTLVHdr->TLVLength)) + sizeof(QMI_TLV_HDR));
        pTLVHdr = (PQMI_TLV_HDR)(((UCHAR *)pTLVHdr) + le16_to_cpu(pTLVHdr->TLVLength) + sizeof(QMI_TLV_HDR));
    }

   return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x13ed0
movw %ax, -0x1a(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movzwl -0x1a(%rbp), %eax
cmpq $0x3, %rax
jb 0xc657
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1000, -0x14(%rbp)    # imm = 0x1000
jle 0xc5ec
movl -0x18(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
cmpl -0x14(%rbp), %eax
jne 0xc5ea
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc65f
jmp 0xc604
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xc602
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc65f
jmp 0xc604
movq -0x28(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movzwl %ax, %eax
movl %eax, %ecx
addq $0x3, %rcx
movzwl -0x1a(%rbp), %eax
subq %rcx, %rax
movw %ax, -0x1a(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movw %ax, %cx
movq -0x30(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0xc5b3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: QmiThreadSendQMITimeout
int QmiThreadSendQMITimeout(PQCQMIMSG pRequest, PQCQMIMSG *ppResponse, unsigned msecs, const char *funcname) {
    int ret;
    
    if (!pRequest)
        return -EINVAL;

    pthread_mutex_lock(&cm_command_mutex);

    if (ppResponse)
        *ppResponse = NULL;

    dump_qmi(pRequest, le16_to_cpu(pRequest->QMIHdr.Length) + 1);

    s_pRequest = pRequest;
    s_pResponse = NULL;

    ret = qmidev_send(pRequest);

    if (ret == 0) {
        ret = pthread_cond_timeout_np(&cm_command_cond, &cm_command_mutex, msecs);
        if (!ret) {
            if (s_pResponse && ppResponse) {
                *ppResponse = s_pResponse;
            } else {
                if (s_pResponse) {
                    free(s_pResponse);
                    s_pResponse = NULL;
                }
            }
        } else {
            dbg_time("%s message timeout", funcname);
        }
    }

    pthread_mutex_unlock(&cm_command_mutex);

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc69a
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xc7f0
leaq 0x2b76f(%rip), %rdi     # 0x37e10
callq 0x5570
cmpq $0x0, -0x18(%rbp)
je 0xc6b8
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x1(%rax), %edi
callq 0x13ed0
movq -0x38(%rbp), %rdi
movzwl %ax, %esi
addl $0x1, %esi
callq 0xc380
movq -0x10(%rbp), %rax
movq %rax, 0x2b6f1(%rip)     # 0x37dd8
movq $0x0, 0x2b6ee(%rip) # 0x37de0
movq 0x2b6ef(%rip), %rax     # 0x37de8
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xc7de
movl -0x1c(%rbp), %edx
leaq 0x2b722(%rip), %rdi     # 0x37e38
leaq 0x2b6f3(%rip), %rsi     # 0x37e10
callq 0x13cb0
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0xc771
cmpq $0x0, 0x2b6ad(%rip)     # 0x37de0
je 0xc74c
cmpq $0x0, -0x18(%rbp)
je 0xc74c
movq 0x2b69d(%rip), %rcx     # 0x37de0
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc76f
cmpq $0x0, 0x2b68c(%rip)     # 0x37de0
je 0xc76d
movq 0x2b683(%rip), %rdi     # 0x37de0
callq 0x5040
movq $0x0, 0x2b673(%rip) # 0x37de0
jmp 0xc76f
jmp 0xc7dc
jmp 0xc773
movq 0x2a866(%rip), %rax     # 0x36fe0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
callq 0x13930
movq -0x40(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq 0x21178(%rip), %rsi     # 0x2d910
movb $0x0, %al
callq 0x52c0
leaq 0x2b6c2(%rip), %rax     # 0x37e68
cmpq $0x0, (%rax)
je 0xc7d8
leaq 0x2b6b5(%rip), %rax     # 0x37e68
movq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0x13930
movq -0x48(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
leaq 0x2113f(%rip), %rsi     # 0x2d910
movb $0x0, %al
callq 0x52c0
jmp 0xc7da
jmp 0xc7dc
jmp 0xc7de
leaq 0x2b62b(%rip), %rdi     # 0x37e10
callq 0x5350
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: is_response
static int is_response(const PQCQMIMSG pRequest, const PQCQMIMSG pResponse) {
    if ((pRequest->QMIHdr.QMIType == pResponse->QMIHdr.QMIType)
        && (pRequest->QMIHdr.ClientId == pResponse->QMIHdr.ClientId)) {
            USHORT requestTID, responseTID;
        if (pRequest->QMIHdr.QMIType == QMUX_TYPE_CTL) {
            requestTID = pRequest->CTLMsg.QMICTLMsgHdr.TransactionId;
            responseTID = pResponse->CTLMsg.QMICTLMsgHdr.TransactionId;
        } else {
            requestTID = le16_to_cpu(pRequest->MUXMsg.QMUXHdr.TransactionId);
            responseTID = le16_to_cpu(pResponse->MUXMsg.QMUXHdr.TransactionId);
        }
        return (requestTID == responseTID);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jne 0xcb78
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jne 0xcb78
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0xcb3f
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x7(%rax), %eax
movw %ax, -0x1c(%rbp)
jmp 0xcb61
movq -0x10(%rbp), %rax
movzwl 0x7(%rax), %edi
callq 0x13ed0
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x7(%rax), %edi
callq 0x13ed0
movw %ax, -0x1c(%rbp)
movzwl -0x1a(%rbp), %eax
movzwl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xcb7f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: uchar2char
static void uchar2char(char *dst_ptr, size_t dst_len, const UCHAR *src_ptr, size_t src_len) { 
    size_t copy = MIN(dst_len-1, src_len);

    if (copy)
        memcpy(dst_ptr, src_ptr, copy);
    dst_ptr[copy] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
cmpq -0x20(%rbp), %rax
jae 0x113b4
movq -0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x113bc
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x113dc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x52f0
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: GetQMUXTransactionId
static USHORT GetQMUXTransactionId(void) {
    static int TransactionId = 0;
    if (++TransactionId > 0xFFFF)
        TransactionId = 1;
    return TransactionId;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x269f6(%rip), %eax     # 0x37df0
addl $0x1, %eax
movl %eax, 0x269ed(%rip)     # 0x37df0
cmpl $0xffff, %eax           # imm = 0xFFFF
jle 0x11414
movl $0x1, 0x269dc(%rip)     # 0x37df0
movl 0x269d6(%rip), %eax     # 0x37df0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: WdsSetQMUXBindMuxDataPort
static USHORT WdsSetQMUXBindMuxDataPort(PQMUX_MSG pMUXMsg, void *arg) {
    QMAP_SETTING *qmap_settings = (QMAP_SETTING *)arg;

    pMUXMsg->BindMuxDataPortReq.TLVType = 0x10;
    pMUXMsg->BindMuxDataPortReq.TLVLength = cpu_to_le16(0x08);
    pMUXMsg->BindMuxDataPortReq.ep_type = cpu_to_le32(qmap_settings->ep_type);
    pMUXMsg->BindMuxDataPortReq.iface_id = cpu_to_le32(qmap_settings->iface_id);
    pMUXMsg->BindMuxDataPortReq.TLV2Type = 0x11;
    pMUXMsg->BindMuxDataPortReq.TLV2Length = cpu_to_le16(0x01);
    pMUXMsg->BindMuxDataPortReq.MuxId = qmap_settings->MuxId;
    pMUXMsg->BindMuxDataPortReq.TLV3Type = 0x13;
    pMUXMsg->BindMuxDataPortReq.TLV3Length = cpu_to_le16(0x04);
    pMUXMsg->BindMuxDataPortReq.client_type = cpu_to_le32(1); //WDS_CLIENT_TYPE_TETHERED
    
    return sizeof(QMIWDS_BIND_MUX_DATA_PORT_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movb $0x10, 0x7(%rax)
movl $0x8, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x14040
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xa(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edi
callq 0x14040
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe(%rax)
movq -0x8(%rbp), %rax
movb $0x11, 0x12(%rax)
movl $0x1, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x13(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x15(%rax)
movq -0x8(%rbp), %rax
movb $0x13, 0x16(%rax)
movl $0x4, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x17(%rax)
movl $0x1, %edi
callq 0x14040
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x19(%rax)
movw $0x1a, %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: WdsSetClientIPFamilyPref
static USHORT WdsSetClientIPFamilyPref(PQMUX_MSG pMUXMsg, void *arg) {
    pMUXMsg->SetClientIpFamilyPrefReq.TLVType = 0x01;
    pMUXMsg->SetClientIpFamilyPrefReq.TLVLength = cpu_to_le16(0x01);
    pMUXMsg->SetClientIpFamilyPrefReq.IpPreference = *((UCHAR *)arg);
    return sizeof(QMIWDS_SET_CLIENT_IP_FAMILY_PREF_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x7(%rax)
movl $0x1, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movw $0x8, %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: WdaSetLoopBackReq
static USHORT WdaSetLoopBackReq(PQMUX_MSG pMUXMsg, void *arg) {
    (void)arg;
	pMUXMsg->SetLoopBackReq.loopback_state.TLVType  = 0x01;
	pMUXMsg->SetLoopBackReq.loopback_state.TLVLength = cpu_to_le16(1);

	pMUXMsg->SetLoopBackReq.replication_factor.TLVType	= 0x10;
	pMUXMsg->SetLoopBackReq.replication_factor.TLVLength = cpu_to_le16(4);

	return sizeof(QMI_WDA_SET_LOOPBACK_CONFIG_REQ_MSG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x7(%rax)
movl $0x1, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x10, 0xb(%rax)
movl $0x4, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc(%rax)
movw $0xf, %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Carton32[P]quectel-CM/QMIThread.c
// Function: UimVerifyPinReqSend
static USHORT UimVerifyPinReqSend(PQMUX_MSG pMUXMsg, void *arg)
{
    pMUXMsg->UIMUIMVerifyPinReq.TLVType = 0x01;
    pMUXMsg->UIMUIMVerifyPinReq.TLVLength = cpu_to_le16(0x02);
    pMUXMsg->UIMUIMVerifyPinReq.Session_Type = 0x00;
    pMUXMsg->UIMUIMVerifyPinReq.Aid_Len = 0x00;
    pMUXMsg->UIMUIMVerifyPinReq.TLV2Type = 0x02;
    pMUXMsg->UIMUIMVerifyPinReq.TLV2Length = cpu_to_le16(2 + strlen((const char *)arg));
    pMUXMsg->UIMUIMVerifyPinReq.PINID = 0x01;  //Pin1, not Puk
    pMUXMsg->UIMUIMVerifyPinReq.PINLen= strlen((const char *)arg);
    qstrcpy((char *)&pMUXMsg->UIMUIMVerifyPinReq.PINValue, ((const char *)arg));
    return sizeof(QMIUIM_VERIFY_PIN_REQ_MSG) + (strlen((const char *)arg) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x7(%rax)
movl $0x2, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xa(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x8(%rbp), %rax
movb $0x2, 0xc(%rax)
movq -0x10(%rbp), %rdi
callq 0x5160
addq $0x2, %rax
movzwl %ax, %edi
callq 0x13ff0
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xd(%rax)
movq -0x8(%rbp), %rax
movb $0x1, 0xf(%rax)
movq -0x10(%rbp), %rdi
callq 0x5160
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
addq $0xe, %rdi
movq -0x10(%rbp), %rsi
callq 0x11cb0
movq -0x10(%rbp), %rdi
callq 0x5160
subq $0x1, %rax
addq $0xf, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)