LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: r_write
ssize_t r_write(int fd, void *buf, size_t size) {
   char *bufp;
   size_t bytestowrite;
   ssize_t byteswritten;
   size_t totalbytes;

   for (bufp = buf, bytestowrite = size, totalbytes = 0;
        bytestowrite > 0;
        bufp += byteswritten, bytestowrite -= byteswritten) {
      byteswritten = write(fd, bufp, bytestowrite);
      if ((byteswritten) == -1 && (errno != EINTR))
         return -1;
      if (byteswritten == -1)
         byteswritten = 0;
      totalbytes += byteswritten;
   }
   return totalbytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x1789
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1070
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
jne 0x1751
callq 0x1030
cmpl $0x4, (%rax)
je 0x1751
movq $-0x1, -0x8(%rbp)
jmp 0x1791
cmpq $-0x1, -0x38(%rbp)
jne 0x1760
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x171b
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: add2currenttime
struct timeval add2currenttime(double seconds) {
   struct timeval newtime;

   gettimeofday(&newtime, NULL);
   newtime.tv_sec += (int)seconds;
   newtime.tv_usec += (int)((seconds - (int)seconds)*D_MILLION + 0.5);
   if (newtime.tv_usec >= MILLION) {
      newtime.tv_sec++;
      newtime.tv_usec -= MILLION;
   }
   return newtime;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
cvttsd2si -0x18(%rbp), %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd 0x18f5(%rip), %xmm1     # 0x30d8
mulsd %xmm1, %xmm0
movsd 0x18f1(%rip), %xmm1     # 0x30e0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
cltq
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jl 0x1825
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
subq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: copyfile
int copyfile(int fromfd, int tofd) {
   int bytesread;
   int totalbytes = 0;

   while ((bytesread = readwrite(fromfd, tofd)) > 0)
      totalbytes += bytesread;
   return totalbytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x1880
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jle 0x1873
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x1855
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: readwrite
int readwrite(int fromfd, int tofd) {
   char buf[BLKSIZE];
   int bytesread;

   if ((bytesread = r_read(fromfd, buf, BLKSIZE)) < 0)
      return -1;
   if (bytesread == 0)
      return 0;
   if (r_write(tofd, buf, bytesread) < 0)
      return -1;
   return bytesread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x15e0
movl %eax, -0x1014(%rbp)
cmpl $0x0, %eax
jge 0x18b9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18f9
cmpl $0x0, -0x1014(%rbp)
jne 0x18cb
movl $0x0, -0x4(%rbp)
jmp 0x18f9
movl -0xc(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movslq -0x1014(%rbp), %rdx
callq 0x16f0
cmpq $0x0, %rax
jge 0x18f0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18f9
movl -0x1014(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: readblock
ssize_t readblock(int fd, void *buf, size_t size) {
   char *bufp;
   ssize_t bytesread;
   size_t bytestoread;
   size_t totalbytes;
 
   for (bufp = buf, bytestoread = size, totalbytes = 0;
        bytestoread > 0;
        bufp += bytesread, bytestoread -= bytesread) {
      bytesread = read(fd, bufp, bytestoread);
      if ((bytesread == 0) && (totalbytes == 0))
         return 0;
      if (bytesread == 0) {
         errno = EINVAL;
         return -1;
      }  
      if ((bytesread) == -1 && (errno != EINTR))
         return -1;
      if (bytesread == -1)
         bytesread = 0;
      totalbytes += bytesread;
   }
   return totalbytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jbe 0x19e4
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x1100
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1972
cmpq $0x0, -0x40(%rbp)
jne 0x1972
movq $0x0, -0x8(%rbp)
jmp 0x19ec
cmpq $0x0, -0x30(%rbp)
jne 0x198e
callq 0x1030
movl $0x16, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x19ec
cmpq $-0x1, -0x30(%rbp)
jne 0x19a9
callq 0x1030
cmpl $0x4, (%rax)
je 0x19a9
movq $-0x1, -0x8(%rbp)
jmp 0x19ec
cmpq $-0x1, -0x30(%rbp)
jne 0x19b8
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
jmp 0x193b
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: readline
int readline(int fd, char *buf, int nbytes) {
   int numread = 0;
   int returnval;

   while (numread < nbytes - 1) {
      returnval = read(fd, buf + numread, 1);
      if ((returnval == -1) && (errno == EINTR))
         continue;
      if ((returnval == 0) && (numread == 0))
         return 0;
      if (returnval == 0)
         break;
      if (returnval == -1)
         return -1;
      numread++;
      if (buf[numread-1] == '\n') {
         buf[numread] = '\0';
         return numread;
      }  
   }   
   errno = EINVAL;
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1abb
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl $0x1, %edx
callq 0x1100
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x1a57
callq 0x1030
cmpl $0x4, (%rax)
jne 0x1a57
jmp 0x1a19
cmpl $0x0, -0x1c(%rbp)
jne 0x1a6c
cmpl $0x0, -0x18(%rbp)
jne 0x1a6c
movl $0x0, -0x4(%rbp)
jmp 0x1acd
cmpl $0x0, -0x1c(%rbp)
jne 0x1a74
jmp 0x1abb
cmpl $-0x1, -0x1c(%rbp)
jne 0x1a83
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1acd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1ab6
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1acd
jmp 0x1a19
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: readtimed
ssize_t readtimed(int fd, void *buf, size_t nbyte, double seconds) {
   struct timeval timedone;

   timedone = add2currenttime(seconds);
   if (waitfdtimed(fd, timedone) == -1)
      return (ssize_t)(-1);
   return r_read(fd, buf, nbyte);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x17a0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1b60
cmpl $-0x1, %eax
jne 0x1b39
movq $-0x1, -0x8(%rbp)
jmp 0x1b4d
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x15e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: waitfdtimed
int waitfdtimed(int fd, struct timeval end) {
   fd_set readset;
   int retval;
   struct timeval timeout;
 
   if ((fd < 0) || (fd >= FD_SETSIZE)) {
      errno = EINVAL;
      return -1;
   }  
   FD_ZERO(&readset);
   FD_SET(fd, &readset);
   if (gettimeout(end, &timeout) == -1)
      return -1;
   while (((retval = select(fd+1, &readset, NULL, NULL, &timeout)) == -1)
           && (errno == EINTR)) {
      if (gettimeout(end, &timeout) == -1)
         return -1;
      FD_ZERO(&readset);
      FD_SET(fd, &readset);
   }
   if (retval == 0) {
      errno = ETIME;
      return -1;
   }
   if (retval == -1)
      return -1;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movl %edi, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1b85
cmpl $0x400, -0x1c(%rbp)     # imm = 0x400
jl 0x1b9c
callq 0x1030
movl $0x16, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d82
jmp 0x1b9e
leaq -0xa0(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl $0x0, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
cmpq $0x10, %rax
jae 0x1be8
movq -0xc8(%rbp), %rax
movl -0xbc(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xbc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbc(%rbp)
jmp 0x1bb6
jmp 0x1bea
movl -0x1c(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x1c(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0xa0(%rbp,%rax,8), %rcx
movq %rcx, -0xa0(%rbp,%rax,8)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x1df0
cmpl $-0x1, %eax
jne 0x1c46
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d82
jmp 0x1c48
movl -0x1c(%rbp), %edi
addl $0x1, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb8(%rbp), %r8
movq %rcx, %rdx
callq 0x1120
movl %eax, %ecx
movl %ecx, -0xa4(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0xd9(%rbp)
jne 0x1c8e
callq 0x1030
cmpl $0x4, (%rax)
sete %al
movb %al, -0xd9(%rbp)
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x1c9d
jmp 0x1d4c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0x1df0
cmpl $-0x1, %eax
jne 0x1cc2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d82
jmp 0x1cc4
leaq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x0, -0xcc(%rbp)
movl -0xcc(%rbp), %eax
cmpq $0x10, %rax
jae 0x1d0e
movq -0xd8(%rbp), %rax
movl -0xcc(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xcc(%rbp)
jmp 0x1cdc
jmp 0x1d10
movl -0x1c(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x1c(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0xa0(%rbp,%rax,8), %rcx
movq %rcx, -0xa0(%rbp,%rax,8)
jmp 0x1c48
cmpl $0x0, -0xa4(%rbp)
jne 0x1d69
callq 0x1030
movl $0x3e, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d82
cmpl $-0x1, -0xa4(%rbp)
jne 0x1d7b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d82
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: readwriteblock
int readwriteblock(int fromfd, int tofd, char *buf, int size) {
   int bytesread;

   bytesread = readblock(fromfd, buf, size);
   if (bytesread != size)         /* can only be 0 or -1 */
      return bytesread;
   return r_write(tofd, buf, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1910
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x1dc8
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1ddb
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x16f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/restart.c
// Function: gettimeout
static int gettimeout(struct timeval end,
                               struct timeval *timeoutp) {
   gettimeofday(timeoutp, NULL);
   timeoutp->tv_sec = end.tv_sec - timeoutp->tv_sec;
   timeoutp->tv_usec = end.tv_usec - timeoutp->tv_usec;
   if (timeoutp->tv_usec >= MILLION) {
      timeoutp->tv_sec++;
      timeoutp->tv_usec -= MILLION;
   }
   if (timeoutp->tv_usec < 0) {
      timeoutp->tv_sec--;
      timeoutp->tv_usec += MILLION;
   }
   if ((timeoutp->tv_sec < 0) ||
       ((timeoutp->tv_sec == 0) && (timeoutp->tv_usec == 0))) {
      errno = ETIME;
      return -1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
subq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0xf4240, 0x8(%rax)     # imm = 0xF4240
jl 0x1e66
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0xf4240, %rcx          # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jge 0x1e92
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0xf4240, %rcx          # imm = 0xF4240
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jl 0x1eb1
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1ec5
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1ec5
callq 0x1030
movl $0x3e, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1ecc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/uiciname.c
// Function: addr2name
void addr2name(struct in_addr addr, char *name, int namelen) {
   struct sockaddr_in saddr;
   saddr.sin_family = AF_INET;
   saddr.sin_port = 0;
   saddr.sin_addr = addr;
   if (getnameinfo((struct sockaddr *)&saddr, sizeof(saddr), name, namelen,
         NULL, 0, 0) != 0) {
      strncpy(name, inet_ntoa(addr), namelen-1);
      name[namelen-1] = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movw $0x2, -0x24(%rbp)
movw $0x0, -0x22(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x24(%rbp), %rdi
movl $0x10, %esi
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
movl $0x0, (%rsp)
callq 0x10f0
cmpl $0x0, %eax
je 0x1f63
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edi
callq 0x1090
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x1040
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/uiciname.c
// Function: name2addr
int name2addr(char *name, in_addr_t *addrp) {
   struct addrinfo hints;
   struct addrinfo *res;
   struct sockaddr_in *saddrp;

   hints.ai_flags = AI_PASSIVE;
   hints.ai_family = PF_INET;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_protocol = 0;
   hints.ai_addrlen = 0;
   hints.ai_canonname = NULL;
   hints.ai_addr = NULL;
   hints.ai_next = NULL;
 
   if (getaddrinfo(name, NULL, &hints, &res) != 0)
      return -1;
   saddrp = (struct sockaddr_in *)(res->ai_addr);
   memcpy(addrp, &saddrp->sin_addr.s_addr, 4);
   freeaddrinfo(res);
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, -0x48(%rbp)
movl $0x2, -0x44(%rbp)
movl $0x1, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x48(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x11b0
cmpl $0x0, %eax
je 0x1fde
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2007
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, (%rax)
movq -0x50(%rbp), %rdi
callq 0x11d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/uici.c
// Function: u_open
int u_open(u_port_t port) {
   int error;  
   struct sockaddr_in server;
   int sock;
   int true = 1;

   if ((u_ignore_sigpipe() == -1) ||
        ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1))
      return -1; 

   if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&true,
                  sizeof(true)) == -1) {
      error = errno;
      while ((close(sock) == -1) && (errno == EINTR)); 
      errno = error;
      return -1;
   }
 
   server.sin_family = AF_INET;
   server.sin_addr.s_addr = htonl(INADDR_ANY);
   server.sin_port = htons((short)port);
   if ((bind(sock, (struct sockaddr *)&server, sizeof(server)) == -1) ||
        (listen(sock, MAXBACKLOG) == -1)) {
      error = errno;
      while ((close(sock) == -1) && (errno == EINTR)); 
      errno = error;
      return -1;
   }
   return sock;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movl $0x1, -0x24(%rbp)
callq 0x24a0
cmpl $-0x1, %eax
je 0x2049
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x11e0
movl %eax, -0x20(%rbp)
cmpl $-0x1, %eax
jne 0x2055
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2164
movl -0x20(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x1060
cmpl $-0x1, %eax
jne 0x20c9
callq 0x1030
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x20(%rbp), %edi
callq 0x10e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x25(%rbp)
jne 0x20a2
callq 0x1030
cmpl $0x4, (%rax)
sete %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x20ab
jmp 0x20ad
jmp 0x2080
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
callq 0x1030
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2164
movw $0x2, -0x1c(%rbp)
xorl %edi, %edi
callq 0x10d0
movl %eax, -0x18(%rbp)
movzwl -0x6(%rbp), %edi
callq 0x10a0
movw %ax, -0x1a(%rbp)
movl -0x20(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x10, %edx
callq 0x1140
cmpl $-0x1, %eax
je 0x210e
movl -0x20(%rbp), %edi
movl $0x32, %esi
callq 0x1130
cmpl $-0x1, %eax
jne 0x215e
callq 0x1030
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x20(%rbp), %edi
callq 0x10e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x2d(%rbp)
jne 0x213a
callq 0x1030
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2143
jmp 0x2145
jmp 0x2118
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x1030
movl -0x34(%rbp), %ecx
movl %ecx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2164
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/uici.c
// Function: u_accept
int u_accept(int fd, char *hostn, int hostnsize) {
   int len = sizeof(struct sockaddr);
   struct sockaddr_in netclient;
   int retval;

   while (((retval =
           accept(fd, (struct sockaddr *)(&netclient), &len)) == -1) &&
          (errno == EINTR))
      ;  
   if ((retval == -1) || (hostn == NULL) || (hostnsize <= 0))
      return retval;
   addr2name(netclient.sin_addr, hostn, hostnsize);
   return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x10, -0x18(%rbp)
movl -0x8(%rbp), %edi
leaq -0x28(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x1180
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x2d(%rbp)
jne 0x21b6
callq 0x1030
cmpl $0x4, (%rax)
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x21bf
jmp 0x21c1
jmp 0x2189
cmpl $-0x1, -0x2c(%rbp)
je 0x21d4
cmpq $0x0, -0x10(%rbp)
je 0x21d4
cmpl $0x0, -0x14(%rbp)
jg 0x21dc
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x21f1
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x24(%rbp), %edi
callq 0x1ee0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/uici.c
// Function: u_ignore_sigpipe
static int u_ignore_sigpipe() {
   struct sigaction act;

   if (sigaction(SIGPIPE, (struct sigaction *)NULL, &act) == -1)
      return -1;
   if (act.sa_handler == SIG_DFL) {
      act.sa_handler = SIG_IGN;
      if (sigaction(SIGPIPE, &act, (struct sigaction *)NULL) == -1)
         return -1;
   }   
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0xd, %edi
xorl %eax, %eax
movl %eax, %esi
leaq -0xa0(%rbp), %rdx
callq 0x1050
cmpl $-0x1, %eax
jne 0x24ce
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2510
cmpq $0x0, -0xa0(%rbp)
jne 0x2509
movl $0x1, %eax
movq %rax, -0xa0(%rbp)
movl $0xd, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
cmpl $-0x1, %eax
jne 0x2507
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2510
jmp 0x2509
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfdec.c
// Function: dblb_rdn
INLINE unsigned dblb_rdn(bits_t *pbits,int n)
{
  unsigned u;
  RDN_PR(*pbits,u);
  pbits->pb+=n;
  u&=dblb_bmsk[n];
  return u;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x10, 0x4(%rax)
jl 0x1642
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x10, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x10, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1640
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, 0x8(%rcx)
movzwl (%rax), %ecx
shll $0x10, %ecx
movq -0x8(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x1642
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
shrl %cl, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x6c24(%rip), %rax      # 0x8290
movl (%rax,%rcx,4), %eax
andl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfdec.c
// Function: dblb_decrep
INLINE int dblb_decrep(bits_t *pbits, __u8 **p, void *pout, __u8 *pend,
		 int repoffs, int k, int flg)
{ int replen;
  __u8 *r;

  if(repoffs==0){LOG_DECOMP("DMSDOS: decrb: zero offset ?\n");return -2;}
  if(repoffs==0x113f)
  { 
    int pos=*p-(__u8*)pout;
    LOG_DECOMP("DMSDOS: decrb: 0x113f sync found.\n");
    if((pos%512) && !(flg&0x4000))
    { LOG_DECOMP("DMSDOS: decrb: sync at decompressed pos %d ?\n",pos);
      return -2;
    }
    return 0;
  }
  replen=dblb_rdlen(pbits)+k;

  if(replen<=0)
    {LOG_DECOMP("DMSDOS: decrb: illegal count ?\n");return -2;}
  if((__u8*)pout+repoffs>*p)
    {LOG_DECOMP("DMSDOS: decrb: of>pos ?\n");return -2;}
  if(*p+replen>pend)
    {LOG_DECOMP("DMSDOS: decrb: output overfill ?\n");return -2;}
  r=*p-repoffs;
  M_MOVSB(*p,r,replen);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x16b5
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17b2
cmpl $0x113f, -0x2c(%rbp)    # imm = 0x113F
jne 0x1704
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl $0x200, %ecx            # imm = 0x200
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x16f8
movl 0x10(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
jne 0x16f8
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17b2
movl $0x0, -0x4(%rbp)
jmp 0x17b2
movq -0x10(%rbp), %rdi
callq 0x1e30
addl -0x30(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jg 0x1725
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17b2
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x1742
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17b2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
addq %rcx, %rax
cmpq -0x28(%rbp), %rax
jbe 0x175f
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17b2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x2c(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x17ab
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb (%rax), %cl
movq -0x18(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1776
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: process_data
static int process_data(char *data, uint32_t size, FILE *fout) {
  struct mof_classes classes;
  classes = parse_bmf(data, size);
  print_classes(fout, classes.classes, classes.count);
  free_classes(classes.classes, classes.count);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2040
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0x2370
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x2ab0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_classes
static void free_classes(struct mof_class *classes, uint32_t count) {
  uint32_t i;
  for (i=0; i<count; ++i)
    free_class(&classes[i]);
  free(classes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2aec
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
imulq $0x48, %rax, %rax
addq %rax, %rdi
callq 0x76f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ac6
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: parse_qualifier_boolean
static struct mof_qualifier parse_qualifier_boolean(char *buf, uint32_t size, uint32_t val) {
  struct mof_qualifier out;
  memset(&out, 0, sizeof(out));
  if (val != 0 && val != 0xFFFF) error("Invalid boolean");
  out.type = MOF_QUALIFIER_BOOLEAN;
  out.name = parse_string(buf, size);
  out.value.boolean = val ? 1 : 0;
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x10c0
cmpl $0x0, -0x10(%rbp)
je 0x5680
cmpl $0xffff, -0x10(%rbp)    # imm = 0xFFFF
je 0x5680
jmp 0x564a
movq 0x59a7(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x2e20(%rip), %rsi      # 0x847b
leaq 0x307b(%rip), %rdx      # 0x86dd
leaq 0x3084(%rip), %rcx      # 0x86ed
movl $0xbf, %r8d
movb $0x0, %al
callq 0x1100
movl $0x1, %edi
callq 0x1180
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5900
movq -0x20(%rbp), %rcx
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq %rdx, 0x8(%rcx)
movl -0x10(%rbp), %edi
xorl %edx, %edx
movl $0x1, %esi
cmpl $0x0, %edi
cmovnel %esi, %edx
movb %dl, 0x18(%rcx)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: parse_qualifier_sint32
static struct mof_qualifier parse_qualifier_sint32(char *buf, uint32_t size, int32_t val) {
  struct mof_qualifier out;
  memset(&out, 0, sizeof(out));
  out.type = MOF_QUALIFIER_SINT32;
  out.name = parse_string(buf, size);
  out.value.sint32 = val;
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x10c0
movq -0x20(%rbp), %rdi
movl $0x2, (%rdi)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5900
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rdi)
movl -0x10(%rbp), %ecx
movl %ecx, 0x18(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: parse_qualifier_string
static struct mof_qualifier parse_qualifier_string(char *buf, uint32_t size, char *buf2, uint32_t size2) {
  struct mof_qualifier out;
  memset(&out, 0, sizeof(out));
  out.type = MOF_QUALIFIER_STRING;
  out.name = parse_string(buf, size);
  out.value.string = parse_string(buf2, size2);
  return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x10c0
movq -0x30(%rbp), %rdi
movl $0x3, (%rdi)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5900
movq -0x30(%rbp), %rdi
movq %rax, 0x8(%rdi)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5900
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: dump_bytes
static void dump_bytes(char *buf, uint32_t size) {
  uint32_t i, ascii_cnt = 0;
  char ascii[17] = { 0, };
  for (i=0; i<size; i++) {
    if (i % 16 == 0) {
      if (i != 0) {
        fprintf(stderr, "  |%s|\n", ascii);
        ascii[0] = 0;
        ascii_cnt = 0;
      }
      fprintf(stderr, "%04X:", (unsigned int)i);
    }
    fprintf(stderr, " %02X", buf[i] & 0xFF);
    ascii[ascii_cnt] = to_ascii(buf[i]);
    ascii[ascii_cnt + 1] = 0;
    ascii_cnt++;
  }
  if (ascii[0]) {
    if (size % 16)
      for (i=0; i<16-(size%16); i++)
        fprintf(stderr, "   ");
    fprintf(stderr, "  |%s|\n", ascii);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x11, %edx
callq 0x10c0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x5882
movl -0x10(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x581c
cmpl $0x0, -0x10(%rbp)
je 0x5801
movq 0x5817(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq -0x30(%rbp), %rdx
leaq 0x2f31(%rip), %rsi      # 0x8720
movb $0x0, %al
callq 0x1100
movb $0x0, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x57f0(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0x2f13(%rip), %rsi      # 0x8728
movb $0x0, %al
callq 0x1100
movq 0x57d5(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movsbl (%rax,%rcx), %edx
andl $0xff, %edx
leaq 0x2ef0(%rip), %rsi      # 0x872e
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x5c70
movb %al, %cl
movl -0x14(%rbp), %eax
movb %cl, -0x30(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movb $0x0, -0x30(%rbp,%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x57bd
cmpb $0x0, -0x30(%rbp)
je 0x58ef
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x58d3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %edx
andl $0xf, %edx
movl $0x10, %ecx
subl %edx, %ecx
cmpl %ecx, %eax
jae 0x58d1
movq 0x5743(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x2e75(%rip), %rsi      # 0x8734
movb $0x0, %al
callq 0x1100
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x589a
jmp 0x58d3
movq 0x571e(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq -0x30(%rbp), %rdx
leaq 0x2e38(%rip), %rsi      # 0x8720
movb $0x0, %al
callq 0x1100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: cmp_variables
static int cmp_variables(struct mof_variable *a, struct mof_variable *b) {
  if (strcmp(a->name, b->name) != 0 || a->variable_type != b->variable_type)
    return 1;
  if ((a->variable_type == MOF_VARIABLE_BASIC_ARRAY || a->variable_type == MOF_VARIABLE_OBJECT_ARRAY) && (a->has_array_max != b->has_array_max || a->array_max != b->array_max))
    return 1;
  switch (a->variable_type) {
  case MOF_VARIABLE_BASIC:
  case MOF_VARIABLE_BASIC_ARRAY:
    return (a->type.basic != b->type.basic) ? 1 : 0;
  case MOF_VARIABLE_OBJECT:
  case MOF_VARIABLE_OBJECT_ARRAY:
    return strcmp(a->type.object, b->type.object) ? 1 : 0;
  default:
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x6eea
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x6ef6
movl $0x1, -0x4(%rbp)
jmp 0x6fae
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
je 0x6f0a
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x6f37
movq -0x10(%rbp), %rax
movzbl 0x2c(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2c(%rcx), %ecx
cmpl %ecx, %eax
jne 0x6f2e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
je 0x6f37
movl $0x1, -0x4(%rbp)
jmp 0x6fae
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x6fa7
movq -0x20(%rbp), %rax
leaq 0x12e2(%rip), %rcx      # 0x8238
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6fae
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x10f0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x6fae
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: cmp_qualifiers
static int cmp_qualifiers(struct mof_qualifier *a, struct mof_qualifier *b) {
  if (strcmp(a->name, b->name) != 0 || a->type != b->type)
    return 1;
  switch (a->type) {
  case MOF_QUALIFIER_BOOLEAN:
    return (a->value.boolean != b->value.boolean) ? 1 : 0;
  case MOF_QUALIFIER_SINT32:
    return (a->value.sint32 != b->value.sint32) ? 1 : 0;
  case MOF_QUALIFIER_STRING:
    return strcmp(a->value.string, b->value.string) ? 1 : 0;
  default:
    return 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10f0
cmpl $0x0, %eax
jne 0x6ff8
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x7004
movl $0x1, -0x4(%rbp)
jmp 0x7098
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x7028
jmp 0x7014
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x7049
jmp 0x701e
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x7068
jmp 0x7091
movq -0x10(%rbp), %rax
movzbl 0x18(%rax), %edx
movq -0x18(%rbp), %rax
movzbl 0x18(%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7098
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7098
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x10f0
movl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7098
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/bmf2mof.c
// Function: print_string
static void print_string(FILE *fout, char *str) {
  int len = strlen(str);
  int i;
  for (i=0; i<len; ++i) {
    if (str[i] == '"' || str[i] == '\\')
      fputc('\\', fout);
    fputc(str[i], fout);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x712b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x22, %eax
je 0x70fd
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x710b
movq -0x8(%rbp), %rsi
movl $0x5c, %edi
callq 0x10d0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x10d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x70d3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/bmf2mof.c
// Function: print_variable
static void print_variable(FILE *fout, struct mof_variable *variable, char *prefix) {
  if (variable->qualifiers_count > 0 || prefix) {
    print_qualifiers(fout, variable->qualifiers, variable->qualifiers_count, prefix);
    fprintf(fout, " ");
  }
  print_variable_type(fout, variable);
  fprintf(fout, " ");
  print_string(fout, variable->name);
  if (variable->variable_type == MOF_VARIABLE_BASIC_ARRAY || variable->variable_type == MOF_VARIABLE_OBJECT_ARRAY) {
    fprintf(fout, "[");
    if (variable->has_array_max)
      fprintf(fout, "%d", variable->array_max);
    fprintf(fout, "]");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
ja 0x7494
cmpq $0x0, -0x18(%rbp)
je 0x74c1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rcx
callq 0x7140
movq -0x8(%rbp), %rdi
leaq 0x127c(%rip), %rsi      # 0x8736
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7560
movq -0x8(%rbp), %rdi
leaq 0x125d(%rip), %rsi      # 0x8736
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x70b0
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
je 0x7505
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x754c
movq -0x8(%rbp), %rdi
leaq 0x161b(%rip), %rsi      # 0x8b2b
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
cmpb $0x0, 0x2c(%rax)
je 0x753a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x15d0(%rip), %rsi      # 0x8b03
movb $0x0, %al
callq 0x1100
movq -0x8(%rbp), %rdi
leaq 0x1630(%rip), %rsi      # 0x8b75
movb $0x0, %al
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_class
static void free_class(struct mof_class *class) {
  if (!class)
    return;
  free(class->name);
  free(class->namespace);
  free(class->superclassname);
  free_qualifiers(class->qualifiers, class->qualifiers_count);
  free_variables(class->variables, class->variables_count);
  free_methods(class->methods, class->methods_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7705
jmp 0x7767
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x7770
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x77c0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x7810
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_qualifiers
static void free_qualifiers(struct mof_qualifier *qualifiers, uint32_t count) {
  uint32_t i;
  for (i=0; i<count; ++i)
    free_qualifier(&qualifiers[i]);
  free(qualifiers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x77ac
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rdi
callq 0x7860
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7786
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_variables
static void free_variables(struct mof_variable *variables, uint32_t count) {
  uint32_t i;
  for (i=0; i<count; ++i)
    free_variable(&variables[i]);
  free(variables);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x77fc
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdi
callq 0x78a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x77d6
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_methods
static void free_methods(struct mof_method *methods, uint32_t count) {
  uint32_t i;
  for (i=0; i<count; ++i)
    free_method(&methods[i]);
  free(methods);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x784c
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
imulq $0x60, %rax, %rax
addq %rax, %rdi
callq 0x7900
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7826
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_qualifier
static void free_qualifier(struct mof_qualifier *qualifier) {
  if (!qualifier)
    return;
  free(qualifier->name);
  if (qualifier->type == MOF_QUALIFIER_STRING)
    free(qualifier->value.string);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7875
jmp 0x7898
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7898
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_variable
static void free_variable(struct mof_variable *variable) {
  if (!variable)
    return;
  free(variable->name);
  free_qualifiers(variable->qualifiers, variable->qualifiers_count);
  if (variable->variable_type == MOF_VARIABLE_OBJECT || variable->variable_type == MOF_VARIABLE_OBJECT_ARRAY)
    free(variable->type.object);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x78b5
jmp 0x78f6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x7770
movq -0x8(%rbp), %rax
cmpl $0x2, 0x18(%rax)
je 0x78e9
movq -0x8(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x78f6
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pali[P]bmfdec/./bmfparse.c
// Function: free_method
static void free_method(struct mof_method *method) {
  if (!method)
    return;
  free_qualifiers(method->qualifiers, method->qualifiers_count);
  free(method->name);
  free_variables(method->parameters, method->parameters_count);
  free_variable(&method->return_value);
  free(method->parameters_direction);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7915
jmp 0x7963
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %esi
callq 0x7770
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x77c0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
callq 0x78a0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/utils/kmp/test/test_kmp.c
// Function: test_1
boolean test_1() {
    char *pattern = "ABCABCABCD";
    char *string = "AABCABCABCABCDABCABCDABCABCABCDA";
    int   next[10];
    kmp_get_next(pattern, next);

    char *c = string;
    int   pos = 0;
    int   ans = 0;
    while (*c != '\0') {
        kmp_char(*(c++), pattern, &pos, next, &ans);
    }
    if (ans != 2) {
        print_err("test_1 error, want %d, got %d\n", 2, ans);
        return F;
    }
    return T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x5c9(%rip), %rax       # 0x2158
movq %rax, -0x10(%rbp)
leaq 0x5c9(%rip), %rax       # 0x2163
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1570
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1bf8
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movb (%rax), %al
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rcx
leaq -0x4c(%rbp), %rdx
leaq -0x50(%rbp), %r8
movsbl %al, %edi
callq 0x1650
jmp 0x1bc1
cmpl $0x2, -0x50(%rbp)
je 0x1c22
movl -0x50(%rbp), %edx
leaq 0x57c(%rip), %rdi       # 0x2184
movl $0x2, %esi
movb $0x0, %al
callq 0x18e0
leaq 0x539(%rip), %rax       # 0x2154
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c2e
leaq 0x527(%rip), %rax       # 0x2150
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)