LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: x0213_combining_p
static int
x0213_combining_p(nkf_char wc)
{
    int i;
    for (i = 0; i < sizeof_x0213_combining_chars; i++) {
	if (x0213_combining_chars[i] == wc) {
	    return TRUE;
	}
    }
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x1ab6e
movslq -0xc(%rbp), %rcx
leaq 0xc79d(%rip), %rax      # 0x272ec
movzwl (%rax,%rcx,2), %eax
cmpl -0x8(%rbp), %eax
jne 0x1ab61
movl $0x1, -0x4(%rbp)
jmp 0x1ab75
jmp 0x1ab63
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ab3e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: push_hold_buf
static nkf_char
push_hold_buf(nkf_char c2)
{
    if (hold_count >= HOLD_SIZE*2)
	return (EOF);
    hold_buf[hold_count++] = c2;
    return ((hold_count >= HOLD_SIZE*2) ? EOF : hold_count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x800, 0x3fa6b(%rip)   # imm = 0x800
jl 0x1ab9c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1abe2
movl -0x8(%rbp), %edx
movl 0x3fa57(%rip), %eax     # 0x5a5fc
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x3fa4c(%rip)     # 0x5a5fc
movslq %eax, %rcx
leaq 0x3fed6(%rip), %rax     # 0x5aa90
movl %edx, (%rax,%rcx,4)
cmpl $0x800, 0x3fa35(%rip)   # imm = 0x800
jl 0x1abd3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x1abdc
movl 0x3fa23(%rip), %eax     # 0x5a5fc
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: switch_mime_getc
static void
switch_mime_getc(void)
{
    if (i_getc!=mime_getc) {
	i_mgetc = i_getc; i_getc = mime_getc;
	i_mungetc = i_ungetc; i_ungetc = mime_ungetc;
	if(mime_f==STRICT_MIME) {
	    i_mgetc_buf = i_mgetc; i_mgetc = mime_getc_buf;
	    i_mungetc_buf = i_mungetc; i_mungetc = mime_ungetc_buf;
	}
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq -0x35fb(%rip), %rax     # 0x17800
cmpq %rax, 0x37506(%rip)     # 0x52308
je 0x1ae7f
movq 0x374fd(%rip), %rax     # 0x52308
movq %rax, 0x3751e(%rip)     # 0x52330
leaq -0x3619(%rip), %rax     # 0x17800
movq %rax, 0x374e8(%rip)     # 0x52308
movq 0x374e9(%rip), %rax     # 0x52310
movq %rax, 0x3750a(%rip)     # 0x52338
leaq -0x2bb5(%rip), %rax     # 0x18280
movq %rax, 0x374d4(%rip)     # 0x52310
cmpl $0x8, 0x3743d(%rip)     # 0x52280
jne 0x1ae7d
movq 0x374e4(%rip), %rax     # 0x52330
movq %rax, 0x374ed(%rip)     # 0x52340
leaq 0x36(%rip), %rax        # 0x1ae90
movq %rax, 0x374cf(%rip)     # 0x52330
movq 0x374d0(%rip), %rax     # 0x52338
movq %rax, 0x374d9(%rip)     # 0x52348
leaq 0x7a(%rip), %rax        # 0x1aef0
movq %rax, 0x374bb(%rip)     # 0x52338
jmp 0x1ae7f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: mime_getc_buf
static nkf_char
mime_getc_buf(FILE *f)
{
    /* we don't keep eof of mime_input_buf, because it contains ?= as
       a terminator. It was checked in mime_integrity. */
    return ((mimebuf_f)?
	    (*i_mgetc_buf)(f):mime_input_buf(mime_input_state.input++));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x3f741(%rip)     # 0x5a5e4
je 0x1aeb7
movq 0x37494(%rip), %rax     # 0x52340
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, -0xc(%rbp)
jmp 0x1aedf
movl 0x3fbb7(%rip), %eax     # 0x5aa74
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x3fbac(%rip)     # 0x5aa74
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, %eax
movl %eax, %ecx
leaq 0x3f794(%rip), %rax     # 0x5a66c
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: mime_ungetc_buf
static nkf_char
mime_ungetc_buf(nkf_char c, FILE *f)
{
    if (mimebuf_f)
	(*i_mungetc_buf)(c,f);
    else
	mime_input_buf(--mime_input_state.input) = (unsigned char)c;
    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x3f6de(%rip)     # 0x5a5e4
je 0x1af1a
movq 0x37439(%rip), %rax     # 0x52348
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
jmp 0x1af41
movl -0x4(%rbp), %eax
movb %al, %dl
movl 0x3fb4f(%rip), %eax     # 0x5aa74
addl $-0x1, %eax
movl %eax, 0x3fb46(%rip)     # 0x5aa74
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, %eax
movl %eax, %ecx
leaq 0x3f72e(%rip), %rax     # 0x5a66c
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nurse[P]nkf/nkf.c
// Function: get_guessed_code
static const char*
get_guessed_code(void)
{
    if (input_codename && !*input_codename) {
	input_codename = "BINARY";
    } else {
	struct input_code *p = find_inputcode_byfunc(iconv);
	if (!input_codename) {
	    input_codename = "ASCII";
	} else if (strcmp(input_codename, "Shift_JIS") == 0) {
	    if (p->score & (SCORE_DEPEND|SCORE_CP932))
		input_codename = "CP932";
	} else if (strcmp(input_codename, "EUC-JP") == 0) {
	    if (p->score & SCORE_X0213)
		input_codename = "EUC-JIS-2004";
	    else if (p->score & (SCORE_X0212))
		input_codename = "EUCJP-MS";
	    else if (p->score & (SCORE_DEPEND|SCORE_CP932))
		input_codename = "CP51932";
	} else if (strcmp(input_codename, "ISO-2022-JP") == 0) {
	    if (p->score & (SCORE_KANA))
		input_codename = "CP50221";
	    else if (p->score & (SCORE_DEPEND|SCORE_CP932))
		input_codename = "CP50220";
	}
    }
    return input_codename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x3f4d8(%rip)     # 0x5a438
je 0x1af81
movq 0x3f4cf(%rip), %rax     # 0x5a438
cmpb $0x0, (%rax)
jne 0x1af81
leaq 0x1fc6(%rip), %rax      # 0x1cf3b
movq %rax, 0x3f4bc(%rip)     # 0x5a438
jmp 0x1b0c1
movq 0x37330(%rip), %rdi     # 0x522b8
callq 0x13660
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x3f49f(%rip)     # 0x5a438
jne 0x1afae
leaq 0x28cf(%rip), %rax      # 0x1d871
movq %rax, 0x3f48f(%rip)     # 0x5a438
jmp 0x1b0bf
movq 0x3f483(%rip), %rdi     # 0x5a438
leaq 0x1e1c(%rip), %rsi      # 0x1cdd8
callq 0xc120
cmpl $0x0, %eax
jne 0x1afe8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x1afe3
leaq 0x2816(%rip), %rax      # 0x1d7f2
movq %rax, 0x3f455(%rip)     # 0x5a438
jmp 0x1b0bd
movq 0x3f449(%rip), %rdi     # 0x5a438
leaq 0x1dec(%rip), %rsi      # 0x1cde2
callq 0xc120
cmpl $0x0, %eax
jne 0x1b061
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1b01f
leaq 0x1ea6(%rip), %rax      # 0x1cebc
movq %rax, 0x3f41b(%rip)     # 0x5a438
jmp 0x1b05f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1b03e
leaq 0x2824(%rip), %rax      # 0x1d859
movq %rax, 0x3f3fc(%rip)     # 0x5a438
jmp 0x1b05d
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x1b05b
leaq 0x1e20(%rip), %rax      # 0x1ce74
movq %rax, 0x3f3dd(%rip)     # 0x5a438
jmp 0x1b05d
jmp 0x1b05f
jmp 0x1b0bb
movq 0x3f3d0(%rip), %rdi     # 0x5a438
leaq 0x1d5d(%rip), %rsi      # 0x1cdcc
callq 0xc120
cmpl $0x0, %eax
jne 0x1b0b9
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1b098
leaq 0x1d8a(%rip), %rax      # 0x1ce19
movq %rax, 0x3f3a2(%rip)     # 0x5a438
jmp 0x1b0b7
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x1b0b5
leaq 0x1d63(%rip), %rax      # 0x1ce11
movq %rax, 0x3f383(%rip)     # 0x5a438
jmp 0x1b0b7
jmp 0x1b0b9
jmp 0x1b0bb
jmp 0x1b0bd
jmp 0x1b0bf
jmp 0x1b0c1
movq 0x3f370(%rip), %rax     # 0x5a438
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones_scroll.c
// Function: SayUsage
void SayUsage (char *programName) {
   static char *usage[] = {
      "Display a MIDITONES bytestream",
      "Usage: miditones_scroll <basefilename>",
      "   reads <basefilename>.bin",
      " -tn displays up to n tone generators",
      " -v expects and displays volume information",
      " -vi expects and ignores volume information",
      " -c  creates an annotated C source file as <basefile>.c",
      " -x  show notes in hex instead of octave/note",
      " -n  don't show the bytestream data",
      "" };
   int i = 0;
   while (usage[i][0] != '\0')
      fprintf (stderr, "%s\n", usage[i++]); }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rcx
leaq 0x4e83(%rip), %rax      # 0x80b0
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x326e
movq 0x4db8(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rsp)
movslq %eax, %rcx
leaq 0x4e56(%rip), %rax      # 0x80b0
movq (%rax,%rcx,8), %rdx
leaq 0x1fc5(%rip), %rsi      # 0x522a
movb $0x0, %al
callq 0x3090
jmp 0x3221
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones_scroll.c
// Function: strlcpy
unsigned int strlcpy (char *dst, const char *src, unsigned int siz) {
   char *d = dst;
   const char *s = src;
   unsigned int n = siz;
   if (n != 0) {  /* Copy as many bytes as will fit */
      while (--n != 0) {
         if ((*d++ = *s++) == '\0')
            break; } }
   /* Not enough room in dst, add NUL and traverse rest of src */
   if (n == 0) {
      if (siz != 0)
         *d = '\0';             /* NUL-terminate dst */
      while (*s++); }
   return (s - src - 1);        /* count does not include NUL */
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, -0x2c(%rsp)
je 0x3507
jmp 0x34c3
movl -0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, %eax
je 0x3505
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
movb (%rax), %al
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x3503
jmp 0x3505
jmp 0x34c3
jmp 0x3507
cmpl $0x0, -0x2c(%rsp)
jne 0x3539
cmpl $0x0, -0x14(%rsp)
je 0x351d
movq -0x20(%rsp), %rax
movb $0x0, (%rax)
jmp 0x351f
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
cmpb $0x0, (%rax)
je 0x3537
jmp 0x351f
jmp 0x3539
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
subq %rcx, %rax
subq $0x1, %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones_scroll.c
// Function: strlcat
unsigned int strlcat (char *dst, const char *src, unsigned int siz) {
   char *d = dst;
   const char *s = src;
   unsigned int n = siz;
   unsigned int dlen;
   /* Find the end of dst and adjust bytes left but don't go past end */
   while (n-- != 0 && *d != '\0') d++;
   dlen = d - dst;
   n = siz - dlen;
   if (n == 0) return (dlen + strlength (s));
   while (*s != '\0') {
      if (n != 1) {
         *d++ = *s;
         n--; }
      s++; }
   *d = '\0';
   return (dlen + (s - src));   /* count does not include NUL */
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x35a8
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x35b2
jmp 0x35c2
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x357e
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
subl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x3606
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3450
movl %eax, %ecx
movl 0x8(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x44(%rsp)
jmp 0x3671
jmp 0x3608
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x3651
cmpl $0x1, 0x14(%rsp)
je 0x3641
movq 0x18(%rsp), %rax
movb (%rax), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3608
movq 0x20(%rsp), %rax
movb $0x0, (%rax)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones_scroll.c
// Function: file_error
void file_error (char *msg, unsigned char *bufptr) {
   unsigned char *ptr;
   fprintf (outfile, "\n---> file format error at position %04X (%d), time %d.%03d: %s\n",
            (unsigned int) (bufptr - buffer), (unsigned int) (bufptr - buffer), timenow / 1000, timenow % 1000, msg);
   /* print some bytes surrounding the error */
   ptr = bufptr - 16;
   if (ptr < buffer) ptr = buffer;
   for (; ptr <= bufptr + 16 && ptr < buffer + buflen; ++ptr)
      fprintf (outfile, ptr == bufptr ? " [%02X]  " : "%02X ", *ptr);
   fprintf (outfile, "\n"); }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x58ab(%rip), %rdi      # 0x8f40
movq 0x18(%rsp), %rax
movq 0x58a7(%rip), %rcx      # 0x8f48
subq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x5894(%rip), %rcx      # 0x8f48
subq %rcx, %rax
movl %eax, %ecx
movq 0x5668(%rip), %rax      # 0x8d28
movl $0x3e8, %esi            # imm = 0x3E8
xorl %edx, %edx
divq %rsi
movq %rax, %r8
movq 0x5654(%rip), %rax      # 0x8d28
movl $0x3e8, %esi            # imm = 0x3E8
xorl %edx, %edx
divq %rsi
movq %rdx, %r9
movl 0xc(%rsp), %edx
movq 0x20(%rsp), %rax
leaq 0x1afc(%rip), %rsi      # 0x51ed
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3090
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x5832(%rip), %rax      # 0x8f48
jae 0x3724
movq 0x5829(%rip), %rax      # 0x8f48
movq %rax, 0x10(%rsp)
jmp 0x3726
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xb(%rsp)
ja 0x375c
movq 0x10(%rsp), %rax
movq 0x57fd(%rip), %rcx      # 0x8f48
addq 0x57fe(%rip), %rcx      # 0x8f50
cmpq %rcx, %rax
setb %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x3766
jmp 0x37ae
movq 0x57d3(%rip), %rdi      # 0x8f40
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
leaq 0x1ada(%rip), %rsi      # 0x5258
leaq 0x1aa9(%rip), %rax      # 0x522e
cmpq %rdx, %rcx
cmoveq %rax, %rsi
movq 0x10(%rsp), %rax
movzbl (%rax), %edx
movb $0x0, %al
callq 0x3090
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3726
movq 0x578b(%rip), %rdi      # 0x8f40
leaq 0x1dd9(%rip), %rsi      # 0x5595
movb $0x0, %al
callq 0x3090
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones_scroll.c
// Function: countbits
int countbits (unsigned int bitmap) {
   int count;
   for (count = 0; bitmap; bitmap >>= 1)
      count += bitmap & 1;
   return count; }

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x0, -0x4(%rsp)
je 0x3c4e
movl -0x4(%rsp), %eax
andl $0x1, %eax
addl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
jmp 0x3c2c
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetNonBlock
int anetNonBlock(char *err, int fd)
{
    int flags;

    /* Set the socket nonblocking.
     * Note that fcntl(2) for F_GETFL and F_SETFL can't be
     * interrupted by a signal. */
    if ((flags = fcntl(fd, F_GETFL)) == -1) {
        anetSetError(err, "fcntl(F_GETFL): %s", strerror(errno));
        return ANET_ERR;
    }
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        anetSetError(err, "fcntl(F_SETFL,O_NONBLOCK): %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x4310
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x5e38
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xc1e2(%rip), %rsi      # 0x1200a
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e8e
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x4310
cmpl $-0x1, %eax
jne 0x5e87
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xc1a6(%rip), %rsi      # 0x1201d
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e8e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetTcpNoDelay
int anetTcpNoDelay(char *err, int fd)
{
    int yes = 1;
    if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &yes, sizeof(yes)) == -1)
    {
        anetSetError(err, "setsockopt TCP_NODELAY: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0x40c0
cmpl $-0x1, %eax
jne 0x5fb9
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0xc092(%rip), %rsi      # 0x1203b
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5fc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetResolve
int anetResolve(char *err, char *host, char *ipbuf)
{
    struct sockaddr_in sa;

    sa.sin_family = AF_INET;
    if (inet_aton(host, &sa.sin_addr) == 0) {
        struct hostent *he;

        he = gethostbyname(host);
        if (he == NULL) {
            anetSetError(err, "can't resolve: %s", host);
            return ANET_ERR;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
    strcpy(ipbuf,inet_ntoa(sa.sin_addr));
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movw $0x2, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0x4250
cmpl $0x0, %eax
jne 0x6143
movq -0x18(%rbp), %rdi
callq 0x4210
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6133
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xbf68(%rip), %rsi      # 0x1208b
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6166
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %edi
callq 0x40f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetTcpGenericConnect
static int anetTcpGenericConnect(char *err, char *addr, int port, int flags)
{
    int s;
    struct sockaddr_in sa;

    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
        return ANET_ERR;

    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
    if (inet_aton(addr, &sa.sin_addr) == 0) {
        struct hostent *he;

        he = gethostbyname(addr);
        if (he == NULL) {
            anetSetError(err, "can't resolve: %s", addr);
            close(s);
            return ANET_ERR;
        }
        memcpy(&sa.sin_addr, he->h_addr, sizeof(struct in_addr));
    }
    if (flags & ANET_CONNECT_NONBLOCK) {
        if (anetNonBlock(err,s) != ANET_OK)
            return ANET_ERR;
    }
    if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1) {
        if (errno == EINPROGRESS &&
            flags & ANET_CONNECT_NONBLOCK)
            return s;

        anetSetError(err, "connect: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6450
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x61d8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f3
movw $0x2, -0x34(%rbp)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x4130
movw %ax, -0x32(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
addq $0x4, %rsi
callq 0x4250
cmpl $0x0, %eax
jne 0x6251
movq -0x18(%rbp), %rdi
callq 0x4210
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x6241
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0xbe65(%rip), %rsi      # 0x1208b
movb $0x0, %al
callq 0x5ea0
movl -0x24(%rbp), %edi
callq 0x41b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f3
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6278
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x5de0
cmpl $0x0, %eax
je 0x6276
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f3
jmp 0x6278
movl -0x24(%rbp), %edi
leaq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
movl $0x10, %edx
callq 0x4390
cmpl $-0x1, %eax
jne 0x62ed
callq 0x4060
cmpl $0x73, (%rax)
jne 0x62b3
movl -0x20(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x62b3
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x62f3
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x50(%rbp), %rdi
movq %rax, %rdx
leaq 0xbdc8(%rip), %rsi      # 0x1209d
movb $0x0, %al
callq 0x5ea0
movl -0x24(%rbp), %edi
callq 0x41b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x62f3
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetCreateSocket
static int anetCreateSocket(char *err, int domain) {
    int s, on = 1;
    if ((s = socket(domain, SOCK_STREAM, 0)) == -1) {
        anetSetError(err, "creating socket: %s", strerror(errno));
        return ANET_ERR;
    }

    /* Make sure connection-intensive things like the redis benckmark
     * will be able to close/open sockets a zillion of times */
    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) {
        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
        return ANET_ERR;
    }
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x43e0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x64af
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0xbc1f(%rip), %rsi      # 0x120be
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6508
movl -0x18(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x1c(%rbp), %rcx
movl $0x4, %r8d
callq 0x40c0
cmpl $-0x1, %eax
jne 0x6502
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xbbe0(%rip), %rsi      # 0x120d2
movb $0x0, %al
callq 0x5ea0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6508
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetTcpServer
int anetTcpServer(char *err, int port, char *bindaddr)
{
    int s;
    struct sockaddr_in sa;

    if ((s = anetCreateSocket(err,AF_INET)) == ANET_ERR)
        return ANET_ERR;

    memset(&sa,0,sizeof(sa));
    sa.sin_family = AF_INET;
    sa.sin_port = htons(port);
    sa.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bindaddr && inet_aton(bindaddr, &sa.sin_addr) == 0) {
        anetSetError(err, "invalid bind address");
        close(s);
        return ANET_ERR;
    }
    if (anetListen(err,s,(struct sockaddr*)&sa,sizeof(sa)) == ANET_ERR)
        return ANET_ERR;
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x6450
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x66d5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
leaq -0x34(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x41a0
movw $0x2, -0x34(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x4130
movw %ax, -0x32(%rbp)
xorl %edi, %edi
callq 0x4190
movl %eax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6744
movq -0x20(%rbp), %rdi
leaq -0x34(%rbp), %rsi
addq $0x4, %rsi
callq 0x4250
cmpl $0x0, %eax
jne 0x6744
movq -0x10(%rbp), %rdi
leaq 0xb97d(%rip), %rsi      # 0x120a9
movb $0x0, %al
callq 0x5ea0
movl -0x24(%rbp), %edi
callq 0x41b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x34(%rbp), %rdx
movl $0x10, %ecx
callq 0x6780
cmpl $-0x1, %eax
jne 0x6767
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x676d
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetListen
static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len) {
    if (bind(s,sa,len) == -1) {
        anetSetError(err, "bind: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }

    /* Use a backlog of 512 entries. We pass 511 to the listen() call because
     * the kernel does: backlogsize = roundup_pow_of_two(backlogsize + 1);
     * which will thus give us a backlog of 512 entries */
    if (listen(s, 511) == -1) {
        anetSetError(err, "listen: %s", strerror(errno));
        close(s);
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rsi
callq 0x4300
cmpl $-0x1, %eax
jne 0x67ec
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xb91a(%rip), %rsi      # 0x120ee
movb $0x0, %al
callq 0x5ea0
movl -0x14(%rbp), %edi
callq 0x41b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x683f
movl -0x14(%rbp), %edi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x42a0
cmpl $-0x1, %eax
jne 0x6838
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x4060
movl (%rax), %edi
callq 0x43b0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xb8d7(%rip), %rsi      # 0x120f7
movb $0x0, %al
callq 0x5ea0
movl -0x14(%rbp), %edi
callq 0x41b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x683f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetTcpAccept
int anetTcpAccept(char *err, int s, char *ip, int *port) {
    int fd;
    struct sockaddr_in sa;
    socklen_t salen = sizeof(sa);
    if ((fd = anetGenericAccept(err,s,(struct sockaddr*)&sa,&salen)) == ANET_ERR)
        return ANET_ERR;

    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
    if (port) *port = ntohs(sa.sin_port);
    return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x10, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x3c(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x69a0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
jne 0x6953
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6995
cmpq $0x0, -0x20(%rbp)
je 0x6976
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x38(%rbp), %edi
callq 0x40f0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4080
cmpq $0x0, -0x28(%rbp)
je 0x698f
movzwl -0x3a(%rbp), %edi
callq 0x42c0
movzwl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetPeerToString
int anetPeerToString(int fd, char *ip, int *port) {
    struct sockaddr_in sa;
    socklen_t salen = sizeof(sa);

    if (getpeername(fd,(struct sockaddr*)&sa,&salen) == -1) {
        *port = 0;
        ip[0] = '?';
        ip[1] = '\0';
        return -1;
    }
    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
    if (port) *port = ntohs(sa.sin_port);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, -0x2c(%rbp)
movl -0x8(%rbp), %edi
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x4100
cmpl $-0x1, %eax
jne 0x6ae9
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x3f, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6b2c
cmpq $0x0, -0x10(%rbp)
je 0x6b0c
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
callq 0x40f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4080
cmpq $0x0, -0x18(%rbp)
je 0x6b25
movzwl -0x26(%rbp), %edi
callq 0x42c0
movzwl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/anet.c
// Function: anetSockName
int anetSockName(int fd, char *ip, int *port) {
    struct sockaddr_in sa;
    socklen_t salen = sizeof(sa);

    if (getsockname(fd,(struct sockaddr*)&sa,&salen) == -1) {
        *port = 0;
        ip[0] = '?';
        ip[1] = '\0';
        return -1;
    }
    if (ip) strcpy(ip,inet_ntoa(sa.sin_addr));
    if (port) *port = ntohs(sa.sin_port);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x10, -0x2c(%rbp)
movl -0x8(%rbp), %edi
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
callq 0x4370
cmpl $-0x1, %eax
jne 0x6b99
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movb $0x3f, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6bdc
cmpq $0x0, -0x10(%rbp)
je 0x6bbc
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %edi
callq 0x40f0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4080
cmpq $0x0, -0x18(%rbp)
je 0x6bd5
movzwl -0x26(%rbp), %edi
callq 0x42c0
movzwl %ax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictGenHashFunction
unsigned int dictGenHashFunction(const unsigned char *buf, int len) {
    unsigned int hash = dict_hash_function_seed;

    while (len--)
        hash = ((hash << 5) + hash) + (*buf++); /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x104f7(%rip), %eax     # 0x17208
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x6d46
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x6d14
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictGenCaseHashFunction
unsigned int dictGenCaseHashFunction(const unsigned char *buf, int len) {
    unsigned int hash = dict_hash_function_seed;

    while (len--)
        hash = ((hash << 5) + hash) + (tolower(*buf++)); /* hash * 33 + c */
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x104a3(%rip), %eax     # 0x17208
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x6da7
movl -0x10(%rbp), %eax
shll $0x5, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %edi
callq 0x4270
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x6d68
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictAddRaw
dictEntry *dictAddRaw(dict *d, void *key)
{
    int index;
    dictEntry *entry;
    dictht *ht;

    if (dictIsRehashing(d)) _dictRehashStep(d);

    /* Get the index of the new element, or -1 if
     * the element already exists. */
    if ((index = _dictKeyIndex(d, key)) == -1)
        return NULL;

    /* Allocate the memory and store the new entry */
    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];
    entry = zmalloc(sizeof(*entry));
    entry->next = ht->table[index];
    ht->table[index] = entry;
    ht->used++;

    /* Set the hash entry fields. */
    dictSetKey(d, entry, key);
    return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x7383
movq -0x10(%rbp), %rdi
callq 0x7470
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x74a0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
jne 0x73a5
movq $0x0, -0x8(%rbp)
jmp 0x7465
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x73c1
movq -0x10(%rbp), %rax
addq $0x10, %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
jmp 0x73cd
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x18, %edi
callq 0x10ce0
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x7450
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x745b
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x745d
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictFind
dictEntry *dictFind(dict *d, const void *key)
{
    dictEntry *he;
    unsigned int h, idx, table;

    if (d->ht[0].size == 0) return NULL; /* We don't have a table at all */
    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);
    for (table = 0; table <= 1; table++) {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        while(he) {
            if (dictCompareKeys(d, key, he->key))
                return he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) return NULL;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x76c8
movq $0x0, -0x8(%rbp)
jmp 0x77c8
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x76db
movq -0x10(%rbp), %rdi
callq 0x7470
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
ja 0x77c0
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movl -0x2c(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
andq 0x10(%rcx), %rax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movl -0x2c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x779c
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x7777
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
jne 0x7784
jmp 0x778e
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x778e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x77c8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x773b
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
jne 0x77b0
movq $0x0, -0x8(%rbp)
jmp 0x77c8
jmp 0x77b2
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x76f5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictClear
int _dictClear(dict *d, dictht *ht)
{
    unsigned long i;

    /* Free all the elements */
    for (i = 0; i < ht->size && ht->used > 0; i++) {
        dictEntry *he, *nextHe;

        if ((he = ht->table[i]) == NULL) continue;
        while(he) {
            nextHe = he->next;
            dictFreeKey(d, he);
            dictFreeVal(d, he);
            zfree(he);
            ht->used--;
            he = nextHe;
        }
    }
    /* Free the table and the allocated cache structure */
    zfree(ht->table);
    /* Re-initialize the table */
    _dictReset(ht);
    return DICT_OK; /* never fails */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x29(%rbp)
jae 0x7ada
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x7ae6
jmp 0x7bab
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x7b04
jmp 0x7b9a
jmp 0x7b06
cmpq $0x0, -0x20(%rbp)
je 0x7b98
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x7b47
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x7b72
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x10fe0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x7b06
jmp 0x7b9a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7ab8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x10fe0
movq -0x10(%rbp), %rdi
callq 0x71f0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictNext
dictEntry *dictNext(dictIterator *iter)
{
    while (1) {
        if (iter->entry == NULL) {
            dictht *ht = &iter->d->ht[iter->table];
            if (iter->safe && iter->index == -1 && iter->table == 0)
                iter->d->iterators++;
            iter->index++;
            if (iter->index >= (signed) ht->size) {
                if (dictIsRehashing(iter->d) && iter->table == 0) {
                    iter->table++;
                    iter->index = 0;
                    ht = &iter->d->ht[1];
                } else {
                    break;
                }
            }
            iter->entry = ht->table[iter->index];
        } else {
            iter->entry = iter->nextEntry;
        }
        if (iter->entry) {
            /* We need to save the 'next' here, the iterator user
             * may delete the entry we are returning. */
            iter->nextEntry = iter->entry->next;
            return iter->entry;
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x7df8
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x7d73
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x7d73
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x7d73
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x54(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jl 0x7ddb
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $-0x1, 0x50(%rax)
je 0x7dd7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x7dd7
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x7dd9
jmp 0x7e3a
jmp 0x7ddb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x7e08
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7e35
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7e42
jmp 0x7d18
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictGetRandomKey
dictEntry *dictGetRandomKey(dict *d)
{
    dictEntry *he, *orighe;
    unsigned int h;
    int listlen, listele;

    if (dictSize(d) == 0) return NULL;
    if (dictIsRehashing(d)) _dictRehashStep(d);
    if (dictIsRehashing(d)) {
        do {
            h = random() % (d->ht[0].size+d->ht[1].size);
            he = (h >= d->ht[0].size) ? d->ht[1].table[h - d->ht[0].size] :
                                      d->ht[0].table[h];
        } while(he == NULL);
    } else {
        do {
            h = random() & d->ht[0].sizemask;
            he = d->ht[0].table[h];
        } while(he == NULL);
    }

    /* Now we found a non empty bucket, but it is a linked
     * list and we need to get a random element from the list.
     * The only sane way to do so is counting the elements and
     * select a random index. */
    listlen = 0;
    orighe = he;
    while(he) {
        he = he->next;
        listlen++;
    }
    listele = random() % listlen;
    he = orighe;
    while(listele--) he = he->next;
    return he;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x48(%rcx), %rax
cmpq $0x0, %rax
jne 0x7ecf
movq $0x0, -0x8(%rbp)
jmp 0x7ff7
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x7ee2
movq -0x10(%rbp), %rdi
callq 0x7470
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x7f5b
jmp 0x7eee
callq 0x4260
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
addq 0x38(%rdx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x7f37
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
subq 0x18(%rdx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x7f4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7eee
jmp 0x7f89
jmp 0x7f5d
callq 0x4260
movq -0x10(%rbp), %rcx
andq 0x20(%rcx), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7f5d
jmp 0x7f89
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7fb6
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7f98
callq 0x4260
movslq -0x28(%rbp), %rcx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x7fef
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7fd1
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictEmpty
void dictEmpty(dict *d) {
    _dictClear(d,&d->ht[0]);
    _dictClear(d,&d->ht[1]);
    d->rehashidx = -1;
    d->iterators = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
callq 0x7aa0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
addq $0x20, %rsi
callq 0x7aa0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, 0x54(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/srned[P]baselib/dict.c
// Function: dictExpandIfNeeded
static int _dictExpandIfNeeded(dict *d)
{
    /* Incremental rehashing already in progress. Return. */
    if (dictIsRehashing(d)) return DICT_OK;

    /* If the hash table is empty expand it to the intial size. */
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);

    /* If we reached the 1:1 ratio, and we are allowed to resize the hash
     * table (global setting) or we should avoid it but the ratio between
     * elements/buckets is over the "safe" threshold, we resize doubling
     * the number of buckets. */
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize ||
         d->ht[0].used/d->ht[0].size > dict_force_resize_ratio))
    {
        return dictExpand(d, ((d->ht[0].size > d->ht[0].used) ?
                                    d->ht[0].size : d->ht[0].used)*2);
    }
    return DICT_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
je 0x80a2
movl $0x0, -0x4(%rbp)
jmp 0x814b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x80c3
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x6ec0
movl %eax, -0x4(%rbp)
jmp 0x814b
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x8144
cmpl $0x0, 0xf130(%rip)      # 0x1720c
jne 0x80fb
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x18(%rcx)
movl 0xf11a(%rip), %ecx      # 0x17210
cmpq %rcx, %rax
jbe 0x8144
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x8123
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x812f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq %rsi
callq 0x6ec0
movl %eax, -0x4(%rbp)
jmp 0x814b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop