LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x32a5
movq %rdi, %r14
movslq %esi, %rax
movq 0x240(%rdi,%rax,8), %r12
testq %r12, %r12
je 0x32c1
movl %ecx, %ebp
movq %rdx, %rbx
movq 0x8(%r12), %rsi
addq $0x44, %rsi
movl 0xa0(%r12), %edx
leaq 0x429a(%rip), %rdi      # 0x74e6
xorl %eax, %eax
callq 0x1030
testl %ebp, %ebp
jle 0x3292
movl %ebp, %r13d
leaq 0x4298(%rip), %r15      # 0x74f9
xorl %ebp, %ebp
movslq (%rbx,%rbp,4), %rax
movq 0x240(%r14,%rax,8), %rax
movq 0x8(%rax), %rsi
addq $0x44, %rsi
movq 0x8(%r12), %rdx
addq $0x44, %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incq %rbp
cmpq %rbp, %r13
jne 0x3263
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x32dd
callq 0x234b
xorl %eax, %eax
jmp 0x3303
leaq 0x3d99(%rip), %rdi      # 0x7045
leaq 0x417a(%rip), %rsi      # 0x742d
leaq 0x421c(%rip), %rdx      # 0x74d6
movl $0x8b, %ecx
jmp 0x32f7
leaq 0x3d7d(%rip), %rdi      # 0x7045
leaq 0x415e(%rip), %rsi      # 0x742d
leaq 0x4200(%rip), %rdx      # 0x74d6
movl $0x8e, %ecx
jmp 0x32f7
leaq 0x3d61(%rip), %rdi      # 0x7045
leaq 0x4142(%rip), %rsi      # 0x742d
leaq 0x41e4(%rip), %rdx      # 0x74d6
movl $0x94, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33cf
movq %rdi, %r14
movslq %esi, %rax
movq 0x240(%rdi,%rax,8), %r12
testq %r12, %r12
je 0x33eb
movl %ecx, %ebp
movq %rdx, %rbx
movq 0x8(%r12), %rsi
addq $0x44, %rsi
leaq 0x41a0(%rip), %rdi      # 0x7516
xorl %eax, %eax
callq 0x1030
testl %ebp, %ebp
jle 0x33bc
movl %ebp, %r13d
leaq 0x4195(%rip), %r15      # 0x7520
xorl %ebp, %ebp
movq 0x8(%r12), %rsi
addq $0x44, %rsi
movslq (%rbx,%rbp,4), %rax
movq 0x240(%r14,%rax,8), %rax
movq 0x8(%rax), %rdx
addq $0x44, %rdx
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incq %rbp
cmpq %rbp, %r13
jne 0x338d
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x3407
callq 0x234b
xorl %eax, %eax
jmp 0x342d
leaq 0x3c6f(%rip), %rdi      # 0x7045
leaq 0x4050(%rip), %rsi      # 0x742d
leaq 0x4121(%rip), %rdx      # 0x7505
movl $0xa3, %ecx
jmp 0x3421
leaq 0x3c53(%rip), %rdi      # 0x7045
leaq 0x4034(%rip), %rsi      # 0x742d
leaq 0x4105(%rip), %rdx      # 0x7505
movl $0xa6, %ecx
jmp 0x3421
leaq 0x3c37(%rip), %rdi      # 0x7045
leaq 0x4018(%rip), %rsi      # 0x742d
leaq 0x40e9(%rip), %rdx      # 0x7505
movl $0xac, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movslq %esi, %rax
movq 0x240(%rdi,%rax,8), %rsi
movq 0x48(%rsi), %r8
testq %r8, %r8
je 0x34c2
testl %ecx, %ecx
jle 0x34b2
movl %ecx, %ecx
xorl %esi, %esi
movslq (%rdx,%rsi,4), %r8
movq 0x240(%rdi,%r8,8), %r8
movq 0x240(%rdi,%rax,8), %r9
movq %r8, 0xa8(%r9,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x347d
movq 0x240(%rdi,%rax,8), %rsi
movq 0x48(%rsi), %r8
testq %r8, %r8
je 0x34c9
callq *%r8
movl $0xc1, %ecx
testl %eax, %eax
jne 0x34ce
xorl %eax, %eax
jmp 0x34ef
movl $0xbb, %ecx
jmp 0x34ce
movl $0xbf, %ecx
leaq 0x3b70(%rip), %rdi      # 0x7045
leaq 0x3f51(%rip), %rsi      # 0x742d
leaq 0x4049(%rip), %rdx      # 0x752c
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x3542
movq %rdi, %rbx
leaq 0x4094(%rip), %rdi      # 0x759b
callq 0x1130
movq 0x230(%rbx), %rdi
leaq 0xca(%rip), %rsi        # 0x35e4
callq 0x46ce
testl %eax, %eax
je 0x355e
leaq 0x3b1b(%rip), %rdi      # 0x7045
leaq 0x3efc(%rip), %rsi      # 0x742d
leaq 0x3f54(%rip), %rdx      # 0x748c
movl $0x153, %ecx            # imm = 0x153
jmp 0x35d0
leaq 0x3afc(%rip), %rdi      # 0x7045
leaq 0x3edd(%rip), %rsi      # 0x742d
leaq 0x3f35(%rip), %rdx      # 0x748c
movl $0x14f, %ecx            # imm = 0x14F
jmp 0x35d0
movq 0x230(%rbx), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %r14
movq %r14, %rdx
callq 0x4905
movl (%r14), %eax
addl $-0x9, %eax
movl $0x158, %ecx            # imm = 0x158
cmpl $-0x8, %eax
jb 0x35bb
xorl %r14d, %r14d
movslq 0x10(%rsp,%r14,4), %rax
movq 0x240(%rbx,%rax,8), %rax
testq %rax, %rax
je 0x35b6
movq 0x10(%rax), %rdi
callq 0x23f9
incq %r14
movslq 0xc(%rsp), %rax
cmpq %rax, %r14
jl 0x358a
xorl %eax, %eax
jmp 0x35dc
movl $0x15c, %ecx            # imm = 0x15C
leaq 0x3a83(%rip), %rdi      # 0x7045
leaq 0x3e64(%rip), %rsi      # 0x742d
leaq 0x3ebc(%rip), %rdx      # 0x748c
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
testq %rsi, %rsi
je 0x383a
movq %rsi, %r14
movq %rdi, %rbx
movq 0x230(%rdi), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %r15
movq %r15, %rdx
callq 0x4905
movslq (%r15), %r15
testq %r15, %r15
jle 0x3856
xorl %r12d, %r12d
movslq 0x10(%rsp,%r12,4), %rax
movq 0x240(%rbx,%rax,8), %r13
movq 0x8(%r13), %rsi
addq $0x44, %rsi
movq %r14, %rdi
callq 0x1100
testl %eax, %eax
je 0x3872
incq %r12
cmpq %r12, %r15
jne 0x3809
xorps %xmm0, %xmm0
jmp 0x38d3
leaq 0x3804(%rip), %rdi      # 0x7045
leaq 0x3be5(%rip), %rsi      # 0x742d
leaq 0x3c46(%rip), %rdx      # 0x7495
movl $0x166, %ecx            # imm = 0x166
jmp 0x38c4
leaq 0x37e8(%rip), %rdi      # 0x7045
leaq 0x3bc9(%rip), %rsi      # 0x742d
leaq 0x3c2a(%rip), %rdx      # 0x7495
movl $0x16c, %ecx            # imm = 0x16C
jmp 0x38c4
movq 0xf8(%r13), %rdi
testq %rdi, %rdi
je 0x388e
movq 0x220(%rbx), %rax
testq %rax, %rax
je 0x38aa
callq *%rax
jmp 0x38d3
leaq 0x37b0(%rip), %rdi      # 0x7045
leaq 0x3b91(%rip), %rsi      # 0x742d
leaq 0x3bf2(%rip), %rdx      # 0x7495
movl $0x172, %ecx            # imm = 0x172
jmp 0x38c4
leaq 0x3794(%rip), %rdi      # 0x7045
leaq 0x3b75(%rip), %rsi      # 0x742d
leaq 0x3bd6(%rip), %rdx      # 0x7495
movl $0x173, %ecx            # imm = 0x173
xorl %eax, %eax
callq 0x1030
movsd 0x3a5d(%rip), %xmm0     # 0x7330
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
testq %rdi, %rdi
je 0x3952
movslq %esi, %rax
movq 0x240(%rdi,%rax,8), %rsi
testq %rsi, %rsi
je 0x396e
movq 0x58(%rsi), %rax
testq %rax, %rax
je 0x398a
testl %ecx, %ecx
jle 0x3949
movl %ecx, %r8d
xorl %r9d, %r9d
movslq (%rdx,%r9,4), %r10
movq 0x240(%rdi,%r10,8), %r10
movq %r10, 0x60(%rsi,%r9,8)
incq %r9
cmpq %r9, %r8
jne 0x3930
movl %ecx, 0xa0(%rsi)
popq %rcx
jmpq *%rax
leaq 0x36ec(%rip), %rdi      # 0x7045
leaq 0x3acd(%rip), %rsi      # 0x742d
leaq 0x3bfb(%rip), %rdx      # 0x7562
movl $0x105, %ecx            # imm = 0x105
jmp 0x39a4
leaq 0x36d0(%rip), %rdi      # 0x7045
leaq 0x3ab1(%rip), %rsi      # 0x742d
leaq 0x3bdf(%rip), %rdx      # 0x7562
movl $0x108, %ecx            # imm = 0x108
jmp 0x39a4
leaq 0x36b4(%rip), %rdi      # 0x7045
leaq 0x3a95(%rip), %rsi      # 0x742d
leaq 0x3bc3(%rip), %rdx      # 0x7562
movl $0x10a, %ecx            # imm = 0x10A
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/xtanitfy[P]Murphy/src/net.c
// Function: NET_autoCreateBlob
int NET_autoCreateBlob(NET_PARA_s *pNetPara,BLOB_s *pPrevData,BLOB_s **pData,int num,int h,int w,int kh,int kw,
								BLOB_s **pK,BLOB_s **pB)
{
	CHECK_EXPR_RET(pPrevData == NULL || pData == NULL,-1);
	CHECK_EXPR_RET(pK == NULL || pB == NULL,-1);
	BLOB_s *pBlob = NULL;
	
	int ret = BLOB_create(pData,pNetPara->batchsize,num,
								h,w,TRUE);
	CHECK_EXPR_RET(ret != 0,-1);
	pBlob = (*pData);
	pBlob->type = BLOB_TYPE_DATA;

	ret = BLOB_create(pK,num,pPrevData->channelSize,
							kh,kw,TRUE);
	CHECK_EXPR_RET(ret != 0,-1);
	pBlob = (*pK);
	pBlob->type = BLOB_TYPE_WEIGHT;

	ret = BLOB_create(pB,1,num,1,1,TRUE);
	pBlob = (*pB);
	pBlob->type = BLOB_TYPE_BIAS;
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
testq %rsi, %rsi
setne %al
testq %rdx, %rdx
setne %dl
testb %dl, %al
jne 0x3a3a
leaq 0x3623(%rip), %rdi      # 0x7045
leaq 0x3a04(%rip), %rsi      # 0x742d
leaq 0x3a71(%rip), %rdx      # 0x74a1
movl $0x194, %ecx            # imm = 0x194
jmp 0x3b03
movq 0x48(%rsp), %rbx
movq 0x40(%rsp), %r15
testq %r15, %r15
setne %al
testq %rbx, %rbx
setne %dl
testb %dl, %al
jne 0x3a73
leaq 0x35ea(%rip), %rdi      # 0x7045
leaq 0x39cb(%rip), %rsi      # 0x742d
leaq 0x3a38(%rip), %rdx      # 0x74a1
movl $0x195, %ecx            # imm = 0x195
jmp 0x3b03
movq %rsi, %r12
movslq 0x210(%rdi), %rsi
movslq %ecx, %r14
movslq %r8d, %rcx
movslq %r9d, %r8
movq %r13, %rdi
movq %r14, %rdx
movl $0x1, %r9d
callq 0x1d64
testl %eax, %eax
je 0x3ab7
leaq 0x35a3(%rip), %rdi      # 0x7045
leaq 0x3984(%rip), %rsi      # 0x742d
leaq 0x39f1(%rip), %rdx      # 0x74a1
movl $0x19a, %ecx            # imm = 0x19A
jmp 0x3b03
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %ecx
movq (%r13), %rdx
movl $0x0, (%rdx)
movq 0x18(%r12), %rdx
movslq %ecx, %rcx
movslq %eax, %r8
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %r9d
callq 0x1d64
testl %eax, %eax
je 0x3b19
leaq 0x3555(%rip), %rdi      # 0x7045
leaq 0x3936(%rip), %rsi      # 0x742d
leaq 0x39a3(%rip), %rdx      # 0x74a1
movl $0x1a0, %ecx            # imm = 0x1A0
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r15), %rax
movl $0x1, (%rax)
movl $0x1, %esi
movl $0x1, %ecx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rdx
movl $0x1, %r9d
callq 0x1d64
movq (%rbx), %rax
movl $0x2, (%rax)
xorl %eax, %eax
jmp 0x3b0f
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rsi, %rsi
je 0x5c06
movq 0x8(%rsi), %rdx
addq $0x10, %rsi
movslq 0x210(%rdi), %rax
movslq 0x290(%rdx), %rcx
movslq 0x28c(%rdx), %r8
xorl %ebx, %ebx
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
xorl %r9d, %r9d
callq 0x1d64
movl $0x14, %ecx
testl %eax, %eax
jne 0x5c0b
jmp 0x5c2c
movl $0xe, %ecx
leaq 0x1433(%rip), %rdi      # 0x7045
leaq 0x1bb6(%rip), %rsi      # 0x77cf
leaq 0x1bbc(%rip), %rdx      # 0x77dc
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rsi, %rsi
je 0x5ca5
movq %rsi, %rbx
movq 0xa8(%rsi), %rax
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x5cac
movl 0x18(%rcx), %edx
leaq 0x10(%rbx), %rax
imull 0x20(%rcx), %edx
movslq 0x210(%rdi), %rsi
imull 0x28(%rcx), %edx
movslq %edx, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
movq %rax, %rdi
movl $0x1, %r9d
callq 0x1d64
movl $0x31, %ecx
testl %eax, %eax
jne 0x5cb1
movq 0x10(%rbx), %rdi
addq $0x28, %rbx
movq %rbx, %rsi
callq 0x2144
movl $0x34, %ecx
testl %eax, %eax
jne 0x5cb1
xorl %eax, %eax
jmp 0x5cd2
movl $0x2a, %ecx
jmp 0x5cb1
movl $0x2c, %ecx
leaq 0x138d(%rip), %rdi      # 0x7045
leaq 0x1b2b(%rip), %rsi      # 0x77ea
leaq 0x1b33(%rip), %rdx      # 0x77f9
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/xtanitfy[P]Murphy/src/layers/linear_layer.c
// Function: LinearLayerForward
int LinearLayerForward(NET_PARA_s *pNetPara,LAYER_s *pLayer)
{
	CHECK_EXPR_RET(pLayer == NULL,-1);
	
	BLOB_s *pPrevData = pLayer->pPrev[0]->pData;
	CHECK_EXPR_RET(pPrevData == NULL,-1);
	
	BLOB_DATA_PTR(pLayer->pData,ptrCurr);
	BLOB_DATA_PTR(pPrevData,ptrPrev);

	int cnt = 0;
	BLOB_s *pData = pLayer->pData;
	
	for (int i_batch = 0;i_batch < pData->numSize;i_batch++) {
		cnt = 0;
		for (int i_in = 0;i_in < pPrevData->channelSize;i_in++) {
			for (int i_w = 0; i_w < pPrevData->widthSize;i_w++) {
				for (int i_h = 0; i_h < pPrevData->heightSize;i_h++) {
					ptrCurr[i_batch][cnt++][0][0] = 
						ptrPrev[i_batch][i_in][i_h][i_w];
				}
			}
		}
	}
	
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rsi, %rsi
je 0x5e0c
movq 0xa8(%rsi), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x5e13
movq 0x10(%rsi), %rdx
movq 0x10(%rdx), %rcx
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
je 0x5e08
movq 0x8(%rdx), %rcx
movq 0x8(%rax), %rsi
movq %rsi, 0x8(%rsp)
movq 0x18(%rax), %rsi
movq 0x20(%rax), %rdi
movq 0x28(%rax), %r8
movq 0x28(%rdx), %r9
imulq 0x20(%rdx), %r9
movq 0x18(%rdx), %rax
imulq %r9, %rax
shlq $0x3, %rax
movq %rax, 0x18(%rsp)
shlq $0x3, %r9
movq %r8, %rax
imulq %rdi, %rax
movq %rax, %rdx
movq %rsi, %r11
imulq %rsi, %rdx
shlq $0x3, %rdx
movq %rdx, 0x10(%rsp)
shlq $0x3, %rax
movq %rax, 0x30(%rsp)
leaq (,%r8,8), %r14
movq %rdi, %r15
negq %r15
xorl %edx, %edx
movq %rdx, 0x28(%rsp)
testq %r11, %r11
je 0x5de6
xorl %r13d, %r13d
movq 0x8(%rsp), %rsi
xorl %eax, %eax
testq %r8, %r8
je 0x5dd9
movq %rsi, %rdx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x5dcd
movslq %eax, %r10
imulq %r9, %r10
addq %rcx, %r10
movq %rdx, %rbp
xorl %r12d, %r12d
movsd (%rbp), %xmm0
movsd %xmm0, (%r10)
addq %r9, %r10
decq %r12
addq %r14, %rbp
cmpq %r12, %r15
jne 0x5db2
subl %r12d, %eax
incq %rbx
addq $0x8, %rdx
cmpq %r8, %rbx
jne 0x5d9d
incq %r13
addq 0x30(%rsp), %rsi
cmpq %r11, %r13
jne 0x5d93
movq 0x28(%rsp), %rdx
incq %rdx
addq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
addq %rax, 0x8(%rsp)
cmpq 0x20(%rsp), %rdx
jne 0x5d7f
xorl %eax, %eax
jmp 0x5e39
movl $0x3b, %ecx
jmp 0x5e18
movl $0x3e, %ecx
leaq 0x1226(%rip), %rdi      # 0x7045
leaq 0x19c4(%rip), %rsi      # 0x77ea
leaq 0x19dc(%rip), %rdx      # 0x7809
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xtanitfy[P]Murphy/src/layers/output_layer.c
// Function: OutputLayerInit
int OutputLayerInit(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);

	OUTPUT_LAYER_PARA_s *pPara = &pLayer->para->select.outputLayer;

	NET_autoCreateBlob(pNetPara,pPrevBlob,&pLayer->pData,
						pPara->num,1,1,1,1,&pLayer->k,&pLayer->b);
	
	CHECK_EXPR_RET(pPara->weightInit == NULL,-1);
	pPara->weightInit(pLayer->k);
	
	CHECK_EXPR_RET(pPara->biasInit == NULL,-1);
	pPara->biasInit(pLayer->b);

	pLayer->k->type = BLOB_TYPE_WEIGHT;
	LOG_writeBlobToTxtFile("fw.txt",pLayer->k);	
	
	BLOB_shapeLike(pLayer->pData,&pLayer->pError);
	BLOB_shapeLike(pLayer->pData,&pLayer->pDelta);
	BLOB_shapeLike(pLayer->k,&pLayer->pDK);
	BLOB_shapeLike(pLayer->b,&pLayer->pDB);
	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x6211
movq %rsi, %rbx
movq 0xa8(%rsi), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x622d
movq 0x8(%rbx), %r14
leaq 0x10(%rbx), %rdx
movl 0x288(%r14), %ecx
leaq 0x18(%rbx), %r15
leaq 0x20(%rbx), %rax
movl $0x1, %r10d
movl $0x1, %r8d
movl $0x1, %r9d
pushq %rax
pushq %r15
pushq %r10
pushq %r10
callq 0x39ff
addq $0x20, %rsp
movq 0x298(%r14), %rax
testq %rax, %rax
je 0x6249
movq (%r15), %rdi
callq *%rax
movq 0x2a0(%r14), %rax
testq %rax, %rax
je 0x6265
movq 0x20(%rbx), %rdi
callq *%rax
movq 0x18(%rbx), %rsi
movl $0x1, (%rsi)
leaq 0x1681(%rip), %rdi      # 0x784f
callq 0x3c0d
movq 0x10(%rbx), %rdi
leaq 0xf8(%rbx), %rsi
callq 0x2144
movq 0x10(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x2144
movq 0x18(%rbx), %rdi
leaq 0x30(%rbx), %rsi
callq 0x2144
movq 0x20(%rbx), %rdi
addq $0x38, %rbx
movq %rbx, %rsi
callq 0x2144
xorl %eax, %eax
jmp 0x628b
leaq 0xe2d(%rip), %rdi       # 0x7045
leaq 0x1611(%rip), %rsi      # 0x7830
leaq 0x1619(%rip), %rdx      # 0x783f
movl $0x26, %ecx
jmp 0x627f
leaq 0xe11(%rip), %rdi       # 0x7045
leaq 0x15f5(%rip), %rsi      # 0x7830
leaq 0x15fd(%rip), %rdx      # 0x783f
movl $0x29, %ecx
jmp 0x627f
leaq 0xdf5(%rip), %rdi       # 0x7045
leaq 0x15d9(%rip), %rsi      # 0x7830
leaq 0x15e1(%rip), %rdx      # 0x783f
movl $0x30, %ecx
jmp 0x627f
leaq 0xdd9(%rip), %rdi       # 0x7045
leaq 0x15bd(%rip), %rsi      # 0x7830
leaq 0x15c5(%rip), %rdx      # 0x783f
movl $0x33, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %r14
movq 0xa8(%rsi), %rax
movq 0x10(%rax), %r8
movq 0x28(%r8), %rax
movslq 0x28c(%r14), %rsi
xorl %edx, %edx
divq %rsi
testq %rdx, %rdx
je 0x6822
leaq 0x83b(%rip), %rdi       # 0x7045
leaq 0x106c(%rip), %rsi      # 0x787d
leaq 0x1072(%rip), %rdx      # 0x788a
movl $0x2e, %ecx
jmp 0x68bd
movq %rax, %rcx
movq 0x20(%r8), %rax
xorl %edx, %edx
divq %rsi
testq %rdx, %rdx
je 0x684f
leaq 0x80b(%rip), %rdi       # 0x7045
leaq 0x103c(%rip), %rsi      # 0x787d
leaq 0x1042(%rip), %rdx      # 0x788a
movl $0x2f, %ecx
jmp 0x68bd
leaq 0x10(%rbx), %r9
movslq 0x210(%rdi), %rsi
movq 0x18(%r8), %rdx
movslq %ecx, %rcx
movslq %eax, %r8
movq %r9, %rdi
movl $0x1, %r9d
callq 0x1d64
testl %eax, %eax
je 0x6892
leaq 0x7c8(%rip), %rdi       # 0x7045
leaq 0xff9(%rip), %rsi       # 0x787d
leaq 0xfff(%rip), %rdx       # 0x788a
movl $0x36, %ecx
jmp 0x68bd
movq 0x10(%rbx), %rdi
leaq 0x28(%rbx), %rsi
callq 0x2144
testl %eax, %eax
je 0x68d1
leaq 0x79b(%rip), %rdi       # 0x7045
leaq 0xfcc(%rip), %rsi       # 0x787d
leaq 0xfd2(%rip), %rdx       # 0x788a
movl $0x39, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0x28c(%r14), %eax
movl %eax, 0xec(%rbx)
xorl %eax, %eax
jmp 0x68c9
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movabsq $-0xfffffbff, %rax      # imm = 0xFFFFFFFF00000401
leaq (%rdi,%rax), %rcx
incq %rax
cmpq %rax, %rcx
jb 0x133d
addq $0xf, %rbx
shrq $0x4, %rbx
movq 0x2dbe(%rip), %rcx      # 0x4058
testq %rcx, %rcx
je 0x12a8
movq (%rcx), %rax
movq 0x8(%rax), %rdx
jmp 0x12cd
leaq 0x2db1(%rip), %rax      # 0x4060
movq %rax, 0x2da2(%rip)      # 0x4058
movq %rax, 0x2da3(%rip)      # 0x4060
movq $0x0, 0x2da0(%rip) # 0x4068
xorl %edx, %edx
movq %rax, %rcx
cmpq %rbx, %rdx
jae 0x12ff
cmpq %rcx, %rax
jne 0x12eb
movq %rbx, %rdi
callq 0x145e
testq %rax, %rax
je 0x1338
movq 0x2d6d(%rip), %rcx      # 0x4058
movq (%rax), %r14
movq 0x8(%r14), %rdx
movq %rax, %rsi
movq %r14, %rax
cmpq %rbx, %rdx
jb 0x12d2
jmp 0x1305
movq %rax, %r14
movq %rcx, %rsi
subq %rbx, %rdx
jne 0x1312
movq (%r14), %rax
movq %rax, (%rsi)
jmp 0x1322
movq %rdx, 0x8(%r14)
shlq $0x4, %rdx
movq %rbx, 0x8(%r14,%rdx)
addq %rdx, %r14
movq %rsi, 0x2d2f(%rip)      # 0x4058
addq $0x10, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %r14d, %r14d
jmp 0x132d
movq 0x2cb4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd39(%rip), %rsi       # 0x2087
xorl %r14d, %r14d
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1060
jmp 0x132d
// File: /workspace/github_c_makefile_star2_O3/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:
movq -0x8(%rdi), %rdx
testq %rdx, %rdx
je 0x13fc
movl $0xfffffbff, %eax       # imm = 0xFFFFFBFF
cmpq %rax, %rdx
je 0x13fc
leaq -0x10(%rdi), %rax
movq 0x2cd5(%rip), %rsi      # 0x4058
movq %rsi, %rcx
cmpq %rsi, %rax
seta %r8b
movq (%rsi), %rsi
cmpq %rsi, %rax
setb %r9b
testb %r9b, %r8b
jne 0x13b4
cmpq %rcx, %rax
seta %r8b
cmpq %rsi, %rax
setb %r9b
cmpq %rsi, %rcx
jb 0x1383
orb %r9b, %r8b
je 0x1383
movq %rdx, %r8
shlq $0x4, %r8
addq %rax, %r8
cmpq %rsi, %r8
jne 0x13d1
addq 0x8(%rsi), %rdx
movq %rdx, -0x8(%rdi)
movq (%rcx), %rsi
movq (%rsi), %rsi
movq %rsi, (%rax)
movq 0x8(%rcx), %rsi
movq %rsi, %rdi
shlq $0x4, %rdi
addq %rcx, %rdi
cmpq %rax, %rdi
jne 0x13f1
addq %rsi, %rdx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
movq %rax, (%rcx)
movq %rcx, 0x2c5d(%rip)      # 0x4058
retq
movq 0x2bf5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc2b(%rip), %rsi       # 0x2038
xorl %eax, %eax
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_08/getch.c
// Function: main
int getch(void)
{
  char temp;

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

    return temp;
  }

  return getchar();
}

// Assembly:
pushq %rbx
movl 0x2edd(%rip), %eax      # 0x4040
cmpl $-0x1, %eax
je 0x1174
movl $0xffffffff, 0x2ece(%rip) # imm = 0xFFFFFFFF
jmp 0x1179
callq 0x1050
movsbl %al, %ebx
leaq 0xe81(%rip), %rdi       # 0x2004
movl %ebx, %esi
xorl %eax, %eax
callq 0x1040
cmpl $-0x1, 0x2ead(%rip)     # 0x4040
je 0x11a9
leaq 0xe6c(%rip), %rdi       # 0x2008
callq 0x1030
movl 0x2e99(%rip), %ebx      # 0x4040
jmp 0x11af
movl %ebx, 0x2e91(%rip)      # 0x4040
cmpl $-0x1, %ebx
je 0x11c0
movl $0xffffffff, 0x2e82(%rip) # imm = 0xFFFFFFFF
jmp 0x11c7
callq 0x1050
movl %eax, %ebx
movsbl %bl, %esi
leaq 0xe33(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1040
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7d4a
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_down
static void command_navigate_down(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_down(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7e1d
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_navigate_pageup
static void command_navigate_pageup(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	listview_pageup(&app->view);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7e30
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7e66
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq -0x178(%rdi), %rbx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %rbx, %rdi
callq 0x4f73
addq $-0x38, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x80ff
testb %al, %al
je 0x3913
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b03
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x150(%rdi), %r15
movq %r15, %rdi
callq 0x7a7c
testq %rax, %rax
je 0x3998
leaq -0x178(%rbx), %r14
movq %r14, %rdi
callq 0x4f73
movq %r14, %rdi
callq 0x7eb3
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x6831
testb %al, %al
je 0x39a4
movq %r15, %rdi
movq %r12, %rsi
callq 0x6811
addq $-0x38, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8062
testb %al, %al
je 0x3998
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4b03
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x57a0(%rip), %rsi      # 0x914b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3b8a
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7eaa
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
callq 0x7a7c
testq %rax, %rax
je 0x3a1f
addq $-0x178, %rbx           # imm = 0xFE88
decq %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7eaa
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq -0x150(%rdi), %r14
movq %r14, %rdi
callq 0x7a7c
testq %rax, %rax
je 0x3a87
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7eb3
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x7a93
xorb $0x1, %al
movzbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7a84
movq %rbx, %rdi
callq 0x7e1d
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4d1e
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x150(%rdi), %r14
movq %r14, %rdi
callq 0x7a7c
testq %rax, %rax
je 0x3ad5
movq %rax, %r15
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x7a93
xorb $0x1, %al
movzbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7a84
incq %r12
cmpq %r12, %r15
jne 0x3ab2
addq $-0x178, %rbx           # imm = 0xFE88
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq -0x178(%rdi), %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
movl $0x1, %edx
callq 0x625b
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq -0x178(%rdi), %rbx
addq $-0x150, %rdi           # imm = 0xFEB0
xorl %edx, %edx
callq 0x625b
movq %rbx, %rdi
callq 0x7bf0
movq %rbx, %rdi
popq %rbx
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_change_directory
static void command_change_directory(struct commandexecutor *commandexecutor, char *path)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	save_current_position(app);

	if(path_set_from_string(&app->cwd, path) == 0)
		enter_directory(app, NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x178(%rdi), %rbx
movq %rbx, %rdi
callq 0x4f73
addq $-0x38, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x81a9
testl %eax, %eax
je 0x3b7b
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x4b03
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_yank
static void command_yank(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	const struct list *list = NULL;

	int ret = dirmodel_getmarkedfilenames(&app->model, &list);
	char *cwd_copy = strdup(path_tocstr(&app->cwd));

	if(ret == ENOMEM)
		goto err;

	if(ret == 0) {
		if(cwd_copy == NULL)
			goto err;
	} else if(ret == ENOENT) {
		if(listmodel_count(&app->model.listmodel) == 0)
			goto err;

		struct list *selectedlist = list_new(1);
		if(selectedlist == NULL)
			goto err;
		list = selectedlist;

		size_t index = listview_getindex(&app->view);
		char *filename = strdup(dirmodel_getfilename(&app->model, index));
		if(filename == NULL)
			goto err;

		if(!list_append(selectedlist, filename)) {
			free(filename);
			goto err;
		}
	}
	clipboard_set_contents(&app->clipboard, cwd_copy, list);
	return;
err:
	free(cwd_copy);
	list_delete(list, free);
	clipboard_set_contents(&app->clipboard, NULL, NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x150(%rdi), %r15
movq %r15, %rdi
callq 0x6028
movl %eax, %ebp
leaq -0x38(%rbx), %rdi
callq 0x8050
movq %rax, %rdi
callq 0x36a0
movq %rax, %r14
cmpl $0xc, %ebp
je 0x3e51
cmpl $0x2, %ebp
je 0x3def
testl %ebp, %ebp
jne 0x3ddb
testq %r14, %r14
je 0x3e51
addq $-0x28, %rbx
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x3e75
movq %r15, %rdi
callq 0x7a7c
testq %rax, %rax
je 0x3e51
movl $0x1, %edi
callq 0x76b0
testq %rax, %rax
je 0x3e51
movq %rax, %r12
leaq -0x178(%rbx), %rdi
movq %rax, 0x8(%rsp)
callq 0x7eb3
movq %r15, %rdi
movq %rax, %rsi
callq 0x6811
movq %rax, %rdi
callq 0x36a0
testq %rax, %rax
je 0x3e51
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x7752
testb %al, %al
jne 0x3ddb
movq %r15, %rdi
callq 0x3740
movq %r14, %rdi
callq 0x3740
movq 0x9150(%rip), %rsi      # 0xcfb0
movq 0x8(%rsp), %rdi
callq 0x7706
addq $-0x28, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5250
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_mkdir
static void command_mkdir(struct commandexecutor *commandexecutor, char *dirname)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(mkdir(dirname, 0777) == 0) {
		dirmodel_notify_file_added_or_changed(&app->model, dirname);
		dirmodel_notify_flush(&app->model);
		select_filename(app, dirname);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x3130
testl %eax, %eax
je 0x3eae
popq %rbx
popq %r14
popq %r15
retq
leaq -0x178(%r14), %r15
addq $-0x150, %r14           # imm = 0xFEB0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x646d
movq %r14, %rdi
callq 0x64e3
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x50aa
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_rename
static void command_rename(struct commandexecutor *commandexecutor, char *newfilename)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	if(listmodel_count(&app->model.listmodel) == 0)
		return;

	size_t index = listview_getindex(&app->view);
	const char *filename = dirmodel_getfilename(&app->model, index);

	if(rename(filename, newfilename) == 0) {
		dirmodel_notify_file_deleted(&app->model, filename);
		dirmodel_notify_file_added_or_changed(&app->model, newfilename);
		dirmodel_notify_flush(&app->model);
		select_filename(app, newfilename);
		if(app->mode == MODE_NORMAL)
			refresh_statusbar(app);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x150(%rdi), %r12
movq %r12, %rdi
callq 0x7a7c
testq %rax, %rax
je 0x4003
leaq -0x178(%rbx), %r15
movq %r15, %rdi
callq 0x7eb3
movq %r12, %rdi
movq %rax, %rsi
callq 0x6811
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x3630
testl %eax, %eax
jne 0x4003
movq %r12, %rdi
movq %r13, %rsi
callq 0x63af
movq %r12, %rdi
movq %r14, %rsi
callq 0x646d
movq %r12, %rdi
callq 0x64e3
movq %r15, %rdi
movq %r14, %rsi
callq 0x50aa
cmpl $0x0, 0x44(%rbx)
je 0x400d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4d1e
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_search_next
static void command_search_next(struct commandexecutor *commandexecutor, char *unused)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	(void)unused;
	if(!app->lastsearch_regex)
		return;

	size_t index = listview_getindex(&app->view);

	index = dirmodel_regex_getnext(&app->model, app->lastsearch_regex, index, app->lastsearch_direction);

	listview_setindex(&app->view, index);
	listview_refresh(&app->view);
	refresh_statusbar(app);
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0x4084
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x178(%rdi), %r14
movq %r14, %rdi
callq 0x7eb3
leaq -0x150(%rbx), %rdi
movq 0x50(%rbx), %rsi
movl 0x58(%rbx), %ecx
movq %rax, %rdx
callq 0x6176
movq %r14, %rdi
movq %rax, %rsi
callq 0x7eaa
movq %r14, %rdi
callq 0x7bf0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d1e
retq
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: command_sort
static void command_sort(struct commandexecutor *commandexecutor, char *mode_string)
{
	struct application *app = container_of(commandexecutor, struct application, commandexecutor);
	enum dirmodel_sort_mode mode;
	if(strcmp(mode_string, "name+") == 0)
		mode = DIRMODEL_FILENAME;
	else if(strcmp(mode_string, "name-") == 0)
		mode = DIRMODEL_FILENAME_DESCENDING;
	else if(strcmp(mode_string, "size+") == 0)
		mode = DIRMODEL_SIZE;
	else if(strcmp(mode_string, "size-") == 0)
		mode = DIRMODEL_SIZE_DESCENDING;
	else if(strcmp(mode_string, "mtime+") == 0)
		mode = DIRMODEL_MTIME;
	else if(strcmp(mode_string, "mtime-") == 0)
		mode = DIRMODEL_MTIME_DESCENDING;
	else
		return;
	dirmodel_set_sort_mode(&app->model, mode);
	enter_directory(app, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50ac(%rip), %rsi      # 0x917b
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4142
leaq 0x509f(%rip), %rsi      # 0x9181
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4146
leaq 0x5092(%rip), %rsi      # 0x9187
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x414d
leaq 0x5085(%rip), %rsi      # 0x918d
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4154
leaq 0x5078(%rip), %rsi      # 0x9193
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x415b
leaq 0x506c(%rip), %rsi      # 0x919a
movq %r14, %rdi
callq 0x33d0
testl %eax, %eax
je 0x4162
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %esi, %esi
jmp 0x4167
movl $0x1, %esi
jmp 0x4167
movl $0x2, %esi
jmp 0x4167
movl $0x3, %esi
jmp 0x4167
movl $0x4, %esi
jmp 0x4167
movl $0x5, %esi
leaq -0x178(%rbx), %r14
addq $-0x150, %rbx           # imm = 0xFEB0
movq %rbx, %rdi
callq 0x639a
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b03
// File: /workspace/github_c_makefile_star2_O3/cglindkamp[P]dfm/src/application.c
// Function: handle_stdin
static void handle_stdin(struct application *app)
{
	wint_t key;
	int ret;

	ret = wget_wch(app->status, &key);
	if(ret == ERR)
		return;

	if(app->mode == MODE_COMMAND) {
		if(ret != KEY_CODE_YES && key == L'\n') {
			app->mode = MODE_NORMAL;
			curs_set(0);
			refresh_statusbar(app);

			const wchar_t *wcommand = commandline_getcommand(&app->commandline);
			char command[wcstombs(NULL, wcommand, 0) + 1];
			wcstombs(command, wcommand, sizeof(command));
			commandexecutor_execute(&app->commandexecutor, command);
			commandline_history_add(&app->commandline, wcommand);
		} else if(ret != KEY_CODE_YES && key == L'\t') {
		} else if(ret != KEY_CODE_YES && key == 27) {
			ret = wget_wch(app->status, &key);
			if(ret == ERR) {
				app->mode = MODE_NORMAL;
				curs_set(0);
				werase(app->status);
				wrefresh(app->status);
				return;
			}
			if(ret != KEY_CODE_YES && key == L'\n')
				insert_current_file_into_commandline(app);
		} else
			commandline_handlekey(&app->commandline, key, ret == KEY_CODE_YES ? true : false);

	} else
		keymap_handlekey(&app->keymap, key, ret == KEY_CODE_YES ? true : false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf0(%rdi), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3720
cmpl $-0x1, %eax
je 0x46e9
cmpl $0x1, 0x1bc(%rbx)
movl -0x2c(%rbp), %esi
jne 0x46d0
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0xa, %esi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x46f8
movl $0x0, 0x1bc(%rbx)
xorl %edi, %edi
callq 0x3140
movq %rbx, %rdi
callq 0x4d1e
leaq 0xf8(%rbx), %r14
movq %r14, %rdi
callq 0x5cff
movq %rax, %r15
xorl %edi, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3660
movq %rsp, %r13
leaq 0x1(%rax), %rdx
addq $0x10, %rax
andq $-0x10, %rax
movq %rsp, %r12
subq %rax, %r12
movq %r12, %rsp
movq %r12, %rdi
movq %r15, %rsi
callq 0x3660
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5579
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d45
movq %r13, %rsp
jmp 0x46e9
addq $0x168, %rbx            # imm = 0x168
xorl %edx, %edx
cmpl $0x100, %eax            # imm = 0x100
sete %dl
movq %rbx, %rdi
callq 0x6bc0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0x9, %esi
sete %dl
testb %dl, %cl
jne 0x46e9
cmpl $0x100, %eax            # imm = 0x100
setne %cl
cmpl $0x1b, %esi
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x474b
movq 0xf0(%rbx), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3720
cmpl $-0x1, %eax
je 0x4766
cmpl $0x100, %eax            # imm = 0x100
je 0x46e9
cmpl $0xa, -0x2c(%rbp)
jne 0x46e9
movq %rbx, %rdi
callq 0x5147
jmp 0x46e9
addq $0xf8, %rbx
xorl %edx, %edx
cmpl $0x100, %eax            # imm = 0x100
sete %dl
movq %rbx, %rdi
callq 0x5879
jmp 0x46e9
movl $0x0, 0x1bc(%rbx)
xorl %edi, %edi
callq 0x3140
movq 0xf0(%rbx), %rdi
callq 0x30e0
movq 0xf0(%rbx), %rdi
callq 0x3390
jmp 0x46e9