LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x20c0
movq %rax, %r14
movq %r15, %rdi
callq 0x20c0
leaq (%r14,%rax), %rdi
addq $0x3, %rdi
callq 0x855a
movq %rax, %r14
leaq 0x43cb(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4110(%rip), %rsi      # 0x9448
movq %r14, %rdi
callq 0x42fc
movq %rax, %r15
movslq %ebp, %rdx
movl $0x4, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2280
movq %r15, %rdi
callq 0x4329
movq %r14, %rdi
callq 0x8611
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/felipelouza[P]lyndon-array/lib/suffix-array.c
// Function: suffix_array_read
int_t suffix_array_read(int_t** SA, char* c_file, const char* ext){

  FILE *f_in;
  char *c_in = malloc((strlen(c_file)+strlen(ext)+3)*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);

  *SA = (int_t*) malloc(n*sizeof(int_t));
  fread(*SA, sizeof(int_t), n, f_in);

  file_close(f_in);
  free(c_in);

return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20c0
movq %rax, %r14
movq %r15, %rdi
callq 0x20c0
leaq (%r14,%rax), %rdi
addq $0x3, %rdi
callq 0x855a
movq %rax, %r14
leaq 0x433d(%rip), %rsi      # 0x96ec
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2260
leaq 0x4309(%rip), %rsi      # 0x96cf
movq %r14, %rdi
callq 0x42fc
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %r15, %rdi
callq 0x2190
movq %rax, %r12
movq %r15, %rdi
callq 0x2110
shrq $0x2, %r12
movslq %r12d, %r12
leaq (,%r12,4), %rdi
callq 0x855a
movq %rax, (%rbx)
movl $0x4, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x2090
movq %r15, %rdi
callq 0x4329
movq %r14, %rdi
callq 0x8611
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %rdi
shlq $0x3, %rdi
callq 0x855a
movq %rax, (%rbx)
testq %rax, %rax
je 0x56ba
movl %ebp, 0xc(%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movq (%rdi), %rax
cmpl 0xc(%rdi), %ecx
jne 0x56f8
addl $0x500, %ecx            # imm = 0x500
movl %ecx, 0xc(%rbx)
movslq %ecx, %rsi
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x86da
movq %rax, (%rbx)
movl 0x8(%rbx), %ecx
movslq %ecx, %rcx
movl %r14d, (%rax,%rcx,8)
movl %ebp, 0x4(%rax,%rcx,8)
incl %ecx
movl %ecx, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal -0x1(%rax), %ebp
cmpl $0x2, %eax
jl 0x5765
movl %ebp, %r14d
leaq 0x4027(%rip), %r15      # 0x9764
xorl %ebp, %ebp
movq (%rbx), %rax
movl (%rax,%r14,8), %edx
movl 0x4(%rax,%r14,8), %ecx
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x573f
movq (%rbx), %rax
movslq %ebp, %rsi
movl (%rax,%rsi,8), %edx
movl 0x4(%rax,%rsi,8), %ecx
leaq 0x3feb(%rip), %rdi      # 0x9764
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %rdi
shlq $0x2, %rdi
callq 0x855a
movq %rax, (%rbx)
testq %rax, %rax
je 0x57b0
movl %ebp, 0xc(%rbx)
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movq (%rdi), %rax
cmpl 0xc(%rdi), %ecx
jne 0x57ea
addl $0x500, %ecx            # imm = 0x500
movl %ecx, 0xc(%rbx)
movslq %ecx, %rsi
shlq $0x2, %rsi
movq %rax, %rdi
callq 0x86da
movq %rax, (%rbx)
movl 0x8(%rbx), %ecx
movslq %ecx, %rcx
movl %ebp, (%rax,%rcx,4)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leal -0x1(%rax), %ebp
cmpl $0x2, %eax
jl 0x5855
movl %ebp, %r14d
leaq 0x3f3f(%rip), %r15      # 0x9771
xorl %ebp, %ebp
movq (%rbx), %rax
movl (%rax,%r14,4), %edx
movq %r15, %rdi
movl %r14d, %esi
xorl %eax, %eax
callq 0x20f0
leaq -0x1(%r14), %rax
cmpq $0x1, %r14
movq %rax, %r14
ja 0x5834
movq (%rbx), %rax
movslq %ebp, %rsi
movl (%rax,%rsi,4), %edx
leaq 0x3f0c(%rip), %rdi      # 0x9771
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0x5943
addl $-0x2, %ecx
movl %ecx, %r9d
subl %eax, %r9d
movl %r9d, %r8d
shrl $0x1f, %r8d
addl %r9d, %r8d
sarl %r8d
addl %eax, %r8d
movslq %r8d, %r10
movl (%rsi,%r10,4), %r9d
cmpl %edi, %r9d
jg 0x5927
cmpl %edi, 0x4(%rsi,%r10,4)
jg 0x5944
leal 0x1(%r8), %r10d
decl %r8d
cmpl %edi, %r9d
cmovll %r10d, %eax
cmovll %ecx, %r8d
movl %r8d, %ecx
cmpl %r8d, %eax
jle 0x58fe
xorl %eax, %eax
retq
movb (%rdx,%r10), %al
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movl $0x1400, %edi           # imm = 0x1400
callq 0x855a
movl $0x0, (%rax)
movl $0x1, %ecx
cmpl $0x2, %ebp
jl 0x5bd5
movl %ebp, %r8d
movl $0x500, %ebx            # imm = 0x500
movl $0x1, %r12d
xorl %ebp, %ebp
movq 0x8(%rsp), %rsi
movq %r8, %r15
decq %r8
movslq %r12d, %r13
movslq -0x4(%rax,%r13,4), %rdx
movl %edx, -0x4(%rsi,%r15,4)
movl -0x8(%r14,%r15,4), %ecx
cmpl -0x4(%r14,%r15,4), %ecx
jle 0x5bbd
cmpl %ebx, %r12d
jne 0x5bae
leal 0x500(%r12), %ebx
movslq %ebx, %rsi
shlq $0x2, %rsi
movq %rax, %rdi
movq %r8, 0x10(%rsp)
callq 0x86da
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %rsi
movl %r8d, (%rax,%r13,4)
incl %r12d
cmpq $0x2, %r15
jg 0x5b64
jmp 0x5bdc
cmpl %ecx, (%r14,%rdx,4)
jl 0x5bb5
subl $0x1, %r12d
cmovbl %ebp, %r12d
movslq %r12d, %rdx
movslq -0x4(%rax,%rdx,4), %rdx
jmp 0x5bbd
movq 0x8(%rsp), %rsi
jmp 0x5bdf
movslq %r12d, %rcx
movl -0x4(%rax,%rcx,4), %ecx
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0x8611
xorl %eax, %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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %ebx
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r12
movl %ecx, %r15d
testl %ecx, %ecx
je 0x6630
leaq (,%r15,4), %rdx
movq %r14, %rdi
xorl %esi, %esi
movl %ecx, 0x4(%rsp)
callq 0x2130
movl 0x4(%rsp), %ecx
testl %r13d, %r13d
jle 0x6659
movl %r13d, %eax
xorl %esi, %esi
cmpl $0x4, %ebp
jne 0x6645
movl (%r12,%rsi,4), %edx
jmp 0x664a
movzbl (%r12,%rsi), %edx
movslq %edx, %rdx
incl (%r14,%rdx,4)
incq %rsi
cmpq %rsi, %rax
jne 0x663a
testl %ecx, %ecx
je 0x667c
xorl %eax, %eax
xorl %ecx, %ecx
movl (%r14,%rax,4), %edx
testl %ebx, %ebx
leal -0x1(%rdx,%rcx), %esi
cmovel %ecx, %esi
addl %edx, %ecx
movl %esi, (%r14,%rax,4)
incq %rax
cmpq %rax, %r15
jne 0x6661
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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r13d
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x40(%rsp), %ebp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %r8d, %ecx
movl $0x1, %r8d
movl %ebp, %r9d
callq 0x65f5
cmpl $0x2, %r13d
jl 0x6709
movl %r13d, %eax
incq %rax
movl -0x8(%r14,%rax,4), %ecx
movl $0x0, -0x8(%r14,%rax,4)
movslq %ecx, %rdx
cmpl $0x4, %ebp
jne 0x66e9
movl (%r12,%rdx,4), %edx
jmp 0x66ee
movzbl (%r12,%rdx), %edx
movslq %edx, %rdx
movslq (%r15,%rdx,4), %rsi
leal -0x1(%rsi), %edi
movl %edi, (%r15,%rdx,4)
movl %ecx, (%r14,%rsi,4)
decq %rax
cmpq $0x2, %rax
ja 0x66cd
decl %ebx
movl %ebx, (%r14)
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/sacak-lyndon.c
// Function: induceSAl0
void induceSAl0(int_t *SA,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the head of each bucket.
  getBuckets_k(s, bkt, n, K, false, cs);

  bkt[0]++; // skip the virtual sentinel.
  for(i=0; i<n; i++)
    if(SA[i]>0) {
      j=SA[i]-1;
      if(chr(j)>=chr(j+1)) {
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]++;
        if(!suffix && i>0) SA[i]=0;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x40(%rsp), %ebp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %r8d, %ecx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x65f5
incl (%r14)
testl %r13d, %r13d
jle 0x67c7
movl %r13d, %eax
xorl %ecx, %ecx
movslq (%r12,%rcx,4), %rsi
testq %rsi, %rsi
jle 0x67bf
leal -0x1(%rsi), %edx
cmpl $0x4, %ebp
jne 0x6787
movslq (%r15,%rdx,4), %rdi
cmpl (%r15,%rsi,4), %edi
jl 0x67bf
movslq (%r14,%rdi,4), %rsi
movl %edx, (%r12,%rsi,4)
movl (%r15,%rdx,4), %edx
jmp 0x679f
movzbl (%r15,%rdx), %edi
cmpb (%r15,%rsi), %dil
jb 0x67bf
movslq (%r14,%rdi,4), %rsi
movl %edx, (%r12,%rsi,4)
movzbl (%r15,%rdx), %edx
testl %ebx, %ebx
setne %sil
movslq %edx, %rdx
incl (%r14,%rdx,4)
testq %rcx, %rcx
sete %dl
orb %sil, %dl
jne 0x67bf
movl $0x0, (%r12,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x675e
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/sacak-lyndon.c
// Function: induceSAs0
void induceSAs0(int_t *SA,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  for(i=n-1; i>0; i--)
    if(SA[i]>0) {
      j=SA[i]-1;
      if(chr(j)<=chr(j+1) && bkt[chr(j)]<i) {
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]--;
        if(!suffix) SA[i]=0;
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %ecx, %r13d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x40(%rsp), %ebp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %r8d, %ecx
movl $0x1, %r8d
movl %ebp, %r9d
callq 0x65f5
cmpl $0x2, %r13d
jl 0x6887
movl %r13d, %eax
decq %rax
movslq (%r12,%rax,4), %rdx
testq %rdx, %rdx
jle 0x6877
leal -0x1(%rdx), %ecx
cmpl $0x4, %ebp
jne 0x6847
movslq (%r15,%rcx,4), %rsi
cmpl (%r15,%rdx,4), %esi
jg 0x6877
movslq (%r14,%rsi,4), %rdx
cmpq %rdx, %rax
jle 0x6877
movl %ecx, (%r12,%rdx,4)
movl (%r15,%rcx,4), %ecx
jmp 0x6864
movzbl (%r15,%rcx), %esi
cmpb (%r15,%rdx), %sil
ja 0x6877
movslq (%r14,%rsi,4), %rdx
cmpq %rdx, %rax
jle 0x6877
movl %ecx, (%r12,%rdx,4)
movzbl (%r15,%rcx), %ecx
movslq %ecx, %rcx
decl (%r14,%rcx,4)
testl %ebx, %ebx
jne 0x6877
movl $0x0, (%r12,%rax,4)
leaq -0x1(%rax), %rcx
incq %rax
cmpq $0x2, %rax
movq %rcx, %rax
ja 0x6819
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/sacak-lyndon.c
// Function: induceSAs0_LA
void induceSAs0_LA(int_t *SA, int_t *LA,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  for(i=n-1; i>0; i--){

		j=SA[i];
		if(!LA[j]){// LA[j]=1;
				int_t l=j+1;
				//while(LA[l++]!=0);
				//LA[j]=l-j-1;
				while(LA[l]!=0) l+=LA[l];//jumping
				LA[j]=l-j;
		}

    if(SA[i]>0) {

      j=SA[i]-1;
      if(chr(j)<=chr(j+1) && bkt[chr(j)]<i) {
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]--;
        if(!suffix) SA[i]=0;
      }
    }
	}

	LA[n-1]=1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movl 0x48(%rsp), %ebp
movq %rdx, %rdi
movq %rcx, %rsi
movl %r8d, %edx
movl %r9d, %ecx
movl $0x1, %r8d
movl %ebp, %r9d
callq 0x65f5
leal -0x1(%r13), %eax
cmpl $0x2, %r13d
jl 0x697d
movl 0x40(%rsp), %ecx
movl %eax, %edx
movl (%r12,%rdx,4), %esi
movslq %esi, %rdi
cmpl $0x0, (%rbx,%rdi,4)
jne 0x6911
leal 0x1(%rsi), %r9d
movl %r9d, %r8d
movslq %r9d, %r9
movl (%rbx,%r9,4), %r10d
leal (%r10,%r8), %r9d
testl %r10d, %r10d
jne 0x68f3
subl %esi, %r8d
movl %r8d, (%rbx,%rdi,4)
movl (%r12,%rdx,4), %esi
testl %esi, %esi
jle 0x696c
leal -0x1(%rsi), %edi
movl %esi, %esi
cmpl $0x4, %ebp
jne 0x693c
movslq (%r15,%rdi,4), %r8
cmpl (%r15,%rsi,4), %r8d
jg 0x696c
movslq (%r14,%r8,4), %rsi
cmpq %rsi, %rdx
jle 0x696c
movl %edi, (%r12,%rsi,4)
movl (%r15,%rdi,4), %esi
jmp 0x6959
movzbl (%r15,%rdi), %r8d
cmpb (%r15,%rsi), %r8b
ja 0x696c
movslq (%r14,%r8,4), %rsi
cmpq %rsi, %rdx
jle 0x696c
movl %edi, (%r12,%rsi,4)
movzbl (%r15,%rdi), %esi
movslq %esi, %rsi
decl (%r14,%rsi,4)
testl %ecx, %ecx
jne 0x696c
movl $0x0, (%r12,%rdx,4)
leaq -0x1(%rdx), %rsi
cmpq $0x1, %rdx
movq %rsi, %rdx
jg 0x68e2
cltq
movl $0x1, (%rbx,%rax,4)
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/sacak-lyndon.c
// Function: induceSAs0_LA_17n
void induceSAs0_LA_17n(int_t *SA, int_t *LA, int_t *PREV, int_t *NEXT,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  for(i=n-1; i>0; i--){

		j=SA[i];

		LA[j]=NEXT[j]-j;	
		NEXT[PREV[j]]=NEXT[j];
		PREV[NEXT[j]]=PREV[j];

    if(SA[i]>0) {

      j=SA[i]-1;
      if(chr(j)<=chr(j+1) && bkt[chr(j)]<i) {
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]--;
        if(!suffix) SA[i]=0;
      }
    }
	}

	LA[n-1]=1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbp
movl 0x58(%rsp), %r9d
movl 0x40(%rsp), %edx
movl 0x48(%rsp), %ecx
movq %r8, %rdi
movq %rbx, %rsi
movl $0x1, %r8d
callq 0x65f5
movl 0x40(%rsp), %ecx
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jl 0x6a7d
movl 0x50(%rsp), %ecx
movl %eax, %edx
movslq (%rbp,%rdx,4), %rsi
movl (%r12,%rsi,4), %edi
subl %esi, %edi
movl %edi, (%r15,%rsi,4)
movslq (%r12,%rsi,4), %rdi
movslq (%r13,%rsi,4), %r8
movl %edi, (%r12,%r8,4)
movl (%r13,%rsi,4), %esi
movl %esi, (%r13,%rdi,4)
movslq (%rbp,%rdx,4), %rdi
testq %rdi, %rdi
jle 0x6a6c
leal -0x1(%rdi), %esi
cmpl $0x4, 0x58(%rsp)
jne 0x6a3d
movslq (%r14,%rsi,4), %r8
cmpl (%r14,%rdi,4), %r8d
jg 0x6a6c
movslq (%rbx,%r8,4), %rdi
cmpq %rdi, %rdx
jle 0x6a6c
movl %esi, (%rbp,%rdi,4)
movl (%r14,%rsi,4), %esi
jmp 0x6a5a
movzbl (%r14,%rsi), %r8d
cmpb (%r14,%rdi), %r8b
ja 0x6a6c
movslq (%rbx,%r8,4), %rdi
cmpq %rdi, %rdx
jle 0x6a6c
movl %esi, (%rbp,%rdi,4)
movzbl (%r14,%rsi), %esi
movslq %esi, %rsi
decl (%rbx,%rsi,4)
testl %ecx, %ecx
jne 0x6a6c
movl $0x0, (%rbp,%rdx,4)
leaq -0x1(%rdx), %rsi
cmpq $0x1, %rdx
movq %rsi, %rdx
jg 0x69e6
cltq
movl $0x1, (%r15,%rax,4)
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/sacak-lyndon.c
// Function: induceSAs0_LA_13n
void induceSAs0_LA_13n(int_t *SA, int_t *LA, int_t *PREV,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  for(i=n-1; i>0; i--){

		j=SA[i];

		int_t next, prev=PREV[j];
		if(LA[j+1]==0) next=j+1;
		else next=PREV[j+1];

		LA[j]=next-j;	

		PREV[next]=prev;
		PREV[prev+1]=next;

    if(SA[i]>0) {
      j=SA[i]-1;
      if(chr(j)<=chr(j+1) && bkt[chr(j)]<i) {
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]--;
        if(!suffix) SA[i]=0;
      }
    }
	}

	LA[n-1]=1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl 0x50(%rsp), %r9d
movl 0x40(%rsp), %ecx
movq %r15, %rdi
movq %r8, %rsi
movl %ebp, %edx
movl $0x1, %r8d
callq 0x65f5
movl 0x50(%rsp), %r11d
leal -0x1(%rbp), %eax
cmpl $0x2, %ebp
jl 0x6b91
movl 0x48(%rsp), %ecx
movl %eax, %edx
movslq (%r13,%rdx,4), %rsi
cmpl $0x0, 0x4(%r14,%rsi,4)
je 0x6afd
movl 0x4(%r12,%rsi,4), %r8d
movslq %r8d, %rdi
jmp 0x6b04
leaq 0x1(%rsi), %rdi
movl %edi, %r8d
movl (%r12,%rsi,4), %r9d
movslq %r9d, %r9
movl %r8d, %r10d
subl %esi, %r10d
movl %r10d, (%r14,%rsi,4)
movl %r9d, (%r12,%rdi,4)
movl %r8d, 0x4(%r12,%r9,4)
movslq (%r13,%rdx,4), %rdi
testq %rdi, %rdi
jle 0x6b80
leal -0x1(%rdi), %esi
cmpl $0x4, %r11d
jne 0x6b4f
movslq (%r15,%rsi,4), %r8
cmpl (%r15,%rdi,4), %r8d
jg 0x6b80
movslq (%rbx,%r8,4), %rdi
cmpq %rdi, %rdx
jle 0x6b80
movl %esi, (%r13,%rdi,4)
movl (%r15,%rsi,4), %esi
jmp 0x6b6d
movzbl (%r15,%rsi), %r8d
cmpb (%r15,%rdi), %r8b
ja 0x6b80
movslq (%rbx,%r8,4), %rdi
cmpq %rdi, %rdx
jle 0x6b80
movl %esi, (%r13,%rdi,4)
movzbl (%r15,%rsi), %esi
movslq %esi, %rsi
decl (%rbx,%rsi,4)
testl %ecx, %ecx
jne 0x6b80
movl $0x0, (%r13,%rdx,4)
leaq -0x1(%rdx), %rsi
cmpq $0x1, %rdx
movq %rsi, %rdx
jg 0x6ae6
cltq
movl $0x1, (%r14,%rax,4)
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/sacak-lyndon.c
// Function: induceSAs0_LA_9n
void induceSAs0_LA_9n(int_t *SA, int_t *LA, 
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int_t suffix, int cs) {
  int_t i, j;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  for(i=n-1; i>0; i--){

    #if DEBUG
	    printf("\n\n");
	    printf("LA (%d)\n",SA[i]);
      for(j=0; j<n; j++)
	    	printf("%" PRIdN "\t", LA[j]);
	    printf("\n\n");
    #endif

		j=SA[i];
		int_t next, prev;

    if(SA[i]>0) {

      if(LA[j-1]<j) prev=LA[j-1];
      else prev=j-1;
	    next=LA[j];

		  LA[next-1]=prev;
      if(prev>=0) LA[prev]=next;

      j=SA[i]-1;
      if(chr(j)<=chr(j+1) && bkt[chr(j)]<i) { //Inducing S-type
        SA[bkt[chr(j)]]=j;
        bkt[chr(j)]--;
        if(!suffix) SA[i]=0;
      }
    }
    else{
      prev=j-1;
	    next=LA[j];
		  LA[next-1]=prev;
    }
	}

  #if DEBUG
	  printf("\n\n");
	  printf("LA (%d)\n",SA[i]);
    for(j=0; j<n; j++)
	  	printf("%" PRIdN "\t", LA[j]);
	  printf("\n\n");
  #endif 

	LA[n-1]=n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movl 0x48(%rsp), %ebp
movq %rdx, %rdi
movq %rcx, %rsi
movl %r8d, %edx
movl %r9d, %ecx
movl $0x1, %r8d
movl %ebp, %r9d
callq 0x65f5
leal -0x1(%rbx), %eax
cmpl $0x2, %ebx
jl 0x6c9e
movl 0x40(%rsp), %ecx
movl %eax, %edx
movslq (%r13,%rdx,4), %rdi
leal -0x1(%rdi), %esi
testq %rdi, %rdi
jle 0x6c50
movl %esi, %r8d
movl (%r14,%r8,4), %r8d
cmpl %edi, %r8d
cmovll %r8d, %esi
movslq (%r14,%rdi,4), %rdi
movl %esi, -0x4(%r14,%rdi,4)
testl %esi, %esi
js 0x6c22
movl %esi, %esi
movl %edi, (%r14,%rsi,4)
movslq (%r13,%rdx,4), %rdi
leaq -0x1(%rdi), %rsi
cmpl $0x4, %ebp
jne 0x6c5b
movslq -0x4(%r12,%rdi,4), %r8
cmpl (%r12,%rdi,4), %r8d
jg 0x6c8d
movslq (%r15,%r8,4), %r8
cmpq %r8, %rdx
jle 0x6c8d
movl %esi, (%r13,%r8,4)
movl -0x4(%r12,%rdi,4), %esi
jmp 0x6c79
movslq (%r14,%rdi,4), %rdi
movl %esi, -0x4(%r14,%rdi,4)
jmp 0x6c8d
movzbl (%r12,%rsi), %r8d
cmpb (%r12,%rdi), %r8b
ja 0x6c8d
movslq (%r15,%r8,4), %rdi
cmpq %rdi, %rdx
jle 0x6c8d
movl %esi, (%r13,%rdi,4)
movzbl (%r12,%rsi), %esi
movslq %esi, %rsi
decl (%r15,%rsi,4)
testl %ecx, %ecx
jne 0x6c8d
movl $0x0, (%r13,%rdx,4)
leaq -0x1(%rdx), %rsi
cmpq $0x1, %rdx
movq %rsi, %rdx
jg 0x6bf4
cltq
movl %ebx, (%r14,%rax,4)
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/sacak-lyndon.c
// Function: putSubstr0
void putSubstr0(int_t *SA,
  int_t *s, int_t *bkt,
  int_t n, unsigned int K, int cs) {
  int_t i, cur_t, succ_t;

  // find the end of each bucket.
  getBuckets_k(s, bkt, n, K, true, cs);

  // set each item in SA as empty.
  for(i=0; i<n; i++) SA[i]=0;

  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) SA[bkt[chr(i)]--]=i;
    succ_t=cur_t;
  }

  // set the single sentinel LMS-substring.
  SA[0]=n-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movl %r8d, %ecx
movl $0x1, %r8d
callq 0x65f5
testl %ebx, %ebx
jle 0x6d8e
movl %ebx, %edx
shlq $0x2, %rdx
xorl %r13d, %r13d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
cmpl $0x3, %ebx
jb 0x6d8e
leal -0x2(%rbx), %eax
cmpl $0x4, %ebp
jne 0x6d39
movl -0x4(%r12,%rax,4), %edx
movl (%r12,%rax,4), %esi
movb $0x1, %cl
cmpl %esi, %edx
jl 0x6d79
sete %dil
testl %r13d, %r13d
setne %cl
andb %dil, %cl
testl %r13d, %r13d
je 0x6d79
cmpl %esi, %edx
je 0x6d79
movl (%r12,%rax,4), %ecx
jmp 0x6d65
movb -0x1(%r12,%rax), %dl
movb (%r12,%rax), %sil
movb $0x1, %cl
cmpb %sil, %dl
jb 0x6d79
sete %dil
testl %r13d, %r13d
setne %cl
andb %dil, %cl
testl %r13d, %r13d
je 0x6d79
cmpb %sil, %dl
je 0x6d79
movzbl (%r12,%rax), %ecx
movslq %ecx, %rcx
movslq (%r15,%rcx,4), %rdx
leal -0x1(%rdx), %esi
movl %esi, (%r15,%rcx,4)
movl %eax, (%r14,%rdx,4)
xorl %ecx, %ecx
movzbl %cl, %r13d
leaq -0x1(%rax), %rcx
cmpq $0x1, %rax
movq %rcx, %rax
jg 0x6d09
decl %ebx
movl %ebx, (%r14)
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/sacak-lyndon.c
// Function: getLengthOfLMS
int_t getLengthOfLMS(int_t *s, 
  int_t n, int level, int_t x, int cs) {
  if(x==n-1) return 1;  
  
  int_t dist=0, i=1;  
  while(1) {
    if(chr(x+i)<chr(x+i-1)) break;
    i++;
  }  
  while(1) {
    if(x+i>n-1 || chr(x+i)>chr(x+i-1)) break;
    if(x+i==n-1 || chr(x+i)<chr(x+i-1)) dist=i;
    i++;
  }
  
  return dist+1;
}

// Assembly:
leal -0x1(%rsi), %r9d
movl $0x1, %eax
cmpl %ecx, %r9d
je 0x74df
pushq %rbp
pushq %r14
pushq %rbx
movslq %ecx, %r10
leaq (%r10,%rdi), %r11
incq %r11
leaq (%rdi,%r10,4), %rbx
addq $0x4, %rbx
xorl %edx, %edx
cmpl $0x4, %r8d
jne 0x745b
movl -0x4(%rbx,%rdx,4), %r14d
movl (%rbx,%rdx,4), %ebp
jmp 0x7466
movzbl (%r11,%rdx), %ebp
movzbl -0x1(%r11,%rdx), %r14d
incq %rdx
cmpl %r14d, %ebp
jge 0x744b
movl %ecx, %ecx
addq %rdx, %rcx
cmpl %esi, %ecx
popq %rbx
popq %r14
popq %rbp
jge 0x74df
movslq %ecx, %rcx
movslq %esi, %rsi
movslq %r9d, %r9
subq %r10, %rsi
xorl %eax, %eax
cmpl $0x4, %r8d
jne 0x749a
movl -0x4(%rdi,%rcx,4), %r11d
movl (%rdi,%rcx,4), %r10d
jmp 0x74a5
movzbl (%rdi,%rcx), %r10d
movzbl -0x1(%rdi,%rcx), %r11d
cmpl %r11d, %r10d
jg 0x74dd
cmpq %rcx, %r9
je 0x74d0
cmpl $0x4, %r8d
jne 0x74c0
movl -0x4(%rdi,%rcx,4), %r11d
movl (%rdi,%rcx,4), %r10d
jmp 0x74cb
movzbl (%rdi,%rcx), %r10d
movzbl -0x1(%rdi,%rcx), %r11d
cmpl %r11d, %r10d
jge 0x74d2
movl %edx, %eax
incq %rdx
incq %rcx
cmpq %rsi, %rdx
jl 0x7489
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leal -0x1(%rcx), %eax
movslq %r8d, %rdi
movl %eax, -0x4(%rdx,%rdi,4)
cmpl $0x3, %ecx
jl 0x783c
pushq %rbx
movl 0x10(%rsp), %eax
addl $-0x2, %ecx
addl $-0x2, %r8d
xorl %edi, %edi
cmpl $0x4, %eax
jne 0x77ec
movl -0x4(%rsi,%rcx,4), %r10d
movl (%rsi,%rcx,4), %r11d
movl $0x1, %r9d
cmpl %r11d, %r10d
jge 0x7802
jmp 0x782b
movzbl -0x1(%rsi,%rcx), %r10d
movzbl (%rsi,%rcx), %r11d
movl $0x1, %r9d
cmpb %r11b, %r10b
jb 0x782b
cmpl %r11d, %r10d
sete %r9b
testl %edi, %edi
setne %bl
andb %r9b, %bl
movzbl %bl, %r9d
cmpl $0x1, %edi
jne 0x782b
cmpl %r11d, %r10d
je 0x782b
movslq %r8d, %rdi
decl %r8d
movl %ecx, (%rdx,%rdi,4)
xorl %r9d, %r9d
leaq -0x1(%rcx), %r10
movl %r9d, %edi
cmpq $0x1, %rcx
movq %r10, %rcx
jg 0x77d1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0xe7a0(%rip), %rsi      # 0xfa3c
movq %rdx, %rdi
callq 0x1140
movl $0x4e, %ebp
testq %rax, %rax
je 0x12eb
movq %rax, %r13
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1120
testl %eax, %eax
jne 0x12de
movq %r13, %rdi
callq 0x10e0
movq %rax, %r14
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %r14
jne 0x12fc
movq %r13, %rdi
callq 0x1070
movl $0x4e, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x1070
testq %r14, %r14
js 0x12eb
movq %r14, (%r12)
movq %r14, %rdi
callq 0x1100
movq %rax, %r12
movq %rax, (%r15)
testq %rax, %rax
sete %al
testq %r14, %r14
setne %cl
movl $0x53, %ebp
testb %al, %cl
jne 0x12eb
leaq 0xe705(%rip), %rsi      # 0xfa3c
movq %rbx, %rdi
callq 0x1140
movl $0x4e, %ebp
testq %rax, %rax
je 0x12eb
movq %rax, %rbx
movl $0x1, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %rax, %rcx
callq 0x1060
movq %rax, %r15
movq %rbx, %rdi
callq 0x1070
xorl %eax, %eax
cmpq %r14, %r15
movl $0x4e, %ebp
cmovel %eax, %ebp
jmp 0x12eb
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xd7c3(%rip), %rsi      # 0xeb51
movq %rdx, %rdi
callq 0x1140
testq %rax, %rax
je 0x13bd
movq %rax, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1160
movq %r15, %rdi
callq 0x1070
xorl %eax, %eax
jmp 0x13c2
movl $0x4f, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: boundaryPM
static void boundaryPM(BPMLists* lists, BPMNode* leaves, size_t numpresent, int c, int num)
{
  unsigned lastindex = lists->chains1[c]->index;

  if(c == 0)
  {
    if(lastindex >= numpresent) return;
    lists->chains0[c] = lists->chains1[c];
    lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, 0);
  }
  else
  {
    /*sum of the weights of the head nodes of the previous lookahead chains.*/
    int sum = lists->chains0[c - 1]->weight + lists->chains1[c - 1]->weight;
    lists->chains0[c] = lists->chains1[c];
    if(lastindex < numpresent && sum > leaves[lastindex].weight)
    {
      lists->chains1[c] = bpmnode_create(lists, leaves[lastindex].weight, lastindex + 1, lists->chains1[c]->tail);
      return;
    }
    lists->chains1[c] = bpmnode_create(lists, sum, lastindex, lists->chains1[c - 1]);
    /*in the end we are only interested in the chain of the last list, so no
    need to recurse if we're at the last one (this gives measurable speedup)*/
    if(num + 1 < (int)(2 * numpresent - 2))
    {
      boundaryPM(lists, leaves, numpresent, c - 1, num);
      boundaryPM(lists, leaves, numpresent, c - 1, num);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rdx
movslq %ecx, %r13
movq (%rdx,%r13,8), %rax
movl 0x4(%rax), %ecx
testl %r13d, %r13d
je 0x1aa5
movq %r8, 0x10(%rsp)
leal 0x1(%r8), %esi
movl %esi, 0x4(%rsp)
leal -0x2(,%r15,2), %esi
movl %esi, (%rsp)
leaq (,%r13,8), %r12
leal -0x1(%r13), %esi
movq %rsi, 0x8(%rsp)
xorl %ebp, %ebp
movq 0x28(%rbx), %rdi
addq %r12, %rdi
movq -0x8(%rdi,%rbp,8), %r8
addq %r12, %rdx
movq -0x8(%rdx,%rbp,8), %rdx
movl (%rdx), %esi
addl (%r8), %esi
movq %rax, (%rdi,%rbp,8)
movl %ecx, %edx
cmpq %r15, %rdx
jae 0x1a3f
leaq (%rdx,%rdx,2), %rax
movl (%r14,%rax,8), %eax
cmpl %eax, %esi
jg 0x1acd
movq 0x30(%rbx), %rax
addq %r12, %rax
movq -0x8(%rax,%rbp,8), %rcx
movq %rbx, %rdi
callq 0x17dd
movq 0x30(%rbx), %rcx
addq %r12, %rcx
movq %rax, (%rcx,%rbp,8)
movl (%rsp), %eax
cmpl %eax, 0x4(%rsp)
jge 0x1af0
movq 0x8(%rsp), %rax
leal (%rax,%rbp), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq 0x10(%rsp), %r8
callq 0x19b2
movq 0x30(%rbx), %rdx
leaq (%rdx,%r12), %rax
movq -0x8(%rax,%rbp,8), %rax
movl 0x4(%rax), %ecx
decq %rbp
movq %r13, %rsi
addq %rbp, %rsi
jne 0x1a0b
movl %ecx, %ecx
cmpq %r15, %rcx
jae 0x1af0
movq 0x28(%rbx), %rdx
movq %rax, (%rdx)
leaq (%rcx,%rcx,2), %rax
movl (%r14,%rax,8), %esi
leal 0x1(%rcx), %edx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x17dd
jmp 0x1ae8
incl %edx
addq 0x30(%rbx), %r12
movq (%r12,%rbp,8), %rcx
movq 0x8(%rcx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x17dd
addq %rbp, %r13
movq 0x30(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_crc32
unsigned lodepng_crc32(const unsigned char* data, size_t length)
{
  unsigned r = 0xffffffffu;
  size_t i;
  for(i = 0; i < length; ++i)
  {
    r = lodepng_crc32_table[(r ^ data[i]) & 0xff] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
testq %rsi, %rsi
je 0x47ec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
leaq 0x9ad1(%rip), %rdx      # 0xe2a0
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x47cf
notl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_chunk_check_crc
unsigned lodepng_chunk_check_crc(const unsigned char* chunk)
{
  unsigned length = lodepng_chunk_length(chunk);
  unsigned CRC = lodepng_read32bitInt(&chunk[length + 8]);
  /*the CRC is taken of the data and the 4 chunk type letters, not the length*/
  unsigned checksum = lodepng_crc32(&chunk[4], length + 4);
  if(CRC != checksum) return 1;
  else return 0;
}

// Assembly:
movl (%rdi), %r9d
bswapl %r9d
leal 0x8(%r9), %edx
movzbl (%rdi,%rdx), %eax
movzbl 0x1(%rdi,%rdx), %esi
movzbl 0x2(%rdi,%rdx), %ecx
movzbl 0x3(%rdi,%rdx), %edx
addl $0x4, %r9d
je 0x48dd
pushq %rbx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
leaq 0x99e4(%rip), %r11      # 0xe2a0
movb 0x4(%rdi,%r10), %bl
xorb %r8b, %bl
movzbl %bl, %ebx
shrl $0x8, %r8d
xorl (%r11,%rbx,4), %r8d
incq %r10
cmpq %r10, %r9
jne 0x48bc
notl %r8d
popq %rbx
jmp 0x48e0
xorl %r8d, %r8d
shll $0x10, %esi
shll $0x18, %eax
orl %esi, %eax
shll $0x8, %ecx
orl %eax, %ecx
orl %edx, %ecx
xorl %eax, %eax
cmpl %r8d, %ecx
setne %al
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_chunk_append
unsigned lodepng_chunk_append(unsigned char** out, size_t* outlength, const unsigned char* chunk)
{
  unsigned i;
  unsigned total_chunk_length = lodepng_chunk_length(chunk) + 12;
  unsigned char *chunk_start, *new_buffer;
  size_t new_length = (*outlength) + total_chunk_length;
  if(new_length < total_chunk_length || new_length < (*outlength)) return 77; /*integer overflow happened*/

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movzbl (%rdx), %r13d
shll $0x18, %r13d
movzbl 0x1(%rdx), %r15d
shll $0x10, %r15d
leal (%r15,%r13), %eax
movzbl 0x2(%rdx), %r14d
shll $0x8, %r14d
orl %r14d, %eax
movzbl 0x3(%rdx), %ecx
leal (%rcx,%rax), %ebp
addl $0xc, %ebp
movq (%rsi), %rax
movq %rbp, %r12
movl $0x4d, %edx
addq %rax, %r12
jb 0x4a03
movq %rax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rdi), %rdi
movq %r12, %rsi
callq 0x1130
testq %rax, %rax
je 0x49fe
movq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq 0x20(%rsp), %rcx
movq %r12, (%rcx)
xorl %edx, %edx
testl %ebp, %ebp
je 0x4a03
addq 0x8(%rsp), %rax
orl %r15d, %r13d
orl %r14d, %r13d
movq 0x10(%rsp), %rcx
leal (%rcx,%r13), %edx
addl $0xb, %edx
incq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x10f0
xorl %edx, %edx
jmp 0x4a03
movl $0x53, %edx
movl %edx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_chunk_create
unsigned lodepng_chunk_create(unsigned char** out, size_t* outlength, unsigned length,
                              const char* type, const unsigned char* data)
{
  unsigned i;
  unsigned char *chunk, *new_buffer;
  size_t new_length = (*outlength) + length + 12;
  if(new_length < length + 12 || new_length < (*outlength)) return 77; /*integer overflow happened*/
  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outlength) = new_length;
  chunk = &(*out)[(*outlength) - length - 12];

  /*1: length*/
  lodepng_set32bitInt(chunk, (unsigned)length);

  /*2: chunk name (4 letters)*/
  chunk[4] = (unsigned char)type[0];
  chunk[5] = (unsigned char)type[1];
  chunk[6] = (unsigned char)type[2];
  chunk[7] = (unsigned char)type[3];

  /*3: the data*/
  for(i = 0; i != length; ++i) chunk[8 + i] = data[i];

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
movl %edx, %r13d
leaq 0xc(%r13), %rbp
addq (%rsi), %rbp
setb %al
leal 0xc(%r14), %esi
cmpq %rsi, %rbp
setb %sil
orb %al, %sil
movl $0x4d, %eax
jne 0x4ad1
movq %r8, %rbx
movq %rdi, %r12
movq %rcx, (%rsp)
movq (%rdi), %rdi
movq %rbp, %rsi
callq 0x1130
testq %rax, %rax
je 0x4acc
movq %rax, (%r12)
movq %rbp, (%r15)
subq %r13, %rbp
leaq (%rax,%rbp), %rdi
addq $-0xc, %rdi
movq %r14, %rdx
movl %edx, %ecx
shrl $0x18, %ecx
movb %cl, -0xc(%rax,%rbp)
movl %edx, %ecx
shrl $0x10, %ecx
movb %cl, -0xb(%rax,%rbp)
movb %dh, -0xa(%rax,%rbp)
movb %dl, -0x9(%rax,%rbp)
movq (%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x8(%rax,%rbp)
testl %edx, %edx
je 0x4ac3
negq %r13
movl $0x8, %eax
movb -0x8(%rbx,%rax), %cl
movl %eax, %edx
movb %cl, (%rdi,%rdx)
leaq (%rax,%r13), %rcx
incq %rcx
incq %rax
cmpq $0x8, %rcx
jne 0x4aaa
callq 0x48f8
xorl %eax, %eax
jmp 0x4ad1
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_color_mode_copy
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
{
  size_t i;
  lodepng_color_mode_cleanup(dest);
  *dest = *source;
  if(source->palette)
  {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    for(i = 0; i != source->palettesize * 4; ++i) dest->palette[i] = source->palette[i];
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4b52
callq 0x1030
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
xorl %r14d, %r14d
cmpq $0x0, 0x8(%rbx)
je 0x4bcd
movl $0x400, %edi            # imm = 0x400
callq 0x1100
movq %rax, (%r15)
movq 0x10(%rbx), %rcx
testq %rax, %rax
je 0x4bbe
shlq $0x2, %rcx
testq %rcx, %rcx
je 0x4bcd
xorl %r14d, %r14d
xorl %eax, %eax
movq 0x8(%rbx), %rcx
movb (%rcx,%rax), %cl
movq (%r15), %rdx
movb %cl, (%rdx,%rax)
incq %rax
movq 0x10(%rbx), %rcx
shlq $0x2, %rcx
cmpq %rcx, %rax
jne 0x4b9f
jmp 0x4bcd
xorl %eax, %eax
testq %rcx, %rcx
movl $0x53, %r14d
cmovel %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_palette_add
unsigned lodepng_palette_add(LodePNGColorMode* info,
                             unsigned char r, unsigned char g, unsigned char b, unsigned char a)
{
  unsigned char* data;
  /*the same resize technique as C++ std::vectors is used, and here it's made so that for a palette with
  the max of 256 colors, it'll have the exact alloc size*/
  if(!info->palette) /*allocate palette if empty*/
  {
    /*room for 256 colors with 4 bytes each*/
    data = (unsigned char*)lodepng_realloc(info->palette, 1024);
    if(!data) return 83; /*alloc fail*/
    else info->palette = data;
  }
  info->palette[4 * info->palettesize + 0] = r;
  info->palette[4 * info->palettesize + 1] = g;
  info->palette[4 * info->palettesize + 2] = b;
  info->palette[4 * info->palettesize + 3] = a;
  ++info->palettesize;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movq 0x8(%rdi), %rax
testq %rax, %rax
jne 0x4c08
movl $0x400, %edi            # imm = 0x400
callq 0x1100
testq %rax, %rax
je 0x4c45
movq %rax, 0x8(%r14)
movq 0x10(%r14), %rcx
movb %r12b, (%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %r15b, 0x1(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bpl, 0x2(%rax,%rcx,4)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movb %bl, 0x3(%rax,%rcx,4)
incq 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x53, %eax
jmp 0x4c3c
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_get_raw_size
size_t lodepng_get_raw_size(unsigned w, unsigned h, const LodePNGColorMode* color)
{
  /*will not overflow for any color type if roughly w * h < 268435455*/
  size_t bpp = lodepng_get_bpp(color);
  size_t n = w * h;
  return ((n / 8) * bpp) + ((n & 7) * bpp + 7) / 8;
}

// Assembly:
movl %esi, %eax
movl (%rdx), %esi
movl 0x4(%rdx), %edx
xorl %ecx, %ecx
cmpq $0x6, %rsi
ja 0x4d0c
leaq 0x9dfb(%rip), %rcx      # 0xeb04
movl (%rcx,%rsi,4), %ecx
imull %edx, %ecx
imull %edi, %eax
movl %eax, %edx
shrl $0x3, %edx
imulq %rcx, %rdx
andl $0x7, %eax
imulq %rcx, %rax
addq $0x7, %rax
shrq $0x3, %rax
addq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_get_raw_size_lct
size_t lodepng_get_raw_size_lct(unsigned w, unsigned h, LodePNGColorType colortype, unsigned bitdepth)
{
  /*will not overflow for any color type if roughly w * h < 268435455*/
  size_t bpp = lodepng_get_bpp_lct(colortype, bitdepth);
  size_t n = w * h;
  return ((n / 8) * bpp) + ((n & 7) * bpp + 7) / 8;
}

// Assembly:
movl %esi, %eax
xorl %esi, %esi
cmpl $0x6, %edx
ja 0x4d43
movl %edx, %edx
leaq 0x9dc4(%rip), %rsi      # 0xeb04
movl (%rsi,%rdx,4), %esi
imull %ecx, %esi
imull %edi, %eax
movl %eax, %ecx
shrl $0x3, %ecx
imulq %rsi, %rcx
andl $0x7, %eax
imulq %rsi, %rax
addq $0x7, %rax
shrq $0x3, %rax
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: LodePNGText_cleanup
static void LodePNGText_cleanup(LodePNGInfo* info)
{
  size_t i;
  for(i = 0; i != info->text_num; ++i)
  {
    string_cleanup(&info->text_keys[i]);
    string_cleanup(&info->text_strings[i]);
  }
  lodepng_free(info->text_keys);
  lodepng_free(info->text_strings);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x4daa
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x1030
movq %r14, (%r12,%r15,8)
movq 0x58(%rbx), %r12
movq (%r12,%r15,8), %rdi
callq 0x1030
movq %r14, (%r12,%r15,8)
incq %r15
cmpq 0x48(%rbx), %r15
jne 0x4d7f
movq 0x50(%rbx), %rdi
callq 0x1030
movq 0x58(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: lodepng_add_text
unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
{
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
  if(!new_keys || !new_strings)
  {
    lodepng_free(new_keys);
    lodepng_free(new_strings);
    return 83; /*alloc fail*/
  }

  ++info->text_num;
  info->text_keys = new_keys;
  info->text_strings = new_strings;

  string_init(&info->text_keys[info->text_num - 1]);
  string_set(&info->text_keys[info->text_num - 1], key);

  string_init(&info->text_strings[info->text_num - 1]);
  string_set(&info->text_strings[info->text_num - 1], str);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x1130
movq %rax, %r12
movq 0x48(%r14), %rax
movq 0x58(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x1130
movq %rax, %r13
testq %r12, %r12
setne %al
testq %r13, %r13
setne %cl
testb %cl, %al
je 0x4ea6
movq %rbx, (%rsp)
movq 0x48(%r14), %rbx
leaq 0x1(%rbx), %rbp
movq %rbp, 0x48(%r14)
movq %r12, 0x50(%r14)
movq %r13, 0x58(%r14)
movq $0x0, (%r12,%rbx,8)
movl $0x1, %edi
callq 0x1100
testq %rax, %rax
je 0x4e55
movb $0x0, (%rax)
movq %rax, (%r12,%rbx,8)
leaq (%r12,%rbp,8), %rdi
addq $-0x8, %rdi
movq %r15, %rsi
callq 0x4eca
movq 0x48(%r14), %rbx
movq 0x58(%r14), %r15
movq $0x0, -0x8(%r15,%rbx,8)
movl $0x1, %edi
callq 0x1100
testq %rax, %rax
je 0x4e8d
movb $0x0, (%rax)
movq %rax, -0x8(%r15,%rbx,8)
movq 0x58(%r14), %rax
leaq (%rax,%rbx,8), %rdi
addq $-0x8, %rdi
movq (%rsp), %rsi
callq 0x4eca
xorl %eax, %eax
jmp 0x4ebb
movq %r12, %rdi
callq 0x1030
movq %r13, %rdi
callq 0x1030
movl $0x53, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Joy-Division[P]tools-mgs/lodepng/lodepng.c
// Function: string_set
static void string_set(char** out, const char* in)
{
  size_t insize = strlen(in), i;
  if(string_resize(out, insize))
  {
    for(i = 0; i != insize; ++i)
    {
      (*out)[i] = in[i];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1090
movq %rax, %r15
movq (%r14), %rdi
leaq 0x1(%rax), %rsi
callq 0x1130
testq %rax, %rax
je 0x4f11
movb $0x0, (%rax,%r15)
movq %rax, (%r14)
testq %r15, %r15
je 0x4f11
xorl %eax, %eax
movb (%rbx,%rax), %cl
movq (%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
cmpq %rax, %r15
jne 0x4f00
popq %rbx
popq %r14
popq %r15
retq