LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: handleCookie
DEF_TOKEN_CALLBACK(handleCookie)
{
    char *tmp = NULL;

    READ_TOKEN_TO_TMP(parser->block->memory, tmp, parser->tokens[parser->currentToken]);
    redditCookieNew("reddit_session", tmp);
    free(tmp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x20(%rsp), %rdx
movslq 0x14(%rdx), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
subl 0x4(%rcx), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x43e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movslq 0x4(%rax), %rax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x14(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x20(%rsp), %rdx
movslq 0x14(%rdx), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
subl 0x4(%rcx), %eax
movslq %eax, %rdx
callq 0x2180
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x20(%rsp), %rdx
movslq 0x14(%rdx), %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
movl 0x8(%rcx), %ecx
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rdx
movq 0x20(%rsp), %rsi
movslq 0x14(%rsi), %rsi
imulq $0x1c, %rsi, %rsi
addq %rsi, %rdx
subl 0x4(%rdx), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rsi
leaq 0x985(%rip), %rdi       # 0x856e
callq 0x21d0
movq 0x8(%rsp), %rdi
callq 0x2040
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: redditUserLoggedUpdate
EXPORT_SYMBOL RedditErrno redditUserLoggedUpdate (RedditUserLogged *user)
{
    TokenParserResult res;
    char *kindStr = NULL;

    TokenIdent ids[] = {
        ADD_TOKEN_IDENT_STRING("kind", kindStr),
        ADD_TOKEN_IDENT_FUNC("data", userUpdateHelper),
        {0}
    };

    res = redditRunParser(REDDIT_API_ME, NULL, ids, &(user->userInfo));
    free(kindStr);

    if (res == TOKEN_PARSER_SUCCESS)
        return REDDIT_SUCCESS;
    else
        return REDDIT_ERROR_RESPONSE;

}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq $0x0, 0xa8(%rsp)
leaq 0x78c(%rip), %rax       # 0x83ae
movq %rax, (%rsp)
movl $0x2, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x28(%rsp)
movb $0x1, 0x2c(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x741(%rip), %rax       # 0x83b3
movq %rax, 0x38(%rsp)
movl $0x3, 0x40(%rsp)
movl $0x2, 0x44(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
movb $0x0, 0x64(%rsp)
leaq 0x8a(%rip), %rax        # 0x7d40
movq %rax, 0x68(%rsp)
movq %rsp, %rdi
addq $0x70, %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2100
movq %rsp, %rdx
movq 0xb8(%rsp), %rcx
addq $0x8, %rcx
leaq 0x8e5(%rip), %rdi       # 0x85c9
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x6ed0
movl %eax, 0xb4(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x2040
cmpl $0x0, 0xb4(%rsp)
jne 0x7d1a
movl $0x0, 0xc4(%rsp)
jmp 0x7d25
movl $0x2, 0xc4(%rsp)
movl 0xc4(%rsp), %eax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cotix[P]cReddit/libreddit/user.c
// Function: userUpdateHelper
DEF_TOKEN_CALLBACK(userUpdateHelper)
{
    ARG_LIST_USER_UPDATE

    int i;
    for (i = 0; idents[i].name != NULL; i++) {
        if (strcmp(idents[i].name, "kind") == 0) {
            /*
             * Check contents of the name
             */
            if (idents[i].value != NULL && strcmp(*((char**)idents[i].value), "t2") == 0) {
                if (*user != NULL)
                    redditUserFree(*user);

                *user = redditGetUser(parser);
            }

            break;
        }
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x28, %eax
ja 0x7d83
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, (%rsp)
jmp 0x7d9b
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x7e71
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq 0x5c9(%rip), %rsi       # 0x83ae
callq 0x2160
cmpl $0x0, %eax
jne 0x7e5f
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x7e5d
movq 0x28(%rsp), %rax
movslq 0x14(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x7c5(%rip), %rsi       # 0x85eb
callq 0x2160
cmpl $0x0, %eax
jne 0x7e5d
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x7e48
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x2090
movq 0x30(%rsp), %rdi
callq 0x73f0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x7e71
jmp 0x7e61
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7daf
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: str2int
char str2int(char c)
{
	switch (c)
	{
		case 'A': case 'a': case '0':
			return 0;
		case 'C': case 'c': case '1':
			return 1;
		case 'G': case 'g': case '2':
			return 2;
		case 'T': case 't': case '3':
			return 3;
	}
	return 4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
addl $-0x30, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x44, %eax
ja 0x1328
movq -0x10(%rbp), %rax
leaq 0x15cfd(%rip), %rcx     # 0x17004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x132c
movb $0x1, -0x1(%rbp)
jmp 0x132c
movb $0x2, -0x1(%rbp)
jmp 0x132c
movb $0x3, -0x1(%rbp)
jmp 0x132c
movb $0x4, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: get_num_line
int get_num_line(char *path,int flag)
{
	FILE *fp;
	int i,size;
	char *line;

	i=strlen(path)+20;
        line=(char *)malloc(i);
        memset(line,'\0',i);
        strcpy(line,path);
	if(flag==0)
	        strcat(line,"triloop.ds");
	else
		strcat(line,"tetraloop.ds");

        if(access(line,0)==-1)
        {
                printf("Error! Don't have %s file!\n",line);
                exit(1);
        }
        fp=fopen(line,"r");
        if(fp==NULL)
        {
                printf("Error! Can't open the %s file!\n",line);
                exit(1);
        }

	size=0;
	while(fgets(line,i,fp)!=NULL)
		size++;
	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10a0
addq $0x14, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x1160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
xorl %esi, %esi
callq 0x10e0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1050
cmpl $0x0, -0xc(%rbp)
jne 0x3290
movq -0x28(%rbp), %rdi
leaq 0x14140(%rip), %rsi     # 0x173c9
callq 0x11b0
jmp 0x32a0
movq -0x28(%rbp), %rdi
leaq 0x14139(%rip), %rsi     # 0x173d4
callq 0x11b0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x1180
cmpl $-0x1, %eax
jne 0x32cc
movq -0x28(%rbp), %rsi
leaq 0x13f5e(%rip), %rdi     # 0x17219
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x11c0
movq -0x28(%rbp), %rdi
leaq 0x14695(%rip), %rsi     # 0x1796c
callq 0x1190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3303
movq -0x28(%rbp), %rsi
leaq 0x13f43(%rip), %rdi     # 0x17235
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x11c0
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x1110
cmpq $0x0, %rax
je 0x332b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x330a
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: tableStartATS
void tableStartATS(double atp_value, double atpS[])
{
        int i, j;

        for (i = 0; i < 5; ++i)
                for (j = 0; j < 5; ++j)
                        atpS[i*5+j] = 0.00000000001;
        atpS[3] = atpS[15] = atp_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x392a
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jge 0x391d
movq -0x10(%rbp), %rax
imull $0x5, -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsd 0x1383b(%rip), %xmm0    # 0x17148
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x38f1
jmp 0x391f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x38e4
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x78(%rax)
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: tableStartATH
void tableStartATH(double atp_value,double atpH[])
{
        int i, j;

        for (i = 0; i < 5; ++i)
                for (j = 0; j < 5; ++j)
                        atpH[i*5+j] = 0.0;
        atpH[3] = atpH[15] = atp_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x39a5
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jge 0x3998
movq -0x10(%rbp), %rax
imull $0x5, -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3971
jmp 0x399a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3964
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x78(%rax)
movq -0x10(%rbp), %rax
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: initMatrix2
void initMatrix2(int Initint[],double enthalpyDPT[],double entropyDPT[],char numSeq1[])
{
	int i,j;
	for(i=1;i<=Initint[0];++i)
		for(j=i;j<=Initint[1];++j)
			if(j-i<4 || (numSeq1[i]+numSeq1[j]!=3))
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=1.0*INFINITY;
				entropyDPT[(i-1)*Initint[2]+j-1]=-1.0;
			}
			else
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=0.0;
				entropyDPT[(i-1)*Initint[2]+j-1]=-3224.0;
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x3ae7
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x3ad7
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
cmpl $0x4, %eax
jl 0x3a2a
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
cmpl $0x3, %eax
je 0x3a7c
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x136e3(%rip), %xmm0    # 0x17130
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x136cb(%rip), %xmm0    # 0x17140
movsd %xmm0, (%rax,%rcx,8)
jmp 0x3ac7
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0x1368e(%rip), %xmm0    # 0x17150
movsd %xmm0, (%rax,%rcx,8)
jmp 0x3ac9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x39f0
jmp 0x3ad9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x39db
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: Ss
double Ss(int i,int j,int k,double stackEntropies[],int Initint[],char numSeq1[],char numSeq2[])
{
	if(k==2)
	{
		if(i>=j)
			return -1.0;
		if(i==Initint[0]||j==Initint[1]+1)
			return -1.0;

		if(i>Initint[0])
			i-=Initint[0];
		if(j>Initint[1])
			j-=Initint[1];
		return stackEntropies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j-1]];
	}
	else
		return stackEntropies[numSeq1[i]*125+numSeq1[i+1]*25+numSeq2[j]*5+numSeq2[j+1]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0x3bef
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x3b31
movsd 0x13619(%rip), %xmm0    # 0x17140
movsd %xmm0, -0x8(%rbp)
jmp 0x3c49
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3b4d
movl -0x10(%rbp), %eax
movq -0x28(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x3b5f
movsd 0x135eb(%rip), %xmm0    # 0x17140
movsd %xmm0, -0x8(%rbp)
jmp 0x3c49
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x3b78
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movl -0xc(%rbp), %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x3b93
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
imull $0x7d, %ecx, %ecx
movq -0x30(%rbp), %rdx
movl -0xc(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movsbl (%rdx,%rsi), %edx
imull $0x19, %edx, %edx
addl %edx, %ecx
movq 0x10(%rbp), %rdx
movslq -0x10(%rbp), %rsi
movsbl (%rdx,%rsi), %edx
imull $0x5, %edx, %edx
addl %edx, %ecx
movq 0x10(%rbp), %rdx
movl -0x10(%rbp), %esi
subl $0x1, %esi
movslq %esi, %rsi
movsbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3c49
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
imull $0x7d, %ecx, %ecx
movq -0x30(%rbp), %rdx
movl -0xc(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movsbl (%rdx,%rsi), %edx
imull $0x19, %edx, %edx
addl %edx, %ecx
movq 0x10(%rbp), %rdx
movslq -0x10(%rbp), %rsi
movsbl (%rdx,%rsi), %edx
imull $0x5, %edx, %edx
addl %edx, %ecx
movq 0x10(%rbp), %rdx
movl -0x10(%rbp), %esi
addl $0x1, %esi
movslq %esi, %rsi
movsbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: find_pos
int find_pos(char *ref,int ref_start,char *source,int length,int num)
{
	int flag,i,j;

	for(i=0;i<num;i++)
	{
		flag=0;
		for(j=0;j<length;j++)
		{
			if(ref[ref_start+j]!=source[i*length+j])
			{
				flag++;
				break;
			}
		}
		if(flag==0)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x5168
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x514d
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x20(%rbp), %rcx
movl -0x30(%rbp), %edx
imull -0x24(%rbp), %edx
addl -0x34(%rbp), %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x5140
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x514d
jmp 0x5142
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x5103
cmpl $0x0, -0x2c(%rbp)
jne 0x515b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x516f
jmp 0x515d
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x50ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: max5
int max5(double a,double b,double c,double d,double e)
{
	if(a>b&&a>c&&a>d&&a>e)
		return 1;
	else if(b>c&&b>d&&b>e)
		return 2;
	else if(c>d&&c>e)
		return 3;
	else if(d>e)
		return 4;
	else
		return 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x5c86
movsd -0x10(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x5c86
movsd -0x10(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x5c86
movsd -0x10(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x5c86
movl $0x1, -0x4(%rbp)
jmp 0x5cf0
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x5cb3
movsd -0x18(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x5cb3
movsd -0x18(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x5cb3
movl $0x2, -0x4(%rbp)
jmp 0x5cf0
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x5cd4
movsd -0x20(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x5cd4
movl $0x3, -0x4(%rbp)
jmp 0x5cf0
movsd -0x28(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x5ce9
movl $0x4, -0x4(%rbp)
jmp 0x5cf0
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: newpush
int newpush(int store[],int i,int j,int mtrx,int total,int next)
{
        int k;
        for(k=total-1;k>=next;k--)
        {
                store[(k+1)*3]=store[k*3];
                store[(k+1)*3+1]=store[k*3+1];
                store[(k+1)*3+2]=store[k*3+2];
        }
        store[next*3]=i;                  
        store[next*3+1]=j;
        store[next*3+2]=mtrx;

        return total+1;           
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movl -0x18(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x7a27
movq -0x8(%rbp), %rax
imull $0x3, -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
imull $0x3, %ecx, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
imull $0x3, -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
imull $0x3, %ecx, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
imull $0x3, -0x20(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
imull $0x3, %ecx, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x79a2
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
imull $0x3, -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
imull $0x3, -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
imull $0x3, -0x1c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: drawHairpin
double drawHairpin(int bp[],double mh,double ms,int Initint[])
{
        int i,N;

        N=0;
        if(fabs(ms)>999999999||fabs(mh)>999999999)
        {
		return 0.0;
        }
        else
        {
		for(i=1;i<Initint[0];++i)
		{
			if(bp[i-1]>0)
				N++;
                }
                return mh/(ms+(((N/2)-1)*-0.51986))-273.15;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movaps 0xd737(%rip), %xmm1     # 0x171f0
pand %xmm1, %xmm0
movsd 0xd673(%rip), %xmm1     # 0x17138
ucomisd %xmm1, %xmm0
ja 0x9ae9
movsd -0x18(%rbp), %xmm0
movaps 0xd719(%rip), %xmm1     # 0x171f0
pand %xmm1, %xmm0
movsd 0xd655(%rip), %xmm1     # 0x17138
ucomisd %xmm1, %xmm0
jbe 0x9af3
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9b6f
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x9b2e
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x9b21
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9b23
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9afa
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm2
movl -0x30(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xd636(%rip), %xmm3     # 0x17188
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xd61a(%rip), %xmm1     # 0x17180
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: initMatrix
void initMatrix(int Initint[],double enthalpyDPT[],double entropyDPT[],char numSeq1[],char numSeq2[])
{
	int i,j;

	for(i=1;i<=Initint[0];++i)
	{
		for(j=1;j<=Initint[1];++j)
		{
			if(numSeq1[i]+numSeq2[j]!=3)
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=1.0*INFINITY;
				entropyDPT[(i-1)*Initint[2]+j-1]=-1.0;
			}
			else
			{
				enthalpyDPT[(i-1)*Initint[2]+j-1]=0.0;
				entropyDPT[(i-1)*Initint[2]+j-1]=-3224.0;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x9ca1
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jg 0x9c91
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
cmpl $0x3, %eax
je 0x9c36
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0xd529(%rip), %xmm0     # 0x17130
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0xd511(%rip), %xmm0     # 0x17140
movsd %xmm0, (%rax,%rcx,8)
jmp 0x9c81
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
addl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd 0xd4d4(%rip), %xmm0     # 0x17150
movsd %xmm0, (%rax,%rcx,8)
jmp 0x9c83
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9bb5
jmp 0x9c93
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9b9f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: drawDimer
double drawDimer(int *ps1,int *ps2,double H,double S,double Initdouble[],int Initint[])
{
        int i,N;

        if(fabs(Initdouble[3])>999999999)
                return 0.0;
        else
        {
                N=0;
                for(i=0;i<Initint[0];i++)
                {
                        if(ps1[i]>0)
                                ++N;
                }
                for(i=0;i<Initint[1];i++)
                {
                        if(ps2[i]>0)
                                ++N;
                }
                N=(N/2)-1;
                return (H/(S+(N*-0.51986)+Initdouble[2]))-273.15;
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x30(%rbp), %rax
movsd 0x18(%rax), %xmm0
movaps 0xa4a2(%rip), %xmm1     # 0x171f0
pand %xmm1, %xmm0
movsd 0xa3de(%rip), %xmm1     # 0x17138
ucomisd %xmm1, %xmm0
jbe 0xcd6d
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xce2f
movl $0x0, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xcdaa
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xcd9d
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xcd9f
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xcd7b
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xcde1
movq -0x18(%rbp), %rax
movslq -0x3c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0xcdd4
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xcdd6
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xcdb1
movl -0x40(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm2
cvtsi2sdl -0x40(%rbp), %xmm1
movsd 0xa37f(%rip), %xmm3     # 0x17188
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
movq -0x30(%rbp), %rax
addsd 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd 0xa35a(%rip), %xmm1     # 0x17180
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: reverse
void reverse(char seq[],char rev[],int length)
{
	int i;

	for(i=0;i<length;i++)
        {
                if(seq[length-1-i]=='A')
                {
                        rev[i]='T';
                        continue;
                }
                if(seq[length-1-i]=='T')
                {
                        rev[i]='A';
                        continue;
                }
                if(seq[length-1-i]=='C')
                {
                        rev[i]='G';
                        continue;
                }
                rev[i]='C';
        }
        rev[i]='\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xea21
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jne 0xe9b9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x54, (%rax,%rcx)
jmp 0xea13
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x54, %eax
jne 0xe9e0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x41, (%rax,%rcx)
jmp 0xea13
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x43, %eax
jne 0xea07
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x47, (%rax,%rcx)
jmp 0xea13
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x43, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe986
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: sort_merge
void sort_merge(int *store,int *temp,int *data,int start,int end)
{
        int middle;

        if(start<end)
        {
                middle=(start+end)/2;
                sort_merge(store,temp,data,start,middle);
                sort_merge(store,temp,data,(middle+1),end);
                merge(store,temp,data,start,end,middle);
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x11db3
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq 0x11d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl -0x20(%rbp), %r8d
callq 0x11d30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x11970
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: next_one
void next_one(struct Primer *first, struct ExoProbe *second)
{
	struct Primer *one;
	struct ExoProbe *two;

	one=first;
	two=second;
	
	while(two)
	{
		if(two->pos<=one->pos)
			two=two->next;
		else
			break;
	}
	while(one)
	{
		if(two==NULL)
			break;
		if(one->pos<two->pos)
		{
			one->other=two;
			one=one->next;
			continue;
		}
		while(two)
		{
			if(two->pos<=one->pos)
				two=two->next;
			else
			{
				one->other=two;
				break;
			}
		}
		one=one->next;
	}			
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13ca3
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x13c9f
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13ca1
jmp 0x13ca3
jmp 0x13c7c
jmp 0x13ca5
cmpq $0x0, -0x18(%rbp)
je 0x13d20
cmpq $0x0, -0x20(%rbp)
jne 0x13cb5
jmp 0x13d20
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x13cdd
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13ca5
jmp 0x13cdf
cmpq $0x0, -0x20(%rbp)
je 0x13d12
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x13d02
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13d10
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x13d12
jmp 0x13cdf
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13ca5
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: check_add
int check_add(int F3_pos,int *best_par,int expect)
{
        int i,dis;

	for(i=0;i<expect;i++)
	{
		if(best_par[i]==-1) //the empty record
			return 1;
		dis=best_par[i]-F3_pos;
		if(abs(dis)<300)
			return 0;
	}
        return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15e6c
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x15e34
movl $0x1, -0x4(%rbp)
jmp 0x15e73
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
cmpl $0x12c, %eax            # imm = 0x12C
jge 0x15e5f
movl $0x0, -0x4(%rbp)
jmp 0x15e73
jmp 0x15e61
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15e15
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: how_manyPrimer
void how_manyPrimer(struct Primer *head,int common)
{
	struct Primer *p_primer;
	struct Node *p_node;
	int i,num,*list;

	list=(int *)malloc(common*sizeof(int));
	p_primer=head;
	while(p_primer)
	{
		p_node=p_primer->common;
		for(i=0;i<common;i++)
			list[i]=0;
		while(p_node)
		{
			list[p_node->gi]=1;
			p_node=p_node->next;
		}
		num=0;
                for(i=0;i<common;i++)
                        num=num+list[i];
		p_primer->total=num;
		p_primer=p_primer->next;
	}
	free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1160
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15f5f
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15ee8
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15ec6
jmp 0x15eea
cmpq $0x0, -0x20(%rbp)
je 0x15f12
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15eea
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15f44
movl -0x28(%rbp), %eax
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15f20
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15ea8
movq -0x30(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jiqingxiaoxi[P]RPA/RPA.c
// Function: how_manyProbe
void how_manyProbe(struct ExoProbe *head,int common)
{
        struct ExoProbe *p_primer;
        struct Node *p_node;
        int i,num,*list;

        list=(int *)malloc(common*sizeof(int));
        p_primer=head;
        while(p_primer)
        {
                p_node=p_primer->common;
                for(i=0;i<common;i++)
                        list[i]=0;
                while(p_node)
                {
                        list[p_node->gi]=1;
                        p_node=p_node->next;
                }
                num=0;
                for(i=0;i<common;i++)
                        num=num+list[i];
                p_primer->total=num;
                p_primer=p_primer->next;
        }
        free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x1160
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1604f
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x15fd8
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15fb6
jmp 0x15fda
cmpq $0x0, -0x20(%rbp)
je 0x16002
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15fda
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x16034
movl -0x28(%rbp), %eax
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16010
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15f98
movq -0x30(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: unpackFQB
void unpackFQB (U32 *u, char *s1, char *q1, char *s2, char *q2)
{
  char *s ; int i,j ;
  if ((s = s1))
    for (i =  0 ; i < 10 ; ++i) for (j = 16 ; j-- ; ) *s++ = (u[i] >> (2*j)) & 3 ;
  if ((s = q1))
    for (i = 10 ; i < 15 ; ++i) for (j = 32 ; j-- ; ) *s++ = (u[i] >> j) & 1 ;
  if ((s = s2))
    for (i = 15 ; i < 25 ; ++i) for (j = 16 ; j-- ; ) *s++ = (u[i] >> (2*j)) & 3 ;
  if ((s = q2))
    for (i = 25 ; i < 30 ; ++i) for (j = 32 ; j-- ; ) *s++ = (u[i] >> j) & 1 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x14c3
movl $0x0, -0x34(%rbp)
cmpl $0xa, -0x34(%rbp)
jge 0x14c1
movl $0x10, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cmpl $0x0, %eax
je 0x14b4
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x38(%rbp), %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x147a
jmp 0x14b6
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x146d
jmp 0x14c3
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x152c
movl $0xa, -0x34(%rbp)
cmpl $0xf, -0x34(%rbp)
jge 0x152a
movl $0x20, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cmpl $0x0, %eax
je 0x151d
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x38(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x14e5
jmp 0x151f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14d8
jmp 0x152c
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1597
movl $0xf, -0x34(%rbp)
cmpl $0x19, -0x34(%rbp)
jge 0x1595
movl $0x10, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cmpl $0x0, %eax
je 0x1588
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x38(%rbp), %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x154e
jmp 0x158a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1541
jmp 0x1597
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1600
movl $0x19, -0x34(%rbp)
cmpl $0x1e, -0x34(%rbp)
jge 0x15fe
movl $0x20, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x38(%rbp)
cmpl $0x0, %eax
je 0x15f1
movq -0x8(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x38(%rbp), %ecx
shrl %cl, %eax
andl $0x1, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
jmp 0x15b9
jmp 0x15f3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15ac
jmp 0x1600
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: seqAddHashes
void seqAddHashes (char *s, int len, Array a, int readCount)
{
  SeqhashRCiterator *mi = moshRCiterator (hasher, s, len) ;
  U64 hash ; int pos ;
  while (moshRCnext (mi, &hash, &pos, 0))
    { HashTemp *h = arrayp(a,arrayMax(a),HashTemp) ;
      h->hash = hash ; h->read = readCount ; h->pos = pos ;
    }
  seqhashRCiteratorDestroy (mi) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x12d8b(%rip), %rdi     # 0x143b8
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0xa940
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0xab60
cmpb $0x0, %al
je 0x168b
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0xc640
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x163d
movq -0x28(%rbp), %rdi
callq 0x16a0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: hashIndexFind
static inline U32 hashIndexFind (U64 hash, int isAdd)
{
  U32 index ;
  U64 offset = hash & hashTableMask ;
  U64 diff = ((hash >> hashTableBits) & hashTableMask) | 1 ; /* odd number so coprime to size */
  while ((index = hashIndex[offset]) && (hashValue[index] != hash))
    offset = (offset + diff) & hashTableMask ;
  if (!index && isAdd)
    { index = hashIndex[offset] = hashNumber++ ;
      hashValue[index] = hash ;
      if (hashNumber > (hashTableSize >> 2)-2) die ("hashTableSize is too small") ;
    }
  return index ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
andq 0x12aa6(%rip), %rax     # 0x14490
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x11758(%rip), %ecx     # 0x13150
shrq %cl, %rax
andq 0x12a8e(%rip), %rax     # 0x14490
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq 0x129c7(%rip), %rax     # 0x143d8
movq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x1a3d
movq 0x129c4(%rip), %rax     # 0x143f0
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1a46
jmp 0x1a5b
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
andq 0x12a3b(%rip), %rax     # 0x14490
movq %rax, -0x18(%rbp)
jmp 0x1a0a
cmpl $0x0, -0x10(%rbp)
jne 0x1ac5
cmpl $0x0, -0xc(%rbp)
je 0x1ac5
movl 0x1297b(%rip), %eax     # 0x143e8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x12970(%rip)     # 0x143e8
movq 0x12959(%rip), %rcx     # 0x143d8
movq -0x18(%rbp), %rdx
movl %eax, (%rcx,%rdx,4)
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq 0x1295c(%rip), %rax     # 0x143f0
movl -0x10(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x12947(%rip), %eax     # 0x143e8
movq 0x12938(%rip), %rcx     # 0x143e0
shrq $0x2, %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jbe 0x1ac3
leaq 0xdb49(%rip), %rdi      # 0xf605
movb $0x0, %al
callq 0xd0c0
jmp 0x1ac5
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: hashDepthHist
void hashDepthHist (void)
{
  if (!arrayMax(hashDepth)) { fprintf (stderr, "  no hash list to print stats for\n") ; return ; }
  Array a = arrayCreate (1024, int) ;
  int i ;
  for (i = 0 ; i < arrayMax(hashDepth) ; ++i)
    ++array(a, arr(hashDepth, i, U32), int) ;
  histogramReport ("HASH_COUNT", a) ;
  arrayDestroy (a) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x11911(%rip), %rax     # 0x143c0
cmpl $0x0, 0x18(%rax)
jne 0x2acf
movq 0x1053c(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
leaq 0xb9ff(%rip), %rsi      # 0xe4c5
movb $0x0, %al
callq 0x1150
jmp 0x2b4b
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0xc1e0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0x118cd(%rip), %rcx     # 0x143c0
cmpl 0x18(%rcx), %eax
jge 0x2b32
movq -0x8(%rbp), %rdi
movq 0x118bd(%rip), %rax     # 0x143c0
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movq 0x118af(%rip), %rdx     # 0x143c0
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %esi
callq 0xc640
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ae9
movq -0x8(%rbp), %rsi
leaq 0xb9ab(%rip), %rdi      # 0xe4e8
callq 0x26e0
movq -0x8(%rbp), %rdi
callq 0xc3e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: codeSizeHist
void codeSizeHist (void)
{
  if (!clusterBlocks || !arrayMax (clusterBlocks))
    { fprintf (stderr, "  no barcodes to print stats for\n") ; return ; }
  Array hashHist = arrayCreate (1024, int) ;
  Array clusterHist = arrayCreate (1024, int) ;
  int i ;
  for (i = 0 ; i < arrayMax(clusterBlocks) ; ++i)
    { ClusterBlock *b = arrp (clusterBlocks, i, ClusterBlock) ;
      ++array(hashHist, b->nHash, int) ;
      ++array(clusterHist, b->nSubCluster, int) ;
    }
  histogramReport ("CODE_SIZE", hashHist) ;
  if (arrayMax(clusterHist) > 1) histogramReport ("CODE_CLUSTER", clusterHist) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpq $0x0, 0x11858(%rip)     # 0x143c8
je 0x2b7f
movq 0x1184f(%rip), %rax     # 0x143c8
cmpl $0x0, 0x18(%rax)
jne 0x2b9c
movq 0x10472(%rip), %rax     # 0x12ff8
movq (%rax), %rdi
leaq 0xb963(%rip), %rsi      # 0xe4f3
movb $0x0, %al
callq 0x1150
jmp 0x2c5e
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0xc1e0
movq %rax, -0x8(%rbp)
movl $0x400, %edi            # imm = 0x400
movl $0x4, %esi
callq 0xc1e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x117f5(%rip), %rcx     # 0x143c8
cmpl 0x18(%rcx), %eax
jge 0x2c34
movq 0x117e9(%rip), %rax     # 0x143c8
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq 0x117db(%rip), %rdx     # 0x143c8
imull 0x14(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xc640
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0xc640
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2bc9
movq -0x8(%rbp), %rsi
leaq 0xb8d6(%rip), %rdi      # 0xe515
callq 0x26e0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jle 0x2c5e
movq -0x10(%rbp), %rsi
leaq 0xb8c6(%rip), %rdi      # 0xe51f
callq 0x26e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/richarddurbin[P]hash10x/hash10x.c
// Function: printArrayStats
void printArrayStats (Array a)
{
  int i, *ai = arrp(a,0,int), sum = 0, min = -1, max = arrayMax(a)-1 ;
  double total = 0 ;
  for (i = 0 ; i < arrayMax(a) ; ++i, ++ai)
    if (*ai)
      { sum += *ai ; total += *ai * i ;
	if (min == -1) min = i ;
      }
  fprintf (outFile, "  %d mean %.1f min %d max %d\n", sum, total/sum, min, max) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
imull $0x0, 0x14(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x2d20
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x2d07
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
imull -0xc(%rbp), %eax
cvtsi2sd %eax, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x2d05
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x2d07
jmp 0x2d09
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
jmp 0x2cc0
movq 0x116a9(%rip), %rdi     # 0x143d0
movl -0x1c(%rbp), %edx
movsd -0x30(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
divsd %xmm1, %xmm0
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq 0xb7e6(%rip), %rsi      # 0xe52c
movb $0x1, %al
callq 0x1150
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)