LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: solve_sudoku_algorithm_1
static int solve_sudoku_algorithm_1(void)
{
  int x, y, solution, found;

  /* Go through all cells in the table and find a possible "only" solution. */
  /* Do this multiple times, until no more solutions are found or table full. */
  do {
    found = 0; /* Will be overwritten if something is found. */
    for (y = 0; y < 9; y++) {
      for (x = 0; x < 9; x++) {
        if (sudoku[y][x] > 0)
          continue;
        solution = find_only_solution(y, x);
        if (solution > 0) {
          sudoku[y][x] = solution;
          display_update("Solving...");
          usleep(10000);
          found++;
        }
      }
    }
    if (table_full())
      break;
  } while (found > 0);

  if (! table_full()) 
    return -1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x1ce7
movl $0x0, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x1cd7
movslq -0xc(%rbp), %rcx
leaq 0x3478(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x1c7b
jmp 0x1ccc
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x1fd0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x1cca
movl -0x10(%rbp), %edx
movslq -0xc(%rbp), %rcx
leaq 0x3443(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq 0x1480(%rip), %rdi      # 0x3132
callq 0x17d0
movl $0x2710, %edi           # imm = 0x2710
callq 0x1140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1ccc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1c57
jmp 0x1cd9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c46
callq 0x21f0
cmpl $0x0, %eax
je 0x1cf3
jmp 0x1cff
jmp 0x1cf5
cmpl $0x0, -0x14(%rbp)
jg 0x1c38
callq 0x21f0
cmpl $0x0, %eax
jne 0x1d12
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d19
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: solve_sudoku_algorithm_2
static int solve_sudoku_algorithm_2(void)
{
  int i, y, x, solutions_found = 0;

  for (y = 0; y < 9; y++) {
    for (x = 0; x < 9; x++) {
      if (sudoku[y][x] > 0)
        continue; /* Already has a number. */

      for (i = 1; i <= 9; i++) {
        if (is_blocked_elsewhere(i, y, x)) {
          sudoku[y][x] = i;
          display_update("Solving...");
          usleep(10000);
          solutions_found++;
          break; /* Solution found, move on to next right away... */
        }
      }

    }
  }

  return solutions_found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x1e09
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x1df9
movslq -0x8(%rbp), %rcx
leaq 0x3374(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jle 0x1d7f
jmp 0x1deb
movl $0x1, -0x4(%rbp)
cmpl $0x9, -0x4(%rbp)
jg 0x1de9
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x2260
cmpl $0x0, %eax
je 0x1ddc
movl -0x4(%rbp), %edx
movslq -0x8(%rbp), %rcx
leaq 0x3333(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq 0x1370(%rip), %rdi      # 0x3132
callq 0x17d0
movl $0x2710, %edi           # imm = 0x2710
callq 0x1140
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1de9
jmp 0x1dde
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1d86
jmp 0x1deb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d57
jmp 0x1dfb
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1d46
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: table_full
static int table_full(void)
{
  int x, y;
  for (y = 0; y < 9; y++) {
    for (x = 0; x < 9; x++) {
      if (sudoku[y][x] == 0)
        return 0;
    }
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x224d
movl $0x0, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x2240
movslq -0xc(%rbp), %rcx
leaq 0x2ec7(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x2233
movl $0x0, -0x4(%rbp)
jmp 0x2254
jmp 0x2235
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2208
jmp 0x2242
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x21fb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: is_blocked_horizontally
static int is_blocked_horizontally(int target, int y)
{
  int i;
  for (i = 0; i < 9; i++) {
    if (sudoku[y][i] == target)
      return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jge 0x249b
movslq -0xc(%rbp), %rcx
leaq 0x2c6e(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x248e
movl $0x1, -0x4(%rbp)
jmp 0x24a2
jmp 0x2490
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2461
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: is_blocked_vertically
static int is_blocked_vertically(int target, int x)
{
  int i;
  for (i = 0; i < 9; i++) {
    if (sudoku[i][x] == target)
      return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x9, -0x10(%rbp)
jge 0x24fb
movslq -0x10(%rbp), %rcx
leaq 0x2c0e(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x24ee
movl $0x1, -0x4(%rbp)
jmp 0x2502
jmp 0x24f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x24c1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kobolt[P]curses-collection/sudoku/sudoku.c
// Function: guess_is_not_possible
static int guess_is_not_possible(void)
{
  int ny, nx;

  /* Check 3x3 box. */
  for (ny = (guess_y / 3) * 3; ny < ((guess_y / 3) + 1) * 3; ny++) {
    for (nx = (guess_x / 3) * 3; nx < ((guess_x / 3) + 1) * 3; nx++) {
      if (sudoku[ny][nx] == guess_number)
        return 1;
    }
  }

  /* Check horizontal line. */
  for (nx = 0; nx < 9; nx++) {
    if (sudoku[guess_y][nx] == guess_number)
      return 1;
  }

  /* Check vertical line. */
  for (ny = 0; ny < 9; ny++) {
    if (sudoku[ny][guess_x] == guess_number)
      return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2d12(%rip), %eax      # 0x522c
movl $0x3, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl 0x2cf8(%rip), %eax      # 0x522c
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl $0x1, %ecx
imull $0x3, %ecx, %ecx
cmpl %ecx, %eax
jge 0x25d0
movl 0x2cd3(%rip), %eax      # 0x5228
movl $0x3, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl 0x2cb9(%rip), %eax      # 0x5228
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl $0x1, %ecx
imull $0x3, %ecx, %ecx
cmpl %ecx, %eax
jge 0x25c0
movslq -0x8(%rbp), %rcx
leaq 0x2b4f(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x2c7f(%rip), %eax      # 0x5224
jne 0x25b3
movl $0x1, -0x4(%rbp)
jmp 0x2665
jmp 0x25b5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2563
jmp 0x25c2
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2528
movl $0x0, -0xc(%rbp)
cmpl $0x9, -0xc(%rbp)
jge 0x2617
movslq 0x2c48(%rip), %rcx      # 0x522c
leaq 0x2af5(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x2c25(%rip), %eax      # 0x5224
jne 0x260a
movl $0x1, -0x4(%rbp)
jmp 0x2665
jmp 0x260c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x25d7
movl $0x0, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x265e
movslq -0x8(%rbp), %rcx
leaq 0x2ab1(%rip), %rax      # 0x50e0
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq 0x2beb(%rip), %rcx      # 0x5228
movl (%rax,%rcx,4), %eax
cmpl 0x2bde(%rip), %eax      # 0x5224
jne 0x2651
movl $0x1, -0x4(%rbp)
jmp 0x2665
jmp 0x2653
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x261e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vusec[P]fpvi-scsb/fp_reverse_engineering/find_operands/find_operands.c
// Function: main
int main(int argc, char **argv)
{
    uint64_t target;

    if (argc < 2)
    {
        printf("Usage: %s <pointer in hex>\n", argv[0]);
        return -1;
    }

    sscanf(argv[1], "0x%lx", &target);
    target = target & 0x00007ffffffffffULL;
    printf("Finding X,Y for target 0x%016lx\n", target);

    uint64_t yh = 0x0000000000000001ULL;
    double   y  = *((double *) &yh);

    //0xfffb is String tag
    uint64_t xh = 0xbffb000000000000ULL;
    xh = xh | (target & 0x00007ffffffffff0ULL);
    double   x  = *((double *) &xh);

    uint64_t offset = target & 0xfULL;
    if(offset == 0ULL) {
        xh |= 0x7ULL;
    } else if(offset == 8ULL) {
        xh |= 0xfULL;
    } else {
        printf("Only target addresses ending i 0x0 or 0x8 are supported\n");
        return -1;
    }

    printf("X = 0x%016lx\t%.16e\n", xh, x);
    printf("Y = 0x%016lx\t%.16e\n", yh, y);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x118d
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xe8a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1292
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe84(%rip), %rsi       # 0x2020
leaq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x1040
movabsq $0x7ffffffffff, %rax    # imm = 0x7FFFFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0xe62(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1030
movq $0x1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movabsq $-0x4005000000000000, %rax # imm = 0xBFFB000000000000
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movabsq $0x7ffffffffff0, %rcx   # imm = 0x7FFFFFFFFFF0
andq -0x18(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rax
andq $0xf, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x122f
movq -0x30(%rbp), %rax
orq $0x7, %rax
movq %rax, -0x30(%rbp)
jmp 0x125d
cmpq $0x8, -0x40(%rbp)
jne 0x1244
movq -0x30(%rbp), %rax
orq $0xf, %rax
movq %rax, -0x30(%rbp)
jmp 0x125b
leaq 0xdfc(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1292
jmp 0x125d
movq -0x30(%rbp), %rsi
movsd -0x38(%rbp), %xmm0
leaq 0xe13(%rip), %rdi       # 0x2080
movb $0x1, %al
callq 0x1030
movq -0x20(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
leaq 0xe10(%rip), %rdi       # 0x2094
movb $0x1, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/4-ProcessKernel/time_example.c
// Function: main
int main(int argc, char **argv) {
	int i, is_printf;
	double x = 0;

	if(argc != 2) {
		print_usage(argv[0]);
		exit(1);
	}

	is_printf = atoi(argv[1]);
	if(is_printf != 0 && is_printf != 1) {
		print_usage(argv[0]);
		exit(1);
	}

	for(i = 1; i <= 1000000; i++) {
		x += i;
		if(is_printf == 1)
			printf("x = %.0f\n", x);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x11da
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1170
movl $0x1, %edi
callq 0x1060
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1050
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x120c
cmpl $0x1, -0x18(%rbp)
je 0x120c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1170
movl $0x1, %edi
callq 0x1060
movl $0x1, -0x14(%rbp)
cmpl $0xf4240, -0x14(%rbp)   # imm = 0xF4240
jg 0x1251
cvtsi2sdl -0x14(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x1244
movsd -0x20(%rbp), %xmm0
leaq 0xe0a(%rip), %rdi       # 0x2047
movb $0x1, %al
callq 0x1030
jmp 0x1246
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1213
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/agl[P]obstcp/curve25519/donna/../test.c
// Function: main
int
main() {
  uint8_t out[32], a[32], b[32];

  memset(a, 42, sizeof(a));
  memset(b, 64, sizeof(b));
  curve25519(out, a, b);
  return 0 != memcmp(out, "\x0eY\xe5-\xdc|%AV\x9eR\xe0\xba!\xf1T]>\xff\xca\xcaSS\x9c\xc4_\xec`O*\xd6\x03", 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x2a, %esi
movl $0x20, %edx
callq 0x1030
leaq -0x70(%rbp), %rdi
movl $0x40, %esi
movl $0x20, %edx
callq 0x1030
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x1fc0
leaq -0x30(%rbp), %rdi
leaq 0x1e53(%rip), %rsi      # 0x3004
movl $0x20, %edx
callq 0x1040
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wtakuo[P]SVM/test2.c
// Function: vmtest
void vmtest (int n, vm_mode_t trace) {
    int codelen = sizeof(code)/sizeof(Bcode);
    Function f = new_function(1, 0, code + 10, codelen - 10);
    gv[0] = (Value)n;
    gv[1] = (Value)f;

    vm(code, codelen, vs_base, VS_SIZE, gv, GV_SIZE, trace);

    delete_function(f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1f, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0xa, %eax
movslq %eax, %rcx
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
leaq 0x2dc2(%rip), %rdx      # 0x5070
addq $0xa, %rdx
callq 0x1c20
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, 0x2dea(%rip)      # 0x50b0
movq -0x18(%rbp), %rax
movq %rax, 0x2de7(%rip)      # 0x50b8
movslq -0xc(%rbp), %rsi
movq 0x2db4(%rip), %rdx      # 0x5090
movl -0x8(%rbp), %eax
leaq 0x2d8a(%rip), %rdi      # 0x5070
movl $0x100, %ecx            # imm = 0x100
leaq 0x2dbe(%rip), %r8       # 0x50b0
movl $0x8, %r9d
movl %eax, (%rsp)
callq 0x11b0
movq -0x18(%rbp), %rdi
callq 0x1ca0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eitijupaenoithoowohd[P]TBezierInterpolation/TBezierInterpolation.cpp
// Function: Segment::calc(double, Point2D&)
void calc(double t, Point2D &p)
	{
		double t2 = t * t;
		double t3 = t2 * t;
		double nt = 1.0 - t;
		double nt2 = nt * nt;
		double nt3 = nt2 * nt;
		p.x = nt3 * points[0].x + 3.0 * t * nt2 * points[1].x + 3.0 * t2 * nt * points[2].x + t3 * points[3].x;
		p.y = nt3 * points[0].y + 3.0 * t * nt2 * points[1].y + 3.0 * t2 * nt * points[2].y + t3 * points[3].y;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1e35(%rip), %xmm0     # 0x4010
subsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd (%rax), %xmm2
movsd 0x1e84(%rip), %xmm1     # 0x4098
mulsd -0x10(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd 0x10(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1e65(%rip), %xmm1     # 0x4098
mulsd -0x20(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movsd 0x20(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd 0x30(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rcx
movsd %xmm0, (%rcx)
movsd -0x40(%rbp), %xmm0
movsd 0x8(%rax), %xmm2
movsd 0x1e22(%rip), %xmm1     # 0x4098
mulsd -0x10(%rbp), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd 0x18(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1e03(%rip), %xmm1     # 0x4098
mulsd -0x20(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movsd 0x38(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.4/fork-exec.c
// Function: spawn(char*, char**)
int spawn (char* program, char** arg_list)
	{
	pid_t child_pid;
	/* Duplicate this process. */
	child_pid = fork ();
	if (child_pid != 0)
	/* This is the parent process. */
	return child_pid;
	else {
		/* Now execute PROGRAM, searching for it in the path. */
		execvp (program, arg_list);
		/* The execvp function returns only if an error occurs. */
		fprintf (stderr, "an error occurred in execvp\n");
		abort ();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x11a7
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1060
movq 0x2e25(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0xe3f(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
callq 0x1050
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.4/fork-exec.c
// Function: main
int main ()
{
	/* The argument list to pass to the "ls" command. */
	char* arg_list[] = {
		"ls", /* argv[0], the name of the program. */
		"-l",
		"/",
		NULL  /* The argument list must end with a NULL. */
	};
	/* Spawn a child process running the "ls" command. Ignore the returned child process ID. */
	spawn ("ls", arg_list);
	printf ("done with main program\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2baa(%rip), %rax      # 0x3da0
movq %rax, -0x30(%rbp)
movq 0x2ba7(%rip), %rax      # 0x3da8
movq %rax, -0x28(%rbp)
movq 0x2ba4(%rip), %rax      # 0x3db0
movq %rax, -0x20(%rbp)
movq 0x2ba1(%rip), %rax      # 0x3db8
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rsi
leaq 0xdfb(%rip), %rdi       # 0x2021
callq 0x1180
leaq 0xdf7(%rip), %rdi       # 0x2029
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: changeState(Thread*, char, bool)
void changeState(struct Thread* t, char statebit, bool op){
    char truebit = statebit;

    if(op){ // add a state
        if(t->state & truebit){} // already has the state
        else
            t->state += truebit;
    }else{
        if(t->state & truebit)
            t->state -= truebit;
        else{} // already lose the state
    }
}

// Assembly:
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rsp)
movb %cl, -0x9(%rsp)
andb $0x1, %al
movb %al, -0xa(%rsp)
movb -0x9(%rsp), %al
movb %al, -0xb(%rsp)
testb $0x1, -0xa(%rsp)
je 0xe60c
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movsbl -0xb(%rsp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xe5f9
jmp 0xe60a
movsbl -0xb(%rsp), %edx
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
addl %edx, %ecx
movb %cl, (%rax)
jmp 0xe637
movq -0x8(%rsp), %rax
movsbl (%rax), %eax
movsbl -0xb(%rsp), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xe633
movsbl -0xb(%rsp), %edx
movq -0x8(%rsp), %rax
movsbl (%rax), %ecx
subl %edx, %ecx
movb %cl, (%rax)
jmp 0xe635
jmp 0xe635
jmp 0xe637
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_resolve_state[abi:cxx11](char)
string unq_resolve_state(char state){
    string ret = "";
    
    ret += state & NORMAL_DISPLAY ? "Normal," : "Deleted,";
    ret += state & MAIN_THREAD ? "Thread," : "";
    ret += state & THREAD_REPLY ? "Reply," : "";
    ret += state & SAGE_THREAD ? "Sage," : "";
    ret += state & LOCKED_THREAD ? "Locked," : "";

    return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movb %sil, %al
movq %rdi, %rcx
movq %rcx, (%rsp)
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movb $0x0, 0x2e(%rsp)
leaq 0x2d(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xdc30
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0xb74ca(%rip), %rsi     # 0xc5b4b
callq 0xdad0
jmp 0xe688
leaq 0x2d(%rsp), %rdi
callq 0xdf30
movq 0x8(%rsp), %rdi
movb 0x2f(%rsp), %cl
leaq 0xb0962(%rip), %rax     # 0xbf004
leaq 0xb0963(%rip), %rsi     # 0xbf00c
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0xd1e0
jmp 0xe6b7
movq 0x8(%rsp), %rdi
movzbl 0x2f(%rsp), %eax
movb %al, %cl
leaq 0xb094b(%rip), %rax     # 0xbf015
leaq 0xb747a(%rip), %rsi     # 0xc5b4b
testb $0x4, %cl
cmovneq %rax, %rsi
callq 0xd1e0
jmp 0xe6df
movq 0x8(%rsp), %rdi
movzbl 0x2f(%rsp), %eax
movb %al, %cl
leaq 0xb092b(%rip), %rax     # 0xbf01d
leaq 0xb7452(%rip), %rsi     # 0xc5b4b
testb $0x2, %cl
cmovneq %rax, %rsi
callq 0xd1e0
jmp 0xe707
movq 0x8(%rsp), %rdi
movzbl 0x2f(%rsp), %eax
movb %al, %cl
leaq 0xb090a(%rip), %rax     # 0xbf024
leaq 0xb742a(%rip), %rsi     # 0xc5b4b
testb $0x10, %cl
cmovneq %rax, %rsi
callq 0xd1e0
jmp 0xe72f
movq 0x8(%rsp), %rdi
movb 0x2f(%rsp), %al
testb %al, %al
leaq 0xb08e9(%rip), %rax     # 0xbf02a
leaq 0xb7403(%rip), %rsi     # 0xc5b4b
cmovsq %rax, %rsi
callq 0xd1e0
jmp 0xe753
movb $0x1, 0x2e(%rsp)
testb $0x1, 0x2e(%rsp)
jne 0xe79f
jmp 0xe795
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2d(%rsp), %rdi
callq 0xdf30
jmp 0xe7a8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xdf50
jmp 0xe7a8
movq 0x8(%rsp), %rdi
callq 0xdf50
movq (%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_reset(unqlite*)
int unq_reset(unqlite *pDb){
    int rc = unq_write_int(pDb, "global_counter", 0, true);
    if (!rc) return 0;

    //construct the root thread
    cclong *key = new cclong(0);
    struct Thread *t = new Thread();
    t->threadID = 0;
    //t->state = 'r';
    t->nextThread = 0;
    t->childCount = 0;

    strcpy(t->content, "slogan");

    rc = unqlite_kv_store(pDb, key, 4, t, sizeof(struct Thread));
    if (rc != UNQLITE_OK)
        return 0;
    else{
        unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xb085d(%rip), %rsi     # 0xbf032
xorl %edx, %edx
movl $0x1, %ecx
callq 0xe8d0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0xe7f9
movl $0x0, 0x34(%rsp)
jmp 0xe8be
movl $0x4, %edi
callq 0xd250
movl $0x0, (%rax)
movq %rax, 0x18(%rsp)
movl $0xd0, %edi
callq 0xd250
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xd0, %edx
callq 0xd430
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x0, 0xb8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0xbc(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0xcc(%rax)
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
leaq 0xb1829(%rip), %rsi     # 0xc009c
callq 0xd580
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl $0x4, %edx
movl $0xd0, %r8d
callq 0x587e0
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xe8ac
movl $0x0, 0x34(%rsp)
jmp 0xe8be
movq 0x28(%rsp), %rdi
callq 0x5a060
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_write_int(unqlite*, char const*, int, bool)
int unq_write_int(unqlite *pDb, const char* key, int value, bool autoCommit){
    int* zzz = new cclong(value);
    int rc;
    rc = unqlite_kv_store(pDb, key, -1, zzz, 4);
    delete zzz;

    if (rc != UNQLITE_OK)
        return 0;
    else{
        if(autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
andb $0x1, %al
movb %al, 0x1b(%rsp)
movl $0x4, %edi
callq 0xd250
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x4, %r8d
callq 0x587e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xe93a
movq (%rsp), %rdi
callq 0xd760
cmpl $0x0, 0xc(%rsp)
je 0xe94b
movl $0x0, 0x34(%rsp)
jmp 0xe964
testb $0x1, 0x1b(%rsp)
je 0xe95c
movq 0x28(%rsp), %rdi
callq 0x5a060
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_thread_parent(unqlite*, Thread*)
int unq_thread_parent(unqlite *pDb, struct Thread* b){
    // struct Thread* b = unq_read_thread(pDb, startID);
    int startID = b->threadID;
    if (!(b->state & NORMAL_DISPLAY)) return -1;
    if (b->state & MAIN_THREAD) return 0;
    if (b->parentThread) return b->parentThread;

    while (b->nextThread != startID){
        b = unq_read_thread(pDb, b->nextThread);
        if (b->parentThread) return b->parentThread;
    }

    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xb8(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe9aa
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xea39
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe9c4
movl $0x0, 0x24(%rsp)
jmp 0xea39
movq 0x10(%rsp), %rax
cmpl $0x0, 0xc8(%rax)
je 0xe9e3
movq 0x10(%rsp), %rax
movl 0xc8(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xea39
jmp 0xe9e5
movq 0x10(%rsp), %rax
movl 0xbc(%rax), %eax
cmpl 0xc(%rsp), %eax
je 0xea31
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movl 0xbc(%rax), %esi
callq 0xea50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0xc8(%rax)
je 0xea2f
movq 0x10(%rsp), %rax
movl 0xc8(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xea39
jmp 0xe9e5
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_read_thread(unqlite*, int)
struct Thread* unq_read_thread(unqlite *pDb, int key){
    unqlite_int64 nBytes = sizeof(struct Thread);
    // cclong *k = new cclong(key);
    int k = key;

    int rc;
    struct Thread* zBuf = new Thread();

    rc = unqlite_kv_fetch(pDb, &k, 4, zBuf, &nBytes);
    
    // delete k;
    //even the fetch function failed, we return an empty structure

    return zBuf;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0xd0, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0xd0, %edi
callq 0xd250
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0xd0, %edx
callq 0xd430
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rcx
leaq 0x1c(%rsp), %rsi
movl $0x4, %edx
leaq 0x20(%rsp), %r8
callq 0x58fb0
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_write_thread(unqlite*, int, Thread*, bool)
int unq_write_thread(unqlite *pDb, cclong key, struct Thread* t, bool autoCommit){
    
    int k = key;
    int rc;
    rc = unqlite_kv_store(pDb, &k, 4, t, sizeof(struct Thread));

    if (rc != UNQLITE_OK)
        return 0;
    else{
        if (autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
movl $0xd0, %r8d
callq 0x587e0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xecf6
movl $0x0, 0x34(%rsp)
jmp 0xed0f
testb $0x1, 0x17(%rsp)
je 0xed07
movq 0x28(%rsp), %rdi
callq 0x5a060
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_write_string(unqlite*, char const*, char const*, bool)
int unq_write_string(unqlite *pDb, const char* key, const char* value, bool autoCommit){
    int rc;
    rc = unqlite_kv_store_fmt(pDb, key, -1, value); //simple
    if (rc != UNQLITE_OK)
        return 0;
    else{
        if (autoCommit) unqlite_commit(pDb);
        return 1;
    }
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
andb $0x1, %al
movb %al, 0x7(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x589c0
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0xf029
movl $0x0, 0x24(%rsp)
jmp 0xf042
testb $0x1, 0x7(%rsp)
je 0xf03a
movq 0x18(%rsp), %rdi
callq 0x5a060
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: displayReply(unqlite*, Thread*)
int displayReply(unqlite *pDb, struct Thread *t){
    cclong ct = t->childThread;
    struct Thread *r = unq_read_thread(pDb, ct); // beginning of the circle
    cclong rid = r->threadID; //the ID

    struct tm * timeinfo;
    timeinfo = localtime(&(r->date));
    fprintf(stdout, "  %d Reply(s)\n", r->childCount);
    fprintf(stdout, "  Reply-ID: %d, Author: %s, Date: %s  %s\n", rid, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));

    while (r->prevThread != rid){
        r = unq_read_thread(pDb, r->prevThread);
        timeinfo = localtime(&(r->date));
        fprintf(stdout, "  Reply-ID: %d, Author: %s, Date: %s  %s\n", r->threadID, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));
    }

    return 1;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movl 0xc4(%rax), %eax
movl %eax, 0x64(%rsp)
movq 0x70(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0xea50
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movl 0xb8(%rax), %eax
movl %eax, 0x54(%rsp)
movq 0x58(%rsp), %rdi
addq $0xa0, %rdi
callq 0xd8b0
movq %rax, 0x48(%rsp)
movq 0xde79c(%rip), %rax     # 0xedf98
movq (%rax), %rdi
movq 0x58(%rsp), %rax
movl 0xcc(%rax), %edx
leaq 0xaf830(%rip), %rsi     # 0xbf041
movb $0x0, %al
callq 0xd2d0
movq 0xde779(%rip), %rax     # 0xedf98
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x58(%rsp), %rax
addq $0x11, %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd610
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x1, %rsi
callq 0xf950
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %edx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
movq %rax, %r9
leaq 0xaf7d4(%rip), %rsi     # 0xbf050
movb $0x0, %al
callq 0xd2d0
movq 0x58(%rsp), %rax
movl 0xc0(%rax), %eax
cmpl 0x54(%rsp), %eax
je 0xf93f
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rax
movl 0xc0(%rax), %esi
callq 0xea50
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
addq $0xa0, %rdi
callq 0xd8b0
movq %rax, 0x48(%rsp)
movq 0xde6c9(%rip), %rax     # 0xedf98
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movl 0xb8(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x58(%rsp), %rax
addq $0x11, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0xd610
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x1, %rsi
callq 0xf950
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq %rax, %r9
leaq 0xaf71d(%rip), %rsi     # 0xbf050
movb $0x0, %al
callq 0xd2d0
jmp 0xf883
movl $0x1, %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_read_string(unqlite*, char const*)
const char* unq_read_string(unqlite *pDb, const char* key){
    unqlite_int64 nBytes;
    int rc;
    rc = unqlite_kv_fetch(pDb, key, -1, NULL, &nBytes);
    if (rc != UNQLITE_OK)
        return 0;

    char *zBuf = new char[++nBytes];
    if (zBuf == NULL) 
        return 0;

    rc = unqlite_kv_fetch(pDb, key, -1, zBuf, &nBytes);
    if (rc != UNQLITE_OK)
        return 0;

    zBuf[nBytes] = 0;

    return zBuf;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %ecx
leaq 0x18(%rsp), %r8
callq 0x58fb0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0xf994
movq $0x0, 0x30(%rsp)
jmp 0xfa1a
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
movq %rdi, 0x18(%rsp)
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0xd650
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xf9ce
movq $0x0, 0x30(%rsp)
jmp 0xfa1a
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %r8
callq 0x58fb0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0xfa02
movq $0x0, 0x30(%rsp)
jmp 0xfa1a
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: listThread(unqlite*)
int listThread(unqlite *pDb){
    struct Thread *r = unq_read_thread(pDb, 0); // get the root thread
    //iterThread(pDb, r);

    while (r->nextThread){
        r = unq_read_thread(pDb, r->nextThread);

        struct tm * timeinfo;
        timeinfo = localtime(&(r->date));
        fprintf(stdout, "ID: %d, Author: %s, Date: %s%s\n", r->threadID, r->author, asctime(timeinfo), unq_read_string(pDb, r->content));

        if (r->childThread) displayReply(pDb, r);
    }

    return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xea50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0xbc(%rax)
je 0xfb1e
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0xbc(%rax), %esi
callq 0xea50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
addq $0xa0, %rdi
callq 0xd8b0
movq %rax, 0x20(%rsp)
movq 0xde505(%rip), %rax     # 0xedf98
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movl 0xb8(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
addq $0x11, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xd610
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x1, %rsi
callq 0xf950
movq (%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq %rax, %r9
leaq 0xaf585(%rip), %rsi     # 0xbf07a
movb $0x0, %al
callq 0xd2d0
movq 0x28(%rsp), %rax
cmpl $0x0, 0xc4(%rax)
je 0xfb19
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf7a0
jmp 0xfa4a
movl $0x1, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_read_int(unqlite*, int)
int unq_read_int(unqlite *pDb, int key){
    unqlite_int64 nBytes = 4;
    int *k = new int(key);
    int rc;
    int* zBuf = new int(0);

    rc = unqlite_kv_fetch(pDb, k, 4, zBuf, &nBytes);
    delete k;

    // if (rc != UNQLITE_OK)
    //  return 0;

    return *zBuf;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x4, 0x20(%rsp)
movl $0x4, %edi
callq 0xd250
movl 0x2c(%rsp), %ecx
movl %ecx, (%rax)
movq %rax, 0x18(%rsp)
movl $0x4, %edi
callq 0xd250
movl $0x0, (%rax)
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rcx
movl $0x4, %edx
leaq 0x20(%rsp), %r8
callq 0x58fb0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xfbaa
movq (%rsp), %rdi
callq 0xd760
movq 0x8(%rsp), %rax
movl (%rax), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/general.cpp
// Function: unq_read_thread_sp(unqlite*, int)
std::shared_ptr<struct Thread> unq_read_thread_sp(unqlite * pDb, int key)
{
    unqlite_int64 nBytes = sizeof(struct Thread);
    std::shared_ptr<struct Thread> ret = std::shared_ptr<struct Thread>(new Thread());

    unqlite_kv_fetch(pDb, &key, 4, ret.get(), &nBytes);

    return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq $0xd0, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
movl $0xd0, %edi
callq 0xd250
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0xc0(%rsi)
movaps %xmm0, 0xb0(%rsi)
movaps %xmm0, 0xa0(%rsi)
movaps %xmm0, 0x90(%rsi)
movaps %xmm0, 0x80(%rsi)
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
callq 0xfcd0
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0xfd00
movq 0x28(%rsp), %rdi
movq %rax, %rcx
leaq 0x54(%rsp), %rsi
movl $0x4, %edx
leaq 0x48(%rsp), %r8
callq 0x58fb0
jmp 0xfc84
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0xfcb6
jmp 0xfcac
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xfd10
jmp 0xfcbf
movq 0x20(%rsp), %rdi
callq 0xfd10
movq (%rsp), %rax
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xd8a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: cck_extract_ssid[abi:cxx11](mg_connection*)
string cck_extract_ssid(mg_connection* conn){
    char ssid[128]; 
    mg_parse_header(mg_get_header(conn, "Cookie"), "ssid", ssid, sizeof(ssid));
    string ret(ssid);

    return ret;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
leaq 0xaeee9(%rip), %rsi     # 0xbf13c
callq 0xb0fe0
movq %rax, %rdi
leaq 0xaeee1(%rip), %rsi     # 0xbf143
leaq 0x40(%rsp), %rdx
movq %rdx, 0x18(%rsp)
movl $0x80, %ecx
callq 0xb2ee0
movb $0x0, 0x3f(%rsp)
leaq 0x3e(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xdc30
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xdad0
jmp 0x102a0
leaq 0x3e(%rsp), %rdi
callq 0xdf30
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x102dc
jmp 0x102d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3e(%rsp), %rdi
callq 0xdf30
jmp 0x102e9
movq 0x10(%rsp), %rdi
callq 0xdf50
movq 0x8(%rsp), %rax
addq $0xd8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: is_assist[abi:cxx11](mg_connection*)
string is_assist(mg_connection* conn){
    string ssid = cck_extract_ssid(conn);
    for(auto x = assist_cookie.begin(); x != assist_cookie.end(); ++x){
        // cout << x->first << "," << x->second << "," << ssid << endl;
        if(x->second == ssid) return x->first;
    }

    return string("");
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x10220
leaq 0xded0f(%rip), %rdi     # 0xef040
callq 0x145a0
movq %rax, 0x40(%rsp)
leaq 0xdecfe(%rip), %rdi     # 0xef040
callq 0x145f0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x145d0
testb $0x1, %al
jne 0x10361
jmp 0x103c6
leaq 0x40(%rsp), %rdi
callq 0x14620
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x48(%rsp), %rsi
callq 0x14500
testb $0x1, %al
jne 0x10382
jmp 0x103b5
leaq 0x40(%rsp), %rdi
callq 0x14620
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd1b0
jmp 0x1039b
movl $0x1, 0x28(%rsp)
jmp 0x1041b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x1042f
jmp 0x103b7
leaq 0x40(%rsp), %rdi
callq 0x14650
jmp 0x1033b
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xdc30
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xb5765(%rip), %rsi     # 0xc5b4b
callq 0xdad0
jmp 0x103ed
leaq 0x27(%rsp), %rdi
callq 0xdf30
movl $0x1, 0x28(%rsp)
jmp 0x1041b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x27(%rsp), %rdi
callq 0xdf30
jmp 0x1042f
leaq 0x48(%rsp), %rdi
callq 0xdf50
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0xdf50
movq 0x30(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: cck_send_ssid(mg_connection*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void cck_send_ssid(mg_connection *conn, const std::string c){
    char expire[100];
    time_t t = time(NULL) + 60 * 60 * 24 * 30;
    strftime(expire, sizeof(expire), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t));

    mg_printf(conn,
        "HTTP/1.1 200 OK\r\n"
        "Set-Cookie: ssid=%s; expires=%s; max-age=%d; path=/; http-only; HttpOnly;\r\n"
        "Content-type: text/html\r\n"
        "X-UA-Compatible: IE=edge\r\n"
        "Content-Length: 0\r\n",
        c.c_str(), expire, 60 * 60 * 24 * 30);
}

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0xd980
addq $0x278d00, %rax         # imm = 0x278D00
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0xd3a0
movq (%rsp), %rdi
movq %rax, %rcx
movl $0x64, %esi
leaq 0xaeca2(%rip), %rdx     # 0xbf148
callq 0xdb40
movq 0x8(%rsp), %rdi
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xd190
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x20(%rsp), %rcx
leaq 0xaec8c(%rip), %rsi     # 0xbf162
movl $0x278d00, %r8d         # imm = 0x278D00
movb $0x0, %al
callq 0xb0cb0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: cck_send_admin_ssid(mg_connection*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const*)
void cck_send_admin_ssid(mg_connection *conn, const string ssid, const char* type){
    ConfigManager c;
    char expire[100];
    time_t t = time(NULL) + 60 * c.global().get<int>("security::" + string(type) + "::expire_time");
    strftime(expire, sizeof(expire), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t));

    mg_printf(conn,
        "HTTP/1.1 200 OK\r\n"
        "Set-Cookie: ssid=%s; expires=%s; path=/; http-only; HttpOnly;\r\n"
        "Content-type: text/html\r\n"
        "X-UA-Compatible: IE=edge\r\n"
        "Content-Length: 0\r\n",
        ssid.c_str(), expire);
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, 0x30(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
leaq 0x138(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x14680
xorl %eax, %eax
movl %eax, %edi
callq 0xd980
movq 0x38(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x146c0
movq %rax, 0x48(%rsp)
jmp 0x10545
movq 0x1e0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdc30
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0xdad0
jmp 0x10577
leaq 0xaec87(%rip), %rsi     # 0xbf205
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rdx
callq 0x14830
jmp 0x1058f
leaq 0xaec7a(%rip), %rdx     # 0xbf210
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x147e0
jmp 0x105aa
movq 0x48(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x14720
movl %eax, 0x1c(%rsp)
jmp 0x105c2
movq 0x40(%rsp), %rax
movl 0x1c(%rsp), %ecx
imull $0x3c, %ecx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x98(%rsp), %rdi
callq 0xdf50
leaq 0x78(%rsp), %rdi
callq 0xdf50
leaq 0x58(%rsp), %rdi
callq 0xdf50
leaq 0x57(%rsp), %rdi
callq 0xdf30
movq (%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0xd3a0
movq %rax, %rcx
leaq 0xaeb22(%rip), %rdx     # 0xbf148
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x64, %esi
callq 0xdb40
movq 0x30(%rsp), %rdi
movq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xd190
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq %rax, %rdx
leaq 0xaebb6(%rip), %rsi     # 0xbf21e
xorl %eax, %eax
callq 0xb0cb0
jmp 0x10671
leaq 0x138(%rsp), %rdi
callq 0x14880
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x10720
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x10716
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x1070c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x10702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xdf50
leaq 0x78(%rsp), %rdi
callq 0xdf50
leaq 0x58(%rsp), %rdi
callq 0xdf50
leaq 0x57(%rsp), %rdi
callq 0xdf30
leaq 0x138(%rsp), %rdi
callq 0x14880
movq 0xc0(%rsp), %rdi
callq 0xd8a0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/coyove[P]chann/./src/helper.cpp
// Function: _generate_appender[abi:cxx11](char const*)
string __generate_appender(const char *username) {
    char *hash = new char[33];
    ConfigManager c;
    mg_md5(hash, username, ":", c.global().get("security::salt").c_str(), NULL);
    // mg_md5(hash, username, ":", md5Salt, NULL);

    string ret(hash);
    delete [] hash;

    return ret;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movl $0x21, %edi
callq 0xd650
movq %rax, 0x140(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x14680
movq 0x40(%rsp), %rdi
movq 0x140(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x50(%rsp)
callq 0x146c0
movq %rax, 0x58(%rsp)
jmp 0x107b3
leaq 0x67(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdc30
movq 0x28(%rsp), %rdx
leaq 0xaeae7(%rip), %rsi     # 0xbf2b5
leaq 0x68(%rsp), %rdi
callq 0xdad0
jmp 0x107da
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x148c0
movq %rax, 0x20(%rsp)
jmp 0x107f0
movq 0x20(%rsp), %rdi
callq 0xd190
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq %rax, %rcx
leaq 0xaf429(%rip), %rdx     # 0xbfc37
xorl %eax, %eax
movl %eax, %r8d
callq 0xb2680
jmp 0x1081a
leaq 0x68(%rsp), %rdi
callq 0xdf50
leaq 0x67(%rsp), %rdi
callq 0xdf30
movb $0x0, 0x66(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x65(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdc30
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xdad0
jmp 0x10865
leaq 0x65(%rsp), %rdi
callq 0xdf30
movq 0x140(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1088c
movq 0x8(%rsp), %rdi
callq 0xd4d0
movb $0x1, 0x66(%rsp)
testb $0x1, 0x66(%rsp)
jne 0x10921
jmp 0x10917
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x1093b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x108eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xdf50
leaq 0x67(%rsp), %rdi
callq 0xdf30
jmp 0x1093b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x65(%rsp), %rdi
callq 0xdf30
jmp 0x1093b
movq 0x30(%rsp), %rdi
callq 0xdf50
leaq 0x98(%rsp), %rdi
callq 0x14880
movq 0x38(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
retq
leaq 0x98(%rsp), %rdi
callq 0x14880
movq 0x90(%rsp), %rdi
callq 0xd8a0
nopw %cs:(%rax,%rax)