LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/kyx0r[P]xkeyboard/xkeyboard.c
// Function: btn_release
void btn_release(Display *display, int button)
{
	// Create and setting up the event
	XEvent event;
	memset (&event, 0, sizeof (event));
	event.xbutton.button = button;
	event.xbutton.same_screen = True;
	event.xbutton.subwindow = DefaultRootWindow (display);
	while (event.xbutton.subwindow)
	{
		event.xbutton.window = event.xbutton.subwindow;
		XQueryPointer (display, event.xbutton.window,
				&event.xbutton.root, &event.xbutton.subwindow,
				&event.xbutton.x_root, &event.xbutton.y_root,
				&event.xbutton.x, &event.xbutton.y,
				&event.xbutton.state);
	}
	if(event.xbutton.window != mousewin)
	{
		if(sendkey)
		{
			event.type = ButtonRelease;
			if (XSendEvent (display, PointerWindow, True, ButtonReleaseMask, &event) == 0)
				fprintf (stderr, "Error to send the event!\n");
			XFlush (display);
		} else {
			XTestFakeButtonEvent(dpy, button, False, CurrentTime);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movl $0xc0, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl %ebp, 0x4(%rsp)
movl %ebp, 0x54(%r14)
movl $0x1, 0x58(%r14)
movq 0xe8(%rbx), %rax
movslq 0xe0(%rbx), %rcx
shlq $0x7, %rcx
movq 0x10(%rax,%rcx), %rsi
movq %rsi, 0x30(%r14)
testq %rsi, %rsi
je 0x4cee
leaq 0x50(%rsp), %r12
leaq 0x54(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x4c(%rsp), %r14
leaq 0x58(%rsp), %r15
movq %rsi, 0x28(%rsp)
subq $0x8, %rsp
movq %rbx, %rdi
leaq 0x38(%rsp), %rdx
leaq 0x40(%rsp), %rcx
movq %r12, %r8
movq %r13, %r9
pushq %r15
pushq %r14
pushq %rbp
callq 0x21b0
addq $0x20, %rsp
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
jne 0x4cba
movq 0x28(%rsp), %rax
cmpq 0x13e46(%rip), %rax     # 0x18b40
je 0x4d47
cmpl $0x0, 0x18549(%rip)     # 0x1d24c
je 0x4d33
leaq 0x8(%rsp), %r8
movl $0x5, (%r8)
movl $0x8, %ecx
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2030
testl %eax, %eax
je 0x4d59
movq %rbx, %rdi
callq 0x22f0
jmp 0x4d47
movq 0x13abe(%rip), %rdi     # 0x187f8
movl 0x4(%rsp), %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2160
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2504
jmp 0x4d29
// File: /workspace/github_c_makefile_star2_O1/liuhaotian[P]xmppsh/libstrophe/examples/roster.c
// Function: handle_reply
int handle_reply(xmpp_conn_t * const conn,
		 xmpp_stanza_t * const stanza,
		 void * const userdata)
{
    xmpp_stanza_t *query, *item;
    char *type, *name;

    type = xmpp_stanza_get_type(stanza);
    if (strcmp(type, "error") == 0)
	fprintf(stderr, "ERROR: query failed\n");
    else {
	query = xmpp_stanza_get_child_by_name(stanza, "query");
	printf("Roster:\n");
	for (item = xmpp_stanza_get_children(query); item; 
	     item = xmpp_stanza_get_next(item))
	    if ((name = xmpp_stanza_get_attribute(item, "name")))
		printf("\t %s (%s) sub=%s\n", 
		       name,
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	    else
		printf("\t %s sub=%s\n",
		       xmpp_stanza_get_attribute(item, "jid"),
		       xmpp_stanza_get_attribute(item, "subscription"));
	printf("END OF LIST\n");
    }

    /* disconnect */
    xmpp_disconnect(conn);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xb5a5
leaq 0xa4e4(%rip), %rsi      # 0xcaa0
movq %rax, %rdi
callq 0x2270
testl %eax, %eax
je 0x26a9
movq %r14, (%rsp)
leaq 0x9a42(%rip), %rsi      # 0xc019
movq %rbx, %rdi
callq 0xb5c3
movq %rax, %rbx
leaq 0x9aca(%rip), %rdi      # 0xc0b3
callq 0x22e0
movq %rbx, %rdi
callq 0xb65e
testq %rax, %rax
je 0x2680
movq %rax, %r14
leaq 0x9d64(%rip), %r15      # 0xc36d
leaq 0x9a21(%rip), %r12      # 0xc031
leaq 0x9a1e(%rip), %r13      # 0xc035
movq %r14, %rdi
movq %r15, %rsi
callq 0xb755
movq %rax, %rbp
movq %r14, %rdi
movq %r12, %rsi
callq 0xb755
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0xb755
testq %rbp, %rbp
je 0x265c
leaq 0x99d5(%rip), %rdi      # 0xc01f
movq %rbp, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2030
jmp 0x2670
leaq 0x99df(%rip), %rdi      # 0xc042
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0xb663
movq %rax, %r14
testq %rax, %rax
jne 0x2617
leaq 0x9a34(%rip), %rdi      # 0xc0bb
callq 0x22e0
movq (%rsp), %r14
movq %r14, %rdi
callq 0x4768
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2380
jmp 0x2690
// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/test/test_str2int.c
// Function: check_strprint2
static int
check_strprint2(int verbose, const char *str, size_t len, size_t destlen,
                char quote, const char *expect) {
    char buf[100];
    hts_strprint(buf, destlen, quote, str, len);
    if (strcmp(buf, expect) != 0) {
        fprintf(stderr, "hts_strprint failed: length %zu: got \"%.*s\", "
                "expected \"%s\"\n", destlen, (int) destlen, buf, expect);
        return -1;
    }
    else if (verbose) {
        fprintf(stderr, "hts_strprint OK: length %zu: got \"%s\"\n",
                destlen, expect);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %rax
movq %rsi, %rcx
movl %edi, %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r8d, %edx
movq %rax, %r8
callq 0x7cd8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x46c0
testl %eax, %eax
jne 0x6d5e
xorl %r15d, %r15d
testl %ebp, %ebp
jne 0x6d8a
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xab27b(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
leaq 0x8b49f(%rip), %rsi     # 0x9220e
movq %rsp, %r8
movq %r14, %rdx
movl %r14d, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x4700
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x6d50
movq 0xab24f(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
leaq 0x8b4af(%rip), %rsi     # 0x9224a
xorl %r15d, %r15d
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4700
jmp 0x6d50
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: CTEST_LOG
void CTEST_LOG(const char* fmt, ...)
{
    va_list argp;
    msg_start(ANSI_BLUE, "LOG");

    va_start(argp, fmt);
    vprint_errormsg(fmt, argp);
    va_end(argp);

    msg_end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x236b
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq 0x2cb9(%rip), %rdi      # 0x502b
leaq 0x2cba(%rip), %rsi      # 0x5033
callq 0x23b4
leaq -0x30(%rbp), %rsi
movq %r14, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x23ee
callq 0x2443
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: vprint_errormsg
static void vprint_errormsg(const char* const fmt, va_list ap) {
    // (v)snprintf returns the number that would have been written
    const int ret = vsnprintf(ctest_errormsg, ctest_errorsize, fmt, ap);
    if (ret < 0) {
        ctest_errormsg[0] = 0x00;
    } else {
        const size_t size = (size_t) ret;
        const size_t s = (ctest_errorsize <= size ? size -ctest_errorsize : size);
        // ctest_errorsize may overflow at this point
        ctest_errorsize -= s;
        ctest_errormsg += s;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq %rdi, %rdx
movq 0x71b9(%rip), %rdi      # 0x95b8
movq 0x71aa(%rip), %rsi      # 0x95b0
callq 0x20a0
testl %eax, %eax
js 0x2437
movl %eax, %eax
movq 0x7198(%rip), %rcx      # 0x95b0
xorl %edx, %edx
cmpq %rax, %rcx
cmovbeq %rcx, %rdx
subq %rdx, %rax
subq %rax, %rcx
movq %rcx, 0x7182(%rip)      # 0x95b0
addq %rax, 0x7183(%rip)      # 0x95b8
jmp 0x2441
movq 0x717a(%rip), %rax      # 0x95b8
movb $0x0, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: CTEST_ERR
void CTEST_ERR(const char* fmt, ...)
{
    va_list argp;
    msg_start(ANSI_YELLOW, "ERR");

    va_start(argp, fmt);
    vprint_errormsg(fmt, argp);
    va_end(argp);

    msg_end();
    longjmp(ctest_err, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x24c6
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq 0x2b6a(%rip), %rdi      # 0x5037
leaq 0x2b6b(%rip), %rsi      # 0x503f
callq 0x23b4
leaq -0x30(%rbp), %rsi
movq %r14, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x23ee
callq 0x2443
leaq 0x5fb6(%rip), %rdi      # 0x84c0
movl $0x1, %esi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_str
void assert_str(const char* exp, const char*  real, const char* caller, int line) {
    if ((exp == NULL && real != NULL) ||
        (exp != NULL && real == NULL) ||
        (exp && real && strcmp(exp, real) != 0)) {
        CTEST_ERR("%s:%d  expected '%s', got '%s'", caller, line, exp, real);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x2573
testq %r15, %r15
setne %al
testq %rbx, %rbx
sete %cl
testb %cl, %al
jne 0x2573
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x256a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2190
testl %eax, %eax
jne 0x2573
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ac9(%rip), %rdi      # 0x5043
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_wstr
void assert_wstr(const wchar_t *exp, const wchar_t *real, const char* caller, int line) {
    if ((exp == NULL && real != NULL) ||
        (exp != NULL && real == NULL) ||
        (exp && real && wcscmp(exp, real) != 0)) {
        CTEST_ERR("%s:%d  expected '%ls', got '%ls'", caller, line, exp, real);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0x25ec
testq %r15, %r15
setne %al
testq %rbx, %rbx
sete %cl
testb %cl, %al
jne 0x25ec
testq %r15, %r15
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x25e3
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2040
testl %eax, %eax
jne 0x25ec
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a6f(%rip), %rdi      # 0x5062
movq %r12, %rsi
movl %r14d, %edx
movq %r15, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_data
void assert_data(const unsigned char* exp, size_t expsize,
                 const unsigned char* real, size_t realsize,
                 const char* caller, int line) {
    size_t i;
    if (expsize != realsize) {
        CTEST_ERR("%s:%d  expected %" PRIuMAX " bytes, got %" PRIuMAX, caller, line, (uintmax_t) expsize, (uintmax_t) realsize);
    }
    for (i=0; i<expsize; i++) {
        if (exp[i] != real[i]) {
            CTEST_ERR("%s:%d expected 0x%02x at offset %" PRIuMAX " got 0x%02x",
                caller, line, exp[i], (uintmax_t) i, real[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %r10
cmpq %rcx, %rsi
jne 0x264b
testq %r10, %r10
je 0x262f
xorl %eax, %eax
movzbl (%rdi,%rax), %ecx
movzbl (%rdx,%rax), %r11d
cmpb %r11b, %cl
jne 0x2631
incq %rax
cmpq %rax, %r10
jne 0x2619
popq %rbp
retq
leaq 0x2a6e(%rip), %rdi      # 0x50a6
movq %r8, %rsi
movl %r9d, %edx
movq %rax, %r8
movl %r11d, %r9d
xorl %eax, %eax
callq 0x246d
movq %rcx, %rax
leaq 0x2a2e(%rip), %rdi      # 0x5083
movq %r8, %rsi
movl %r9d, %edx
movq %r10, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x246d
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_dbl_near
void assert_dbl_near(double exp, double real, double tol, const char* caller, int line) {
    double diff = exp - real;
    double absdiff = diff;
    /* avoid using fabs and linking with a math lib */
    if(diff < 0) {
      absdiff *= -1;
    }
    if (absdiff > tol) {
        CTEST_ERR("%s:%d  expected %0.3e, got %0.3e (diff %0.3e, tol %0.3e)", caller, line, exp, real, diff, tol);
    }
}

// Assembly:
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x28d0(%rip), %xmm4     # 0x5010
xorpd %xmm2, %xmm4
maxsd %xmm2, %xmm4
ucomisd %xmm3, %xmm4
ja 0x274f
retq
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movq %rdi, %rsi
leaq 0x2a03(%rip), %rdi      # 0x5162
movb $0x4, %al
callq 0x246d
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: assert_dbl_far
void assert_dbl_far(double exp, double real, double tol, const char* caller, int line) {
    double diff = exp - real;
    double absdiff = diff;
    /* avoid using fabs and linking with a math lib */
    if(diff < 0) {
      absdiff *= -1;
    }
    if (absdiff <= tol) {
        CTEST_ERR("%s:%d  expected %0.3e, got %0.3e (diff %0.3e, tol %0.3e)", caller, line, exp, real, diff, tol);
    }
}

// Assembly:
movapd %xmm2, %xmm3
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x2896(%rip), %xmm4     # 0x5010
xorpd %xmm2, %xmm4
maxsd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
jae 0x2789
retq
pushq %rbp
movq %rsp, %rbp
movl %esi, %edx
movq %rdi, %rsi
leaq 0x29c9(%rip), %rdi      # 0x5162
movb $0x4, %al
callq 0x246d
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/thirdparty/ctest.h
// Function: color_print
static void color_print(const char* color, const char* text) {
    if (color_output)
        printf("%s%s"ANSI_NORMAL"\n", color, text);
    else
        printf("%s\n", text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rdx
cmpl $0x0, 0x5577(%rip)      # 0x8128
je 0x2bc5
movq %rdi, %rsi
leaq 0x26d9(%rip), %rdi      # 0x5296
xorl %eax, %eax
popq %rbp
jmp 0x2100
movq %rdx, %rdi
popq %rbp
jmp 0x2080
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Escape_html
char* Escape_html(char* str)
{
    int len = (int)strlen(str);
    /// In the worst case, string is increased 3 times + '\0'
    char* without_html_str = (char*)calloc((len * 3) + 1, sizeof(char));
    int j = 0;
    for (int i = 0; i < len; i++, j++) {
        if (str[i] == '<') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'l';
            without_html_str[j + 2] = 't';
            j += 2;
        } else if (str[i] == '>') {
            without_html_str[j] = '&';
            without_html_str[j + 1] = 'g';
            without_html_str[j + 2] = 't';
            j += 2;
        } else {
            without_html_str[j] = str[i];
        }
    }
    without_html_str[j] = '\0';
    free(str);
    return without_html_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
movq %rax, %r15
leaq (%rax,%rax,2), %rax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
xorl %eax, %eax
testl %r15d, %r15d
jle 0x3cea
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %esi
movslq %eax, %rdx
cmpl $0x3e, %esi
je 0x3cc5
cmpl $0x3c, %esi
jne 0x3cda
movw $0x6c26, (%r14,%rdx)    # imm = 0x6C26
jmp 0x3ccc
movw $0x6726, (%r14,%rdx)    # imm = 0x6726
movb $0x74, 0x2(%r14,%rdx)
addq $0x2, %rdx
movl %edx, %eax
jmp 0x3cde
movb %sil, (%r14,%rdx)
incq %rcx
incl %eax
cmpq %rcx, %r15
jne 0x3cab
cltq
movb $0x0, (%r14,%rax)
movq %rbx, %rdi
callq 0x2030
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Get_filename_without_extension
const char* Get_filename_without_extension(char* path)
{
    char* temp_path = (char*)calloc(strlen(path), sizeof(char*));
    strcpy(temp_path, path);
    char* last_dot_ptr = strrchr(path, '.');
    if (last_dot_ptr == NULL) {
        return "";
    }
    int last_dot_index = last_dot_ptr - path;
    temp_path[last_dot_index] = '\0';
    temp_path = strrchr(temp_path, '/');
    return temp_path == NULL ? "" : temp_path + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d0
movl $0x8, %esi
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2070
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x2120
testq %rax, %rax
je 0x3d6b
subl %ebx, %eax
cltq
movb $0x0, (%r14,%rax)
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2120
leaq 0x1(%rax), %rcx
testq %rax, %rax
leaq 0x1dca(%rip), %rax      # 0x5b2f
cmovneq %rcx, %rax
jmp 0x3d72
leaq 0x1dbd(%rip), %rax      # 0x5b2f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Search_files_recursive
int Search_files_recursive(char* path, char** paths, int* recursive_exit_flag)
{
    DIR* d = opendir(path);
    if (d == NULL) {
        printf("\x1b[31m Error! \x1b[0m Wrong path\n");
        return 0;
    }
    struct dirent* dir;
    while ((dir = readdir(d)) != NULL) {
        /// Hidden and system files check
        if (dir->d_name[0] == '.') {
            continue;
        }
        if (*recursive_exit_flag == MAX_COUNT_OF_FILES) {
            return -1;
        }
        if (dir->d_type != DT_DIR) {
            char* f_path = (char*)calloc(MAX_PATH_LEN, sizeof(char));
            sprintf(f_path, "%s/%s", path, dir->d_name);
            strcpy(paths[*recursive_exit_flag], f_path);
            free(f_path);
            *recursive_exit_flag = *recursive_exit_flag + 1;
        } else if (
                dir->d_type == DT_DIR && strcmp(dir->d_name, ".") != 0
                && strcmp(dir->d_name, "..") != 0) {
            char d_path[MAX_PATH_LEN * 2];
            sprintf(d_path, "%s/%s", path, dir->d_name);
            Search_files_recursive(d_path, paths, recursive_exit_flag);
        }
    }
    closedir(d);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %rbx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
callq 0x20c0
testq %rax, %rax
je 0x3e7a
movq %rax, %r12
movq %r12, %rdi
callq 0x21c0
testq %rax, %rax
je 0x3e70
cmpb $0x2e, 0x13(%rax)
je 0x3da6
cmpl $0x1e, (%rbx)
je 0x3e9a
leaq 0x13(%rax), %r13
cmpb $0x4, 0x12(%rax)
jne 0x3e25
movq %r13, %rdi
leaq 0x1c91(%rip), %rsi      # 0x5a6b
callq 0x2190
testl %eax, %eax
je 0x3da6
movq %r13, %rdi
leaq 0x1c7d(%rip), %rsi      # 0x5a6a
callq 0x2190
testl %eax, %eax
je 0x3da6
leaq -0x230(%rbp), %r14
movq %r14, %rdi
leaq 0x1c5d(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2200
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0x3d77
jmp 0x3da6
movl $0xff, %edi
movl $0x1, %esi
callq 0x2180
movq %rax, %r14
movq %rax, %rdi
leaq 0x1c23(%rip), %rsi      # 0x5a64
movq %r15, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2200
movslq (%rbx), %rax
movq -0x30(%rbp), %rcx
movq (%rcx,%rax,8), %rdi
movq %r14, %rsi
callq 0x2070
movq %r14, %rdi
callq 0x2030
incl (%rbx)
jmp 0x3da6
movq %r12, %rdi
callq 0x2150
jmp 0x3e86
leaq 0x1d29(%rip), %rdi      # 0x5baa
callq 0x2080
xorl %eax, %eax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3e88
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Get_data_from_document
char** Get_data_from_document(char* paths)
{
    FILE* myfile;
    myfile = fopen(paths, "r");
    if (myfile == NULL) {
        printf("%s%s%s\n", "On path ", paths, " file not found!");
        return 0;
    }
    char* ptrFile;
    int quan_str = 0;
    char** data = (char**)calloc(MAX_QTY_STR, sizeof(char*));
    for (int i = 0; i < MAX_QTY_STR; i++) {
        data[i] = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
    }
    while (quan_str < MAX_QTY_STR) {
        char* temp = (char*)calloc(MAX_LEN_INP_STR, sizeof(char));
        ptrFile = fgets(temp, MAX_LEN_INP_STR, myfile);
        if (ptrFile == NULL) {
            if (feof(myfile) != 0) {
                break;
            }
        }
        strcpy(data[quan_str], temp);
        quan_str++;
        free(temp);
    }
    fclose(myfile);
    return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x1cab(%rip), %rsi      # 0x5b61
callq 0x21f0
testq %rax, %rax
je 0x3f68
movq %rax, %r14
movl $0xc350, %edi           # imm = 0xC350
movl $0x8, %esi
callq 0x2180
movq %rax, %rbx
xorl %r15d, %r15d
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0xc350, %r15           # imm = 0xC350
jne 0x3edc
xorl %r12d, %r12d
cmpl $0xc34f, %r12d          # imm = 0xC34F
jg 0x3f5e
movl $0x1f4, %edi            # imm = 0x1F4
movl $0x1, %esi
callq 0x2180
movq %rax, %r15
movq %rax, %rdi
movl $0x1f4, %esi            # imm = 0x1F4
movq %r14, %rdx
callq 0x2160
testq %rax, %rax
je 0x3f4c
movslq %r12d, %rax
movq (%rbx,%rax,8), %rdi
movq %r15, %rsi
callq 0x2070
incl %r12d
movq %r15, %rdi
callq 0x2030
movb $0x1, %al
jmp 0x3f5a
movq %r14, %rdi
callq 0x21a0
testl %eax, %eax
je 0x3f2e
xorl %eax, %eax
testb %al, %al
jne 0x3efe
movq %r14, %rdi
callq 0x20b0
jmp 0x3f89
leaq 0x1afe(%rip), %rdi      # 0x5a6d
leaq 0x1aff(%rip), %rsi      # 0x5a75
leaq 0x1b01(%rip), %rcx      # 0x5a7e
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2100
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Print_help
void Print_help()
{
    printf("%s\n%s\n",
           "usage: documentary [--version] [--help]",
           "\t  [-inpdir <path>] [-outdir <path>]");
    printf("%s\n", "Available commands");
    printf("\t%s\n", "-inpdir");
    printf("\t%s\n", "-outdir");
    printf("\t%s\n", "--help");
    printf("\t%s\n", "--version");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x1acb(%rip), %rdi      # 0x5a8f
leaq 0x1acb(%rip), %rsi      # 0x5a96
leaq 0x1aec(%rip), %rdx      # 0x5abe
xorl %eax, %eax
callq 0x2100
leaq 0x1b03(%rip), %rdi      # 0x5ae3
callq 0x2080
leaq 0x1b0a(%rip), %rbx      # 0x5af6
leaq 0x12fa(%rip), %rsi      # 0x52ed
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x12f7(%rip), %rsi      # 0x52fb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x1317(%rip), %rsi      # 0x532c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2100
leaq 0x12fc(%rip), %rsi      # 0x5322
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2100
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/utilities.c
// Function: Check_argc
int Check_argc(int argc, char** array_argv)
{
    if (argc == 1) {
        printf("%s\n%s\n",
               "usage: documentary [--version] [--help]",
               "\t  [-inpdir <path>] [-outdir <path>]");
        return 0;
    }
    if (argc > 5 || argc == 4) {
        printf("Error! Invalid number of arguments");
        return 0;
    }
    if (argc == 2) {
        if (strcmp(array_argv[1], HELP_FLAG) == 0) {
            Print_help();
            return 0;
        }
        if (strcmp(array_argv[1], VERSION_FLAG) == 0) {
            printf("%s\n", PROGRAM_VERSION);
            return 0;
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jne 0x4062
leaq 0x1a46(%rip), %rdi      # 0x5a8f
leaq 0x1a46(%rip), %rsi      # 0x5a96
leaq 0x1a67(%rip), %rdx      # 0x5abe
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x40cd
cmpl $0x6, %edi
setl %al
cmpl $0x4, %edi
setne %cl
testb %cl, %al
jne 0x4084
leaq 0x1a82(%rip), %rdi      # 0x5afb
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2100
jmp 0x40cd
movl $0x1, %ebx
cmpl $0x2, %edi
jne 0x40cd
movq 0x8(%rsi), %r14
leaq 0x1293(%rip), %rsi      # 0x532c
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
je 0x40c6
leaq 0x1276(%rip), %rsi      # 0x5322
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x40cd
leaq 0x1a5f(%rip), %rdi      # 0x5b1e
callq 0x2080
jmp 0x40cb
callq 0x3fb7
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/comments_check.c
// Function: Check_single_comment
int Check_single_comment(char* str)
{
    size_t len = strlen(str);
    for (unsigned int i = 0; i < len; i++) {
        if (str[i] == '/' && str[i + 1] == '/') {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
testq %rax, %rax
setne %cl
je 0x4291
movl $0x1, %edx
xorl %esi, %esi
cmpb $0x2f, (%rbx,%rsi)
movl %edx, %esi
jne 0x4287
cmpb $0x2f, (%rbx,%rsi)
je 0x4291
incl %edx
cmpq %rsi, %rax
seta %cl
ja 0x4279
movzbl %cl, %eax
andl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_begin
char* Del_multiline_comment_begin(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '/' && str[i + 1] == '*') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2f, %edx
je 0x4360
testl %edx, %edx
jne 0x436b
jmp 0x4370
cmpb $0x2a, (%rcx)
jne 0x436b
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x4351
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_end
char* Del_multiline_comment_end(char* str)
{
    for (int i = 0; str[i] != '\0'; i++) {
        if (str[i] == '*' && str[i + 1] == '/') {
            str[i] = ' ';
            str[i + 1] = ' ';
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x1(%rdi), %rcx
movzbl -0x1(%rcx), %edx
cmpl $0x2a, %edx
je 0x438c
testl %edx, %edx
jne 0x4397
jmp 0x439c
cmpb $0x2f, (%rcx)
jne 0x4397
movw $0x2020, -0x1(%rcx)     # imm = 0x2020
incq %rcx
jmp 0x437d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/comments_delete.c
// Function: Del_multiline_comment_stars
char* Del_multiline_comment_stars(char* str)
{
    for (unsigned int i = 0; i < strlen(str); i++) {
        if (str[i] != ' ' && str[i] != '*') {
            break;
        } else if (str[i] != ' ' && str[i] == '*') {
            str[i] = ' ';
            break;
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d0
testq %rax, %rax
je 0x43d5
movl $0x1, %edx
xorl %ecx, %ecx
movzbl (%rbx,%rcx), %esi
cmpl $0x20, %esi
jne 0x43cc
movl %edx, %ecx
incl %edx
cmpq %rcx, %rax
ja 0x43b8
jmp 0x43d5
cmpl $0x2a, %esi
jne 0x43d5
movb $0x20, (%rbx,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/advanced_check.c
// Function: Check_extension
int Check_extension(char* path)
{
    char* valid_extentions[QTY_OF_EXTENSION] = {"cpp", "h", "c"};
    char* temp = Get_file_extension(path);
    for (int i = 0; i < QTY_OF_EXTENSION; i++) {
        if (strcmp(temp, valid_extentions[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x3f95
movq %rax, %rbx
leaq 0xf45(%rip), %rsi       # 0x533e
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
je 0x443a
xorl %ecx, %ecx
leaq 0x17ba(%rip), %r14      # 0x5bc8
movq %rcx, %r15
cmpq $0x2, %rcx
je 0x442f
movslq 0x4(%r14,%r15,4), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x2190
leaq 0x1(%r15), %rcx
testl %eax, %eax
jne 0x440e
xorl %eax, %eax
cmpq $0x2, %r15
setb %al
jmp 0x443f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/advanced_handle.c
// Function: Generate_filename
char* Generate_filename(char* path, char* dest_dir)
{
    long int s_time = 0;
    struct tm* m_time;
    s_time = time(NULL);
    m_time = localtime(&s_time);
    char* str_time = asctime(m_time);
    for (int i = 0; str_time[i] != '\0'; i++) {
        if (str_time[i] == ' ') {
            str_time[i] = '_';
        }
    }
    size_t len = strlen(str_time) - 1;
    if (str_time[len] == '\n') {
        str_time[len] = '\0';
    }
    int max_time_len = 50;
    char* filename = (char*)calloc((strlen(path) + max_time_len), sizeof(char));
    sprintf(filename,
            "%s%s%s%s%s%s",
            dest_dir,
            "/",
            Get_filename_without_extension(path),
            "_",
            str_time,
            ".html");
    return filename;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %r15
movq $0x0, (%r15)
xorl %edi, %edi
callq 0x21b0
movq %rax, (%r15)
movq %r15, %rdi
callq 0x2050
movq %rax, %rdi
callq 0x20e0
movq %rax, %r15
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x4513
testl %ecx, %ecx
jne 0x4516
jmp 0x451b
movb $0x5f, (%rax)
incq %rax
jmp 0x4505
movq %r15, %rdi
callq 0x20d0
cmpb $0xa, -0x1(%r15,%rax)
jne 0x4531
movb $0x0, -0x1(%r15,%rax)
movq %r14, %rdi
callq 0x20d0
leaq 0x32(%rax), %rdi
movl $0x1, %esi
callq 0x2180
movq %rax, %r12
movq %r14, %rdi
callq 0x3d05
leaq 0x176d(%rip), %r10      # 0x5cc6
leaq 0x1674(%rip), %rsi      # 0x5bd4
leaq 0x1037(%rip), %rcx      # 0x559e
leaq 0x1673(%rip), %r9       # 0x5be1
movq %r12, %rdi
movq %rbx, %rdx
movq %rax, %r8
xorl %eax, %eax
pushq %r10
pushq %r15
callq 0x2200
addq $0x10, %rsp
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/advanced_handle.c
// Function: Get_document_type
char* Get_document_type(char* path)
{
    char* extension = Get_file_extension(path);
    if (!strcmp(extension, "h")) {
        return "<i>Header file to program code on C/C++</i></br></br>";
    } else if (!strcmp(extension, "c")) {
        return "<i>Program code in language C</i></br></br>";
    } else if (!strcmp(extension, "cpp")) {
        return "<i>Program code in language C++</i></br></br>";
    }
    return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x3f95
movq %rax, %rbx
leaq 0x1264(%rip), %rsi      # 0x580f
movq %rax, %rdi
callq 0x2190
testl %eax, %eax
je 0x45ef
leaq 0x1315(%rip), %rsi      # 0x58d3
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
je 0x45f8
leaq 0xd6d(%rip), %rsi       # 0x533e
movq %rbx, %rdi
callq 0x2190
testl %eax, %eax
leaq 0x1663(%rip), %rcx      # 0x5c45
leaq 0x1546(%rip), %rax      # 0x5b2f
cmoveq %rcx, %rax
jmp 0x45ff
leaq 0x15ed(%rip), %rax      # 0x5be3
jmp 0x45ff
leaq 0x161a(%rip), %rax      # 0x5c19
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/morozov312[P]documentary/./src/processing.c
// Function: Check_code
int Check_code(char* str)
{
    int single_flag = Check_single_comment(str);
    int multiline_begin_flag = Check_multiline_comment_begin(str);
    int multiline_end_flag = Check_multiline_comment_end(str);
    if (!single_flag && !multiline_begin_flag && !multiline_end_flag) {
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x425c
movl %eax, %r14d
movq %rbx, %rdi
callq 0x429e
movl %eax, %r15d
movq %rbx, %rdi
callq 0x42e0
orl %r14d, %r15d
xorl %ecx, %ecx
orl %eax, %r15d
sete %cl
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mflatt[P]gc-demo/refcount/refcount.c
// Function: refcount_dec
void refcount_dec(struct node *p)
{
  if (p) {
    /* Decrement the reference count, and free if it does to zero */
    struct rc_node *rn = NODE_TO_RC(p);
    if (--rn->count == 0) {
      refcount_dec(rn->n.left);
      refcount_dec(rn->n.right);
      raw_free(rn, sizeof(struct rc_node));
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1354
movq %rdi, %rbx
decl -0x8(%rdi)
je 0x135c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq -0x8(%rbx), %r14
movq (%rbx), %rdi
callq 0x1343
movq 0x8(%rbx), %rdi
callq 0x1343
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x130e
// File: /workspace/github_c_makefile_star2_O1/orangeduck[P]mpc/examples/maths.c
// Function: main
int main(int argc, char **argv) {
  
  mpc_parser_t *Expr  = mpc_new("expression");
  mpc_parser_t *Prod  = mpc_new("product");
  mpc_parser_t *Value = mpc_new("value");
  mpc_parser_t *Maths = mpc_new("maths");
  
  mpca_lang(MPCA_LANG_PREDICTIVE,
    " expression : <product> (('+' | '-') <product>)*; "
    " product : <value>   (('*' | '/')   <value>)*;    "
    " value : /[0-9]+/ | '(' <expression> ')';         "
    " maths : /^/ <expression> /$/;                    ",
    Expr, Prod, Value, Maths, NULL);
  
  mpc_print(Expr);
  mpc_print(Prod);
  mpc_print(Value);
  mpc_print(Maths);
  
  if (argc > 1) {
    
    mpc_result_t r;
    if (mpc_parse_contents(argv[1], Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
    
  } else {

    mpc_result_t r;
    if (mpc_parse_pipe("<stdin>", stdin, Maths, &r)) {
      mpc_ast_print(r.output);
      mpc_ast_delete(r.output);
    } else {
      mpc_err_print(r.error);
      mpc_err_delete(r.error);
    }
  
  }

  mpc_cleanup(4, Expr, Prod, Value, Maths);
  
  return 0;
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movl %edi, %ebp
leaq 0x9cce(%rip), %rdi      # 0xb004
callq 0x2f65
movq %rax, %rbx
leaq 0x9cca(%rip), %rdi      # 0xb00f
callq 0x2f65
movq %rax, %r14
leaq 0x9cc3(%rip), %rdi      # 0xb017
callq 0x2f65
movq %rax, %r15
leaq 0x9cba(%rip), %rdi      # 0xb01d
callq 0x2f65
movq %rax, %r12
movq $0x0, (%rsp)
leaq 0x9ca9(%rip), %rsi      # 0xb023
movl $0x1, %edi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x8b6c
movq %rbx, %rdi
callq 0x62dd
movq %r14, %rdi
callq 0x62dd
movq %r15, %rdi
callq 0x62dd
movq %r12, %rdi
callq 0x62dd
cmpl $0x2, %ebp
jl 0x13cd
movq 0x8(%r13), %rdi
leaq 0x10(%rsp), %r13
movq %r12, %rsi
movq %r13, %rdx
callq 0x2d2d
jmp 0x13ee
movq 0xec0c(%rip), %rax      # 0xffe0
movq (%rax), %rsi
leaq 0x9d0e(%rip), %rdi      # 0xb0ec
leaq 0x10(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0x2c65
movq (%r13), %rdi
testl %eax, %eax
je 0x1407
callq 0x6d52
movq 0x10(%rsp), %rdi
callq 0x68eb
jmp 0x1416
callq 0x1493
movq 0x10(%rsp), %rdi
callq 0x1440
movl $0x4, %edi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x33b4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/mgrosvenor[P]evec/demo2.c
// Function: main
int main(int argc, char** argv)
{
    void* a = evinisz(128);
    evpsh(a, "Test");
    evpsh(a, "Best");
    evpsh(a, "Rest");

    for(int i =0; i < evcnt(a); i++){
        char* s = (char*)evidx(a,i);
        printf("%i: %s\n", i, s);
    }

    a = evfree(a);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl $0x80, %edi
movl $0x8, %esi
callq 0x1284
leaq 0x9fa(%rip), %rsi       # 0x2380
movl $0x5, %edx
movq %rax, %rdi
callq 0x1656
leaq 0x9eb(%rip), %rsi       # 0x2385
movl $0x5, %edx
movq %rax, %rdi
callq 0x1656
leaq 0x9dc(%rip), %rsi       # 0x238a
movl $0x5, %edx
movq %rax, %rdi
callq 0x1656
movq %rax, %rbx
movq %rax, %rdi
callq 0x1725
testq %rax, %rax
je 0x1a00
leaq 0x9bd(%rip), %r14       # 0x238f
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1766
movq %r14, %rdi
movl %r15d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1050
incq %r15
movq %rbx, %rdi
callq 0x1725
cmpq %r15, %rax
ja 0x19d5
movq %rbx, %rdi
callq 0x1925
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/zhoudian64[P]OS2-exp/locker.c
// Function: main
int main() {
	int fd = open ("./lock", O_RDONLY | O_CREAT, 0666);
	while (1) {
		getchar();
	// 非共享🔒
		flock(fd, LOCK_EX);
		printf("Lock!\n");
		getchar();
		flock(fd, LOCK_UN);
		printf("UnLock!\n");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xe87(%rip), %rdi       # 0x2004
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1050
movl %eax, %ebx
leaq 0xe76(%rip), %r14       # 0x200d
leaq 0xe6d(%rip), %r15       # 0x200b
callq 0x1040
movl %ebx, %edi
movl $0x2, %esi
callq 0x1060
movq %r14, %rdi
callq 0x1030
callq 0x1040
movl %ebx, %edi
movl $0x8, %esi
callq 0x1060
movq %r15, %rdi
callq 0x1030
jmp 0x119e
// File: /workspace/github_c_makefile_star2_O1/kisom[P]kam/queue.c
// Function: dequeue8
uint8_t
dequeue8(queue8 q)
{
	struct node8	*node;
	uint8_t	val;

	if (NULL == q->head)
		abort();

	node = q->head;
	val = node->val;

	q->head = node->next;
	free(node);
	q->nodes--;
	if (0 == q->nodes)
		q->tail = NULL;
	return val;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x12e1
movb (%rdi), %bpl
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
decq 0x10(%rbx)
jne 0x12d8
movq $0x0, 0x8(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/kisom[P]kam/qtest.c
// Function: main
static void
test_queue8(void)
{
	uint8_t val;
	queue8	st;

	st = new_queue8();
	if (st == NULL) {
		errx(EX_OSERR, "FAILED: malloc failure");
	}

	enqueue8(st, 1);
	enqueue8(st, 2);
	if (1 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 2 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}

	enqueue8(st, 3);
	if (2 != (val = dequeue8(st))) {
		fprintf(stderr,
		    "FAILED: should have received 3 from the queue.\n");
		fprintf(stderr,
		    "        (received %d)\n", val);
		exit(EXIT_FAILURE);
	}
	if (3 != (val = dequeue8(st)))
		errx(EX_SOFTWARE,
		    "FAILED: should have received 1 from the queue.");
	if (!empty_queue8(st))
		errx(EX_SOFTWARE,
		    "FAILED: queue should report empty.");
	enqueue8(st, 5);
	enqueue8(st, 5);
	destroy_queue8(st);
	printf("queue8: OK\n");
}

// Assembly:
pushq %rbx
callq 0x122c
testq %rax, %rax
je 0x14f3
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0x1251
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1251
movq %rbx, %rdi
callq 0x12ad
cmpb $0x1, %al
jne 0x1501
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1251
movq %rbx, %rdi
callq 0x12ad
cmpb $0x2, %al
jne 0x1509
movq %rbx, %rdi
callq 0x12ad
cmpb $0x3, %al
jne 0x1511
movq %rbx, %rdi
callq 0x12e6
testl %eax, %eax
je 0x151a
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1251
movq %rbx, %rdi
movl $0x5, %esi
callq 0x1251
movq %rbx, %rdi
callq 0x12f1
leaq 0xbfa(%rip), %rdi       # 0x20e4
callq 0x1050
xorl %eax, %eax
popq %rbx
retq
leaq 0xb0a(%rip), %rsi       # 0x2004
movl $0x47, %edi
jmp 0x1526
movzbl %al, %edi
callq 0x10c0
movzbl %al, %edi
callq 0x10ff
leaq 0xb7a(%rip), %rsi       # 0x2092
jmp 0x1521
leaq 0xba0(%rip), %rsi       # 0x20c1
movl $0x46, %edi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/minkcv[P]vm/assembler.c
// Function: countInstructions
int countInstructions(FILE* src)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if (line[0] != '\n' && line[0] != '@' && line[0] != ';')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
        }
        free(line);
        line = NULL; // Causes getline to keep reading
    }
    rewind(src);
    return instrCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq -0x38(%rbp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1c3b
xorl %r14d, %r14d
leaq -0x30(%rbp), %r12
leaq -0x38(%rbp), %r13
movabsq $0x42000000000001, %r15 # imm = 0x42000000000001
movq -0x30(%rbp), %rdi
movzbl (%rdi), %eax
addl $-0xa, %eax
cmpl $0x36, %eax
ja 0x1bec
btq %rax, %r15
jb 0x1c12
leaq 0x46e(%rip), %rsi       # 0x2061
callq 0x1130
movq %rax, %rdi
leaq 0x45b(%rip), %rsi       # 0x205d
callq 0x10c0
cmpl $0x1, %eax
adcw $0x0, %r14w
incl %r14d
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x30(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1150
cmpq $-0x1, %rax
jne 0x1bd7
movzwl %r14w, %r14d
movq %rbx, %rdi
callq 0x10b0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/minkcv[P]vm/assembler.c
// Function: createLabelMap
void createLabelMap(FILE* src, LabelAddress*** labelMap)
{
    char* line = NULL;
    size_t toRead = 0; // Read until \n
    ssize_t charsRead;
    int labelCount = 0;
    uint16_t instrCount = 0;
    while ((charsRead = getline(&line, &toRead, src)) != -1)
    {
        if(line[0] == '@')
        {
            // Create the label entry in labelMap
            char* start = line;
            char* beforeAt = strsep(&line, "@");
            char* labelName = strsep(&line, " ;\n"); // Trim any comments or other text off the end
            LabelAddress* labeladdr = malloc(sizeof(LabelAddress));
            labeladdr->label = malloc(sizeof(char) * (strlen(labelName) + 1));
            strcpy(labeladdr->label, labelName);
            labeladdr->segAddr = instrCount / JUMP_SEGMENT_SIZE;
            labeladdr->offsetAddr = instrCount % JUMP_SEGMENT_SIZE;
            (*labelMap)[labelCount] = labeladdr;
            labelCount++;
            free(start);
            start = NULL;
            labelName = NULL;
            beforeAt = NULL;
            line = NULL;
        }
        else if (line[0] != ';' && line[0] != '\n')
        {
            char* token = strtok(line, " ");
            if (!strcmp(token, "LRL"))
                instrCount++;
            instrCount++;
            free(line);
            line = NULL;
        }
        else
        {
            free(line);
            line = NULL;
        }
    }
    rewind(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %r14
xorl %r15d, %r15d
leaq -0x30(%rbp), %rdi
movq %r15, (%rdi)
leaq -0x40(%rbp), %rsi
movq %r15, (%rsi)
movq %r14, %rdx
callq 0x1150
cmpq $-0x1, %rax
je 0x1d9e
leaq -0x30(%rbp), %rbx
leaq -0x40(%rbp), %r12
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %r13
movzbl (%r13), %eax
cmpl $0xa, %eax
je 0x1d43
cmpl $0x3b, %eax
je 0x1d43
cmpl $0x40, %eax
jne 0x1d48
movq %rbx, %rdi
leaq 0x396(%rip), %rsi       # 0x2063
callq 0x1100
movq %rbx, %rdi
leaq 0x37d(%rip), %rsi       # 0x2059
callq 0x1100
movq %r15, %rbx
movq %r14, %r15
movq %rax, %r14
movl $0x10, %edi
callq 0x10f0
movq %rax, %r12
movq %r14, %rdi
callq 0x1090
leaq 0x1(%rax), %rdi
callq 0x10f0
movq %rax, 0x8(%r12)
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %r14
movq %rbx, %r15
leaq -0x30(%rbp), %rbx
callq 0x1050
movl -0x34(%rbp), %eax
rolw $0x8, %ax
movw %ax, (%r12)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq %r15d, %r15
movq %r12, (%rax,%r15,8)
leaq -0x40(%rbp), %r12
incl %r15d
movq %r13, %rdi
jmp 0x1d79
movq %r13, %rdi
leaq 0x30f(%rip), %rsi       # 0x2061
callq 0x1130
movq %rax, %rdi
leaq 0x2fc(%rip), %rsi       # 0x205d
callq 0x10c0
cmpl $0x1, %eax
movl -0x34(%rbp), %eax
adcw $0x0, %ax
incl %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1030
movq $0x0, -0x30(%rbp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1150
cmpq $-0x1, %rax
jne 0x1c9f
movq %r14, %rdi
callq 0x10b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/minkcv[P]vm/assembler.c
// Function: getAddressesOfLabel
void getAddressesOfLabel(char* label, LabelAddress* labelMap[MAX_LABELS], uint8_t* segAddr, uint8_t* offsetAddr)
{
    int i;
    for (i = 0; i < MAX_LABELS; i++)
    {
        LabelAddress* current = labelMap[i];
        if (current != NULL && current->label != NULL)
        {
            if (!strcmp(current->label, label))
            {
                *segAddr = current->segAddr;
                *offsetAddr = current->offsetAddr;
                return;
            }
        }
    }
    printf("Error: Label \"%s\" not defined\n", label);
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbx
testq %rbx, %rbx
je 0x1df1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1df1
movq %r14, %rsi
callq 0x10c0
testl %eax, %eax
je 0x1e18
incq %r13
cmpq $0x400, %r13            # imm = 0x400
jne 0x1dd3
leaq 0x310(%rip), %rdi       # 0x2114
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
movl $0x1, %edi
callq 0x1160
movb (%rbx), %al
movb %al, (%r15)
movb 0x1(%rbx), %al
movq -0x30(%rbp), %rcx
movb %al, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/giometti[P]mastering_UNIX_programming/chapter_08/atexit.c
// Function: main
int main(void)
{
	long atexit_max;
	int ret;

#ifdef ATEXIT_MAX
	atexit_max = ATEXIT_MAX;
#else
	errno = 0;
	atexit_max = sysconf(_SC_ATEXIT_MAX);
	if (atexit_max < 0) {
		if (errno == 0) {
			fprintf(stderr, "_SC_ATEXIT_MAX limit not supported\n");
		} else {
			perror("sysconf");
			return -1;
		}
	}
#endif
	printf("ATEXIT_MAX = %ld\n", atexit_max);

	ret = atexit(func1);
	if (ret) {
		fprintf(stderr, "cannot set atexit func1\n");
		return -1;
	}

	ret = atexit(func2);
	if (ret) {
		fprintf(stderr, "cannot set atexit func2\n");
		return -1;
	}

	printf("press ENTER to continue >");
	getchar();

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x1030
movq %rax, %r14
movl $0x0, (%rax)
movl $0x57, %edi
callq 0x1080
movq %rax, %rbx
testq %rax, %rax
js 0x1298
leaq 0xde1(%rip), %rdi       # 0x2030
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
leaq -0x54(%rip), %rdi       # 0x120c
callq 0x12d0
testl %eax, %eax
jne 0x12a5
leaq -0x58(%rip), %rdi       # 0x1218
callq 0x12d0
testl %eax, %eax
jne 0x12ac
leaq 0xdf4(%rip), %rdi       # 0x2074
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1050
callq 0x1060
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, (%r14)
jne 0x12b3
callq 0x10c0
jmp 0x1248
callq 0x10dc
jmp 0x12bf
callq 0x10f8
jmp 0x12bf
leaq 0xd6e(%rip), %rdi       # 0x2028
callq 0x1070
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x128e
nopw %cs:(%rax,%rax)