LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: setunfocus
void setunfocus(xcb_drawable_t win)
{
    uint32_t values[1];

    if (NULL == focuswin)
    {
        return;
    }
    
    if (focuswin->id == screen->root)
    {
        return;
    }

    /* Set new border colour. */
    values[0] = conf.unfocuscol;
    xcb_change_window_attributes(conn, win, XCB_CW_BORDER_PIXEL, values);

    xcb_flush(conn);
}

// Assembly:
movq 0x4950(%rip), %rax      # 0xa940
testq %rax, %rax
je 0x6033
movl (%rax), %eax
movq 0x494a(%rip), %rcx      # 0xa948
cmpl (%rcx), %eax
je 0x6033
pushq %rax
movl %edi, %esi
movl 0x4961(%rip), %eax      # 0xa96c
leaq 0x4(%rsp), %rcx
movl %eax, (%rcx)
movq 0x495f(%rip), %rdi      # 0xa978
movl $0x8, %edx
callq 0x30f0
movq 0x494e(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: raisewindow
void raisewindow(xcb_drawable_t win)
{
    uint32_t values[] = { XCB_STACK_MODE_ABOVE };

    if (screen->root == win || 0 == win)
    {
        return;
    }
    
    xcb_configure_window(conn, win,
                         XCB_CONFIG_WINDOW_STACK_MODE,
                         values);
    xcb_flush(conn);
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
testl %edi, %edi
je 0x61cb
movl %edi, %esi
movq 0x47a3(%rip), %rax      # 0xa948
cmpl %edi, (%rax)
je 0x61cb
movq 0x47c8(%rip), %rdi      # 0xa978
leaq 0x4(%rsp), %rcx
movl $0x40, %edx
callq 0x3200
movq 0x47b2(%rip), %rdi      # 0xa978
callq 0x3150
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: addtoworkspace
void addtoworkspace(struct client *client, uint32_t ws)
{
    struct item *item;
    
    item = additem(&wslist[ws]);
    if (NULL == item)
    {
        PDEBUG("addtoworkspace: Out of memory.\n");
        return;
    }

    /* Remember our place in the workspace window list. */
    client->wsitem[ws] = item;

    /* Remember the data. */
    item->data = client;

    /*
     * Set window hint property so we can survive a crash.
     * 
     * Fixed windows have their own special WM hint. We don't want to
     * mess with that.
     */
    if (!client->fixed)
    {
        setwmdesktop(client->id, ws);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r15d
leaq 0x46fb(%rip), %rax      # 0xa8e0
leaq (%rax,%r15,8), %rdi
callq 0x6d0c
testq %rax, %rax
je 0x6233
movq %rax, 0x48(%r14,%r15,8)
movq %r14, (%rax)
cmpb $0x0, 0x32(%r14)
jne 0x6233
movl (%r14), %edx
leaq 0xc(%rsp), %rax
movl %ebx, (%rax)
movq 0x4765(%rip), %rdi      # 0xa978
movl 0x4767(%rip), %ecx      # 0xa980
xorl %esi, %esi
movl $0x6, %r8d
movl $0x20, %r9d
pushq %rax
pushq $0x1
callq 0x3520
addq $0x10, %rsp
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: movewindow
void movewindow(xcb_drawable_t win, uint16_t x, uint16_t y)
{
    uint32_t values[2];

    if (screen->root == win || 0 == win)
    {
        /* Can't move root. */
        return;
    }
    
    values[0] = x;
    values[1] = y;

    xcb_configure_window(conn, win, XCB_CONFIG_WINDOW_X
                         | XCB_CONFIG_WINDOW_Y, values);
    
    xcb_flush(conn);
}

// Assembly:
testl %edi, %edi
je 0x6280
movl %edi, %eax
movq 0x46fe(%rip), %rcx      # 0xa948
cmpl %edi, (%rcx)
je 0x6280
pushq %rax
movzwl %si, %esi
movq %rsp, %rcx
movl %esi, (%rcx)
movzwl %dx, %edx
movl %edx, 0x4(%rcx)
movq 0x4714(%rip), %rdi      # 0xa978
movl %eax, %esi
movl $0x3, %edx
callq 0x3200
movq 0x4701(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: resize
void resize(xcb_drawable_t win, uint16_t width, uint16_t height)
{
    uint32_t values[2];

    if (screen->root == win || 0 == win)
    {
        /* Can't resize root. */
        return;
    }

    PDEBUG("Resizing to %d x %d.\n", width, height);
    
    values[0] = width;
    values[1] = height;
                                        
    xcb_configure_window(conn, win,
                         XCB_CONFIG_WINDOW_WIDTH
                         | XCB_CONFIG_WINDOW_HEIGHT, values);
    xcb_flush(conn);
}

// Assembly:
testl %edi, %edi
je 0x62c4
movl %edi, %eax
movq 0x46ba(%rip), %rcx      # 0xa948
cmpl %edi, (%rcx)
je 0x62c4
pushq %rax
movzwl %si, %esi
movq %rsp, %rcx
movl %esi, (%rcx)
movzwl %dx, %edx
movl %edx, 0x4(%rcx)
movq 0x46d0(%rip), %rdi      # 0xa978
movl %eax, %esi
movl $0xc, %edx
callq 0x3200
movq 0x46bd(%rip), %rdi      # 0xa978
callq 0x3150
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: resizelim
void resizelim(struct client *client)
{
    int16_t mon_x;
    int16_t mon_y;
    uint16_t mon_width;
    uint16_t mon_height;
    
    if (NULL == client->monitor)
    {
        mon_x = 0;
        mon_y = 0;
        mon_width = screen->width_in_pixels;
        mon_height = screen->height_in_pixels;
    }
    else
    {
        mon_x = client->monitor->x;
        mon_y = client->monitor->y;
        mon_width = client->monitor->width;
        mon_height = client->monitor->height;        
    }
    
    /* Is it smaller than it wants to  be? */
    if (0 != client->min_height && client->height < client->min_height)
    {
        client->height = client->min_height;
    }

    if (0 != client->min_width && client->width < client->min_width)
    {
        client->width = client->min_width;
    }

    if (client->x + client->width + conf.borderwidth * 2 > mon_x + mon_width)
    {
        client->width = mon_width - ((client->x - mon_x) + conf.borderwidth
                                     * 2);
    }
    
    if (client->y + client->height + conf.borderwidth * 2 > mon_y + mon_height)
    {
        client->height = mon_height - ((client->y - mon_y) + conf.borderwidth
                                       * 2);
    }
    
    resize(client->id, client->width, client->height);
}

// Assembly:
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
je 0x6435
movswl 0x10(%rsi), %edx
movswl 0x12(%rsi), %eax
jmp 0x6440
xorl %edx, %edx
movq 0x450a(%rip), %rsi      # 0xa948
xorl %eax, %eax
movzwl 0x16(%rsi), %ecx
movzwl 0x14(%rsi), %esi
movzwl 0x18(%rdi), %r8d
testw %r8w, %r8w
je 0x645f
cmpw %r8w, 0xc(%rdi)
jae 0x645f
movw %r8w, 0xc(%rdi)
movzwl 0x16(%rdi), %r8d
testw %r8w, %r8w
je 0x6476
cmpw %r8w, 0xa(%rdi)
jae 0x6476
movw %r8w, 0xa(%rdi)
movswl 0x6(%rdi), %r9d
movzwl 0xa(%rdi), %r8d
addl %r9d, %r8d
movl 0x44c6(%rip), %r10d     # 0xa950
leal (%r8,%r10,2), %r11d
movl %r10d, %r8d
addl %r10d, %r8d
leal (%rdx,%rsi), %r10d
cmpl %r10d, %r11d
jle 0x64aa
subl %edx, %r9d
addl %r8d, %r9d
subl %r9d, %esi
movw %si, 0xa(%rdi)
movswl 0x8(%rdi), %edx
movzwl 0xc(%rdi), %esi
addl %edx, %esi
addl %r8d, %esi
leal (%rax,%rcx), %r9d
cmpl %r9d, %esi
jle 0x64cc
subl %eax, %r8d
addl %r8d, %edx
subl %edx, %ecx
movw %cx, 0xc(%rdi)
movl (%rdi), %eax
movzwl 0xa(%rdi), %esi
movzwl 0xc(%rdi), %edx
movl %eax, %edi
jmp 0x6281
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: getpointer
bool getpointer(xcb_drawable_t win, int16_t *x, int16_t *y)
{
    xcb_query_pointer_reply_t *pointer;
    
    pointer
        = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win), 0);
    if (NULL == pointer)
    {
        return false;
    }

    *x = pointer->win_x;
    *y = pointer->win_y;

    free(pointer);

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %esi
movq 0x4487(%rip), %r15      # 0xa978
movq %r15, %rdi
callq 0x3290
movq %r15, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x32b0
movq %rax, %r15
testq %rax, %rax
je 0x6526
movzwl 0x14(%r15), %eax
movw %ax, (%r14)
movzwl 0x16(%r15), %eax
movw %ax, (%rbx)
movq %r15, %rdi
callq 0x3040
testq %r15, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: movelim
void movelim(struct client *client)
{
    int16_t mon_x;
    int16_t mon_y;
    uint16_t mon_width;
    uint16_t mon_height;
    
    if (NULL == client->monitor)
    {
        mon_x = 0;
        mon_y = 0;
        mon_width = screen->width_in_pixels;
        mon_height = screen->height_in_pixels;
    }
    else
    {
        mon_x = client->monitor->x;
        mon_y = client->monitor->y;
        mon_width = client->monitor->width;
        mon_height = client->monitor->height;        
    }

    /* Is it outside the physical monitor? */
    if (client->x < mon_x)
    {
        client->x = mon_x;
    }
    if (client->y < mon_y)
    {
        client->y = mon_y;
    }

    if (client->x + client->width > mon_x + mon_width - conf.borderwidth * 2)
    {
        client->x = (mon_x + mon_width - conf.borderwidth * 2) - client->width;
    }

    if (client->y + client->height > mon_y + mon_height - conf.borderwidth * 2)
    {
        client->y = (mon_y + mon_height - conf.borderwidth * 2)
            - client->height;
    }    

    movewindow(client->id, client->x, client->y);
}

// Assembly:
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x6545
movzwl 0x10(%rcx), %esi
movzwl 0x12(%rcx), %edx
jmp 0x6550
movq 0x43fc(%rip), %rcx      # 0xa948
xorl %esi, %esi
xorl %edx, %edx
movzwl 0x16(%rcx), %eax
movzwl 0x14(%rcx), %ecx
cmpw %si, 0x6(%rdi)
jge 0x6562
movw %si, 0x6(%rdi)
movswl %si, %esi
cmpw %dx, 0x8(%rdi)
jge 0x656f
movw %dx, 0x8(%rdi)
movswl %dx, %edx
movswl 0x6(%rdi), %r9d
movzwl 0xa(%rdi), %r8d
addl %r8d, %r9d
addl %esi, %ecx
movl 0x43c9(%rip), %esi      # 0xa950
addl %esi, %esi
subl %esi, %ecx
negl %esi
cmpl %ecx, %r9d
jle 0x6599
subl %r8d, %ecx
movw %cx, 0x6(%rdi)
movswl 0x8(%rdi), %r8d
movzwl 0xc(%rdi), %ecx
addl %ecx, %r8d
addl %edx, %eax
addl %esi, %eax
cmpl %eax, %r8d
jle 0x65b4
subl %ecx, %eax
movw %ax, 0x8(%rdi)
movl (%rdi), %eax
movzwl 0x6(%rdi), %esi
movzwl 0x8(%rdi), %edx
movl %eax, %edi
jmp 0x623d
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: getrandr
void getrandr(void)
{
    xcb_randr_get_screen_resources_current_cookie_t rcookie;
    xcb_randr_get_screen_resources_current_reply_t *res;
    xcb_randr_output_t *outputs;
    int len;    
    xcb_timestamp_t timestamp;
    
    rcookie = xcb_randr_get_screen_resources_current(conn, screen->root);
    res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL);
    if (NULL == res)
    {
        printf("No RANDR extension available.\n");
        return;
    }
    timestamp = res->config_timestamp;

    len = xcb_randr_get_screen_resources_current_outputs_length(res);
    outputs = xcb_randr_get_screen_resources_current_outputs(res);

    PDEBUG("Found %d outputs.\n", len);
    
    /* Request information for all outputs. */
    getoutputs(outputs, len, timestamp);

    free(res);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x42f3(%rip), %rdi      # 0xa978
movq 0x42bc(%rip), %rax      # 0xa948
movl (%rax), %esi
callq 0x3220
movq 0x42de(%rip), %rdi      # 0xa978
movl %eax, %esi
xorl %edx, %edx
callq 0x3370
testq %rax, %rax
je 0x66da
movq %rax, %rbx
movl 0xc(%rax), %ebp
movq %rax, %rdi
callq 0x3550
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3230
movq %rax, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x66ea
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3040
leaq 0xe64(%rip), %rdi       # 0x7545
popq %rbx
popq %r14
popq %rbp
jmp 0x30c0
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/mcwm.c
// Function: finishtabbing
void finishtabbing(void)
{
    mode = 0;
    
    if (NULL != lastfocuswin)
    {
        movetohead(&wslist[curws], lastfocuswin->wsitem[curws]);
        lastfocuswin = NULL;             
    }
                
    movetohead(&wslist[curws], focuswin->wsitem[curws]);
}

// Assembly:
pushq %rax
movl $0x0, 0x3c79(%rip)      # 0xa8d8
movq 0x3d3a(%rip), %rax      # 0xa9a0
testq %rax, %rax
je 0x6c91
movl 0x3c4f(%rip), %ecx      # 0xa8c0
leaq 0x3c68(%rip), %rdx      # 0xa8e0
leaq (%rdx,%rcx,8), %rdi
movq 0x48(%rax,%rcx,8), %rsi
callq 0x6cb4
movq $0x0, 0x3d0f(%rip) # 0xa9a0
movl 0x3c29(%rip), %eax      # 0xa8c0
leaq 0x3c42(%rip), %rcx      # 0xa8e0
leaq (%rcx,%rax,8), %rdi
movq 0x3c97(%rip), %rcx      # 0xa940
movq 0x48(%rcx,%rax,8), %rsi
popq %rax
jmp 0x6cb4
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/list.c
// Function: freeitem
void freeitem(struct item **list, int *stored,
              struct item *item)
{
    if (NULL == list || NULL == *list || NULL == item)
    {
        return;
    }
    
    if (NULL != item->data)
    {
        free(item->data);
        item->data = NULL;
    }

    delitem(list, item);

    if (NULL != stored)
    {
        (*stored) --;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x6dd5
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
testq %rdx, %rdx
je 0x6dd0
movq %rdi, %r15
cmpq $0x0, (%rdi)
je 0x6dd0
movq %rsi, %rbx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x6dbe
callq 0x3040
movq $0x0, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6d49
testq %rbx, %rbx
je 0x6dd0
decl (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tkln[P]mcwm/list.c
// Function: delallitems
void delallitems(struct item **list, int *stored)
{
    struct item *item;
    struct item *next;
    
    for (item = *list; item != NULL; item = next)
    {
        next = item->next;
        free(item->data);
        delitem(list, item);
    }

    if (NULL != stored)
    {
        (*stored) = 0;
    }    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x6e0b
movq %rdi, %r14
movq (%r15), %rdi
movq 0x10(%r15), %r12
callq 0x3040
movq %r14, %rdi
movq %r15, %rsi
callq 0x6d49
movq %r12, %r15
testq %r12, %r12
jne 0x6dec
testq %rbx, %rbx
je 0x6e16
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/list.c
// Function: SH_List__init
SH_List*
SH_List__init(int* err) {
	SH_List* obj;

	__cascade(err, (SH_List*)0);

	obj = (SH_List*)malloc(sizeof(SH_List));
	if ((SH_List*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_List*)0;
	}

	obj->count = 0;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x117e
cmpl $0x0, (%rbx)
je 0x117e
xorl %eax, %eax
jmp 0x11aa
movl $0x2008, %edi           # imm = 0x2008
callq 0x1070
testq %rax, %rax
je 0x119c
xorl %ecx, %ecx
movq $0x0, 0x2000(%rax)
jmp 0x11a3
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x11aa
movl %ecx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/list.c
// Function: SH_List__destroy
void
SH_List__destroy(SH_List* obj, sh_bool_t recursive, int* err) {
	int local_err;
	int final_err = SH_E_NO_ERROR;
	size_t i;
	__cascade(err,);
	if (recursive) {
		for (i = 0; i < obj->count; i++) {
			local_err = SH_E_NO_ERROR;
			SH_Item__destroy(obj->_list[i], recursive, &local_err);
			if (final_err == SH_E_NO_ERROR && local_err != SH_E_NO_ERROR) {
				final_err = local_err;
			}
		}
		free(obj);
		__raise(err, final_err);
	} else {
		free(obj);
		__clear(err);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x11c7
cmpl $0x0, (%rbx)
jne 0x123a
testb %sil, %sil
je 0x121a
cmpq $0x0, 0x2000(%r14)
je 0x1227
xorl %r13d, %r13d
movzbl %sil, %ebp
leaq 0x4(%rsp), %r15
xorl %r12d, %r12d
movl $0x0, 0x4(%rsp)
movq (%r14,%r13,8), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1040
movl 0x4(%rsp), %eax
testl %eax, %eax
cmovel %r12d, %eax
testl %r12d, %r12d
cmovel %eax, %r12d
incq %r13
cmpq 0x2000(%r14), %r13
jb 0x11e5
jmp 0x122a
movq %r14, %rdi
callq 0x1030
xorl %r12d, %r12d
jmp 0x1232
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x123a
movl %r12d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/list.c
// Function: SH_List__add
void
SH_List__add(SH_List* obj, SH_Item* item, int* err) {
	__cascade(err,);
	if (obj->count >= SH_LIST_CAPACITY) {
		__raise(err, SH_E_LIST_OVERFLOW);
		return;
	}
	obj->_list[obj->count++] = item;
	__clear(err);
}

// Assembly:
testq %rdx, %rdx
je 0x1254
cmpl $0x0, (%rdx)
je 0x1254
retq
movq 0x2000(%rdi), %rcx
cmpq $0x400, %rcx            # imm = 0x400
jb 0x126b
movl $0x300001, %eax         # imm = 0x300001
jmp 0x127c
leaq 0x1(%rcx), %r8
xorl %eax, %eax
movq %r8, 0x2000(%rdi)
movq %rsi, (%rdi,%rcx,8)
testq %rdx, %rdx
je 0x1253
movl %eax, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/list.c
// Function: _SH_List__to_s_item
void
__SH_List__to_s_item(SH_Item* obj, void* ptr, int* err) {
	__sh_list__string* str;

	sh_char_t* s;

	int local_err = SH_E_NO_ERROR;

	__cascade(err,);

	str = (__sh_list__string*)ptr;

	s = SH_Item__to_s(obj, &local_err);
	if (local_err) {
		__raise(err, local_err);
		return;
	}

	str->a[str->n ++] = s; str->length += strlen((const char*)s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movl $0x0, 0xc(%rsp)
testq %rdx, %rdx
je 0x135f
cmpl $0x0, (%r14)
jne 0x1399
leaq 0xc(%rsp), %r15
movq %r15, %rsi
callq 0x1090
movl (%r15), %ecx
testl %ecx, %ecx
je 0x137d
testq %r14, %r14
je 0x1399
movl %ecx, (%r14)
jmp 0x1399
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movq %rax, 0x10(%rbx,%rcx,8)
movq %rax, %rdi
callq 0x1050
addq %rax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phluid61[P]hsf/src/list.c
// Function: SH_List__to_s
sh_char_t*
SH_List__to_s(SH_List* obj, int* err) {
	sh_char_t* tmp_s;
	sh_char_t* s;
	sh_char_t* ptr;

	size_t i;
	size_t n;
	size_t total;

	__sh_list__string str;
	str.length = (size_t)0;
	str.n = (size_t)0;

	SH_List__each(obj, &__SH_List__to_s_item, (void*)(&str), err);
	if (__catch(err)) {
		for (i = 0; i < str.n; i++) {
			free(str.a[i]);
		}
		__cascade(err, (sh_char_t*)0);
	}

	total = 0;
	total += str.length;
	if (str.n > 1)
		total += (str.n - 1) * 2; /* ', ' between items */
	total += 1; /* NULL */

	s = (sh_char_t*)malloc(sizeof(sh_char_t) * total);
	if ((sh_char_t*)0 == s) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (sh_char_t*)0;
	}

	ptr = s;

	for (i = 0; i < str.n; i++) {
		if (i > 0) {
			*ptr = ',';
			ptr ++;

			*ptr = ' ';
			ptr ++;
		}

		tmp_s = str.a[i];
		n = strlen((const char*)tmp_s);
		memcpy((void*)ptr, (const void*)tmp_s, n);
		free(str.a[i]);
		ptr += n;
	}

	*ptr = SH_CHAR_C(0);

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rsi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq 0x2c12(%rip), %rsi      # 0x3fd8
movq %r14, %rcx
callq 0x1080
testq %r14, %r14
je 0x1401
cmpl $0x0, (%r14)
je 0x1401
cmpq $0x0, 0x8(%rsp)
je 0x13f7
xorl %ebx, %ebx
movq 0x10(%rsp,%rbx,8), %rdi
callq 0x1030
incq %rbx
cmpq 0x8(%rsp), %rbx
jb 0x13e3
cmpl $0x0, (%r14)
jne 0x1494
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
xorl %edx, %edx
cmpq $0x2, %rcx
leaq -0x2(%rcx,%rcx), %rcx
cmovaeq %rcx, %rdx
leaq (%rax,%rdx), %rdi
incq %rdi
callq 0x1070
testq %rax, %rax
je 0x1488
movq %rax, %rbx
cmpq $0x0, 0x8(%rsp)
movq %rax, %r14
je 0x1482
xorl %r13d, %r13d
movq %rbx, %r14
testq %r13, %r13
je 0x144d
movw $0x202c, (%r14)         # imm = 0x202C
addq $0x2, %r14
movq 0x10(%rsp,%r13,8), %r15
movq %r15, %rdi
callq 0x1050
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1060
movq 0x10(%rsp,%r13,8), %rdi
callq 0x1030
addq %r12, %r14
incq %r13
cmpq 0x8(%rsp), %r13
jb 0x143e
movb $0x0, (%r14)
jmp 0x1496
testq %r14, %r14
je 0x1494
movl $0x80000001, (%r14)     # imm = 0x80000001
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.5/mmap-write.c
// Function: main
int main (int argc, char* const argv[])
{
  int fd;
  void* file_memory;

  /* Seed the random number generator.*/
  srand (time (NULL));

  /* Prepare a file large enough to hold an unsigned integer. */
  fd = open (argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
  lseek (fd, FILE_LENGTH+1, SEEK_SET);
  write (fd, "", 1);
  lseek (fd, 0, SEEK_SET);

  /* Create the memory mapping. */
  file_memory = mmap (0, FILE_LENGTH, PROT_WRITE, MAP_SHARED, fd, 0);
  close (fd);
  /* Write a random integer to memory-mapped area. */
  sprintf((char*) file_memory, "%d\n", random_range (-100, 100));

  /* Release the memory (unnecessary because the program exits). */
  munmap (file_memory, FILE_LENGTH);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1070
movq 0x8(%rbx), %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x10a0
movl %eax, %ebx
movl $0x101, %esi            # imm = 0x101
movl %eax, %edi
xorl %edx, %edx
callq 0x1050
leaq 0xdcf(%rip), %rsi       # 0x201b
movl $0x1, %edx
movl %ebx, %edi
callq 0x1030
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1050
movl $0x100, %esi            # imm = 0x100
xorl %edi, %edi
movl $0x2, %edx
movl $0x1, %ecx
movl %ebx, %r8d
xorl %r9d, %r9d
callq 0x1040
movq %rax, %r14
movl %ebx, %edi
callq 0x1060
callq 0x10c0
cvtsi2sd %eax, %xmm0
mulsd 0xd76(%rip), %xmm0      # 0x2010
mulsd 0xd66(%rip), %xmm0      # 0x2008
cvttsd2si %xmm0, %edx
addl $-0x64, %edx
leaq 0xd68(%rip), %rsi       # 0x2018
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x1090
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/vanhauser-thc[P]vulntest/tricky.c
// Function: main
int main(int argc, char *argv[]) {
  char buf[128];
  int user_len = atoi(argv[2]);
  int buf_size = sizeof(buf);

  if (user_len > buf_size) {
    printf("Attempted Overflow Detected\n");
    return -1;
  }

  memcpy(buf, argv[1], user_len);
  if (buf[0] != 0)
    return 0;
  else
    return -1;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x1050
cmpl $0x81, %eax
jl 0x118a
leaq 0xe86(%rip), %rdi       # 0x2004
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x11a3
movq 0x8(%rbx), %rsi
movslq %eax, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1040
xorl %eax, %eax
cmpb $0x1, (%rbx)
sbbl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: printLine
void printLine( char *line, WORD32 loc, WORD32 val, LINESTYLE_T linestyle )
{
  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;
  switch( linestyle )
  {
  default:
  case LINE:
    fprintf( listfile, "%5d             ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    if( !listed )
    {
      fprintf( listfile, "%5d       %4.4o  ", lineno, val );
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "            %4.4o\n", val );
    }
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated && lgm_flag )
      {
        fprintf( listfile, "%5d %5.5o %4.4o@ ", lineno, loc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o %4.4o  ", lineno, loc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x95ec(%rip)      # 0xd370
je 0x3dda
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x6462
incl 0xa336(%rip)            # 0xe0d8
incl 0xa338(%rip)            # 0xe0e0
cmpl $0x1, %r15d
je 0x3e0c
cmpl $0x2, %r15d
je 0x3de5
cmpl $0x3, %r15d
je 0x3dee
movq 0x95af(%rip), %rdi      # 0xd370
movl 0xa309(%rip), %edx      # 0xe0d0
leaq 0x3a01(%rip), %rsi      # 0x77cf
xorl %eax, %eax
callq 0x2120
jmp 0x3e83
movl $0x0, 0x9448(%rip)      # 0xd22c
retq
cmpl $0x0, 0xa2dc(%rip)      # 0xe0c8
je 0x3e2e
movq 0x957b(%rip), %rdi      # 0xd370
leaq 0x3a2d(%rip), %rsi      # 0x7829
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2120
jmp 0x3e9c
cmpl $0x0, 0xa2b5(%rip)      # 0xe0c8
movq 0x9556(%rip), %rdi      # 0xd370
je 0x3e6d
leaq 0x39cf(%rip), %rsi      # 0x77f2
movl %ebx, %edx
xorl %eax, %eax
callq 0x2120
jmp 0x3e9c
cmpb $0x0, 0xa297(%rip)      # 0xe0cc
leaq 0x39c9(%rip), %rsi      # 0x7805
leaq 0x39d4(%rip), %rax      # 0x7817
cmoveq %rax, %rsi
cmpb $0x0, 0xa5c6(%rip)      # 0xe414
movq 0x951b(%rip), %rdi      # 0xd370
movl 0xa275(%rip), %edx      # 0xe0d0
cmoveq %rax, %rsi
movl %ebp, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x2120
jmp 0x3e83
movl 0xa25d(%rip), %edx      # 0xe0d0
leaq 0x3966(%rip), %rsi      # 0x77e0
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2120
movq 0x94e6(%rip), %rsi      # 0xd370
movq %r14, %rdi
callq 0x20c0
movl $0x1, 0xa22c(%rip)      # 0xe0c8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x64cf
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
  WORD32  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = toupper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ecx, %ecx
cmpl %edx, %esi
jge 0x402d
movl %edx, %ebp
movl %esi, %r14d
callq 0x2030
movslq %r14d, %rdx
movslq %ebp, %rsi
leaq 0x1(%rdx), %rdi
xorl %r8d, %r8d
leaq 0xa0ed(%rip), %r9       # 0xe0f0
movq (%rax), %rcx
leaq (%rdi,%r8), %r10
leaq (%rdx,%r8), %r11
movsbq (%r9,%r11), %r11
movb (%rcx,%r11,4), %r11b
leaq 0x1(%r8), %rcx
movb %r11b, (%rbx,%r8)
cmpq %rsi, %r10
jge 0x402d
cmpq $0x5, %r8
movq %rcx, %r8
jb 0x4003
cmpl $0x6, %ecx
ja 0x4045
movl %ecx, %edi
addq %rbx, %rdi
movl $0x7, %edx
subl %ecx, %edx
xorl %esi, %esi
callq 0x20d0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, WORD32 col )
{
  char   linecol[12];

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%d)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
                                         filename, linecol, mesg->file, clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
cmpl $0x2, 0x7b36(%rip)      # 0xd230
jne 0x576c
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
incl 0x7b18(%rip)            # 0xd228
movl 0x89ba(%rip), %edx      # 0xe0d0
leal 0x1(%rbx), %ecx
leaq 0x21f2(%rip), %rsi      # 0x7912
leaq 0x4(%rsp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2160
movq 0x7aea(%rip), %rdi      # 0xd220
movq 0x8(%r14), %r8
movl 0x7d5f(%rip), %r9d      # 0xd4a0
leaq 0x21fb(%rip), %rsi      # 0x7943
leaq 0x7cd1(%rip), %rdx      # 0xd420
movq %r15, %rcx
xorl %eax, %eax
callq 0x2120
movq (%r14), %rdi
movl %ebx, %esi
callq 0x69e6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
movb $0x1, 0x8b01(%rip)      # 0xe274
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: punchObject
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
movq 0x6cab(%rip), %rsi      # 0xd2e0
testq %rsi, %rsi
je 0x664d
pushq %rbx
movzbl %dil, %ebx
movl %ebx, %edi
callq 0x20e0
addl %ebx, 0x6c04(%rip)      # 0xd250
popq %rbx
movb $0x1, 0x4b3c(%rip)      # 0xb190
retq
// File: /workspace/github_c_makefile_star2_O1/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: conditionFalse
void conditionFalse()
{
  int     level;

  if( line[lexstart] == '<' )
  {
    /* Invariant: line[cc] is the next unexamined character.                  */
    level = 1;
    while( level > 0 )
    {
      if( isend( line[cc] ) || ( line[cc] == '/' ))
      {
        readLine();
      }
      else
      {
        switch( line[cc] )
        {
        case '>':
          level--;
          cc++;
          break;

        case '<':
          level++;
          cc++;
          break;

        case '$':
          level = 0;
          cc++;
          break;

        default:
          cc++;
          break;
        } /* end switch                                                       */
      } /* end if                                                             */
    } /* end while                                                            */
    nextLexeme();
  }
  else
  {
    errorMessage( &lt_expected, lexstart );
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movslq 0x7930(%rip), %rsi      # 0xe270
leaq 0x77a9(%rip), %rbx      # 0xe0f0
cmpb $0x3c, (%rsi,%rbx)
jne 0x69af
movl $0x1, %ebp
movslq 0x792b(%rip), %rax      # 0xe284
movzbl (%rax,%rbx), %ecx
cmpl $0x2e, %ecx
jg 0x697c
testl %ecx, %ecx
je 0x698b
cmpl $0xa, %ecx
je 0x698b
cmpl $0x24, %ecx
jne 0x6998
incl %eax
movl %eax, 0x790c(%rip)      # 0xe284
xorl %ebp, %ebp
jmp 0x69a0
cmpl $0x3e, %ecx
je 0x6992
cmpl $0x3c, %ecx
je 0x6996
cmpl $0x2f, %ecx
jne 0x6998
callq 0x3612
jmp 0x69a0
decl %ebp
jmp 0x6998
incl %ebp
incl %eax
movl %eax, 0x78e4(%rip)      # 0xe284
testl %ebp, %ebp
jg 0x6952
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x38fd
leaq 0x469a(%rip), %rdi      # 0xb050
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x56f3
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/readseek3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDONLY);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		lseek(fd, offset, SEEK_SET);
		assert(read(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x24c8(%rip), %rdi      # 0x51a0
xorl %esi, %esi
xorl %eax, %eax
callq 0x2230
movl %eax, %ebp
callq 0x22a0
testl %ebp, %ebp
js 0x2d5e
movslq %eax, %r14
imulq %r15, %r14
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2120
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
callq 0x2170
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x2d3f
movq %rsp, %r15
incq (%rbx)
movl %ebp, %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2120
movl $0x1000, %edx           # imm = 0x1000
movl %ebp, %edi
movq %r15, %rsi
callq 0x2170
cmpq $0x1000, %rax           # imm = 0x1000
je 0x2d19
leaq 0x5c3(%rip), %rdi       # 0x3309
leaq 0x54c(%rip), %rsi       # 0x3299
leaq 0x582(%rip), %rcx       # 0x32d6
movl $0x28, %edx
callq 0x2130
leaq 0x52c(%rip), %rdi       # 0x3291
leaq 0x52d(%rip), %rsi       # 0x3299
leaq 0x563(%rip), %rcx       # 0x32d6
movl $0x24, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/map_test.c
// Function: kvmap_help_message
static void
kvmap_help_message(void)
{
  fprintf(stderr, "%s Usage: <stdout> <stderr> {api ... {rgen ... {pass ...}}}\n", __func__);
  kvmap_api_helper_message();
  maptest_passes_message();
  fprintf(stderr, "set MAP_TEST_PERF=y to enable perf recording\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x159bb(%rip), %rbx     # 0x1bff8
movq (%rbx), %rdi
leaq 0xea11(%rip), %rsi      # 0x15058
leaq 0xea47(%rip), %rdx      # 0x15095
xorl %eax, %eax
callq 0x62f0
callq 0x68c1
callq 0x6966
movq (%rbx), %rcx
leaq 0xea3f(%rip), %rdi      # 0x150a8
pushq $0x2d
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6540
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/map_test.c
// Function: test_kvmap
static int
test_kvmap(const int argc, char ** const argv)
{
  struct oalloc * const oa = oalloc_create();
  debug_assert(oa);
  struct kvmap_mm mm = { .af = (kv_alloc_func)oalloc_alloc, .ap = oa, };
  //struct kvmap_mm mm = { .af = kv_alloc_malloc, .rf = kv_retire_free, };
  struct kvmap_api * api = NULL;
  const int n1 = kvmap_api_helper(argc, argv, &api, &mm, false);
  if (n1 < 0) {
    kvmap_help_message();
    oalloc_destroy(oa);
    return n1;
  }

  char *pref[64] = {};
  for (int i = 0; i < n1; i++) {
    pref[i] = argv[i];
  }
  pref[n1] = NULL;

  struct pass_info pi = {};
  pi.api = api;
  pi.vctr_size = 8;
  pi.wf = kvmap_worker;
  pi.af = kvmap_analyze;
  const int n2 = maptest_passes(argc - n1, argv + n1, pref, &pi);

  kvmap_api_destroy(api);
  oalloc_destroy(oa);
  if (n2 < 0) {
    kvmap_help_message();
    return n2;
  } else {
    return n1 + n2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %r12
movl %edi, %r15d
callq 0x842a
movq %rax, %rbx
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x760e
vxorps %xmm0, %xmm0, %xmm0
leaq -0xb0(%rbp), %rcx
vmovups %ymm0, (%rcx)
vmovups %ymm0, 0x30(%rcx)
vmovups %ymm0, 0x20(%rcx)
leaq 0x15ce(%rip), %rax      # 0x8479
movq %rax, (%rcx)
movq %rbx, 0x8(%rcx)
leaq -0x30(%rbp), %rdx
movq $0x0, (%rdx)
movl %r15d, %edi
movq %r12, %rsi
xorl %r8d, %r8d
vzeroupper
callq 0xbc30
movl %eax, %r14d
testl %eax, %eax
js 0x6f93
leaq -0x2b0(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
xorl %esi, %esi
callq 0x6200
movl %r14d, %r13d
testl %r14d, %r14d
je 0x6f0b
leaq (,%r13,8), %rdx
leaq -0x2b0(%rbp), %rdi
movq %r12, %rsi
callq 0x6330
movq $0x0, -0x2b0(%rbp,%r13,8)
vxorps %xmm0, %xmm0, %xmm0
leaq -0x60(%rbp), %rcx
vmovups %ymm0, (%rcx)
movq -0x30(%rbp), %rax
movq %rax, 0x8(%rcx)
movq $0x8, 0x10(%rcx)
leaq 0x72(%rip), %rax        # 0x6fac
movq %rax, 0x18(%rcx)
leaq 0xfe(%rip), %rax        # 0x7043
movq %rax, 0x20(%rcx)
subl %r14d, %r15d
leaq (%r12,%r13,8), %rsi
leaq -0x2b0(%rbp), %rdx
movl %r15d, %edi
vzeroupper
callq 0x1356d
movl %eax, %r15d
movq -0x30(%rbp), %rdi
callq 0xbc07
movq %rbx, %rdi
callq 0x867e
testl %r15d, %r15d
js 0x6fa2
addl %r15d, %r14d
movl %r14d, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6630
movq %rbx, %rdi
callq 0x867e
jmp 0x6f7e
callq 0x6630
movl %r15d, %r14d
jmp 0x6f7e
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/map_test.c
// Function: kvmap_worker
static void *
kvmap_worker(void * const ptr)
{
  struct maptest_worker_info * const info = (typeof(info))ptr;
  const u64 end_magic = info->end_magic;
  info->priv = malloc(2048);
  srandom_u64(info->seed);
  if (info->end_type == MAPTEST_END_TIME) {
    do {
      kvmap_mix_batch(info, 4096);
    } while (time_nsec() < end_magic);
  } else if (info->end_type == MAPTEST_END_COUNT) {
    u64 count = 0;
    do {
      const u64 nr = (end_magic - count) > 4096 ? 4096 : (end_magic - count);
      kvmap_mix_batch(info, nr);
      count += nr;
    } while (count < end_magic);
  }
  free(info->priv);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %r15
movl $0x800, %edi            # imm = 0x800
callq 0x6390
movq %rax, 0x58(%rbx)
movq 0x20(%rbx), %rdi
callq 0x9bb3
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x7012
cmpq $0x1, %rax
jne 0x7029
xorl %r12d, %r12d
movl $0x1000, %r13d          # imm = 0x1000
movq %r15, %r14
subq %r12, %r14
cmpq %r13, %r14
cmovaeq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7110
addq %r14, %r12
cmpq %r15, %r12
jb 0x6ff0
jmp 0x7029
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
callq 0x7110
callq 0x741a
cmpq %r15, %rax
jb 0x7012
movq 0x58(%rbx), %rdi
callq 0x6060
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/map_test.c
// Function: kvmap_analyze
static bool
kvmap_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  u64 v[8];
  for (u64 i = 0; i < 8; i++) {
    v[i] = vctr_get(va, i);
  }

  const u64 nrop = v[XSA] + v[XDA] + v[XGA] + v[XPA];
  const double mops = ((double)nrop) / (dt * 1.0e6);
  const bool done = damp_add_test(damp, mops);
  const double havg = damp_average(damp);
  const char * const pat = " set %"PRIu64" %"PRIu64" del %"PRIu64" %"PRIu64
      " get %"PRIu64" %"PRIu64" pro %"PRIu64" %"PRIu64" mops %.4lf havg %.4lf\n";
  sprintf(out, pat, v[XSA], v[XSS], v[XDA], v[XDS], v[XGA], v[XGS], v[XPA], v[XPS], mops, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, %r14
vmovsd %xmm0, -0x30(%rbp)
movq %rdi, %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x9aed
movq %rax, -0x80(%rbp,%r12,8)
incq %r12
cmpq $0x8, %r12
jne 0x7066
movq -0x80(%rbp), %r12
movq -0x70(%rbp), %r15
movq -0x60(%rbp), %rbx
movq -0x50(%rbp), %r13
leaq (%rbx,%r13), %rcx
addq %r15, %rcx
addq %r12, %rcx
vcvtusi2sd %rcx, %xmm1, %xmm0
vmovsd -0x30(%rbp), %xmm1
vmulsd 0xdf5c(%rip), %xmm1, %xmm1 # 0x15008
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x38(%rbp)
movq %r14, %rdi
callq 0x9912
movb %al, -0x30(%rbp)
movq %r14, %rdi
callq 0x9826
vmovapd %xmm0, %xmm1
movq -0x78(%rbp), %rcx
movq -0x68(%rbp), %r9
leaq 0xdf35(%rip), %rsi      # 0x15010
movq -0x40(%rbp), %rdi
movq %r12, %rdx
movq %r15, %r8
vmovsd -0x38(%rbp), %xmm0
movb $0x2, %al
pushq -0x48(%rbp)
pushq %r13
pushq -0x58(%rbp)
pushq %rbx
callq 0x6510
addq $0x20, %rsp
movb -0x30(%rbp), %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/map_test.c
// Function: kvmap_mix_batch
static void
kvmap_mix_batch(const struct maptest_worker_info * const info, const u64 nr)
{
  struct kvmap_api * const api = (typeof(api))info->api;
  struct kv * const kv = (typeof(kv))info->priv;
  struct kv * const out = (typeof(out))(((u8*)info->priv)+384);
  struct vctr * const v = info->vctr;
  rgen_next_func next = info->rgen_next;

  for (u64 i = 0; i < nr; i++) {
    const u64 x = next(info->gen);
    kv_refill(kv, &x, sizeof(x), "", 0);
    const u64 y = random_u64() % 100lu;
    if (y < info->pset) { // SET
      vctr_add1(v, XSA);
      kv->vlen = info->vlen;
      if (api->set(api->map, kv)) vctr_add1(v, XSS);
    } else if (y < info->pdel) { // DEL
      vctr_add1(v, XDA);
      if (api->del(api->map, kv)) vctr_add1(v, XDS);
    } else if (y < info->pget) { // GET
      vctr_add1(v, XGA);
      if (api->get(api->map, kv, out)) vctr_add1(v, XGS);
    } else { // PROBE
      vctr_add1(v, XPA);
      if (api->probe(api->map, kv)) vctr_add1(v, XPS);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x725c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq 0x58(%rdi), %r15
leaq 0x180(%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x60(%rdi), %r13
movq 0x10(%r14), %rdi
callq *-0x38(%rbp)
movq %rax, -0x40(%rbp)
movq %r15, %rdi
leaq -0x40(%rbp), %rsi
movl $0x8, %edx
leaq 0xe634(%rip), %rcx      # 0x157a1
xorl %r8d, %r8d
callq 0xb78f
callq 0x860f
movq %rax, %rdx
shrq $0x2, %rdx
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulxq %rcx, %rcx, %rcx
shrq $0x2, %rcx
imulq $0x64, %rcx, %rcx
subq %rcx, %rax
cmpq 0x30(%r14), %rax
jae 0x71c6
movq %r13, %rdi
xorl %esi, %esi
callq 0x9aab
movl 0x28(%r14), %eax
movl %eax, 0xc(%r15)
movq (%r12), %rdi
movq %r15, %rsi
callq *0x18(%r12)
movl $0x1, %esi
jmp 0x7239
cmpq 0x38(%r14), %rax
jae 0x71ec
movl $0x2, %esi
movq %r13, %rdi
callq 0x9aab
movq (%r12), %rdi
movq %r15, %rsi
callq *0x20(%r12)
movl $0x3, %esi
jmp 0x7239
cmpq 0x40(%r14), %rax
jae 0x721b
movl $0x4, %esi
movq %r13, %rdi
callq 0x9aab
movq (%r12), %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq *0x8(%r12)
movl $0x5, %esi
testq %rax, %rax
jne 0x723d
jmp 0x7245
movl $0x6, %esi
movq %r13, %rdi
callq 0x9aab
movq (%r12), %rdi
movq %r15, %rsi
callq *0x10(%r12)
movl $0x7, %esi
testb %al, %al
je 0x7245
movq %r13, %rdi
callq 0x9aab
decq %rbx
jne 0x714f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/openshmem-org[P]openshmem-examples/c/cswap.c
// Function: main
int
main()
{
    static int race_winner = -1;
    int oldval;
    int me;

    shmem_init();
    me = shmem_my_pe();

    oldval = shmem_int_atomic_compare_swap(&race_winner, -1, me, 0);

    if (oldval == -1) {
        printf("pe %d was first\n", me);
    }

    shmem_finalize();

    return 0;
}

// Assembly:
pushq %rbx
callq 0x1060
callq 0x1050
movl %eax, %ebx
leaq 0x2ec0(%rip), %rdi      # 0x4050
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %eax, %edx
xorl %ecx, %ecx
callq 0x1070
cmpl $-0x1, %eax
jne 0x11b3
leaq 0xe5a(%rip), %rdi       # 0x2004
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
callq 0x1040
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cktan[P]tomlc99/toml_sample.c
// Function: main
int main() {
  FILE *fp;
  char errbuf[200];

  // 1. Read and parse toml file
  fp = fopen("sample.toml", "r");
  if (!fp) {
    fatal("cannot open sample.toml - ", strerror(errno));
  }

  toml_table_t *conf = toml_parse_file(fp, errbuf, sizeof(errbuf));
  fclose(fp);

  if (!conf) {
    fatal("cannot parse - ", errbuf);
  }

  // 2. Traverse to a table.
  toml_table_t *server = toml_table_in(conf, "server");
  if (!server) {
    fatal("missing [server]", "");
  }

  // 3. Extract values
  toml_datum_t host = toml_string_in(server, "host");
  if (!host.ok) {
    fatal("cannot read server.host", "");
  }

  toml_array_t *portarray = toml_array_in(server, "port");
  if (!portarray) {
    fatal("cannot read server.port", "");
  }

  printf("host: %s\n", host.u.s);
  printf("port: ");
  for (int i = 0;; i++) {
    toml_datum_t port = toml_int_at(portarray, i);
    if (!port.ok)
      break;
    printf("%d ", (int)port.u.i);
  }
  printf("\n");

  // 4. Free memory
  free(host.u.s);
  toml_free(conf);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq 0x4c12(%rip), %rdi      # 0x6004
leaq 0x50eb(%rip), %rsi      # 0x64e4
callq 0x1190
testq %rax, %rax
je 0x14ff
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
movl $0xc8, %edx
callq 0x2ccd
movq %rax, %rbx
movq %r14, %rdi
callq 0x10a0
testq %rbx, %rbx
je 0x1504
leaq 0x4c06(%rip), %rsi      # 0x603b
movq %rbx, %rdi
callq 0x3135
testq %rax, %rax
je 0x150c
movq %rax, %r15
leaq 0x4c16(%rip), %rsi      # 0x6066
movq %rax, %rdi
callq 0x4167
testl %eax, %eax
je 0x1511
movq %rdx, %r14
leaq 0x4c14(%rip), %rsi      # 0x607e
movq %r15, %rdi
callq 0x30ee
testq %rax, %rax
je 0x1516
movq %rax, %r15
leaq 0x4bfe(%rip), %rdi      # 0x6083
movq %r14, %rsi
xorl %eax, %eax
callq 0x10d0
leaq 0x4bf7(%rip), %rdi      # 0x608d
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
xorl %esi, %esi
callq 0x3fe4
testl %eax, %eax
je 0x14d3
movl $0x1, %ebp
leaq 0x4bdd(%rip), %r12      # 0x6094
movq %r12, %rdi
movl %edx, %esi
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
movl %ebp, %esi
callq 0x3fe4
incl %ebp
testl %eax, %eax
jne 0x14b7
movl $0xa, %edi
callq 0x1040
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x2cc8
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12a8
movq %rsp, %rdi
callq 0x127d
callq 0x124e
callq 0x121f
callq 0x11f0
nop
// File: /workspace/github_c_makefile_star2_O1/hansvanstaveren[P]BigDeal/rmd160.c
// Function: MDfinish
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
{
   unsigned int i;                                 /* counter       */
   dword        X[16];                             /* message words */

   memset(X, 0, 16*sizeof(dword));

   /* put bytes from strptr into X */
   for (i=0; i<(lswlen&63); i++) {
      /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
      X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
   }

   /* append the bit m_n == 1 */
   X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);

   if ((lswlen & 63) > 55) {
      /* length goes to next block */
      compress(MDbuf, X);
      memset(X, 0, 16*sizeof(dword));
   }

   /* append length in bits*/
   X[14] = lswlen << 3;
   X[15] = (lswlen >> 29) | (mswlen << 3);
   compress(MDbuf, X);

   return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %ecx, %ebx
movl %edx, %r15d
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %edx, %eax
andl $0x3f, %eax
je 0x3724
xorl %edx, %edx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movl %edx, %ecx
andb $0x18, %cl
shll %cl, %r8d
movl %edi, %ecx
andl $-0x4, %ecx
xorl %r8d, (%rsp,%rcx)
incq %rdi
addl $0x8, %edx
cmpl %edi, %eax
jne 0x3704
leal (,%r15,8), %ebp
movl $0x80, %edx
movl %ebp, %ecx
shll %cl, %edx
movl %r15d, %ecx
andl $0x3c, %ecx
xorl %edx, (%rsp,%rcx)
cmpl $0x38, %eax
jb 0x376b
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x23de
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %rsp, %rsi
movl %ebp, 0x38(%rsi)
shldl $0x3, %r15d, %ebx
movl %ebx, 0x3c(%rsi)
movq %r14, %rdi
callq 0x23de
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_mul
void
mp96_mul(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1*b2
 * overflow goes undetected
 */
{
	int i,j;
	unsigned int h,carry;
	byte b1copy[L],b2copy[L],bpart[L];

	/*
	 * Make copies of input in case one of the inputs is also output
	 */
	mp96_assign(b1copy, b1);
	mp96_assign(b2copy, b2);

	/*
	 * Here if an input is also output the input gets overwritten
	 */
	mp96_zero(b);

	for (i=L-1; i>=0; i--) {
		for (j=L-1; j>i; j--)
			bpart[j] = 0;
		carry=0;
		for (j=i; j>=0; j--) {
			h = b1copy[i]*b2copy[L-1+j-i]+carry;
			carry = h/256;
			bpart[j] = h;
		}
		(void) mp96_add(b,b,bpart);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rsp)
movq (%rdx), %rax
leaq 0x23(%rsp), %r14
movq %rax, -0xb(%r14)
movl 0x8(%rdx), %eax
movl %eax, -0x3(%r14)
movl $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
leaq 0x17(%rsp), %r15
movl $0xb, %r12d
movl $0xc, %r13d
xorl %ebp, %ebp
cmpq $0xa, %r12
ja 0x389e
leal -0x1(%rbp), %edx
movq %r15, %rdi
subq %rdx, %rdi
incq %rdx
xorl %esi, %esi
callq 0x20f0
movzbl (%rsp,%r12), %eax
xorl %edx, %edx
movq %r14, %rcx
movq %r13, %rsi
movzbl (%rcx), %edi
imull %eax, %edi
addl %edx, %edi
movl %edi, %edx
shrl $0x8, %edx
movb %dil, 0xb(%rsp,%rsi)
decq %rcx
decq %rsi
jg 0x38ab
xorl %ecx, %ecx
movl $0xb, %eax
movzbl (%rbx,%rax), %edx
addl %ecx, %edx
movzbl 0xc(%rsp,%rax), %esi
addl %edx, %esi
xorl %ecx, %ecx
cmpl $0x100, %esi            # imm = 0x100
setae %cl
movb %sil, (%rbx,%rax)
addq $-0x1, %rax
jb 0x38cc
decq %r12
incq %rbp
decq %r13
cmpq $0xc, %rbp
jne 0x3885
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq