LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/main.c
// Function: read_data
void read_data(const char * path, char *Input) {
	
	FILE *ptr_file;
	int32_t size;
	int i, j, idx;
	const int pd_offset = 62; //offset to pd (pixel data)
	const int bpl = BYTE_TO_BITS(4); // bits_per_line = bpl.
	char ch;
	
	// Open the B&W bitmap file of the given path.
	ptr_file = fopen(path, "rb");
	
	// Null pointer signifies an error :
	if (!ptr_file) {
		fprintf(stdout, "Failed opening the data.\n");
		exit(EXIT_FAILURE);
	}
	// Get the size of the bitmap file.
	fseek(ptr_file, 0, SEEK_END);
	size = ftell(ptr_file);
	
	// Skips header info.
	fseek(ptr_file, pd_offset, SEEK_SET);
	
	// Read bitmap : 
	idx = 0;
	for (i = 0; i < size - pd_offset; i++) {
		ch = fgetc(ptr_file);
		// Each byte represents 8 pixels in reverse order.
		for (j = BYTE_TO_BITS(1) - 1; j >= 0 ; j--) {
			/* 
			Consider zero padding : 
			3 bytes are padded.
			
			Store only significant pixel data.
			*/
			if((idx % bpl) < IMG_WIDTH) {
				Input[Y_POS(idx, bpl, IMG_HEIGHT) + (idx % bpl)] = (ch >> j & 0x1);
			}
			idx++;
		}
	}
	fclose(ptr_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x3e, -0x2c(%rbp)
movl $0x20, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1bdd(%rip), %rsi      # 0x3116
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x156b
movq 0x3a80(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
leaq 0x1bbf(%rip), %rsi      # 0x3119
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10c0
movq -0x18(%rbp), %rdi
callq 0x10a0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl $0x3e, %esi
xorl %edx, %edx
callq 0x10c0
movl $0x0, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x3e, %ecx
cmpl %ecx, %eax
jge 0x164f
movq -0x18(%rbp), %rdi
callq 0x1070
movb %al, -0x31(%rbp)
movl $0x7, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x163f
movl -0x28(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
cmpl $0x1d, %edx
jge 0x162b
movsbl -0x31(%rbp), %eax
movl -0x24(%rbp), %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x28(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl $0x1c, %eax
subl %ecx, %eax
imull $0x1d, %eax, %ecx
movl -0x28(%rbp), %eax
movl $0x20, %esi
cltd
idivl %esi
movq -0x40(%rbp), %rax
movl %edx, %esi
movb -0x32(%rbp), %dl
addl %esi, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15cb
jmp 0x1641
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15a7
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/main.c
// Function: write_data
void write_data(char (*Input)[841], int size) 
{
	FILE *ptr_file;
	int i, j, k;
	// Create a new data header file.
	ptr_file = fopen("data.h", "wb");
	// Null pointer signifies an error :
	if (!ptr_file) {
		fprintf(stdout, "Failed creating new header files\n");
		exit(EXIT_FAILURE);
	}
	fprintf(ptr_file,	"#ifndef _DATA_H_\n"\
						"#define	_DATA_H_\n"\
						"\tchar Input[10][29*29] = {");
	for (i = 0; i < size; i++) {
		fputs("{\n\t\t", ptr_file);
		for (j = 0; j < IMG_HEIGHT; j++) {
			for (k = 0; k < IMG_WIDTH; k++) {				
				fputc('0' + Input[i][j * IMG_HEIGHT + k], ptr_file);
				if (j == (IMG_HEIGHT - 1) && k == (IMG_WIDTH - 1)) 
					fputs("}", ptr_file);
				else {
					fputc(',', ptr_file);
				}
				
			}
			if (j < (IMG_HEIGHT - 1))
				fputs("\n\t\t", ptr_file);
		}
		if (i < (size - 1))
			fputs(",\n\t\t", ptr_file);
		
	}					
	fputs("};\n", ptr_file);
	fprintf(ptr_file, "#endif /* DATA_H_ */");
	fclose(ptr_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x1abd(%rip), %rdi      # 0x3133
leaq 0x1abd(%rip), %rsi      # 0x313a
callq 0x10d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x16af
movq 0x393c(%rip), %rax      # 0x4fd0
movq (%rax), %rdi
leaq 0x1a9f(%rip), %rsi      # 0x313d
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x10f0
movq -0x18(%rbp), %rdi
leaq 0x1aa5(%rip), %rsi      # 0x315f
movb $0x0, %al
callq 0x1090
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x17ba
movq -0x18(%rbp), %rsi
leaq 0x1abd(%rip), %rdi      # 0x319c
callq 0x1050
movl $0x0, -0x20(%rbp)
cmpl $0x1d, -0x20(%rbp)
jge 0x178d
movl $0x0, -0x24(%rbp)
cmpl $0x1d, -0x24(%rbp)
jge 0x1767
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x349, %rcx, %rcx      # imm = 0x349
addq %rcx, %rax
imull $0x1d, -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
addl $0x30, %edi
movq -0x18(%rbp), %rsi
callq 0x1080
cmpl $0x1c, -0x20(%rbp)
jne 0x174c
cmpl $0x1c, -0x24(%rbp)
jne 0x174c
movq -0x18(%rbp), %rsi
leaq 0x1a5c(%rip), %rdi      # 0x31a1
callq 0x1050
jmp 0x175a
movq -0x18(%rbp), %rsi
movl $0x2c, %edi
callq 0x1080
jmp 0x175c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16fc
cmpl $0x1c, -0x20(%rbp)
jge 0x177d
movq -0x18(%rbp), %rsi
leaq 0x1a2c(%rip), %rdi      # 0x31a4
callq 0x1050
jmp 0x177f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x16eb
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x17aa
movq -0x18(%rbp), %rsi
leaq 0x19fe(%rip), %rdi      # 0x31a3
callq 0x1050
jmp 0x17ac
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16c8
movq -0x18(%rbp), %rsi
leaq 0x194d(%rip), %rdi      # 0x3112
callq 0x1050
movq -0x18(%rbp), %rdi
leaq 0x19d3(%rip), %rsi      # 0x31a8
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/main.c
// Function: write_weights
void write_weights(FILE *ptr_file1, FILE *ptr_file2, const char* layer_name, float *Layer_Weights_CPU, int size) {
	
	#define fprintfs(file1, file2, str) 	fprintf(file1, str);\
											fprintf(file2, str)
	int i;
	fprintf(ptr_file1, "short %s[%d] = {", layer_name, size);
	fprintf(ptr_file2, "char %s[%d] = {", layer_name, size);
	for (i = 0; i < size; i++) {
		fprintf(ptr_file1, "%d", (short)(Layer_Weights_CPU[i] * 100));
		fprintf(ptr_file2, "%d", (char)(Layer_Weights_CPU[i] * 10));
		if (i < (size - 1))
			fprintfs(ptr_file1, ptr_file2, ", ");
	}
	fprintfs(ptr_file1, ptr_file2, "};\n");
	
	#undef fprintfs
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq 0x18cd(%rip), %rsi      # 0x30eb
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
leaq 0x18c5(%rip), %rsi      # 0x30fc
movb $0x0, %al
callq 0x1090
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x18f4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x17a6(%rip), %xmm1     # 0x3010
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movswl %ax, %edx
leaq 0x1890(%rip), %rsi      # 0x310c
xorl %eax, %eax
callq 0x1090
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movss 0x1778(%rip), %xmm1     # 0x3014
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movsbl %al, %edx
leaq 0x185e(%rip), %rsi      # 0x310c
movb $0x0, %al
callq 0x1090
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x18d4
movq -0x8(%rbp), %rdi
leaq 0x1842(%rip), %rsi      # 0x310f
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
leaq 0x1830(%rip), %rsi      # 0x310f
movb $0x0, %al
callq 0x1090
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1845
movq -0x8(%rbp), %rdi
leaq 0x1813(%rip), %rsi      # 0x3112
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
leaq 0x1801(%rip), %rsi      # 0x3112
movb $0x0, %al
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer1
void calculateLayer1(char* input, float* Layer1_Neurons_CPU){
	int i, j;
	for (i = 0; i < IMG_HEIGHT; i++) 
		for (j = 0; j < IMG_WIDTH; j++) 
			Layer1_Neurons_CPU[i * IMG_HEIGHT + j] = input[i * IMG_HEIGHT + j];
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1d, -0x14(%rbp)
jge 0x1996
movl $0x0, -0x18(%rbp)
cmpl $0x1d, -0x18(%rbp)
jge 0x1989
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leal (%rdx,%rdx,8), %esi
movl %esi, %edx
leal (%rdx,%rdx,2), %edx
addl %ecx, %edx
addl %edx, %ecx
movl -0x18(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cvtsi2ss %eax, %xmm0
movq -0x10(%rbp), %rax
imull $0x1d, -0x14(%rbp), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1940
jmp 0x198b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1933
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer2
void calculateLayer2(float* Layer1_Neurons_CPU, WEIGHT_TYPE* Layer1_Weights_CPU, float* Layer2_Neurons_CPU){
	float somme;
	int i,j,k,m,n;
	for(i=0;i<6;i++)
		for(j=0;j<13;j++)
			for(k=0;k<13;k++){
				somme = Layer1_Weights_CPU[26*i];
				for(m=0;m<5;m++)
					for(n=0;n<5;n++)
						somme += Layer1_Weights_CPU[26*i+5*m+n+1] * Layer1_Neurons_CPU[29*(m+2*j)+n+2*k];
				Layer2_Neurons_CPU[13*13*i+13*j+k] = SIGMOID(CONV(somme));
			}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x6, -0x20(%rbp)
jge 0x1af6
movl $0x0, -0x24(%rbp)
cmpl $0xd, -0x24(%rbp)
jge 0x1ae6
movl $0x0, -0x28(%rbp)
cmpl $0xd, -0x28(%rbp)
jge 0x1ad6
movq -0x10(%rbp), %rax
imull $0x1a, -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x5, -0x2c(%rbp)
jge 0x1a7f
movl $0x0, -0x30(%rbp)
cmpl $0x5, -0x30(%rbp)
jge 0x1a72
movq -0x10(%rbp), %rax
imull $0x1a, -0x20(%rbp), %ecx
imull $0x5, -0x2c(%rbp), %edx
addl %edx, %ecx
addl -0x30(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl -0x24(%rbp), %edx
shll %edx
addl %edx, %ecx
imull $0x1d, %ecx, %ecx
addl -0x30(%rbp), %ecx
movl -0x28(%rbp), %edx
shll %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1a10
jmp 0x1a74
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a03
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1738(%rip), %xmm0     # 0x31c8
mulsd %xmm1, %xmm0
callq 0x10e0
movaps %xmm0, %xmm1
movsd 0x171c(%rip), %xmm0     # 0x31c0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
imull $0xa9, -0x20(%rbp), %ecx
imull $0xd, -0x24(%rbp), %edx
addl %edx, %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x19dd
jmp 0x1ad8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x19cc
jmp 0x1ae8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x19bb
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer4
void calculateLayer4(float* Layer3_Neurons_CPU, WEIGHT_TYPE* Layer3_Weights_CPU, float* Layer4_Neurons_CPU){
	float somme;
	int i, j, k, m;
	for( i=0;i<100;i++){
		somme = Layer3_Weights_CPU[i*(1+50*25)];
		for( j=0;j<50;j++)
			for( k=0;k<5;k++)
				for ( m=0;m<5;m++)
					somme += Layer3_Weights_CPU[i*(1+50*25)+1 + m + k*5 + j*25] * Layer3_Neurons_CPU[m+5*k+25*j];

		Layer4_Neurons_CPU[i] = SIGMOID(CONV(somme));
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x64, -0x20(%rbp)
jge 0x1f8a
movq -0x10(%rbp), %rax
imull $0x4e3, -0x20(%rbp), %ecx # imm = 0x4E3
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x32, -0x24(%rbp)
jge 0x1f42
movl $0x0, -0x28(%rbp)
cmpl $0x5, -0x28(%rbp)
jge 0x1f32
movl $0x0, -0x2c(%rbp)
cmpl $0x5, -0x2c(%rbp)
jge 0x1f25
movq -0x10(%rbp), %rax
imull $0x4e3, -0x20(%rbp), %ecx # imm = 0x4E3
addl $0x1, %ecx
addl -0x2c(%rbp), %ecx
imull $0x5, -0x28(%rbp), %edx
addl %edx, %ecx
imull $0x19, -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
imull $0x5, -0x28(%rbp), %edx
addl %edx, %ecx
imull $0x19, -0x24(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1ec2
jmp 0x1f27
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1eb5
jmp 0x1f34
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ea4
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1275(%rip), %xmm0     # 0x31c8
mulsd %xmm1, %xmm0
callq 0x10e0
movaps %xmm0, %xmm1
movsd 0x1259(%rip), %xmm0     # 0x31c0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e7b
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CerfVert94[P]lenet_cnn/neural_network.c
// Function: calculateLayer5
void calculateLayer5(float* Layer4_Neurons_CPU, WEIGHT_TYPE* Layer4_Weights_CPU, double* Layer5_Neurons_CPU){
	float somme;
	int i, j;
	for( i=0;i<10;i++){
		somme = Layer4_Weights_CPU[101*i];
		for( j=0;j<100;j++)
			somme += Layer4_Weights_CPU[1+101*i+j] * Layer4_Neurons_CPU[j];
		Layer5_Neurons_CPU[i] = SIGMOID(CONV(somme));
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0xa, -0x20(%rbp)
jge 0x205b
movq -0x10(%rbp), %rax
imull $0x65, -0x20(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x64, -0x24(%rbp)
jge 0x2017
movq -0x10(%rbp), %rax
imull $0x65, -0x20(%rbp), %ecx
addl $0x1, %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x1c(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x1c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1fd1
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x11a0(%rip), %xmm0     # 0x31c8
mulsd %xmm1, %xmm0
callq 0x10e0
movaps %xmm0, %xmm1
movsd 0x1184(%rip), %xmm0     # 0x31c0
mulsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1fab
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: hash
int hash(char *s, int limit) {
    unsigned int code = 0;
    char *       ptr = s;

    int param = 1;
    while (compare_char(*ptr, '\0') != 0) {
        // code = code ^ (*ptr);
        code += (param * (*ptr)) % limit;
        param = (param * 9999991) % limit;
        ++ptr;
    }
    code = (code ^ 9999901) % limit;
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
xorl %esi, %esi
movsbl (%rax), %edi
callq 0x2d60
cmpl $0x0, %eax
je 0x48db
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
imull %ecx, %eax
cltd
idivl -0xc(%rbp)
addl -0x10(%rbp), %edx
movl %edx, -0x10(%rbp)
imull $0x989677, -0x1c(%rbp), %eax # imm = 0x989677
cltd
idivl -0xc(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4895
movl -0x10(%rbp), %eax
xorl $0x98961d, %eax         # imm = 0x98961D
xorl %edx, %edx
divl -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_init
hash_table *ht_init(int length) {
    hash_table *ht = mp_new(sizeof(hash_table));
    ht->length = length;
    ht->array = mp_new(ht->length * sizeof(link_list *));
    memset(ht->array, 0, ht->length * sizeof(link_list *));
    return ht;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x32b0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x32b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x8(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x10a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_add
void ht_add(hash_table *ht, char *s) {
    unsigned int code = hash(s, ht->length);
    link_list *       ptr = ht->array[code];

    if (ptr == NULL) {
        ptr = ht->array[code] = lk_init();
    }

    char *ss = mp_new(sizeof(char) * (strlen(s) + 1));
    strcpy(ss, s);
    lk_add(ptr, ss);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x4870
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x49c5
movb $0x0, %al
callq 0x3700
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x14(%rbp), %edx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1070
addq $0x1, %rax
shlq $0x0, %rax
movl %eax, %edi
callq 0x32b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1030
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x37c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/hashtable_search/hashtable_search.c
// Function: ht_exist
boolean ht_exist(hash_table *ht, char *s) {
    int   code = hash(s, ht->length);
    link_list *ptr = ht->array[code];

    if (ptr == NULL) {
        return F;
    }
    return NULL != lk_search(ptr, s, compare);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x4870
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4a5b
leaq 0x64c(%rip), %rax       # 0x50a0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x4a82
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x22a(%rip), %rdx      # 0x4840
callq 0x3940
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/endeav0r[P]hsvm/src/disassembler.c
// Function: disassembler_load
unsigned char * disassembler_load (const char * filename, size_t * filesize)
{
    FILE * fh;
    unsigned char * buf;

    fh = fopen(filename, "rb");
    if (fh == NULL) {
        fprintf(stderr, "could not open file %s\n", filename);
        return NULL;
    }

    fseek(fh, 0, SEEK_END);
    *filesize = ftell(fh);
    fseek(fh, 0, SEEK_SET);

    buf = (unsigned char *) malloc(*filesize);

    fread(buf, 1, *filesize, fh);

    fclose(fh);

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6149(%rip), %rsi      # 0x7514
callq 0x1260
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1401
movq 0x8c16(%rip), %rax      # 0x9ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x5c14(%rip), %rsi      # 0x7004
movb $0x0, %al
callq 0x11a0
movq $0x0, -0x8(%rbp)
jmp 0x146f
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x11f0
movq -0x20(%rbp), %rdi
callq 0x11b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x11f0
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x11d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x10c0
movq -0x20(%rbp), %rdi
callq 0x10e0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/endeav0r[P]hsvm/src/disassembler.c
// Function: is_branch
int is_branch (uint8_t * buf)
{
    struct _instruction * ins = (struct _instruction *) buf;
    switch (ins->opcode) {
        case OP_JMP  :
        case OP_JE   :
        case OP_JNE  :
        case OP_JL   :
        case OP_JLE  :
        case OP_JG   :
        case OP_JGE  :
        case OP_CALL :
            return 1;
    };
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
addl $-0x20, %eax
subl $0x7, %eax
ja 0x14aa
jmp 0x14a1
movl $0x1, -0x4(%rbp)
jmp 0x14b1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ikbenlike[P]nngutils/src/tee.c
// Function: parse_arg
struct tee_args *parse_arg(struct tee_args *args, int argc, char **argv){
    args->files = calloc(1, sizeof(char*) * argc);
    args->fcount = 0;
    for(int i = 1; i < argc; i++){
        if(argv[i][0] == '-'){
            if(!strcmp(argv[i], "-a")){
                args->append = true;
            }
            else if(!strcmp(argv[i], "-i")){
                args->ignore_interrupts = true;
            }
            else if(!strcmp(argv[i], "-p")){
                args->diagnose = true;
            }
            else {
                fprintf(stderr, "%s: invalid argument '%s'\n", argv[0], argv[i]);
                exit(1);
            }
        }
        else {
            args->files[args->fcount++] = argv[i];
        }
    }
    return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rsi
shlq $0x3, %rsi
movl $0x1, %edi
callq 0x1060
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1312
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x12d8
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xdcb(%rip), %rsi       # 0x2004
callq 0x1070
cmpl $0x0, %eax
jne 0x124f
movq -0x8(%rbp), %rax
movb $0x1, (%rax)
jmp 0x12d6
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xda5(%rip), %rsi       # 0x2007
callq 0x1070
cmpl $0x0, %eax
jne 0x1276
movq -0x8(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x12d4
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xd81(%rip), %rsi       # 0x200a
callq 0x1070
cmpl $0x0, %eax
jne 0x129d
movq -0x8(%rbp), %rax
movb $0x1, 0x2(%rax)
jmp 0x12d2
movq 0x2d54(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xd4c(%rip), %rsi       # 0x200d
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10a0
jmp 0x12d4
jmp 0x12d6
jmp 0x1302
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x10(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x10(%rsi)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1304
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1202
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_normalize_P
void vl_aib_normalize_P (double * P, vl_uint nelem)
{
    vl_uint i;
    double sum = 0;
    for(i=0; i<nelem; i++)
        sum += P[i];
    for(i=0; i<nelem; i++)
        P[i] /= sum;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x9d9b
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x18(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x9d6a
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jae 0x9dd7
movsd -0x18(%rsp), %xmm1
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x9da3
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_new_nodelist
vl_uint *vl_aib_new_nodelist (vl_uint nentries)
{
    vl_uint * nodelist = vl_malloc(sizeof(vl_uint)*nentries);
    vl_uint n;
    for(n=0; n<nentries; n++)
        nodelist[n] = n;

    return nodelist;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x9660
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x9e2b
movl 0x4(%rsp), %edx
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x9e04
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_new_Px
double * vl_aib_new_Px(double * Pcx, vl_uint nvalues, vl_uint nlabels)
{
    double * Px = vl_malloc(sizeof(double)*nvalues);
    vl_uint r,c;
    for(r=0; r<nvalues; r++)
    {
        double sum = 0;
        for(c=0; c<nlabels; c++)
            sum += Pcx[r*nlabels+c];
        Px[r] = sum;
    }
    return Px;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x9660
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x9ee1
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x9ec1
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
imull 0x18(%rsp), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x9e87
movsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9e6d
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_new_Pc
double * vl_aib_new_Pc(double * Pcx, vl_uint nvalues, vl_uint nlabels)
{
    double * Pc = vl_malloc(sizeof(double)*nlabels);
    vl_uint r, c;
    for(c=0; c<nlabels; c++)
    {
        double sum = 0;
        for(r=0; r<nvalues; r++)
            sum += Pcx[r*nlabels+c];
        Pc[c] = sum;
    }
    return Pc;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x9660
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x9f91
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x9f71
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
imull 0x18(%rsp), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x9f37
movsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x9f1d
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_min_beta
void vl_aib_min_beta
(VlAIB * aib, vl_uint * besti, vl_uint * bestj, double * minbeta)
{
    vl_uint i;
    *minbeta = aib->beta[0];
    *besti   = 0;
    *bestj   = aib->bidx[0];

    for(i=0; i<aib->nentries; i++)
    {
        if(aib->beta[i] < *minbeta)
        {
            *minbeta = aib->beta[i];
            *besti = i;
            *bestj = aib->bidx[i];
        }
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl (%rax), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xa06a
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm1
movq -0x20(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa05b
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movl -0x24(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rsp), %ecx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0xa05d
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x9fef
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_calculate_information
void vl_aib_calculate_information(VlAIB * aib, double * I, double * H)
{
    vl_uint r, c;
    *H = 0;
    *I = 0;

    /*
     * H(x)   = - sum_x p(x)    \ log p(x)
     * I(x,c) =   sum_xc p(x,c) \ log (p(x,c) / p(x)p(c))
     */

    /* for each entry */
    for(r = 0 ; r< aib->nentries ; r++) {

      if (aib->Px[r] == 0) continue ;
      *H += -log(aib->Px[r]) * aib->Px[r] ;

      for(c=0; c<aib->nlabels; c++) {
        if (aib->Pcx[r*aib->nlabels+c] == 0) continue;
        *I += aib->Pcx[r*aib->nlabels+c] *
          log (aib->Pcx[r*aib->nlabels+c] / (aib->Px[r]*aib->Pc[c])) ;
      }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0xa90a
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa7b7
jp 0xa7b7
jmp 0xa8fa
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm0
callq 0x94c0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm2
movq 0x10(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jae 0xa8f8
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rdx
imull 0x4c(%rdx), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa857
jp 0xa857
jmp 0xa8e8
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rdx
imull 0x4c(%rdx), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rdx
imull 0x4c(%rdx), %ecx
addl 0x8(%rsp), %ecx
movl %ecx, %ecx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0xc(%rsp), %ecx
movsd (%rax,%rcx,8), %xmm1
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x8(%rsp), %ecx
mulsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
callq 0x94c0
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xa814
jmp 0xa8fa
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xa783
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/aib.c
// Function: vl_aib_delete
void
vl_aib_delete (VlAIB * aib)
{
  if (aib) {
    if (aib-> nodes)   vl_free (aib-> nodes);
    if (aib-> beta)    vl_free (aib-> beta);
    if (aib-> bidx)    vl_free (aib-> bidx);
    if (aib-> which)   vl_free (aib-> which);
    if (aib-> Px)      vl_free (aib-> Px);
    if (aib-> Pc)      vl_free (aib-> Pc);
    if (aib-> parents) vl_free (aib-> parents);
    if (aib-> costs)   vl_free (aib-> costs);

    vl_free (aib) ;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0xac17
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xab66
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0xab7e
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xab96
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xabae
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xabc6
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xabde
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0xabf6
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0xac0e
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x9620
movq (%rsp), %rdi
callq 0x9620
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/array.c
// Function: vl_array_get_num_elements
VL_EXPORT vl_size
vl_array_get_num_elements (VlArray const * self)
{
  vl_size numElements = 1 ;
  vl_uindex k ;
  if (self->numDimensions == 0) {
    return 0 ;
  }
  for (k = 0 ; k < self->numDimensions ; ++k) {
    numElements *= self->dimensions[k] ;
  }
  return numElements ;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x1, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xae25
movq $0x0, -0x8(%rsp)
jmp 0xae72
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xae68
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
movq 0x18(%rax,%rcx,8), %rax
imulq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0xae2e
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/array.c
// Function: vl_array_init
VL_EXPORT VlArray *
vl_array_init (VlArray* self, vl_type type,
               vl_size numDimensions, vl_size const * dimensions)
{
  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
  self->type = type ;
  self->numDimensions = numDimensions ;
  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
  self->data = vl_malloc(vl_get_type_size(type) * vl_array_get_num_elements (self)) ;
  self->isEnvelope = VL_FALSE ;
  self->isSparse = VL_FALSE ;
  return self ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
callq 0x9640
movl 0x1c(%rsp), %edi
callq 0xaf30
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x9270
movq (%rsp), %rdi
imulq %rax, %rdi
callq 0x9660
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/generic.h
// Function: vl_get_type_size
VL_INLINE vl_size
vl_get_type_size (vl_type type)
{
  vl_size dataSize = 0 ;
  switch (type) {
    case VL_TYPE_DOUBLE : dataSize = sizeof(double) ; break ;
    case VL_TYPE_FLOAT  : dataSize = sizeof(float) ; break ;
    case VL_TYPE_INT64  : case VL_TYPE_UINT64 : dataSize = sizeof(vl_int64) ; break ;
    case VL_TYPE_INT32  : case VL_TYPE_UINT32 : dataSize = sizeof(vl_int32) ; break ;
    case VL_TYPE_INT16  : case VL_TYPE_UINT16 : dataSize = sizeof(vl_int16) ; break ;
    case VL_TYPE_INT8   : case VL_TYPE_UINT8  : dataSize = sizeof(vl_int8)  ; break ;
    default:
      abort() ;
  }
  return dataSize ;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movl 0x14(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x9, %eax
ja 0xafa8
movq (%rsp), %rax
leaq 0x4e0f3(%rip), %rcx     # 0x59050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x8, 0x8(%rsp)
jmp 0xafad
movq $0x4, 0x8(%rsp)
jmp 0xafad
movq $0x8, 0x8(%rsp)
jmp 0xafad
movq $0x4, 0x8(%rsp)
jmp 0xafad
movq $0x2, 0x8(%rsp)
jmp 0xafad
movq $0x1, 0x8(%rsp)
jmp 0xafad
callq 0x90b0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/array.c
// Function: vl_array_init_envelope
VL_EXPORT VlArray *
vl_array_init_envelope (VlArray * self, void * data, vl_type type,
                        vl_size numDimensions, vl_size const * dimensions)
{
  assert (numDimensions <= VL_ARRAY_MAX_NUM_DIMENSIONS) ;
  self->type = type ;
  self->numDimensions = numDimensions ;
  memcpy(self->dimensions, dimensions, sizeof(vl_size) * numDimensions) ;
  self->data = data ;
  self->isEnvelope = VL_TRUE ;
  self->isSparse = VL_FALSE ;
  return self ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
callq 0x9640
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x20(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/array.c
// Function: vl_array_dealloc
VL_EXPORT void
vl_array_dealloc (VlArray * self)
{
  if (! self->isEnvelope) {
    if (self->data) {
      vl_free(self->data) ;
      self->data = NULL ;
    }
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xb12e
movq (%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0xb12c
movq (%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x98(%rax)
jmp 0xb12e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_resize_buffer
static int
_vl_resize_buffer (void ** buffer, vl_size * bufferSize, vl_size targetSize) {
  void * newBuffer ;
  if (*buffer == NULL) {
    *buffer = vl_malloc(targetSize) ;
    if (*buffer) {
      *bufferSize = targetSize ;
      return VL_ERR_OK ;
    } else {
      *bufferSize = 0 ;
      return VL_ERR_ALLOC ;
    }
  }
  newBuffer = vl_realloc(*buffer, targetSize) ;
  if (newBuffer) {
    *buffer = newBuffer ;
    *bufferSize = targetSize ;
    return VL_ERR_OK ;
  } else {
    return VL_ERR_ALLOC ;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbc7b
movq 0x8(%rsp), %rdi
callq 0x9660
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbc65
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0xbcc3
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movl $0x2, 0x24(%rsp)
jmp 0xbcc3
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x9460
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xbcbb
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0xbcc3
movl $0x2, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_reset
void
vl_covdet_reset (VlCovDet * self)
{
  if (self->features) {
    vl_free(self->features) ;
    self->features = NULL ;
  }
  if (self->css) {
    vl_scalespace_delete(self->css) ;
    self->css = NULL ;
  }
  if (self->gss) {
    vl_scalespace_delete(self->gss) ;
    self->gss = NULL ;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0xda49
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x9620
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xda6d
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x9990
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0xda8e
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x9990
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_append_feature
int
vl_covdet_append_feature (VlCovDet * self, VlCovDetFeature const * feature)
{
  vl_size requiredSize ;
  assert(self) ;
  assert(feature) ;
  self->numFeatures ++ ;
  requiredSize = self->numFeatures * sizeof(VlCovDetFeature) ;
  if (requiredSize > self->numFeatureBufferSize) {
    int err = _vl_resize_buffer((void**)&self->features, &self->numFeatureBufferSize,
                                (self->numFeatures + 1000) * sizeof(VlCovDetFeature)) ;
    if (err) {
      self->numFeatures -- ;
      return err ;
    }
  }
  self->features[self->numFeatures - 1] = *feature ;
  return VL_ERR_OK ;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rax)
movq 0x18(%rsp), %rax
imulq $0x28, 0x58(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jbe 0xdb60
movq 0x18(%rsp), %rdi
addq $0x50, %rdi
movq 0x18(%rsp), %rsi
addq $0x60, %rsi
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
addq $0x3e8, %rax            # imm = 0x3E8
imulq $0x28, %rax, %rdx
callq 0xbc10
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xdb5e
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x58(%rax)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0xdb94
jmp 0xdb60
movq 0x18(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
subq $0x1, %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movl $0x28, %edx
callq 0x9640
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_extract_patch_for_frame
vl_bool
vl_covdet_extract_patch_for_frame (VlCovDet * self,
                                   float * patch,
                                   vl_size resolution,
                                   double extent,
                                   double sigma,
                                   VlFrameOrientedEllipse frame)
{
  double A[2*2] = {frame.a11, frame.a21, frame.a12, frame.a22} ;
  double T[2] = {frame.x, frame.y} ;
  double D[4], U[4], V[4] ;

  vl_svd2(D, U, V, A) ;

  return vl_covdet_extract_patch_helper
  (self, NULL, NULL, patch, resolution, extent, sigma, A, T, D[0], D[3]) ;
}

// Assembly:
subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movsd %xmm0, 0xa8(%rsp)
movsd %xmm1, 0xa0(%rsp)
movss 0x8(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
movss 0x10(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x88(%rsp)
movss 0xc(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
movss 0x14(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x98(%rsp)
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
movss 0x4(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x78(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x80(%rsp), %rcx
callq 0x9730
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rcx
movq 0xb0(%rsp), %r8
movsd 0xa8(%rsp), %xmm0
movsd 0xa0(%rsp), %xmm1
leaq 0x80(%rsp), %r9
leaq 0x70(%rsp), %rax
movsd 0x50(%rsp), %xmm2
movsd 0x68(%rsp), %xmm3
xorl %edx, %edx
movq %rdx, %rsi
movq %rax, (%rsp)
callq 0xfdd0
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/vl/covdet.c
// Function: vl_covdet_extract_affine_shape
void
vl_covdet_extract_affine_shape (VlCovDet * self)
{
  vl_index i, j = 0 ;
  vl_size numFeatures = vl_covdet_get_num_features(self) ;
  VlCovDetFeature * feature = vl_covdet_get_features(self);
  for (i = 0 ; i < (signed)numFeatures ; ++i) {
    int status ;
    VlFrameOrientedEllipse adapted ;
    status = vl_covdet_extract_affine_shape_for_frame(self, &adapted, feature[i].frame) ;
    if (status == VL_ERR_OK) {
      feature[j] = feature[i] ;
      feature[j].frame = adapted ;
      ++ j ;
    }
  }
  self->numFeatures = j ;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0x9390
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
callq 0x9150
movq %rax, 0x50(%rsp)
movq $0x0, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq 0x58(%rsp), %rcx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x12180
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rax
imulq $0x28, 0x68(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
leaq 0x34(%rsp), %rsi
leaq 0x18(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x98c0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x1216b
movq 0x50(%rsp), %rdi
imulq $0x28, 0x60(%rsp), %rax
addq %rax, %rdi
movq 0x50(%rsp), %rsi
imulq $0x28, 0x68(%rsp), %rax
addq %rax, %rsi
movl $0x28, %edx
callq 0x9640
movq 0x50(%rsp), %rax
imulq $0x28, 0x60(%rsp), %rcx
addq %rcx, %rax
movq 0x34(%rsp), %rcx
movq %rcx, (%rax)
movq 0x3c(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x44(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x1216d
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x12099
movq 0x60(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, 0x58(%rax)
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)