LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: num_lt
static int num_lt(num a, num b) {
  int ret;
  int is_fixnum = a.is_fixnum && b.is_fixnum;
  if (is_fixnum) {
    ret = a.value.ivalue < b.value.ivalue;
  } else {
    ret = num_rvalue(a) < num_rvalue(b);
  }
  return ret;
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movb %al, -0x20(%rsp)
movq %rcx, -0x18(%rsp)
movsbl -0x10(%rsp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rsp)
je 0x15b16
movsbl -0x20(%rsp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rsp)
cmpl $0x0, -0x28(%rsp)
je 0x15b42
movq -0x8(%rsp), %rax
cmpq -0x18(%rsp), %rax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rsp)
jmp 0x15bae
cmpb $0x0, -0x10(%rsp)
jne 0x15b57
movsd -0x8(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x15b64
cvtsi2sdq -0x8(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
movsd -0x38(%rsp), %xmm0
movsd %xmm0, -0x40(%rsp)
cmpb $0x0, -0x20(%rsp)
jne 0x15b85
movsd -0x18(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
jmp 0x15b92
cvtsi2sdq -0x18(%rsp), %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x40(%rsp), %xmm1
movsd -0x48(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rsp)
movl -0x24(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: reverse
static pointer reverse(scheme * sc, pointer a) {
/* a must be checked by gc */
  pointer p = sc->NIL;

  for (; is_pair(a); a = cdr(a)) {
    p = cons(sc, car(a), p);
  }
  return (p);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x4710
cmpl $0x0, %eax
je 0x15f2a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq (%rsp), %rdx
xorl %ecx, %ecx
callq 0x4950
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x15eee
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: revappend
static pointer revappend(scheme * sc, pointer a, pointer b) {
  pointer result = a;
  pointer p = b;

  while (is_pair(p)) {
    result = cons(sc, car(p), result);
    p = cdr(p);
  }

  if (p == sc->NIL) {
    return result;
  }

  return sc->F;                 /* signal an error */
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4710
cmpl $0x0, %eax
je 0x15fa5
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x4950
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x15f67
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x90(%rcx), %rax
jne 0x15fc4
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x15fd5
movq 0x28(%rsp), %rax
movq 0xd0(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: oblist_all_symbols
static pointer oblist_all_symbols(scheme * sc) {
  int i;
  pointer x;
  pointer ob_list = sc->NIL;

  for (i = 0; i < ivalue_unchecked(sc->oblist); i++) {
    for (x = vector_elem(sc->oblist, i); x != sc->NIL; x = cdr(x)) {
      ob_list = cons(sc, x, ob_list);
    }
  }
  return ob_list;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xf8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jge 0x16080
movq 0x20(%rsp), %rax
movq 0xf8(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0x8180
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x90(%rcx), %rax
je 0x16071
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x4950
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x16033
jmp 0x16073
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x16002
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_from_filename
static pointer port_from_filename(scheme * sc, const char *fn, int prop) {
  port *pt;
  pt = port_rep_from_filename(sc, fn, prop);
  if (pt == 0) {
    return sc->NIL;
  }
  return mk_port(sc, pt);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0x16140
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x160d3
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x160e6
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6f30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_from_scratch
static pointer port_from_scratch(scheme * sc) {
  port *pt;
  pt = port_rep_from_scratch(sc);
  if (pt == 0) {
    return sc->NIL;
  }
  return mk_port(sc, pt);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x162a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x16121
movq 0x8(%rsp), %rax
movq 0x90(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x16134
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6f30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_rep_from_filename
static port *port_rep_from_filename(scheme * sc, const char *fn, int prop) {
  FILE *f;
  char *rw;
  port *pt;
  if (prop == (port_input | port_output)) {
    rw = "a+";
  } else if (prop == port_output) {
    rw = "w";
  } else {
    rw = "r";
  }
  f = fopen(fn, rw);
  if (f == 0) {
    return 0;
  }
  pt = port_rep_from_file(sc, f, prop);
  pt->rep.stdio.closeit = 1;

#if SHOW_ERROR_LINE
  if (fn)
    pt->rep.stdio.filename = store_string(sc, strlen(fn), fn);

  pt->rep.stdio.curr_line = 0;
#endif
  return pt;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
cmpl $0x30, 0x2c(%rsp)
jne 0x16167
leaq 0x237d(%rip), %rax      # 0x184dd
movq %rax, 0x18(%rsp)
jmp 0x1618a
cmpl $0x20, 0x2c(%rsp)
jne 0x1617c
leaq 0x236b(%rip), %rax      # 0x184e0
movq %rax, 0x18(%rsp)
jmp 0x16188
leaq 0x1877(%rip), %rax      # 0x179fa
movq %rax, 0x18(%rsp)
jmp 0x1618a
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4230
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x161b1
movq $0x0, 0x40(%rsp)
jmp 0x16224
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0x16230
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x1, 0x10(%rax)
cmpq $0x0, 0x30(%rsp)
je 0x1620e
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x40a0
movq 0x8(%rsp), %rdi
movl %eax, %esi
movq 0x30(%rsp), %rdx
callq 0x4cc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_rep_from_file
static port *port_rep_from_file(scheme * sc, FILE * f, int prop) {
  port *pt;

  pt = (port *) sc->malloc(sizeof *pt);
  if (pt == NULL) {
    return NULL;
  }
  pt->kind = port_file | prop;
  pt->rep.stdio.file = f;
  pt->rep.stdio.closeit = 0;
  return pt;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl $0x20, %edi
callq *(%rax)
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x16264
movq $0x0, 0x20(%rsp)
jmp 0x16294
movl 0xc(%rsp), %eax
orl $0x1, %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_rep_from_scratch
static port *port_rep_from_scratch(scheme * sc) {
  port *pt;
  char *start;
  pt = (port *) sc->malloc(sizeof(port));
  if (pt == 0) {
    return 0;
  }
  start = sc->malloc(BLOCK_SIZE);
  if (start == 0) {
    return 0;
  }
  memset(start, ' ', BLOCK_SIZE - 1);
  start[BLOCK_SIZE - 1] = '\0';
  pt->kind = port_string | port_output | port_srfi6;
  pt->rep.string.start = start;
  pt->rep.string.curr = start;
  pt->rep.string.past_the_end = start + BLOCK_SIZE - 1;
  return pt;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl $0x20, %edi
callq *(%rax)
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x162d0
movq $0x0, 0x20(%rsp)
jmp 0x1635b
movq 0x18(%rsp), %rax
movl $0x100, %edi            # imm = 0x100
callq *(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x162f4
movq $0x0, 0x20(%rsp)
jmp 0x1635b
movq 0x8(%rsp), %rdi
movl $0x20, %esi
movl $0xff, %edx
callq 0x4100
movq 0x8(%rsp), %rax
movb $0x0, 0xff(%rax)
movq 0x10(%rsp), %rax
movb $0x26, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
addq $0x100, %rcx            # imm = 0x100
addq $-0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: inchar8
static int inchar8(scheme * sc) {
  int c;
  port *pt;
  if (sc->backchar >= 0) {
    c = sc->backchar;
    sc->backchar = -1;
    return c;
  }
  pt = sc->inport->_object._port;
  if (pt->kind & port_saw_EOF) {
    return EOF;
  }
  c = basic_inchar(pt);
  if (c == EOF && sc->inport == sc->loadport) {
    /* Instead, set port_saw_EOF */
    pt->kind |= port_saw_EOF;
    return EOF;
  }
  return c;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jl 0x163a6
movq 0x18(%rsp), %rax
movl 0x2c(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl $0xffffffff, 0x2c(%rax) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x16423
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x163d5
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16423
movq 0x8(%rsp), %rdi
callq 0x13c90
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x1641b
movq 0x18(%rsp), %rax
movq 0x170(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x188(%rcx), %rax
jne 0x1641b
movq 0x8(%rsp), %rax
movzbl (%rax), %ecx
orl $0x40, %ecx
movb %cl, (%rax)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16423
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: readstr_upto
static char *readstr_upto(scheme * sc, char *delim) {
  char *p = sc->strbuff;
  int c, len;

  while (1) {
    c = inchar(sc);
    if (check_strbuff_size(sc, &p)) {
      char_to_utf8(c, p, &len);
      p += len;
    }
    if(is_one_of(delim, c)) {
      break;
    }
  }

  if (p == sc->strbuff + 2 && p[-2] == '\\') {
    *p = 0;
  } else {
    backchar(sc, p[-1]);
    *--p = '\0';
  }
  return sc->strbuff;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0xea0(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x13a70
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x159b0
cmpl $0x0, %eax
je 0x16498
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x15830
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x13b30
cmpl $0x0, %eax
je 0x164ad
jmp 0x164af
jmp 0x1644f
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0xea0(%rcx), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x164e1
movq 0x10(%rsp), %rax
movsbl -0x2(%rax), %eax
cmpl $0x5c, %eax
jne 0x164e1
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
jmp 0x16509
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movsbl -0x1(%rax), %esi
callq 0x13b90
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rsp)
movb $0x0, -0x1(%rax)
movq 0x20(%rsp), %rax
movq 0xea0(%rax), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: putchars
static void putchars(scheme * sc, const char *s, int len) {
  port *pt = sc->outport->_object._port;
  if (pt->kind & port_file) {
    fwrite(s, 1, len, pt->rep.stdio.file);
  } else {
    for (; len; len--) {
      if (pt->rep.string.curr != pt->rep.string.past_the_end) {
        *pt->rep.string.curr++ = *s++;
      } else if (pt->kind & port_srfi6 && realloc_port_string(sc, pt)) {
        *pt->rep.string.curr++ = *s++;
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x178(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16939
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x4290
jmp 0x169e8
jmp 0x1693b
cmpl $0x0, 0x14(%rsp)
je 0x169e6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
je 0x16985
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x169d4
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x169d2
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x5240
cmpl $0x0, %eax
je 0x169d2
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movb %cl, (%rax)
jmp 0x169d4
jmp 0x169d6
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1693b
jmp 0x169e8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: mk_proc
static pointer mk_proc(scheme * sc, enum scheme_opcodes op) {
  pointer y;

  y = get_cell(sc, sc->NIL, sc->NIL);
  typeflag(y) = (T_PROC | T_ATOM);
  ivalue_unchecked(y) = (long) op;
  set_num_integer(y);
  return y;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rdx
callq 0x49c0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x4004, (%rax)         # imm = 0x4004
movl 0xc(%rsp), %eax
movl %eax, %ecx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movb $0x1, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: port_rep_from_string
static port *port_rep_from_string(scheme * sc, char *start,
    char *past_the_end, int prop) {
  port *pt;
  pt = (port *) sc->malloc(sizeof(port));
  if (pt == 0) {
    return 0;
  }
  pt->kind = port_string | prop;
  pt->rep.string.start = start;
  pt->rep.string.curr = start;
  pt->rep.string.past_the_end = past_the_end;
  return pt;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rax
movl $0x20, %edi
callq *(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16a8b
movq $0x0, 0x30(%rsp)
jmp 0x16acf
movl 0x14(%rsp), %eax
orl $0x2, %eax
movb %al, %cl
movq 0x8(%rsp), %rax
movb %cl, (%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/RodionGork[P]tinyscheme/scheme.c
// Function: finalize_cell
static void finalize_cell(scheme * sc, pointer a) {
  if (is_string(a)) {
    sc->free(strvalue(a));
  } else if (is_port(a)) {
    if (a->_object._port->kind & port_file
        && a->_object._port->rep.stdio.closeit) {
      port_close(sc, a, port_input | port_output);
    }
    sc->free(a->_object._port);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4400
cmpl $0x0, %eax
je 0x16d33
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
jmp 0x16d8f
movq 0x8(%rsp), %rdi
callq 0x4650
cmpl $0x0, %eax
je 0x16d8d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16d79
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x10(%rax)
je 0x16d79
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x30, %edx
callq 0x138f0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
jmp 0x16d8f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/compute_file_md5.c
// Function: compute_file_md5
int compute_file_md5(const char* file_path,char* md5_str,int size)
{
    int i;
	int fd;
	int ret;
	unsigned char data[READ_DATA_SIZE];
	unsigned char md5_value[MD5_SIZE];
	MD5_CTX md5;

	fd = open(file_path, O_RDONLY);
	if (-1 == fd)
	{
		perror("open");
		return -1;
	}

	// init md5
	MD5Init(&md5);

    int total = 0;
    while(total < size)
	{
        if(size - total > 4096)
		    ret = read(fd, data, 4096);
        else
            ret = read(fd,data,size - total);
		if (-1 == ret)
		{
			perror("read");
			close(fd);
			return -1;
		}
		MD5Update(&md5, data, ret);
        total += ret;
	}

	close(fd);

	MD5Final(&md5, md5_value);

	// convert md5 value to md5 string
	for(i = 0; i < MD5_SIZE; i++)
	{
		snprintf(md5_str + i*2, 2+1, "%02x", md5_value[i]);
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10a0, %rsp           # imm = 0x10A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x2100
movl %eax, -0x24(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x24(%rbp), %eax
jne 0x2c78
leaq 0x343b(%rip), %rdi      # 0x60a2
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d9f
leaq -0x1098(%rbp), %rdi
callq 0x34c0
movl $0x0, -0x109c(%rbp)
movl -0x109c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x2d38
movl -0x1c(%rbp), %eax
subl -0x109c(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x2cc6
movl -0x24(%rbp), %edi
leaq -0x1030(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2200
movl %eax, -0x28(%rbp)
jmp 0x2ce4
movl -0x24(%rbp), %edi
leaq -0x1030(%rbp), %rsi
movl -0x1c(%rbp), %eax
subl -0x109c(%rbp), %eax
movslq %eax, %rdx
callq 0x2200
movl %eax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x28(%rbp), %eax
jne 0x2d0e
leaq 0x33b2(%rip), %rdi      # 0x60a7
callq 0x2130
movl -0x24(%rbp), %edi
callq 0x22c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d9f
leaq -0x1030(%rbp), %rsi
movl -0x28(%rbp), %edx
leaq -0x1098(%rbp), %rdi
callq 0x3510
movl -0x28(%rbp), %eax
addl -0x109c(%rbp), %eax
movl %eax, -0x109c(%rbp)
jmp 0x2c8e
movl -0x24(%rbp), %edi
callq 0x22c0
leaq -0x1040(%rbp), %rsi
leaq -0x1098(%rbp), %rdi
callq 0x4560
movl $0x0, -0x20(%rbp)
cmpl $0x10, -0x20(%rbp)
jge 0x2d98
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
movslq -0x20(%rbp), %rax
movzbl -0x1040(%rbp,%rax), %ecx
movl $0x3, %esi
leaq 0x3326(%rip), %rdx      # 0x60ac
movb $0x0, %al
callq 0x2270
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2d5a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10a0, %rsp           # imm = 0x10A0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/get_absolute_path.c
// Function: get_absolute_path
int get_absolute_path(char* buf,int size)
{              
    char* oldpath = getcwd(NULL,0);
    chdir(buf);
    char* newpath = getcwd(NULL,0);
    memset(buf,0,size);
    strcpy(buf,newpath);
    chdir(oldpath);
    free(oldpath);
    free(newpath);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2210
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x20f0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x2210
movq -0x18(%rbp), %rdi
callq 0x21a0
movq -0x20(%rbp), %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/gets.c
// Function: pthread_download_file
void* pthread_download_file(void* arg)
{
    int sock_fd = *(int*)arg;
    char buf[4096];
    while(1)
    {
        memset(buf,0,sizeof(buf));
        int len;
        int ret = recv(sock_fd,&len,sizeof(int),0);
        if(ret == 0)
            break;
        ret = recv_client_all(sock_fd,buf,len);
        if(ret == -1)
            break;
        char file_type = '\0';
        ret = recv(sock_fd,&file_type,sizeof(char),0);
        if(ret == 0)
            break;
        if(file_type == 'd')
        {
            puts(buf);
            struct stat st;
            ret = stat(buf,&st);
            if(ret == -1)
            {
                mkdir(buf,0777);
            }
            else if((st.st_mode & S_IFMT) != S_IFDIR)
            {
                unlink(buf);
                mkdir(buf,0777);
            }
        }
        else
        {
            ret = recv_server_file(sock_fd,buf);
            if(ret == -1)
                break;
        }
    }
    close(sock_fd);
    free(arg);
    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10b0, %rsp           # imm = 0x10B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20f0
movl -0xc(%rbp), %edi
leaq -0x1014(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x2080
movl %eax, -0x1018(%rbp)
cmpl $0x0, -0x1018(%rbp)
jne 0x2ee5
jmp 0x2fe6
movl -0xc(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl -0x1014(%rbp), %edx
callq 0x4a30
movl %eax, -0x1018(%rbp)
cmpl $-0x1, -0x1018(%rbp)
jne 0x2f0e
jmp 0x2fe6
movb $0x0, -0x1019(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1019(%rbp), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x2080
movl %eax, -0x1018(%rbp)
cmpl $0x0, -0x1018(%rbp)
jne 0x2f3f
jmp 0x2fe6
movsbl -0x1019(%rbp), %eax
cmpl $0x64, %eax
jne 0x2fbf
leaq -0x1010(%rbp), %rdi
callq 0x2250
leaq -0x1010(%rbp), %rdi
leaq -0x10b0(%rbp), %rsi
callq 0x2150
movl %eax, -0x1018(%rbp)
cmpl $-0x1, -0x1018(%rbp)
jne 0x2f8c
leaq -0x1010(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20a0
jmp 0x2fbd
movl -0x1098(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x2fbb
leaq -0x1010(%rbp), %rdi
callq 0x20b0
leaq -0x1010(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x20a0
jmp 0x2fbd
jmp 0x2fe1
movl -0xc(%rbp), %edi
leaq -0x1010(%rbp), %rsi
callq 0x4e10
movl %eax, -0x1018(%rbp)
cmpl $-0x1, -0x1018(%rbp)
jne 0x2fdf
jmp 0x2fe6
jmp 0x2fe1
jmp 0x2ea8
movl -0xc(%rbp), %edi
callq 0x22c0
movq -0x8(%rbp), %rdi
callq 0x21a0
xorl %eax, %eax
movl %eax, %edi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/gets.c
// Function: gets
int gets(int sock_fd,const char* file_name,const char* path,int file_id)
{
    int ctl_num = CTL_GET;
    send(sock_fd,&ctl_num,sizeof(int),0);
    char buf[4096];
    int file_name_len = strlen(file_name);
    int path_len = strlen(path);
    memcpy(buf ,&file_id,sizeof(int));
    memcpy(buf + sizeof(int),&file_name_len,sizeof(int));
    memcpy(buf + sizeof(int) * 2,&path_len,sizeof(int));
    memcpy(buf + sizeof(int) * 3,file_name,file_name_len);
    memcpy(buf + sizeof(int) * 3 + file_name_len,path,path_len);
    send(sock_fd,buf,sizeof(int) * 3 + file_name_len + path_len,0);

    pthread_t id;
    int * arg = (int*)malloc(sizeof(int));
    *arg = sock_fd;
    pthread_create(&id,NULL,pthread_download_file,arg);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1040, %rsp           # imm = 0x1040
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x5, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x1024(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2090
movl %eax, -0x1028(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x1020(%rbp)
movl -0x1024(%rbp), %eax
movl %eax, -0x101c(%rbp)
movl -0x1028(%rbp), %eax
movl %eax, -0x1018(%rbp)
leaq -0x1020(%rbp), %rdi
addq $0xc, %rdi
movq -0x10(%rbp), %rsi
movslq -0x1024(%rbp), %rdx
callq 0x2110
leaq -0x1020(%rbp), %rdi
addq $0xc, %rdi
movslq -0x1024(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x1028(%rbp), %rdx
callq 0x2110
movl -0x4(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movslq -0x1024(%rbp), %rdx
addq $0xc, %rdx
movslq -0x1028(%rbp), %rax
addq %rax, %rdx
xorl %ecx, %ecx
callq 0x20d0
movl $0x4, %edi
callq 0x21c0
movq %rax, -0x1038(%rbp)
movl -0x4(%rbp), %ecx
movq -0x1038(%rbp), %rax
movl %ecx, (%rax)
movq -0x1038(%rbp), %rcx
leaq -0x1030(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x27e(%rip), %rdx      # 0x2e90
callq 0x22b0
xorl %eax, %eax
addq $0x1040, %rsp           # imm = 0x1040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/link_path.c
// Function: link_path
void link_path(char* file_name)
{
    char tmp[256] = {0};
    strcpy(tmp,file_name);
    char* path = getcwd(NULL,0);
    sprintf(file_name,"%s/%s",path,tmp);
    free(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x20f0
leaq -0x110(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2160
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x20e0
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
movq -0x118(%rbp), %rdx
leaq -0x110(%rbp), %rcx
leaq 0x2f33(%rip), %rsi      # 0x60b1
movb $0x0, %al
callq 0x2060
movq -0x118(%rbp), %rdi
callq 0x21a0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/ls.c
// Function: ls
int ls(int sock_fd,int file_id)
{
    int ctl_num = CTL_LS;
    send(sock_fd,&ctl_num,sizeof(int),0);
    send(sock_fd,&file_id,sizeof(int),0);
    int len;
    char buf[4096];
    while(1)
    {
        memset(buf,0,sizeof(buf));
        recv(sock_fd,&len,sizeof(int),0);
        if(len == LS_FIN)
            break;
        recv_n_bytes(sock_fd,buf,len);
        char file_type = buf[0];
        int file_size = *(int*)(buf + 1);
        printf("%-32s",buf + 5);
        switch(file_type)
        {
        case 'd':
            printf("%-30s"," ");
            puts("directory");
            break;
        case 'f':
            printf("%20s%-10d"," ",file_size);
            puts("regular file");
            break;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20f0
movl -0x4(%rbp), %edi
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x2080
cmpl $0x0, -0x10(%rbp)
jne 0x33ff
jmp 0x34ae
movl -0x4(%rbp), %edi
movl -0x10(%rbp), %edx
leaq -0x1010(%rbp), %rsi
callq 0x4da0
movb -0x1010(%rbp), %al
movb %al, -0x1011(%rbp)
movl -0x100f(%rbp), %eax
movl %eax, -0x1018(%rbp)
leaq -0x100b(%rbp), %rsi
leaq 0x2cf7(%rip), %rdi      # 0x612e
xorl %eax, %eax
callq 0x2030
movsbl -0x1011(%rbp), %eax
movl %eax, -0x101c(%rbp)
subl $0x64, %eax
je 0x345f
jmp 0x3452
movl -0x101c(%rbp), %eax
subl $0x66, %eax
je 0x3482
jmp 0x34a9
leaq 0x2cce(%rip), %rdi      # 0x6134
leaq 0x2be7(%rip), %rsi      # 0x6054
movb $0x0, %al
callq 0x2030
leaq 0x2bf5(%rip), %rdi      # 0x6070
callq 0x2250
jmp 0x34a9
movl -0x1018(%rbp), %edx
leaq 0x2cab(%rip), %rdi      # 0x613a
leaq 0x2bbe(%rip), %rsi      # 0x6054
movb $0x0, %al
callq 0x2030
leaq 0x2ca0(%rip), %rdi      # 0x6144
callq 0x2250
jmp 0x33ce
xorl %eax, %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/md5.c
// Function: MD5Update
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
{
	unsigned int i = 0;
	unsigned int index = 0;
	unsigned int partlen = 0;

	index = (context->count[0] >> 3) & 0x3F;
	partlen = 64 - index;
	context->count[0] += inputlen << 3;

	if(context->count[0] < (inputlen << 3))
		context->count[1]++;
	context->count[1] += inputlen >> 29;

	if(inputlen >= partlen)
	{
		memcpy(&context->buffer[index], input,partlen);
		MD5Transform(context->state, context->buffer);

		for(i = partlen; i+64 <= inputlen; i+=64)
			MD5Transform(context->state, &input[i]);

		index = 0;        
	}  
	else
	{
		i = 0;
	}
	memcpy(&context->buffer[index], &input[i], inputlen-i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl $0x40, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
shll $0x3, %ecx
cmpl %ecx, %eax
jae 0x357d
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
shrl $0x1d, %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0x3602
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x2110
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x3640
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x40, %eax
cmpl -0x14(%rbp), %eax
ja 0x35f9
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0x3640
movl -0x18(%rbp), %eax
addl $0x40, %eax
movl %eax, -0x18(%rbp)
jmp 0x35cc
movl $0x0, -0x1c(%rbp)
jmp 0x3609
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/md5.c
// Function: MD5Final
void MD5Final(MD5_CTX *context, unsigned char digest[16])
{
	unsigned int index = 0,padlen = 0;
	unsigned char bits[8];

	index = (context->count[0] >> 3) & 0x3F;
	padlen = (index < 56)?(56-index):(120-index);
	MD5Encode(bits, context->count, 8);
	MD5Update(context, PADDING, padlen);
	MD5Update(context, bits, 8);
	MD5Encode(digest, context->state, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
cmpl $0x38, -0x14(%rbp)
jae 0x45a0
movl $0x38, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x45ab
movl $0x78, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x8, %edx
callq 0x4610
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x3baf(%rip), %rsi      # 0x8180
callq 0x3510
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x8, %edx
callq 0x3510
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl $0x10, %edx
callq 0x4610
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/md5.c
// Function: MD5Encode
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
	unsigned int i = 0;
	unsigned int j = 0;

	while(j < len)
	{
		output[j] = input[i] & 0xFF;  
		output[j+1] = (input[i] >> 8) & 0xFF;
		output[j+2] = (input[i] >> 16) & 0xFF;
		output[j+3] = (input[i] >> 24) & 0xFF;
		i++;
		j += 4;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x46d4
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x462d
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/md5.c
// Function: MD5Decode
void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
{
	unsigned int i = 0;
	unsigned int j = 0;

	while(j < len)
	{
		output[i] = (input[j]) |
			(input[j+1] << 8) |
			(input[j+2] << 16) |
			(input[j+3] << 24);
		i++;
		j += 4; 
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x476d
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x10, %eax
orl %eax, %edx
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
shll $0x18, %eax
orl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0x46fd
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/my_mkdir.c
// Function: my_mkdir
int my_mkdir(int sock_fd,int file_id,int user_id,const char* file_name)
{
    int ctl_num = CTL_MKDIR;
    send(sock_fd,&ctl_num,sizeof(int),0);
    send(sock_fd,&file_id,sizeof(int),0);
    send(sock_fd,&user_id,sizeof(int),0);
    int len = strlen(file_name);
    send(sock_fd,&len,sizeof(int),0);
    send(sock_fd,file_name,len,0);
    recv(sock_fd,&ctl_num,sizeof(int),0);
    if(ctl_num == FILE_NAME_AVAIABLE)
    {
        puts("mkdir success!");
    }
    else
    {
        puts("mkdir fail!");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x7, -0x1c(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x4(%rbp), %edi
leaq -0x8(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x4(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movq -0x18(%rbp), %rdi
callq 0x2090
movl %eax, -0x20(%rbp)
movl -0x4(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
xorl %ecx, %ecx
callq 0x20d0
movl -0x4(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x2080
cmpl $0x1, -0x1c(%rbp)
jne 0x481d
leaq 0x193b(%rip), %rdi      # 0x6151
callq 0x2250
jmp 0x4829
leaq 0x193c(%rip), %rdi      # 0x6160
callq 0x2250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/put.c
// Function: pthread_upload_func
void* pthread_upload_func(void* arg)
{
    int sock_fd = *(int*)arg;
    int parent_id = *((int*)arg + 1);
    char* path = (char*)arg + sizeof(int) * 2;
    upload(sock_fd,path,parent_id);
    int ctl_num = NO_MORE_FILE;
    send(sock_fd,&ctl_num,sizeof(int),0);
    free(arg);
    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movl -0x10(%rbp), %edx
callq 0x52f0
movl $0x3, -0x1c(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movq -0x8(%rbp), %rdi
callq 0x21a0
xorl %eax, %eax
movl %eax, %edi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/put.c
// Function: put
int put(int sock_fd,char* path,int user_id,int file_id)
{
    
    char file_name[128] = {0};
    get_file_name(file_name,path);
    int ctl_num = CTL_PUT;
    send(sock_fd,&ctl_num,sizeof(int),0);
    int len = strlen(file_name);
    send(sock_fd,&user_id,sizeof(int),0);
    send(sock_fd,&file_id,sizeof(int),0);
    send(sock_fd,&len,sizeof(int),0);
    send(sock_fd,file_name,len,0);
    recv(sock_fd,&ctl_num,sizeof(int),0);
    if(ctl_num == PUT_FAIL)
    {
        puts("在当前目录有同名文件，不可上传");
        close(sock_fd);
        return -1;
    }
    char* buf = (char*)malloc(4096);
    memset(buf,0,4096);
    memcpy(buf,&sock_fd,sizeof(int));
    memcpy(buf + sizeof(int),&file_id,sizeof(int));
    strcpy(buf + sizeof(int) * 2,path);
    pthread_t id;
    pthread_create(&id,NULL,pthread_upload_func,(void*)buf);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x20f0
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e30
movl $0x4, -0xa4(%rbp)
movl -0x8(%rbp), %edi
leaq -0xa4(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
leaq -0xa0(%rbp), %rdi
callq 0x2090
movl %eax, -0xa8(%rbp)
movl -0x8(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x8(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x8(%rbp), %edi
leaq -0xa8(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20d0
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
movslq -0xa8(%rbp), %rdx
xorl %ecx, %ecx
callq 0x20d0
movl -0x8(%rbp), %edi
leaq -0xa4(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x2080
cmpl $0x0, -0xa4(%rbp)
jne 0x49ad
leaq 0x17d5(%rip), %rdi      # 0x616c
callq 0x2250
movl -0x8(%rbp), %edi
callq 0x22c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a23
movl $0x1000, %edi           # imm = 0x1000
callq 0x21c0
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20f0
movq -0xb0(%rbp), %rax
movl -0x8(%rbp), %ecx
movl %ecx, (%rax)
movq -0xb0(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x2160
movq -0xb0(%rbp), %rcx
leaq -0xb8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x1d7(%rip), %rdx      # 0x4840
callq 0x22b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/recv_client_all.c
// Function: recv_client_all
int recv_client_all(int fd,void* buf,int len)
{
    int total = 0;
    int ret;
    while(total < len)
    {
        ret = recv(fd,(char*)buf + total,len - total,MSG_WAITALL);
        if(ret == 0)
        {
            return -1;
        }
        total += ret;
    }
    return 0;
}

// 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
cmpl -0x14(%rbp), %eax
jge 0x4a8f
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x2080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4a84
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4a96
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x4a49
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/recv_file.c
// Function: recv_file
int recv_file(int sock_fd,int file_fd, int file_size)
{
    int total = 0;
    int pipefd[2];
    int ret = pipe(pipefd);
    ERROR_CHECK(ret,-1,"pipe");
    int download_size = 0;
    int splice_size = file_size/10000;
    int previous_download_size = 0;
    while(total < file_size)
    {
        ret = splice(sock_fd,NULL,pipefd[1],NULL,4096,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        ret = splice(pipefd[0],NULL,file_fd,NULL,ret,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        total += ret;
        download_size += ret;
        if(download_size - previous_download_size >= splice_size)
        {
            printf("downloading %.2f\r",(double)download_size/file_size * 100);
            fflush(stdout);
            previous_download_size = download_size;
        }
    }
    printf("downloading %.2f\n",(double)download_size/file_size * 100);
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x21d0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x4ae2
leaq 0x16d7(%rip), %rdi      # 0x61a8
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c14
movl $0x0, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4be5
movl -0x8(%rbp), %edi
movl -0x18(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x1000, %r8d           # imm = 0x1000
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20c0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x4b49
leaq 0x1675(%rip), %rdi      # 0x61ad
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c14
movl -0x1c(%rbp), %edi
movl -0xc(%rbp), %edx
movslq -0x20(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20c0
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0x4b86
leaq 0x1638(%rip), %rdi      # 0x61ad
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4c14
movl -0x20(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
subl -0x2c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x4be0
cvtsi2sdl -0x24(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x15e7(%rip), %xmm1     # 0x61a0
mulsd %xmm1, %xmm0
leaq 0x15f0(%rip), %rdi      # 0x61b4
movb $0x1, %al
callq 0x2030
movq 0x33ee(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x2190
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4afe
cvtsi2sdl -0x24(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x15a5(%rip), %xmm1     # 0x61a0
mulsd %xmm1, %xmm0
leaq 0x15c0(%rip), %rdi      # 0x61c6
movb $0x1, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/clientSrc/recv_file_from_offset.c
// Function: recv_file_from_offset
int recv_file_from_offset(int sock_fd,int file_fd, int file_size,int offset)
{
    int total = offset;
    int pipefd[2];
    int ret = pipe(pipefd);
    ERROR_CHECK(ret,-1,"pipe");
    int download_size = 0;
    int splice_size = file_size/10000;
    int previous_download_size = 0;
    while(total < file_size)
    {
        ret = splice(sock_fd,NULL,pipefd[1],NULL,4096,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        ret = splice(pipefd[0],NULL,file_fd,NULL,ret,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        total += ret;
        download_size += ret;
        if(download_size - previous_download_size >= splice_size)
        {
            printf("downloading %.2f\r",(double)download_size/file_size * 100);
            fflush(stdout);
            previous_download_size = download_size;
        }
    }
    printf("downloading %.2f\n",(double)download_size/file_size * 100);
    return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x21d0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x4c64
leaq 0x1555(%rip), %rdi      # 0x61a8
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d96
movl $0x0, -0x28(%rbp)
movl -0x10(%rbp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4d67
movl -0x8(%rbp), %edi
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x1000, %r8d           # imm = 0x1000
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x4ccb
leaq 0x14f3(%rip), %rdi      # 0x61ad
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d96
movl -0x20(%rbp), %edi
movl -0xc(%rbp), %edx
movslq -0x24(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20c0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x4d08
leaq 0x14b6(%rip), %rdi      # 0x61ad
callq 0x2130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d96
movl -0x24(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
subl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jl 0x4d62
cvtsi2sdl -0x28(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1465(%rip), %xmm1     # 0x61a0
mulsd %xmm1, %xmm0
leaq 0x146e(%rip), %rdi      # 0x61b4
movb $0x1, %al
callq 0x2030
movq 0x326c(%rip), %rax      # 0x7fc0
movq (%rax), %rdi
callq 0x2190
movl -0x28(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x4c80
cvtsi2sdl -0x28(%rbp), %xmm0
cvtsi2sdl -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x1423(%rip), %xmm1     # 0x61a0
mulsd %xmm1, %xmm0
leaq 0x143e(%rip), %rdi      # 0x61c6
movb $0x1, %al
callq 0x2030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop