LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: extract_chunks
chunk_t *extract_chunks(char *s)
{
	size_t len = strlen(s);
	unsigned int i = 0, j = 0;
	bool inhibit = false;
	int num_seq = 0;
	chunk_t *c = make_chunk();
	chunk_t *head = c;
	while (i < len) {
		if (inhibit) {
			c->text[j++] = s[i];
			inhibit = false;
		} else if (s[i] == MAGIC_INHIBIT) {
			inhibit = true;
			if ((s[i+1] != MAGIC_INHIBIT || c->sequence)
					&& s[i+1] != SEQ_BEGIN
					&& s[i+1] != SEQ_END)
				c->text[j++] = s[i];
		} else if (s[i] == SEQ_BEGIN) {
			if (j > 0) {
				c->text[j] = '\0';
				j = 0;
				chunk_t *next = make_chunk();
				c->next = next;
				c = next;
			}
			c->sequence = true;
		} else if (s[i] == SEQ_END) {
			if (c->sequence)
				num_seq++;
			if (j > 0) {
				c->text[j] = '\0';
				j = 0;
				chunk_t *next = make_chunk();
				c->next = next;
				c = next;
			}
			c->sequence = false;
		} else {
			c->text[j++] = s[i];
		}
		i++;
	}
	c->text[j] = '\0';
	return head;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xe130
movq %rax, %r15
movl $0x1, %edi
movl $0x418, %esi            # imm = 0x418
callq 0xe200
movq %rax, %rbx
movb $0x1, 0x409(%rax)
xorl %eax, %eax
testq %r15, %r15
je 0xfb96
movl $0x1, %ebp
xorl %r13d, %r13d
xorl %ecx, %ecx
movq %rbx, %r12
movb (%r14,%r13), %dl
movl %ebp, %r13d
testb $0x1, %cl
je 0xfad1
movl %eax, %ecx
incl %eax
movb %dl, (%r12,%rcx)
xorl %ecx, %ecx
jmp 0xfb87
movzbl %dl, %ecx
cmpl $0x7d, %ecx
je 0xfb4e
cmpl $0x7b, %ecx
je 0xfb17
cmpl $0x5c, %ecx
jne 0xfac2
movzbl (%r14,%r13), %edx
movb $0x1, %cl
cmpl $0x7d, %edx
je 0xfb87
cmpl $0x7b, %edx
je 0xfb87
cmpl $0x5c, %edx
jne 0xfb0c
cmpb $0x1, 0x408(%r12)
jne 0xfb87
movl %eax, %edx
incl %eax
movb $0x5c, (%r12,%rdx)
jmp 0xfb87
testl %eax, %eax
je 0xfb43
movl %eax, %eax
movb $0x0, (%r12,%rax)
movl $0x1, %edi
movl $0x418, %esi            # imm = 0x418
callq 0xe200
movb $0x1, 0x409(%rax)
movq %rax, 0x410(%r12)
movq %rax, %r12
movb $0x1, 0x408(%r12)
jmp 0xfb83
testl %eax, %eax
je 0xfb7a
movl %eax, %eax
movb $0x0, (%r12,%rax)
movl $0x1, %edi
movl $0x418, %esi            # imm = 0x418
callq 0xe200
movb $0x1, 0x409(%rax)
movq %rax, 0x410(%r12)
movq %rax, %r12
movb $0x0, 0x408(%r12)
xorl %ecx, %ecx
xorl %eax, %eax
incl %ebp
cmpq %r13, %r15
ja 0xfab6
movl %eax, %eax
jmp 0xfb99
movq %rbx, %r12
movb $0x0, (%r12,%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: destroy_chunks
void destroy_chunks(chunk_t *chunk)
{
	chunk_t *c = chunk;
	while (c != NULL) {
		chunk_t *next = c->next;
		free(c);
		c = next;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xfbcb
pushq %rbx
movq 0x410(%rdi), %rbx
callq 0xe040
movq %rbx, %rdi
testq %rbx, %rbx
jne 0xfbb6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: get_token
char *get_token(char *dst, char *ign, char *src, char *sep)
{
	size_t len = strlen(src);
	unsigned int i = 0, j = 0, k = 0;
	bool inhibit = false;
	bool found = false;
	while (i < len && !found) {
		if (inhibit) {
			dst[j++] = src[i];
			inhibit = false;
		} else if (src[i] == MAGIC_INHIBIT) {
			inhibit = true;
			if (src[i+1] != MAGIC_INHIBIT && strchr(sep, src[i+1]) == NULL)
				dst[j++] = src[i];
		} else if (strchr(sep, src[i]) != NULL) {
			if (j > 0)
				found = true;
			do {
				if (ign != NULL)
					ign[k++] = src[i];
				i++;
			} while (i < len && strchr(sep, src[i]) != NULL);
			i--;
		} else {
			dst[j++] = src[i];
		}
		i++;
	}
	dst[j] = '\0';
	if (ign != NULL)
		ign[k] = '\0';
	return src + i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rdx, %rdi
callq 0xe130
xorl %ebp, %ebp
testq %rax, %rax
je 0x10162
movq %rax, %r13
xorl %eax, %eax
xorl %ecx, %ecx
movl $0x0, (%rsp)
xorl %r15d, %r15d
movb (%rbx,%rax), %r12b
testb $0x1, %cl
je 0x100c5
xorl %ecx, %ecx
movl (%rsp), %edx
movl %edx, %eax
incl %edx
movl %edx, (%rsp)
movq 0x10(%rsp), %rdx
movb %r12b, (%rdx,%rax)
xorl %edx, %edx
movl %r15d, %eax
incl %eax
cmpq %rax, %r13
jbe 0x1015b
movl %eax, %r15d
testb %dl, %dl
je 0x1008b
jmp 0x1015b
cmpb $0x5c, %r12b
jne 0x100de
leal 0x1(%r15), %eax
movsbl (%rbx,%rax), %esi
cmpl $0x5c, %esi
jne 0x1013e
xorl %edx, %edx
movb $0x1, %cl
jmp 0x100ab
movsbl %r12b, %esi
movq 0x8(%rsp), %rdi
callq 0xe160
testq %rax, %rax
je 0x10094
cmpl $0x0, (%rsp)
setne %al
movl %eax, 0x4(%rsp)
movl %r15d, %r12d
testq %r14, %r14
je 0x10112
movl %r12d, %eax
movb (%rbx,%rax), %al
movl %ebp, %ecx
incl %ebp
movb %al, (%r14,%rcx)
leal 0x1(%r12), %r15d
cmpq %r15, %r13
jbe 0x10130
movsbl (%rbx,%r15), %esi
movq 0x8(%rsp), %rdi
callq 0xe160
testq %rax, %rax
jne 0x100fc
xorl %ecx, %ecx
movl %r12d, %r15d
movl 0x4(%rsp), %edx
jmp 0x100ab
movq 0x8(%rsp), %rdi
callq 0xe160
movb $0x1, %cl
testq %rax, %rax
jne 0x100a9
movb $0x5c, %r12b
jmp 0x10096
movl (%rsp), %ecx
movl %ebp, %ebp
jmp 0x10166
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x10(%rsp), %rdx
movb $0x0, (%rdx,%rcx)
testq %r14, %r14
je 0x10179
movb $0x0, (%r14,%rbp)
addq %rax, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: parse_keysym
bool parse_keysym(char *name, xcb_keysym_t *keysym)
{
	for (unsigned int i = 0; i < LENGTH(nks_dict); i++) {
		keysym_dict_t nks = nks_dict[i];
		if (strcmp(name, nks.name) == 0) {
			*keysym = nks.keysym;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x9e31(%rip), %rsi      # 0x1a210
callq 0xe220
testl %eax, %eax
je 0x10422
movq $-0x1, %r12
leaq 0x9e1a(%rip), %r15      # 0x1a210
cmpq $0x810, %r12            # imm = 0x810
je 0x10433
movq 0x10(%r15), %rsi
addq $0x10, %r15
movq %r14, %rdi
callq 0xe220
incq %r12
testl %eax, %eax
jne 0x103f6
cmpq $0x811, %r12            # imm = 0x811
setb %al
jmp 0x1042b
leaq 0x9de7(%rip), %r15      # 0x1a210
movb $0x1, %al
movl 0x8(%r15), %ecx
movl %ecx, (%rbx)
jmp 0x10435
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: modfield_from_keysym
int16_t modfield_from_keysym(xcb_keysym_t keysym)
{
	uint16_t modfield = 0;
	xcb_keycode_t *keycodes = NULL;
	if ((keycodes = keycodes_from_keysym(keysym)) != NULL) {
		for (xcb_keycode_t *k = keycodes; *k != XCB_NO_SYMBOL; k++)
			modfield |= modfield_from_keycode(*k);
	}
	free(keycodes);
	return modfield;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
callq 0x106d4
movq %rax, %rbx
testq %rax, %rax
je 0x104a2
movb (%rbx), %al
testb %al, %al
je 0x104a2
movq %rbx, %r14
incq %r14
xorl %ebp, %ebp
movzbl %al, %edi
callq 0xf9a4
orl %eax, %ebp
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x1048c
jmp 0x104a4
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xe040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/baskerville[P]sxhkd/src/parse.c
// Function: get_standard_keysyms
void get_standard_keysyms(void)
{
#define GETKS(X) \
	if (!parse_keysym(#X, &X)) \
		warn("Couldn't retrieve keysym for '%s'.\n", #X); \
	else \
		PRINTF("keysym for '%s' is 0x%X.\n", #X, X);
	GETKS(Alt_L)
	GETKS(Alt_R)
	GETKS(Super_L)
	GETKS(Super_R)
	GETKS(Hyper_L)
	GETKS(Hyper_R)
	GETKS(Mode_switch)
	GETKS(Num_Lock)
	GETKS(Scroll_Lock)
#undef GETKS
}

// Assembly:
pushq %rax
leaq 0x116c(%rip), %rdi      # 0x1167f
leaq 0x123a6(%rip), %rsi     # 0x228c0
callq 0x103ca
testb %al, %al
jne 0x10538
leaq 0x6eb7(%rip), %rdi      # 0x173e1
leaq 0x114e(%rip), %rsi      # 0x1167f
xorl %eax, %eax
callq 0xe410
leaq 0x1146(%rip), %rdi      # 0x11685
leaq 0x1237e(%rip), %rsi     # 0x228c4
callq 0x103ca
testb %al, %al
jne 0x10564
leaq 0x6e8b(%rip), %rdi      # 0x173e1
leaq 0x1128(%rip), %rsi      # 0x11685
xorl %eax, %eax
callq 0xe410
leaq 0x1120(%rip), %rdi      # 0x1168b
leaq 0x12356(%rip), %rsi     # 0x228c8
callq 0x103ca
testb %al, %al
jne 0x10590
leaq 0x6e5f(%rip), %rdi      # 0x173e1
leaq 0x1102(%rip), %rsi      # 0x1168b
xorl %eax, %eax
callq 0xe410
leaq 0x10fc(%rip), %rdi      # 0x11693
leaq 0x1232e(%rip), %rsi     # 0x228cc
callq 0x103ca
testb %al, %al
jne 0x105bc
leaq 0x6e33(%rip), %rdi      # 0x173e1
leaq 0x10de(%rip), %rsi      # 0x11693
xorl %eax, %eax
callq 0xe410
leaq 0x10d8(%rip), %rdi      # 0x1169b
leaq 0x12306(%rip), %rsi     # 0x228d0
callq 0x103ca
testb %al, %al
jne 0x105e8
leaq 0x6e07(%rip), %rdi      # 0x173e1
leaq 0x10ba(%rip), %rsi      # 0x1169b
xorl %eax, %eax
callq 0xe410
leaq 0x10b4(%rip), %rdi      # 0x116a3
leaq 0x122de(%rip), %rsi     # 0x228d4
callq 0x103ca
testb %al, %al
jne 0x10614
leaq 0x6ddb(%rip), %rdi      # 0x173e1
leaq 0x1096(%rip), %rsi      # 0x116a3
xorl %eax, %eax
callq 0xe410
leaq 0xe10(%rip), %rdi       # 0x1142b
leaq 0x122be(%rip), %rsi     # 0x228e0
callq 0x103ca
testb %al, %al
jne 0x10640
leaq 0x6daf(%rip), %rdi      # 0x173e1
leaq 0xdf2(%rip), %rsi       # 0x1142b
xorl %eax, %eax
callq 0xe410
leaq 0xdfe(%rip), %rdi       # 0x11445
leaq 0x12296(%rip), %rsi     # 0x228e4
callq 0x103ca
testb %al, %al
jne 0x1066c
leaq 0x6d83(%rip), %rdi      # 0x173e1
leaq 0xde0(%rip), %rsi       # 0x11445
xorl %eax, %eax
callq 0xe410
leaq 0xcae(%rip), %rdi       # 0x11321
leaq 0x1226e(%rip), %rsi     # 0x228e8
callq 0x103ca
testb %al, %al
je 0x10685
popq %rax
retq
leaq 0x6d55(%rip), %rdi      # 0x173e1
leaq 0xc8e(%rip), %rsi       # 0x11321
xorl %eax, %eax
popq %rcx
jmp 0xe410
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq 0x11d8d(%rip), %rax     # 0x22478
movq (%rax), %rdi
callq 0xe350
testq %rax, %rax
je 0x10782
movzbl 0x22(%rax), %r12d
movzbl 0x23(%rax), %eax
xorl %r13d, %r13d
movl %eax, 0xc(%rsp)
cmpb %al, %r12b
ja 0x10782
leaq 0x11d70(%rip), %r14     # 0x22488
xorl %eax, %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movzbl %r12b, %r15d
movq (%r14), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xe250
cmpl %ebx, %eax
je 0x10744
incl %ebp
cmpl $0x4, %ebp
jne 0x10725
movq 0x10(%rsp), %rax
jmp 0x10769
leal 0x2(%r13), %esi
movq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xe2d0
testq %rax, %rax
je 0x1077a
movl %r13d, %ecx
incl %r13d
movb %r12b, (%rax,%rcx)
movb $0x0, (%rax,%r13)
leal 0x1(%r12), %ecx
cmpl 0xc(%rsp), %r12d
movl %ecx, %r12d
jne 0x1071a
jmp 0x10784
movq %r15, %rdi
callq 0xe040
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rax
leaq 0x68f9(%rip), %rsi      # 0x17450
movl $0x45, %edi
callq 0xee68
leaq 0x11948(%rip), %rax     # 0x224b0
movq (%rax), %rax
testq %rax, %rax
je 0x10b83
movq (%rax), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x218(%rax), %rax
jmp 0x10b6b
leaq 0x118f7(%rip), %rax     # 0x22481
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x118eb(%rip), %rax     # 0x22480
movb %cl, (%rax)
leaq 0x117b6(%rip), %rax     # 0x22354
cmpl $0x0, (%rax)
jle 0x10baa
xorl %edi, %edi
callq 0xe1c0
callq 0xf252
popq %rax
jmp 0xeeec
// File: /workspace/github_c_makefile_star2_O3/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:
movq (%rdi), %rcx
movq (%rsi), %rdx
testq %rcx, %rcx
sete %al
testq %rdx, %rdx
sete %sil
orb %al, %sil
movb $0x1, %al
jne 0x10c63
pushq %rbx
movq %rcx, %rsi
movb 0x108(%rsi), %dil
movl 0x100(%rsi), %r8d
movb 0x104(%rsi), %r9b
movzwl 0x106(%rsi), %r10d
movq %rdx, %r11
cmpb %dil, 0x108(%r11)
jne 0x10c28
cmpl %r8d, 0x100(%r11)
jne 0x10c28
cmpb %r9b, 0x104(%r11)
jne 0x10c28
movzwl 0x106(%r11), %ebx
cmpl $0x8000, %ebx           # imm = 0x8000
je 0x10c42
cmpw %r10w, %bx
je 0x10c42
movq 0x118(%r11), %r11
testq %r11, %r11
jne 0x10bf7
movq 0x118(%rsi), %rsi
testq %rsi, %rsi
jne 0x10bd7
jmp 0x10c60
movq 0x110(%rcx), %rcx
testq %rcx, %rcx
je 0x10c62
movq 0x110(%rdx), %rdx
testq %rdx, %rdx
jne 0x10bd4
jmp 0x10c62
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x228, %edi            # imm = 0x228
callq 0xe270
movq %rax, %rbx
movq %r15, (%rax)
movb $0x0, 0x208(%rax)
cmpb $0x3b, (%r14)
jne 0x10ee7
incq %r14
movq %r14, %rdi
callq 0xf417
movq %rax, %r14
movb $0x1, 0x208(%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x232(%rip), %rdx       # 0x11127
movl $0x200, %esi            # imm = 0x200
movq %r14, %rcx
xorl %eax, %eax
callq 0xe170
xorps %xmm0, %xmm0
movups %xmm0, 0x210(%rbx)
movq $0x0, 0x220(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
leaq 0x11587(%rip), %rax     # 0x224b0
cmpq $0x0, (%rax)
je 0x10f49
leaq 0x11572(%rip), %rax     # 0x224a8
movq (%rax), %rax
movq %rdi, 0x218(%rax)
movq %rax, 0x220(%rdi)
jmp 0x10f4c
movq %rdi, (%rax)
leaq 0x11555(%rip), %rax     # 0x224a8
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10f7a
movq 0x110(%rdi), %r14
callq 0x10f89
movq %r14, %rdi
testq %r14, %r14
jne 0x10f66
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
testq %rdi, %rdi
je 0x10fb0
movq 0x118(%rdi), %r14
callq 0xe040
movq %r14, %rdi
testq %r14, %r14
jne 0x10f9c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O3/svpv[P]rpmset/./base64pack.h
// Function: pack18x5c15
static inline void pack18x5c15(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(v[0] & Mask( 6))];
    s[ 1] = base64[(v[0] & Mask(12)) >>  6];
    s[ 2] = base64[(v[0] & Mask(18)) >> 12];
    s[ 3] = base64[(v[1] & Mask( 6))];
    s[ 4] = base64[(v[1] & Mask(12)) >>  6];
    s[ 5] = base64[(v[1] & Mask(18)) >> 12];
    s[ 6] = base64[(v[2] & Mask( 6))];
    s[ 7] = base64[(v[2] & Mask(12)) >>  6];
    s[ 8] = base64[(v[2] & Mask(18)) >> 12];
    s[ 9] = base64[(v[3] & Mask( 6))];
    s[10] = base64[(v[3] & Mask(12)) >>  6];
    s[11] = base64[(v[3] & Mask(18)) >> 12];
    s[12] = base64[(v[4] & Mask( 6))];
    s[13] = base64[(v[4] & Mask(12)) >>  6];
    s[14] = base64[(v[4] & Mask(18)) >> 12];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x2005(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x4(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x8(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0xc(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0xc(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x10(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x10(%rdi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xe(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x0, 0xd0f1(%rip)      # 0xf434
jne 0x2353
leaq 0x801e(%rip), %rdi      # 0xa36a
xorl %eax, %eax
callq 0x6cc0
testl %r14d, %r14d
jle 0x235f
movl %r14d, 0xd0d1(%rip)     # 0xf430
testl %ebp, %ebp
jle 0x2369
movl %ebp, 0xd0cf(%rip)      # 0xf438
movq 0xcc88(%rip), %r14      # 0xeff8
movq (%r14), %rdi
movl 0xd0b7(%rip), %edx      # 0xf430
leaq 0x802d(%rip), %rsi      # 0xa3ad
xorl %eax, %eax
callq 0x21d0
movq (%r14), %rdi
movl 0xd0a8(%rip), %edx      # 0xf438
leaq 0x8028(%rip), %rsi      # 0xa3bf
xorl %eax, %eax
callq 0x21d0
movq %rbx, 0x1c953(%rip)     # 0x1ecf8
movl 0xd085(%rip), %edi      # 0xf430
movl 0xd087(%rip), %esi      # 0xf438
pushq $0x1
popq %rdx
movl $0x186a0, %ecx          # imm = 0x186A0
callq 0x6f2c
movq %rax, 0x1c93b(%rip)     # 0x1ed00
movq %rax, %rdi
callq 0x6ff3
andq $0x0, 0x1c933(%rip)     # 0x1ed08
andl $0x0, 0x1c934(%rip)     # 0x1ed10
andl $0x0, 0xd051(%rip)      # 0xf434
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cvtsi2sd %esi, %xmm1
ucomisd %xmm1, %xmm0
jae 0x2c06
cvttsd2si %xmm0, %ebp
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
subsd %xmm1, %xmm0
mulsd 0x7699(%rip), %xmm0     # 0xa258
callq 0x2170
movsd 0x7694(%rip), %xmm1     # 0xa260
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
mulsd 0x768c(%rip), %xmm2     # 0xa268
movslq %ebp, %rax
xorps %xmm0, %xmm0
cvtsi2sdl (%rbx,%rax,4), %xmm0
subsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rbx,%rax,4), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
jmp 0x2c0d
movslq %esi, %rax
movl -0x4(%rbx,%rax,4), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq 0x1c0ee(%rip), %rbx     # 0x1ed14
leal 0x1(%rbx), %eax
movl %eax, 0x1c0e5(%rip)     # 0x1ed14
cmpq $0x27, %rbx
jl 0x2c48
leaq 0x779a(%rip), %rdi      # 0xa3d6
movl $0x28, %esi
xorl %eax, %eax
callq 0x6cc0
movq %r15, %rdi
callq 0x22e0
leaq 0x1c0c9(%rip), %rcx     # 0x1ed20
movq %rax, (%rcx,%rbx,8)
movq %r14, %rdi
callq 0x22e0
leaq 0x1c1f6(%rip), %rcx     # 0x1ee60
movq %rax, (%rcx,%rbx,8)
leaq 0x1c32b(%rip), %rax     # 0x1efa0
movl $0x0, (%rax,%rbx,4)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leal 0x1(%r12), %ebp
movslq %ebp, %rdi
shlq $0x2, %rdi
callq 0x2230
testq %rax, %rax
je 0x2d0c
movq %rax, %r15
testl %r12d, %r12d
js 0x2cf7
movl %ebp, %r12d
movq %rsp, %r13
xorl %ebp, %ebp
movl $0x200, %esi            # imm = 0x200
movq %r13, %rdi
leaq 0x7742(%rip), %rdx      # 0xa415
movq %rbx, %rcx
movl %ebp, %r8d
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
movq %r13, %rsi
callq 0x2c14
movl %eax, (%r15,%rbp,4)
incq %rbp
cmpq %rbp, %r12
jne 0x2cc4
movq %r15, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x23e8
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movsd 0x74e9(%rip), %xmm2     # 0xa270
movsd %xmm1, (%rsp)
mulsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x2ded
movsd 0x74da(%rip), %xmm1     # 0xa278
mulsd (%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %esi
movapd %xmm2, %xmm0
callq 0x314c
movsd 0x8(%rsp), %xmm0
callq 0x543b
movsd 0x10(%rsp), %xmm2
movsd 0x18(%rsp), %xmm0
subsd (%rsp), %xmm0
ucomisd %xmm2, %xmm0
ja 0x2daf
movq 0x18(%rbx), %rax
movq (%rax), %rdi
movl 0x8(%rbx), %edx
movl 0xc(%rbx), %esi
addq $0x20, %rsp
popq %rbx
jmp 0x314c
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
callq 0x2f18
movl 0xc(%rax), %esi
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
cvtsi2sdl 0xc5f5(%rip), %xmm1 # 0xf430
divsd %xmm1, %xmm0
divsd 0x7439(%rip), %xmm0     # 0xa280
mulsd 0xc661(%rip), %xmm0     # 0xf4b0
movl 0x8(%rax), %edx
movq 0x18(%rax), %rax
movq (%rax), %rdi
movsd 0x1bea7(%rip), %xmm1    # 0x1ed08
movaps %xmm1, 0x10(%rsp)
callq 0x314c
cvttpd2dq 0x10(%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd 0x73fd(%rip), %xmm1     # 0xa280
divsd 0xc625(%rip), %xmm1     # 0xf4b0
movapd %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtsi2sdl 0xc596(%rip), %xmm1 # 0xf430
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %edi
addq $0x28, %rsp
jmp 0x36ce
// File: /workspace/github_c_makefile_star2_O3/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 %rax
cmpl $0x1, 0xc68d(%rip)      # 0xf544
jne 0x2ef6
movsd 0xc54f(%rip), %xmm1     # 0xf410
ucomisd %xmm0, %xmm1
jne 0x2ef6
jp 0x2ef6
xorl %eax, %eax
cmpl $0x0, 0xc546(%rip)      # 0xf418
sete %al
leaq 0x7424(%rip), %rcx      # 0xa300
mulsd (%rcx,%rax,8), %xmm0
divsd 0x739f(%rip), %xmm0     # 0xa288
movsd %xmm0, (%rsp)
movl %eax, 0xc524(%rip)      # 0xf418
jmp 0x2efb
movsd %xmm0, (%rsp)
callq 0x2f18
movq 0x18(%rax), %rcx
movq (%rcx), %rdi
movl 0x8(%rax), %edx
movl 0xc(%rax), %esi
movsd (%rsp), %xmm0
popq %rax
jmp 0x314c
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: setLocation
int
setLocation(int future)
    {
    int old = location;

    location = future;

    if (location > maxLocation)
        {
        while (location >= output->samples)
            growOutput();
        maxLocation = location;
        }

    if (location < 0)
        {
        //printf("attempt to rewind to a negative index, "
        //       "setting index to zero\n");
        location = 0;
        }

    return old;
    }

// Assembly:
movsd 0x1b632(%rip), %xmm2    # 0x1ed08
cvtsi2sd %edi, %xmm0
movsd %xmm0, 0x1b626(%rip)    # 0x1ed08
cvtsi2sdl 0x1b626(%rip), %xmm1 # 0x1ed10
ucomisd %xmm1, %xmm0
jbe 0x372d
pushq %rax
movsd %xmm2, (%rsp)
movq 0x1b603(%rip), %rax     # 0x1ed00
xorps %xmm1, %xmm1
cvtsi2sdl 0xc(%rax), %xmm1
ucomisd %xmm1, %xmm0
jb 0x371a
callq 0x38cb
movsd 0x1b5f0(%rip), %xmm0    # 0x1ed08
jmp 0x36f6
cvttsd2si %xmm0, %eax
movl %eax, 0x1b5ec(%rip)     # 0x1ed10
movsd (%rsp), %xmm2
addq $0x8, %rsp
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3742
movq $0x0, 0x1b5c6(%rip) # 0x1ed08
cvttsd2si %xmm2, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: oneshot
void
oneshot(int *data,int length, int bps)
    {
    int i;
    double  bpsFactor;

    dTrace("entering\n");
    //printf("playing oneshot note at %f\n",location - spaces);

    bpsFactor = pow(2,bitsPerSample) / pow(2,bps);

    if (length <= 0) return;

    while (location + length >= output->samples)
        growOutput();

    /* write out all the data */

    for (i = 0; i < length; ++i)
        {
        output->data[0][(int)location] +=
            data[i] * amplitude * bpsFactor;
        location += 1;
        }

    if (location > maxLocation) maxLocation = location;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
cvtsi2sdl 0xbca7(%rip), %xmm0 # 0xf438
callq 0x2030
movsd %xmm0, 0x10(%rsp)
movsd 0x6abc(%rip), %xmm0     # 0xa260
movl %r14d, %edi
callq 0x2060
testl %ebp, %ebp
jle 0x3896
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %ebp, %xmm3
movsd 0x1b542(%rip), %xmm0    # 0x1ed08
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
movq 0x1b52b(%rip), %rax     # 0x1ed00
cvtsi2sdl 0xc(%rax), %xmm2
ucomisd %xmm2, %xmm1
jb 0x3816
movsd %xmm3, 0x18(%rsp)
callq 0x38cb
movsd 0x18(%rsp), %xmm3
movsd 0x1b50f(%rip), %xmm0    # 0x1ed08
movapd %xmm0, %xmm1
addsd %xmm3, %xmm1
movq 0x1b4f8(%rip), %rax     # 0x1ed00
xorps %xmm2, %xmm2
cvtsi2sdl 0xc(%rax), %xmm2
ucomisd %xmm2, %xmm1
jae 0x37e6
movsd 0x10(%rsp), %xmm4
divsd 0x8(%rsp), %xmm4
movsd 0xbc3e(%rip), %xmm1     # 0xf468
movq 0x18(%rax), %rax
movq (%rax), %rax
movl %ebp, %ecx
xorl %edx, %edx
movsd 0x6a23(%rip), %xmm5     # 0xa260
xorps %xmm2, %xmm2
cvtsi2sdl (%rbx,%rdx,4), %xmm2
cvttsd2si %xmm0, %esi
mulsd %xmm1, %xmm2
movslq %esi, %rsi
xorps %xmm3, %xmm3
cvtsi2sdl (%rax,%rsi,4), %xmm3
mulsd %xmm4, %xmm2
addsd %xmm2, %xmm3
cvttsd2si %xmm3, %edi
movl %edi, (%rax,%rsi,4)
addsd %xmm5, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x383d
movsd %xmm0, 0x1b48d(%rip)    # 0x1ed08
xorps %xmm1, %xmm1
cvtsi2sdl 0x1b48a(%rip), %xmm1 # 0x1ed10
ucomisd %xmm1, %xmm0
jbe 0x3896
cvttsd2si %xmm0, %eax
movl %eax, 0x1b47a(%rip)     # 0x1ed10
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: samplesToMeasures
double
samplesToBeats(double samples)
    {
    return samples
           / (double) SampleRate
           / 60.0
           * beatsPerMinute;
    }

// Assembly:
cvtsi2sdl 0xbb89(%rip), %xmm1 # 0xf430
divsd %xmm1, %xmm0
divsd 0x69cd(%rip), %xmm0     # 0xa280
mulsd 0xbbf5(%rip), %xmm0     # 0xf4b0
xorps %xmm1, %xmm1
cvtsi2sdl 0xbb8a(%rip), %xmm1 # 0xf450
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: growOutput
static void
growOutput()
    {
    int i;
    int samples = output->samples;

    growRRA(output);

    for (i = samples; i < output->samples; ++i)
        output->data[0][i] = 0;
    }

// Assembly:
pushq %rbx
movq 0x1b42d(%rip), %rdi     # 0x1ed00
movslq 0xc(%rdi), %rbx
callq 0x7daa
movq 0x1b41d(%rip), %rax     # 0x1ed00
cmpl 0xc(%rax), %ebx
jge 0x3902
movq 0x18(%rax), %rcx
movq (%rcx), %rcx
movl $0x0, (%rcx,%rbx,4)
incq %rbx
movslq 0xc(%rax), %rdx
cmpq %rdx, %rbx
jl 0x38ef
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: chord
void
chord(double beats,int inst,int octave,int pitch,...)
    {
    int offset;
    int noteCount = 0;
    int notes[CHORD_LENGTH];
    va_list ap;

    dTrace("entering\n");;
    /* store the first absolute note */

    notes[noteCount++] = octave * 12 + pitch;

    /* extract the following pitch deltas */

    va_start(ap, pitch);

    offset = va_arg(ap,int);
    while (offset != 0)
        {
        if (offset < - OCTAVES * NOTES || offset >= OCTAVES * NOTES)
            Fatal("chord: bad offset: %d (missing zero terminator?)\n",offset);
        if (noteCount >= sizeof(notes) / sizeof(int))
            Fatal("chord: too many notes\n");
        notes[noteCount++] = notes[0]+offset;
        offset = va_arg(ap,int);
        }
    va_end(ap);

    anchord(beats,inst,notes,noteCount);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8d8, %rsp            # imm = 0x8D8
movl %edi, %ebx
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3986
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leal (%rsi,%rsi,2), %eax
leal (%rdx,%rax,4), %ebp
movl %ebp, 0xd0(%rsp)
movabsq $0x4000000018, %rax     # imm = 0x4000000018
movq %rax, (%rsp)
leaq 0x910(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movl $0x18, %ecx
cmpq $0x28, %rcx
ja 0x39d0
movl $0x18, %eax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x39de
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %r13d
testl %r13d, %r13d
je 0x3a6b
movl $0x1, %r14d
leaq 0x6a24(%rip), %r15      # 0xa41b
leaq 0x6a50(%rip), %r12      # 0xa44e
leal -0x84(%r13), %eax
cmpl $0xfffffef7, %eax       # imm = 0xFFFFFEF7
ja 0x3a19
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x6cc0
cmpq $0x200, %r14            # imm = 0x200
jb 0x3a2c
movq %r12, %rdi
xorl %eax, %eax
callq 0x6cc0
addl %ebp, %r13d
movl %r13d, 0xd0(%rsp,%r14,4)
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3a50
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x3a5e
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movl (%rax), %r13d
incq %r14
testl %r13d, %r13d
jne 0x39fe
jmp 0x3a71
movl $0x1, %r14d
leaq 0xd0(%rsp), %rsi
movsd 0x18(%rsp), %xmm0
movl %ebx, %edi
movl %r14d, %edx
callq 0x3a9b
addq $0x8d8, %rsp            # imm = 0x8D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: achord
void
achord(double beats,int inst,int octave,int pitch,int *offsets,int length)
    {
    int i;
    int notes[CHORD_LENGTH];

    for (i = 0; i < length; ++i)
        {
        if (i >= sizeof(notes) / sizeof(int))
            Fatal("achord: too many notes\n");
        notes[i] = octave * 12 + pitch + offsets[i];
        }

    anchord(beats,inst,notes,length);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp            # imm = 0x818
movl %r8d, %ebx
movl %edi, 0x4(%rsp)
movsd %xmm0, 0x8(%rsp)
testl %r8d, %r8d
jle 0x4010
movq %rcx, %r14
leal (%rsi,%rsi,2), %eax
leal (%rdx,%rax,4), %r12d
movl %ebx, %r13d
leaq 0x6465(%rip), %r15      # 0xa44d
xorl %ebp, %ebp
cmpq $0x200, %rbp            # imm = 0x200
jb 0x3ffd
movq %r15, %rdi
xorl %eax, %eax
callq 0x6cc0
movl (%r14,%rbp,4), %eax
addl %r12d, %eax
movl %eax, 0x10(%rsp,%rbp,4)
incq %rbp
cmpq %rbp, %r13
jne 0x3fea
leaq 0x10(%rsp), %rsi
movsd 0x8(%rsp), %xmm0
movl 0x4(%rsp), %edi
movl %ebx, %edx
callq 0x3a9b
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: rchord
void
rchord(double beats,...)
    {
    int noteCount;
    RRA *note;
    va_list ap;

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

    /* extract the arguments */

    va_start(ap, beats);

    noteCount = 0;
    note = va_arg(ap,RRA *);
    while (note != 0)
        {
        if (noteCount > 0) backwards(beats-stride);

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

        note = va_arg(ap,RRA *);

        ++noteCount;
        }

    va_end(ap);

    backwards((noteCount - 1) * stride);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4097
movapd %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
cmpl $0x1, 0xb4a6(%rip)      # 0xf544
jne 0x40d6
movsd 0xb368(%rip), %xmm1     # 0xf410
ucomisd %xmm0, %xmm1
jne 0x40d6
jp 0x40d6
xorl %eax, %eax
cmpl $0x0, 0xb35f(%rip)      # 0xf418
sete %al
leaq 0x623d(%rip), %rcx      # 0xa300
mulsd (%rcx,%rax,8), %xmm0
divsd 0x61b8(%rip), %xmm0     # 0xa288
movl %eax, 0xb342(%rip)      # 0xf418
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x4000000000, %rax     # imm = 0x4000000000
movq %rax, (%rsp)
movl $0x28, %eax
negq %rax
ja 0x4113
movq 0x10(%rsp), %rax
movl $0x8, (%rsp)
jmp 0x4121
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
testq %r14, %r14
je 0x41ae
movl $0x1, %ebx
movsd %xmm0, 0x18(%rsp)
cmpl $0x1, %ebx
je 0x4158
subsd 0xb413(%rip), %xmm0     # 0xf558
xorpd 0x61c3(%rip), %xmm0     # 0xa310
callq 0x543b
movsd 0x18(%rsp), %xmm0
movq 0x18(%r14), %rax
movq (%rax), %rdi
movl 0x8(%r14), %edx
movl 0xc(%r14), %esi
callq 0x314c
movl (%rsp), %ecx
cmpq $0x28, %rcx
ja 0x4185
movq %rcx, %rax
addq 0x10(%rsp), %rax
addl $0x8, %ecx
movl %ecx, (%rsp)
jmp 0x4193
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %r14
decl %ebx
testq %r14, %r14
movsd 0x18(%rsp), %xmm0
jne 0x4138
negl %ebx
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
jmp 0x41b6
movsd 0x60fa(%rip), %xmm1     # 0xa2b0
movsd 0xb39a(%rip), %xmm0     # 0xf558
xorpd 0x614a(%rip), %xmm0     # 0xa310
mulsd %xmm1, %xmm0
callq 0x543b
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: softer
void
softer(double factor)
    {
    if (factor == 0.0)
        {
        setAmplitude(getAmplitude() * softLoud);
        softLoud = popAmplitudeFactor();
        }
    else
        {
        setAmplitude(getAmplitude() / factor);
        softLoud = factor;
        pushAmplitudeFactor(factor);
        }
    }

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd 0xaa96(%rip), %xmm1     # 0xf468
jne 0x4a06
jp 0x4a06
mulsd 0xaa42(%rip), %xmm1     # 0xf420
movsd %xmm1, 0xaa82(%rip)     # 0xf468
movl 0x1aee4(%rip), %eax     # 0x1f8d0
testl %eax, %eax
jle 0x4a3e
decl %eax
movl %eax, 0x1aed8(%rip)     # 0x1f8d0
leaq 0x1aee1(%rip), %rcx     # 0x1f8e0
movsd (%rcx,%rax,8), %xmm0
jmp 0x4a55
divsd %xmm0, %xmm1
movsd %xmm1, 0xaa56(%rip)     # 0xf468
movsd %xmm0, 0xaa06(%rip)     # 0xf420
movl 0x1aeb0(%rip), %eax     # 0x1f8d0
cmpq $0x1fe, %rax            # imm = 0x1FE
ja 0x4a3d
leal 0x1(%rax), %ecx
movl %ecx, 0x1ae9f(%rip)     # 0x1f8d0
leaq 0x1aea8(%rip), %rcx     # 0x1f8e0
movsd %xmm0, (%rcx,%rax,8)
retq
pushq %rax
leaq 0x5b91(%rip), %rdi      # 0xa5d7
xorl %eax, %eax
callq 0x6cc0
xorpd %xmm0, %xmm0
addq $0x8, %rsp
movsd %xmm0, 0xa9c3(%rip)     # 0xf420
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: draw
void
draw(double beats,int inst,int octave,int pitch,double length,...)
    {
    int i;
    int octaves[CHORD_LENGTH],pitches[CHORD_LENGTH];
    double lengths[CHORD_LENGTH];

    dTrace("entering\n");;

    octaves[0] = octave;
    pitches[0] = pitch;
    lengths[0] = length;

    /* extract the remaining arguments */

    va_list ap;

    va_start(ap, length);

    octave = va_arg(ap,int);
    i = 1;
    while (octave != (int) 0 && i < sizeof(octaves)/sizeof(int))
        {
        pitch = va_arg(ap,int);
        length = va_arg(ap,double);

        octaves[i] = octave;
        pitches[i] = pitch;
        lengths[i] = length;

        ++i;

        octave = va_arg(ap,int);
        }

    va_end(ap);

    adraw(beats,inst,i,octaves,pitches,lengths);
    }

// Assembly:
subq $0x20d8, %rsp           # imm = 0x20D8
leaq 0x20(%rsp), %r10
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4b43
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movl %esi, 0x8d0(%rsp)
movl %edx, 0xd0(%rsp)
movsd %xmm1, 0x10d0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0x20e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x5000000018, %rax     # imm = 0x5000000018
movq %rax, (%rsp)
movl $0x18, %eax
movl $0x18, %ecx
cmpq $0x28, %rcx
ja 0x4b97
addq 0x10(%rsp), %rcx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x4ba5
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movl (%rcx), %r9d
testl %r9d, %r9d
je 0x4c67
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r10
movl $0x1, %edx
movl 0x4(%rsp), %r8d
cmpl $0x28, %eax
ja 0x4bdb
movq %r10, %r11
movl %eax, %r10d
addq %rcx, %r10
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x4be4
leaq 0x8(%r10), %r11
movq %r11, 0x8(%rsp)
movl (%r10), %r10d
cmpl $0xa0, %r8d
ja 0x4c04
movq %r11, %rsi
movl %r8d, %r11d
addq %rcx, %r11
addl $0x10, %r8d
movl %r8d, 0x4(%rsp)
jmp 0x4c0d
leaq 0x8(%r11), %rsi
movq %rsi, 0x8(%rsp)
movsd (%r11), %xmm1
movl %r9d, 0x8d0(%rsp,%rdx,4)
movl %r10d, 0xd0(%rsp,%rdx,4)
movsd %xmm1, 0x10d0(%rsp,%rdx,8)
cmpl $0x28, %eax
ja 0x4c40
movq %rsi, %r10
movl %eax, %esi
addq %rcx, %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x4c49
leaq 0x8(%rsi), %r10
movq %r10, 0x8(%rsp)
movl (%rsi), %r9d
leaq 0x1(%rdx), %rsi
testl %r9d, %r9d
je 0x4c6c
cmpq $0x1ff, %rdx            # imm = 0x1FF
movq %rsi, %rdx
jb 0x4bc5
jmp 0x4c6c
movl $0x1, %esi
leaq 0x8d0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
leaq 0x10d0(%rsp), %r8
callq 0x41da
addq $0x20d8, %rsp           # imm = 0x20D8
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: ndraw
void
ndraw(double beats,int inst,int note,double length,...)
    {
    int i;
    int octaves[CHORD_LENGTH],pitches[CHORD_LENGTH];
    double lengths[CHORD_LENGTH];

    dTrace("entering\n");;

    octaves[0] = note / NOTES;
    pitches[0] = note % NOTES;
    lengths[0] = length;

    /* extract the remaining arguments */

    va_list ap;

    va_start(ap, length);

    note = va_arg(ap,int);
    i = 1;
    while (note != (int) 0 && i < sizeof(octaves)/sizeof(int))
        {
        length = va_arg(ap,double);

        octaves[i] = note / NOTES;
        pitches[i] = note % NOTES;
        lengths[i] = length;

        ++i;

        note = va_arg(ap,int);
        }

    va_end(ap);

    adraw(beats,inst,i,octaves,pitches,lengths);
    }

// Assembly:
subq $0x20d8, %rsp           # imm = 0x20D8
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4cde
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movslq %esi, %rax
imulq $0x2aaaaaab, %rax, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
movl %ecx, 0x8d0(%rsp)
shll $0x2, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
movl %eax, 0xd0(%rsp)
movsd %xmm1, 0x10d0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0x20e0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x5000000010, %rax     # imm = 0x5000000010
movq %rax, (%rsp)
movl $0x10, %eax
movl $0x10, %ecx
cmpq $0x28, %rcx
ja 0x4d51
addq 0x10(%rsp), %rcx
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x4d5f
movq 0x8(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movl (%rcx), %r10d
testl %r10d, %r10d
je 0x4e20
movq 0x10(%rsp), %rcx
movl 0x4(%rsp), %edx
movl $0x1, %r8d
movq 0x8(%rsp), %r9
cmpl $0xa0, %edx
ja 0x4d99
movq %r9, %rsi
movl %edx, %r9d
addq %rcx, %r9
addl $0x10, %edx
movl %edx, 0x4(%rsp)
jmp 0x4da2
leaq 0x8(%r9), %rsi
movq %rsi, 0x8(%rsp)
movsd (%r9), %xmm1
movslq %r10d, %r9
imulq $0x2aaaaaab, %r9, %r10  # imm = 0x2AAAAAAB
movq %r10, %r11
shrq $0x3f, %r11
sarq $0x21, %r10
addl %r11d, %r10d
movl %r10d, 0x8d0(%rsp,%r8,4)
shll $0x2, %r10d
leal (%r10,%r10,2), %r10d
subl %r10d, %r9d
movl %r9d, 0xd0(%rsp,%r8,4)
movsd %xmm1, 0x10d0(%rsp,%r8,8)
cmpl $0x28, %eax
ja 0x4df9
movq %rsi, %r9
movl %eax, %esi
addq %rcx, %rsi
addl $0x8, %eax
movl %eax, (%rsp)
jmp 0x4e02
leaq 0x8(%rsi), %r9
movq %r9, 0x8(%rsp)
movl (%rsi), %r10d
leaq 0x1(%r8), %rsi
testl %r10d, %r10d
je 0x4e25
cmpq $0x1ff, %r8             # imm = 0x1FF
movq %rsi, %r8
jb 0x4d7f
jmp 0x4e25
movl $0x1, %esi
leaq 0x8d0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
leaq 0x10d0(%rsp), %r8
callq 0x41da
addq $0x20d8, %rsp           # imm = 0x20D8
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: bend
void
bend(double beats,int inst,int octave,int pitch,int offset,
    double bendLength)
    {
    setDrawRamp(getDrawRamp() * bendLength);
    resolve(beats,inst,octave,pitch+offset,0,octave,pitch);
    //rbend(beats,getNote(inst,octave,pitch),start,startLength,bendLength);
    setDrawRamp(-1); // reset to previous draw ramp
    }

// Assembly:
movsd 0xa30c(%rip), %xmm2     # 0xf490
mulsd %xmm2, %xmm1
xorpd %xmm3, %xmm3
ucomisd %xmm1, %xmm3
jbe 0x519c
movsd 0x19ef6(%rip), %xmm1    # 0x1f090
jmp 0x51a4
movsd %xmm2, 0x19eec(%rip)    # 0x1f090
pushq %rax
movsd %xmm1, 0xa2e3(%rip)     # 0xf490
addl %edx, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %edi, %xmm1
movl $0x0, (%rsp)
xorl %edi, %edi
xorl %edx, %edx
movl %esi, %ecx
xorl %r8d, %r8d
movl %esi, %r9d
movb $0x4, %al
callq 0x4afa
movsd 0x19ea2(%rip), %xmm0    # 0x1f090
movsd %xmm0, 0xa29a(%rip)     # 0xf490
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/lib/songlib.c
// Function: dbend
void
dbend(double beats,int *data,int length,double start,
    double startLength,double bendLength,int bps)
    {
    int i;
    int* bentNote;
    int maxSamples,startSamples,bendSamples;
    double t;
    double adjust,delta;
    
    maxSamples = 4 * length;

    bentNote = (int *) New(sizeof(int) * maxSamples);

    /* resample */

    bendSamples = beatsToSamples(bendLength);
    startSamples = beatsToSamples(startLength);
    delta = (1.0 - start) / bendSamples;

    i = 0;
    t = 0;
    adjust = start;
    while (i < maxSamples && i < length)
        {
        bentNote[i] = interp(data,length,t);

        if (i >= startSamples + bendSamples)
            adjust = 1.0;
        else if (i > startSamples)
            adjust += delta;

        /* update the new time */

        t += adjust;
        ++i;
        }

    dplay(beats,bentNote,i,bps);

    free(bentNote);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebx
movapd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movl %esi, %ebp
movq %rdi, %r15
movsd %xmm0, 0x38(%rsp)
movl %esi, %edi
shll $0x4, %edi
callq 0x6ddf
movq %rax, %r14
testl %ebp, %ebp
jle 0x53c4
movl %ebx, 0x1c(%rsp)
movapd 0x20(%rsp), %xmm4
mulsd 0x4f92(%rip), %xmm4     # 0xa280
movsd 0xa1ba(%rip), %xmm0     # 0xf4b0
xorps %xmm1, %xmm1
cvtsi2sdl 0xa12f(%rip), %xmm1 # 0xf430
divsd %xmm0, %xmm4
mulsd %xmm1, %xmm4
cvttsd2si %xmm4, %eax
movsd 0x4f4b(%rip), %xmm3     # 0xa260
cvttpd2dq %xmm4, %xmm2
movsd 0x8(%rsp), %xmm4
subsd %xmm4, %xmm3
cvtdq2pd %xmm2, %xmm2
divsd %xmm2, %xmm3
movsd %xmm3, 0x40(%rsp)
movsd 0x10(%rsp), %xmm2
mulsd 0x4f41(%rip), %xmm2     # 0xa280
divsd %xmm0, %xmm2
mulsd %xmm1, %xmm2
cvttsd2si %xmm2, %ecx
addl %ecx, %eax
movslq %ecx, %rcx
movq %rcx, 0x20(%rsp)
movslq %eax, %r13
movl %ebp, %ebx
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movapd %xmm4, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
movsd %xmm1, 0x10(%rsp)
movapd %xmm1, %xmm0
callq *0x19970(%rip)          # 0x1ecf0
movl %eax, (%r14,%r12,4)
movsd 0x4ed4(%rip), %xmm0     # 0xa260
cmpq %r13, %r12
jge 0x53ac
cmpq 0x20(%rsp), %r12
jle 0x53a6
movsd 0x8(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
jmp 0x53ac
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
incq %r12
cmpq %r12, %rbx
jne 0x5365
movl 0x1c(%rsp), %ebx
jmp 0x53c6
xorl %ebp, %ebp
movsd 0x38(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x314c
movq %r14, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040