LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_unary_get_signature
static fin_str_t* fin_mod_unary_get_signature(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_unary_expr_t* unary_expr) {
    char sign[128];
    sign[0] = '\0';
    switch (unary_expr->op) {
        case fin_ast_unary_type_pos:  strcat(sign, "__op_pos"); break;
        case fin_ast_unary_type_neg:  strcat(sign, "__op_neg"); break;
        case fin_ast_unary_type_not:  strcat(sign, "__op_not"); break;
        case fin_ast_unary_type_bnot: strcat(sign, "__op_bnot"); break;
        case fin_ast_unary_type_inc:  strcat(sign, "__op_inc"); break;
        case fin_ast_unary_type_dec:  strcat(sign, "__op_dec"); break;
    }
    strcat(sign, "(");
    strcat(sign, fin_str_cstr(fin_mod_resolve_type(ctx, cmp, unary_expr->expr)));
    strcat(sign, ")");
    return fin_str_create(ctx, sign, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, -0xa0(%rbp)
movl 0x4(%rdx), %eax
cmpq $0x5, %rax
ja 0x791c
leaq 0x2b60(%rip), %rcx      # 0xa3c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x736f705f706f5f5f, %rcx # imm = 0x736F705F706F5F5F
jmp 0x790c
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x636e695f706f5f5f, %rcx # imm = 0x636E695F706F5F5F
jmp 0x790c
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x746f6e5f706f5f5f, %rcx # imm = 0x746F6E5F706F5F5F
jmp 0x790c
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x6f6e625f706f5f5f, %rcx # imm = 0x6F6E625F706F5F5F
movq %rcx, -0xa0(%rbp,%rax)
movw $0x74, -0x98(%rbp,%rax)
jmp 0x791c
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x67656e5f706f5f5f, %rcx # imm = 0x67656E5F706F5F5F
jmp 0x790c
leaq -0xa0(%rbp), %rdi
callq 0x3100
movabsq $0x6365645f706f5f5f, %rcx # imm = 0x6365645F706F5F5F
movq %rcx, -0xa0(%rbp,%rax)
movb $0x0, -0x98(%rbp,%rax)
leaq -0xa0(%rbp), %r12
movq %r12, %rdi
callq 0x3100
movw $0x28, -0xa0(%rbp,%rax)
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x754c
movq %rax, %rdi
callq 0x83b1
movq %r12, %rdi
movq %rax, %rsi
callq 0x3280
movq %r12, %rdi
callq 0x3100
movw $0x29, -0xa0(%rbp,%rax)
movq %rbx, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8040
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_invoke_get_signature
static fin_str_t* fin_mod_invoke_get_signature(fin_ctx_t* ctx, fin_mod_compiler_t* cmp, fin_ast_invoke_expr_t* expr) {
    char signature[128];
    signature[0] = '\0';
    if (expr->id->type == fin_ast_expr_type_id) {
        fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)expr->id;
        if (id_expr->primary && id_expr->primary->type == fin_ast_expr_type_id) {
            fin_ast_id_expr_t* prim_id_expr = (fin_ast_id_expr_t*)id_expr->primary;
            strcat(signature, fin_str_cstr(prim_id_expr->name));
            strcat(signature, ".");
        }
        strcat(signature, fin_str_cstr(id_expr->name));
    }
    strcat(signature, "(");
    for (fin_ast_arg_expr_t* e = expr->args; e; e = e->next) {
        if (e != expr->args)
            strcat(signature, ",");
        fin_str_t* arg_type = fin_mod_resolve_type(ctx, cmp, &e->base);
        strcat(signature, fin_str_cstr(arg_type));
        fin_str_destroy(ctx, arg_type);
    }
    strcat(signature, ")");
    return fin_str_create(ctx, signature, -1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
movb $0x0, -0xb0(%rbp)
movq 0x8(%rdx), %r15
cmpl $0x0, (%r15)
jne 0x7d19
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x7d01
cmpl $0x0, (%rax)
jne 0x7d01
movq 0x10(%rax), %rdi
callq 0x83b1
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x3280
movq %r12, %rdi
callq 0x3100
movw $0x2e, -0xb0(%rbp,%rax)
movq 0x10(%r15), %rdi
callq 0x83b1
leaq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x3280
leaq -0xb0(%rbp), %rdi
callq 0x3100
movw $0x28, -0xb0(%rbp,%rax)
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x7d91
leaq -0xb0(%rbp), %r13
cmpq 0x10(%r14), %r12
je 0x7d57
movq %r13, %rdi
callq 0x3100
movw $0x2c, -0xb0(%rbp,%rax)
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x754c
movq %rax, %r15
movq %rax, %rdi
callq 0x83b1
movq %r13, %rdi
movq %rax, %rsi
callq 0x3280
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8217
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x7d3f
leaq -0xb0(%rbp), %r14
movq %r14, %rdi
callq 0x3100
movw $0x29, -0xb0(%rbp,%rax)
movq %rbx, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x8040
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_mod.c
// Function: fin_mod_find_type
static fin_mod_type_t* fin_mod_find_type(fin_ctx_t* ctx, fin_mod_t* mod, fin_str_t* name) {
    for (int32_t i=0; i<mod->types_count; i++) {
        if (mod->types[i].name == name)
            return &mod->types[i];
    }
    fin_mod_t* m = ctx->mod;
    while (m) {
        for (int32_t i=0; i<m->types_count; i++) {
            if (m->types[i].name == name)
                return &m->types[i];
        }
        m = m->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x28(%rsi), %rcx
testq %rcx, %rcx
jle 0x7deb
movq 0x8(%rsi), %rax
cmpq %rdx, (%rax)
je 0x7e17
addq $0x18, %rax
decq %rcx
jne 0x7ddd
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x7e15
movslq 0x28(%rcx), %rsi
testq %rsi, %rsi
jle 0x7e0f
movq 0x8(%rcx), %rax
cmpq %rdx, (%rax)
je 0x7e17
addq $0x18, %rax
decq %rsi
jne 0x7e01
movq 0x40(%rcx), %rcx
jmp 0x7def
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_resize
void fin_str_resize(fin_str_pool_t* pool, int32_t capacity) {
    fin_str_pool_t new_pool;
    new_pool.entries = (fin_str_entry_t*)pool->alloc(NULL, sizeof(fin_str_entry_t) * capacity);
    new_pool.capacity = capacity;
    new_pool.count = 0;
    new_pool.alloc = pool->alloc;
    for (int32_t i=0; i<capacity; i++) {
        new_pool.entries[i].hash = 0;
        new_pool.entries[i].str = NULL;
    }
    for (int32_t i=0; i<pool->capacity; i++)
        if (pool->entries[i].str != 0)
            fin_str_insert(&new_pool, pool->entries[i].hash, pool->entries[i].str);
    pool->alloc(pool->entries, 0);
    *pool = new_pool;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
shll $0x4, %esi
xorl %r12d, %r12d
xorl %edi, %edi
callq *0x10(%rbx)
movq %rax, %r15
movq 0x10(%rbx), %r13
testl %r14d, %r14d
jle 0x7f66
movl %r14d, %eax
shlq $0x4, %rax
xorl %ecx, %ecx
movl $0x0, (%r15,%rcx)
movq $0x0, 0x8(%r15,%rcx)
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x7f4c
movslq 0x8(%rbx), %r8
movq (%rbx), %rdi
testq %r8, %r8
jle 0x7fd3
xorl %r9d, %r9d
xorl %r12d, %r12d
movq %r9, %rax
shlq $0x4, %rax
movq 0x8(%rdi,%rax), %r10
testq %r10, %r10
je 0x7fcb
addq %rdi, %rax
movl (%rax), %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %r14d
movl %edx, %esi
movslq %edx, %r11
shlq $0x4, %r11
leaq (%r15,%r11), %rax
cmpl $0x0, (%r15,%r11)
je 0x7fbe
cmpq $0x0, 0x8(%rax)
je 0x7fbe
incl %edx
movl %edx, %eax
cltd
idivl %r14d
cmpl %esi, %edx
jne 0x7f97
jmp 0x7fcb
movl %ecx, (%rax)
movq %r10, 0x8(%rax)
movl %edx, 0x8(%r10)
incl %r12d
incq %r9
cmpq %r8, %r9
jne 0x7f78
xorl %esi, %esi
callq *%r13
movq %r15, (%rbx)
movl %r14d, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
movq %r13, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_destroy
void fin_str_destroy(fin_ctx_t* ctx, fin_str_t* str) {
    fin_str_pool_t* pool = ctx->pool;
    if (--str->ref == 0) {
        pool->entries[str->slot].str = NULL;
        pool->entries[str->slot].hash = 1;
        pool->alloc(str, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
decl (%rsi)
je 0x8225
popq %rbp
retq
movq (%rax), %rcx
movslq 0x8(%rsi), %rdx
shlq $0x4, %rdx
movq $0x0, 0x8(%rcx,%rdx)
movl $0x1, (%rcx,%rdx)
movq 0x10(%rax), %rax
movq %rsi, %rdi
xorl %esi, %esi
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_str.c
// Function: fin_str_join
fin_str_t* fin_str_join(fin_ctx_t* ctx, fin_str_t* arr, int32_t count) {
    int32_t length = 0;
    for (int32_t i=0; i<count; i++)
        length += fin_str_len(arr + i);
    char* buffer = ctx->alloc(NULL, length + 1);
    length = 0;
    for (int32_t i=0; i<count; i++) {
        if (!(arr+i))
            continue;
        strncpy(buffer, (arr+i)->cstr, (arr+i)->len);
        length += (arr+i)->len;
    }
    fin_str_t* result = fin_str_create(ctx, buffer, length);
    ctx->alloc(buffer, 0);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
testl %edx, %edx
jle 0x8361
movl %edx, %r13d
movq %rsi, %r14
movl %edx, %ebx
movq %rbx, %rax
shlq $0x4, %rax
xorl %ecx, %ecx
xorl %esi, %esi
movl $0x0, %edx
testq %r14, %r14
je 0x8311
movl 0x4(%r14,%rcx), %edx
addl %edx, %esi
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x8302
incl %esi
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, -0x30(%rbp)
callq *(%r12)
movq %rax, %r12
testl %r13d, %r13d
jle 0x835b
leaq 0xc(%r14), %r13
xorl %r15d, %r15d
testq %r14, %r14
je 0x8352
movslq -0x8(%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x3070
addl -0x8(%r13), %r15d
addq $0x10, %r13
decq %rbx
jne 0x833a
movq -0x30(%rbp), %rbx
jmp 0x8375
xorl %r15d, %r15d
xorl %edi, %edi
movl $0x1, %esi
callq *(%r12)
movq %r12, %rbx
movq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x8040
movq %rax, %r14
movq %r12, %rdi
xorl %esi, %esi
callq *(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/fin_vm.c
// Function: fin_vm_invoke_int
inline void fin_vm_invoke_int(fin_ctx_t* ctx, fin_mod_func_t* func, fin_val_t* stack) {
    if (func->is_native) {
        fin_val_t result;
        (*func->func)(ctx, stack - func->args, &result);
        if (func->ret_type)
            stack[-func->args] = result;
    }
    else
        fin_vm_interpret(ctx, func, stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x1, 0x20(%rsi)
jne 0x872d
movzbl 0x34(%r14), %eax
shll $0x3, %eax
movq %rbx, %rsi
subq %rax, %rsi
leaq -0x18(%rbp), %rdx
callq *0x18(%r14)
cmpq $0x0, 0x8(%r14)
je 0x8724
movzbl 0x34(%r14), %eax
shll $0x3, %eax
subq %rax, %rbx
movq -0x18(%rbp), %rax
movq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %r14, %rsi
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x83cc
// File: /workspace/github_c_makefile_star2_O3/naleksiev[P]fin/src/mod/fin_io.c
// Function: fin_io_file_write
static void fin_io_file_write(fin_ctx_t* ctx, const fin_val_t* args, fin_val_t* ret) {
    const char* file = fin_str_cstr(args[0].s);
    if (!file)
        return;
    FILE* fp = fopen(file, "wb");
    if (!fp)
        return;
    fputs(fin_str_cstr(args[1].s), fp);
    fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
callq 0x83b1
testq %rax, %rax
je 0x88dc
leaq 0x1fb8(%rip), %rsi      # 0xa864
movq %rax, %rdi
callq 0x3250
testq %rax, %rax
je 0x88dc
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x83b1
movq %rax, %rdi
movq %r14, %rsi
callq 0x3130
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-show-type.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	sparse_initialize(argc, argv, &filelist);
	Wdecl = 0;
	FOR_EACH_PTR(filelist, file) {
		show_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	return has_error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0xf0f6
leaq 0x51843(%rip), %rax     # 0x60218
movl $0x0, (%rax)
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xea9e
leaq 0x31611(%rip), %rbx     # 0x40004
movq 0x8(%rsp), %r12
movzwl (%r12), %eax
testb %al, %al
jle 0xea8e
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xea1c
testq %rdi, %rdi
je 0xea7a
callq 0xf42e
testq %rax, %rax
je 0xea7a
movq %rax, %r14
movq %rax, %rbp
movzwl (%rbp), %eax
testb %al, %al
jle 0xea71
xorl %r15d, %r15d
movq 0x18(%rbp,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xea4c
testq %rdi, %rdi
je 0xea62
callq 0x1a8bd
movq %rbx, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movzwl (%rbp), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xea37
movq 0x10(%rbp), %rbp
cmpq %r14, %rbp
jne 0xea2c
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0xea08
movq 0x10(%r12), %r12
cmpq 0x8(%rsp), %r12
jne 0xe9f8
leaq 0x56eef(%rip), %rax     # 0x65994
movl (%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/lyndon-array.c
// Function: compute_lyndon_nsv
int compute_lyndon_nsv(unsigned char *s, int_t *A, int_t n){

int_t i;

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

	#if STEP_TIME
		time_t t_time = 0;clock_t c_time = 0;
		tstart(&t_time, &c_time); 
		printf("1. SA construction:\n");
	#endif
	
	// 1. sort
	//int_t *SA = A;
	int_t *SA = (int_t*) malloc(n*sizeof(int_t));
	sacak(s, SA, n);

	#if STEP_TIME
		fprintf(stderr,"%.6lf\n", tstop(t_time, c_time));
		tstart(&t_time, &c_time);
		printf("2. Compute ISA:\n"); 
	#endif

	//2. compute ISA
	int_t *ISA = A;
	for(i=0; i<n; i++) ISA[SA[i]]=i;

	#if STEP_TIME
		fprintf(stderr,"%.6lf\n", tstop(t_time, c_time));
		tstart(&t_time, &c_time);
		printf("3. Compute NSV-array:\n"); 
	#endif

	//3. compute NSV
	int_t *NSV = SA; //(in the space of SA[0,n-1])
	compute_nsv(NSV, ISA, n);
	NSV[n-1]=n;

	#if STEP_TIME
		fprintf(stderr,"%.6lf\n", tstop(t_time, c_time));
		tstart(&t_time, &c_time);
		printf("4. Compute Lyndon:\n");
	#endif


	#if PRINT
		printf("step\tpos\tT^{rev}\tLyndon\n");
	#endif

	int_t *LA = A;
	for(i=0; i < n; i++){	
		LA[i] = NSV[i]-i;
	}

	#if STEP_TIME
		fprintf(stderr,"%.6lf\n", tstop(t_time, c_time));
	#endif

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

	free(SA);
	//free(ISA);
	//free(NSV);

return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
xorl %edi, %edi
callq 0x21b0
movq %rax, (%rsp)
callq 0x20a0
movq %rax, %r15
movslq %ebp, %r13
leaq (,%r13,4), %rdi
callq 0x855a
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
movl %r13d, %edx
callq 0x83c9
testl %r13d, %r13d
jle 0x2def
movl %ebp, %r14d
xorl %eax, %eax
movslq (%rbx,%rax,4), %rcx
movl %eax, (%r12,%rcx,4)
incq %rax
cmpq %rax, %r14
jne 0x2daf
movq %rbx, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x5b19
movl %ebp, -0x4(%rbx,%r13,4)
testl %ebp, %ebp
jle 0x2e01
xorl %eax, %eax
xorl %ecx, %ecx
movl (%rbx,%rcx,4), %edx
addl %eax, %edx
movl %edx, (%r12,%rcx,4)
incq %rcx
decl %eax
cmpq %rcx, %r14
jne 0x2dda
jmp 0x2e01
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x5b19
movl %ebp, -0x4(%rbx,%r13,4)
leaq 0x67d1(%rip), %rdi      # 0x95d9
callq 0x2080
movq 0xa1e4(%rip), %rax      # 0xcff8
movq (%rax), %r14
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x589a
leaq 0x65dd(%rip), %rsi      # 0x9407
movq %r14, %rdi
movb $0x1, %al
callq 0x2180
movq %rbx, %rdi
callq 0x8611
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %r13
xorl %edi, %edi
callq 0x21b0
movq %rax, %rbx
callq 0x20a0
movq %rax, %r12
leal -0x1(%r15), %eax
cmpl $0x2, %r15d
jl 0x2ebd
movl %eax, %ecx
xorl %edx, %edx
movq %rdx, %rsi
incq %rdx
movl %edx, %edi
movl %edx, %r8d
movl %edi, %r9d
movq %r13, %r10
movb (%r10,%r9), %r11b
incl %r8d
leaq 0x1(%r10), %rbp
cmpb %r11b, (%r10,%rsi)
movq %rbp, %r10
je 0x2e92
jae 0x2eb2
movl %r8d, %edi
cmpl %r15d, %r8d
jl 0x2e8c
jmp 0x2eb8
subl %esi, %edi
movl %edi, (%r14,%rsi,4)
cmpq %rcx, %rdx
jne 0x2e81
cltq
movl $0x1, (%r14,%rax,4)
leaq 0x670b(%rip), %rdi      # 0x95d9
callq 0x2080
movq 0xa11e(%rip), %rax      # 0xcff8
movq (%rax), %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x589a
leaq 0x6518(%rip), %rsi      # 0x9407
movq %r14, %rdi
movb $0x1, %al
callq 0x2180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0xa058(%rip), %rax      # 0xcfc8
movq (%rax), %rdi
movq 0x10a236(%rip), %rdx    # 0x10d1b0
movq 0xa1f7(%rip), %rcx      # 0xd178
movq 0xa1e8(%rip), %r8       # 0xd170
leaq 0x69e3(%rip), %rsi      # 0x9972
xorl %eax, %eax
callq 0x2180
movq 0xa05b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq 0xa1d1(%rip), %rdx      # 0xd178
leaq 0x6a02(%rip), %rsi      # 0x99b0
xorl %eax, %eax
popq %rcx
jmp 0x2180
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/main.c
// Function: cat_char
unsigned char* cat_char(unsigned char** R, size_t d, size_t *n){

  (*n)++; //add 0 at the end

  int_t i, j;
  int_t l=0;
  unsigned char *str = (unsigned char*) malloc((*n)*sizeof(unsigned char));

  for(i=0; i<d; i++){
    int_t m = strlen((char*)R[i]);
    for(j=0; j<m; j++){
      if(R[i][j]<255) str[l++] = R[i][j]+1;
    }
#if CAT == 1
    str[l++] = 1; //add 1 as separator
#endif
  }

  str[l++]=0;
  if(*n>l){
    str = (unsigned char*) realloc(str, (l)*sizeof(unsigned char)); 
  }
  *n = l;

return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r13
movq (%rdx), %rdi
incq %rdi
movq %rdx, 0x10(%rsp)
movq %rdi, (%rdx)
movq %rdi, 0x8(%rsp)
callq 0x855a
movq %rax, %r14
testq %r12, %r12
je 0x31b3
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%r13,%r15,8), %rbp
movq %rbp, %rdi
callq 0x20c0
testl %eax, %eax
jle 0x31a9
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movb (%rbp,%rcx), %dl
cmpb $-0x1, %dl
je 0x31a1
incb %dl
movslq %ebx, %rsi
incl %ebx
movb %dl, (%r14,%rsi)
incq %rcx
cmpq %rcx, %rax
jne 0x318d
incq %r15
cmpq %r12, %r15
jne 0x3175
jmp 0x31b5
xorl %ebx, %ebx
movslq %ebx, %rax
incl %ebx
movb $0x0, (%r14,%rax)
movslq %ebx, %r12
cmpq %r12, 0x8(%rsp)
jbe 0x31d7
movq %r14, %rdi
movq %r12, %rsi
callq 0x86da
movq %rax, %r14
movq 0x10(%rsp), %rax
movq %r12, (%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/main.c
// Function: usage
void usage(char *name){
  printf("lyndon-array:\n\tUsage: %s [options] FILE \n\n",name);
  puts("Computes the Lyndon-array of FILE");
  puts("Output:\tLyndon-array (and Suffix-array)\n");
  puts("Available options:");
  puts("\t-A a\tpreferred algorithm to use (default 10)");
  puts("\t-d D\tuse the first D documents of the INPUT");
  puts("\t-b\tread INPUT as binary input (default)");
  puts("\t-f\tread INPUT as formatted input (txt, fasta or fastq)");
  puts("\t-v\tverbose output");
  puts("\t-o\toutput computed arrays to disk (INPUT.la and INPUT.sa)");
  puts("\t-s\tcompute some statistics for LA");
  puts("\t-l\toutput the lyndon-factors (start positions) to (INPUT.pos)");
  puts("\t-L\toutput the lyndon-factors (substrings) to (INPUT.lyn)");
  puts("Debug options:");
  puts("\t-c\tcheck output (for debug)");
  puts("\t-p P\tprint the output arrays LA[1,P] and SA[1,P] (for debug)");
  puts("\t-h\tthis help message");
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x5eb4(%rip), %rdi      # 0x90b0
xorl %eax, %eax
callq 0x20f0
leaq 0x5ed1(%rip), %rdi      # 0x90db
callq 0x2080
leaq 0x5ee7(%rip), %rdi      # 0x90fd
callq 0x2080
leaq 0x5f04(%rip), %rdi      # 0x9126
callq 0x2080
leaq 0x5f0b(%rip), %rdi      # 0x9139
callq 0x2080
leaq 0x5f2d(%rip), %rdi      # 0x9167
callq 0x2080
leaq 0x5f4e(%rip), %rdi      # 0x9194
callq 0x2080
leaq 0x5f6b(%rip), %rdi      # 0x91bd
callq 0x2080
leaq 0x5f97(%rip), %rdi      # 0x91f5
callq 0x2080
leaq 0x5f9e(%rip), %rdi      # 0x9208
callq 0x2080
leaq 0x5fcd(%rip), %rdi      # 0x9243
callq 0x2080
leaq 0x5fe4(%rip), %rdi      # 0x9266
callq 0x2080
leaq 0x6017(%rip), %rdi      # 0x92a5
callq 0x2080
leaq 0x6045(%rip), %rdi      # 0x92df
callq 0x2080
leaq 0x6048(%rip), %rdi      # 0x92ee
callq 0x2080
leaq 0x6059(%rip), %rdi      # 0x930b
callq 0x2080
leaq 0x608b(%rip), %rdi      # 0x9349
callq 0x2080
movl $0x1, %edi
callq 0x2270
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/file.c
// Function: clean_filename_ext
const char *clean_filename_ext(const char *filename) {

    char *dot = strrchr(filename, '.');

    *dot = '\0';

    if(!dot || dot == filename) return "";

    return filename;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2e, %esi
callq 0x2120
movb $0x0, (%rax)
cmpq %rbx, %rax
leaq 0x518d(%rip), %rax      # 0x9434
cmovneq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
callq 0x21f0
movq %rax, %rbx
testq %rax, %rax
je 0x431b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq %rbx, %rax
popq %rbx
retq
leaq 0x538e(%rip), %rdi      # 0x96b0
callq 0x2200
jmp 0x430a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rdx
xorl %eax, %eax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x2240
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x43e1
movq %rbx, %rdi
incq %rdi
callq 0x855a
movq %rax, %r14
movq (%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2060
movw $0x24, -0x1(%r14,%rbx)
movq %r15, %rdi
callq 0x8611
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x52dd(%rip), %rdi      # 0x96c5
callq 0x2200
jmp 0x43a4
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movl $0x4000, %edi           # imm = 0x4000
callq 0x855a
movq %rax, %r14
cmpq $0x0, (%rbx)
je 0x4498
movl $0x800, %ebp            # imm = 0x800
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
leaq (%r14,%r12), %rdi
movq %r15, (%r14,%r13,8)
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2240
movq (%r14,%r13,8), %rdi
cmpq $-0x1, %rax
je 0x4490
movb $0x0, -0x1(%rdi,%rax)
movq (%rsp), %rcx
addq %rax, (%rcx)
leal -0x1(%rbp), %eax
cltq
cmpq %rax, %r13
jne 0x4482
movslq %ebp, %rax
addl $0x800, %ebp            # imm = 0x800
leaq 0x4000(,%rax,8), %rsi
movq %r14, %rdi
callq 0x86da
movq %rax, %r14
incq %r13
addq $0x8, %r12
cmpq (%rbx), %r13
jb 0x442a
jmp 0x4498
callq 0x8611
movq %r13, (%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x20(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
movl $0x4000, %edi           # imm = 0x4000
callq 0x855a
movq %rax, %r15
movq %rbx, 0x10(%rsp)
cmpq $0x0, (%rbx)
je 0x45ff
movl $0x800, %r12d           # imm = 0x800
xorl %r13d, %r13d
movq %rsp, %rbx
leaq 0x8(%rsp), %rax
movq $0x0, 0x18(%rsp)
xorl %ebp, %ebp
movq %r12, 0x28(%rsp)
movq %r13, 0x8(%rsp)
movq %r13, (%rsp)
movq %rbx, %rdi
movq %rax, %r12
movq %rax, %rsi
movq %r14, %rdx
callq 0x2240
xorl %r13d, %r13d
movq %rax, 0x30(%rsp)
movq (%rsp), %rdi
callq 0x8611
cmpq $0x2, 0x30(%rsp)
jl 0x45f7
movq %r13, 0x8(%rsp)
movq 0x18(%rsp), %rax
leaq (%r15,%rax), %rdi
movq %r13, (%r15,%rbp,8)
movq %r12, %rsi
movq %r14, %rdx
callq 0x2240
movq (%r15,%rbp,8), %rcx
movb $0x0, -0x1(%rcx,%rax)
movq 0x20(%rsp), %rcx
addq %rax, (%rcx)
movq %r13, 0x8(%rsp)
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2240
movq (%rsp), %rdi
callq 0x8611
movq %r13, 0x8(%rsp)
movq %r13, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2240
movq (%rsp), %rdi
callq 0x8611
movq 0x28(%rsp), %r12
leal -0x1(%r12), %eax
cltq
cmpq %rax, %rbp
movl $0x0, %r13d
jne 0x45d9
movslq %r12d, %rax
addl $0x800, %r12d           # imm = 0x800
leaq 0x4000(,%rax,8), %rsi
movq %r15, %rdi
callq 0x86da
movq %rax, %r15
incq %rbp
addq $0x8, 0x18(%rsp)
movq 0x10(%rsp), %rax
cmpq (%rax), %rbp
leaq 0x8(%rsp), %rax
jb 0x44fb
jmp 0x45ff
movq 0x10(%rsp), %rax
movq %rbp, (%rax)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/file.c
// Function: load_multiple_fasta
char** load_multiple_fasta(FILE* f_in, size_t *k, size_t *n){

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

	char *buf = NULL;
	size_t len = 0;

	getline(&buf, &len, f_in);// first sequence
	free(buf);

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

		if(i!=count){
			*k = i;
			break;		
		}

		int c_alloc = 128;
		c_buffer[i] = (char*) malloc(c_alloc*sizeof(char));

		size_t p=0;
		len = 0; buf=NULL;
		while(getline(&buf, &len, f_in)!=-1){

			if(buf[0] == '>'){
				count++;
				break;
			}

			if(p+len>c_alloc){
				c_alloc += len+128;
				c_buffer[i] = (char*) realloc(c_buffer[i], sizeof(char) * c_alloc);
			}

			strcpy(&c_buffer[i][p], buf);
			p+=strlen(buf)-1;

			free(buf);
			buf=NULL; len=0;
		}

		free(buf);
		c_buffer[i][p] = 0;
		(*n) += p+1;

		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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r12
movl $0x4000, %edi           # imm = 0x4000
callq 0x855a
movq %rax, %r15
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq %rbx, (%r13)
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movq %r13, %rdi
movq %r12, 0x28(%rsp)
movq %r12, %rdx
callq 0x2240
movq (%r13), %rdi
callq 0x8611
movq %r14, 0x18(%rsp)
cmpq %rbx, (%r14)
je 0x47d3
movl $0x800, %r12d           # imm = 0x800
xorl %r14d, %r14d
xorl %r13d, %r13d
xorl %ebx, %ebx
cmpq %rbx, %r13
jne 0x47cb
movl $0x80, %edi
callq 0x855a
movq %rax, (%r15,%r13,8)
movq %r14, 0x10(%rsp)
movq %r14, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x2240
movl $0x0, %ebp
movq %r13, %rbx
cmpq $-0x1, %rax
je 0x476d
movq %r12, 0x20(%rsp)
movl $0x80, %r12d
xorl %ebp, %ebp
movq 0x8(%rsp), %rsi
cmpb $0x3e, (%rsi)
je 0x4764
movq 0x10(%rsp), %rax
leaq (%rax,%rbp), %rcx
movslq %r12d, %rdx
movq (%r15,%r13,8), %rdi
cmpq %rdx, %rcx
jbe 0x4714
addl %eax, %r12d
addl $0x80, %r12d
movslq %r12d, %rsi
callq 0x86da
movq %rax, %rdi
movq %rax, (%r15,%r13,8)
movq 0x8(%rsp), %rsi
addq %rbp, %rdi
callq 0x2070
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x20c0
addq %rax, %rbp
decq %rbp
movq %rbx, %rdi
callq 0x8611
movq %r14, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x2240
cmpq $-0x1, %rax
jne 0x46d3
movq %r13, %rbx
jmp 0x4768
leaq 0x1(%r13), %rbx
movq 0x20(%rsp), %r12
movq 0x8(%rsp), %rdi
callq 0x8611
movq (%r15,%r13,8), %rax
movb $0x0, (%rax,%rbp)
movq 0x30(%rsp), %rcx
movq (%rcx), %rax
leaq 0x1(%rbp,%rax), %rax
movq %rax, (%rcx)
leal -0x1(%r12), %eax
cltq
cmpq %rax, %r13
jne 0x47b8
movslq %r12d, %rax
addl $0x800, %r12d           # imm = 0x800
leaq 0x4000(,%rax,8), %rsi
movq %r15, %rdi
callq 0x86da
movq %rax, %r15
incq %r13
movq 0x18(%rsp), %rax
cmpq (%rax), %r13
jb 0x467f
jmp 0x47d3
movq 0x18(%rsp), %rax
movq %r13, (%rax)
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x4ed1(%rip), %rsi      # 0x96cf
callq 0x42fc
testq %rax, %rax
je 0x4883
movq %rax, %rbx
movq %r13, %rdi
movl $0x2e, %esi
callq 0x2120
leaq 0x1(%rax), %r12
cmpq %r13, %rax
leaq 0x4c0e(%rip), %rcx      # 0x9434
cmoveq %rcx, %r12
testq %rax, %rax
cmoveq %rcx, %r12
cmpq $0x0, (%r15)
jne 0x483e
movq $0x7fffffff, (%r15)     # imm = 0x7FFFFFFF
leaq 0x4e8d(%rip), %rsi      # 0x96d2
movq %r12, %rdi
callq 0x2170
testl %eax, %eax
je 0x4888
leaq 0x4e7e(%rip), %rsi      # 0x96d6
movq %r12, %rdi
callq 0x2170
testl %eax, %eax
je 0x4898
leaq 0x4e71(%rip), %rsi      # 0x96dc
movq %r12, %rdi
callq 0x2170
testl %eax, %eax
je 0x48a8
leaq 0x4e74(%rip), %rdi      # 0x96f2
callq 0x2080
xorl %r14d, %r14d
jmp 0x48c1
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x43ef
jmp 0x48b6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4611
jmp 0x48b6
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x44aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x20c0
movq %rax, %rbx
movq %r12, %rdi
callq 0x20c0
leaq (%rbx,%rax), %rdi
addq $0x3, %rdi
callq 0x855a
movq %rax, %rbx
leaq 0x4da5(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4aea(%rip), %rsi      # 0x9448
movq %rbx, %rdi
callq 0x42fc
movq %rax, %r12
testq %r14, %r14
je 0x4986
xorl %eax, %eax
movb (%r15,%rax), %cl
testb %cl, %cl
je 0x497e
decb %cl
movb %cl, (%r15,%rax)
incq %rax
cmpq %rax, %r14
jne 0x4970
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x2280
movq %r12, %rdi
callq 0x20b0
testq %r12, %r12
je 0x49bd
movq %rbx, %rdi
callq 0x8611
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4cf6(%rip), %rdi      # 0x96ba
callq 0x2200
jmp 0x49a6
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x20c0
movq %rax, %rbx
movq %r12, %rdi
callq 0x20c0
addq %rax, %rbx
movq %rbx, %rdi
callq 0x855a
movq %rax, %rbx
leaq 0x4ce4(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4a29(%rip), %rsi      # 0x9448
movq %rbx, %rdi
callq 0x42fc
movq %rax, %r12
movl $0x4, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x2280
movq %r12, %rdi
callq 0x20b0
testq %r12, %r12
je 0x4a61
movq %rbx, %rdi
callq 0x8611
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4c52(%rip), %rdi      # 0x96ba
callq 0x2200
jmp 0x4a4a
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x20c0
addq %rax, %rbx
movq %rbx, %rdi
callq 0x855a
movq %rax, %rbx
leaq 0x4c43(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4c0f(%rip), %rsi      # 0x96cf
movq %rbx, %rdi
callq 0x42fc
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %r12, %rdi
callq 0x2190
movq %rax, %r15
movq %r12, %rdi
callq 0x2110
movslq %r15d, %r13
movq %r13, %rdi
callq 0x855a
movq %rax, (%r14)
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2090
movq %r12, %rdi
callq 0x20b0
testq %r12, %r12
je 0x4b30
movq %rbx, %rdi
callq 0x8611
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4b83(%rip), %rdi      # 0x96ba
callq 0x2200
jmp 0x4b1b
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/file.c
// Function: file_text_int_read
int_t file_text_int_read(int_t** str_int, 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(int_t);

	*str_int = (int_t*) malloc(n*sizeof(int_t));
	fread(*str_int, sizeof(int_t), n, f_in);
	
	file_close(f_in);
	free(c_in);

return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20c0
movq %rax, %rbx
movq %r15, %rdi
callq 0x20c0
addq %rax, %rbx
movq %rbx, %rdi
callq 0x855a
movq %rax, %rbx
leaq 0x4b74(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4b40(%rip), %rsi      # 0x96cf
movq %rbx, %rdi
callq 0x42fc
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %r12, %rdi
callq 0x2190
movq %rax, %r15
movq %r12, %rdi
callq 0x2110
shrq $0x2, %r15
movslq %r15d, %r13
leaq (,%r13,4), %rdi
callq 0x855a
movq %rax, (%r14)
movl $0x4, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x2090
movq %r12, %rdi
callq 0x20b0
testq %r12, %r12
je 0x4c08
movq %rbx, %rdi
callq 0x8611
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x4aab(%rip), %rdi      # 0x96ba
callq 0x2200
jmp 0x4bf3
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %edx, %edx
jle 0x4c46
movl %edx, %r15d
movl %edx, %eax
xorl %ecx, %ecx
xorl %ebp, %ebp
xorl %edx, %edx
cmpb %bl, (%r14,%rcx)
setle %dl
addl %edx, %ebp
incq %rcx
cmpq %rcx, %rax
jne 0x4c31
jmp 0x4c4b
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x20c0
cmpl %eax, %r15d
jge 0x4c70
movl %r15d, %ecx
movl %eax, %eax
xorl %edx, %edx
cmpb %bl, (%r14,%rcx)
setl %dl
addl %edx, %ebp
incq %rcx
cmpq %rcx, %rax
jne 0x4c5d
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/bwt.c
// Function: bwt_lyndon_suffix_order
int bwt_lyndon_suffix_order(char *T, int_t *LA, int n){

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

int_t size=1;
//base cases
LA[n-2]=size++;
LA[n-1]=size++;

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

  /*steps 1 and 2*/
  p=r+1;
  for(i=s+1, r=0; T[i]!=0; i++)if(T[i]<=T[s])r++;
  for(; i<n; i++) if(T[i]<T[s])r++;
  
  T[p+s] = T[s]; //replace('$', T[s]);

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

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

for(i=n-1; i>0; i--){
  int_t max=0;
  for(s=i-1; s>=0; s--){
    if(LA[s]<LA[i] && LA[s]>max) max = LA[s];
  }
  LA[i]-=max;
}

return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq %edx, %rax
movabsq $0x200000001, %rcx      # imm = 0x200000001
movq %rcx, -0x8(%rsi,%rax,4)
cmpl $0x3, %edx
jl 0x4f79
leal -0x3(%rdx), %eax
leal -0x2(%rdx), %ecx
leaq (%rsi,%rax,4), %r8
addq $0x4, %r8
leaq (%rax,%rdi), %r9
incq %r9
movl $0x1, %ebx
movl $0x3, %r10d
movb 0x1(%rdi,%rax), %r15b
testb %r15b, %r15b
je 0x4eec
movb (%rdi,%rax), %bpl
xorl %r11d, %r11d
movq %rcx, %r14
xorl %r12d, %r12d
cmpb %bpl, %r15b
setle %r12b
addl %r12d, %r11d
movb 0x1(%rdi,%r14), %r15b
incq %r14
testb %r15b, %r15b
jne 0x4ed0
jmp 0x4ef3
leaq 0x1(%rax), %r14
xorl %r11d, %r11d
movb (%rdi,%rax), %bpl
cmpl %edx, %r14d
jge 0x4f1a
movl %r14d, %r15d
addq %rdi, %r15
xorl %r12d, %r12d
cmpb %bpl, (%r15)
setl %r12b
addl %r12d, %r11d
incq %r15
incl %r14d
cmpl %edx, %r14d
jl 0x4f02
incl %ebx
addl %eax, %ebx
movslq %ebx, %rbx
movb %bpl, (%rdi,%rbx)
leal (%r11,%rax), %ebx
testl %r11d, %r11d
jle 0x4f4e
xorl %r14d, %r14d
movb (%r9,%r14), %bpl
movb %bpl, -0x1(%r9,%r14)
movl (%r8,%r14,4), %ebp
movl %ebp, -0x4(%r8,%r14,4)
incq %r14
leal (%r14,%rax), %ebp
cmpl %ebp, %ebx
jg 0x4f31
movslq %ebx, %rbx
movb $0x0, (%rdi,%rbx)
movl %r10d, (%rsi,%rbx,4)
leal 0x1(%r10), %ebp
decq %rax
decq %rcx
addq $-0x4, %r8
decq %r9
movl %r11d, %ebx
cmpl %edx, %r10d
movl %ebp, %r10d
jne 0x4ebc
cmpl $0x2, %edx
jl 0x4fcd
leal -0x1(%rdx), %eax
movl %eax, %ecx
leaq -0x1(%rcx), %rax
movl (%rsi,%rcx,4), %edi
xorl %r8d, %r8d
movq %rax, %r9
movl %edx, %r10d
movl %r8d, %r11d
movl %r9d, %ebx
movl (%rsi,%rbx,4), %ebx
cmpl %r8d, %ebx
cmovgl %ebx, %r8d
cmpl %edi, %ebx
cmovgel %r11d, %r8d
decl %r10d
decq %r9
cmpl $0x1, %r10d
jg 0x4f93
subl %r8d, %edi
movl %edi, (%rsi,%rcx,4)
leaq -0x1(%rcx), %rdi
decl %edx
decq %rax
cmpq $0x1, %rcx
movq %rdi, %rcx
jg 0x4f87
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/bwt.c
// Function: bwt_lyndon_text_order
int bwt_lyndon_text_order(char *T, int_t *LA, int n){

  int p, r=1;
  int i, s;
  
  //base cases
  LA[n-2]=n-1;
  LA[n-1]=n-2;
  
  for(s=n-3; s>=0; s--){
  
    /*steps 1 and 2*/
    p=r+1;
    for(i=s+1, r=0; T[i]!=0; i++)if(T[i]<=T[s])r++;
    for(; i<n; i++) if(T[i]<T[s])r++;
    
    T[p+s] = T[s]; //replace('$', T[s]);
    
    for(i=s; i<s+r; i++){
      T[i] = T[i+1];
    }
    
    for(i=s+1; i<n; i++){
      if(LA[i]<=s+r) LA[i]--; 
    }
    
    T[s+r] = 0; //END_MARKER;
    LA[s]=s+r;
  }
  
  //LA = ISA
  for(i=0; i<n; i++){
  //find the next suffix smaller than T[i,n]
    for(s=i+1; s<n; s++){
      if(LA[s]<LA[i]) break;
    }
    LA[i]=s-i;
  }

return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
leal -0x1(%rdx), %eax
leal -0x2(%rdx), %ecx
movslq %ecx, %r9
movl %eax, (%rsi,%r9,4)
movslq %edx, %r8
movl %r9d, -0x4(%rsi,%r8,4)
movl %r8d, %eax
cmpl $0x3, %r8d
jl 0x511c
leal -0x3(%rdx), %r8d
movl %ecx, %ecx
leaq (%rcx,%rdi), %r9
incq %r9
movq %r9, -0x10(%rsp)
leaq (%r8,%rdi), %r10
incq %r10
leaq (%rsi,%rcx,4), %r11
movl $0x1, %ebp
leaq 0x1(%r8), %r9
movq %rdi, %r14
movb 0x1(%rdi,%r8), %r12b
movl $0x0, %ebx
movq %r9, -0x8(%rsp)
movl %r9d, %r15d
testb %r12b, %r12b
je 0x506b
movb (%r14,%r8), %r13b
xorl %ebx, %ebx
movq -0x10(%rsp), %r9
movl %ecx, %r15d
xorl %edi, %edi
cmpb %r13b, %r12b
setle %dil
addl %edi, %ebx
movb (%r9), %r12b
incl %r15d
incq %r9
testb %r12b, %r12b
jne 0x5052
movq %r14, %rdi
movb (%r14,%r8), %r12b
cmpl %edx, %r15d
jge 0x509c
movl %r15d, %r9d
addq %rdi, %r9
movq -0x8(%rsp), %r13
xorl %r14d, %r14d
cmpb %r12b, (%r9)
setl %r14b
addl %r14d, %ebx
incq %r9
incl %r15d
cmpl %edx, %r15d
jl 0x5082
jmp 0x50a1
movq -0x8(%rsp), %r13
addl %r13d, %ebp
movslq %ebp, %r9
movb %r12b, (%rdi,%r9)
leal (%r8,%rbx), %ebp
testl %ebx, %ebx
jle 0x50cb
xorl %r9d, %r9d
movb (%r10,%r9), %r14b
movb %r14b, -0x1(%r10,%r9)
incq %r9
leal (%r9,%r8), %r14d
cmpl %r14d, %ebp
jg 0x50b6
cmpq %rax, %r13
jge 0x50ef
xorl %r14d, %r14d
movl (%r11,%r14,4), %r9d
cmpl %ebp, %r9d
jg 0x50e3
decl %r9d
movl %r9d, (%r11,%r14,4)
incq %r14
leal (%r14,%rcx), %r9d
cmpl %edx, %r9d
jl 0x50d3
movslq %ebp, %r9
movb $0x0, (%rdi,%r9)
movl %ebp, (%rsi,%r8,4)
leaq -0x1(%r8), %r9
decq %rcx
decq -0x10(%rsp)
decq %r10
addq $-0x4, %r11
movl %ebx, %ebp
testq %r8, %r8
movq %r9, %r8
jg 0x5026
testl %edx, %edx
jle 0x515c
movl $0x1, %ecx
xorl %edx, %edx
movq %rdx, %rdi
incq %rdx
movl %edx, %r8d
cmpq %rax, %rdx
jae 0x514d
movl (%rsi,%rdi,4), %r9d
movq %rcx, %r8
cmpl %r9d, (%rsi,%r8,4)
jl 0x514d
incq %r8
cmpq %r8, %rax
jne 0x513c
movl %eax, %r8d
subl %edi, %r8d
movl %r8d, (%rsi,%rdi,4)
incq %rcx
cmpq %rax, %rdx
jne 0x5127
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x3, %esi
jl 0x51fe
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
addl $-0x3, %r14d
leaq (%r14,%rdi), %r15
incq %r15
movl $0x1, %r12d
leal 0x1(%r12), %edx
leaq (%rbx,%r14), %rdi
incq %rdi
movsbl -0x1(%rdi), %ebp
movl %ebp, %esi
callq 0x4c18
leal (%r12,%r14), %ecx
incl %ecx
movslq %ecx, %rcx
movb %bpl, (%rbx,%rcx)
leal (%rax,%r14), %ecx
testl %eax, %eax
jle 0x51dd
xorl %edx, %edx
movb (%r15,%rdx), %sil
movb %sil, -0x1(%r15,%rdx)
incq %rdx
leal (%r14,%rdx), %esi
cmpl %esi, %ecx
jg 0x51c9
movslq %ecx, %rcx
movb $0x0, (%rbx,%rcx)
leaq -0x1(%r14), %rcx
decq %r15
movl %eax, %r12d
testq %r14, %r14
movq %rcx, %r14
jg 0x519b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x855a
movq %rax, %r15
cmpl $0x2, %ebx
jl 0x5241
leal -0x2(%rbx), %r12d
xorl %eax, %eax
movslq %eax, %rdx
movsbl (%r14,%rdx), %esi
movb %sil, (%r15,%r12)
movq %r14, %rdi
callq 0x4c18
addq $-0x1, %r12
jb 0x5227
movslq %ebx, %rax
movw $0x0, -0x1(%r15,%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
xorl %ecx, %ecx
movl %ecx, (%rsi,%rax,4)
addl (%rdi,%rax,4), %ecx
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x52a3
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x20c0
movq %rax, %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x52df
xorl %edx, %edx
cmpb $0x0, (%rbx,%rdx)
je 0x52dd
incq %rdx
cmpq %rdx, %rcx
jne 0x52cd
jmp 0x52df
movl %edx, %eax
popq %rbx
retq
nopl (%rax)