LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Rook.c
// Function: EvalWhiteRook
int EvalWhiteRook(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[wR]; ++pceNum) {
		sq = pos->pList[wR][pceNum];
		score += RookTable[SQ64(sq)];
		if(!(pos->pawns[BOTH] & FileBBMask[FilesBrd[sq]])) {
			score += RookOpenFile;
		} else if(!(pos->pawns[WHITE] & FileBBMask[FilesBrd[sq]])) {
			score += RookSemiOpenFile;
		}
	}	
	return score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x238(%rcx), %eax
jge 0x9a87
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc310(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5ed5(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x28aa(%rip), %rax      # 0xc2a0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x1f0(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x6087(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d28c(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x9a3b
movl -0x14(%rsp), %eax
addl $0xf, %eax
movl %eax, -0x14(%rsp)
jmp 0x9a75
movq -0x8(%rsp), %rax
movq 0x1e0(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x604d(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d252(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x9a73
movl -0x14(%rsp), %eax
addl $0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x9a75
jmp 0x9a77
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x99b5
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Rook.c
// Function: EvalBlackRook
int EvalBlackRook(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[bR]; ++pceNum) {
		sq = pos->pList[bR][pceNum];
		score += RookTable[MIRROR64(SQ64(sq))];
		if(!(pos->pawns[BOTH] & FileBBMask[FilesBrd[sq]])) {
			score += RookOpenFile;
		} else if(!(pos->pawns[BLACK] & FileBBMask[FilesBrd[sq]])) {
			score += RookSemiOpenFile;
		}
	}	
	return -score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x250(%rcx), %eax
jge 0x9b82
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc400(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5de5(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x177a(%rip), %rax      # 0xb260
movslq (%rax,%rcx,4), %rcx
leaq 0x27af(%rip), %rax      # 0xc2a0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x1f0(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x5f8c(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d191(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x9b36
movl -0x14(%rsp), %eax
addl $0xf, %eax
movl %eax, -0x14(%rsp)
jmp 0x9b70
movq -0x8(%rsp), %rax
movq 0x1e8(%rax), %rax
movslq -0x10(%rsp), %rdx
leaq 0x5f52(%rip), %rcx      # 0xfaa0
movslq (%rcx,%rdx,4), %rdx
leaq 0x1d157(%rip), %rcx     # 0x26cb0
andq (%rcx,%rdx,8), %rax
cmpq $0x0, %rax
jne 0x9b6e
movl -0x14(%rsp), %eax
addl $0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x9b70
jmp 0x9b72
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x9aa5
xorl %eax, %eax
subl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Pawn.c
// Function: EvalWhitePawns
int EvalWhitePawns(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[wP]; ++pceNum) {
		sq = pos->pList[wP][pceNum];
		score += PawnTable[SQ64(sq)];	
		
		if( (IsolatedMask[SQ64(sq)] & pos->pawns[WHITE]) == 0) {
			score += PawnIsolated;
		}
		
		if( (WhitePassedMask[SQ64(sq)] & pos->pawns[BLACK]) == 0) {
			score += PawnPassed[RanksBrd[sq]];
		}
		if( (DoubledPawnsMask[SQ64(sq)] & pos->pawns[WHITE]) !=0) {
			score += PawnDoubled;
		}
			
	}
	return score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x22c(%rcx), %eax
jge 0x9cc2
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc298(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5ce5(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x27ea(%rip), %rax      # 0xc3d0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5cc3(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1d0e8(%rip), %rax     # 0x26cf0
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e0(%rcx), %rax
cmpq $0x0, %rax
jne 0x9c29
movl -0x14(%rsp), %eax
addl $-0xf, %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5c8b(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1d8f0(%rip), %rax     # 0x27530
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e8(%rcx), %rax
cmpq $0x0, %rax
jne 0x9c78
movslq -0x10(%rsp), %rcx
leaq 0x1e1ce(%rip), %rax     # 0x27e30
movslq (%rax,%rcx,4), %rcx
leaq 0x2743(%rip), %rax      # 0xc3b0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5c3c(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1ce21(%rip), %rax     # 0x26ab0
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e0(%rcx), %rax
cmpq $0x0, %rax
je 0x9cb0
movl -0x14(%rsp), %eax
addl $-0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x9cb2
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x9ba5
movl -0x14(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/Pawn.c
// Function: EvalBlackPawns
int EvalBlackPawns(const S_BOARD *pos)
{
	int pceNum, sq, score=0;
	for(pceNum = 0; pceNum < pos->pceNum[bP]; ++pceNum) {
		sq = pos->pList[bP][pceNum];
	
		score += PawnTable[MIRROR64(SQ64(sq))];	
		
		if( (IsolatedMask[SQ64(sq)] & pos->pawns[BLACK]) == 0) {
			score += PawnIsolated;
		}
		
		if( (BlackPassedMask[SQ64(sq)] & pos->pawns[WHITE]) == 0) {
			score += PawnPassed[7 - RanksBrd[sq]];
		}

		if( (DoubledPawnsMask[SQ64(sq)] & pos->pawns[BLACK]) !=0) {
			score += PawnDoubled;
		}
	}
	return -score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x244(%rcx), %eax
jge 0x9e14
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movl 0xc388(%rax,%rcx,4), %eax
movl %eax, -0x10(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5ba5(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x153a(%rip), %rax      # 0xb260
movslq (%rax,%rcx,4), %rcx
leaq 0x269f(%rip), %rax      # 0xc3d0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5b78(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1cf9d(%rip), %rax     # 0x26cf0
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e8(%rcx), %rax
cmpq $0x0, %rax
jne 0x9d74
movl -0x14(%rsp), %eax
addl $-0xf, %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5b40(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1c925(%rip), %rax     # 0x266b0
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e0(%rcx), %rax
cmpq $0x0, %rax
jne 0x9dca
movslq -0x10(%rsp), %rdx
movl $0x7, %eax
leaq 0x1e07e(%rip), %rcx     # 0x27e30
subl (%rcx,%rdx,4), %eax
movslq %eax, %rcx
leaq 0x25f1(%rip), %rax      # 0xc3b0
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x5aea(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x1cccf(%rip), %rax     # 0x26ab0
movq (%rax,%rcx,8), %rax
movq -0x8(%rsp), %rcx
andq 0x1e8(%rcx), %rax
cmpq $0x0, %rax
je 0x9e02
movl -0x14(%rsp), %eax
addl $-0xa, %eax
movl %eax, -0x14(%rsp)
jmp 0x9e04
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x9ce5
xorl %eax, %eax
subl -0x14(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/King.c
// Function: EvalWhiteKing
int EvalWhiteKing(const S_BOARD *pos)
{
	int score=0;
	int sq=pos->KingSq[WHITE];
	int material=pos->material[BLACK];
	if( (material >= ENDGAME_MAT) ) {
		score += KingO[MIRROR64(SQ64(sq))];
	} else{
		if(material > 0)
		{

			//int whiteMaterial=pos->material[WHITE];
			//bishop and knight mate deserves special attention*
			/*
			if(material==655 && whiteMaterial==0)
			{
				int square=pos->pList[bB][0];
				int color=ColorSquare[SQ64(square)];
				if(color)
				{
					score += 5*KingEd[SQ64(sq)];
				}
				else
				{
			score += 5*KingEl[SQ64(sq)];
			//	}
		}else
		{*/
			score += KingE[SQ64(sq)];
		//}
		}
		//piece checkmates require a slightly different king evaluation
		else
		{
			int blackKingSq=pos->KingSq[BLACK];
			score -= 2*KingManhattanDistances[SQ64(sq)][SQ64(blackKingSq)];

		}	
	}

	return score;	

}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x1f8(%rax), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x268(%rax), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
leaq 0x154a(%rip), %rcx      # 0xb3a0
movl 0x10(%rcx), %ecx
shll $0x0, %ecx
leaq 0x153d(%rip), %rdx      # 0xb3a0
movl 0x8(%rdx), %edx
shll %edx
addl %edx, %ecx
leaq 0x152f(%rip), %rdx      # 0xb3a0
movl 0x4(%rdx), %edx
shll %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x9eab
movslq -0x10(%rsp), %rcx
leaq 0x5a38(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x13cd(%rip), %rax      # 0xb260
movslq (%rax,%rcx,4), %rcx
leaq 0x2732(%rip), %rax      # 0xc5d0
movl (%rax,%rcx,4), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0x9f24
cmpl $0x0, -0x14(%rsp)
jle 0x9ed6
movslq -0x10(%rsp), %rcx
leaq 0x5a02(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x2607(%rip), %rax      # 0xc4d0
movl (%rax,%rcx,4), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0x9f22
movq -0x8(%rsp), %rax
movl 0x1fc(%rax), %eax
movl %eax, -0x18(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x59cf(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x180b4(%rip), %rax     # 0x21fb0
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rdx
leaq 0x59b1(%rip), %rcx      # 0xf8c0
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ecx
shll %ecx
movl -0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rsp)
jmp 0x9f24
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ArchLuke[P]YouSuck/King.c
// Function: EvalBlackKing
int EvalBlackKing(const S_BOARD * pos)
{
	int score=0;
	int sq=pos->KingSq[BLACK];
	int material=pos->material[WHITE];
	if( (material >= ENDGAME_MAT) ) {
		score += KingO[MIRROR64(SQ64(sq))];
	} else{
		if(material > 0)
		{
		
		//	int blackMaterial=pos->material[BLACK];
			//bishop and knight mate deserves special attention
			/*
			if(material==655 && blackMaterial==0)
			{
				int square=pos->pList[wB][0];
				int color=ColorSquare[SQ64(square)];
				if(color)
					score += 5*KingEl[SQ64(sq)];
				else
					score += 5*KingEd[SQ64(sq)];
			}
			else
			{*/
			score += KingE[SQ64(sq)];
			//}
		}
		//piece checkmates require a slightly different king evaluation
		else
		{
			int whiteKingSq=pos->KingSq[WHITE];
			score -= 2*KingManhattanDistances[SQ64(sq)][SQ64(whiteKingSq)];

		}	
	}
	return -score;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x1fc(%rax), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x264(%rax), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
leaq 0x143a(%rip), %rcx      # 0xb3a0
movl 0x10(%rcx), %ecx
shll $0x0, %ecx
leaq 0x142d(%rip), %rdx      # 0xb3a0
movl 0x8(%rdx), %edx
shll %edx
addl %edx, %ecx
leaq 0x141f(%rip), %rdx      # 0xb3a0
movl 0x4(%rdx), %edx
shll %edx
addl %edx, %ecx
cmpl %ecx, %eax
jl 0x9fbb
movslq -0x10(%rsp), %rcx
leaq 0x5928(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x12bd(%rip), %rax      # 0xb260
movslq (%rax,%rcx,4), %rcx
leaq 0x2622(%rip), %rax      # 0xc5d0
movl (%rax,%rcx,4), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0xa034
cmpl $0x0, -0x14(%rsp)
jle 0x9fe6
movslq -0x10(%rsp), %rcx
leaq 0x58f2(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x24f7(%rip), %rax      # 0xc4d0
movl (%rax,%rcx,4), %eax
addl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
jmp 0xa032
movq -0x8(%rsp), %rax
movl 0x1f8(%rax), %eax
movl %eax, -0x18(%rsp)
movslq -0x10(%rsp), %rcx
leaq 0x58bf(%rip), %rax      # 0xf8c0
movslq (%rax,%rcx,4), %rcx
leaq 0x17fa4(%rip), %rax     # 0x21fb0
shlq $0x8, %rcx
addq %rcx, %rax
movslq -0x18(%rsp), %rdx
leaq 0x58a1(%rip), %rcx      # 0xf8c0
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %ecx
shll %ecx
movl -0xc(%rsp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rsp)
jmp 0xa034
xorl %eax, %eax
subl -0xc(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: physmem_total
long physmem_total(void)
{
    #if defined _SC_PHYS_PAGES && defined _SC_PAGESIZE
    {
        /* This works on linux-gnu, solaris2 and cygwin */
        long pages = sysconf(_SC_PHYS_PAGES);
        long pagesize = sysconf(_SC_PAGESIZE);
        if (0 <= pages && 0 <= pagesize)
        return pages * pagesize;
    }
    #elif defined CTL_HW && defined HW_PHYSMEM
    { 
        /* This works on *bsd and darwin */
        unsigned int physmem;
        size_t len = sizeof physmem;
        static int mib[2] = { CTL_HW, HW_PHYSMEM };
        if (sysctl (mib, ARRAY_SIZE(mib), &physmem, &len, NULL, 0) == 0
            && len == sizeof (physmem))
        return physmem;
    }
    #endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x55, %edi
callq 0x2300
movq %rax, -0x10(%rbp)
movl $0x1e, %edi
callq 0x2300
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jg 0x2673
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jg 0x2673
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x267b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: physmem_avail
long physmem_avail(void)
{
    #if defined _SC_AVPHYS_PAGES && defined _SC_PAGESIZE
    {
        /* This works on linux-gnu, solaris2 and cygwin */
        long pages = sysconf(_SC_AVPHYS_PAGES);
        long pagesize = sysconf(_SC_PAGESIZE);
        if (0 <= pages && 0 <= pagesize)
        return pages * pagesize;
    }
    #elif defined CTL_HW && defined HW_USERMEM
    {
        /* This works on *bsd and darwin */
        unsigned int usermem;
        size_t len = sizeof usermem;
        static int mib[2] = { CTL_HW, HW_USERMEM };
        if (sysctl (mib, ARRAY_SIZE(mib), &usermem, &len, NULL, 0) == 0
            && len == sizeof (usermem))
        return usermem;
    }
    #endif

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x56, %edi
callq 0x2300
movq %rax, -0x10(%rbp)
movl $0x1e, %edi
callq 0x2300
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jg 0x26d3
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jg 0x26d3
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26db
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: ram_limit
void ram_limit(long *total, long *avail)
{
    long t, a, a1;
    struct rlimit lim;
    getrlimit(RLIMIT_RSS, &lim);
    a = lim.rlim_cur;
    getrlimit(RLIMIT_AS, &lim);
    a = MAX(a, (long) lim.rlim_cur);
    // a1 = (long) (sysconf(_SC_AVPHYS_PAGES) * sysconf(_SC_PAGESIZE));
    a1 = physmem_avail();
    a = a > 0? MIN(a, a1) : a1;
    // t = sysconf(_SC_PHYS_PAGES) * sysconf(_SC_PAGESIZE);
    t = physmem_total();
    *avail = a;
    *total = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x5, %edi
leaq -0x38(%rbp), %rsi
callq 0x23a0
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x9, %edi
leaq -0x38(%rbp), %rsi
callq 0x23a0
movq -0x20(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x2738
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x2740
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2690
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x277e
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x276c
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x2774
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x2786
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2630
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: file_copy
int file_copy(char *fin, char *fout)
{
    FILE *fptr1, *fptr2;
    int c;
    fptr1 = fopen(fin, "r");
    fptr2 = fopen(fout, "w");
    c = fgetc(fptr1);
    while (c != EOF) {
        fputc(c, fptr2);
        c = fgetc(fptr1);
    }
    fclose(fptr1);
    fclose(fptr2);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xb2b9(%rip), %rsi      # 0xda94
callq 0x22d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa821(%rip), %rsi      # 0xd010
callq 0x22d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2180
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
je 0x2824
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x21b0
movq -0x18(%rbp), %rdi
callq 0x2180
movl %eax, -0x24(%rbp)
jmp 0x2804
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
callq 0x2100
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: is_read_pair
int8_t is_read_pair(const char *rname0, const char *rname1)
{
    int n = strlen(rname0);
    if (n == 0 || n != strlen(rname1))
          return 0;
    if (!strcmp(rname0, rname1) || 
            (n > 2 &&
             !strncmp(rname0, rname1, n - 1) &&
             rname0[n - 2] == '/' &&
             rname1[n - 2] == '/' &&
             rname0[n - 1] != rname1[n - 1]))
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x287f
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2110
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x2888
movb $0x0, -0x1(%rbp)
jmp 0x2917
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21e0
cmpl $0x0, %eax
je 0x290d
cmpl $0x2, -0x1c(%rbp)
jle 0x2913
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x2090
cmpl $0x0, %eax
jne 0x2913
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x2913
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x2913
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2913
movb $0x1, -0x1(%rbp)
jmp 0x2917
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: linear_scale
uint64_t linear_scale(uint64_t g, int *scale, uint64_t max_g)
{
    int s;
    s = 0;
    while (g > max_g) {
        ++s;
        g >>= 1;
    }
    
    *scale = s;
    return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x29d7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movq %rax, -0x8(%rbp)
jmp 0x29b7
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: write_bin_header
void write_bin_header(FILE *fo)
{
    int64_t magic_number = BIN_H;
    int64_t bin_version = BIN_V;
    magic_number |= bin_version;
    fwrite(&magic_number, sizeof(int64_t), 1, fo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movabsq $0x5941485342494e56, %rax # imm = 0x5941485342494E56
movq %rax, -0x10(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2390
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: is_valid_bin_header
int is_valid_bin_header(int64_t n)
{
    int64_t magic_number = BIN_H;
    int64_t bin_version = BIN_V;
    magic_number |= bin_version;
    return n == magic_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movabsq $0x5941485342494e56, %rax # imm = 0x5941485342494E56
movq %rax, -0x10(%rbp)
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rax
orq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: strcmp_case_insensitive
int strcmp_case_insensitive(const char *s1, const char *s2)
{
    const unsigned char *p1 = (const unsigned char *) s1;
    const unsigned char *p2 = (const unsigned char *) s2;
    int result;
    if (p1 == p2)
        return 0;
    while ((result = tolower (*p1) - tolower(*p2++)) == 0)
        if (*p1++ == '\0')
            break;
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x2ae3
movl $0x0, -0x4(%rbp)
jmp 0x2b3b
jmp 0x2ae5
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x2250
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %edi
callq 0x2250
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x2b35
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2b33
jmp 0x2b35
jmp 0x2ae5
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: is_empty_line
int is_empty_line(char *line)
{
    while (isspace(*line))
        line++;
    if(*line == '\0')
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x23f0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x2bda
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2bac
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x2bef
movl $0x1, -0x4(%rbp)
jmp 0x2bf6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: iostream_open
iostream_t *iostream_open(const char *spath)
{
    iostream_t *iostream;
    iostream = (iostream_t *) calloc(1, sizeof(iostream_t));
    if (iostream == NULL)
        return NULL;
    iostream->koaux = kopen(spath, &iostream->fd);
    if (iostream->koaux == 0) {
        free(iostream);
        return NULL;
    }
    iostream->fp = gzdopen(iostream->fd, "r");
    if (iostream->fp == Z_NULL) {
        kclose(iostream->koaux);
        free(iostream);
        return NULL;
    }
    iostream->stream = ks_init(iostream->fp);
    iostream->buffer = kstring_init(BUFF_SIZE);

    return iostream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x21d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2c33
movq $0x0, -0x8(%rbp)
jmp 0x2ce6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3c30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2c69
movq -0x18(%rbp), %rdi
callq 0x2050
movq $0x0, -0x8(%rbp)
jmp 0x2ce6
movq -0x18(%rbp), %rax
movl (%rax), %edi
leaq 0xae1e(%rip), %rsi      # 0xda94
callq 0x20f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2cb1
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4a80
movq -0x18(%rbp), %rdi
callq 0x2050
movq $0x0, -0x8(%rbp)
jmp 0x2ce6
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2cf0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x1000, %edi           # imm = 0x1000
callq 0x2d50
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: kstring_init
static kstring_t *kstring_init(int size)
{
    kstring_t *str;
    str = (kstring_t *) calloc(1, sizeof(kstring_t));
    str->m = size;
    str->s = (char *) malloc(sizeof(char) * size);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x21d0
movq %rax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x0, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: iostream_close
void iostream_close(iostream_t *iostream)
{
    if (!iostream) return;
    ks_destroy(iostream->stream);
    kstring_destroy(iostream->buffer);
    gzclose(iostream->fp);
    kclose(iostream->koaux);
    free(iostream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2db5
jmp 0x2df2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2e00
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2e40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x4a80
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/asset.c
// Function: iostream_getline
char *iostream_getline(iostream_t *iostream)
{
    int len;
    kstring_t *buffer;
    buffer = (kstring_t *) (iostream->buffer);
    len = ks_getuntil(iostream->stream, KS_SEP_LINE, buffer, 0);
    if (len >= 0) {
        iostream->nline += 1;
        return buffer->s;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rdx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x2ef0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2ed9
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2ee1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/kalloc.c
// Function: km_init2
void *km_init2(void *km_par, size_t min_core_size)
{
	kmem_t *km;
	km = (kmem_t*)kcalloc(km_par, 1, sizeof(kmem_t));
	km->par = km_par;
	km->min_core_size = min_core_size > 0? min_core_size : 0x80000;
	return (void*)km;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
movl $0x30, %edx
callq 0x3440
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
jbe 0x3413
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x341e
movl $0x80000, %eax          # imm = 0x80000
movq %rax, -0x20(%rbp)
jmp 0x341e
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: sd_init
sdict_t *sd_init(void)
{
    sdict_t *d;
    d = (sdict_t *) calloc(1, sizeof(sdict_t));
    d->n = 0;
    d->m = 16;
    d->s = (sd_seq_t *) malloc(d->m * sizeof(sd_seq_t));
    d->h = kh_init(sdict);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x21d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x10, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
imulq $0x18, %rax, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x5140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: asm_init
asm_dict_t *asm_init(sdict_t *sdict)
{
    asm_dict_t *d;
    d = (asm_dict_t *) calloc(1, sizeof(asm_dict_t));
    d->n = 0;
    d->m = 16;
    d->s = (sd_aseq_t *) malloc(d->m * sizeof(sd_aseq_t));
    d->h = kh_init(sdict);
    d->u = 0;
    d->v = 16;
    d->seg = (sd_seg_t *) malloc(d->v * sizeof(sd_seg_t));
    d->a = (uint64_t *) malloc(sdict->n * sizeof(uint64_t));
    d->index = 0;
    d->sdict = sdict;
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x40, %esi
callq 0x21d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x10, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imulq $0x58, %rax, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x5140
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x10, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
imulq $0x30, %rax, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2260
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: sd_destroy
void sd_destroy(sdict_t *d)
{
    if (!d) return;
    uint32_t i;
    if (d == 0)
        return;
    if (d->h)
        kh_destroy(sdict, d->h);
    if(d->s) {
        for (i = 0; i < d->n; ++i) {
            free(d->s[i].name);
            if (d->s[i].seq)
                free(d->s[i].seq);
        }
        free(d->s);
    }
    free(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5248
jmp 0x52fa
cmpq $0x0, -0x8(%rbp)
jne 0x5254
jmp 0x52fa
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x526c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5300
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x52f1
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x52e4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x52d7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2050
jmp 0x52d9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x527e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: asm_destroy
void asm_destroy(asm_dict_t *d)
{
    if (!d) return;
    uint32_t i;
    if (d == 0)
        return;
    if (d->s) {
        for (i = 0; i < d->n; ++i) {
            free(d->s[i].name);
            free(d->s[i].gs);
            free(d->s[i].gsize);
            free(d->s[i].gcomp);
            free(d->s[i].gtype);
            free(d->s[i].glink);
            free(d->s[i].gevid);
        }
        free(d->s);
    }
    if (d->seg)
        free(d->seg);
    if (d->a)
        free(d->a);
    if (d->index)
        free(d->index);
    if (d->h)
        kh_destroy(sdict, d->h);
    free(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5378
jmp 0x54e9
cmpq $0x0, -0x8(%rbp)
jne 0x5384
jmp 0x54e9
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5480
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x5473
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x40(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x50(%rax), %rdi
callq 0x2050
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x539a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x5498
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x54b0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54c8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x54e0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5300
movq -0x8(%rbp), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: sd_put
uint32_t sd_put(sdict_t *d, const char *name, uint32_t len)
{
    if (!name)
        return UINT32_MAX;
    sdhash_t *h = d->h;
    khint_t k;
    int absent;
    k = kh_put(sdict, h, name, &absent);
    if (absent) {
        sd_seq_t *s;
        if (d->n == d->m) {
            d->m = d->m? d->m<<1 : 16;
            d->s = (sd_seq_t *) realloc(d->s, d->m * sizeof(sd_seq_t));
        }
        s = &d->s[d->n];
        s->len = len;
        s->seq = 0;
        kh_key(h, k) = s->name = strdup(name);
        kh_val(h, k) = d->n++;
    }
    return kh_val(h, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5516
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x561b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5630
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0x560a
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x559e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x5567
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
shll %eax
movl %eax, -0x3c(%rbp)
jmp 0x5571
movl $0x10, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5571
movl -0x3c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
imulq $0x18, %rax, %rsi
callq 0x22a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x23c0
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq %rdx, (%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl (%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x2c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
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/c-zhou[P]yahs/sdict.c
// Function: sd_get
uint32_t sd_get(sdict_t *d, const char *name)
{
    sdhash_t *h = d->h;
    khint_t k;
    k = kh_get(sdict, h, name);
    return k == kh_end(h)? UINT32_MAX : kh_val(h, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5a50
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x5a31
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x20(%rbp)
jmp 0x5a42
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: sd_hash
void sd_hash(sdict_t *d)
{
    uint32_t i;
    sdhash_t *h;
    if (d->h)
        return;
    d->h = h = kh_init(sdict);
    for (i = 0; i < d->n; ++i) {
        int absent;
        khint_t k;
        k = kh_put(sdict, h, d->s[i].name, &absent);
        kh_val(h, k) = i;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5bb9
jmp 0x5c20
callq 0x5140
movq %rax, %rcx
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x5c20
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq -0x1c(%rbp), %rdx
callq 0x5630
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x20(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5bd4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: make_sdict_from_fa
sdict_t *make_sdict_from_fa(const char *f, uint32_t min_len)
{
    int fd;
    int64_t l;
    gzFile fp;
    kseq_t *ks;
    void *ko = 0;

    ko = kopen(f, &fd);
    if (ko == 0) {
        fprintf(stderr, "[E::%s] cannot open file %s for reading\n", __func__, f);
        exit(EXIT_FAILURE);
    }
    fp = gzdopen(fd, "r");
    ks = kseq_init(fp);
    
    sdict_t *d;
    d = sd_init();
    while ((l = kseq_read(ks)) >= 0) {
        if (l > UINT32_MAX) {
            fprintf(stderr, "[E::%s] >4G sequence chunks are not supported: %s [%ld]\n", __func__, ks->name.s, l);
            exit(EXIT_FAILURE);
        }
        if (strlen(ks->seq.s) >= min_len)
            sd_put1(d, ks->name.s, ks->seq.s, strlen(ks->seq.s));
    }

    kseq_destroy(ks);
    gzclose(fp);
    kclose(ko);

    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3c30
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5c8c
movq 0xb392(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x76dc(%rip), %rsi      # 0xd350
leaq 0x76fe(%rip), %rdx      # 0xd379
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
movl -0x10(%rbp), %edi
leaq 0x7dfe(%rip), %rsi      # 0xda94
callq 0x20f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5d90
movq %rax, -0x28(%rbp)
callq 0x50d0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5dd0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jl 0x5d66
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jle 0x5d0c
movq 0xb31a(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0x7698(%rip), %rsi      # 0xd38c
leaq 0x767e(%rip), %rdx      # 0xd379
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2110
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jb 0x5d61
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2110
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
callq 0x5990
jmp 0x5cb5
movq -0x28(%rbp), %rdi
callq 0x61d0
movq -0x20(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x4a80
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: make_sdict_from_index
sdict_t *make_sdict_from_index(const char *f, uint32_t min_len)
{
    iostream_t *fp;
    char *line;
    char name[4096];
    int64_t len;

    fp = iostream_open(f);
    if (fp == NULL) {
        fprintf(stderr, "[E::%s] cannot open file %s for reading\n", __func__, f);
        exit(EXIT_FAILURE);
    }
    
    sdict_t *d;
    d = sd_init();
    while ((line = iostream_getline(fp)) != NULL) {
        if (is_empty_line(line))
            continue;
        sscanf(line, "%s %ld", name, &len);
        if (len > UINT32_MAX) {
            fprintf(stderr, "[E::%s] >4G sequence chunks are not supported: %s [%ld]\n", __func__, name, len);
            exit(EXIT_FAILURE);
        }
        if (len >= min_len)
            sd_put(d, name, len);
    }

    iostream_close(fp);
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6293
movq 0xad8b(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x70d5(%rip), %rsi      # 0xd350
leaq 0x7143(%rip), %rdx      # 0xd3c5
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
callq 0x50d0
movq %rax, -0x1030(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e80
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x635b
movq -0x20(%rbp), %rdi
callq 0x2ba0
cmpl $0x0, %eax
je 0x62c6
jmp 0x629f
movq -0x20(%rbp), %rdi
leaq -0x1020(%rbp), %rdx
leaq 0x7103(%rip), %rsi      # 0xd3db
leaq -0x1028(%rbp), %rcx
movb $0x0, %al
callq 0x2270
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x1028(%rbp)
jle 0x632b
movq 0xacfd(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq -0x1020(%rbp), %rcx
movq -0x1028(%rbp), %r8
leaq 0x7079(%rip), %rsi      # 0xd38c
leaq 0x70ab(%rip), %rdx      # 0xd3c5
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
movq -0x1028(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jl 0x6356
movq -0x1030(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x1028(%rbp), %rax
movl %eax, %edx
callq 0x54f0
jmp 0x629f
movq -0x18(%rbp), %rdi
callq 0x2da0
movq -0x1030(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: make_sdict_from_gfa
sdict_t *make_sdict_from_gfa(const char *f, uint32_t min_len)
{
    iostream_t *fp;
    char *line;
    char name[4096], lens[4096];
    uint64_t len;

    fp = iostream_open(f);
    if (fp == NULL) {
        fprintf(stderr, "[E::%s] cannot open file %s for reading\n", __func__, f);
        exit(EXIT_FAILURE);
    }

    sdict_t *d;
    d = sd_init();
    while ((line = iostream_getline(fp)) != NULL) {
        if (is_empty_line(line))
            continue;
        if (line[0] == 'S') {
            sscanf(line, "%*s %s %*s %s", name, lens);
            len = strtoul(lens + 5, NULL, 10);
            if (len > UINT32_MAX) {
                fprintf(stderr, "[E::%s] >4G sequence chunks are not supported: %s [%ld]\n", __func__, name, len);
                exit(EXIT_FAILURE);
            }
            if (len >= min_len)
                sd_put(d, name, len);
        }
    }
    iostream_close(fp);

    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2030, %rsp           # imm = 0x2030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c00
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x63d3
movq 0xac4b(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x6f95(%rip), %rsi      # 0xd350
leaq 0x7020(%rip), %rdx      # 0xd3e2
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
callq 0x50d0
movq %rax, -0x2030(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2e80
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x64cd
movq -0x20(%rbp), %rdi
callq 0x2ba0
cmpl $0x0, %eax
je 0x6406
jmp 0x63df
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x53, %eax
jne 0x64c8
movq -0x20(%rbp), %rdi
leaq -0x1020(%rbp), %rdx
leaq -0x2020(%rbp), %rcx
leaq 0x6fc7(%rip), %rsi      # 0xd3f6
movb $0x0, %al
callq 0x2270
leaq -0x2020(%rbp), %rdi
addq $0x5, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x2330
movq %rax, -0x2028(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x2028(%rbp)
jbe 0x649b
movq 0xab8d(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
leaq -0x1020(%rbp), %rcx
movq -0x2028(%rbp), %r8
leaq 0x6f09(%rip), %rsi      # 0xd38c
leaq 0x6f58(%rip), %rdx      # 0xd3e2
movb $0x0, %al
callq 0x2200
movl $0x1, %edi
callq 0x2370
movq -0x2028(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jb 0x64c6
movq -0x2030(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
movq -0x2028(%rbp), %rax
movl %eax, %edx
callq 0x54f0
jmp 0x64c8
jmp 0x63df
movq -0x18(%rbp), %rdi
callq 0x2da0
movq -0x2030(%rbp), %rax
addq $0x2030, %rsp           # imm = 0x2030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]yahs/sdict.c
// Function: memcpy1
static inline void *memcpy1(const void *src, size_t count)
{
    if (count == 0) return 0;
    void *dest = malloc(count);
    memcpy(dest, src, count);
    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6741
movq $0x0, -0x8(%rbp)
jmp 0x6767
movq -0x18(%rbp), %rdi
callq 0x2260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2220
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)