LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/parse.c
// Function: keycodes_from_keysym
xcb_keycode_t *keycodes_from_keysym(xcb_keysym_t keysym)
{
	xcb_setup_t const *setup;
	unsigned int num = 0;
	xcb_keycode_t *result = NULL, *result_np = NULL;

	if ((setup = xcb_get_setup(dpy)) != NULL) {
		xcb_keycode_t min_kc = setup->min_keycode;
		xcb_keycode_t max_kc = setup->max_keycode;

		/* We must choose a type for kc other than xcb_keycode_t whose size
		 * is 1, otherwise, since max_kc will most likely be 255, if kc == 255,
		 * kc++ would be 0 and the outer loop would start over ad infinitum */
		for(unsigned int kc = min_kc; kc <= max_kc; kc++)
			for(unsigned int col = 0; col < KEYSYMS_PER_KEYCODE; col++) {
				xcb_keysym_t ks = xcb_key_symbols_get_keysym(symbols, kc, col);
				if (ks == keysym) {
					num++;
					result_np = realloc(result, sizeof(xcb_keycode_t) * (num + 1));
					if (result_np == NULL) {
						free(result);
						return NULL;
					}
					result = result_np;
					result[num - 1] = kc;
					result[num] = XCB_NO_SYMBOL;
					break;
				}
			}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
leaq 0x11f5f(%rip), %rax     # 0x23488
movq (%rax), %rdi
callq 0xe350
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x11626
movq -0x18(%rbp), %rax
movb 0x22(%rax), %al
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rax
movb 0x23(%rax), %al
movb %al, -0x32(%rbp)
movzbl -0x31(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movzbl -0x32(%rbp), %ecx
cmpl %ecx, %eax
ja 0x11624
movl $0x0, -0x3c(%rbp)
cmpl $0x4, -0x3c(%rbp)
jae 0x11614
leaq 0x11f17(%rip), %rax     # 0x23498
movq (%rax), %rdi
movl -0x38(%rbp), %eax
movl -0x3c(%rbp), %edx
movzbl %al, %esi
callq 0xe250
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x11604
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
callq 0xe2d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x115db
movq -0x28(%rbp), %rdi
callq 0xe040
movq $0x0, -0x8(%rbp)
jmp 0x1162e
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x38(%rbp), %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb $0x0, (%rax,%rcx)
jmp 0x11614
jmp 0x11606
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11570
jmp 0x11616
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1155a
jmp 0x11626
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: match_chord
bool match_chord(chord_t *chord, uint8_t event_type, xcb_keysym_t keysym, xcb_button_t button, uint16_t modfield)
{
	for (chord_t *c = chord; c != NULL; c = c->more)
		if (c->event_type == event_type && c->keysym == keysym && c->button == button && (c->modfield == XCB_MOD_MASK_ANY || c->modfield == modfield))
			return true;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %r8w, %ax
movq %rdi, -0x10(%rbp)
movb %sil, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movw %ax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x11aec
movq -0x28(%rbp), %rax
movzbl 0x108(%rax), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x11ad9
movq -0x28(%rbp), %rax
movl 0x100(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x11ad9
movq -0x28(%rbp), %rax
movzbl 0x104(%rax), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x11ad9
movq -0x28(%rbp), %rax
movzwl 0x106(%rax), %eax
cmpl $0x8000, %eax           # imm = 0x8000
je 0x11ad3
movq -0x28(%rbp), %rax
movzwl 0x106(%rax), %eax
movzwl -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jne 0x11ad9
movb $0x1, -0x1(%rbp)
jmp 0x11af0
jmp 0x11adb
movq -0x28(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x11a72
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: abort_chain
void abort_chain(void)
{
	PUTS("abort chain");
	put_status(END_CHAIN_PREFIX, "End chain");
	for (hotkey_t *hk = hotkeys_head; hk != NULL; hk = hk->next)
		hk->chain->state = hk->chain->head;
	chained = false;
	locked = false;
	if (timeout > 0)
		alarm(0);
	ungrab();
	grab();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x45, %edi
leaq 0x78ef(%rip), %rsi      # 0x19403
callq 0xefc0
leaq 0x119a0(%rip), %rax     # 0x234c0
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11b54
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x11b27
leaq 0x11936(%rip), %rax     # 0x23491
movb $0x0, (%rax)
leaq 0x1192b(%rip), %rax     # 0x23490
movb $0x0, (%rax)
leaq 0x117f5(%rip), %rax     # 0x23364
cmpl $0x0, (%rax)
jle 0x11b7b
xorl %edi, %edi
callq 0xe1c0
callq 0xf5d0
callq 0xf090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: chains_interfere
bool chains_interfere(chain_t* a, chain_t* b) {
	chord_t* i = a->head;
	chord_t* j = b->head;
	for (; i && j; i = i->next, j = j->next) {
		bool match = false;
		for (chord_t* k = i; k; k = k->more) {
			if (match_chord(j, k->event_type, k->keysym, k->button, k->modfield)) {
				match = true;
				break;
			}
		}
		if (!match) {
			break;
		}
	}
	bool result = !i || !j;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x32(%rbp)
je 0x11bcd
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x11bd9
jmp 0x11c73
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x11c46
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movb 0x108(%rax), %sil
movq -0x30(%rbp), %rax
movl 0x100(%rax), %edx
movq -0x30(%rbp), %rax
movb 0x104(%rax), %cl
movq -0x30(%rbp), %rax
movzbl %sil, %esi
movzbl %cl, %ecx
movzwl 0x106(%rax), %r8d
callq 0x11a50
testb $0x1, %al
jne 0x11c2d
jmp 0x11c33
movb $0x1, -0x21(%rbp)
jmp 0x11c46
jmp 0x11c35
movq -0x30(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x11be5
testb $0x1, -0x21(%rbp)
jne 0x11c4e
jmp 0x11c73
jmp 0x11c50
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x11bb6
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x33(%rbp)
je 0x11c8c
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: add_chord
void add_chord(chain_t *chain, chord_t *chord)
{
	if (chain->head == NULL) {
		chain->head = chain->tail = chain->state = chord;
	} else {
		chain->tail->next = chord;
		chain->tail = chord;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x12023
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x12042
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x110(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: make_cycle
cycle_t *make_cycle(int delay, int period)
{
	cycle_t *cycle = malloc(sizeof(cycle_t));
	cycle->delay = delay;
	cycle->period = period;
	return cycle;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x8, %edi
callq 0xe270
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: make_hotkey
hotkey_t *make_hotkey(chain_t *chain, char *command)
{
	hotkey_t *hk = malloc(sizeof(hotkey_t));
	hk->chain = chain;
	hk->sync = false;
	if (command[0] == SYNCHRONOUS_CHAR) {
		command = lgraph(command+1);
		hk->sync = true;
	}
	snprintf(hk->command, sizeof(hk->command), "%s", command);
	hk->cycle = NULL;
	hk->next = hk->prev = NULL;
	return hk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x228, %edi            # imm = 0x228
callq 0xe270
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x208(%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
jne 0x1213c
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0xf8e0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movb $0x1, 0x208(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rcx
movl $0x200, %esi            # imm = 0x200
leaq 0x1025(%rip), %rdx      # 0x13179
movb $0x0, %al
callq 0xe170
movq -0x18(%rbp), %rax
movq $0x0, 0x210(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x218(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: add_hotkey
void add_hotkey(hotkey_t *hk)
{
	if (hotkeys_head == NULL) {
		hotkeys_head = hotkeys_tail = hk;
	} else {
		hotkeys_tail->next = hk;
		hk->prev = hotkeys_tail;
		hotkeys_tail = hk;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x11311(%rip), %rax     # 0x234c0
cmpq $0x0, (%rax)
jne 0x121cf
movq -0x8(%rbp), %rcx
leaq 0x112f8(%rip), %rax     # 0x234b8
movq %rcx, (%rax)
leaq 0x112f6(%rip), %rax     # 0x234c0
movq %rcx, (%rax)
jmp 0x12207
movq -0x8(%rbp), %rcx
leaq 0x112de(%rip), %rax     # 0x234b8
movq (%rax), %rax
movq %rcx, 0x218(%rax)
leaq 0x112cd(%rip), %rax     # 0x234b8
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x220(%rax)
movq -0x8(%rbp), %rcx
leaq 0x112b4(%rip), %rax     # 0x234b8
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: destroy_chain
void destroy_chain(chain_t *chain)
{
	chord_t *c = chain->head;
	while (c != NULL) {
		chord_t *n = c->next;
		destroy_chord(c);
		c = n;
	}
	free(chain);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12250
movq -0x10(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12260
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x12227
movq -0x8(%rbp), %rdi
callq 0xe040
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]sxhkd/src/types.c
// Function: destroy_chord
void destroy_chord(chord_t *chord)
{
	chord_t *c = chord->more;
	while (c != NULL) {
		chord_t *n = c->more;
		free(c);
		c = n;
	}
	free(chord);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x122a4
movq -0x10(%rbp), %rax
movq 0x118(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1227b
movq -0x8(%rbp), %rdi
callq 0xe040
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/begriffs[P]pthread-test/alarm_fork.c
// Function: main
int main(void)
{
	int seconds;
	char line[128], message[64];
	pid_t pid;

	while (printf("Alarm> ") &&
			fgets(line, sizeof(line), stdin))
	{
		if (strlen(line) <= 1)
			continue;
		if (sscanf(line, "%d %64[^\n]", &seconds, message) < 2)
			fputs("Bad command\n", stderr);
		else
		{
			if ((pid = fork()) == 0)
			{
				sleep(seconds);
				printf("(%d) %s\n", seconds, message);
				exit(EXIT_SUCCESS);
			}
			else if (pid > 0)
			{
				do
				{
					/* collect kids who have finished */
					pid = waitpid(-1, NULL, WNOHANG);
				} while (pid > 0);
			}
			else
				fputs("Failed fork()\n", stderr);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe2b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd5(%rbp)
je 0x1217
leaq -0x90(%rbp), %rdi
movq 0x2ddb(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x80, %esi
callq 0x1060
cmpq $0x0, %rax
setne %al
movb %al, -0xd5(%rbp)
movb -0xd5(%rbp), %al
testb $0x1, %al
jne 0x1226
jmp 0x12ff
leaq -0x90(%rbp), %rdi
callq 0x1030
cmpq $0x1, %rax
ja 0x123a
jmp 0x11d2
leaq -0x90(%rbp), %rdi
leaq -0xd0(%rbp), %rcx
leaq 0xdbd(%rip), %rsi       # 0x200c
leaq -0x8(%rbp), %rdx
movb $0x0, %al
callq 0x1070
cmpl $0x2, %eax
jge 0x127a
movq 0x2d92(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xda7(%rip), %rdi       # 0x2017
callq 0x1050
jmp 0x12fa
callq 0x10b0
movl %eax, -0xd4(%rbp)
cmpl $0x0, %eax
jne 0x12b1
movl -0x8(%rbp), %edi
callq 0x10a0
movl -0x8(%rbp), %esi
leaq -0xd0(%rbp), %rdx
leaq 0xd81(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1040
xorl %edi, %edi
callq 0x1090
cmpl $0x0, -0xd4(%rbp)
jle 0x12e0
jmp 0x12bc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x1080
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jg 0x12bc
jmp 0x12f6
movq 0x2d11(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
leaq 0xd3c(%rip), %rdi       # 0x202d
callq 0x1050
jmp 0x12f8
jmp 0x12fa
jmp 0x11d2
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/bench-base64unpack.c
// Function: wrap_LOOP
static inline uint64_t wrap_LOOP(
	bool (*unpack)(const char *s, uint32_t *v, unsigned *e),
	const char *s, uint32_t *v, unsigned *e,
	unsigned n, unsigned c)
{
    uint64_t t = rdtsc();
    asm volatile("" ::: "memory");
    const char *s_end = s + LOOP*c;
    do {
	bool ok = unpack(s, v, e);
	if (!ok)
	    return 0;
	v += n, s += c, e++;
    } while (s < s_end);
    asm volatile("" ::: "memory");
    return rdtsc() - t;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl %r9d, 0x18(%rsp)
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rsp), %ecx
shll $0x8, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq *%rax
andb $0x1, %al
movb %al, 0x7(%rsp)
testb $0x1, 0x7(%rsp)
jne 0x1214
movq $0x0, 0x40(%rsp)
jmp 0x126b
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x18(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x11e6
rdtsc
shlq $0x20, %rdx
orq %rdx, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack12x8c16
static inline bool unpack12x8c16(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x;
    if (!unpack6(s, &x)) return false;
    x = glue12(x);
    VSTORE(v + 0, VMOVZWLO(x));
    VSTORE(v + 4, VMOVZWHI(x));
    return (void) e, true;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1bbd0
testb $0x1, %al
jne 0xa921
movb $0x0, 0x2f(%rsp)
jmp 0xaa60
vmovdqa (%rsp), %xmm1
movl $0x40014001, 0x5c(%rsp) # imm = 0x40014001
movl 0x5c(%rsp), %eax
movl %eax, 0xbc(%rsp)
movl %eax, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
movl %eax, 0xb0(%rsp)
movl 0xb4(%rsp), %edx
movl 0xb8(%rsp), %ecx
movl 0xbc(%rsp), %eax
vmovd 0xb0(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0xa0(%rsp)
vmovdqa 0xa0(%rsp), %xmm0
vmovdqa %xmm1, 0x40(%rsp)
vmovdqa %xmm0, 0x30(%rsp)
vmovdqa 0x40(%rsp), %xmm0
vmovdqa 0x30(%rsp), %xmm1
vpmaddubsw %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
movq 0x18(%rsp), %rax
vmovdqa (%rsp), %xmm0
vmovdqa %xmm0, 0xc0(%rsp)
vpmovzxwd 0xc0(%rsp), %xmm0
movq %rax, 0x98(%rsp)
vmovdqa %xmm0, 0x80(%rsp)
vmovdqa 0x80(%rsp), %xmm0
movq 0x98(%rsp), %rax
vmovdqu %xmm0, (%rax)
movq 0x18(%rsp), %rax
addq $0x10, %rax
vmovdqa (%rsp), %xmm1
vxorps %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0xf0(%rsp)
vmovdqa 0xf0(%rsp), %xmm0
vmovdqa %xmm1, 0xe0(%rsp)
vmovdqa %xmm0, 0xd0(%rsp)
vmovdqa 0xe0(%rsp), %xmm0
vmovdqa 0xd0(%rsp), %xmm1
vpunpckhwd %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
movq %rax, 0x78(%rsp)
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x60(%rsp), %xmm0
movq 0x78(%rsp), %rax
vmovdqu %xmm0, (%rax)
movb $0x1, 0x2f(%rsp)
movb 0x2f(%rsp), %al
andb $0x1, %al
addq $0x108, %rsp            # imm = 0x108
retq
nop
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack12x16c32
static inline bool unpack12x16c32(const char *s, uint32_t *v, unsigned *e)
{
#ifdef W32x8
    W32x8 x, lo, hi;
    x = Wunpack6x(WLOAD(s), &lo, &hi);
    x = Wglue12(x);
    if (Wu6err(lo, hi)) return false;
    WSTORE(v + 0, WMOVZWLO(x));
    WSTORE(v + 8, WMOVZWHI(x));
    return (void) e, true;
#else
    V32x4 x, y;
    if (!unpack6(s +  0, &x)) return false;
    x = glue12(x);
    if (!unpack6(s + 16, &y)) return false;
    y = glue12(y);
    VSTORE(v +  0, VMOVZWLO(x));
    VSTORE(v +  4, VMOVZWHI(x));
    VSTORE(v +  8, VMOVZWLO(y));
    VSTORE(v + 12, VMOVZWHI(y));
    return (void) e, true;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
vmovups (%rax), %ymm0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1c800
vmovaps %ymm0, 0x60(%rsp)
vmovaps 0x60(%rsp), %ymm1
movl $0x40014001, 0x11c(%rsp) # imm = 0x40014001
movl 0x11c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl %eax, 0x20c(%rsp)
movl %eax, 0x208(%rsp)
movl %eax, 0x204(%rsp)
movl %eax, 0x200(%rsp)
movl %eax, 0x1fc(%rsp)
movl %eax, 0x1f8(%rsp)
movl %eax, 0x1f4(%rsp)
movl %eax, 0x1f0(%rsp)
movl 0x1f4(%rsp), %edx
movl 0x1f8(%rsp), %ecx
movl 0x1fc(%rsp), %eax
movl 0x204(%rsp), %r8d
movl 0x208(%rsp), %edi
movl 0x20c(%rsp), %esi
vmovd 0x200(%rsp), %xmm0
vpinsrd $0x1, %r8d, %xmm0, %xmm0
vpinsrd $0x2, %edi, %xmm0, %xmm0
vpinsrd $0x3, %esi, %xmm0, %xmm2
vmovd 0x1f0(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm3
vmovaps %xmm3, %xmm0
vinserti128 $0x1, %xmm2, %ymm0, %ymm0
vmovdqa %ymm0, 0x1c0(%rsp)
vmovdqa 0x1c0(%rsp), %ymm0
vmovdqa %ymm1, 0xe0(%rsp)
vmovdqa %ymm0, 0xc0(%rsp)
vmovdqa 0xe0(%rsp), %ymm0
vmovdqa 0xc0(%rsp), %ymm1
vpmaddubsw %ymm1, %ymm0, %ymm0
vmovdqa %ymm0, 0x60(%rsp)
vmovdqa 0x40(%rsp), %ymm0
vmovdqa 0x20(%rsp), %ymm1
callq 0x1d210
testb $0x1, %al
jne 0xac1f
jmp 0xac2c
movb $0x0, 0xb7(%rsp)
jmp 0xacca
movq 0xa0(%rsp), %rax
vmovaps 0x60(%rsp), %ymm0
vmovdqa %xmm0, 0x1b0(%rsp)
vpmovzxwd 0x1b0(%rsp), %ymm0
movq %rax, 0x198(%rsp)
vmovaps %ymm0, 0x160(%rsp)
vmovaps 0x160(%rsp), %ymm0
movq 0x198(%rsp), %rax
vmovups %ymm0, (%rax)
movq 0xa0(%rsp), %rax
addq $0x20, %rax
vmovdqa 0x70(%rsp), %xmm0
vmovdqa %xmm0, 0x1a0(%rsp)
vmovdqa 0x1a0(%rsp), %xmm0
vpmovzxwd %xmm0, %ymm0    # ymm0 = xmm0[0],zero,xmm0[1],zero,xmm0[2],zero,xmm0[3],zero,xmm0[4],zero,xmm0[5],zero,xmm0[6],zero,xmm0[7],zero
movq %rax, 0x158(%rsp)
vmovdqa %ymm0, 0x120(%rsp)
vmovdqa 0x120(%rsp), %ymm0
movq 0x158(%rsp), %rax
vmovdqu %ymm0, (%rax)
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
movq %rbp, %rsp
popq %rbp
vzeroupper
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack23x4c16e4
static inline bool unpack23x4c16e4(const char *s, uint32_t *v, unsigned *e)
{
    V32x4 x, y;
    if (!unpack6(s, &x)) return false;
#ifdef VMOVSIGN32
    y = VSHL32(x, 31);
    x = glue12(x);
    *e = VMOVSIGN32(y);
#else
    y = VSHUF8(x, V8x16_C(
	     0,  4,  8, 12, -1, -1, -1, -1,
	    -1, -1, -1, -1, -1, -1, -1, -1));
    x = glue12(x);
    *e = (y[0] & 0x1010101) * 0x10204080 >> 28;
#endif
    x = glue24(x);
    VSTORE(v, VSHR32(x, 1));
    return true;
}

// Assembly:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1bbd0
testb $0x1, %al
jne 0x10803
movb $0x0, 0x3f(%rsp)
jmp 0x109ff
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm0, 0x110(%rsp)
movl $0x1f, 0x10c(%rsp)
vmovdqa 0x110(%rsp), %xmm0
vmovd 0x10c(%rsp), %xmm1
vpslld %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm1
movl $0x40014001, 0x8c(%rsp) # imm = 0x40014001
movl 0x8c(%rsp), %eax
movl %eax, 0xdc(%rsp)
movl %eax, 0xd8(%rsp)
movl %eax, 0xd4(%rsp)
movl %eax, 0xd0(%rsp)
movl 0xd4(%rsp), %edx
movl 0xd8(%rsp), %ecx
movl 0xdc(%rsp), %eax
vmovd 0xd0(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0xc0(%rsp)
vmovdqa 0xc0(%rsp), %xmm0
vmovdqa %xmm1, 0x70(%rsp)
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vmovdqa 0x60(%rsp), %xmm1
vpmaddubsw %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
vmovdqa (%rsp), %xmm0
vmovdqa %xmm0, 0x130(%rsp)
vmovdqa 0x130(%rsp), %xmm0
vmovdqa %xmm0, 0x120(%rsp)
vmovaps 0x120(%rsp), %xmm0
vmovmskps %xmm0, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
vmovdqa 0x10(%rsp), %xmm1
movl $0x10000001, 0x88(%rsp) # imm = 0x10000001
movl 0x88(%rsp), %eax
movl %eax, 0x108(%rsp)
movl %eax, 0x104(%rsp)
movl %eax, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
movl 0x100(%rsp), %edx
movl 0x104(%rsp), %ecx
movl 0x108(%rsp), %eax
vmovd 0xfc(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0xe0(%rsp)
vmovdqa 0xe0(%rsp), %xmm0
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vmovdqa 0x40(%rsp), %xmm1
vpmaddwd %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rax
vmovdqa 0x10(%rsp), %xmm0
vmovdqa %xmm0, 0xb0(%rsp)
movl $0x1, 0xac(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
movl 0xac(%rsp), %ecx
vmovd %ecx, %xmm1
vpsrld %xmm1, %xmm0, %xmm0
movq %rax, 0xa0(%rsp)
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0x90(%rsp), %xmm0
movq 0xa0(%rsp), %rax
vmovdqu %xmm0, (%rax)
movb $0x1, 0x3f(%rsp)
movb 0x3f(%rsp), %al
andb $0x1, %al
addq $0x148, %rsp            # imm = 0x148
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-simd.h
// Function: unpack24
static inline bool unpack24(const char *s, V32x4 *x)
{
    V32x4 lo, hi;
    *x = unpack6x(VLOAD(s), &lo, &hi);
    bool err = u6err(lo, hi);
    *x = glue12(*x);
    *x = glue24(*x);
    return !err;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
vmovdqu (%rax), %xmm0
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1bc20
movq 0x30(%rsp), %rax
vmovdqa %xmm0, (%rax)
vmovdqa 0x20(%rsp), %xmm0
vmovdqa 0x10(%rsp), %xmm1
callq 0x1c150
movb %al, 0xf(%rsp)
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm1
movl $0x40014001, 0x84(%rsp) # imm = 0x40014001
movl 0x84(%rsp), %eax
movl %eax, 0xac(%rsp)
movl %eax, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
movl %eax, 0xa0(%rsp)
movl 0xa4(%rsp), %edx
movl 0xa8(%rsp), %ecx
movl 0xac(%rsp), %eax
vmovd 0xa0(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0x90(%rsp)
vmovdqa 0x90(%rsp), %xmm0
vmovdqa %xmm1, 0x70(%rsp)
vmovdqa %xmm0, 0x60(%rsp)
vmovdqa 0x70(%rsp), %xmm0
vmovdqa 0x60(%rsp), %xmm1
vpmaddubsw %xmm1, %xmm0, %xmm0
movq 0x30(%rsp), %rax
vmovdqa %xmm0, (%rax)
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm1
movl $0x10000001, 0x80(%rsp) # imm = 0x10000001
movl 0x80(%rsp), %eax
movl %eax, 0xd4(%rsp)
movl %eax, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
movl %eax, 0xc8(%rsp)
movl 0xcc(%rsp), %edx
movl 0xd0(%rsp), %ecx
movl 0xd4(%rsp), %eax
vmovd 0xc8(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0xb0(%rsp), %xmm0
vmovdqa %xmm1, 0x50(%rsp)
vmovdqa %xmm0, 0x40(%rsp)
vmovdqa 0x50(%rsp), %xmm0
vmovdqa 0x40(%rsp), %xmm1
vpmaddwd %xmm1, %xmm0, %xmm0
movq 0x30(%rsp), %rax
vmovdqa %xmm0, (%rax)
movb 0xf(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dnbaker[P]fastiota/testfastiota_c.c
// Function: main
int main() {
    int n = 400;
    uint32_t *ptr = (uint32_t *)malloc(n * sizeof(uint32_t));
    fastiota32(ptr, n, 13);
    for(uint32_t *s = ptr; s < ptr + n; ++s) fprintf(stderr, "%u,", *s);
    fputc('\n', stderr);
    free(ptr);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl $0x190, 0x10(%rsp)      # imm = 0x190
movslq 0x10(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1070
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movslq 0x10(%rsp), %rsi
movl $0xd, %edx
callq 0x1240
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movslq 0x10(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x120a
movq 0x2e13(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsp), %rax
movl (%rax), %edx
leaq 0xe4b(%rip), %rsi       # 0x2040
movb $0x0, %al
callq 0x1060
movq (%rsp), %rax
addq $0x4, %rax
movq %rax, (%rsp)
jmp 0x11c4
movq 0x2de7(%rip), %rax      # 0x3ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1050
movq 0x8(%rsp), %rdi
callq 0x1030
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dcat[P]mdphat/mdphat.c
// Function: i2c_set
__u8
i2c_set(__u8 reg, __u8 arg) {
	__u8 buf[2];

	buf[0] = reg;
	buf[1] = arg;

	return write(d, buf, 2) == 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x4(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x3(%rbp)
movl 0x13992a(%rip), %edi    # 0x53b050
leaq -0x4(%rbp), %rsi
movl $0x2, %edx
callq 0x449120
cmpq $0x2, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dcat[P]mdphat/mdphat.c
// Function: i2c_get
__u8
i2c_get(__u8 reg, __u8 *ret, size_t n) {
	__u8 r;

	r = reg | 0xFF;

	if (write(d, &r, 1) <= 0)
		return 0;

	return read(d, ret, n) == n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movzbl -0x2(%rbp), %eax
orl $0xff, %eax
movb %al, -0x19(%rbp)
movl 0x1398d8(%rip), %edi    # 0x53b050
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x449120
cmpq $0x0, %rax
jg 0x401792
movb $0x0, -0x1(%rbp)
jmp 0x4017b4
movl 0x1398b8(%rip), %edi    # 0x53b050
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x449080
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dcat[P]mdphat/mdphat.c
// Function: printchar
void
printchar(int x, int chr) {
	int i, y, z;
	char buf[7], reg;

	reg = x % 2 ? CMD_MATRIX2 : CMD_MATRIX1;

	i2c_adr(MDH_ADR + x / 2);

	switch (chr) {
	case '\0':
	case '\n':
	case '\r':
		return;
	}

	if (x % 2) {
		/* flip */
		for (i = 0, y = 7; i < 7; i++, y--)
			buf[i] = 0;

		for (i = 0; i < 8; i++)
			for (y = 0; y < 7; y++)
				buf[i] |= font[chr][y] & (1 << i) ? 1 << y : 0;

		for (i = 0; i < 7; i++)
			i2c_set(reg + i, buf[i]);
	} else
		for (i = 0; i < 7; i++)
			i2c_set(reg + i, font[chr][i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %edx
shrl $0x1f, %edx
movl %eax, %ecx
addl %edx, %ecx
andl $-0x2, %ecx
subl %ecx, %eax
movl $0xe, %ecx
movl $0x1, %eax
cmovnel %ecx, %eax
movb %al, -0x1c(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %ecx, %eax
shrl %eax
addl $0x61, %eax
movzbl %al, %edi
callq 0x4017c0
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x401856
jmp 0x401842
movl -0x20(%rbp), %eax
subl $0xa, %eax
je 0x401856
jmp 0x40184c
movl -0x20(%rbp), %eax
subl $0xd, %eax
jne 0x40185b
jmp 0x401856
jmp 0x4019a0
movl -0x4(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x40195b
movl $0x0, -0xc(%rbp)
movl $0x7, -0x10(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x4018a0
movslq -0xc(%rbp), %rax
movb $0x0, -0x1b(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x40187d
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x401927
movl $0x0, -0x10(%rbp)
cmpl $0x7, -0x10(%rbp)
jge 0x40191a
movslq -0x8(%rbp), %rcx
leaq 0xc782b(%rip), %rax     # 0x4c90f0
imulq $0x7, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x4018f6
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
jmp 0x4018fd
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x4018fd
movl -0x24(%rbp), %edx
movslq -0xc(%rbp), %rax
movsbl -0x1b(%rbp,%rax), %ecx
orl %edx, %ecx
movb %cl, -0x1b(%rbp,%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4018b4
jmp 0x40191c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4018a7
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x401959
movsbl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movb %al, %cl
movslq -0xc(%rbp), %rax
movzbl %cl, %edi
movzbl -0x1b(%rbp,%rax), %esi
callq 0x401700
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40192e
jmp 0x4019a0
movl $0x0, -0xc(%rbp)
cmpl $0x7, -0xc(%rbp)
jge 0x40199e
movsbl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0xc7774(%rip), %rax     # 0x4c90f0
imulq $0x7, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movzbl %dl, %edi
movzbl (%rax,%rcx), %esi
callq 0x401700
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x401962
jmp 0x4019a0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dcat[P]mdphat/mdphat.c
// Function: printstring
void
printstring(char *str) {
	int x = 0;
	char *p = str;

	while (*p) {
		printchar(x++, *p++);

		if (x > 5)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x401a00
movl -0xc(%rbp), %edi
movl %edi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %esi
callq 0x4017f0
cmpl $0x5, -0xc(%rbp)
jle 0x4019fe
jmp 0x401a00
jmp 0x4019cb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dcat[P]mdphat/mdphat.c
// Function: i2c_set_all
void
i2c_set_all(__u8 reg, __u8 val) {
	int i;

	for (i = 0; i < 3; i++) {
		i2c_adr(MDH_ADR + i);
		i2c_set(reg, val);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x401a59
movl -0x8(%rbp), %eax
addl $0x61, %eax
movzbl %al, %edi
callq 0x4017c0
movb -0x1(%rbp), %al
movzbl %al, %edi
movzbl -0x2(%rbp), %esi
callq 0x401700
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x401a2b
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/setjmp2.c
// Function: func1
int func1(char *s, jmp_buf env)
{
	int ret;

	ret = setjmp(env);
	printf("func1: setjmp() returned %d\n", ret);

	printf("func1: &s=%p\n", s);
	printf("func1: s=%s\n", s);

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0xe7e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rsi
leaq 0xe89(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rsi
leaq 0xe85(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/setjmp2.c
// Function: main
int main(int argc, char *argv[])
{
	jmp_buf env;
	int ret;

	ret = func1("foo", env);
	if (ret)
		return -1;

	func2(3, env);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xe0(%rbp), %rsi
leaq 0xe3c(%rip), %rdi       # 0x2063
callq 0x1160
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe4(%rbp)
je 0x1244
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x125c
leaq -0xe0(%rbp), %rsi
movl $0x3, %edi
callq 0x11c0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/reverb2/reverb2.c
// Function: processData
static void
processData(FILE *in,FILE *out,RRA *h)
    {
    int amp;

    amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    while (!feof(in))
        {
        fprintf(out,"%d\n",(int)(get(amp) * AmpFactor));
        update(amp);
        //getchar();
        amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        }
   }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x8296(%rip), %rcx      # 0xab80
callq 0x9ed0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x21b0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2909
jmp 0x2963
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %edi
callq 0x2970
movq -0x28(%rbp), %rdi
cvtsi2sd %eax, %xmm0
mulsd 0xf8e7(%rip), %xmm0     # 0x12210
cvttsd2si %xmm0, %edx
leaq 0xaf09(%rip), %rsi      # 0xd83d
movb $0x0, %al
callq 0x2190
movl -0x1c(%rbp), %edi
callq 0x29a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x8227(%rip), %rcx      # 0xab80
callq 0x9ed0
movl %eax, -0x1c(%rbp)
jmp 0x28f2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/reverb2/reverb2.c
// Function: getCombs
static int
getCombs(int in)
    {
    int i;
    int middle = 0;
    for (i = 0; i < COMBS; ++i)
        middle += getLPC(early[i],in);
    return middle;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x6, -0x8(%rbp)
jge 0x2a17
movslq -0x8(%rbp), %rcx
leaq 0xfab6(%rip), %rax      # 0x124b0
movq (%rax,%rcx,8), %rdi
movl -0x4(%rbp), %esi
callq 0xc470
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x29e9
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: interp2
int
interp2(int *data,int length,double t)
    {
    int x;
    double mu;
    double mu2;

    if (t >= length) return data[length - 1];

    x = (int) t;
    mu = t - x;
    mu2 = (1-cos(mu*3.14159))/2;
    return(data[x]*(1-mu2)+data[x+1]*mu2);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jb 0x2b1c
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x2ba9
cvttsd2si -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movsd -0x20(%rbp), %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0xa7f9(%rip), %xmm0     # 0xd338
mulsd -0x30(%rbp), %xmm0
callq 0x2140
movaps %xmm0, %xmm1
movsd 0xa7d4(%rip), %xmm0     # 0xd328
subsd %xmm1, %xmm0
movsd 0xa7d0(%rip), %xmm1     # 0xd330
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm0
movsd 0xa7aa(%rip), %xmm2     # 0xd328
subsd -0x38(%rbp), %xmm2
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cvtsi2sdl (%rax,%rcx,4), %xmm1
mulsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: openOutput
void
openOutput(char *fn,int sr,int bps)
    {
    if (closed == 0)
        Fatal("attempt to open output wave when "
                "previous has not yet been closed\n");

    if (sr > 0) SampleRate = sr;
    if (bps > 0) bitsPerSample = bps;

    fprintf(stderr,"sampleRate is %d\n",SampleRate);
    fprintf(stderr,"bits per sample is %d\n",bitsPerSample);

    outputName = fn;
    output = newRRA(SampleRate,bitsPerSample,1,OUTPUT_LENGTH);

    clearRRAData(output);

    location = 0;
    maxLocation = 0;

    closed = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, 0xf82b(%rip)      # 0x12404
jne 0x2be9
leaq 0xa802(%rip), %rdi      # 0xd3e4
movb $0x0, %al
callq 0x8c70
cmpl $0x0, -0xc(%rbp)
jle 0x2bf8
movl -0xc(%rbp), %eax
movl %eax, 0xf808(%rip)      # 0x12400
cmpl $0x0, -0x10(%rbp)
jle 0x2c07
movl -0x10(%rbp), %eax
movl %eax, 0xf801(%rip)      # 0x12408
movq 0xf3ea(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl 0xf7e9(%rip), %edx      # 0x12400
leaq 0xa809(%rip), %rsi      # 0xd427
movb $0x0, %al
callq 0x2190
movq 0xf3cc(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movl 0xf7d3(%rip), %edx      # 0x12408
leaq 0xa7fd(%rip), %rsi      # 0xd439
movb $0x0, %al
callq 0x2190
movq -0x8(%rbp), %rax
movq %rax, 0x1f07a(%rip)     # 0x21cc8
movl 0xf7ac(%rip), %edi      # 0x12400
movl 0xf7ae(%rip), %esi      # 0x12408
movl $0x1, %edx
movl $0x186a0, %ecx          # imm = 0x186A0
callq 0x9190
movq %rax, 0x1f060(%rip)     # 0x21cd0
movq 0x1f059(%rip), %rdi     # 0x21cd0
callq 0x9310
xorps %xmm0, %xmm0
movsd %xmm0, 0x1f051(%rip)    # 0x21cd8
movl $0x0, 0x1f04f(%rip)     # 0x21ce0
movl $0x0, 0xf769(%rip)      # 0x12404
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: readScale
int
readScale(char *dirName,char *baseName)
    {
    int inst = InstrumentCount;

    ++InstrumentCount;

    if (InstrumentCount >= INSTRUMENTS)
        Fatal("readScale: too many instruments, the max is %d\n",INSTRUMENTS);

    InstrumentDir[inst] = strdup(dirName);
    InstrumentBase[inst] = strdup(baseName);

    pitchShift[inst] = 0;

    return inst;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1f01e(%rip), %eax     # 0x21ce4
movl %eax, -0x14(%rbp)
movl 0x1f015(%rip), %eax     # 0x21ce4
addl $0x1, %eax
movl %eax, 0x1f00c(%rip)     # 0x21ce4
cmpl $0x28, 0x1f005(%rip)    # 0x21ce4
jl 0x2cf4
leaq 0xa768(%rip), %rdi      # 0xd450
movl $0x28, %esi
movb $0x0, %al
callq 0x8c70
movq -0x8(%rbp), %rdi
callq 0x2280
movq %rax, %rdx
movslq -0x14(%rbp), %rcx
leaq 0x1efe5(%rip), %rax     # 0x21cf0
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
callq 0x2280
movq %rax, %rdx
movslq -0x14(%rbp), %rcx
leaq 0x1f10a(%rip), %rax     # 0x21e30
movq %rdx, (%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
leaq 0x1f23b(%rip), %rax     # 0x21f70
movl $0x0, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: readStrings
int *
readStrings(char *dirName, char *baseName, int strings)
    {
    int i = 0;
    int *result = malloc((strings+1)*sizeof(int));
    if (result == 0)
        {
        fprintf(stderr, "Out of memory\n");
        exit(1);
        }
    for (i = 0; i < (strings + 1); ++i)
        {
        char newBase[512];
        snprintf(newBase, sizeof(newBase), "%s%d_", baseName, i);
        result[i] = readScale(dirName, newBase);
        }
    return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2dac
movq 0xf267(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0xa6e5(%rip), %rsi      # 0xd480
movb $0x0, %al
callq 0x2190
movl $0x1, %edi
callq 0x2270
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2e0a
leaq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %r8d
movl $0x200, %esi            # imm = 0x200
leaq 0xa6b4(%rip), %rdx      # 0xd48f
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x2cb0
movl %eax, %edx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2db3
movq -0x20(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setPlay
PLAYER
setPlay(PLAYER f)
    {
    static PLAYER old = (PLAYER) 0;
    if (f == 0)
        {
        PLAYER temp = play;
        play = old;
        return temp;
        }
    else
        {
        old = play;
        play = f;
        return old;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2e92
movq 0xf5a2(%rip), %rax      # 0x12418
movq %rax, -0x18(%rbp)
movq 0x1f18f(%rip), %rax     # 0x22010
movq %rax, 0xf590(%rip)      # 0x12418
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2eb6
movq 0xf57f(%rip), %rax      # 0x12418
movq %rax, 0x1f170(%rip)     # 0x22010
movq -0x10(%rbp), %rax
movq %rax, 0xf56d(%rip)      # 0x12418
movq 0x1f15e(%rip), %rax     # 0x22010
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: rdrone
void
rdrone(double beats,RRA *h,double length)
    {
    dTrace("entering\n");

    while (beats > 1.5 * length)
        {
        dplay(1.5 * length,h->data[0],h->samples,h->bitsPerSample);
        //attack = 1 - sustain;
        backwards(length / 2);
        beats = beats - length;
        }

    dplay(beats,h->data[0],h->samples,h->bitsPerSample);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0xa40d(%rip), %xmm1     # 0xd340
mulsd -0x18(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2f90
movsd 0xa3fa(%rip), %xmm0     # 0xd340
mulsd -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x31c0
movsd -0x18(%rbp), %xmm0
movsd 0xa3ba(%rip), %xmm1     # 0xd330
divsd %xmm1, %xmm0
callq 0x3870
movsd -0x8(%rbp), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2f26
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x31c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: snplay
void
snplay(double beats,int inst,int offset)
    {
    RRA *h;
    int spot;

    dTrace("entering\n");

    h = getNumberedNote(inst,offset);

    spot = getLocation();
    dplay(samplesToBeats(h->samples),h->data[0],h->samples,h->bitsPerSample);
    setLocation(spot + beatsToSamples(beats));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3180
movq %rax, -0x18(%rbp)
callq 0x38b0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cvtsi2sdl 0xc(%rax), %xmm0
callq 0x38c0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x31c0
cvtsi2sdl -0x1c(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
callq 0x3980
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %edi
callq 0x38f0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: nplay
void
_nplay(double beats,int inst,int offset)
    {
    RRA *h;
 
    dTrace("entering\n");

    // if style is SWING,
    //swing beats are pulled longer and shorter, alternately

    if (style == SWING && swingBeat == beats)
        {
        if (swingDown) beats = beats * 4 / 3;
        else beats = beats *2 / 3;
        swingDown = !swingDown;
        }

    h = getNumberedNote(inst,offset);
    dplay(beats,h->data[0],h->samples,h->bitsPerSample);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x1, 0xf44a(%rip)      # 0x12514
jne 0x313b
movsd 0xf30c(%rip), %xmm0     # 0x123e0
ucomisd -0x8(%rbp), %xmm0
jne 0x313b
jp 0x313b
cmpl $0x0, 0xf304(%rip)      # 0x123e8
je 0x3106
movsd 0x9f1a(%rip), %xmm0     # 0xd008
mulsd -0x8(%rbp), %xmm0
movsd 0xa24d(%rip), %xmm1     # 0xd348
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3124
movsd 0xa222(%rip), %xmm0     # 0xd330
mulsd -0x8(%rbp), %xmm0
movsd 0xa22d(%rip), %xmm1     # 0xd348
divsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
cmpl $0x0, 0xf2bd(%rip)      # 0x123e8
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xf2ad(%rip)      # 0x123e8
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3180
movq %rax, -0x18(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x31c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/lib/songlib.c
// Function: setNPlay
NPLAYER
setNPlay(NPLAYER f)
    {
    static NPLAYER old = (NPLAYER) 0;
    if (f == 0)
        {
        NPLAYER temp = nplay;
        nplay = old;
        return temp;
        }
    else
        {
        old = nplay;
        nplay = f;
        return old;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x37f2
movq 0xec3a(%rip), %rax      # 0x12410
movq %rax, -0x18(%rbp)
movq 0x1e837(%rip), %rax     # 0x22018
movq %rax, 0xec28(%rip)      # 0x12410
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3816
movq 0xec17(%rip), %rax      # 0x12410
movq %rax, 0x1e818(%rip)     # 0x22018
movq -0x10(%rbp), %rax
movq %rax, 0xec05(%rip)      # 0x12410
movq 0x1e806(%rip), %rax     # 0x22018
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)