LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: putSuffix0_generalized_DA
void putSuffix0_generalized_DA(uint_t *SA, int_t *DA,
  uint_t *s, uint_t *bkt, 
  uint_t n, unsigned int K, int_t n1, int cs, uint_t separator) {
  uint_t i, j;

  // find the end of each bucket.
  getBuckets_k((int_t*)s, bkt, n, K, true, cs);

  int_t tmp=bkt[separator]--;// shifts one position left of bkt[separator]
  
  // put the suffixes into their buckets.
  for(i=n1-1; i>0; i--) {
    j=SA[i]; SA[i]=0;
    SA[bkt[chr(j)]]=j;
    DA[bkt[chr(j)]--]=DA[i];
  }

 // SA[0]=n-1; // set the single sentinel suffix.

  SA[tmp]=SA[0]-1;// insert the last separator at the end of bkt[separator]
  DA[tmp]=tmp-1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl 0x18(%rbp), %r9d
movl $0x1, %r8d
callq 0x81c0
movq -0x20(%rbp), %rcx
movq 0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rax
movq %rax, %rsi
addq $-0x1, %rsi
movq %rsi, (%rcx,%rdx,8)
movq %rax, -0x48(%rbp)
movq 0x10(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x8883
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x8, %rax
jne 0x87d2
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
jmp 0x87e2
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x68(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq 0x18(%rbp), %rax
cmpq $0x8, %rax
jne 0x8839
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
jmp 0x884c
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rdx
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rdi
movq (%rsi,%rdi,8), %rcx
movq %rcx, %r8
addq $-0x1, %r8
movq %r8, (%rsi,%rdi,8)
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8773
movq -0x8(%rbp), %rax
movq (%rax), %rdx
subq $0x1, %rdx
movq -0x8(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rdx
subq $0x1, %rdx
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: induceSAl0
void induceSAl0(uint_t *SA,
  int_t *s, uint_t *bkt,
  uint_t n, unsigned int K, int_t suffix, int cs) {
  uint_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
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl 0x10(%rbp), %r9d
xorl %r8d, %r8d
callq 0x81c0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x8d01
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x8cee
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x8bc8
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x8bd8
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x8bfd
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
jmp 0x8c0e
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jl 0x8cec
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x8c53
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
jmp 0x8c63
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rdx
movq -0x60(%rbp), %rcx
movq -0x78(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x8ca2
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
jmp 0x8cb5
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movq -0x88(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x30(%rbp)
jne 0x8cea
cmpq $0x0, -0x38(%rbp)
jbe 0x8cea
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x8cec
jmp 0x8cee
jmp 0x8cf0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8b77
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: induceSAl0_generalized
void induceSAl0_generalized(uint_t *SA,
  uint_t *s, uint_t *bkt,
  uint_t n, unsigned int K, int_t suffix, int cs, uint_t separator) {
  uint_t i, j;

  // find the head of each bucket.
  getBuckets_k((int_t*)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) ) {
	if(chr(j)!=separator)//gsa-is
          SA[bkt[chr(j)]++]=j;
        if(!suffix && i>0) SA[i]=0;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl 0x10(%rbp), %r9d
xorl %r8d, %r8d
callq 0x81c0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x9125
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x9112
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x8ffc
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
jmp 0x900c
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x9031
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
jmp 0x9042
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl 0x1(%rax,%rcx), %eax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jl 0x9110
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x906f
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
jmp 0x907f
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq 0x18(%rbp), %rax
je 0x90f0
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0x90bd
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
jmp 0x90cd
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x80(%rbp)
movq -0x70(%rbp), %rax
movq -0x78(%rbp), %rdx
movq -0x68(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq (%rsi,%rdi,8), %rcx
movq %rcx, %r8
addq $0x1, %r8
movq %r8, (%rsi,%rdi,8)
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, -0x30(%rbp)
jne 0x910e
cmpq $0x0, -0x38(%rbp)
jbe 0x910e
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x9110
jmp 0x9112
jmp 0x9114
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8fab
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: putSuffix1
void putSuffix1(int_t *SA, int_t *s, int_t n1, int cs) {
  int_t i, j, pos=n1, cur, pre=-1;
  
  for(i=n1-1; i>0; i--) {
    j=SA[i]; SA[i]=EMPTY_k;
    cur=chr(j);
    if(cur!=pre) {
      pre=cur; pos=cur;
    }
    SA[pos--]=j;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $-0x1, -0x48(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jle 0xcc5a
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rax
cmpq $0x8, %rax
jne 0xcbfc
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x50(%rbp)
jmp 0xcc0c
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0xcc2e
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x38(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xcbaf
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: getSAlms
void getSAlms(uint_t *SA, 
  int_t *s, 
  uint_t *s1, uint_t n, 
  uint_t n1, int level, int cs) {
  uint_t i, j, cur_t, succ_t;

  j=n1-1; s1[j--]=n-1;
  succ_t=0; // s[n-2] must be L-type
  for(i=n-2; i>0; i--) {
    cur_t=(chr(i-1)<chr(i) ||
          (chr(i-1)==chr(i) && succ_t==1))?1:0;
    if(cur_t==0 && succ_t==1) s1[j--]=i;
    succ_t=cur_t;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x40(%rbp)
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x50(%rbp)
movq -0x20(%rbp), %rax
subq $0x2, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0xebb0
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0xea5d
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
jmp 0xea71
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0xea95
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
jmp 0xeaa5
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rcx
movq -0x68(%rbp), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x69(%rbp)
jl 0xeb58
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0xeadb
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x78(%rbp)
jmp 0xeaef
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movslq 0x10(%rbp), %rax
cmpq $0x8, %rax
jne 0xeb16
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
jmp 0xeb29
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rcx
movq -0x88(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x89(%rbp)
jne 0xeb4f
cmpq $0x1, -0x50(%rbp)
sete %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xeb97
cmpq $0x1, -0x50(%rbp)
jne 0xeb97
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x40(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xea32
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: gsacak
int gsacak(unsigned char *s, uint_t *SA, int_t *LCP, int_t *DA, uint_t n){
  if((s == NULL) || (SA == NULL) || (n < 0)) return -1;

  if((LCP == NULL) && (DA == NULL))
	return gSACA_K((uint_t*)s, SA, n, 256, sizeof(char), 1, 0);
  else if (DA == NULL)
	return gSACA_K_LCP((uint_t*)s, SA, LCP, n, 256, sizeof(char), 1, 0);
  else if (LCP == NULL)
	return gSACA_K_DA((uint_t*)s, SA, DA, n, 256, sizeof(char), 1, 0);
  else
	return gSACA_K_LCP_DA((uint_t*)s, SA, LCP, DA, n, 256, sizeof(char), 1, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10651
cmpq $0x0, -0x18(%rbp)
je 0x10651
cmpq $0x0, -0x30(%rbp)
jae 0x1065d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10758
cmpq $0x0, -0x20(%rbp)
jne 0x1069e
cmpq $0x0, -0x28(%rbp)
jne 0x1069e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
movl $0x1, %r8d
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xf260
movl %eax, -0x4(%rbp)
jmp 0x10758
cmpq $0x0, -0x28(%rbp)
jne 0x106dd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
movl $0x1, %r9d
xorl %eax, %eax
movq $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xf680
movl %eax, -0x4(%rbp)
jmp 0x10758
cmpq $0x0, -0x20(%rbp)
jne 0x1071c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x100, %r8d            # imm = 0x100
movl $0x1, %r9d
xorl %eax, %eax
movq $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xfb50
movl %eax, -0x4(%rbp)
jmp 0x10758
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x100, %r9d            # imm = 0x100
xorl %eax, %eax
movl $0x1, (%rsp)
movq $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0xffe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/gsacak.c
// Function: gsacak_int
int gsacak_int(uint_t *s, uint_t *SA, int_t *LCP, int_t *DA, uint_t n, uint_t k){
  if((s == NULL) || (SA == NULL) || (n < 0)) return -1;
  
  if((LCP == NULL) && (DA == NULL))
	return gSACA_K((uint_t*)s, SA, n, k, sizeof(int_t), 1, 0);
  else if (DA == NULL)
	return gSACA_K_LCP((uint_t*)s, SA, LCP, n, k, sizeof(int_t), 1, 0);
  else if (LCP == NULL)
	return gSACA_K_DA((uint_t*)s, SA, DA, n, k, sizeof(int_t), 1, 0);
  else
	return gSACA_K_LCP_DA((uint_t*)s, SA, LCP, DA, n, k, sizeof(int_t), 1, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x107a5
cmpq $0x0, -0x18(%rbp)
je 0x107a5
cmpq $0x0, -0x30(%rbp)
jae 0x107b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108b0
cmpq $0x0, -0x20(%rbp)
jne 0x107f3
cmpq $0x0, -0x28(%rbp)
jne 0x107f3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rax
movl %eax, %ecx
movl $0x8, %r8d
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xf260
movl %eax, -0x4(%rbp)
jmp 0x108b0
cmpq $0x0, -0x28(%rbp)
jne 0x10833
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movl %eax, %r8d
movl $0x8, %r9d
xorl %eax, %eax
movq $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xf680
movl %eax, -0x4(%rbp)
jmp 0x108b0
cmpq $0x0, -0x20(%rbp)
jne 0x10873
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movl %eax, %r8d
movl $0x8, %r9d
xorl %eax, %eax
movq $0x1, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0xfb50
movl %eax, -0x4(%rbp)
jmp 0x108b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rax
movl %eax, %r9d
xorl %eax, %eax
movl $0x8, (%rsp)
movq $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0xffe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/malloc_count.c
// Function: malloc
extern void* malloc(size_t size)
{
    void* ret;

    if (size == 0) return NULL;

    if (real_malloc)
    {
        /* call read malloc procedure in libc */
        ret = (*real_malloc)(alignment + size);

        inc_count(size);
        if (log_operations && size >= log_operations_threshold) {
            fprintf(stderr, PPREFIX "malloc(%'lld) = %p   (current %'lld)\n",
                    (long long)size, (char*)ret + alignment, curr);
        }

        /* prepend allocation size and check sentinel */
        *(size_t*)ret = size;
        *(size_t*)((char*)ret + alignment - sizeof(size_t)) = sentinel;

        return (char*)ret + alignment;
    }
    else
    {
        if (init_heap_use + alignment + size > INIT_HEAP_SIZE) {
            fprintf(stderr, PPREFIX "init heap full !!!\n");
            exit(EXIT_FAILURE);
        }

        ret = init_heap + init_heap_use;
        init_heap_use += alignment + size;

        /* prepend allocation size and check sentinel */
        *(size_t*)ret = size;
        *(size_t*)((char*)ret + alignment - sizeof(size_t)) = sentinel;

        if (log_operations_init_heap) {
            fprintf(stderr, PPREFIX "malloc(%'lld) = %p   on init heap\n",
                    (long long)size, (char*)ret + alignment);
        }

        return (char*)ret + alignment;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10980
movq $0x0, -0x8(%rbp)
jmp 0x10a56
cmpq $0x0, 0x4808(%rip)      # 0x15190
je 0x109d1
movq 0x47ff(%rip), %rax      # 0x15190
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a60
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0xdeadc0de, %ecx       # imm = 0xDEADC0DE
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x10a56
movq 0x47c0(%rip), %rax      # 0x15198
addq $0x10, %rax
addq -0x10(%rbp), %rax
cmpq $0x100000, %rax         # imm = 0x100000
jbe 0x10a0a
movq 0x4609(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq 0x127a(%rip), %rsi      # 0x11c73
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2270
leaq 0x478f(%rip), %rax      # 0x151a0
addq 0x4780(%rip), %rax      # 0x15198
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
addq 0x476d(%rip), %rax      # 0x15198
movq %rax, 0x4766(%rip)      # 0x15198
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0xdeadc0de, %ecx       # imm = 0xDEADC0DE
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/malloc_count.c
// Function: free
extern void free(void* ptr)
{
    size_t size;

    if (!ptr) return;   /* free(NULL) is no operation */

    if ((char*)ptr >= init_heap &&
        (char*)ptr <= init_heap + init_heap_use)
    {
        if (log_operations_init_heap) {
            fprintf(stderr, PPREFIX "free(%p)   on init heap\n", ptr);
        }
        return;
    }

    if (!real_free) {
        fprintf(stderr, PPREFIX
                "free(%p) outside init heap and without real_free !!!\n", ptr);
        return;
    }

    ptr = (char*)ptr - alignment;

    if (*(size_t*)((char*)ptr + alignment - sizeof(size_t)) != sentinel) {
        fprintf(stderr, PPREFIX
                "free(%p) has no sentinel !!! memory corruption?\n", ptr);
    }

    size = *(size_t*)ptr;
    dec_count(size);

    if (log_operations && size >= log_operations_threshold) {
        fprintf(stderr, PPREFIX "free(%p) -> %'lld   (current %'lld)\n",
                ptr, (long long)size, curr);
    }

    (*real_free)(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10ae8
jmp 0x10b91
leaq 0x46b1(%rip), %rax      # 0x151a0
cmpq %rax, -0x8(%rbp)
jb 0x10b11
movq -0x8(%rbp), %rax
leaq 0x46a0(%rip), %rcx      # 0x151a0
addq 0x4691(%rip), %rcx      # 0x15198
cmpq %rcx, %rax
ja 0x10b11
jmp 0x10b91
cmpq $0x0, 0x104687(%rip)    # 0x1151a0
jne 0x10b39
movq 0x44d6(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1168(%rip), %rsi      # 0x11c98
movb $0x0, %al
callq 0x2190
jmp 0x10b91
movq -0x8(%rbp), %rax
addq $-0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xdeadc0de, %ecx       # imm = 0xDEADC0DE
cmpq %rcx, 0x8(%rax)
je 0x10b70
movq 0x449d(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1176(%rip), %rsi      # 0x11cdf
movb $0x0, %al
callq 0x2190
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10ba0
movq 0x104615(%rip), %rax    # 0x1151a0
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/malloc_count.c
// Function: calloc
extern void* calloc(size_t nmemb, size_t size)
{
    void* ret;
    size *= nmemb;
    if (!size) return NULL;
    ret = malloc(size);
    memset(ret, 0, size);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x10c1e
movq $0x0, -0x8(%rbp)
jmp 0x10c42
movq -0x18(%rbp), %rdi
callq 0x10960
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2150
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/src/malloc_count.c
// Function: init
static __attribute__((constructor)) void init(void)
{
    char *error;

    setlocale(LC_NUMERIC, ""); /* for better readable numbers */

    dlerror();

    real_malloc = (malloc_type)dlsym(RTLD_NEXT, "malloc");
    if ((error = dlerror()) != NULL) {
        fprintf(stderr,  PPREFIX "error %s\n", error);
        exit(EXIT_FAILURE);
    }

    real_realloc = (realloc_type)dlsym(RTLD_NEXT, "realloc");
    if ((error = dlerror()) != NULL) {
        fprintf(stderr,  PPREFIX "error %s\n", error);
        exit(EXIT_FAILURE);
    }

    real_free = (free_type)dlsym(RTLD_NEXT, "free");
    if ((error = dlerror()) != NULL) {
        fprintf(stderr,  PPREFIX "error %s\n", error);
        exit(EXIT_FAILURE);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
leaq 0xe0e(%rip), %rsi       # 0x11c22
callq 0x21f0
callq 0x2030
movq $-0x1, %rdi
leaq 0xf3a(%rip), %rsi       # 0x11d66
callq 0x2230
movq %rax, 0x4358(%rip)      # 0x15190
callq 0x2030
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x10e6d
movq 0x41aa(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xf11(%rip), %rsi       # 0x11d6d
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2270
movq $-0x1, %rdi
leaq 0xf0d(%rip), %rsi       # 0x11d88
callq 0x2230
movq %rax, 0x104321(%rip)    # 0x1151a8
callq 0x2030
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x10ebc
movq 0x415b(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xec2(%rip), %rsi       # 0x11d6d
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2270
movq $-0x1, %rdi
leaq 0xec6(%rip), %rsi       # 0x11d90
callq 0x2230
movq %rax, 0x1042ca(%rip)    # 0x1151a0
callq 0x2030
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x10f0b
movq 0x410c(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xe73(%rip), %rsi       # 0x11d6d
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.11/job-queue2.c
// Function: thread_function
void* thread_function (void* arg)
{
  while (1) {
    struct job* next_job;

    /* Lock the mutex on the job queue.  */
    pthread_mutex_lock (&job_queue_mutex);
    /* Now it's safe to check if the queue is empty.  */
    if (job_queue == NULL)
      next_job = NULL;
    else {
      /* Get the next available job.  */
      next_job = job_queue;
      /* Remove this job from the list.  */
      job_queue = job_queue->next;
    }
    /* Unlock the mutex on the job queue, since we're done with the
       queue for now.  */
    pthread_mutex_unlock (&job_queue_mutex);

    /* Was the queue empty?  If so, end the thread.  */
    if (next_job == NULL)
      break;

    /* Carry out the work.  */
    process_job (next_job);
    /* Clean up.  */
    free (next_job);
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2e95(%rip), %rdi      # 0x4068
callq 0x1090
cmpq $0x0, 0x2eb0(%rip)      # 0x4090
jne 0x11ec
movq $0x0, -0x10(%rbp)
jmp 0x1208
movq 0x2e9d(%rip), %rax      # 0x4090
movq %rax, -0x10(%rbp)
movq 0x2e92(%rip), %rax      # 0x4090
movq (%rax), %rax
movq %rax, 0x2e88(%rip)      # 0x4090
leaq 0x2e59(%rip), %rdi      # 0x4068
callq 0x1050
cmpq $0x0, -0x10(%rbp)
jne 0x121d
jmp 0x1231
movq -0x10(%rbp), %rdi
callq 0x11a0
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x11cc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_4/4.11/job-queue2.c
// Function: main
int main(void){
  struct job* trabajo = (struct job*) malloc(sizeof(struct job));
  trabajo->next = NULL;
  job_queue = trabajo;
  pthread_t hilo;
  pthread_create(&hilo, NULL, &thread_function, NULL);
  pthread_join(hilo, NULL);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x1060
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x2e1d(%rip)      # 0x4090
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xc2(%rip), %rdx       # 0x11c0
movq %rcx, %rsi
callq 0x1070
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: usage
static void usage(const char *name)
{
    fprintf(stderr, "Usage: %s [-v] [-q] [-m] [-s] [filename]\n", name);
    fprintf(stderr, "  -v              verbose output\n");
    fprintf(stderr, "  -q              quiet output\n");
    fprintf(stderr, "  -s              silent output\n");
    fprintf(stderr, "  -t              pass output to sendmail -t (ignored without -f/-m)\n");
    fprintf(stderr, "  -m              MIME-style output\n");
    fprintf(stderr, "  -5              Show MD5 of body parts\n");
    fprintf(stderr, "  -f <fromaddr>   The from address for replies (implies -m)\n");
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x11275(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0xd8c5(%rip), %rsi      # 0x10656
movb $0x0, %al
callq 0x2100
movq 0x11259(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd8d7(%rip), %rsi      # 0x10680
movb $0x0, %al
callq 0x2100
movq 0x11241(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd8e1(%rip), %rsi      # 0x106a2
movb $0x0, %al
callq 0x2100
movq 0x11229(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd8e9(%rip), %rsi      # 0x106c2
movb $0x0, %al
callq 0x2100
movq 0x11211(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd8f2(%rip), %rsi      # 0x106e3
movb $0x0, %al
callq 0x2100
movq 0x111f9(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd920(%rip), %rsi      # 0x10729
movb $0x0, %al
callq 0x2100
movq 0x111e1(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd92d(%rip), %rsi      # 0x1074e
movb $0x0, %al
callq 0x2100
movq 0x111c9(%rip), %rax     # 0x13ff8
movq (%rax), %rdi
leaq 0xd93f(%rip), %rsi      # 0x10778
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x21c0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: disposeminfo
static void disposeminfo(MIMEinfo *minfo)
{
    msgtoken *cur;
    int j;

    for (j = 0; j < 10; ++j) {
	if ((cur = minfo->keep[j]) != NULL) {
	    cur->next = msgfree;
	    msgfree = cur;
	}
    }
    free(minfo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x52f5
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x52e8
movq 0xfc5a(%rip), %rcx      # 0x14f30
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xfc48(%rip)      # 0x14f30
jmp 0x52ea
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x52b3
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: tokcomp
static int tokcomp(const char *instr, int len, msgtoken *tok)
{
    int tlen;
    const unsigned char *str = (const unsigned char *) instr;
    const unsigned char *tokstr;

    if (tok == NULL || tok->type == tok_error) return (-1);
    tlen = tok->len;
    tokstr = (const unsigned char *) tok->data;
    while (tlen > 0 || (len != 0 && *str != '\0')) {
	if (tlen == 0) return ((int) *str);
	if (len == 0 || *str == '\0') return (- (int) *tokstr);
	if (*str != TOLOWER(*tokstr)) return ((int) *str - *tokstr);
	++str, ++tokstr, --len, --tlen;
    }
    
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x60c8
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x60d4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x61c3
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movb $0x1, %al
cmpl $0x0, -0x24(%rbp)
movb %al, -0x39(%rbp)
jg 0x6116
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x3a(%rbp)
je 0x6110
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6122
jmp 0x61bc
cmpl $0x0, -0x24(%rbp)
jne 0x6137
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x61c3
cmpl $0x0, -0x14(%rbp)
je 0x6149
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6159
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x61c3
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %edx
leaq 0x8fa0(%rip), %rcx      # 0xf110
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x618d
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movzbl (%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x61c3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x60ea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: tokprint
static void tokprint(const char *label, msgtoken *cur)
{
    if (silent) return;
    for (; cur != NULL; cur = cur->next) {
	wprintf(NULL, label, " Token type %13s: %t",
		toktypemap[cur->type], cur);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0xaf41(%rip)      # 0x14ce8
je 0x9dab
jmp 0x9def
jmp 0x9dad
cmpq $0x0, -0x10(%rbp)
je 0x9def
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
leaq 0xacc8(%rip), %rax      # 0x14a90
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %r8
xorl %eax, %eax
movl %eax, %edi
leaq 0x7d7c(%rip), %rdx      # 0x11b57
movb $0x0, %al
callq 0x2e50
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x9dad
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: newmsgtoken
static msgtoken *newmsgtoken(msgtoken ***ptr, toktype type,
			     const char *dat, int len, int toknum)
{
    msgtoken *result = msgfree;
    const static char uninit[] = "uninitialized token";
    
    if (result != NULL) {
	msgfree = result->next;
    } else {
	result = malloc(sizeof (msgtoken));
	if (result == NULL) {
	    perror("malloc");
	    exit(1);
	}
    }
    if (type == tok_error) {
	result->type = tok_error;
	result->data = uninit;
	result->len = sizeof (uninit) - 1;
    } else {
	result->type = type;
	result->data = dat;
	result->len = len;
    }
    result->whiteafter = 0;
    result->flags = 0;
    result->toknum = toknum;
    result->next = NULL;
    if (ptr != NULL) {
	**ptr = result;
	*ptr = &result->next;
    } 

    return (result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq 0xb10f(%rip), %rax      # 0x14f30
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9e3c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, 0xb0f6(%rip)      # 0x14f30
jmp 0x9e69
movl $0x28, %edi
callq 0x2130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x9e67
leaq 0x67d1(%rip), %rdi      # 0x10629
callq 0x2180
movl $0x1, %edi
callq 0x21c0
jmp 0x9e69
cmpl $0x0, -0xc(%rbp)
jne 0x9e96
movq -0x28(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
leaq 0x590b(%rip), %rcx      # 0xf790
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0x13, 0x14(%rax)
jmp 0x9eb6
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x9f01
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: skipvalgroup
const static char *skipvalgroup(const char *scan)
{
    int level = 0;

    while (*scan != '\0' && (*scan != '}' || level-- > 0)) {
	if (*scan == '{') ++level;
	++scan;
    }

    if (*scan == '}') return (scan + 1);

    return (scan);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x9f5b
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x7d, %ecx
movb %al, -0x16(%rbp)
jne 0x9f55
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x9f64
jmp 0x9f87
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x9f79
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9f1f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
jne 0x9fa1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9fa9
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: whtupdate
static void whtupdate(whtwarn_ctx *wht, msgtoken *cur, dbinfo *db)
{
    if (wht->last != NULL) {
	wprintf(db, w_warn, "%s after %T is obsolete", wht->lasttype,
	       wht->last);
    }
    warnupdate(wht, db);
    wht->lastdphrase = wht->curdphrase;
    wht->curdphrase = 0;
    wht->last = NULL;
    if (wht->cur != NULL) {
	wht->last = wht->cur;
	wht->lasttype = wht->curtype;
	wht->cur = NULL;
    }
    if (cur != NULL) {
	if (cur->whiteafter & 2) {
	    wht->cur = cur;
	    wht->curtype = comment_str;
	} else if (cur->whiteafter & 1) {
	    wht->cur = cur;
	    wht->curtype = whitespace_str;
	}
    }
    if (wht->last == wht->cur) {
	wht->last = NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9ff8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x5387(%rip), %rsi      # 0xf371
leaq 0x79bc(%rip), %rdx      # 0x119ad
movb $0x0, %al
callq 0x2e50
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa0e0
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa05e
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0xa0bd
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xa090
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x5741(%rip), %rcx      # 0xf7cb
movq %rcx, 0x18(%rax)
jmp 0xa0bb
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa0b9
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x570b(%rip), %rcx      # 0xf7c0
movq %rcx, 0x18(%rax)
jmp 0xa0bb
jmp 0xa0bd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0xa0da
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: skipvalseg
const static char *skipvalseg(const char *scan)
{
    int level = 0;

    while (*scan != '\0' &&
	   (*scan != '|' || level > 0) &&
	   (*scan != '}' || level-- > 0)) {
	if (*scan == '{') ++level;
	++scan;
    }

    if (*scan == '|') return (scan + 1);

    return (scan);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xa412
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0xa3e7
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jle 0xa412
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x7d, %ecx
movb %al, -0x16(%rbp)
jne 0xa40c
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xa41b
jmp 0xa43e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0xa430
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa3bf
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0xa458
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xa460
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/msglint.c
// Function: vcreset
static int vcreset(int *pstack, vcstack *vs, const char **pdata,
	const char **ptmpl)
{
    int stack = *pstack;
    const char *next;

    while (stack >= 0) {
	if (*vs[stack].type == 'O' ||
	    *vs[stack].type == '*' ||
	    (*vs[stack].type == 'R' && vs[stack].count >= vs[stack].minc)) {
	    *ptmpl = skipvalgroup(vs[stack].tmpl);
	    *pdata = vs[stack].data;
	    *pstack = stack - 1;
	    return (1);
	}
	if (*vs[stack].type == 'A') {
	    next = vs[stack].tmpl = skipvalseg(vs[stack].tmpl);
	    if (*next != '}' && *next != '\0') {
		*ptmpl = next;
		*pdata = vs[stack].data;
		*pstack = stack;
		return (1);
	    }
	}
	--stack;
    }
    
    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xae9f
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x4f, %eax
je 0xad9f
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0xad9f
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
jne 0xadf3
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x1c(%rcx), %eax
jl 0xadf3
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x9f10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xaea6
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jne 0xae91
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0xa3b0
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movq %rax, 0x8(%rcx)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7d, %eax
je 0xae8f
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xae8f
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xaea6
jmp 0xae91
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xad21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/md5c.c
// Function: MD5Init
void MD5Init(MD5_CTX *context)
{
    context->count[0] = context->count[1] = 0;
    /* Load magic initialization constants.
     */
    context->state[0] = 0x67452301;
    context->state[1] = 0xefcdab89;
    context->state[2] = 0x98badcfe;
    context->state[3] = 0x10325476;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, %ecx       # imm = 0xEFCDAB89
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x98badcfe, %ecx       # imm = 0x98BADCFE
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x10325476, 0x18(%rax) # imm = 0x10325476
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/NedFreed[P]msglint/md5c.c
// Function: MD5Update
void MD5Update(MD5_CTX *context,
	       const unsigned char *input, unsigned int inputLen)
{
    unsigned int i, index, partLen;
    
    /* Compute number of bytes mod 64 */
    index = (unsigned int)((context->count[0] >> 3) & 0x3F);
    
    /* Update number of bits */
    if ((context->count[0] += ((UINT4)inputLen << 3))
	< ((UINT4)inputLen << 3))
	context->count[1]++;
    context->count[1] += ((UINT4)inputLen >> 29);
    
    partLen = 64 - index;
    
    /* Transform as many times as possible.
     */
    if (inputLen >= partLen) {
	memcpy(&context->in[index], input, partLen);
	MD5Transform (context->state, context->in);
	
	for (i = partLen; i + 63 < inputLen; i += 64)
	    MD5Transform (context->state, &input[i]);
	
	index = 0;
    }
    else
	i = 0;
    
    /* Buffer remaining input */
    memcpy(&context->in[index], &input[i], inputLen-i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
shrq $0x3, %rax
andq $0x3f, %rax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
shlq $0x3, %rax
movq -0x8(%rbp), %rcx
addq 0x20(%rcx), %rax
movq %rax, 0x20(%rcx)
movl -0x14(%rbp), %ecx
shlq $0x3, %rcx
cmpq %rcx, %rax
jae 0xc785
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %eax
movl %eax, %ecx
shrq $0x1d, %rcx
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0xc812
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x2110
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
callq 0xc850
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x3f, %eax
cmpl -0x14(%rbp), %eax
jae 0xc809
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0xc850
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0xc7e0
movl $0x0, -0x1c(%rbp)
jmp 0xc819
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)