LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/functions.c
// Function: biasInit
int biasInit(BLOB_s *b)
{
	BLOB_DATA_PTR(b,ptr);
	
	for (int i_batch = 0;i_batch < b->numSize;i_batch++) {
		for (int i_num = 0;i_num < b->channelSize;i_num++) {	
			for (int i_height = 0;i_height < b->heightSize;i_height++) {
				for (int i_width = 0;i_width < b->widthSize;i_width++) {	
					ptr[i_batch][i_num][i_height][i_width] = 0;
				}
			}
		}
	}
	
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3438
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x3428
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x3418
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x3408
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq %rsi, %rdi
imulq %rdx, %rdi
imulq %rdi, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq %rdx, %rsi
imulq %rsi, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
imulq %rdx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x339a
jmp 0x340a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3381
jmp 0x341a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3368
jmp 0x342a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x334f
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/functions.c
// Function: functionLoss1
double functionLoss1(BLOB_s *pError)
{
	CHECK_EXPR_RET(pError == NULL,-1);

	double loss = 0.0;
	for (int i = 0;i < pError->count;i++) {
		loss += 0.5 * pError->data[i] * pError->data[i];
	}
	loss /= pError->numSize;

	return loss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3486
leaq 0x7bbb(%rip), %rdi      # 0xb015
leaq 0x7f57(%rip), %rsi      # 0xb3b8
leaq 0x7f67(%rip), %rdx      # 0xb3cf
movl $0x4f, %ecx
movb $0x0, %al
callq 0x1030
movsd 0x7e4c(%rip), %xmm0     # 0xb2c8
movsd %xmm0, -0x8(%rbp)
jmp 0x352d
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x34ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x7e09(%rip), %xmm0     # 0xb2c0
mulsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3495
movq -0x10(%rbp), %rax
movq 0x10(%rax), %xmm1
movaps 0x7dd6(%rip), %xmm0     # 0xb2d0
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movapd 0x7dda(%rip), %xmm0     # 0xb2e0
subpd %xmm0, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NET_create
NET_s *NET_create(NET_PARA_s *pNetPara)
{
	CHECK_EXPR_RET(pNetPara == NULL,NULL);
	
	NET_s *pNet = (NET_s *)malloc(sizeof(NET_s));
	CHECK_EXPR_RET(pNet == NULL,NULL);

	pNet->pMTree = MTREE_create(pNet);
	CHECK_EXPR_RET(pNet->pMTree == NULL,NULL);
	
	memcpy(&pNet->para, pNetPara, sizeof(pNet->para));

	for (int i = 0;i < LAYERS_MAX_N;i++) {
		pNet->layers[i] = NULL;
	} 
	pNet->layerId = 0;

	int ret = BLOB_create(&pNet->pTableY,pNetPara->batchsize,pNetPara->classifyNum,1,1,FALSE);
	CHECK_EXPR_RET(ret != 0,NULL);

	pNet->para.pTableY = pNet->pTableY;
	printf("NET_init!\n");
	
	return pNet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3cb1
leaq 0x738b(%rip), %rdi      # 0xb015
leaq 0x774c(%rip), %rsi      # 0xb3dd
leaq 0x776a(%rip), %rdx      # 0xb402
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x3e28
movl $0x2248, %edi           # imm = 0x2248
callq 0x10e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3cf4
leaq 0x7348(%rip), %rdi      # 0xb015
leaq 0x7709(%rip), %rsi      # 0xb3dd
leaq 0x7727(%rip), %rdx      # 0xb402
movl $0x2f, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x3e28
movq -0x18(%rbp), %rdi
callq 0x5e00
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x230(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x230(%rax)
jne 0x3d47
leaq 0x72f5(%rip), %rdi      # 0xb015
leaq 0x76b6(%rip), %rsi      # 0xb3dd
leaq 0x76d4(%rip), %rdx      # 0xb402
movl $0x32, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x3e28
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x230, %edx            # imm = 0x230
callq 0x1090
movl $0x0, -0x1c(%rbp)
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
jge 0x3d88
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq $0x0, 0x240(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3d60
movq -0x18(%rbp), %rax
movl $0x0, 0x2240(%rax)
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movq -0x10(%rbp), %rax
movslq 0x210(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x21c(%rax), %rdx
movl $0x1, %r8d
xorl %r9d, %r9d
movq %r8, %rcx
callq 0x2280
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x3dfc
leaq 0x723d(%rip), %rdi      # 0xb015
leaq 0x75fe(%rip), %rsi      # 0xb3dd
leaq 0x761c(%rip), %rdx      # 0xb402
movl $0x3c, %ecx
movb $0x0, %al
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x3e28
movq -0x18(%rbp), %rax
movq 0x238(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x228(%rax)
leaq 0x75f4(%rip), %rdi      # 0xb40d
movb $0x0, %al
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NETForwardPrint
static int NETForwardPrint(void *usr,int idCurr,int *idPrev,int nIdPrev)
{
	NET_s *pNet = (NET_s *)usr;
	CHECK_EXPR_RET(pNet == NULL,-1);
	
	LAYER_s *pLayerCurr =  pNet->layers[idCurr];
	CHECK_EXPR_RET(pLayerCurr == NULL,-1);
	
	printf("====>%s nNext:%d \n",pLayerCurr->para->name,pLayerCurr->nNext);
	for (int i = 0;i < nIdPrev;i++) {
		printf("**%s-->%s:\n",pNet->layers[idPrev[i]]->para->name,pLayerCurr->para->name);
	}
	CHECK_EXPR_RET(pLayerCurr->pData == NULL,-1);
	BLOB_printPara(pLayerCurr->pData);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x44a2
leaq 0x6b99(%rip), %rdi      # 0xb015
leaq 0x6f5a(%rip), %rsi      # 0xb3dd
leaq 0x703b(%rip), %rdx      # 0xb4c5
movl $0x8b, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45ab
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x44ea
leaq 0x6b51(%rip), %rdi      # 0xb015
leaq 0x6f12(%rip), %rsi      # 0xb3dd
leaq 0x6ff3(%rip), %rdx      # 0xb4c5
movl $0x8e, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45ab
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
movq -0x38(%rbp), %rax
movl 0xa0(%rax), %edx
leaq 0x6fce(%rip), %rdi      # 0xb4d5
movb $0x0, %al
callq 0x1030
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4562
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdx
addq $0x44, %rdx
leaq 0x6f98(%rip), %rdi      # 0xb4e8
movb $0x0, %al
callq 0x1030
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4515
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4597
leaq 0x6aa1(%rip), %rdi      # 0xb015
leaq 0x6e62(%rip), %rsi      # 0xb3dd
leaq 0x6f43(%rip), %rdx      # 0xb4c5
movl $0x94, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x45ab
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2c40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NETBackwardPrint
static int NETBackwardPrint(void *usr,int idCurr,int *idNext,int nIdNext)
{
	NET_s *pNet = (NET_s *)usr;
	CHECK_EXPR_RET(pNet == NULL,-1);

	LAYER_s *pLayerCurr =  pNet->layers[idCurr];
	CHECK_EXPR_RET(pLayerCurr == NULL,-1);

	printf("<====%s:\n",pLayerCurr->para->name);
	for (int i = 0;i < nIdNext;i++) {
		printf("**%s<--%s:\n",pLayerCurr->para->name,pNet->layers[idNext[i]]->para->name);
	}
	CHECK_EXPR_RET(pLayerCurr->pData == NULL,-1);
	BLOB_printPara(pLayerCurr->pData);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4652
leaq 0x69e9(%rip), %rdi      # 0xb015
leaq 0x6daa(%rip), %rsi      # 0xb3dd
leaq 0x6eba(%rip), %rdx      # 0xb4f4
movl $0xa3, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4751
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x469a
leaq 0x69a1(%rip), %rdi      # 0xb015
leaq 0x6d62(%rip), %rsi      # 0xb3dd
leaq 0x6e72(%rip), %rdx      # 0xb4f4
movl $0xa6, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4751
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
leaq 0x6e58(%rip), %rdi      # 0xb505
movb $0x0, %al
callq 0x1030
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4708
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
addq $0x44, %rdx
leaq 0x6e19(%rip), %rdi      # 0xb50f
movb $0x0, %al
callq 0x1030
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x46bb
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x473d
leaq 0x68fb(%rip), %rdi      # 0xb015
leaq 0x6cbc(%rip), %rsi      # 0xb3dd
leaq 0x6dcc(%rip), %rdx      # 0xb4f4
movl $0xac, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4751
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2c40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NETLayerInit
static int NETLayerInit(NET_s *pNet,int idCurr,int *idPrev,int nIdPrev)
{
	CHECK_EXPR_RET(pNet->layers[idCurr]->init == NULL,-1);
	for (int i = 0;i < nIdPrev;i++) {
		 pNet->layers[idCurr]->pPrev[i] = pNet->layers[idPrev[i]];
	}
	CHECK_EXPR_RET(pNet->layers[idCurr]->init == NULL,-1);
	int ret = pNet->layers[idCurr]->init(&pNet->para,pNet->layers[idCurr]);
	CHECK_EXPR_RET(ret != 0,-1);
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
cmpq $0x0, 0x48(%rax)
jne 0x484a
leaq 0x67f1(%rip), %rdi      # 0xb015
leaq 0x6bb2(%rip), %rsi      # 0xb3dd
leaq 0x6ce9(%rip), %rdx      # 0xb51b
movl $0xbb, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x493d
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x4898
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq 0x240(%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, 0xa8(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4851
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
cmpq $0x0, 0x48(%rax)
jne 0x48d9
leaq 0x675f(%rip), %rdi      # 0xb015
leaq 0x6b20(%rip), %rsi      # 0xb3dd
leaq 0x6c57(%rip), %rdx      # 0xb51b
movl $0xbf, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x493d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movq 0x240(%rcx,%rdx,8), %rsi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x4936
leaq 0x6702(%rip), %rdi      # 0xb015
leaq 0x6ac3(%rip), %rsi      # 0xb3dd
leaq 0x6bfa(%rip), %rdx      # 0xb51b
movl $0xc1, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x493d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NET_test
int NET_test(NET_s *pNet)
{
	CHECK_EXPR_RET(pNet == NULL,-1);

	printf(">>>>NET_test:\n");
	int ret = MTREE_forward(pNet->pMTree,NETForward);
	CHECK_EXPR_RET(ret != 0,-1);

	int idEnd[LAYER_MAX_MUX];
	int nEnd;
	MTREE_getEndIds(pNet->pMTree,idEnd,&nEnd);
	CHECK_EXPR_RET(nEnd <= 0 || nEnd > LAYER_MAX_MUX,-1);
	LAYER_s *pLayer = NULL;
	for (int i = 0;i < nEnd;i++) {
		pLayer = pNet->layers[idEnd[i]];
		CHECK_EXPR_RET(pLayer == NULL,-1);
//		printf("%s test out:\n",pLayer->name);
		BLOB_print(pLayer->pData);
	}
	
	return 0;
 }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4990
leaq 0x66ab(%rip), %rdi      # 0xb015
leaq 0x6a6c(%rip), %rsi      # 0xb3dd
leaq 0x6af4(%rip), %rdx      # 0xb46c
movl $0x14f, %ecx            # imm = 0x14F
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4abc
leaq 0x6ade(%rip), %rdi      # 0xb475
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rdi
leaq 0x120(%rip), %rsi       # 0x4ad0
callq 0x63b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x49eb
leaq 0x6650(%rip), %rdi      # 0xb015
leaq 0x6a11(%rip), %rsi      # 0xb3dd
leaq 0x6a99(%rip), %rdx      # 0xb46c
movl $0x153, %ecx            # imm = 0x153
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4abc
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x6770
cmpl $0x0, -0x44(%rbp)
jle 0x4a0f
cmpl $0x8, -0x44(%rbp)
jle 0x4a3c
leaq 0x65ff(%rip), %rdi      # 0xb015
leaq 0x69c0(%rip), %rsi      # 0xb3dd
leaq 0x6a48(%rip), %rdx      # 0xb46c
movl $0x158, %ecx            # imm = 0x158
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4abc
movq $0x0, -0x50(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x4ab5
movq -0x10(%rbp), %rax
movslq -0x54(%rbp), %rcx
movslq -0x40(%rbp,%rcx,4), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x4a9d
leaq 0x659b(%rip), %rdi      # 0xb015
leaq 0x695c(%rip), %rsi      # 0xb3dd
leaq 0x69e4(%rip), %rdx      # 0xb46c
movl $0x15c, %ecx            # imm = 0x15C
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4abc
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2d90
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4a4b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NET_GetLoss
double NET_GetLoss(NET_s *pNet,char *layerName)
{
	CHECK_EXPR_RET(layerName == NULL,-1);

	int idEnd[LAYER_MAX_MUX];
	int nEnd;

	MTREE_getEndIds(pNet->pMTree,idEnd,&nEnd);
	CHECK_EXPR_RET(nEnd <= 0,-1);
	LAYER_s *pLayer = NULL;
	double  loss = 0;
	for (int i = 0;i < nEnd;i++) {
		pLayer = pNet->layers[idEnd[i]];
		if (strcmp(layerName,pLayer->para->name) == 0) {
			CHECK_EXPR_RET(pLayer->pError == NULL,-1);
			CHECK_EXPR_RET(pNet->para.loss_function == NULL,-1);
			loss = pNet->para.loss_function(pLayer->pError);
			break;
		}
	}

	return loss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4dfa
leaq 0x6247(%rip), %rdi      # 0xb015
leaq 0x6608(%rip), %rsi      # 0xb3dd
leaq 0x66a8(%rip), %rdx      # 0xb484
movl $0x166, %ecx            # imm = 0x166
movb $0x0, %al
callq 0x1030
movsd 0x64d8(%rip), %xmm0     # 0xb2c8
movsd %xmm0, -0x8(%rbp)
jmp 0x4f5a
movq -0x10(%rbp), %rax
movq 0x230(%rax), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x44(%rbp), %rdx
callq 0x6770
cmpl $0x0, -0x44(%rbp)
jg 0x4e4b
leaq 0x61f6(%rip), %rdi      # 0xb015
leaq 0x65b7(%rip), %rsi      # 0xb3dd
leaq 0x6657(%rip), %rdx      # 0xb484
movl $0x16c, %ecx            # imm = 0x16C
movb $0x0, %al
callq 0x1030
movsd 0x6487(%rip), %xmm0     # 0xb2c8
movsd %xmm0, -0x8(%rbp)
jmp 0x4f5a
movq $0x0, -0x50(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x4f50
movq -0x10(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movslq -0x40(%rbp,%rcx,4), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x4f40
movq -0x50(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x4ee3
leaq 0x615b(%rip), %rdi      # 0xb015
leaq 0x651c(%rip), %rsi      # 0xb3dd
leaq 0x65bc(%rip), %rdx      # 0xb484
movl $0x172, %ecx            # imm = 0x172
movb $0x0, %al
callq 0x1030
movsd 0x63ec(%rip), %xmm0     # 0xb2c8
movsd %xmm0, -0x8(%rbp)
jmp 0x4f5a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x220(%rax)
jne 0x4f21
leaq 0x611d(%rip), %rdi      # 0xb015
leaq 0x64de(%rip), %rsi      # 0xb3dd
leaq 0x657e(%rip), %rdx      # 0xb484
movl $0x173, %ecx            # imm = 0x173
movb $0x0, %al
callq 0x1030
movsd 0x63ae(%rip), %xmm0     # 0xb2c8
movsd %xmm0, -0x8(%rbp)
jmp 0x4f5a
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x50(%rbp), %rcx
movq 0xf8(%rcx), %rdi
callq *%rax
movsd %xmm0, -0x58(%rbp)
jmp 0x4f50
jmp 0x4f42
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x4e62
movsd -0x58(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/net.c
// Function: NETBackward
static int NETBackward(void *usr,int idCurr,int *idNext,int nIdNext)
{
	NET_s *pNet = (NET_s *)usr;
	CHECK_EXPR_RET(pNet == NULL,-1);

	LAYER_s *pLayerCurr = pNet->layers[idCurr];
	CHECK_EXPR_RET(pLayerCurr == NULL,-1);

	CHECK_EXPR_RET(pLayerCurr->backward == NULL,-1);
	for (int i = 0;i < nIdNext;i++) {
		pLayerCurr->pNext[i] = pNet->layers[idNext[i]];
	}
	pLayerCurr->nNext = nIdNext;

	CHECK_EXPR_RET(pLayerCurr->backward == NULL,-1);
	return pLayerCurr->backward(&pNet->para,pLayerCurr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5022
leaq 0x6019(%rip), %rdi      # 0xb015
leaq 0x63da(%rip), %rsi      # 0xb3dd
leaq 0x6547(%rip), %rdx      # 0xb551
movl $0x105, %ecx            # imm = 0x105
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5138
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x240(%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x506a
leaq 0x5fd1(%rip), %rdi      # 0xb015
leaq 0x6392(%rip), %rsi      # 0xb3dd
leaq 0x64ff(%rip), %rdx      # 0xb551
movl $0x108, %ecx            # imm = 0x108
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5138
movq -0x38(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x50a2
leaq 0x5f99(%rip), %rdi      # 0xb015
leaq 0x635a(%rip), %rsi      # 0xb3dd
leaq 0x64c7(%rip), %rdx      # 0xb551
movl $0x10a, %ecx            # imm = 0x10A
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5138
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x50e1
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq 0x240(%rax,%rcx,8), %rdx
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, 0x60(%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x50a9
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xa0(%rax)
movq -0x38(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x5123
leaq 0x5f15(%rip), %rdi      # 0xb015
leaq 0x62d6(%rip), %rsi      # 0xb3dd
leaq 0x6443(%rip), %rdx      # 0xb551
movl $0x110, %ecx            # imm = 0x110
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5138
movq -0x38(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq *%rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/layers/data_layer.c
// Function: DataLayerInit
int DataLayerInit(NET_PARA_s *pNetPara,LAYER_s *pLayer)
{
	CHECK_EXPR_RET(pLayer == NULL,-1);
	
	DATA_LAYER_PARA_s *layerPara = &pLayer->para->select.dataLayer;
	
	int ret = BLOB_create(&pLayer->pData,pNetPara->batchsize,\
						1,layerPara->wSize,layerPara->hSize,FALSE);
	CHECK_EXPR_RET(ret != 0,-1);


	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8581
leaq 0x2ab7(%rip), %rdi      # 0xb015
leaq 0x324a(%rip), %rsi      # 0xb7af
leaq 0x3250(%rip), %rdx      # 0xb7bc
movl $0xe, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85fd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x288, %rax            # imm = 0x288
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movslq 0x210(%rax), %rsi
movq -0x20(%rbp), %rax
movslq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movslq 0x4(%rax), %r8
movl $0x1, %edx
xorl %r9d, %r9d
callq 0x2280
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x85f6
leaq 0x2a42(%rip), %rdi      # 0xb015
leaq 0x31d5(%rip), %rsi      # 0xb7af
leaq 0x31db(%rip), %rdx      # 0xb7bc
movl $0x14, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x85fd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/layers/linear_layer.c
// Function: LinearLayerInit
int LinearLayerInit(NET_PARA_s *pNetPara,LAYER_s *pLayer)
{
	CHECK_EXPR_RET(pLayer == NULL,-1);
	BLOB_s *pPrevBlob = pLayer->pPrev[0]->pData;
	CHECK_EXPR_RET(pPrevBlob == NULL,-1);
	
	int size = pPrevBlob->channelSize * pPrevBlob->heightSize* pPrevBlob->widthSize;
	int ret = BLOB_create(&pLayer->pData,pNetPara->batchsize,size,
								1,1,TRUE);
	CHECK_EXPR_RET(ret != 0,-1);

	ret = BLOB_shapeLike(pLayer->pData,&pLayer->pDelta);
	CHECK_EXPR_RET(ret != 0,-1);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8664
leaq 0x29d7(%rip), %rdi      # 0xb015
leaq 0x3185(%rip), %rsi      # 0xb7ca
leaq 0x318d(%rip), %rdx      # 0xb7d9
movl $0x2a, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8775
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x86ab
leaq 0x2990(%rip), %rdi      # 0xb015
leaq 0x313e(%rip), %rsi      # 0xb7ca
leaq 0x3146(%rip), %rdx      # 0xb7d9
movl $0x2c, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8775
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
imulq 0x20(%rcx), %rax
movq -0x20(%rbp), %rcx
imulq 0x28(%rcx), %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movslq 0x210(%rax), %rsi
movslq -0x24(%rbp), %rdx
movl $0x1, %r8d
movl $0x1, %r9d
movq %r8, %rcx
callq 0x2280
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x8726
leaq 0x2912(%rip), %rdi      # 0xb015
leaq 0x30c0(%rip), %rsi      # 0xb7ca
leaq 0x30c8(%rip), %rdx      # 0xb7d9
movl $0x31, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8775
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x28e0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x876e
leaq 0x28ca(%rip), %rdi      # 0xb015
leaq 0x3078(%rip), %rsi      # 0xb7ca
leaq 0x3080(%rip), %rdx      # 0xb7d9
movl $0x34, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8775
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/layers/samp_layer.c
// Function: SampLayerInit
int SampLayerInit(NET_PARA_s *pNetPara,LAYER_s *pLayer)
{
	SAMP_LAYER_PARA_s *pPara = &pLayer->para->select.sampLayer;

	BLOB_s *pPrevBlob = pLayer->pPrev[0]->pData;
	CHECK_EXPR_RET(pPrevBlob->widthSize% pPara->stride != 0,-1);
	CHECK_EXPR_RET(pPrevBlob->heightSize% pPara->stride != 0,-1);

	int width =  pPrevBlob->widthSize/ pPara->stride;
	int height =  pPrevBlob->heightSize/ pPara->stride;

	int ret = BLOB_create(&pLayer->pData,pNetPara->batchsize,pPrevBlob->channelSize,\
			width,height,TRUE);
	CHECK_EXPR_RET(ret != 0,-1);
	
	ret = BLOB_shapeLike(pLayer->pData,&pLayer->pDelta);
	CHECK_EXPR_RET(ret != 0,-1);
	pLayer->sampScale = pPara->stride;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x288, %rax            # imm = 0x288
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xa8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x9f3d
leaq 0x10fe(%rip), %rdi      # 0xb015
leaq 0x193f(%rip), %rsi      # 0xb85d
leaq 0x1945(%rip), %rdx      # 0xb86a
movl $0x2e, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa076
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x9f85
leaq 0x10b6(%rip), %rdi      # 0xb015
leaq 0x18f7(%rip), %rsi      # 0xb85d
leaq 0x18fd(%rip), %rdx      # 0xb86a
movl $0x2f, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa076
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rax
movslq 0x210(%rax), %rsi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
movslq -0x2c(%rbp), %rcx
movslq -0x30(%rbp), %r8
movl $0x1, %r9d
callq 0x2280
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xa016
leaq 0x1022(%rip), %rdi      # 0xb015
leaq 0x1863(%rip), %rsi      # 0xb85d
leaq 0x1869(%rip), %rdx      # 0xb86a
movl $0x36, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa076
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
callq 0x28e0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0xa05e
leaq 0xfda(%rip), %rdi       # 0xb015
leaq 0x181b(%rip), %rsi      # 0xb85d
leaq 0x1821(%rip), %rdx      # 0xb86a
movl $0x39, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa076
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xec(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zhoudian64[P]OS2-exp/sender.c
// Function: main
int main() {
	printf("\n");
	int i;
	close(1);
	open("./mypipe.txt", O_WRONLY | O_CREAT, 0666);
	for( i=0; ; i++) {
	// 由于pipe1 被关闭了所以都往下一个fd(open的文件)里写了
		printf("%d\n", i);
		sleep(1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe8d(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1040
leaq 0xe66(%rip), %rdi       # 0x2004
movl $0x41, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1050
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0xe51(%rip), %rdi       # 0x2011
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1060
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11b6
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_08/bfree.c
// Function: c_malloc
void *c_malloc(size_t nr_of_bytes)
{
  Header *p;
  Header *prev_p;

  if (nr_of_bytes == 0 || nr_of_bytes >= UINT_MAX - MIN_NR_OF_UNITS)
  {
    fprintf(stderr, "Error(malloc): invalid size %zu\n", nr_of_bytes);
    return NULL;
  }

  size_t nr_of_units = (nr_of_bytes + sizeof(Header) - 1) / sizeof(Header);

  if ((prev_p = free_p) == NULL)
  {
    base.s.free_block_p = free_p = prev_p = &base;
    base.s.size = 0;
  }

  for (p = prev_p->s.free_block_p;; prev_p = p, p = p->s.free_block_p)
  {
    if (p->s.size >= nr_of_units)
    {
      if (p->s.size == nr_of_units)
      {
        prev_p->s.free_block_p = p->s.free_block_p;
      }
      else
      {
        p->s.size -= nr_of_units;
        p += p->s.size;
        p->s.size = nr_of_units;
      }

      free_p = prev_p;
      return (void *)(p + 1);
    }

    if (p == free_p)
    {
      if ((p = c_morecore(nr_of_units)) == NULL)
      {
        return NULL;
      }
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12be
movl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
cmpq %rax, -0x10(%rbp)
jb 0x12e7
movq 0x2d33(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xe28(%rip), %rsi       # 0x20fb
movb $0x0, %al
callq 0x1070
movq $0x0, -0x8(%rbp)
jmp 0x1407
movq -0x10(%rbp), %rax
addq $0x10, %rax
subq $0x1, %rax
shrq $0x4, %rax
movq %rax, -0x28(%rbp)
movq 0x2d5e(%rip), %rax      # 0x4060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x133e
leaq 0x2d55(%rip), %rax      # 0x4068
movq %rax, -0x20(%rbp)
leaq 0x2d4a(%rip), %rax      # 0x4068
movq %rax, 0x2d3b(%rip)      # 0x4060
leaq 0x2d3c(%rip), %rax      # 0x4068
movq %rax, 0x2d35(%rip)      # 0x4068
movq $0x0, 0x2d32(%rip) # 0x4070
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jb 0x13c1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x28(%rbp), %rax
jne 0x1375
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x13a8
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x4, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x2cad(%rip)      # 0x4060
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x1407
movq -0x18(%rbp), %rax
cmpq 0x2c94(%rip), %rax      # 0x4060
jne 0x13ed
movq -0x28(%rbp), %rdi
callq 0x1660
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x13eb
movq $0x0, -0x8(%rbp)
jmp 0x1407
jmp 0x13ed
jmp 0x13ef
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1349
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_08/bfree.c
// Function: c_free
void c_free(void *a_p)
{
  Header *p;
  Header *b_p = (Header *)a_p - 1;

  if (b_p->s.size == 0 || b_p->s.size == UINT_MAX - MIN_NR_OF_UNITS)
  {
    fprintf(stderr, "Error(free): invalid block size %zu\n", b_p->s.size);
    return;
  }

  for (p = free_p; !(b_p > p && b_p < p->s.free_block_p); p = p->s.free_block_p)
  {
    if (p >= p->s.free_block_p && (b_p > p || b_p < p->s.free_block_p))
    {
      break;
    }
  }

  if (b_p + b_p->s.size == p->s.free_block_p)
  {
    b_p->s.size += p->s.free_block_p->s.size;
    b_p->s.free_block_p = p->s.free_block_p->s.free_block_p;
  }
  else
  {
    b_p->s.free_block_p = p->s.free_block_p;
  }

  if (p + p->s.size == b_p)
  {
    p->s.size += b_p->s.size;
    p->s.free_block_p = b_p->s.free_block_p;
  }
  else
  {
    p->s.free_block_p = b_p;
  }

  free_p = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1452
movq -0x18(%rbp), %rax
movl $0xfffffbff, %ecx       # imm = 0xFFFFFBFF
cmpq %rcx, 0x8(%rax)
jne 0x1477
movq 0x2b9f(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0xc41(%rip), %rsi       # 0x20ac
movb $0x0, %al
callq 0x1070
jmp 0x1589
movq 0x2be2(%rip), %rax      # 0x4060
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0x14a2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x14ad
jmp 0x14e2
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0x14d3
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x14d1
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x14d3
jmp 0x14e2
jmp 0x14d5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1482
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1528
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1536
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jne 0x1573
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x157e
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x2ad7(%rip)      # 0x4060
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_8/exercise_8_08/bfree.c
// Function: c_bfree
void c_bfree(void *p, size_t block_size)
{
  Header *b_p;

  if (block_size < MIN_NR_OF_UNITS)
  {
    fprintf(stderr, "Error: block must be at least of size %d\n", MIN_NR_OF_UNITS);
    return;
  }

  b_p = (Header *)p;
  b_p->s.size = (block_size / sizeof(Header)) - 1;
  c_free((void *)(b_p + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x400, -0x10(%rbp)     # imm = 0x400
jae 0x1629
movq 0x29e7(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xab6(%rip), %rsi       # 0x20d1
movl $0x400, %edx            # imm = 0x400
movb $0x0, %al
callq 0x1070
jmp 0x1652
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
shrq $0x4, %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x1420
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_08/getch.c
// Function: main
int main(void)
{
  char c = getch();
  printf("%c\n", c);

  ungetch(c);

  printf("%c\n", c = getch());

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x11b0
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %esi
leaq 0xe92(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movsbl -0x5(%rbp), %edi
callq 0x11f0
callq 0x11b0
movb %al, -0x5(%rbp)
movsbl %al, %esi
leaq 0xe70(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_08/getch.c
// Function: getch
int getch(void)
{
  char temp;

  if (buf != -1)
  {
    temp = buf;
    buf = -1;

    return temp;
  }

  return getchar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $-0x1, 0x2e79(%rip)     # 0x4038
je 0x11dd
movl 0x2e71(%rip), %eax      # 0x4038
movb %al, -0x5(%rbp)
movl $0xffffffff, 0x2e64(%rip) # imm = 0xFFFFFFFF
movsbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x11e5
callq 0x1040
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_up
static void command_navigate_up(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_up(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xac10
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_pagedown
static void command_navigate_pagedown(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_pagedown(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xaed0
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_left
static void command_navigate_left(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	const char *oldpathname = NULL;

	save_current_position(app);

	if(path_remove_component(&app->cwd, &oldpathname))
		enter_directory(app, oldpathname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x58f0
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
leaq -0x20(%rbp), %rsi
callq 0xb470
testb $0x1, %al
jne 0x3989
jmp 0x3996
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5260
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_right
static void command_navigate_right(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;

	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	save_current_position(app);

	size_t index = listview_getindex(&app->view);
	if(dirmodel_isdir(&app->model, index)) {
		const char *filename = dirmodel_getfilename(&app->model, index);
		if(!path_add_component(&app->cwd, filename))
			return;
		enter_directory(app, NULL);
	} else {
		command_invoke_handler(commandexecutor, "open");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
jne 0x39d3
jmp 0x3a4e
movq -0x18(%rbp), %rdi
callq 0x58f0
movq -0x18(%rbp), %rdi
callq 0xafa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x82e0
testb $0x1, %al
jne 0x3a00
jmp 0x3a3e
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0x8250
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x28(%rbp), %rsi
callq 0xb350
testb $0x1, %al
jne 0x3a2f
jmp 0x3a4e
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5260
jmp 0x3a4e
movq -0x8(%rbp), %rdi
leaq 0x96e6(%rip), %rsi      # 0xd12f
callq 0x3d60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_first
static void command_navigate_first(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_setindex(&app->view, 0);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaf70
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_last
static void command_navigate_last(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	size_t count = listmodel_count(&app->model.listmodel);

	if(count > 0) {
		listview_setindex(&app->view, count - 1);
		listview_refresh(&app->view);
		refresh_statusbar(app);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x3b09
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
subq $0x1, %rsi
callq 0xaf70
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_togglemark
static void command_togglemark(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	listmodel_setmark(&app->model.listmodel, index, !listmodel_ismarked(&app->model.listmodel, index));
	listview_down(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
cmpq $0x0, %rax
jne 0x3b43
jmp 0x3ba5
movq -0x18(%rbp), %rdi
callq 0xafa0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x20(%rbp), %rsi
callq 0xa710
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorb $-0x1, %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xa6c0
movq -0x18(%rbp), %rdi
callq 0xae10
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_invert_marks
static void command_invert_marks(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	size_t count = listmodel_count(&app->model.listmodel);

	if(count > 0) {
		for(size_t i = 0; i < count; i++)
			listmodel_setmark(&app->model.listmodel, i, !listmodel_ismarked(&app->model.listmodel, i));
	}
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jbe 0x3c42
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x3c40
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
callq 0xa710
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorb $-0x1, %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xa6c0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3bee
jmp 0x3c42
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_mark
static void command_mark(struct commandexecutor *commandexecutor, char *regex)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	dirmodel_regex_setmark(&app->model, regex, true);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x7b90
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cglindkamp[P]dfm/src/application.c
// Function: command_unmark
static void command_unmark(struct commandexecutor *commandexecutor, char *regex)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	dirmodel_regex_setmark(&app->model, regex, false);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $-0x178, %rax           # imm = 0xFE88
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x7b90
movq -0x18(%rbp), %rdi
callq 0xa990
movq -0x18(%rbp), %rdi
callq 0x5560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)