LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_mutex.c
// Function: alarm_thread
void *alarm_thread(void *_arg)
{
	struct alarm *a;
	int sleep_time;
	time_t now;

	(void)_arg; /* unused */

	while (1)
	{
		pthread_mutex_lock(&g_alarm_mutex);
		a = g_alarm_list;

		if (!a)
			sleep_time = 1;
		else
		{
			g_alarm_list = a->link;
			now = time(NULL);
			sleep_time = MAX(0, a->time - now);
		}
		pthread_mutex_unlock(&g_alarm_mutex);

		if (sleep_time > 0)
		{
			/* this kind of sucks because it will miss out on any
			 * alarms created during the sleep which expire sooner */
			sleep(sleep_time);
		}
		else
			sched_yield(); /* give main() a chance */

		if (a)
		{
			printf("(%d) %s\n", a->seconds, a->message);
			free(a);
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x2e85(%rip), %rdi      # 0x4098
callq 0x10f0
movq 0x2ea1(%rip), %rax      # 0x40c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1233
movl $0x1, -0x14(%rbp)
jmp 0x1280
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x2e7f(%rip)      # 0x40c0
xorl %eax, %eax
movl %eax, %edi
callq 0x1090
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
subq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jl 0x1269
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x1279
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x14(%rbp)
leaq 0x2e11(%rip), %rdi      # 0x4098
callq 0x10a0
cmpl $0x0, -0x14(%rbp)
jle 0x129c
movl -0x14(%rbp), %edi
callq 0x10e0
jmp 0x12a1
callq 0x1070
cmpq $0x0, -0x10(%rbp)
je 0x12ce
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rdx
addq $0x14, %rdx
leaq 0xd46(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x120c
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: key
void key(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		do {
			tmp = stte[indx];
			kndx += tmp;
			kndx += ptr[(int)indx % len];
			stte[indx] = stte[kndx];
			stte[kndx] = tmp;
		} while (++indx);
		ptr += 256;
		len -= 256;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4495
jmp 0x43cf
movzbl 0x7a3c(%rip), %eax      # 0xbe12
movl %eax, %ecx
leaq 0x7a41(%rip), %rax      # 0xbe20
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %ecx
movzbl 0x7a20(%rip), %eax      # 0xbe10
addl %ecx, %eax
movb %al, 0x7a18(%rip)       # 0xbe10
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl 0x7a0b(%rip), %eax      # 0xbe12
cltd
idivl -0xc(%rbp)
movq -0x20(%rbp), %rax
movslq %edx, %rcx
movzbl (%rax,%rcx), %ecx
movzbl 0x79f3(%rip), %eax      # 0xbe10
addl %ecx, %eax
movb %al, 0x79eb(%rip)       # 0xbe10
movzbl 0x79e4(%rip), %eax      # 0xbe10
movl %eax, %ecx
leaq 0x79eb(%rip), %rax      # 0xbe20
movb (%rax,%rcx), %dl
movzbl 0x79d3(%rip), %eax      # 0xbe12
movl %eax, %ecx
leaq 0x79d8(%rip), %rax      # 0xbe20
movb %dl, (%rax,%rcx)
movb -0xd(%rbp), %dl
movzbl 0x79bb(%rip), %eax      # 0xbe10
movl %eax, %ecx
leaq 0x79c2(%rip), %rax      # 0xbe20
movb %dl, (%rax,%rcx)
movb 0x79ab(%rip), %al       # 0xbe12
addb $0x1, %al
movb %al, 0x79a3(%rip)       # 0xbe12
cmpb $0x0, %al
jne 0x43cf
movq -0x18(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
movl %eax, -0xc(%rbp)
jmp 0x43c3
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: arc4
void arc4(void * str, int len)
{
	unsigned char tmp, * ptr = (unsigned char *)str;
	while (len > 0) {
		indx++;
		tmp = stte[indx];
		jndx += tmp;
		stte[indx] = stte[jndx];
		stte[jndx] = tmp;
		tmp += stte[indx];
		*ptr ^= stte[tmp];
		ptr++;
		len--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4583
movb 0x794f(%rip), %al       # 0xbe12
addb $0x1, %al
movb %al, 0x7947(%rip)       # 0xbe12
movzbl 0x7940(%rip), %eax      # 0xbe12
movl %eax, %ecx
leaq 0x7945(%rip), %rax      # 0xbe20
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %ecx
movzbl 0x7925(%rip), %eax      # 0xbe11
addl %ecx, %eax
movb %al, 0x791d(%rip)       # 0xbe11
movzbl 0x7916(%rip), %eax      # 0xbe11
movl %eax, %ecx
leaq 0x791c(%rip), %rax      # 0xbe20
movb (%rax,%rcx), %dl
movzbl 0x7904(%rip), %eax      # 0xbe12
movl %eax, %ecx
leaq 0x7909(%rip), %rax      # 0xbe20
movb %dl, (%rax,%rcx)
movb -0xd(%rbp), %dl
movzbl 0x78ed(%rip), %eax      # 0xbe11
movl %eax, %ecx
leaq 0x78f3(%rip), %rax      # 0xbe20
movb %dl, (%rax,%rcx)
movzbl 0x78db(%rip), %eax      # 0xbe12
movl %eax, %ecx
leaq 0x78e0(%rip), %rax      # 0xbe20
movzbl (%rax,%rcx), %ecx
movzbl -0xd(%rbp), %eax
addl %ecx, %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
movl %eax, %ecx
leaq 0x78c6(%rip), %rax      # 0xbe20
movzbl (%rax,%rcx), %edx
movq -0x18(%rbp), %rax
movzbl (%rax), %ecx
xorl %edx, %ecx
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x44b3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: key_with_file
int key_with_file(char * file)
{
	struct stat statf[1];
	struct stat control[1];

	if (stat(file, statf) < 0)
		return -1;

	/* Turn on stable fields */
	memset(control, 0, sizeof(control));
	control->st_ino = statf->st_ino;
	control->st_dev = statf->st_dev;
	control->st_rdev = statf->st_rdev;
	control->st_uid = statf->st_uid;
	control->st_gid = statf->st_gid;
	control->st_size = statf->st_size;
	control->st_mtime = statf->st_mtime;
	control->st_ctime = statf->st_ctime;
	key(control, sizeof(control));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x4150
cmpl $0x0, %eax
jge 0x45c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4648
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x40f0
movq -0x98(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x84(%rbp), %eax
movl %eax, -0x114(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x110(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x130(%rbp), %rdi
movl $0x90, %esi
callq 0x43b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: read_script
char * read_script(char * file)
{
	FILE * i;
	char * text;
	int cnt, l;

	text = malloc(SIZE);
	if (!text)
		return NULL;
	i = fopen(file, "r");
	if (!i)
		return NULL;
	for (l = 0;;) {
		text = realloc(text, l + SIZE);
		if (!text)
			return NULL;
		cnt = fread(&text[l], 1, SIZE, i);
		if (!cnt)
			break;
		l += cnt;
	}
	fclose(i);
	text = realloc(text, l + 1);
	if (!text)
		return NULL;
	text[l] = '\0';

	/* Check current System ARG_MAX limit. */
	if (l > 0.80 * (cnt = sysconf(_SC_ARG_MAX))) {
		fprintf(stderr, "%s: WARNING!!\n"
"   Scripts of length near to (or higher than) the current System limit on\n"
"   \"maximum size of arguments to EXEC\", could comprise its binary execution.\n"
"   In the current System the call sysconf(_SC_ARG_MAX) returns %d bytes\n"
"   and your script \"%s\" is %d bytes length.\n",
		my_name, cnt, file, l);
	}
	return text;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1000, %edi           # imm = 0x1000
callq 0x4170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4b1e
movq $0x0, -0x8(%rbp)
jmp 0x4c4a
movq -0x10(%rbp), %rdi
leaq 0x2d34(%rip), %rsi      # 0x785d
callq 0x41c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4b46
movq $0x0, -0x8(%rbp)
jmp 0x4c4a
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movslq %eax, %rsi
callq 0x41b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4b79
movq $0x0, -0x8(%rbp)
jmp 0x4c4a
movq -0x20(%rbp), %rdi
movslq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x4070
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x4ba2
jmp 0x4bad
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x4b4d
movq -0x18(%rbp), %rdi
callq 0x4090
movq -0x20(%rbp), %rdi
movl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0x41b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4bdd
movq $0x0, -0x8(%rbp)
jmp 0x4c4a
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cvtsi2sdl -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorl %edi, %edi
callq 0x41e0
movsd -0x30(%rbp), %xmm0
movl %eax, -0x24(%rbp)
cvtsi2sd %eax, %xmm2
movsd 0x23fa(%rip), %xmm1     # 0x7008
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4c42
movq 0x63d9(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %r8
movl -0x28(%rbp), %r9d
leaq 0x28f0(%rip), %rsi      # 0x7524
leaq 0x2609(%rip), %rdx      # 0x7244
movb $0x0, %al
callq 0x4140
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: rand_mod
unsigned rand_mod(unsigned mod)
{
	/* Without skew */
	unsigned rnd, top = RAND_MAX;
	top -= top % mod;
	while (top <= (rnd = rand()))
		continue;
	/* Using high-order bits. */
	rnd = 1.0*mod*rnd/(1.0+top);
	return rnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x7fffffff, -0xc(%rbp) # imm = 0x7FFFFFFF
movl -0xc(%rbp), %eax
xorl %edx, %edx
divl -0x4(%rbp)
movl -0xc(%rbp), %eax
subl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x4240
movl %eax, %ecx
movl -0x10(%rbp), %eax
movl %ecx, -0x8(%rbp)
cmpl %ecx, %eax
ja 0x4c9b
jmp 0x4c82
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm0
movl -0x8(%rbp), %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd 0x2351(%rip), %xmm2     # 0x7010
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: noise
int noise(char * ptr, unsigned min, unsigned xtra, int str)
{
	if (xtra) xtra = rand_mod(xtra);
	xtra += min;
	for (min = 0; min < xtra; min++, ptr++)
		do
			*ptr = rand_chr();
		while (str && !isalnum((int)*ptr));
	if (str) *ptr = '\0';
	return xtra;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x4d16
movl -0x10(%rbp), %edi
callq 0x4c60
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x4d8c
jmp 0x4d30
callq 0x4ce0
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
je 0x4d6c
callq 0x4250
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x4d30
jmp 0x4d75
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x4d26
cmpl $0x0, -0x14(%rbp)
je 0x4d99
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: prnt_bytes
void prnt_bytes(FILE * o, char * ptr, int m, int l, int n)
{
	int i;

	l += m;
	n += l;
	for (i = 0; i < n; i++) {
		if ((i & 0xf) == 0)
			fprintf(o, "\n\t\"");
		fprintf(o, "\\%03o", (unsigned char)((i>=m) && (i<l) ? ptr[i-m] : rand_chr()));
		if ((i & 0xf) == 0xf)
			fprintf(o, "\"");
	}
	if ((i & 0xf) != 0)
		fprintf(o, "\"");
	offset += n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4e8a
movl -0x20(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x4e0c
movq -0x8(%rbp), %rdi
leaq 0x2839(%rip), %rsi      # 0x763e
movb $0x0, %al
callq 0x4140
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x4e3a
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4e3a
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x4e45
callq 0x4ce0
movsbl %al, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movzbl %al, %edx
leaq 0x27ec(%rip), %rsi      # 0x7642
movb $0x0, %al
callq 0x4140
movl -0x20(%rbp), %eax
andl $0xf, %eax
cmpl $0xf, %eax
jne 0x4e7a
movq -0x8(%rbp), %rdi
leaq 0x27cd(%rip), %rsi      # 0x7640
movb $0x0, %al
callq 0x4140
jmp 0x4e7c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4de3
movl -0x20(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x4ea7
movq -0x8(%rbp), %rdi
leaq 0x27a0(%rip), %rsi      # 0x7640
movb $0x0, %al
callq 0x4140
movl -0x1c(%rbp), %eax
addl 0x70a0(%rip), %eax      # 0xbf50
movl %eax, 0x709a(%rip)      # 0xbf50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: prnt_array
void prnt_array(FILE * o, void * ptr, char * name, int l, char * cast)
{
	int m = rand_mod(1+l/4);		/* Random amount of random pre  padding (offset) */
	int n = rand_mod(1+l/4);		/* Random amount of random post padding  (tail)  */
	int a = (offset+m)%l;
	if (cast && a) m += l - a;		/* Type alignement. */
	fprintf(o, "\n");
	fprintf(o, "#define      %s_z	%d", name, l);
	fprintf(o, "\n");
	fprintf(o, "#define      %s	(%s(&data[%d]))", name, cast?cast:"", offset+m);
	prnt_bytes(o, ptr, m, l, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %edi
addl $0x1, %edi
callq 0x4c60
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %edi
addl $0x1, %edi
callq 0x4c60
movl %eax, -0x30(%rbp)
movl 0x703f(%rip), %eax      # 0xbf50
addl -0x2c(%rbp), %eax
cltd
idivl -0x1c(%rbp)
movl %edx, -0x34(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4f34
cmpl $0x0, -0x34(%rbp)
je 0x4f34
movl -0x1c(%rbp), %eax
subl -0x34(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x27f5(%rip), %rsi      # 0x7734
movb $0x0, %al
callq 0x4140
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
leaq 0x26f0(%rip), %rsi      # 0x7648
movb $0x0, %al
callq 0x4140
movq -0x8(%rbp), %rdi
leaq 0x27ca(%rip), %rsi      # 0x7734
movb $0x0, %al
callq 0x4140
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4f92
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4f9f
leaq 0x278e(%rip), %rax      # 0x7727
movq %rax, -0x50(%rbp)
jmp 0x4f9f
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rcx
movl 0x6f9e(%rip), %r8d      # 0xbf50
addl -0x2c(%rbp), %r8d
leaq 0x26a0(%rip), %rsi      # 0x765d
movb $0x0, %al
callq 0x4140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x30(%rbp), %r8d
callq 0x4db0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: do_all
void do_all(int argc, char * argv[])
{
	parse_args(argc, argv);
	text = read_script(file);
	if (!text)
		return;
	if (eval_shell(text))
		return;
	if (write_C(file, argv))
		return;
	if (make())
		return;
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5f40
movq 0x60b6(%rip), %rdi      # 0xbf98
callq 0x4af0
movq %rax, 0x608a(%rip)      # 0xbf78
cmpq $0x0, 0x6082(%rip)      # 0xbf78
jne 0x5efa
jmp 0x5f37
movq 0x6077(%rip), %rdi      # 0xbf78
callq 0x4660
cmpl $0x0, %eax
je 0x5f0d
jmp 0x5f37
movq 0x6084(%rip), %rdi      # 0xbf98
movq -0x10(%rbp), %rsi
callq 0x5040
cmpl $0x0, %eax
je 0x5f24
jmp 0x5f37
callq 0x5c80
cmpl $0x0, %eax
je 0x5f30
jmp 0x5f37
xorl %edi, %edi
callq 0x4220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: parse_args
static void parse_args(int argc, char * argv[])
{
	int err = 0;
	int ret;

#if 0
	my_name = strrchr(argv[0], '/');
	if (my_name)
		my_name++;
	else
		my_name = argv[0];
#endif

	do {
		ret = parse_an_arg(argc, argv);
		if (ret == -1)
			err++;
	} while (ret);
	if (err) {
		fprintf(stderr, "\n%s %s\n\n", my_name, usage);
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x6010
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x5f74
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5f76
cmpl $0x0, -0x18(%rbp)
jne 0x5f56
cmpl $0x0, -0x14(%rbp)
je 0x5fb2
movq 0x506f(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x2e9f(%rip), %rsi      # 0x8e32
leaq 0x12aa(%rip), %rdx      # 0x7244
leaq 0x13df(%rip), %rcx      # 0x7380
movb $0x0, %al
callq 0x4140
movl $0x1, %edi
callq 0x4220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fuldaros[P]akb_sources/cc/akb_cc.c
// Function: main
int main(int argc, char * argv[])
{
	putenv("LANG=");
	do_all(argc, argv);
	/* Return on error */
	perror(argv[0]);
	exit(1);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x185f(%rip), %rdi      # 0x783c
callq 0x4110
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5ec0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x41d0
movl $0x1, %edi
callq 0x4220
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/chunk.c
// Function: moonsndfile_freechunks
void freechunks(lua_State *L, chunknode_t *list)
/* free all cunks in ud->chunklist */
    {
    chunknode_t *pp, *p = list;
    while(p)
        {
        pp = p;
        p = p->next;
        freechunk(L, pp);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4908
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4240
jmp 0x48d8
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/chunk.c
// Function: SetChunk
static int SetChunk(lua_State *L)
    {
    ud_t *ud;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    chunknode_t *chunknode = checkchunk(L, 2);
    
    CheckPfn(L, set_chunk, 1, 0, 26);
    if(sf.set_chunk(sndfile, &chunknode->chunk) != 0)
        {
        freechunk(L, chunknode);
        return sndfileerror(L, sndfile);
        }
    
    insertchunk(ud, chunknode); 
    /* The chunk will be released after file closure, as requested in sndfile.h:
     * ("The chunk_info->data pointer must be valid until the file is closed.")
     */
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
leaq 0x10(%rsp), %rdx
leaq 0xd748(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x4500
movq %rax, (%rsp)
movq 0x1266d(%rip), %rax     # 0x16fe0
cmpq $0x0, 0x118(%rax)
jne 0x49d2
movl $0x1, %edi
xorl %esi, %esi
movl $0x1a, %edx
callq 0x4440
cmpl $0x0, %eax
jne 0x49b9
movq 0x18(%rsp), %rdi
leaq 0xd70c(%rip), %rsi      # 0x120ab
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1a, %r8d
movb $0x0, %al
callq 0x46c0
movl %eax, 0x24(%rsp)
jmp 0x4a2f
movq 0x18(%rsp), %rdi
leaq 0xd71b(%rip), %rsi      # 0x120e0
movb $0x0, %al
callq 0x46c0
movl %eax, 0x24(%rsp)
jmp 0x4a2f
jmp 0x49d4
movq 0x12605(%rip), %rax     # 0x16fe0
movq 0x118(%rax), %rax
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
addq $0x8, %rsi
callq *%rax
cmpl $0x0, %eax
je 0x4a19
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4240
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x4a2f
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4d90
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_set_count
int command_set_count(lua_State *L, int command)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    sf_count_t frames = luaL_checkinteger(L, 2);    
    int res = sf.command(sndfile, command, &frames, sizeof(frames));
    lua_pushboolean(L, res == 0);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd265(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x4470
movq %rax, 0x8(%rsp)
movq 0x12189(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
leaq 0x8(%rsp), %rdx
movl $0x8, %ecx
callq *%rax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
cmpl $0x0, 0x4(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %esi
callq 0x4550
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_get_boolean
int command_get_boolean(lua_State *L, int command)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = sf.command(sndfile, command, NULL, 0);
    lua_pushboolean(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd1d5(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x1210d(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
xorl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x4550
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_set_boolean
int command_set_boolean(lua_State *L, int command)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = checkboolean(L, 2);
    sf.command(sndfile, command, NULL, val);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd165(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x44d0
movl %eax, 0xc(%rsp)
movq 0x1208a(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0xc(%rsp), %ecx
xorl %edx, %edx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_get_integer
int command_get_integer(lua_State *L, int command)
    {
    int val;
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    if(sf.command(sndfile, command, &val, sizeof(val)) != 0)
        return sndfileerror(L, sndfile);
    lua_pushinteger(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd0f5(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x1202d(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x10(%rsp), %rdx
movl $0x4, %ecx
callq *%rax
cmpl $0x0, %eax
je 0x4fe6
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x4ffd
movq 0x18(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x4320
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_set_integer
int command_set_integer(lua_State *L, int command)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = luaL_checkinteger(L, 2);
    if(sf.command(sndfile, command, &val, sizeof(val)) != SF_TRUE)
        return sndfileerror(L, sndfile);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xd065(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x4470
movl %eax, 0x4(%rsp)
movq 0x11f8a(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x4(%rsp), %rdx
movl $0x4, %ecx
callq *%rax
cmpl $0x1, %eax
je 0x5089
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x5091
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_get_double
int command_get_double(lua_State *L, int command)
    {
    double val;
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    if(sf.command(sndfile, command, &val, sizeof(val)) != 0)
        return sndfileerror(L, sndfile);
    lua_pushnumber(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xcfd5(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, (%rsp)
movq 0x11f0e(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x8(%rsp), %rdx
movl $0x8, %ecx
callq *%rax
cmpl $0x0, %eax
je 0x5103
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x511b
movq 0x18(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4510
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_set_double
int command_set_double(lua_State *L, int command)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    double val = luaL_checknumber(L, 2);
    if(sf.command(sndfile, command, &val, sizeof(val)) != SF_TRUE)
        return sndfileerror(L, sndfile);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xcf45(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0x4260
movsd %xmm0, (%rsp)
movq 0x11e69(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq %rsp, %rdx
movl $0x8, %ecx
callq *%rax
cmpl $0x1, %eax
je 0x51a8
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x51b0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: moonsndfile_command_get_double_all_channels
int command_get_double_all_channels(lua_State *L, int command, int success_retcode)
    {
    ud_t *ud;
    int i;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    size_t size = ud->sfinfo.channels * sizeof(double);
    double *val = (double*)Malloc(L, size);
    int res = sf.command(sndfile, command, val, size);
    if(res != success_retcode)
        return sndfileerror(L, sndfile);
    lua_newtable(L);
    for(i = 0; i < ud->sfinfo.channels; i++)
        {
        lua_pushnumber(L, val[i]);
        lua_rawseti(L, -2, i+1);
        }
    Free(L, val);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rdx
leaq 0xceb0(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movslq 0x2c(%rax), %rax
shlq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x41d0
movq %rax, 0x8(%rsp)
movq 0x11dc2(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0x525a
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4340
movl %eax, 0x44(%rsp)
jmp 0x52d4
movq 0x38(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x52bd
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x4510
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4490
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5270
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x43a0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: GetChannelMapInfo
static int GetChannelMapInfo(lua_State *L)
    {
    ud_t *ud;
    int i;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    size_t size = ud->sfinfo.channels * sizeof(int);
    int *val = (int*)Malloc(L, size);
    int res = sf.command(sndfile, SFC_GET_CHANNEL_MAP_INFO, val, size);
    if(res == 0)
        return sndfileerror(L, sndfile);
    lua_newtable(L);
    for(i = 0; i < ud->sfinfo.channels; i++)
        {
        pushchannelmap(L, val[i]);
        lua_rawseti(L, -2, i+1);
        }
    Free(L, val);
    return 1;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl $0x1, %esi
leaq 0x30(%rsp), %rdx
leaq 0xccb8(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movslq 0x2c(%rax), %rax
shlq $0x2, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x41d0
movq %rax, 0x10(%rsp)
movq 0x11bca(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1100, %esi           # imm = 0x1100
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x5450
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4340
movl %eax, 0x44(%rsp)
jmp 0x54cd
movq 0x38(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x2c(%rcx), %eax
jge 0x54b6
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movl $0x7, %esi
callq 0x4110
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4490
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x5466
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x43a0
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: SetChannelMapInfo
static int SetChannelMapInfo(lua_State *L)
    {
    ud_t *ud;
    size_t count, size;
    int err, res;
    sndfile_t sndfile = checksndfile(L, 1, &ud);
    int *list = checkchannelmaplist(L, 2, &count, &err);
    if(err)
        return luaL_argerror(L, 2, errstring(err));
    if(count != (size_t)ud->sfinfo.channels)
        {
        freechannelmaplist(L, list);
        return luaL_argerror(L, 2, errstring(ERR_LENGTH));
        }
    size = count * sizeof(int);
    res = sf.command(sndfile, SFC_SET_CHANNEL_MAP_INFO, list, size);
    freechannelmaplist(L, list);
    if(res == 0)
        return sndfileerror(L, sndfile);
    return 1;
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movl $0x1, %esi
leaq 0x40(%rsp), %rdx
leaq 0xcb98(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movl $0x7, %esi
movl $0x2, %edx
leaq 0x38(%rsp), %rcx
leaq 0x2c(%rsp), %r8
callq 0x42f0
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x5561
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %edi
callq 0x4660
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x4100
movl %eax, 0x54(%rsp)
jmp 0x5615
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rcx
movslq 0x2c(%rcx), %rcx
cmpq %rcx, %rax
je 0x55af
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4150
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0xfffffff9, %edi       # imm = 0xFFFFFFF9
callq 0x4660
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0x2, %esi
callq 0x4100
movl %eax, 0x54(%rsp)
jmp 0x5615
movq 0x38(%rsp), %rax
shlq $0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x11a1c(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x30(%rsp), %rcx
movl $0x1101, %esi           # imm = 0x1101
callq *%rax
movl %eax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4150
cmpl $0x0, 0x28(%rsp)
jne 0x560d
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4340
movl %eax, 0x54(%rsp)
jmp 0x5615
movl $0x1, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: WavexSetAmbisonic
static int WavexSetAmbisonic(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = checkambisonic(L, 2);
    int res = sf.command(sndfile, SFC_WAVEX_SET_AMBISONIC, NULL, val);
    if(res == 0)
        return sndfileerror(L, sndfile);
    return 0;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xca59(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0xb, %esi
movl $0x2, %edx
callq 0x4120
movl %eax, 0xc(%rsp)
movq 0x11979(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %ecx
movl $0x1200, %esi           # imm = 0x1200
xorl %edx, %edx
callq *%rax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0x569d
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x56a5
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/command.c
// Function: WavexGetAmbisonic
static int WavexGetAmbisonic(lua_State *L)
    {
    sndfile_t sndfile = checksndfile(L, 1, NULL);
    int val = sf.command(sndfile, SFC_WAVEX_GET_AMBISONIC, NULL, 0);
    if(val==0)
        return sndfileerror(L, sndfile);
    pushambisonic(L, val);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0xc9c9(%rip), %rcx      # 0x12097
callq 0x4400
movq %rax, 0x10(%rsp)
movq 0x11901(%rip), %rax     # 0x16fe0
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
movl $0x1201, %esi           # imm = 0x1201
xorl %ecx, %ecx
movl %ecx, %edx
xorl %ecx, %ecx
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x5715
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4340
movl %eax, 0x24(%rsp)
jmp 0x5730
movq 0x18(%rsp), %rdi
movl 0xc(%rsp), %edx
movl $0xb, %esi
callq 0x4110
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/datahandling.c
// Function: sizeoftype
static size_t sizeoftype(int type)
    {
    switch(type)
        {
        case NONSF_TYPE_SHORT:  return sizeof(short);
        case NONSF_TYPE_INT:    return sizeof(int);
        case NONSF_TYPE_FLOAT:  return sizeof(float);
        case NONSF_TYPE_DOUBLE: return sizeof(double);
        default:
            return 0;
        }
    return 0;
    }

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x3, %eax
ja 0x5e27
movq -0x18(%rsp), %rax
leaq 0xc4a6(%rip), %rcx      # 0x12298
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x2, -0x8(%rsp)
jmp 0x5e30
movq $0x4, -0x8(%rsp)
jmp 0x5e30
movq $0x4, -0x8(%rsp)
jmp 0x5e30
movq $0x8, -0x8(%rsp)
jmp 0x5e30
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/enums.c
// Function: moonsndfile_enums_checklist
int* enums_checklist(lua_State *L, uint32_t domain, int arg, size_t *count, int *err)
    {
    int* list;
    size_t i;

    *count = 0;
    *err = 0;
    if(lua_isnoneornil(L, arg))
        { *err = ERR_NOTPRESENT; return NULL; }
    if(lua_type(L, arg) != LUA_TTABLE)
        { *err = ERR_TABLE; return NULL; }

    *count = luaL_len(L, arg);
    if(*count == 0)
        { *err = ERR_NOTPRESENT; return NULL; }

    list = (int*)MallocNoErr(L, sizeof(int) * (*count));
    if(!list)
        { *count = 0; *err = ERR_MEMORY; return NULL; }

    for(i=0; i<*count; i++)
        {
        lua_rawgeti(L, arg, i+1);
        list[i] = enums_test(L, domain, -1, err);
        lua_pop(L, 1);
        if(*err)
            { Free(L, list); *count = 0; return NULL; }
        }
    return list;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x4730
cmpl $0x0, %eax
jg 0x6ade
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x6c41
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x4730
cmpl $0x5, %eax
je 0x6b0a
movq 0x10(%rsp), %rax
movl $0xfffffffc, (%rax)     # imm = 0xFFFFFFFC
movq $0x0, 0x30(%rsp)
jmp 0x6c41
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x4740
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x6b47
movq 0x10(%rsp), %rax
movl $0x1, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x6c41
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
shlq $0x2, %rsi
callq 0x4390
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6b8f
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0xfffffffa, (%rax)     # imm = 0xFFFFFFFA
movq $0x0, 0x30(%rsp)
jmp 0x6c41
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x6c37
movq 0x28(%rsp), %rdi
movl 0x20(%rsp), %esi
movq (%rsp), %rdx
addq $0x1, %rdx
callq 0x42a0
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4600
movl %eax, %edx
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4080
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
je 0x6c24
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x43a0
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x30(%rsp)
jmp 0x6c41
jmp 0x6c26
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x6b97
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/format.c
// Function: FormatCheck
static int FormatCheck(lua_State *L)
/* boolean = sf.format_check(format, subformat) */
    {
    SF_INFO sfinfo;
    int format = checkformat(L, 1);
    int subformat = checksubformat(L, 2);
    
    memset(&sfinfo, 0, sizeof(sfinfo));
    sfinfo.channels = 1;
    sfinfo.format = (format & SF_FORMAT_TYPEMASK) | subformat;
    lua_pushboolean(L, sf.format_check(&sfinfo));
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x4120
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x4120
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4310
movl $0x1, 0x1c(%rsp)
movl 0xc(%rsp), %eax
andl $0xfff0000, %eax        # imm = 0xFFF0000
orl 0x8(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x10(%rsp), %rdi
movq 0xb73e(%rip), %rax      # 0x16fe0
callq *0x48(%rax)
movq (%rsp), %rdi
movl %eax, %esi
callq 0x4550
movl $0x1, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/format.c
// Function: GetSimpleFormatList
static int GetSimpleFormatList(lua_State *L)
    {
    SF_FORMAT_INFO info;
    int i, count;
    sf.command(NULL, SFC_GET_SIMPLE_FORMAT_COUNT, &count, sizeof(count));
    lua_newtable(L);
    for(i = 0; i < count; i++) 
        {
        info.format = i;
        sf.command(NULL, SFC_GET_SIMPLE_FORMAT, &info, sizeof(info));
        pushsimpleformat(L, &info);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1020, %esi           # imm = 0x1020
movq %rsp, %rdx
movl $0x4, %ecx
movq 0xb6ff(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0xb95d
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1021, %esi           # imm = 0x1021
leaq 0x8(%rsp), %rdx
movl $0x18, %ecx
movq 0xb6bb(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x43e0
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4490
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xb8fa
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/format.c
// Function: GetFormatList
static int GetFormatList(lua_State *L)
    {
    SF_FORMAT_INFO info;
    int i, count;
    sf.command(NULL, SFC_GET_FORMAT_MAJOR_COUNT, &count, sizeof(count));

    lua_newtable(L);
    memset(&info, 0, sizeof(info));
    for(i = 0; i < count; i++) 
        {
        info.format = i;
        sf.command(NULL, SFC_GET_FORMAT_MAJOR, &info, sizeof(info));
        sf.command(NULL, SFC_GET_FORMAT_INFO, &info, sizeof(info));
        pushformatinfo(L, &info);
        lua_rawseti(L, -2, i+1);
        }
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1030, %esi           # imm = 0x1030
movq %rsp, %rdx
movl $0x4, %ecx
movq 0xb64f(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4310
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jge 0xba3b
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1031, %esi           # imm = 0x1031
leaq 0x8(%rsp), %rdx
movl $0x18, %ecx
movq 0xb5fa(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
xorl %eax, %eax
movl %eax, %edi
movl $0x1028, %esi           # imm = 0x1028
leaq 0x8(%rsp), %rdx
movl $0x18, %ecx
movq 0xb5dd(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x44e0
movq 0x20(%rsp), %rdi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4490
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xb9bb
movl $0x1, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/format.c
// Function: GetFormatInfo
static int GetFormatInfo(lua_State *L)
    {
    SF_FORMAT_INFO info;
    int format = checkformat(L, 1);
    memset(&info, 0, sizeof(info));
    info.format = format;
    sf.command(NULL, SFC_GET_FORMAT_INFO, &info, sizeof(info));
    pushformatinfo(L, &info);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x4120
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4310
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1028, %esi           # imm = 0x1028
leaq 0x8(%rsp), %rdx
movl $0x18, %ecx
movq 0xb53f(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x44e0
movl $0x1, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/format.c
// Function: GetSubFormatInfo
static int GetSubFormatInfo(lua_State *L)
    {
    SF_FORMAT_INFO info;
    int subformat = checksubformat(L, 1);
    memset(&info, 0, sizeof(info));
    info.format = subformat;
    sf.command(NULL, SFC_GET_FORMAT_INFO, &info, sizeof(info));
    pushsubformatinfo(L, &info);
    return 1;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x4120
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4310
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
movl $0x1028, %esi           # imm = 0x1028
leaq 0x8(%rsp), %rdx
movl $0x18, %ecx
movq 0xb4cc(%rip), %rax      # 0x16fe0
callq *0x40(%rax)
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4330
movl $0x1, %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/main.c
// Function: luaopen_moonsndfile
int luaopen_moonsndfile(lua_State *L)
/* Lua calls this function to load the module */
    {
    moonsndfile_L = L;

    moonsndfile_utils_init(L);
    atexit(AtExit);

    lua_newtable(L); /* the cl table */

    /* add functions: */
    moonsndfile_open_getproc(L);
    moonsndfile_open_version(L);
    moonsndfile_open_enums(L);
    moonsndfile_open_tracing(L);
    moonsndfile_open_sndfile(L);
    moonsndfile_open_readwrite(L);
    moonsndfile_open_rawreadwrite(L);
    moonsndfile_open_datahandling(L);
    moonsndfile_open_command(L);
    moonsndfile_open_format(L);
    moonsndfile_open_chunk(L);

#if 0 //@@
    /* Add functions implemented in Lua */
    lua_pushvalue(L, -1); lua_setglobal(L, "moonsndfile");
    if(luaL_dostring(L, "require('moonsndfile.utils')") != 0) lua_error(L);
    lua_pushnil(L);  lua_setglobal(L, "moonsndfile");
#endif

    return 1;
    }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq %rax, 0xad80(%rip)      # 0x17560
movq (%rsp), %rdi
callq 0x45c0
leaq 0x80(%rip), %rdi        # 0xc870
callq 0x11a40
movq (%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4220
movq (%rsp), %rdi
callq 0x44a0
movq (%rsp), %rdi
callq 0x4410
movq (%rsp), %rdi
callq 0x4070
movq (%rsp), %rdi
callq 0x4050
movq (%rsp), %rdi
callq 0x4750
movq (%rsp), %rdi
callq 0x4360
movq (%rsp), %rdi
callq 0x41f0
movq (%rsp), %rdi
callq 0x4640
movq (%rsp), %rdi
callq 0x41c0
movq (%rsp), %rdi
callq 0x42e0
movq (%rsp), %rdi
callq 0x4250
movl $0x1, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moonsndfile/src/main.c
// Function: AtExit
static void AtExit(void)
    {
    if(moonsndfile_L)
        {
        enums_free_all(moonsndfile_L);
        moonsndfile_atexit_getproc();
        moonsndfile_L = NULL;
        }
    }

// Assembly:
pushq %rax
cmpq $0x0, 0xace7(%rip)      # 0x17560
je 0xc897
movq 0xacde(%rip), %rdi      # 0x17560
callq 0x4090
callq 0x40a0
movq $0x0, 0xacc9(%rip) # 0x17560
popq %rax
retq
nopl (%rax)