LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_open
FILE* file_open(char *c_file, const char * c_mode){
	
	FILE* f_in;
	
	f_in = fopen(c_file, c_mode);
	if (!f_in) perror ("file_open");

	fseek(f_in, 0, SEEK_SET);
	
return f_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4114
leaq 0x8661(%rip), %rdi      # 0xc770
callq 0x21e0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x21b0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_load
char* file_load(FILE* f_in) {
	
	size_t len = 0;
	ssize_t size = 0;
 	char *c_aux = NULL;
 	
 	/*Read one line*/
 	size = getline(&c_aux, &len, f_in);
 	if (size == -1) perror("file_load");

 	/*Copy line to c_buffer*/
 	char *c_buffer = (char*) malloc((size+1)*sizeof(char));
	strncpy(c_buffer, c_aux, size);

	c_buffer[size-1] = END_MARKER;
	c_buffer[size] = '\0';

	free(c_aux);

return c_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x2220
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x41ec
leaq 0x859e(%rip), %rdi      # 0xc785
callq 0x21e0
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2050
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x24, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0xb810
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: load_multiple_txt
char** load_multiple_txt(FILE* f_in, size_t *k, size_t *n) {

  int n_alloc = N_ALLOC;
	char **c_buffer = (char**) malloc(n_alloc*sizeof(char*));

	size_t i;
 	for(i=0; i<*k; i++){

		size_t len = 0; c_buffer[i] = NULL;		
		ssize_t size = getline(&c_buffer[i], &len, f_in);
		if (size == -1){
	      		free(c_buffer[i]);
			*k = i;
			break;		
		}
		c_buffer[i][size-1] = 0;

		(*n) += size;

		if(i==n_alloc-1){
			n_alloc+=N_ALLOC;
      			c_buffer = (char**) realloc(c_buffer, n_alloc*sizeof(char*));
		}
	}

return c_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x800, -0x1c(%rbp)     # imm = 0x800
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0xb6a0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x435d
movq $0x0, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x2220
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
jne 0x42f2
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xb810
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x435d
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x40(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0x434a
movl -0x1c(%rbp), %eax
addl $0x800, %eax            # imm = 0x800
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x3, %rsi
callq 0xb990
movq %rax, -0x28(%rbp)
jmp 0x434c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4284
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: load_multiple_fastq
char** load_multiple_fastq(FILE* f_in, size_t *k, size_t *n){

	int n_alloc = N_ALLOC;
	char **c_buffer = (char**) malloc(n_alloc*sizeof(char*));

  	size_t len = 0;
	char *buf = NULL;
	size_t i;
 	for(i=0; i<*k; i++){

		len = 0; buf = NULL;
		ssize_t size = getline(&buf, &len, f_in); // @'s line
		free(buf);
		if (size <= 1){
			*k = i;
			break;		
		}

		len = 0; c_buffer[i] = NULL;
		size = getline(&c_buffer[i], &len, f_in); // read line
		c_buffer[i][size-1] = 0;

    		(*n) += size;

		len = 0; buf = NULL;
		getline(&buf, &len, f_in); // +'s line
		free(buf);
		len = 0; buf = NULL;
		getline(&buf, &len, f_in); // @'s line
		free(buf);

		if(i==n_alloc-1){
			n_alloc+=N_ALLOC;
     			c_buffer = (char**) realloc(c_buffer, n_alloc*sizeof(char*));
		}
	}

return c_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x800, -0x1c(%rbp)     # imm = 0x800
movslq -0x1c(%rbp), %rdi
shlq $0x3, %rdi
callq 0xb6a0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x4501
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2220
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb810
cmpq $0x1, -0x48(%rbp)
jg 0x440a
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4501
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x2220
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x48(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2220
movq -0x38(%rbp), %rdi
callq 0xb810
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2220
movq -0x38(%rbp), %rdi
callq 0xb810
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0x44ee
movl -0x1c(%rbp), %eax
addl $0x800, %eax            # imm = 0x800
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
shlq $0x3, %rsi
callq 0xb990
movq %rax, -0x28(%rbp)
jmp 0x44f0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x43b4
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_load_multiple
char** file_load_multiple(char* c_file, size_t *k, size_t *n) {

/* .ext
 * .txt   - strings per line
 * .fasta - strings separated by '>' line
 * .fastq - strings separated by four lines
 */

	FILE* f_in = file_open(c_file, "rb");
	if(!f_in) return 0;

	const char *type = get_filename_ext(c_file);
	char **c_buffer = NULL; // = (char**) malloc(k*sizeof(char*));

	if(*k==0) *k=INT_MAX;

	if(strcmp(type,"txt") == 0)
		c_buffer = load_multiple_txt(f_in, k, n);

	else if(strcmp(type,"fasta") == 0)
		c_buffer = load_multiple_fasta(f_in, k, n);

	else if(strcmp(type,"fastq") == 0)
		c_buffer = load_multiple_fastq(f_in, k, n);
	else{
		printf("Error: file not recognized (.txt, .fasta, .fastq)\n");
		return 0;
	}

	fclose(f_in);

return c_buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x8040(%rip), %rsi      # 0xc78f
callq 0x40e0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x476c
movq $0x0, -0x8(%rbp)
jmp 0x4847
movq -0x10(%rbp), %rdi
callq 0x3fc0
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4796
movq -0x18(%rbp), %rax
movq $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
movq -0x30(%rbp), %rdi
leaq 0x7ff1(%rip), %rsi      # 0xc792
callq 0x2150
cmpl $0x0, %eax
jne 0x47c2
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4250
movq %rax, -0x38(%rbp)
jmp 0x4836
movq -0x30(%rbp), %rdi
leaq 0x7fc9(%rip), %rsi      # 0xc796
callq 0x2150
cmpl $0x0, %eax
jne 0x47ee
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4510
movq %rax, -0x38(%rbp)
jmp 0x4834
movq -0x30(%rbp), %rdi
leaq 0x7fa3(%rip), %rsi      # 0xc79c
callq 0x2150
cmpl $0x0, %eax
jne 0x481a
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4370
movq %rax, -0x38(%rbp)
jmp 0x4832
leaq 0x7f81(%rip), %rdi      # 0xc7a2
movb $0x0, %al
callq 0x20e0
movq $0x0, -0x8(%rbp)
jmp 0x4847
jmp 0x4834
jmp 0x4836
movq -0x28(%rbp), %rdi
callq 0x20a0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: mkdir
void mkdir(const char* c_file){
	
	char c_aux[500];
	
	strcpy (c_aux,"mkdir -p ");
	strcat (c_aux, c_file);
			
	system (c_aux);//remove .bin
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
leaq -0x200(%rbp), %rdi
leaq 0x7f58(%rip), %rsi      # 0xc7d5
callq 0x2060
leaq -0x200(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2230
leaq -0x200(%rbp), %rdi
callq 0x20d0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_text_write
int file_text_write(unsigned char *str, size_t n, char* c_file, const char* ext){

	FILE *f_out;
	char *c_out = (char*) malloc((strlen(c_file)+strlen(ext)+3)*sizeof(char));
	
	sprintf(c_out, "%s.%s", c_file, ext);
	f_out = file_open(c_out, "wb");
	
	size_t i;
	for(i=0; i<n;i++) if(str[i]) str[i]--;

	fwrite(str, sizeof(unsigned char), n, f_out);
	
	file_close(f_out);
	free(c_out);

return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x40(%rbp), %rdi
addq %rax, %rdi
addq $0x3, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x7ed6(%rip), %rsi      # 0xc7df
movb $0x0, %al
callq 0x2240
movq -0x30(%rbp), %rdi
leaq 0x7d2f(%rip), %rsi      # 0xc64a
callq 0x40e0
movq %rax, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4965
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4955
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
addb $-0x1, %dl
movb %dl, (%rax,%rcx)
jmp 0x4957
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x492c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x2260
movq -0x28(%rbp), %rdi
callq 0x4130
movq -0x30(%rbp), %rdi
callq 0xb810
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_text_int_write
int file_text_int_write(int_t *str, size_t n, char* c_file, const char* ext){

	FILE *f_out;
	char *c_out = (char*) malloc((strlen(c_file)+strlen(ext))*sizeof(char));
	
	sprintf(c_out, "%s.%s", c_file, ext);
	f_out = file_open(c_out, "wb");
	
	fwrite(str, sizeof(int_t), n, f_out);
	
	file_close(f_out);
	free(c_out);

return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
addq %rax, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x7dea(%rip), %rsi      # 0xc7df
movb $0x0, %al
callq 0x2240
movq -0x30(%rbp), %rdi
leaq 0x7c43(%rip), %rsi      # 0xc64a
callq 0x40e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x4, %esi
callq 0x2260
movq -0x28(%rbp), %rdi
callq 0x4130
movq -0x30(%rbp), %rdi
callq 0xb810
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/file.c
// Function: file_text_read
int_t file_text_read(unsigned char** str, char* c_file, const char* ext){

	FILE *f_in;
	char *c_in = (char*) malloc((strlen(c_file)+strlen(ext))*sizeof(char));
	
	sprintf(c_in, "%s.%s", c_file, ext);
	f_in = file_open(c_in, "rb");

	fseek(f_in, 0L, SEEK_END);
	size_t size = ftell(f_in);
	rewind(f_in);

	int_t n = size/sizeof(unsigned char);

	*str = (unsigned char*) malloc(n*sizeof(unsigned char));
	fread(*str, sizeof(unsigned char), n, f_in);
	
	file_close(f_in);
	free(c_in);

return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq -0x40(%rbp), %rdi
addq %rax, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x7d3e(%rip), %rsi      # 0xc7df
movb $0x0, %al
callq 0x2240
movq -0x28(%rbp), %rdi
leaq 0x7cdc(%rip), %rsi      # 0xc78f
callq 0x40e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21b0
movq -0x20(%rbp), %rdi
callq 0x2170
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %rax
shrq $0x0, %rax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movslq -0x34(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x2080
movq -0x20(%rbp), %rdi
callq 0x4130
movq -0x28(%rbp), %rdi
callq 0xb810
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: rank
int rank(char *T, char c, int i){

  int sum=0;
  int j;

  for(j=0; j<i; j++) if(T[j] <= c) sum++;
  int len = strlen(T);
  for(; j<len; j++) if(T[j] < c) sum++;

return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4c85
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jg 0x4c78
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c7a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c53
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4cc3
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x4cb6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4cb8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4c91
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: bwt_inplace
int bwt_inplace(char *T, int n){

  int p, r=1;
  int i, s;

  for(s=n-3; s>=0; s--){

    p = r+1;//  p = find_sentinel(&T[s]);
    r = rank(&T[s+1], T[s], p);
  
    T[p+s] = T[s]; //replace('$', T[s]);

    for(i=s; i<s+r; i++) 
      T[i] = T[i+1];

    T[s+r] = 0; //END_MARKER;
  }

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x54fd
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x10(%rbp), %edx
movsbl %al, %esi
callq 0x4c30
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
cmpl %ecx, %eax
jge 0x54de
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x54ab
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x544f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: bwt_reverse
char* bwt_reverse(char *bwt, int n){

  char* rev = (char*) malloc((n+1)*sizeof(char));
  int p = 0;

  //backward reconstruction
  int s;
  for(s=n-2; s>=0; s--){

    rev[s] = bwt[p];
    p = rank(bwt, rev[s], p);
  }

  rev[n-1] = 0; //END_MARKER;
  rev[n] = '\0';

return rev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0xc(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x5589
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movl -0x1c(%rbp), %edx
movsbl %al, %esi
callq 0x4c30
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5545
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: get_count
void get_count(char* T, int *C){

  int i;
  for(i=0; i<UCHAR_SIZE; i++) C[i]=0;
  int size = strlen(T);
  for(i=0; i<size; i++) C[(int)T[i]]++;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x55ea
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55c7
movq -0x8(%rbp), %rdi
callq 0x20b0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x562c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55fd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: get_bucket
void get_bucket(int *C, int *B){

  int sum=0;
  int i;
  for(i=0; i<UCHAR_SIZE; i++){
      B[i] = sum;
      sum+=C[i];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x568d
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x565a
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/bwt.c
// Function: find_sentinel
int find_sentinel(char *T){

  int i;
  for(i=0; i<strlen(T); i++)
    if(T[i] == 0) return i; //END_MARKER

return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x56e6
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x56d9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x56ed
jmp 0x56db
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56a3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/suffix-array.c
// Function: suffix_array_write
int suffix_array_write(int_t *SA, int_t n, char* c_file, const char* ext){

  FILE *f_out;
  char *c_out = malloc((strlen(c_file)+strlen(ext)+3)*sizeof(char));
  
  sprintf(c_out, "%s.%s", c_file, ext);
  f_out = file_open(c_out, "wb");
  
  fwrite(SA, sizeof(int_t), n, f_out);
  
  file_close(f_out);
  free(c_out);

return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20b0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20b0
movq -0x38(%rbp), %rdi
addq %rax, %rdi
addq $0x3, %rdi
shlq $0x0, %rdi
callq 0xb6a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x7087(%rip), %rsi      # 0xc7df
movb $0x0, %al
callq 0x2240
movq -0x30(%rbp), %rdi
leaq 0x6ee0(%rip), %rsi      # 0xc64a
callq 0x40e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x4, %esi
callq 0x2260
movq -0x28(%rbp), %rdi
callq 0x4130
movq -0x30(%rbp), %rdi
callq 0xb810
movl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_pair_init
int stack_pair_init(stack_pair *S, int_t size){

	S->array = (s_pair*) malloc(size*sizeof(s_pair));	
	if(S->array==NULL) return 0;

	S->size = size;
	S->top = 0;

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0xb6a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5e59
movl $0x0, -0x4(%rbp)
jmp 0x5e75
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_pair_push
void stack_pair_push(stack_pair *S, int_t i, int_t j){

	if(S->top==S->size){
		S->size += STACK_SIZE;
		S->array = (s_pair*) realloc(S->array, S->size*sizeof(s_pair));
	} 

	S->array[S->top].i = i;
	S->array[S->top].j = j;

	(S->top)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x5ed6
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rcx
addq $0x500, %rcx            # imm = 0x500
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0xb990
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,8)
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_pair_top
s_pair stack_pair_top(stack_pair *S){

	s_pair aux;
	aux.i = S->array[S->top-1].i;
	aux.j = S->array[S->top-1].j; 

return aux;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,8), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_pair_print
void stack_pair_print(stack_pair *S){

	int_t i;

	for(i=S->top-1; i>0; i--)
		printf("%d\t(%d, %d)\n", i, S->array[i].i, S->array[i].j);
	
	printf("%d\t(%d, %d)\n", i, S->array[i].i, S->array[i].j);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x5fe8
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %ecx
leaq 0x684f(%rip), %rdi      # 0xc825
movb $0x0, %al
callq 0x20e0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5fa9
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,8), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,8), %ecx
leaq 0x6816(%rip), %rdi      # 0xc825
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_init
int stack_init(stack *S, int_t size){

	S->array = (int_t*) malloc(size*sizeof(int_t));	
	if(S->array==NULL) return 0;

	S->size = size;
	S->top = 0;

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq $0x2, %rdi
callq 0xb6a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6059
movl $0x0, -0x4(%rbp)
jmp 0x6075
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_push
void stack_push(stack *S, int_t i){

	if(S->top==S->size){
		S->size += STACK_SIZE;
		S->array = (int_t*) realloc(S->array, S->size*sizeof(int_t));
	} 

	S->array[S->top] = i;

	(S->top)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x60d3
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rcx
addq $0x500, %rcx            # imm = 0x500
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x2, %rsi
callq 0xb990
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: stack_print
void stack_print(stack *S){

	int_t i;

	for(i=S->top-1; i>0; i--)
		printf("%d\t(%d)\n", i, S->array[i]);
	
	printf("%d\t(%d)\n", i, S->array[i]);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x61a9
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x669b(%rip), %rdi      # 0xc832
movb $0x0, %al
callq 0x20e0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6179
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x6671(%rip), %rdi      # 0xc832
movb $0x0, %al
callq 0x20e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: find_symbol
unsigned char find_symbol(int_t pos, int_t* F, unsigned char* Alpha, int_t n){

	//binary search
	int_t a=0;
	int_t b=n-2;

	int_t i=0;
	while(a<=b){
		i=a+(b-a)/2;
		if(pos>=F[i] && pos<F[i+1]){
			return Alpha[i];
		}
		if(pos>F[i]) a=i+1;
		else b=i-1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0x664d
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
subl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x6624
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x28(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x6624
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
jmp 0x6651
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x28(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x663f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6648
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x65c9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: compute_nsv
int compute_nsv(int_t* NSV, int_t *array, int_t n){

	stack S;
	S.top=0; S.size=STACK_SIZE;
	stack_init(&S,STACK_SIZE);
	stack_push(&S, 0);//(idx, value)=(pos, step)

	int_t i;
  for(i=n-1; i>0; i--){

    NSV[i] = stack_top(&S);
		
    if(array[i-1]>array[i]){
      stack_push(&S, i);
    }
    else{
      //while(stack_top(&S).j >= array[i-1]) stack_pop(&S);
      while(array[stack_top(&S)] >= array[i-1]) stack_pop(&S);
    }
  }

  NSV[0] = stack_top(&S);
  free(S.array);

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x500, -0x1c(%rbp)     # imm = 0x500
leaq -0x28(%rbp), %rdi
movl $0x500, %esi            # imm = 0x500
callq 0x6020
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x6080
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x717c
leaq -0x28(%rbp), %rdi
callq 0x6100
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x712e
movl -0x2c(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x6080
jmp 0x716c
jmp 0x7130
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6100
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movl -0x2c(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x716a
leaq -0x28(%rbp), %rdi
callq 0x6130
jmp 0x7130
jmp 0x716c
jmp 0x716e
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x70e3
leaq -0x28(%rbp), %rdi
callq 0x6100
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rdi
callq 0xb810
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: compute_lyndon_max_lyn
int compute_lyndon_max_lyn(unsigned char *s, int_t *A, int_t n){

int_t j;

	#if TIME
		time_t t_total= 0;clock_t c_total= 0;
		tstart(&t_total, &c_total); 
	#endif

	int_t *LA = A;
	for(j=0; j < n-1; j++){	

		int_t i = j+1;
		int_t max = j+1;

		while(i<n){

			int_t k = 0;
			while(s[j+k]==s[i+k]) k++;

			if(s[j+k]<s[i+k]){
				i+=k+1;
				max=i;
			}
			else{
				LA[j]=max-j;	
				break;
			}
		}
	}
	LA[n-1]=1;

	#if TIME
		printf("TOTAL:\n");
		fprintf(stderr,"%.6lf\n", tstop(t_total, c_total)); 
	#endif

return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x61d0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x73e8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x73d8
movl $0x0, -0x3c(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x34(%rbp), %edx
addl -0x3c(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x7386
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7355
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl -0x3c(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movl -0x34(%rbp), %edx
addl -0x3c(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jge 0x73c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x73d3
movl -0x38(%rbp), %edx
subl -0x18(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x73d8
jmp 0x7342
jmp 0x73da
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x731f
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,4)
leaq 0x50cf(%rip), %rdi      # 0xc4d2
movb $0x0, %al
callq 0x20e0
movq 0x7be7(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6210
movq -0x48(%rbp), %rdi
leaq 0x50aa(%rip), %rsi      # 0xc4da
movb $0x1, %al
callq 0x2160
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/external/sacak-lyndon.c
// Function: getBuckets_k
void getBuckets_k(int_t *s, 
  int_t *bkt, int_t n,
  unsigned int K, int end, int cs) { 
  int_t i, sum=0;
  
  // clear all buckets .
  for(i=0; i<K; i++) bkt[i]=0; 
  
  // compute the size of each bucket .
  for(i=0; i<n; i++) bkt[chr(i)]++; 
  
  for(i=0; i<K; i++) { 
    sum+=bkt[i]; 
    bkt[i]=end ? sum-1 : sum-bkt[i]; 
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x862a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8608
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8688
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0x4, %rax
jne 0x865b
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
jmp 0x866a
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8631
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x86e3
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x86b9
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x86ca
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x24(%rbp), %rdx
subl (%rcx,%rdx,4), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x868f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/external/sacak-lyndon.c
// Function: putSuffix0
void putSuffix0(int_t *SA, 
  int_t *s, int_t *bkt, 
  int_t n, unsigned int K, int_t n1, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  // put the suffixes into their buckets.
  for(i=n1-1; i>0; i--) {
    j=SA[i]; SA[i]=0;
    SA[bkt[chr(j)]--]=j;
  }
  SA[0]=n-1; // set the single sentinel suffix.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl 0x10(%rbp), %r9d
movl $0x1, %r8d
callq 0x85e0
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x87d1
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x4, %rax
jne 0x878f
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
jmp 0x879e
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movl -0x44(%rbp), %edx
movq -0x38(%rbp), %rsi
movl -0x48(%rbp), %ecx
movslq %ecx, %rdi
movl (%rsi,%rdi,4), %ecx
movl %ecx, %r8d
addl $-0x1, %r8d
movl %r8d, (%rsi,%rdi,4)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8738
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/external/sacak-lyndon.c
// Function: getSAlms
void getSAlms(int_t *SA, 
  int_t *s, 
  int_t *s1, int_t n, 
  int_t n1, int level, int cs) {
  int_t i, j, cur_t, succ_t;

  j=n1-1; s1[j--]=n-1;
  succ_t=0; // s[n-2] must be L-type
  for(i=n-2; i>0; i--) {
    cur_t=(chr(i-1)<chr(i) ||
          (chr(i-1)==chr(i) && succ_t==1))?1:0;
    if(cur_t==0 && succ_t==1) s1[j--]=i;
    succ_t=cur_t;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %edx
subl $0x1, %edx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x34(%rbp)
movl -0x1c(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0xaa9d
movslq 0x10(%rbp), %rax
cmpq $0x4, %rax
jne 0xa97b
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0xa98f
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x4, %rax
jne 0xa9af
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0xa9be
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x41(%rbp)
jl 0xaa52
movslq 0x10(%rbp), %rax
cmpq $0x4, %rax
jne 0xa9f0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x48(%rbp)
jmp 0xaa04
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4c(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x4, %rax
jne 0xaa24
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x50(%rbp)
jmp 0xaa33
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x50(%rbp)
movl -0x4c(%rbp), %ecx
movl -0x50(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x51(%rbp)
jne 0xaa4c
cmpl $0x1, -0x34(%rbp)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jne 0xaa89
cmpl $0x1, -0x34(%rbp)
jne 0xaa89
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, -0x2c(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xa952
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]lyndon-array/external/malloc_count/malloc_count.c
// Function: finish
static __attribute__((destructor)) void finish(void)
{
    fprintf(stdout, PPREFIX
            "exiting, total: %'lld, peak: %'lld, current: %'lld\n",
            total, peak, curr);

    fprintf(stderr, "%'lld\n", peak);

    //fprintf(stderr, "%'lld\t%'lld\t%'lld\n", total, peak, curr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x335d(%rip), %rax      # 0xefc8
movq (%rax), %rdi
movq 0x10352b(%rip), %rdx    # 0x10f1a0
movq 0x34ec(%rip), %rcx      # 0xf168
movq 0x34dd(%rip), %r8       # 0xf160
leaq 0xd50(%rip), %rsi       # 0xc9da
movb $0x0, %al
callq 0x2160
movq 0x3360(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq 0x34c6(%rip), %rdx      # 0xf168
leaq 0xd6f(%rip), %rsi       # 0xca18
movb $0x0, %al
callq 0x2160
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_load_file
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
{
  long size = lodepng_filesize(filename);
  if (size < 0) return 78;
  *outsize = (size_t)size;

  *out = (unsigned char*)lodepng_malloc((size_t)size);
  if(!(*out) && size > 0) return 83; /*the above malloc failed*/

  return lodepng_buffer_file(*out, (size_t)size, filename);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1310
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x12b1
movl $0x4e, -0x4(%rbp)
jmp 0x1300
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x13b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12e9
cmpq $0x0, -0x28(%rbp)
jle 0x12e9
movl $0x53, -0x4(%rbp)
jmp 0x1300
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_filesize
static long lodepng_filesize(const char* filename)
{
  FILE* file;
  long size;
  file = fopen(filename, "rb");
  if(!file) return -1;

  if(fseek(file, 0, SEEK_END) != 0)
  {
    fclose(file);
    return -1;
  }

  size = ftell(file);
  /* It may give LONG_MAX as directory size, this is invalid for us. */
  if(size == LONG_MAX) size = -1;

  fclose(file);
  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x140f9(%rip), %rsi     # 0x15420
callq 0x1110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1341
movq $-0x1, -0x8(%rbp)
jmp 0x13a1
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10f0
cmpl $0x0, %eax
je 0x136b
movq -0x18(%rbp), %rdi
callq 0x1050
movq $-0x1, -0x8(%rbp)
jmp 0x13a1
movq -0x18(%rbp), %rdi
callq 0x10b0
movq %rax, -0x20(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x20(%rbp)
jne 0x1390
movq $-0x1, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1050
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_buffer_file
static unsigned lodepng_buffer_file(unsigned char* out, size_t size, const char* filename)
{
  FILE* file;
  size_t readsize;
  file = fopen(filename, "rb");
  if(!file) return 78;

  readsize = fread(out, 1, size, file);
  fclose(file);

  if (readsize != size) return 78;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x14031(%rip), %rsi     # 0x15420
callq 0x1110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1408
movl $0x4e, -0x4(%rbp)
jmp 0x1445
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1040
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1050
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x143e
movl $0x4e, -0x4(%rbp)
jmp 0x1445
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_save_file
unsigned lodepng_save_file(const unsigned char* buffer, size_t buffersize, const char* filename)
{
  FILE* file;
  file = fopen(filename, "wb" );
  if(!file) return 79;
  fwrite((char*)buffer , 1 , buffersize, file);
  fclose(file);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x130c6(%rip), %rsi     # 0x14535
callq 0x1110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1488
movl $0x4f, -0x4(%rbp)
jmp 0x14ae
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x1130
movq -0x28(%rbp), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)