LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kazzmir[P]xborder/src/main.cpp
// Function: get_rgb(int, float, float)
rgb get_rgb(int h, float s, float v){
    hsv hsv;
    hsv.h = h;
    hsv.s = s;
    hsv.v = v;
    return hsv2rgb(hsv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl %esi, -0x4(%rbp)
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3cb0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: get_rgb(int, int)
rgb get_rgb(int x, int y){
    if (x < 0 || x > palette_x || y < 0 || y > palette_y){
        rgb out;
        out.r = 0;
        out.g = 0;
        out.b = 0;
        return out;
    }
    hsv hsv;
    hsv.h = (int) interpolate(x, 0, palette_x, 0, 360);
    hsv.s = 1.0;
    hsv.v = 1.2 - interpolate(y, 0, palette_y, 0.2, 1.0);
    return hsv2rgb(hsv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x41de
cmpl $0x14, -0x4(%rbp)
jg 0x41de
cmpl $0x0, -0x8(%rbp)
jl 0x41de
cmpl $0x6, -0x8(%rbp)
jle 0x41fe
movq -0x48(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rax)
jmp 0x42b0
cvtsi2ssl -0x4(%rbp), %xmm0
xorps %xmm3, %xmm3
movss 0x2e56(%rip), %xmm2     # 0x7064
movss 0x2e52(%rip), %xmm4     # 0x7068
movaps %xmm3, %xmm1
callq 0x40c0
cvttss2si %xmm0, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x2ded(%rip), %xmm0     # 0x7020
movsd %xmm0, -0x18(%rbp)
cvtsi2ssl -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
movss 0x2e10(%rip), %xmm2     # 0x7058
movss 0x2e0c(%rip), %xmm3     # 0x705c
movss 0x2e08(%rip), %xmm4     # 0x7060
callq 0x40c0
movq -0x48(%rbp), %rdi
cvtss2sd %xmm0, %xmm1
movsd 0x2de3(%rip), %xmm0     # 0x7050
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3cb0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: time_now()
uint64_t time_now(){
    struct timeval time;
    if (gettimeofday(&time, NULL) == 0){
        return time.tv_sec * 1000 + time.tv_usec / 1000;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x35d0
cmpl $0x0, %eax
jne 0x4304
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x430c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: draw_palette(_XDisplay*, unsigned long, int)
void draw_palette(Display * display, Window window, int start_y){
    
    GC local = XCreateGC(display, window, 0, NULL);
    
    int x = 0;
    int y = start_y;
    int size = palette_size_block;

    for (int cy = 0; cy <= palette_y; cy++){
        for (int cx = 0; cx <= palette_x; cx++){
            rgb rgb = get_rgb(cx, cy);
            XColor color = create_color(display, rgb);
            XGCValues values;
            values.foreground = color.pixel;
            XChangeGC(display, local, GCForeground, &values);
            XFillRectangle(display, window, local, x, y, size, size);

            x += size;
        }
        x = 0;
        y += size;
    } 

    XFreeGC(display, local);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x3170
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl $0xf, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
cmpl $0x6, -0x30(%rbp)
jg 0x4454
movl $0x0, -0x34(%rbp)
cmpl $0x14, -0x34(%rbp)
jg 0x4436
movl -0x34(%rbp), %esi
movl -0x30(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x41b0
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3c50
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x4, %edx
leaq -0xf8(%rbp), %rcx
callq 0x31f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movl -0x2c(%rbp), %eax
movl %eax, (%rsp)
callq 0x3180
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x437a
movl $0x0, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4369
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x31c0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: change_background_color(_XDisplay*, unsigned long, rgb)
void change_background_color(Display * display, Window window, rgb rgb){
    XSetWindowAttributes attributes;
    attributes.background_pixel = create_color(display, rgb).pixel;
    XChangeWindowAttributes(display, window, CWBackPixel, &attributes);
    XClearWindow(display, window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x3c50
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
leaq -0x80(%rbp), %rcx
callq 0x35c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x32e0
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: x_error(_XDisplay*, XErrorEvent*)
int x_error(Display * display, XErrorEvent * event){
    char buffer[256];
    snprintf(buffer, sizeof(buffer), "/tmp/xborder-error.%lu", window);
    FILE * log = fopen(buffer, "a");
    fprintf(log, "xborder pid %d window id %lu crashed\n", getpid(), window);
    fprintf(log, "xerror:\n");
    fprintf(log, "  serial: %lu\n", event->serial);
    char error_string[256];
    XGetErrorText(display, event->error_code, error_string, sizeof(error_string));
    fprintf(log, "  error code: %s\n", error_string);
    fprintf(log, "  request code: %d\n", event->request_code);
    fprintf(log, "  minor code: %d\n", event->minor_code);
    fprintf(log, "  resource id: %lu\n", event->resourceid);
    fprintf(log, "\n");
    show_backtrace(fileno(log));
    fclose(log);
    // exit(1);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
movq 0x5d9f(%rip), %rcx      # 0xa380
movl $0x100, %esi            # imm = 0x100
leaq 0x2b75(%rip), %rdx      # 0x7162
movb $0x0, %al
callq 0x35b0
leaq -0x110(%rbp), %rdi
leaq 0x2b77(%rip), %rsi      # 0x7179
callq 0x33f0
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0x228(%rbp)
callq 0x3510
movq -0x228(%rbp), %rdi
movl %eax, %edx
movq 0x5d4f(%rip), %rcx      # 0xa380
leaq 0x2b43(%rip), %rsi      # 0x717b
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
leaq 0x2b54(%rip), %rsi      # 0x71a1
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x2b40(%rip), %rsi      # 0x71aa
movb $0x0, %al
callq 0x34c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %esi
leaq -0x220(%rbp), %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x34e0
movq -0x118(%rbp), %rdi
leaq -0x220(%rbp), %rdx
leaq 0x2b16(%rip), %rsi      # 0x71b9
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x21(%rax), %edx
leaq 0x2b0b(%rip), %rsi      # 0x71cb
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x22(%rax), %edx
leaq 0x2b02(%rip), %rsi      # 0x71df
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2af7(%rip), %rsi      # 0x71f1
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
leaq 0x2a99(%rip), %rsi      # 0x71a8
movb $0x0, %al
callq 0x34c0
movq -0x118(%rbp), %rdi
callq 0x3390
movl %eax, %edi
callq 0x4740
movq -0x118(%rbp), %rdi
callq 0x3320
xorl %eax, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
// File: kazzmir[P]xborder/src/main.cpp
// Function: get_window_title[abi:cxx11](_XDisplay*, unsigned long)
std::string get_window_title(Display * display, Window window){
    char* buffer = NULL;
    if (XFetchName(display, window, &buffer) != 0){
        if (buffer != NULL){
            std::string out = buffer;
            XFree(buffer);
            return out;
        }
    }

    return "XBorder";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3560
cmpl $0x0, %eax
je 0x4863
cmpq $0x0, -0x20(%rbp)
je 0x4861
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x22(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3630
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x5bc0
jmp 0x4808
leaq -0x22(%rbp), %rdi
callq 0x33a0
movq -0x20(%rbp), %rdi
callq 0x3430
jmp 0x481c
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x485f
jmp 0x4856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x22(%rbp), %rdi
callq 0x33a0
jmp 0x48b2
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x31d0
jmp 0x48b2
movq -0x48(%rbp), %rdi
callq 0x31d0
jmp 0x48a8
jmp 0x4863
leaq -0x35(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3630
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x2986(%rip), %rsi      # 0x7205
callq 0x5bc0
jmp 0x4886
leaq -0x35(%rbp), %rdi
callq 0x33a0
jmp 0x48a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x35(%rbp), %rdi
callq 0x33a0
jmp 0x48b2
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3620
nopl (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: get_parent_window(_XDisplay*, unsigned long)
Window get_parent_window(Display * display, Window window){
    Window root = 0;
    Window parent = 0;
    Window* children = NULL;
    unsigned int count = 0;
    XQueryTree(display, window, &root, &parent, &children, &count);
    if (children != NULL){
        XFree(children);
    }
    return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x2c(%rbp), %r9
callq 0x3120
cmpq $0x0, -0x28(%rbp)
je 0x4c0c
movq -0x28(%rbp), %rdi
callq 0x3430
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: do_configure_xborder()
void do_configure_xborder(){
    Display * display;

    display = XOpenDisplay(NULL);
    if (display == NULL){
        std::cerr << "Cannot open display" << std::endl;
        return;
    }

    Window chosen = find_xborder_window(display);
    if (chosen == 0){
        XCloseDisplay(display);
        return;
    }

    // std::cout << "Send event to window " << chosen << std::endl;

    Atom xborder_configure = XInternAtom(display, "xborder", false);

    XEvent event;
    XClientMessageEvent * client = &event.xclient;
    event.type = ClientMessage;
    client->message_type = xborder_configure;
    client->format = 8;
    client->window = chosen;
    client->data.b[0] = XBorderConfigure;

    if (XSendEvent(display, chosen, 0, 0, &event) != 0){
        std::cout << "Reconfigured xborder window " << chosen << std::endl;
    } else {
        std::cout << "Could not send an event" << std::endl;
    }
    XCloseDisplay(display);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x3480
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5786
movq 0x488a(%rip), %rdi      # 0x9ff0
leaq 0x1afa(%rip), %rsi      # 0x7267
callq 0x3310
movq %rax, %rdi
movq 0x4844(%rip), %rsi      # 0x9fc0
callq 0x3370
jmp 0x5887
movq -0x8(%rbp), %rdi
callq 0x3920
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x57a8
movq -0x8(%rbp), %rdi
callq 0x3680
jmp 0x5887
movq -0x8(%rbp), %rdi
leaq 0x1bbe(%rip), %rsi      # 0x7371
xorl %edx, %edx
callq 0x3230
movq %rax, -0x18(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0xe0(%rbp)
movl $0x21, -0xd8(%rbp)
movq -0x18(%rbp), %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0xe0(%rbp), %rax
movl $0x8, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq -0xe0(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0xe0(%rbp), %rax
movb $0x0, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xd8(%rbp), %r8
callq 0x3080
cmpl $0x0, %eax
je 0x585c
movq 0x479d(%rip), %rdi      # 0x9fd0
leaq 0x1b3f(%rip), %rsi      # 0x7379
callq 0x3310
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3060
movq %rax, %rdi
movq 0x476b(%rip), %rsi      # 0x9fc0
callq 0x3370
jmp 0x587e
movq 0x476d(%rip), %rdi      # 0x9fd0
leaq 0x1b2c(%rip), %rsi      # 0x7396
callq 0x3310
movq %rax, %rdi
movq 0x4747(%rip), %rsi      # 0x9fc0
callq 0x3370
movq -0x8(%rbp), %rdi
callq 0x3680
addq $0xe0, %rsp
popq %rbp
retq
// File: kazzmir[P]xborder/src/main.cpp
// Function: main
int main(int argc, char ** argv){
    bool glow = false;

    for (int i = 1; i < argc; i++){
        std::string arg(argv[i]);
        if (arg == "glow" ||
            arg == "-glow" ||
            arg == "--glow"){
            glow = true;
        } else if (arg == "configure"){
            do_configure_xborder();
            return 0;
        }
    }

    run_xborder(glow);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x59e9
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3630
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x5bc0
jmp 0x58ed
leaq -0x39(%rbp), %rdi
callq 0x33a0
leaq 0x1ab3(%rip), %rsi      # 0x73b0
leaq -0x38(%rbp), %rdi
callq 0x5c70
movb %al, -0x61(%rbp)
jmp 0x590b
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x5950
jmp 0x5914
leaq 0x1a94(%rip), %rsi      # 0x73af
leaq -0x38(%rbp), %rdi
callq 0x5c70
movb %al, -0x62(%rbp)
jmp 0x5929
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x5950
jmp 0x5932
leaq 0x1a75(%rip), %rsi      # 0x73ae
leaq -0x38(%rbp), %rdi
callq 0x5c70
movb %al, -0x63(%rbp)
jmp 0x5947
movb -0x63(%rbp), %al
testb $0x1, %al
jne 0x5950
jmp 0x5987
movb $0x1, -0x11(%rbp)
jmp 0x59be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x33a0
jmp 0x59ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
jmp 0x59ff
leaq 0x1a27(%rip), %rsi      # 0x73b5
leaq -0x38(%rbp), %rdi
callq 0x5c70
movb %al, -0x64(%rbp)
jmp 0x599c
movb -0x64(%rbp), %al
testb $0x1, %al
jne 0x59a5
jmp 0x59bc
callq 0x5740
jmp 0x59ac
movl $0x0, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x59c5
jmp 0x59be
movl $0x0, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31d0
movl -0x50(%rbp), %eax
testl %eax, %eax
je 0x59d9
jmp 0x59d7
jmp 0x59f6
jmp 0x59db
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x58b1
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x4c90
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3620
nopl (%rax,%rax)
// File: kazzmir[P]xborder/src/main.cpp
// Function: TryChildren(_XDisplay*, unsigned long, unsigned long)
static Window TryChildren(Display *dpy, Window win, Atom WM_STATE){
    Window root, parent;
    Window *children;
    unsigned int nchildren;
    unsigned int i;
    Atom type = None;
    int format;
    unsigned long nitems, after;
    unsigned char *data;
    Window inf = 0;

    if (!XQueryTree(dpy, win, &root, &parent, &children, &nchildren))
        return 0;
    for (i = 0; !inf && (i < nchildren); i++) {
        data = NULL;
        XGetWindowProperty(dpy, children[i], WM_STATE, 0, 0, False,
                AnyPropertyType, &type, &format, &nitems,
                &after, &data);
        if (data)
            XFree(data);
        if (type)
            inf = children[i];
    }
    for (i = 0; !inf && (i < nchildren); i++)
        inf = TryChildren(dpy, children[i], WM_STATE);
    if (children)
        XFree(children);
    return inf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x40(%rbp), %rcx
leaq -0x48(%rbp), %r8
leaq -0x4c(%rbp), %r9
callq 0x3120
cmpl $0x0, %eax
jne 0x5a69
movq $0x0, -0x18(%rbp)
jmp 0x5ba3
movl $0x0, -0x50(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x80(%rbp)
movb %al, -0x81(%rbp)
jne 0x5a8e
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
setb %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x5a9d
jmp 0x5b33
movq $0x0, -0x78(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rax
movl -0x50(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
leaq -0x58(%rbp), %r14
leaq -0x5c(%rbp), %rbx
leaq -0x68(%rbp), %r11
leaq -0x70(%rbp), %r10
leaq -0x78(%rbp), %rax
movq %r8, %rcx
movq $0x0, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x30d0
cmpq $0x0, -0x78(%rbp)
je 0x5b0d
movq -0x78(%rbp), %rdi
callq 0x3430
cmpq $0x0, -0x58(%rbp)
je 0x5b23
movq -0x48(%rbp), %rax
movl -0x50(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
jmp 0x5b25
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x5a70
movl $0x0, -0x50(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x80(%rbp)
movb %al, -0x82(%rbp)
jne 0x5b58
movl -0x50(%rbp), %eax
cmpl -0x4c(%rbp), %eax
setb %al
movb %al, -0x82(%rbp)
movb -0x82(%rbp), %al
testb $0x1, %al
jne 0x5b64
jmp 0x5b8b
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rax
movl -0x50(%rbp), %ecx
movq (%rax,%rcx,8), %rsi
movq -0x30(%rbp), %rdx
callq 0x5a10
movq %rax, -0x80(%rbp)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x5b3a
cmpq $0x0, -0x48(%rbp)
je 0x5b9b
movq -0x48(%rbp), %rdi
callq 0x3430
movq -0x80(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: j-faria[P]kima/examples/default_priors/kima_setup.cpp
// Function: main
int main(int argc, char** argv)
{
    datafile = "dummy_data.rv";

    load(datafile, "kms", 0);

    Sampler<RVmodel> sampler = setup<RVmodel>(argc, argv);
    sampler.run(1000);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x6f0, %rsp            # imm = 0x6F0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xad598(%rip), %rdi     # 0x11a7b8
movq %rdi, -0x6f0(%rbp)
leaq 0x58783(%rip), %rsi     # 0xc59b1
callq 0x6690
movq -0x6f0(%rbp), %rdi
movl $0x0, -0x14(%rbp)
leaq 0x4a2a0(%rip), %rsi     # 0xb74e8
leaq -0x14(%rbp), %rdx
callq 0x6d960
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq -0x6d0(%rbp), %rdi
movq %rdi, -0x6e8(%rbp)
callq 0x6daa0
movq -0x6e8(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x6db40
jmp 0x6d27e
movl $0x0, -0x4(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6df60
movl -0x4(%rbp), %eax
addq $0x6f0, %rsp            # imm = 0x6F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x6d8(%rbp)
movl %eax, -0x6dc(%rbp)
leaq -0x6d0(%rbp), %rdi
callq 0x6df60
movq -0x6d8(%rbp), %rdi
callq 0x6830
nopw (%rax,%rax)
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::~sort_timer_lst()
sort_timer_lst::~sort_timer_lst()
{
    util_timer *tmp = head;
    while (tmp)
    {
        head = tmp->next;
        delete tmp;
        tmp = head;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x533a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x532d
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x52fb
addq $0x20, %rsp
popq %rbp
retq
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::add_timer(util_timer*)
void sort_timer_lst::add_timer(util_timer *timer)
{
    if (!timer)
    {
        return;
    }
    if (!head)
    {
        head = tail = timer;
        return;
    }
    if (timer->expire < head->expire)
    {
        timer->next = head;
        head->prev = timer;
        head = timer;
        return;
    }
    add_timer(timer, head);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5361
jmp 0x53c2
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x537c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x53c2
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rcx), %rcx
cmpq (%rcx), %rax
jge 0x53b2
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x20(%rcx)
movq -0x10(%rbp), %rdx
movq (%rax), %rcx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x53c2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rdx
callq 0x53d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::add_timer(util_timer*, util_timer*)
void sort_timer_lst::add_timer(util_timer *timer, util_timer *lst_head)
{
    util_timer *prev = lst_head;
    util_timer *tmp = prev->next;
    while (tmp)
    {
        if (timer->expire < tmp->expire)
        {
            prev->next = timer;
            timer->next = tmp;
            tmp->prev = timer;
            timer->prev = prev;
            break;
        }
        prev = tmp;
        tmp = tmp->next;
    }
    if (!tmp)
    {
        prev->next = timer;
        timer->prev = prev;
        timer->next = NULL;
        tail = timer;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x545b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x5445
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x545b
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x53fc
cmpq $0x0, -0x28(%rbp)
jne 0x5492
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x20(%rcx)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, 0x20(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::adjust_timer(util_timer*)
void sort_timer_lst::adjust_timer(util_timer *timer)
{
    if (!timer)
    {
        return;
    }
    util_timer *tmp = timer->next;
    if (!tmp || (timer->expire < tmp->expire))
    {
        return;
    }
    if (timer == head)
    {
        head = head->next;
        head->prev = NULL;
        timer->next = NULL;
        add_timer(timer, head);
    }
    else
    {
        timer->prev->next = timer->next;
        timer->next->prev = timer->prev;
        add_timer(timer, timer->next);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x54c4
jmp 0x5566
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x54e7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x54e9
jmp 0x5566
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jne 0x5529
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq %rax, (%rdi)
movq (%rdi), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rsi
movq (%rdi), %rdx
callq 0x53d0
jmp 0x5566
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x53d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::del_timer(util_timer*)
void sort_timer_lst::del_timer(util_timer *timer)
{
    if (!timer)
    {
        return;
    }
    if ((timer == head) && (timer == tail))
    {
        delete timer;
        head = NULL;
        tail = NULL;
        return;
    }
    if (timer == head)
    {
        head = head->next;
        head->prev = NULL;
        delete timer;
        return;
    }
    if (timer == tail)
    {
        tail = tail->prev;
        tail->next = NULL;
        delete timer;
        return;
    }
    timer->prev->next = timer->next;
    timer->next->prev = timer->prev;
    delete timer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5594
jmp 0x56b6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jne 0x55e3
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x55e3
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x55cb
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
jmp 0x56b6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq (%rcx), %rax
jne 0x562a
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5625
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
jmp 0x56b6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jne 0x5672
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5670
movq -0x30(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
jmp 0x56b6
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x56b6
movq -0x38(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: yckwong[P]tinywebserver/timer/lst_timer.cpp
// Function: sort_timer_lst::tick()
void sort_timer_lst::tick()
{
    if (!head)
    {
        return;
    }
    
    time_t cur = time(NULL);
    util_timer *tmp = head;
    while (tmp)
    {
        if (cur < tmp->expire)
        {
            break;
        }
        tmp->cb_func(tmp->user_data);
        head = tmp->next;
        if (head)
        {
            head->prev = NULL;
        }
        delete tmp;
        tmp = head;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0x56df
jmp 0x576f
xorl %eax, %eax
movl %eax, %edi
callq 0x4450
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x576f
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x5710
jmp 0x576f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x5746
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5762
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x44b0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x56fa
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yckwong[P]tinywebserver/http/http_conn.cpp
// Function: http_conn::init(int, sockaddr_in const&, char*, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void http_conn::init(int sockfd, const sockaddr_in &addr, char *root, int SQLVerify, int TRIGMode,
                     int close_log, string user, string passwd, string sqlname)
{
    m_sockfd = sockfd;
    m_address = addr;

    addfd(m_epollfd, sockfd, true, m_TRIGMode);
    m_user_count++;

    //当浏览器出现连接重置时，可能是网站根目录出错或http响应格式出错或者访问的文件中内容完全为空
    doc_root = root;
    m_SQLVerify = SQLVerify;
    m_TRIGMode = TRIGMode;
    m_close_log = close_log;

    strcpy(sql_user, user.c_str());
    strcpy(sql_passwd, passwd.c_str());
    strcpy(sql_name, sqlname.c_str());

    init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq 0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x18(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x20(%rax)
movl 0x1017f(%rip), %edi     # 0x164c0
movl -0xc(%rbp), %esi
movl 0xe34(%rax), %ecx
movl $0x1, %edx
callq 0x6150
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x101e6(%rip), %ecx     # 0x16548
addl $0x1, %ecx
movl %ecx, 0x101dd(%rip)     # 0x16548
movq -0x20(%rbp), %rcx
movq %rcx, 0xdf8(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xe30(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0xe34(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0xe38(%rax)
addq $0xe3c, %rax            # imm = 0xE3C
movq %rax, -0x58(%rbp)
callq 0x4190
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x4470
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0xea0, %rax            # imm = 0xEA0
movq %rax, -0x48(%rbp)
callq 0x4190
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4470
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
addq $0xf04, %rax            # imm = 0xF04
movq %rax, -0x38(%rbp)
callq 0x4190
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4470
movq -0x30(%rbp), %rdi
callq 0x6410
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yckwong[P]tinywebserver/http/http_conn.cpp
// Function: http_conn::read_once()
bool http_conn::read_once()
{
    if (m_read_idx >= READ_BUFFER_SIZE)
    {
        return false;
    }
    int bytes_read = 0;
    while (true)
    {
        bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
        if (bytes_read == -1)
        {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                break;
            return false;
        }
        else if (bytes_read == 0)
        {
            return false;
        }
        m_read_idx += bytes_read;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x800, 0x828(%rax)     # imm = 0x800
jl 0x66a9
movb $0x0, -0x1(%rbp)
jmp 0x6729
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl 0x14(%rcx), %edi
movq %rcx, %rsi
addq $0x28, %rsi
movslq 0x828(%rcx), %rax
addq %rax, %rsi
movl $0x800, %eax            # imm = 0x800
subl 0x828(%rcx), %eax
movslq %eax, %rdx
xorl %ecx, %ecx
callq 0x4140
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x6702
callq 0x4060
cmpl $0xb, (%rax)
je 0x66fa
callq 0x4060
cmpl $0xb, (%rax)
jne 0x66fc
jmp 0x6725
movb $0x0, -0x1(%rbp)
jmp 0x6729
cmpl $0x0, -0x14(%rbp)
jne 0x670e
movb $0x0, -0x1(%rbp)
jmp 0x6729
jmp 0x6710
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
addl 0x828(%rax), %ecx
movl %ecx, 0x828(%rax)
jmp 0x66b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yckwong[P]tinywebserver/webserver.cpp
// Function: WebServer::init(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, int, int, int, int, int, int)
void WebServer::init(int port, string user, string passWord, string databaseName, int log_write, int sqlverify,
                     int opt_linger, int trigmode, int sql_num, int thread_num, int close_log, int actor_model)
{
    m_port = port;
    m_user = user;
    m_passWord = passWord;
    m_databaseName = databaseName;
    m_sql_num = sql_num;
    m_thread_num = thread_num;
    m_log_write = log_write;
    m_SQLVerify = sqlverify;
    m_OPT_LINGER = opt_linger;
    m_TRIGMode = trigmode;
    m_close_log = close_log;
    m_actormodel = actor_model;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %r8, -0x40(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, -0x50(%rbp)
movl %esi, %eax
movq -0x50(%rbp), %rsi
movl 0x40(%rbp), %edx
movl 0x38(%rbp), %edx
movl 0x30(%rbp), %edx
movl 0x28(%rbp), %edx
movl 0x20(%rbp), %edx
movl 0x18(%rbp), %edx
movl 0x10(%rbp), %edx
movq %rdi, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
addq $0x38, %rdi
callq 0x4050
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x58, %rdi
callq 0x4050
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x4050
movq -0x38(%rbp), %rax
movl 0x28(%rbp), %ecx
movl %ecx, 0x98(%rax)
movl 0x30(%rbp), %ecx
movl %ecx, 0xa8(%rax)
movl -0x2c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x9c(%rax)
movl 0x18(%rbp), %ecx
movl %ecx, 0x1d570(%rax)
movl 0x20(%rbp), %ecx
movl %ecx, 0x1d574(%rax)
movl 0x38(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl 0x40(%rbp), %ecx
movl %ecx, 0x18(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yckwong[P]tinywebserver/webserver.cpp
// Function: WebServer::sql_pool()
void WebServer::sql_pool()
{
    //初始化数据库连接池
    m_connPool = connection_pool::GetInstance();
    m_connPool->init("localhost", m_user, m_passWord, m_databaseName, 3306, m_sql_num, m_close_log);

    //初始化数据库读取表
    if (0 == m_SQLVerify)
        users->initmysql_result(m_connPool);
    else if (1 == m_SQLVerify)
        users->initresultFile(m_connPool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0xbb20
movq %rax, %rcx
movq -0xb8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x47e0
movq -0xa8(%rbp), %rdx
leaq 0x331b(%rip), %rsi      # 0x104d1
leaq -0x28(%rbp), %rdi
callq 0x4f60
jmp 0xd1c1
movq -0xb8(%rbp), %rsi
addq $0x38, %rsi
leaq -0x60(%rbp), %rdi
callq 0x41b0
jmp 0xd1d7
movq -0xb8(%rbp), %rsi
addq $0x58, %rsi
leaq -0x80(%rbp), %rdi
callq 0x41b0
jmp 0xd1ed
movq -0xb8(%rbp), %rsi
addq $0x78, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x41b0
jmp 0xd206
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rax
movl 0x14(%rax), %edx
movl 0x98(%rax), %ecx
movq %rsp, %rax
movl %edx, 0x8(%rax)
movl %ecx, (%rax)
leaq -0x28(%rbp), %rsi
leaq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq -0xa0(%rbp), %r8
movl $0xcea, %r9d            # imm = 0xCEA
callq 0xbbb0
jmp 0xd245
leaq -0xa0(%rbp), %rdi
callq 0x42d0
leaq -0x80(%rbp), %rdi
callq 0x42d0
leaq -0x60(%rbp), %rdi
callq 0x42d0
leaq -0x28(%rbp), %rdi
callq 0x42d0
leaq -0x29(%rbp), %rdi
callq 0x4500
movq -0xb8(%rbp), %rcx
xorl %eax, %eax
cmpl 0x9c(%rcx), %eax
jne 0xd319
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rsi
callq 0x5a70
jmp 0xd343
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd30e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd2fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xd2f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x42d0
leaq -0x80(%rbp), %rdi
callq 0x42d0
leaq -0x60(%rbp), %rdi
callq 0x42d0
leaq -0x28(%rbp), %rdi
callq 0x42d0
leaq -0x29(%rbp), %rdi
callq 0x4500
jmp 0xd34c
movq -0xb8(%rbp), %rcx
movl $0x1, %eax
cmpl 0x9c(%rcx), %eax
jne 0xd341
movq -0xb8(%rbp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rsi
callq 0x5d20
jmp 0xd343
addq $0xd0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x47d0
nopw %cs:(%rax,%rax)
// File: yckwong[P]tinywebserver/webserver.cpp
// Function: WebServer::adjust_timer(util_timer*)
void WebServer::adjust_timer(util_timer *timer)
{
    time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    timer_lst.adjust_timer(timer);

    LOG_INFO("%s", "adjust timer once");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4450
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
addq $0xf, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x1d578, %rdi          # imm = 0x1D578
movq -0x10(%rbp), %rsi
callq 0x54a0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0xdac2
callq 0x8ad0
movq %rax, %rdi
movl $0x1, %esi
leaq 0x280a(%rip), %rdx      # 0x102b1
leaq 0x2a8c(%rip), %rcx      # 0x1053a
movb $0x0, %al
callq 0xafe0
callq 0x8ad0
movq %rax, %rdi
callq 0xb550
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yckwong[P]tinywebserver/webserver.cpp
// Function: WebServer::deal_timer(util_timer*, int)
void WebServer::deal_timer(util_timer *timer, int sockfd)
{
    timer->cb_func(&users_timer[sockfd]);
    if (timer)
    {
        timer_lst.del_timer(timer);
    }

    LOG_INFO("close fd %d", users_timer[sockfd].sockfd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x1d588(%rcx), %rdi
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rdi
callq *%rax
cmpq $0x0, -0x10(%rbp)
je 0xdb22
movq -0x20(%rbp), %rdi
addq $0x1d578, %rdi          # imm = 0x1D578
movq -0x10(%rbp), %rsi
callq 0x5570
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl 0x14(%rcx), %eax
jne 0xdb6e
callq 0x8ad0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x1d588(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movl $0x1, %esi
leaq 0x29f2(%rip), %rdx      # 0x1054c
movb $0x0, %al
callq 0xafe0
callq 0x8ad0
movq %rax, %rdi
callq 0xb550
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/json/lib/boost/container/static_vector.hxx
// Function: bool cxon::read<cxon::JSON<cxon::json::format_traits>, boost::container::static_vector<int, 3ul, void>, void>::value<char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(boost::container::static_vector<int, 3ul, void>&, char const*&, char const*, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static bool value(boost::container::static_vector<T, N>& t, II& i, II e, Cx& cx) {
                    II const o = i;
                        std::size_t p = 0;
                    return cio::cnt::read_list<Y>(i, e, cx, [&] {
                        if (++p <= N)
                            return read_value<Y>(cnt::emplace(t), i, e, cx);
                        return cio::rewind(i, o), cx/json::read_error::overflow;
                    });
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups -0x40(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x498e0
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/char.hxx
// Function: std::enable_if<!cxon::JSON<cxon::json::format_traits>::produce_strict_javascript, bool>::type cxon::cio::chr::imp::encode_<cxon::JSON<cxon::json::format_traits>, char32_t>::value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cxon::context<cxon::JSON<cxon::json::format_traits>>, cxon::JSON<cxon::json::format_traits>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char32_t, cxon::context<cxon::JSON<cxon::json::format_traits>>&)
static auto value(O& o, char32_t c, Cx& cx) -> enable_if_t<!S::produce_strict_javascript, bool> {
                        if (c > 0x7F) {
                                char b[4]; int const n = utf32_to_utf8(b, c);
                                return poke<X>(o, b, n, cx);
                        }
                        else    return encode_<X, char>::value(o, char(c), cx);
                    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x7f, -0x14(%rbp)
jbe 0x5fd34
movl -0x14(%rbp), %esi
leaq -0x24(%rbp), %rdi
callq 0x5b010
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
movslq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5cb50
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5fd4c
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movsbl %al, %esi
callq 0x5c9d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: oknenavin[P]cxon/test/../src/cxon/lang/common/cio/string.hxx
// Function: std::enable_if<chr::is_char_16<char16_t>::value, bool>::type cxon::cio::str::imp::char_append_<boost::container::basic_string<char16_t, std::char_traits<char16_t>, boost::container::new_allocator<char16_t>>, char16_t>(boost::container::basic_string<char16_t, std::char_traits<char16_t>, boost::container::new_allocator<char16_t>>&, char32_t)
inline auto char_append_(C& c, char32_t c32) -> enable_if_t<chr::is_char_16<T>::value, bool> {
                if (c32 > 0xFFFF) {
                    c32 -= 0x10000;
                    return cxon::cnt::append(c, T(0xD800 | (c32 >> 10))) && cxon::cnt::append(c, T(0xDC00 | (c32 & 0x3FF)));
                }
                return cxon::cnt::append(c, T(c32));
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jbe 0x60248
movl -0x14(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
shrl $0xa, %eax
orl $0xd800, %eax           # imm = 0xD800
movw %ax, -0x16(%rbp)
leaq -0x16(%rbp), %rsi
callq 0x60310
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1b(%rbp)
jne 0x6021d
jmp 0x6023e
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xdc00, %eax           # imm = 0xDC00
movw %ax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x60310
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x60261
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movw %ax, -0x1a(%rbp)
leaq -0x1a(%rbp), %rsi
callq 0x60310
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)