LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_printPara
void BLOB_printPara(BLOB_s *pBolb)
{	
	printf("num:     %ld\n",pBolb->numSize);
	printf("channel: %ld\n",pBolb->channelSize);
	printf("height:  %ld\n",pBolb->heightSize);
	printf("width:   %ld\n",pBolb->widthSize);
	printf("size:    %ld\n",pBolb->count);
	printf("bytes:   %ld\n",pBolb->count*sizeof(BLOB_DATA_TYPE));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xb0a(%rip), %rdi       # 0x3165
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0xb02(%rip), %rdi       # 0x3173
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xafa(%rip), %rdi       # 0x3181
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq 0xaf2(%rip), %rdi       # 0x318f
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
leaq 0xaea(%rip), %rdi       # 0x319d
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
shlq $0x3, %rsi
leaq 0xade(%rip), %rdi       # 0x31ab
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_val
BLOB_DATA_TYPE BLOB_val(BLOB_s *pBlob,unsigned long num,unsigned long channel,
								unsigned long height,unsigned long width)
{
#if 0
	unsigned long offset = pBolb->batcheSize*batches + num*pBolb->numSize + \
		width*pBolb->widthSize + height*pBolb->heightSize + channel;
	return *(pBolb->data + offset);
#else
	BLOB_DATA_TYPE (*ptr)[pBlob->channelSize][pBlob->heightSize][pBlob->widthSize] = \
	(BLOB_DATA_TYPE (*)[pBlob->channelSize][pBlob->heightSize][pBlob->widthSize])pBlob->data;
	return ptr[num][channel][height][width];
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
imulq %rsi, %rdi
imulq %rcx, %rdi
imulq %rdi, %rdx
shlq $0x3, %rdx
addq %rdx, %rax
movq -0x18(%rbp), %rdx
imulq %rcx, %rsi
imulq %rsi, %rdx
shlq $0x3, %rdx
addq %rdx, %rax
imulq -0x20(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aparrish[P]rwet-examples-c/markov.c
// Function: main
int main(int argc, char** argv) {

	int len, n, i, line_count;
	char* line;
	markov_gen_t* gen;

	if (argc != 3) {
		fprintf(stderr, "usage: markov n line_count\n");
		exit(-1);
	}

	n = atoi(argv[1]);
	line_count = atoi(argv[2]);

	gen = markov_gen_new(n, 100);
	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		markov_gen_feed(gen, line);
		free(line);
	}

	/* uncomment to dump markov chain data */
	/*markov_gen_dump(gen);*/

	for (i = 0; i < line_count; i++) {
		markov_gen_generate_new(gen, &line);
		printf("%s\n", line);
		free(line);
	}

	markov_gen_free(gen);

	return 0;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x129e
movq 0x5d75(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
leaq 0x3d77(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x1090
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1120
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1100
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1100
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movl $0x64, %esi
callq 0x19b0
movq %rax, -0x30(%rbp)
movq 0x5d02(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
callq 0x10a0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12ec
jmp 0x131a
movq 0x5ce5(%rip), %rax      # 0x6fd8
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x4910
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a60
movq -0x28(%rbp), %rdi
callq 0x1030
jmp 0x12cf
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x135c
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3470
movq -0x28(%rbp), %rsi
leaq 0x3d93(%rip), %rdi      # 0x50d4
movb $0x0, %al
callq 0x1060
movq -0x28(%rbp), %rdi
callq 0x1030
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1321
movq -0x30(%rbp), %rdi
callq 0x4330
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aparrish[P]rwet-examples-c/markov_gen.c
// Function: markov_gen_new
markov_gen_t* markov_gen_new(int n, int max) {
	markov_gen_t* mg;
	mg = (markov_gen_t*)malloc(sizeof(markov_gen_t));
	mg->n = n;
	mg->max = max;
	mg->ngrams = NULL;
	utarray_new(mg->beginnings, &ptr_icd);
	return mg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x18, %edi
callq 0x10c0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x30, %edi
callq 0x10c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1070
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x569d(%rip), %rcx      # 0x70c0
movq %rcx, 0x8(%rax)
movq 0x569a(%rip), %rcx      # 0x70c8
movq %rcx, 0x10(%rax)
movq 0x5697(%rip), %rcx      # 0x70d0
movq %rcx, 0x18(%rax)
movq 0x5694(%rip), %rcx      # 0x70d8
movq %rcx, 0x20(%rax)
jmp 0x1a4a
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/spin.c
// Function: main
int main() {
	dthread_t th1, th2, th3, th4; 
	int a1,a2,a3,a4;
    dthread_init();
    printf("\n\n");

	a1 = dthread_create(&th1, thread1, NULL);
	a2 = dthread_create(&th2, thread2, NULL);
	a3 = dthread_create(&th3, thread3, NULL);
	a4 = dthread_create(&th4, thread4, NULL);
	if(a1 != 0 || a2 != 0 || a3 !=0 || a4 != 0) {
		printf("Error in creation \n");
		return 0;
	}
	sleep(2);
	run = 0;
	dthread_join(th1, NULL);
	dthread_join(th2, NULL);
	dthread_join(th2, NULL);
	dthread_join(th2, NULL);

	if(c == c1 + c2 + c3 + c4) {
		printf(GREEN "**PASSED**: Spin lock test for race problem between 4 threads\n" NONE);
	}
	else {
		printf(RED "**FAILED**: Spin lock test for race problem between 4 threads\n" NONE);
	}

    // printf("\n%ld %ld %ld %ld %ld %ld\n", c, c1+c2+c3+c4 , c1, c2, c3, c4);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
callq 0x1200
leaq 0x326(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1080
leaq -0x10(%rbp), %rdi
leaq -0x1ad(%rip), %rsi      # 0x1b80
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x164(%rip), %rsi      # 0x1be0
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl %eax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x11b(%rip), %rsi      # 0x1c40
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0xd2(%rip), %rsi       # 0x1ca0
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x1d96
cmpl $0x0, -0x30(%rbp)
jne 0x1d96
cmpl $0x0, -0x34(%rbp)
jne 0x1d96
cmpl $0x0, -0x38(%rbp)
je 0x1db0
leaq 0x2a7(%rip), %rdi       # 0x2044
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
jmp 0x1e46
movl $0x2, %edi
callq 0x10f0
movq $0x0, 0x22cb(%rip) # 0x4090
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq 0x22b8(%rip), %rax      # 0x40b8
movq 0x22b9(%rip), %rcx      # 0x40c0
addq 0x22ba(%rip), %rcx      # 0x40c8
addq 0x22bb(%rip), %rcx      # 0x40d0
addq 0x22bc(%rip), %rcx      # 0x40d8
cmpq %rcx, %rax
jne 0x1e31
leaq 0x230(%rip), %rdi       # 0x2058
movb $0x0, %al
callq 0x1080
jmp 0x1e3f
leaq 0x26c(%rip), %rdi       # 0x20a4
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jeske[P]Clearsilver/perl/ClearSilver.c
// Function: XS_ClearSilver__CS_displayError
XS_EUPXS(XS_ClearSilver__CS_displayError)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "cs");
    {
	ClearSilver__CS	cs;

	if (SvROK(ST(0)) && sv_derived_from(ST(0), "ClearSilver::CS")) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    cs = INT2PTR(ClearSilver__CS,tmp);
	}
	else
	    Perl_croak_nocontext("%s: %s is not of type %s",
			"ClearSilver::CS::displayError",
			"cs", "ClearSilver::CS")
;
#line 397 "ClearSilver.xs"
	nerr_log_error(cs->err);
#line 982 "ClearSilver.c"
    }
    XSRETURN_EMPTY;
}

// Assembly:
endbr64
pushq %r14
pushq %r13
movq %rsi, %r13
pushq %r12
pushq %rbp
pushq %rbx
movq 0x5f7a(%rip), %rbx      # 0x8fe0
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq (%rax), %rbp
callq 0x2400
movl (%rbx), %edi
movq 0x70(%rax), %rdx
leaq -0x4(%rdx), %rcx
movq %rcx, 0x70(%rax)
movslq (%rdx), %r14
callq 0x2400
movq 0x18(%rax), %rax
leaq (%rax,%r14,8), %rax
subq %rax, %rbp
sarq $0x3, %rbp
cmpl $0x1, %ebp
jne 0x31c0
movl (%rbx), %edi
leal 0x1(%r14), %r12d
movslq %r12d, %rbp
callq 0x2400
leaq (,%rbp,8), %r12
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
testb $0x8, 0xd(%rax)
je 0x319a
movl (%rbx), %edi
leaq 0x3f35(%rip), %r13      # 0x700b
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %r14
callq 0x2400
movq %r13, %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x23f0
testb %al, %al
je 0x31a1
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %eax
andl $0x200100, %eax         # imm = 0x200100
cmpl $0x100, %eax            # imm = 0x100
je 0x3180
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rbp
callq 0x2400
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x23b0
movq 0x8(%rax), %rdi
callq 0x24f0
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rbp
callq 0x2400
leaq -0x8(%rbp,%r12), %rdx
movq %rdx, (%rax)
popq %rbx
popq %rbp
popq %r12
popq %r13
popq %r14
retq
nopl (%rax,%rax)
callq 0x2400
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
jmp 0x314c
leaq 0x3e6a(%rip), %r13      # 0x700b
movq %r13, %rcx
leaq 0x3e70(%rip), %rdx      # 0x701b
leaq 0x3ef0(%rip), %rsi      # 0x70a2
xorl %eax, %eax
leaq 0x3e80(%rip), %rdi      # 0x703b
callq 0x2570
leaq 0x3e54(%rip), %rsi      # 0x701b
movq %r13, %rdi
callq 0x2510
nop
// File: /workspace/github_c_makefile_star2_O0/jeske[P]Clearsilver/perl/ClearSilver.c
// Function: XS_ClearSilver__CS_DESTROY
XS_EUPXS(XS_ClearSilver__CS_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "cs");
    {
	ClearSilver__CS	cs;

	if (SvROK(ST(0))) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    cs = INT2PTR(ClearSilver__CS,tmp);
	}
	else
	    Perl_croak_nocontext("%s: %s is not a reference",
			"ClearSilver::CS::DESTROY",
			"cs")
;
#line 390 "ClearSilver.xs"
	debug("perlcs_DESTROY() is called\n");
	cs_destroy(&(cs->cs));
#line 956 "ClearSilver.c"
    }
    XSRETURN_EMPTY;
}

// Assembly:
endbr64
pushq %r14
pushq %r13
movq %rsi, %r13
pushq %r12
pushq %rbp
pushq %rbx
movq 0x5dfa(%rip), %rbx      # 0x8fe0
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq (%rax), %r12
callq 0x2400
movl (%rbx), %edi
movq 0x70(%rax), %rdx
leaq -0x4(%rdx), %rcx
movq %rcx, 0x70(%rax)
movslq (%rdx), %r14
callq 0x2400
movq 0x18(%rax), %rax
leaq (%rax,%r14,8), %rax
subq %rax, %r12
sarq $0x3, %r12
cmpl $0x1, %r12d
jne 0x32fe
movl (%rbx), %edi
leal 0x1(%r14), %ebp
movslq %ebp, %rbp
callq 0x2400
leaq (,%rbp,8), %r12
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
testb $0x8, 0xd(%rax)
je 0x32e2
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %eax
andl $0x200100, %eax         # imm = 0x200100
cmpl $0x100, %eax            # imm = 0x100
je 0x32c8
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rbp
callq 0x2400
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x23b0
movq %rax, %rdi
callq 0x2440
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rbp
callq 0x2400
leaq -0x8(%rbp,%r12), %rdx
movq %rdx, (%rax)
popq %rbx
popq %rbp
popq %r12
popq %r13
popq %r14
retq
nopl (%rax)
callq 0x2400
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
jmp 0x329d
leaq 0x3d32(%rip), %rdx      # 0x701b
leaq 0x3dd0(%rip), %rsi      # 0x70c0
xorl %eax, %eax
leaq 0x3de0(%rip), %rdi      # 0x70d9
callq 0x2570
leaq 0x3d16(%rip), %rsi      # 0x701b
movq %r13, %rdi
callq 0x2510
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeske[P]Clearsilver/perl/ClearSilver.c
// Function: XS_ClearSilver__HDF_DESTROY
XS_EUPXS(XS_ClearSilver__HDF_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "hdf");
    {
	ClearSilver__HDF	hdf;

	if (SvROK(ST(0))) {
	    IV tmp = SvIV((SV*)SvRV(ST(0)));
	    hdf = INT2PTR(ClearSilver__HDF,tmp);
	}
	else
	    Perl_croak_nocontext("%s: %s is not a reference",
			"ClearSilver::HDF::DESTROY",
			"hdf")
;
#line 122 "ClearSilver.xs"
        debug("hdf_DESTROY:%x\n", hdf);
        hdf_destroy(&(hdf->hdf));
#line 310 "ClearSilver.c"
    }
    XSRETURN_EMPTY;
}

// Assembly:
endbr64
pushq %r14
pushq %r13
movq %rsi, %r13
pushq %r12
pushq %rbp
pushq %rbx
movq 0x315a(%rip), %rbx      # 0x8fe0
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq (%rax), %r12
callq 0x2400
movl (%rbx), %edi
movq 0x70(%rax), %rdx
leaq -0x4(%rdx), %rcx
movq %rcx, 0x70(%rax)
movslq (%rdx), %r14
callq 0x2400
movq 0x18(%rax), %rax
leaq (%rax,%r14,8), %rax
subq %rax, %r12
sarq $0x3, %r12
cmpl $0x1, %r12d
jne 0x5f9e
movl (%rbx), %edi
leal 0x1(%r14), %ebp
movslq %ebp, %rbp
callq 0x2400
leaq (,%rbp,8), %r12
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
testb $0x8, 0xd(%rax)
je 0x5f82
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movl 0xc(%rax), %eax
andl $0x200100, %eax         # imm = 0x200100
cmpl $0x100, %eax            # imm = 0x100
je 0x5f68
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rbp
callq 0x2400
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x23b0
movq %rax, %rdi
callq 0x2640
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rbp
callq 0x2400
leaq -0x8(%rbp,%r12), %rdx
movq %rdx, (%rax)
popq %rbx
popq %rbp
popq %r12
popq %r13
popq %r14
retq
nopl (%rax)
callq 0x2400
movq 0x18(%rax), %rax
movq (%rax,%rbp,8), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
jmp 0x5f3d
leaq 0x1170(%rip), %rdx      # 0x70f9
leaq 0x1383(%rip), %rsi      # 0x7313
xorl %eax, %eax
leaq 0x1140(%rip), %rdi      # 0x70d9
callq 0x2570
leaq 0x1154(%rip), %rsi      # 0x70f9
movq %r13, %rdi
callq 0x2510
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jeske[P]Clearsilver/perl/ClearSilver.c
// Function: XS_ClearSilver__HDF_new
XS_EUPXS(XS_ClearSilver__HDF_new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	char*	self = (char *)SvPV_nolen(ST(0))
;
#line 105 "ClearSilver.xs"
	ClearSilver__HDF hdf;
#line 266 "ClearSilver.c"
	ClearSilver__HDF	RETVAL;
#line 107 "ClearSilver.xs"
	debug("%s\n", self);
	hdf = (ClearSilver__HDF)malloc(sizeof(perlHDF));
	if (!hdf) {
	  RETVAL = NULL;
	} else {
	  hdf->err = hdf_init(&(hdf->hdf));
	  RETVAL = hdf;
	}
#line 277 "ClearSilver.c"
	{
	    SV * RETVALSV;
	    RETVALSV = sv_newmortal();
	    sv_setref_pv(RETVALSV, "ClearSilver::HDF", (void*)RETVAL);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}

// Assembly:
endbr64
pushq %r14
pushq %r13
movq %rsi, %r13
pushq %r12
pushq %rbp
pushq %rbx
movq 0x301a(%rip), %rbx      # 0x8fe0
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq (%rax), %rbp
callq 0x2400
movl (%rbx), %edi
movq 0x70(%rax), %rdx
leaq -0x4(%rdx), %rcx
movq %rcx, 0x70(%rax)
movslq (%rdx), %r14
callq 0x2400
movq 0x18(%rax), %rax
leaq (%rax,%r14,8), %rax
subq %rax, %rbp
sarq $0x3, %rbp
cmpl $0x1, %ebp
jne 0x60ea
movl (%rbx), %edi
leal 0x1(%r14), %r12d
movslq %r12d, %r13
callq 0x2400
leaq (,%r13,8), %r14
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%r13,8), %rax
movl 0xc(%rax), %eax
andl $0x200400, %eax         # imm = 0x200400
cmpl $0x400, %eax            # imm = 0x400
je 0x60e0
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rax
movq (%rax,%r13,8), %rbp
callq 0x2400
movl $0x2, %ecx
xorl %edx, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x24c0
movl $0x10, %edi
callq 0x2560
movq %rax, %r12
testq %rax, %rax
je 0x607d
movq %rax, %rdi
callq 0x2550
movq %rax, 0x8(%r12)
movl (%rbx), %edi
callq 0x2400
movq %rax, %rdi
callq 0x26c0
movl (%rbx), %edi
movq %rax, %rbp
callq 0x2400
movq %r12, %rcx
movq %rbp, %rsi
leaq 0x105a(%rip), %rdx      # 0x70fd
movq %rax, %rdi
callq 0x23a0
movl (%rbx), %edi
callq 0x2400
movq 0x18(%rax), %rax
movq %rbp, (%rax,%r13,8)
movl (%rbx), %edi
callq 0x2400
movl (%rbx), %edi
movq 0x18(%rax), %rbp
callq 0x2400
addq %r14, %rbp
movq %rbp, (%rax)
popq %rbx
popq %rbp
popq %r12
popq %r13
popq %r14
retq
nopl (%rax,%rax)
callq 0x2400
jmp 0x605e
leaq 0x123c(%rip), %rsi      # 0x732d
movq %r13, %rdi
callq 0x2510
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/transform.c
// Function: main
int main(int arcg, char *argv[]) {
    scg_config_t config = scg_config_new_default();
    config.video.title = "SCG Example: Transform";

    scg_app_t app;
    scg_app_init(&app, config);

    scg_image_t *image = scg_image_new_from_bmp("assets/ball.bmp");
    if (image == NULL) {
        return -1;
    }

    while (scg_app_process_events(&app)) {
        draw(app.draw_target, image, app.elapsed_time);

        scg_app_present(&app);
    }

    scg_image_free(image);
    scg_app_free(&app);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x49e0
leaq 0xe83(%rip), %rax       # 0x758c
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xa0(%rbp), %rdi
callq 0x4a30
leaq 0xe69(%rip), %rdi       # 0x75a3
callq 0x2c10
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x6759
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67b2
jmp 0x675b
leaq -0xa0(%rbp), %rdi
callq 0x56b0
testb $0x1, %al
jne 0x676d
jmp 0x6793
movq -0x68(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movss -0x98(%rbp), %xmm0
callq 0x67c0
leaq -0xa0(%rbp), %rdi
callq 0x5800
jmp 0x675b
movq -0xa8(%rbp), %rdi
callq 0x4670
leaq -0xa0(%rbp), %rdi
callq 0x5cb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]scg/examples/transform.c
// Function: draw
static void draw(scg_image_t *draw_target, scg_image_t *image,
                 float32_t elapsed_time) {
    scg_image_clear(draw_target, SCG_COLOR_95_GREEN);

    int w = draw_target->width;
    int h = draw_target->height;

    scg_image_set_blend_mode(draw_target, SCG_BLEND_MODE_ALPHA);
    scg_image_draw_image_rotate_scale(draw_target, image, w / 2 - image->height,
                                      h / 2 - image->width, elapsed_time, 2.0f,
                                      2.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movb $-0x80, -0x18(%rbp)
movb $-0x80, -0x17(%rbp)
movb $0x0, -0x16(%rbp)
movb $-0x1, -0x15(%rbp)
movl -0x18(%rbp), %esi
callq 0x3100
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x2ec0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x24(%rbp), %edx
movl %eax, %ecx
movq -0x10(%rbp), %rax
subl (%rax), %ecx
movss -0x14(%rbp), %xmm0
movss 0x7be(%rip), %xmm2      # 0x7010
movaps %xmm2, %xmm1
callq 0x35c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: luaopen_xpio_c
int luaopen_xpio_c(lua_State *L)
{
   // POSIX fail: SIGPIPE will terminate a program when it writes to a socket
   // that a peer has closed, unless the program takes action to block or
   // ignore SIGPIPE. BSD provides SO_NOSIGPIPE, but that is not
   // portable. The following protects us from SIGPIPE, but it also disables
   // SIGPIPE behavior for stdin/stdout.  It is unfortunate to trigger
   // global side effects, but the default SIGPIPE behavior is essentially
   // incompatible with any network programming.
   signal(SIGPIPE, SIG_IGN);

   // create table
   lua_createtable(L, 0, ARRAY_LENGTH(xpio_regs)-1);

   // bind XPIO table to each function in a C closure, so they can
   // access the appropriate metatables for sockets, etc.
   xlua_register(L, -1, xpio_regs, -1);

   // create metatables

   XLUA_NEWMT(L, XPProc);
   lua_setfield(L, -2, "_XPProc");

   XLUA_NEWMT(L, XPQueue);
   lua_setfield(L, -2, "_XPQueue");

   XLUA_NEWMT(L, XPSocket);

   // make `socket:try_accept` a closure; it creates a socket
   lua_pushvalue(L, -2);
   lua_pushcclosure(L, xpsocket_try_accept, 1);
   lua_setfield(L, -2, "try_accept");

   lua_setfield(L, -2, "_XPSocket");

   // extract environment variables

   xpio_getenv(L);
   lua_setfield(L, -2, "env");

   return 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movl $0xd, %edi
movl $0x1, %esi
callq 0x3270
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x8dd0
movq (%rsp), %rdi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x2d1fc(%rip), %rdx     # 0x307a0
movl %ecx, %esi
callq 0x36c0
movq (%rsp), %rdi
leaq 0x2d27a(%rip), %rsi     # 0x30830
callq 0x3760
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2d265(%rip), %rdx     # 0x30830
xorl %ecx, %ecx
callq 0x36c0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x24a46(%rip), %rdx     # 0x28028
callq 0x9120
movq (%rsp), %rdi
leaq 0x2d28e(%rip), %rsi     # 0x30880
callq 0x3760
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2d279(%rip), %rdx     # 0x30880
xorl %ecx, %ecx
callq 0x36c0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x24a12(%rip), %rdx     # 0x28030
callq 0x9120
movq (%rsp), %rdi
leaq 0x2d292(%rip), %rsi     # 0x308c0
callq 0x3760
movq (%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2d27d(%rip), %rdx     # 0x308c0
xorl %ecx, %ecx
callq 0x36c0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7930
movq (%rsp), %rdi
leaq 0x17d(%rip), %rsi       # 0x37e0
movl $0x1, %edx
callq 0x8830
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x249bc(%rip), %rdx     # 0x28039
callq 0x9120
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x249b2(%rip), %rdx     # 0x28044
callq 0x9120
movq (%rsp), %rdi
callq 0x38e0
movq (%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x2499e(%rip), %rdx     # 0x2804e
callq 0x9120
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xlua.h
// Function: xlua_register
static inline void
xlua_register(lua_State *L,
              int ndxTable,
              const luaL_Reg *regs,
              int ndxUpValue)
{
   const luaL_Reg *preg;

   ndxTable = lua_absindex(L, ndxTable);

   for (preg = regs; preg->func; ++preg) {
      if (ndxUpValue) {
         lua_pushvalue(L, ndxUpValue);
      }
      lua_pushcclosure(L, preg->func, (ndxUpValue ? 1 : 0));
      lua_setfield(L, ndxTable, preg->name);
   }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7410
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3757
cmpl $0x0, 0xc(%rsp)
je 0x3711
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x7930
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movl 0xc(%rsp), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
callq 0x8830
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq (%rsp), %rax
movq (%rax), %rdx
callq 0x9120
movq (%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
jmp 0x36f1
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xlua.h
// Function: xlua_newMT
static inline void
xlua_newMT(lua_State *L, const void *tptr)
{
   // mt = {}
   lua_createtable(L, 0, 0);

   // REGISTRY[mt] = regs
   lua_pushvalue(L, -1);
   lua_pushlightuserdata(L, CONST_CAST(void*) tptr);
   lua_rawset(L, LUA_REGISTRYINDEX);

   // mt.__index = mt
   lua_pushvalue(L, -1);
   lua_setfield(L, -2, "__index");

   // return mt
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8dd0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7930
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x89d0
movq 0x10(%rsp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
callq 0x91e0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7930
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x249eb(%rip), %rdx     # 0x281b4
callq 0x9120
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpsocket_try_accept
static int xpsocket_try_accept(lua_State *L)
{
   XPSocket *me = XLUA_CAST(L, 1, XPSocket);
   XPSocket *ps = xpsocket_new(L);

   ps->s = accept(me->s, NULL, NULL);
   if (ps->s == -1) {
      return pushError(L, isRetry(errno) ? "retry" : NULL);
   }

   // Linux: accepted socket does not inherit file status (the nerve!)
   if (setNonBlocking(ps->s, 1) == -1) {
      (void) close(ps->s);
      ps->s = -1;
      return pushError(L, NULL);
   }

   return 1;  // success => return new socket
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x2d0c6(%rip), %rdx     # 0x308c0
leaq 0x24844(%rip), %rcx     # 0x28045
callq 0x5450
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4960
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %edi
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x33a0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x3885
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3060
movl (%rax), %edi
callq 0x6f80
movq 0x8(%rsp), %rdi
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0x24995(%rip), %rax     # 0x28208
cmpl $0x0, %ecx
cmovneq %rax, %rsi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x38ce
movq 0x18(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x4a20
cmpl $-0x1, %eax
jne 0x38c6
movq 0x18(%rsp), %rax
movl (%rax), %edi
callq 0x31e0
movq 0x18(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x38ce
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_getenv
static int xpio_getenv(lua_State *L)
{
   char **pstr;

   lua_newtable(L);

   char *str;
   for (pstr = environ; (str = *pstr) != NULL; ++pstr) {
      char *eq = strchr(str, '=');
      if (eq) {
         lua_pushlstring(L, str, eq - str);  // name
         lua_pushstring(L, eq + 1);          // value
         lua_rawset(L, -3);
      }
   }

   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8dd0
movq 0x2d6da(%rip), %rax     # 0x30fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3985
movq 0x10(%rsp), %rdi
movl $0x3d, %esi
callq 0x3170
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3973
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq %rax, %rdx
callq 0x8590
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x1, %rsi
callq 0x8630
movq 0x20(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x91e0
jmp 0x3975
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x3906
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: scanNum
static const char *
scanNum(const char *pszNum, unsigned *pn)
{
   const char *psz = pszNum;
   unsigned n = 0;
   while (isDigit(*psz)) {
      n = n *10 + (*psz - '0');
      ++psz;
   }
   *pn = n;
   return psz;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
cmpl $0x9, %eax
ja 0x4242
imull $0xa, -0x1c(%rsp), %eax
movq -0x18(%rsp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
jmp 0x420c
movl -0x1c(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: addrFromString
static int addrFromString(struct sockaddr_in *psin, const char *psz)
{
   unsigned nums[4] = {0};
   unsigned port = 0;
   size_t i;

   for (i=0; ; ++i) {
      if (!*psz) {
         break;
      }
      if (*psz == ':') {
         psz = scanNum(psz+1, &port);
         break;
      }
      if (i >= ARRAY_LENGTH(nums)) {
         return -1;
      }
      psz = scanNum(psz, &nums[i]);
      if (*psz == '.') {
         ++psz;
      }
   }

   // TODO: syntax validation
   // TODO: range validation

   // POSIX fail: I can find no specifications or docs (POSIX, Linux,
   // MacOS) that indicate to zero the unused fields, but trial and error
   // indicates that it is necessary (at least on MacOS).
   ZERO_REC(*psin);

   if (i > 1) nums[0] *= 0x1000000;
   if (i > 2) nums[1] *= 0x10000;
   if (i > 3) nums[2] *= 0x100;

   // POSIX fail: Port and addr are typed as numbers *yet* stored in network
   // byte order, requiring htons/htonl (still...).
   psin->sin_family = AF_INET;
   psin->sin_addr.s_addr = htonl(nums[0] + nums[1] + nums[2] + nums[3]);
   psin->sin_port = htons(port);
   return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31c0
movl $0x0, 0xc(%rsp)
movq $0x0, (%rsp)
movq 0x20(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x429e
jmp 0x4326
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x42c5
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
leaq 0xc(%rsp), %rsi
callq 0x41f0
movq %rax, 0x20(%rsp)
jmp 0x4326
cmpq $0x4, (%rsp)
jb 0x42d9
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x43b6
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
leaq 0x10(%rsp), %rsi
shlq $0x2, %rax
addq %rax, %rsi
callq 0x41f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x4313
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4315
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x428f
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x31c0
cmpq $0x1, (%rsp)
jbe 0x4349
movl 0x10(%rsp), %eax
shll $0x18, %eax
movl %eax, 0x10(%rsp)
cmpq $0x2, (%rsp)
jbe 0x435b
movl 0x14(%rsp), %eax
shll $0x10, %eax
movl %eax, 0x14(%rsp)
cmpq $0x3, (%rsp)
jbe 0x436d
movl 0x18(%rsp), %eax
shll $0x8, %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movw $0x2, (%rax)
movl 0x10(%rsp), %edi
addl 0x14(%rsp), %edi
addl 0x18(%rsp), %edi
addl 0x1c(%rsp), %edi
callq 0x31b0
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0xc(%rsp), %eax
movzwl %ax, %edi
callq 0x3150
movw %ax, %cx
movq 0x28(%rsp), %rax
movw %cx, 0x2(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_socket
static int xpio_socket(lua_State *L)
{
   XPSocket *me = xpsocket_new(L);
   const char *typeName = luaL_checkstring(L, 1);
   int type;

   if (0 == strcmp(typeName, "TCP")) {
      type = SOCK_STREAM;
   } else if (0 == strcmp(typeName, "UDP")) {
      type = SOCK_DGRAM;
   } else {
      lua_pushnil(L);
      lua_pushstring(L, "xpio: unsupported socket type");
      return 2;
   }

   me->s = socket(AF_INET, type, 0);
   if (me->s == -1) {
      return pushError(L, NULL);
   }

   // Note: *me and me->s will be cleaned up when userdata is collected

   if (setNonBlocking(me->s, 1) == -1) {
      return pushError(L, NULL);
   }

   return 1;   // success => return userdata
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4960
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x23cf5(%rip), %rsi     # 0x280f1
callq 0x3260
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4413
movl $0x1, 0x4(%rsp)
jmp 0x445d
movq 0x8(%rsp), %rdi
leaq 0x23cd6(%rip), %rsi     # 0x280f5
callq 0x3260
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4436
movl $0x2, 0x4(%rsp)
jmp 0x445b
movq 0x18(%rsp), %rdi
callq 0x8440
movq 0x18(%rsp), %rdi
leaq 0x23cad(%rip), %rsi     # 0x280f9
callq 0x8630
movl $0x2, 0x24(%rsp)
jmp 0x44c6
jmp 0x445d
movl 0x4(%rsp), %esi
movl $0x2, %edi
xorl %edx, %edx
callq 0x3460
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x4494
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x24(%rsp)
jmp 0x44c6
movq 0x10(%rsp), %rax
movl (%rax), %edi
movl $0x1, %esi
callq 0x4a20
cmpl $-0x1, %eax
jne 0x44be
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x24(%rsp)
jmp 0x44c6
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_tqueue
static int xpio_tqueue(lua_State *L)
{
   XPQueue *me = XPIO_NEWOBJECT(L, XPQueue);

   me->pfds = 0;
   me->nfds = 0;

   lua_createtable(L, 2, 0);             // uservalue
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_READ);     // uservalue[1] = readers
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_WRITE);    // uservalue[2] = writers
   lua_newtable(L);
   lua_rawseti(L, -2, XPQUEUE_CHILD);    // uservalue[2] = childWaiters
   lua_setuservalue(L, -2);

   return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x10, %esi
leaq 0x23b46(%rip), %rdx     # 0x28030
callq 0x4a70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x8dd0
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8dd0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x1, %edx
callq 0x92d0
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8dd0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %edx
callq 0x92d0
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8dd0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x3, %edx
callq 0x92d0
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x9610
movl $0x1, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_fdopen
static int xpio_fdopen(lua_State *L)
{
   XPSocket *ps = xpsocket_new(L);

   // dup() creates a descriptor for the xpsocket to own (and close on
   // finalization). This avoids one xpsocket unpredictably closing a
   // descriptor used by another xpsocket.
   ps->s = dup((int) checkUInt(L, 1));
   if (ps->s == -1) {
      return pushError(L, NULL);
   }
   return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4960
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x4c80
movl %eax, %edi
callq 0x3190
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x4682
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x14(%rsp)
jmp 0x468a
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio__spawn
static int xpio__spawn(lua_State *L)
{
   const char *path = luaL_checkstring(L, 1);
   luaL_checktype(L, 2, LUA_TTABLE);
   luaL_checktype(L, 3, LUA_TTABLE);
   luaL_checktype(L, 4, LUA_TTABLE);

   pid_t pid = fork();
   if (pid) {
      XPProc *pproc = xpproc_new(L);
      pproc->pid = pid;
      return 1;
   }

   // exec

   // reset signals

   // TODO: what about reversing SIG_IGN for SIGPIPE?
   sigset_t sigmask;
   sigemptyset(&sigmask);
   BAIL_IF(sigprocmask(SIG_SETMASK, &sigmask, NULL));

   // perform file actions

   int fdFrom, fdTo, ndx;
   for (ndx = 1; xpio_getAction(L, 4, ndx, &fdFrom, &fdTo); ++ndx) {
      if (fdFrom >= 0) {
         if (fdFrom != fdTo) {
            dup2(fdFrom, fdTo);
         }
         // make granted FDs blocking
         (void) setNonBlocking(fdTo, 0);
      } else {
         close(fdTo);
      }
   }

   char **argv = readStringArray(L, 2);
   char **envp = readStringArray(L, 3);

   execve(path, argv, envp);

 bail:
   exit(127);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb350
movq %rax, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movl $0x2, %esi
movl $0x5, %edx
callq 0xb410
movq 0xc0(%rsp), %rdi
movl $0x3, %esi
movl $0x5, %edx
callq 0xb410
movq 0xc0(%rsp), %rdi
movl $0x4, %esi
movl $0x5, %edx
callq 0xb410
callq 0x3440
movl %eax, 0xb4(%rsp)
cmpl $0x0, 0xb4(%rsp)
je 0x475c
movq 0xc0(%rsp), %rdi
callq 0x4d00
movq %rax, 0xa8(%rsp)
movl 0xb4(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, %eax
addq $0xc8, %rsp
retq
leaq 0x28(%rsp), %rdi
callq 0x3290
movl $0x2, %edi
leaq 0x28(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3030
cmpl $0x0, %eax
je 0x4783
jmp 0x4838
movl $0x1, 0x1c(%rsp)
movq 0xc0(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl $0x4, %esi
leaq 0x24(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x4d70
cmpl $0x0, %eax
je 0x47f3
cmpl $0x0, 0x24(%rsp)
jl 0x47db
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
je 0x47ce
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x3160
movl 0x20(%rsp), %edi
xorl %esi, %esi
callq 0x4a20
jmp 0x47e4
movl 0x20(%rsp), %edi
callq 0x31e0
jmp 0x47e6
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x478b
movq 0xc0(%rsp), %rdi
movl $0x2, %esi
callq 0x4e60
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rdi
movl $0x3, %esi
callq 0x4e60
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3240
movl $0x7f, %edi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio__nextfd
static int xpio__nextfd(lua_State *L)
{
   struct rlimit rl;
   int fd = 0;
   int flags;
   int fdMax = -1;

   fd = tointegerDefault(L, 2, -1) + 1;

   if (fdMax < 0) {
      if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
         return luaL_error(L, "xpio: getrlimit failed");
      }
      // rlim_max is negative in OSX => use rlim_cur ?
      fdMax = rl.rlim_max - 1;
      if (fdMax < 0) {
         fdMax = rl.rlim_cur - 1;
      }
   }

   for (; fd <= fdMax; ++fd) {
      flags = fcntl(fd, F_GETFD);
      if (flags >= 0 && (flags & FD_CLOEXEC) == 0) {
         lua_pushinteger(L, fd);
         return 1;
      }
   }

   lua_pushnil(L);
   return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5120
addl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x48de
movl $0x7, %edi
leaq 0x18(%rsp), %rsi
callq 0x3400
cmpl $0x0, %eax
jge 0x48bb
movq 0x28(%rsp), %rdi
leaq 0x238f2(%rip), %rsi     # 0x2819d
movb $0x0, %al
callq 0xab70
movl %eax, 0x34(%rsp)
jmp 0x494b
movq 0x20(%rsp), %rax
subq $0x1, %rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x48dc
movq 0x18(%rsp), %rax
subq $0x1, %rax
movl %eax, 0xc(%rsp)
jmp 0x48de
jmp 0x48e0
movl 0x14(%rsp), %eax
cmpl 0xc(%rsp), %eax
jg 0x4939
movl 0x14(%rsp), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x30e0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jl 0x492a
movl 0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x492a
movq 0x28(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x84c0
movl $0x1, 0x34(%rsp)
jmp 0x494b
jmp 0x492c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x48e0
movq 0x28(%rsp), %rdi
callq 0x8440
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: setNonBlocking
static int setNonBlocking(int fd, int bOn)
{
   int flagsAdd = 0;
   int flagsRemove = 0;

   if (bOn) {
      flagsAdd = O_NONBLOCK;
   } else {
      flagsRemove = O_NONBLOCK;
   }

   return fcntl_mod_FL(fd, flagsAdd, flagsRemove);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x4a4d
movl $0x800, 0xc(%rsp)       # imm = 0x800
jmp 0x4a55
movl $0x800, 0x8(%rsp)       # imm = 0x800
movl 0x14(%rsp), %edi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x4b30
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_newObject
static void *xpio_newObject(lua_State *L, size_t size, const char *mtName)
{
   void *pv;

   lua_getfield(L, lua_upvalueindex(1), mtName);
   pv = xlua_newObject(L, -1, size);
   lua_remove(L, -2);

   return pv;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0xfff0b9d7, %esi       # imm = 0xFFF0B9D7
callq 0x8b80
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4ad0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7550
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xlua.h
// Function: xlua_newObject
static inline void*
xlua_newObject(lua_State *L,
               int ndxMT,
               size_t size)
{
   void *me;

   ndxMT = lua_absindex(L, ndxMT);
   me = lua_newuserdata(L, size);  // stack: udata
   lua_pushvalue(L, ndxMT);        // stack: udata mt
   lua_setmetatable(L, -2);        // stack: udata
   return me;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7410
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xa050
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x7930
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x9480
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: fcntl_mod_FL
static int fcntl_mod_FL(int fd, int flagsAdd, int flagsRemove)
{
   int flags = fcntl(fd, F_GETFL);
   if (flags != -1) {
      flags = fcntl(fd, F_SETFL, (flags & ~flagsRemove) | flagsAdd);
   }
   return flags;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0x14(%rsp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x30e0
movl %eax, 0x8(%rsp)
cmpl $-0x1, 0x8(%rsp)
je 0x4b80
movl 0x14(%rsp), %edi
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %eax
xorl $-0x1, %eax
andl %eax, %edx
orl 0x10(%rsp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x30e0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpio_pair
static int xpio_pair(lua_State *L, int nPairType)
{
   XPSocket *psA = xpsocket_new(L);
   XPSocket *psB = xpsocket_new(L);
   int spOut[2];
   int n, err;

   if (nPairType == PAIR_PIPE) {
      err = pipe(spOut);
   } else {
      err = socketpair(AF_UNIX, SOCK_STREAM, 0, spOut);
   }

   if (err) {
      return pushError(L, NULL);
   }

   psA->s = spOut[0];
   psB->s = spOut[1];

   for (n = 0; n <= 1; ++n) {
      if (setNonBlocking(spOut[n], 1) == -1) {
         return pushError(L, NULL);
      }
   }

   return 2;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4960
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4960
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x24(%rsp)
jne 0x4bd1
leaq 0x8(%rsp), %rdi
callq 0x31f0
movl %eax, (%rsp)
jmp 0x4be7
leaq 0x8(%rsp), %rcx
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x32c0
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
je 0x4c01
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x4c69
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jg 0x4c61
movslq 0x4(%rsp), %rax
movl 0x8(%rsp,%rax,4), %edi
movl $0x1, %esi
callq 0x4a20
cmpl $-0x1, %eax
jne 0x4c52
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x49a0
movl %eax, 0x34(%rsp)
jmp 0x4c69
jmp 0x4c54
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4c1f
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: checkUInt
static unsigned checkUInt(lua_State *L, int ndx)
{
   lua_Number num = luaL_checknumber(L, ndx);
   if (! (num >= 0)) {
      return luaL_error(L, "xpio: invalid argument #%d", ndx);
   }
   if (num > UINT_MAX) {
      return UINT_MAX;
   }
   return (unsigned) num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xb4e0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jae 0x4ccd
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x23457(%rip), %rsi     # 0x28117
movb $0x0, %al
callq 0xab70
movl %eax, 0x24(%rsp)
jmp 0x4cf6
movsd 0x8(%rsp), %xmm0
movsd 0x23335(%rip), %xmm1    # 0x28010
ucomisd %xmm1, %xmm0
jbe 0x4ceb
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x4cf6
cvttsd2si 0x8(%rsp), %rax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bhk[P]tooltree/monoglot/./xpio_c.c
// Function: xpproc_new
static XPProc *xpproc_new(lua_State *L)
{
   XPProc *me = XPIO_NEWOBJECT(L, XPProc);
   me->pid = 0;
   me->status = 0;

   me->next = gpHeadProc;
   gpHeadProc = me;

   xpproc_init();

   return me;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x10, %esi
leaq 0x2330e(%rip), %rdx     # 0x28028
callq 0x4a70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x2c515(%rip), %rcx     # 0x31258
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x2c501(%rip)     # 0x31258
callq 0x4f80
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)