LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/baskerville[P]sxhkd/src/parse.c
// Function: render_next
void render_next(chunk_t *chunks, char *dest)
{
	if (chunks == NULL)
		return;
	int i = 0;
	bool incr = false;
	for (chunk_t *c = chunks; c != NULL; c = c->next) {
		if (c->sequence) {
			if (!incr) {
				if (c->range_cur < c->range_max) {
					c->range_cur++;
					incr = true;
				} else {
					c->range_cur = 1, c->range_max = 0;
				}
			}
			if (c->advance == NULL) {
				incr = true;
				c->advance = get_token(c->item, NULL, c->text, SEQ_SEP);
			} else if (!incr && c->range_cur > c->range_max) {
				if (c->advance[0] == '\0') {
					c->advance = get_token(c->item, NULL, c->text, SEQ_SEP);
				} else {
					c->advance = get_token(c->item, NULL, c->advance, SEQ_SEP);
					incr = true;
				}
			}
			if (c->range_cur > c->range_max && strlen(c->item) == 3)
				sscanf(c->item, "%c-%c", &c->range_cur, &c->range_max);
			if (c->range_cur <= c->range_max) {
				dest[i++] = c->range_cur;
			} else {
				if (c->item[0] == SEQ_NONE && c->item[1] == '\0')
					continue;
				strcpy(dest + i, c->item);
				i += strlen(c->item);
			}
		} else {
			strcpy(dest + i, c->text);
			i += strlen(c->text);
		}
	}
	dest[i] = '\0';
	if (!incr)
		dest[0] = '\0';
}

// Assembly:
testq %rdi, %rdi
je 0xfdfd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movq %rsi, (%rsp)
cmpb $0x1, 0x408(%r14)
jne 0xfc9f
testb $0x1, %bl
jne 0xfcbf
movb 0x409(%r14), %al
cmpb 0x40a(%r14), %al
jge 0xfcb5
incb %al
movb %al, 0x409(%r14)
movb $0x1, %bl
jmp 0xfcbf
movslq %r15d, %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0xe070
movq %r14, %rdi
jmp 0xfd98
movw $0x1, 0x409(%r14)
movq 0x400(%r14), %rdx
testq %rdx, %rdx
je 0xfcf4
testb $0x1, %bl
jne 0xfd15
movb 0x409(%r14), %al
cmpb 0x40a(%r14), %al
jle 0xfd15
leaq 0x200(%r14), %rdi
cmpb $0x0, (%rdx)
je 0xfdc6
xorl %esi, %esi
jmp 0xfd00
leaq 0x200(%r14), %rdi
xorl %esi, %esi
movq %r14, %rdx
leaq 0x864f(%rip), %rcx      # 0x18356
callq 0x10108
movb $0x1, %bl
movq %rax, 0x400(%r14)
leaq 0x409(%r14), %r13
movb 0x409(%r14), %al
leaq 0x40a(%r14), %rbp
cmpb 0x40a(%r14), %al
jle 0xfd5f
leaq 0x200(%r14), %r12
movq %r12, %rdi
callq 0xe130
cmpq $0x3, %rax
jne 0xfd5f
movq %r12, %rdi
leaq 0x8606(%rip), %rsi      # 0x18358
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xe290
movb (%r13), %al
cmpb (%rbp), %al
jle 0xfda5
cmpb $0x5f, 0x200(%r14)
movq (%rsp), %r13
jne 0xfd80
cmpb $0x0, 0x201(%r14)
je 0xfdb4
leaq 0x200(%r14), %r12
movslq %r15d, %rdi
addq %r13, %rdi
movq %r12, %rsi
callq 0xe070
movq %r12, %rdi
callq 0xe130
addl %r15d, %eax
movl %eax, %r15d
jmp 0xfdb4
movslq %r15d, %rcx
incl %r15d
movq (%rsp), %r13
movb %al, (%r13,%rcx)
movq 0x410(%r14), %r14
testq %r14, %r14
jne 0xfc73
jmp 0xfddc
xorl %esi, %esi
movq %r14, %rdx
leaq 0x8584(%rip), %rcx      # 0x18356
callq 0x10108
jmp 0xfd0e
movslq %r15d, %rax
movb $0x0, (%r13,%rax)
testb $0x1, %bl
jne 0xfdef
movb $0x0, (%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq %rdx, %rdi
callq 0xe130
xorl %ebp, %ebp
testq %rax, %rax
je 0x1023d
movq %rax, %r13
xorl %eax, %eax
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
xorl %r15d, %r15d
movb (%rbx,%rax), %r12b
testb $0x1, 0x10(%rsp)
je 0x1019e
movl $0x0, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movl %ecx, %eax
incl %ecx
movl %ecx, 0xc(%rsp)
movq 0x20(%rsp), %rcx
movb %r12b, (%rcx,%rax)
movl %r15d, %eax
incl %eax
cmpq %rax, %r13
jbe 0x10235
movl %eax, %r15d
testb $0x1, 0x14(%rsp)
je 0x10159
jmp 0x10235
cmpb $0x5c, %r12b
jne 0x101ce
leal 0x1(%r15), %eax
movsbl (%rbx,%rax), %esi
movb $0x1, %al
movl %eax, 0x10(%rsp)
cmpl $0x5c, %esi
je 0x10181
movq 0x18(%rsp), %rdi
callq 0xe160
movb $0x1, %cl
movl %ecx, 0x10(%rsp)
testq %rax, %rax
jne 0x10181
jmp 0x1016c
movsbl %r12b, %esi
movq 0x18(%rsp), %rdi
callq 0xe160
testq %rax, %rax
je 0x1016c
cmpl $0x0, 0xc(%rsp)
movl 0x14(%rsp), %ecx
movzbl %cl, %ecx
movl $0x1, %eax
cmovnel %eax, %ecx
movl %ecx, 0x14(%rsp)
movl %r15d, %r12d
testq %r14, %r14
je 0x1020f
movl %r12d, %eax
movb (%rbx,%rax), %al
movl %ebp, %ecx
incl %ebp
movb %al, (%r14,%rcx)
leal 0x1(%r12), %r15d
cmpq %r15, %r13
jbe 0x1022d
movsbl (%rbx,%r15), %esi
movq 0x18(%rsp), %rdi
callq 0xe160
testq %rax, %rax
jne 0x101f9
movl %r12d, %r15d
jmp 0x10181
movl 0xc(%rsp), %ecx
movl %ebp, %ebp
jmp 0x10241
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x20(%rsp), %rdx
movb $0x0, (%rdx,%rcx)
testq %r14, %r14
je 0x10254
movb $0x0, (%r14,%rbp)
addq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baskerville[P]sxhkd/src/parse.c
// Function: make_chunk
chunk_t *make_chunk(void)
{
	chunk_t *c = calloc(1, sizeof(chunk_t));
	c->sequence = false;
	c->advance = NULL;
	c->next = NULL;
	c->range_cur = 1;
	c->range_max = 0;
	return c;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x418, %esi            # imm = 0x418
callq 0xe200
movb $0x0, 0x408(%rax)
xorl %ecx, %ecx
movq %rcx, 0x400(%rax)
movq %rcx, 0x410(%rax)
movw $0x1, 0x409(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad3d(%rip), %rsi      # 0x1b210
callq 0xe220
leaq 0xad31(%rip), %r15      # 0x1b210
testl %eax, %eax
je 0x10515
xorl %r12d, %r12d
cmpq $0x811, %r12            # imm = 0x811
je 0x1051f
movq 0x10(%r15), %rsi
addq $0x10, %r15
movq %r14, %rdi
callq 0xe220
incq %r12
testl %eax, %eax
jne 0x104e6
decq %r12
cmpq $0x811, %r12            # imm = 0x811
setb %al
jmp 0x10517
movb $0x1, %al
movl 0x8(%r15), %ecx
movl %ecx, (%rbx)
jmp 0x10522
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x107c1
movq %rax, %rbx
testq %rax, %rax
je 0x1058f
movb (%rbx), %al
testb %al, %al
je 0x1058f
movq %rbx, %r14
incq %r14
xorl %ebp, %ebp
movzbl %al, %edi
callq 0xf9c1
orl %eax, %ebp
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x10579
jmp 0x10591
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xe040
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x207f(%rip), %rdi      # 0x1267f
leaq 0x132b9(%rip), %rsi     # 0x238c0
callq 0x104be
testb %al, %al
jne 0x10625
leaq 0x7dca(%rip), %rdi      # 0x183e1
leaq 0x2061(%rip), %rsi      # 0x1267f
xorl %eax, %eax
callq 0xe410
leaq 0x2059(%rip), %rdi      # 0x12685
leaq 0x13291(%rip), %rsi     # 0x238c4
callq 0x104be
testb %al, %al
jne 0x10651
leaq 0x7d9e(%rip), %rdi      # 0x183e1
leaq 0x203b(%rip), %rsi      # 0x12685
xorl %eax, %eax
callq 0xe410
leaq 0x2033(%rip), %rdi      # 0x1268b
leaq 0x13269(%rip), %rsi     # 0x238c8
callq 0x104be
testb %al, %al
jne 0x1067d
leaq 0x7d72(%rip), %rdi      # 0x183e1
leaq 0x2015(%rip), %rsi      # 0x1268b
xorl %eax, %eax
callq 0xe410
leaq 0x200f(%rip), %rdi      # 0x12693
leaq 0x13241(%rip), %rsi     # 0x238cc
callq 0x104be
testb %al, %al
jne 0x106a9
leaq 0x7d46(%rip), %rdi      # 0x183e1
leaq 0x1ff1(%rip), %rsi      # 0x12693
xorl %eax, %eax
callq 0xe410
leaq 0x1feb(%rip), %rdi      # 0x1269b
leaq 0x13219(%rip), %rsi     # 0x238d0
callq 0x104be
testb %al, %al
jne 0x106d5
leaq 0x7d1a(%rip), %rdi      # 0x183e1
leaq 0x1fcd(%rip), %rsi      # 0x1269b
xorl %eax, %eax
callq 0xe410
leaq 0x1fc7(%rip), %rdi      # 0x126a3
leaq 0x131f1(%rip), %rsi     # 0x238d4
callq 0x104be
testb %al, %al
jne 0x10701
leaq 0x7cee(%rip), %rdi      # 0x183e1
leaq 0x1fa9(%rip), %rsi      # 0x126a3
xorl %eax, %eax
callq 0xe410
leaq 0x1d23(%rip), %rdi      # 0x1242b
leaq 0x131d1(%rip), %rsi     # 0x238e0
callq 0x104be
testb %al, %al
jne 0x1072d
leaq 0x7cc2(%rip), %rdi      # 0x183e1
leaq 0x1d05(%rip), %rsi      # 0x1242b
xorl %eax, %eax
callq 0xe410
leaq 0x1d11(%rip), %rdi      # 0x12445
leaq 0x131a9(%rip), %rsi     # 0x238e4
callq 0x104be
testb %al, %al
jne 0x10759
leaq 0x7c96(%rip), %rdi      # 0x183e1
leaq 0x1cf3(%rip), %rsi      # 0x12445
xorl %eax, %eax
callq 0xe410
leaq 0x1bc1(%rip), %rdi      # 0x12321
leaq 0x13181(%rip), %rsi     # 0x238e8
callq 0x104be
testb %al, %al
je 0x10772
popq %rax
retq
leaq 0x7c68(%rip), %rdi      # 0x183e1
leaq 0x1ba1(%rip), %rsi      # 0x12321
xorl %eax, %eax
popq %rcx
jmp 0xe410
// File: /workspace/github_c_makefile_star2_O1/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 0x12ca0(%rip), %rax     # 0x23478
movq (%rax), %rdi
callq 0xe350
testq %rax, %rax
je 0x107f5
movzbl 0x22(%rax), %ecx
movzbl 0x23(%rax), %eax
movl %eax, 0x8(%rsp)
cmpb %al, %cl
jbe 0x1080a
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12c77(%rip), %r14     # 0x23488
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %ebx, 0x4(%rsp)
xorl %ebp, %ebp
movq %rcx, 0x10(%rsp)
movzbl %cl, %eax
movl %eax, 0xc(%rsp)
movq (%r14), %rdi
movl 0xc(%rsp), %esi
movl %ebp, %edx
callq 0xe250
movl %eax, %r12d
cmpl %ebx, %eax
jne 0x10872
movq %r14, %rbx
leal 0x1(%r13), %r14d
leal 0x2(%r13), %esi
movq %r15, %rdi
callq 0xe2d0
testq %rax, %rax
je 0x10876
movl %r13d, %ecx
movq 0x10(%rsp), %rdx
movb %dl, (%rax,%rcx)
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
movl $0x5, %ecx
movq %rax, %r15
jmp 0x10883
xorl %ecx, %ecx
jmp 0x1088d
movq %r15, %rdi
callq 0xe040
movl $0x1, %ecx
movl %r14d, %r13d
movq %rbx, %r14
movl 0x4(%rsp), %ebx
cmpl %ebx, %r12d
je 0x1089e
incl %ebp
cmpl $0x4, %ebp
jne 0x10829
movl $0x5, %ecx
cmpl $0x5, %ecx
jne 0x107f5
movq 0x10(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl 0x8(%rsp), %ecx
movl %eax, %ecx
jne 0x1081b
jmp 0x107f8
// File: /workspace/github_c_makefile_star2_O1/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 0x7760(%rip), %rsi      # 0x18450
movl $0x45, %edi
callq 0xee73
leaq 0x127af(%rip), %rax     # 0x234b0
movq (%rax), %rax
testq %rax, %rax
je 0x10d1c
movq (%rax), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rcx)
movq 0x218(%rax), %rax
jmp 0x10d04
leaq 0x1275e(%rip), %rax     # 0x23481
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x12752(%rip), %rax     # 0x23480
movb %cl, (%rax)
leaq 0x1261d(%rip), %rax     # 0x23354
cmpl $0x0, (%rax)
jle 0x10d43
xorl %edi, %edi
callq 0xe1c0
callq 0xf25d
popq %rax
jmp 0xeef8
// File: /workspace/github_c_makefile_star2_O1/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 %sil
testq %rdx, %rdx
sete %al
orb %sil, %al
jne 0x10e0e
pushq %rbp
pushq %rbx
movq %rcx, %rsi
movb 0x108(%rsi), %dil
movl 0x100(%rsi), %r8d
movb 0x104(%rsi), %r9b
movzwl 0x106(%rsi), %r11d
movb $0x1, %r10b
movq %rdx, %rbx
cmpb %dil, 0x108(%rbx)
jne 0x10dc2
cmpl %r8d, 0x100(%rbx)
jne 0x10dc2
cmpb %r9b, 0x104(%rbx)
jne 0x10dc2
movzwl 0x106(%rbx), %ebp
cmpl $0x8000, %ebp           # imm = 0x8000
je 0x10dd2
cmpw %r11w, %bp
je 0x10dd2
movq 0x118(%rbx), %rbx
testq %rbx, %rbx
setne %r10b
jne 0x10d92
testb $0x1, %r10b
jne 0x10de6
movq 0x118(%rsi), %rsi
testq %rsi, %rsi
jne 0x10d6f
jmp 0x10e0c
movq 0x110(%rcx), %rcx
movq 0x110(%rdx), %rdx
testq %rcx, %rcx
sete %sil
testq %rdx, %rdx
sete %al
orb %sil, %al
cmpb $0x1, %al
jne 0x10d6c
popq %rbx
popq %rbp
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movl $0x8, %edi
callq 0xe270
movl %ebp, 0x4(%rax)
movl %ebx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x110d7
incq %r14
movq %r14, %rdi
callq 0xf423
movq %rax, %r14
movb $0x1, 0x208(%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
leaq 0x1042(%rip), %rdx      # 0x12127
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_O1/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 0x12397(%rip), %rax     # 0x234b0
cmpq $0x0, (%rax)
je 0x11139
leaq 0x12382(%rip), %rax     # 0x234a8
movq (%rax), %rcx
movq %rdi, 0x218(%rcx)
movq %rcx, 0x220(%rdi)
jmp 0x11143
leaq 0x12368(%rip), %rcx     # 0x234a8
movq %rdi, (%rcx)
movq %rdi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1116a
movq 0x110(%rdi), %r14
callq 0x11179
movq %r14, %rdi
testq %r14, %r14
jne 0x11156
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O1/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 0x111a0
movq 0x118(%rdi), %r14
callq 0xe040
movq %r14, %rdi
testq %r14, %r14
jne 0x1118c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xe040
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0xe10(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1040
testl %eax, %eax
je 0x12a8
movq 0x2dce(%rip), %rbp      # 0x3fd8
leaq 0x50(%rsp), %rbx
leaq 0xdee(%rip), %r14       # 0x2004
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
leaq 0xdf0(%rip), %r15       # 0x2017
movq (%rbp), %rdx
movq %rbx, %rdi
movl $0x80, %esi
callq 0x1060
testq %rax, %rax
je 0x12a8
movq %rbx, %rdi
callq 0x1030
cmpq $0x2, %rax
jb 0x1291
movq %rbx, %rdi
leaq 0xdb7(%rip), %rsi       # 0x200c
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1070
movq %r15, %rdi
cmpl $0x2, %eax
jl 0x12a1
callq 0x10b0
testl %eax, %eax
je 0x12bc
leaq 0xdb3(%rip), %rdi       # 0x202d
jle 0x12a1
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %esi, %esi
movl $0x1, %edx
callq 0x1080
testl %eax, %eax
jg 0x127c
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
testl %eax, %eax
jne 0x1227
jmp 0x12a8
callq 0x10d0
jmp 0x1291
xorl %eax, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edi
callq 0x10a0
movl 0xc(%rsp), %esi
leaq 0xd54(%rip), %rdi       # 0x2024
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
callq 0x1040
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/bench-base64unpack.c
// Function: LOOP_unpack9x32c48
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:
rdtsc
movq %rdx, %rcx
shlq $0x20, %rcx
orq %rax, %rcx
movq $-0x30, %rdx
vpbroadcastd 0x8d34(%rip), %xmm0 # 0xa58c
vpbroadcastb 0x8c85(%rip), %xmm1 # 0xa4e6
vmovdqa 0x86f7(%rip), %xmm2     # 0x9f60
vmovdqa 0x86ff(%rip), %xmm3     # 0x9f70
xorl %eax, %eax
vmovq 0x8705(%rip), %xmm4     # 0x9f80
vpbroadcastw 0x8c64(%rip), %xmm5 # 0xa4e8
vpbroadcastq 0x8db3(%rip), %xmm6 # 0xa640
vpbroadcastd 0x8cea(%rip), %xmm7 # 0xa580
vmovdqu 0x30(%rdi,%rdx), %xmm8
vpsrld $0x4, %xmm8, %xmm9
vpand %xmm0, %xmm9, %xmm9
vpand %xmm1, %xmm8, %xmm10
vpshufb %xmm10, %xmm2, %xmm10
vpshufb %xmm9, %xmm3, %xmm11
vptest %xmm11, %xmm10
jne 0x1a0b
vpcmpeqb %xmm1, %xmm8, %xmm10
vpaddb %xmm10, %xmm9, %xmm9
vpshufb %xmm9, %xmm4, %xmm9
vpaddb %xmm8, %xmm9, %xmm8
vpmaddubsw %xmm5, %xmm8, %xmm8
vpand %xmm6, %xmm8, %xmm9
vmovdqu %xmm9, (%rsi)
vpmaddwd %xmm7, %xmm8, %xmm8
vpsrld $0x9, %xmm8, %xmm9
vpand %xmm6, %xmm9, %xmm9
vmovdqu %xmm9, 0x10(%rsi)
vmovdqu 0x40(%rdi,%rdx), %xmm9
vpsrld $0x4, %xmm9, %xmm10
vpand %xmm0, %xmm10, %xmm10
vpand %xmm1, %xmm9, %xmm11
vpshufb %xmm11, %xmm2, %xmm11
vpshufb %xmm10, %xmm3, %xmm12
vptest %xmm12, %xmm11
jne 0x1a0b
vpcmpeqb %xmm1, %xmm9, %xmm11
vpaddb %xmm11, %xmm10, %xmm10
vpshufb %xmm10, %xmm4, %xmm10
vpaddb %xmm9, %xmm10, %xmm9
vpsrld $0x12, %xmm8, %xmm8
vpslld $0x6, %xmm9, %xmm10
vpor %xmm8, %xmm10, %xmm8
vpmaddubsw %xmm5, %xmm9, %xmm9
vpand %xmm6, %xmm8, %xmm8
vmovdqu %xmm8, 0x20(%rsi)
vpsrld $0x3, %xmm9, %xmm8
vpand %xmm6, %xmm8, %xmm8
vmovdqu %xmm8, 0x30(%rsi)
vpmaddwd %xmm7, %xmm9, %xmm8
vpsrld $0xc, %xmm8, %xmm9
vpand %xmm6, %xmm9, %xmm9
vmovdqu %xmm9, 0x40(%rsi)
vmovdqu 0x50(%rdi,%rdx), %xmm9
vpsrld $0x4, %xmm9, %xmm10
vpand %xmm0, %xmm10, %xmm10
vpand %xmm1, %xmm9, %xmm11
vpshufb %xmm11, %xmm2, %xmm11
vpshufb %xmm10, %xmm3, %xmm12
vptest %xmm12, %xmm11
jne 0x1a0b
vpcmpeqb %xmm1, %xmm9, %xmm11
vpaddb %xmm11, %xmm10, %xmm10
vpshufb %xmm10, %xmm4, %xmm10
vpaddb %xmm9, %xmm10, %xmm9
vpsrld $0x15, %xmm8, %xmm8
vpslld $0x3, %xmm9, %xmm10
vpor %xmm8, %xmm10, %xmm8
vpmaddubsw %xmm5, %xmm9, %xmm9
vpand %xmm6, %xmm8, %xmm8
vmovdqu %xmm8, 0x50(%rsi)
vpmaddwd %xmm7, %xmm9, %xmm8
vpsrld $0x6, %xmm8, %xmm9
vpand %xmm6, %xmm9, %xmm9
vmovdqu %xmm9, 0x60(%rsi)
vpsrld $0xf, %xmm8, %xmm8
vmovdqu %xmm8, 0x70(%rsi)
subq $-0x80, %rsi
addq $0x30, %rdx
cmpq $0x2fd0, %rdx           # imm = 0x2FD0
jb 0x1896
rdtsc
movq %rax, %rsi
movq %rdx, %rax
shlq $0x20, %rax
orq %rsi, %rax
subq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack6x16c16
static inline void pack6x16c16(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[v[ 0] & Mask(6)];
    s[ 4] = base64[v[ 1] & Mask(6)];
    s[ 8] = base64[v[ 2] & Mask(6)];
    s[12] = base64[v[ 3] & Mask(6)];
    s[ 1] = base64[v[ 4] & Mask(6)];
    s[ 5] = base64[v[ 5] & Mask(6)];
    s[ 9] = base64[v[ 6] & Mask(6)];
    s[13] = base64[v[ 7] & Mask(6)];
    s[ 2] = base64[v[ 8] & Mask(6)];
    s[ 6] = base64[v[ 9] & Mask(6)];
    s[10] = base64[v[10] & Mask(6)];
    s[14] = base64[v[11] & Mask(6)];
    s[ 3] = base64[v[12] & Mask(6)];
    s[ 7] = base64[v[13] & Mask(6)];
    s[11] = base64[v[14] & Mask(6)];
    s[15] = base64[v[15] & Mask(6)];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x4371(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl 0x4(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %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, 0xc(%rsi)
movl 0x10(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl 0x14(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x18(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x1c(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x20(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x24(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x28(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x2c(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0x30(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x34(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x38(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x3c(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack7x12c14
static inline void pack7x12c14(const uint32_t *v, char *s, unsigned e)
{
    uint64_t x;
    x = (v[ 0] & Mask(7))       | (v[ 4] & Mask(7)) <<  7 | (v[ 8] & Mask(7)) << 14
      | (v[ 1] & Mask(7)) << 21 | (v[ 5] & Wask(7)) << 28 | (v[ 9] & Wask(7)) << 35;
    s[ 0] = base64[(x      ) & Mask(6)];
    s[ 1] = base64[(x >>  6) & Mask(6)];
    s[ 2] = base64[(x >> 12) & Mask(6)];
    s[ 3] = base64[(x >> 18) & Mask(6)];
    s[ 4] = base64[(x >> 24) & Mask(6)];
    s[ 5] = base64[(x >> 30) & Mask(6)];
    s[ 6] = base64[(x >> 36)          ];
    x = (v[ 2] & Mask(7))       | (v[ 6] & Mask(7)) <<  7 | (v[10] & Mask(7)) << 14
      | (v[ 3] & Mask(7)) << 21 | (v[ 7] & Wask(7)) << 28 | (v[11] & Wask(7)) << 35;
    s[ 7] = base64[(x      ) & Mask(6)];
    s[ 8] = base64[(x >>  6) & Mask(6)];
    s[ 9] = base64[(x >> 12) & Mask(6)];
    s[10] = base64[(x >> 18) & Mask(6)];
    s[11] = base64[(x >> 24) & Mask(6)];
    s[12] = base64[(x >> 30) & Mask(6)];
    s[13] = base64[(x >> 36)          ];
    (void) e;
}

// Assembly:
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
andl $0x7f, %eax
movl 0x10(%rdi), %r8d
andl $0x7f, %r8d
shll $0x7, %r8d
orl %eax, %r8d
movl 0x20(%rdi), %r9d
andl $0x7f, %r9d
shll $0xe, %r9d
orl %r8d, %r9d
andl $0x7f, %ecx
shll $0x15, %ecx
orl %r9d, %ecx
movl 0x14(%rdi), %eax
andl $0x7f, %eax
shlq $0x1c, %rax
movl 0x24(%rdi), %edx
andl $0x7f, %edx
movq %rdx, %r10
shlq $0x23, %r10
orq %rax, %r10
orq %rcx, %r10
movl %ecx, %r11d
andl $0x3f, %r11d
leaq 0x425d(%rip), %rax      # 0x9010
movb (%r11,%rax), %r11b
movb %r11b, (%rsi)
shrl $0x6, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x1(%rsi)
shrl $0xc, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r8b
movb %r8b, 0x2(%rsi)
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl %r10d, %ecx
shrl $0x18, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
shrq $0x1e, %r10
andl $0x3f, %r10d
movb (%r10,%rax), %cl
movb %cl, 0x5(%rsi)
shrl %edx
movb (%rdx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
andl $0x7f, %edx
movl 0x18(%rdi), %r8d
andl $0x7f, %r8d
shll $0x7, %r8d
orl %edx, %r8d
movl 0x28(%rdi), %r9d
andl $0x7f, %r9d
shll $0xe, %r9d
orl %r8d, %r9d
andl $0x7f, %ecx
shll $0x15, %ecx
orl %r9d, %ecx
movl 0x1c(%rdi), %r10d
andl $0x7f, %r10d
shlq $0x1c, %r10
movl 0x2c(%rdi), %edx
andl $0x7f, %edx
movq %rdx, %rdi
shlq $0x23, %rdi
orq %r10, %rdi
orq %rcx, %rdi
movl %ecx, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r10b
movb %r10b, 0x7(%rsi)
shrl $0x6, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x8(%rsi)
shrl $0xc, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r8b
movb %r8b, 0x9(%rsi)
shrl $0x12, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl %edi, %ecx
shrl $0x18, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
shrq $0x1e, %rdi
andl $0x3f, %edi
movb (%rdi,%rax), %cl
movb %cl, 0xc(%rsi)
shrl %edx
movb (%rdx,%rax), %al
movb %al, 0xd(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack9x10c15
static inline void pack9x10c15(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(v[0] & Mask(6))];
    s[ 1] = base64[(v[0] & Mask(9)) >> 6 |
		   (v[1] & Mask(3)) << 3];
    s[ 2] = base64[(v[1] & Mask(9)) >> 3];
    s[ 3] = base64[(v[2] & Mask(6))];
    s[ 4] = base64[(v[2] & Mask(9)) >> 6 |
		   (v[3] & Mask(3)) << 3];
    s[ 5] = base64[(v[3] & Mask(9)) >> 3];
    s[ 6] = base64[(v[4] & Mask(6))];
    s[ 7] = base64[(v[4] & Mask(9)) >> 6 |
		   (v[5] & Mask(3)) << 3];
    s[ 8] = base64[(v[5] & Mask(9)) >> 3];
    s[ 9] = base64[(v[6] & Mask(6))];
    s[10] = base64[(v[6] & Mask(9)) >> 6 |
		   (v[7] & Mask(3)) << 3];
    s[11] = base64[(v[7] & Mask(9)) >> 3];
    s[12] = base64[(v[8] & Mask(6))];
    s[13] = base64[(v[8] & Mask(9)) >> 6 |
		   (v[9] & Mask(3)) << 3];
    s[14] = base64[(v[9] & Mask(9)) >> 3];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x3cff(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
shrl $0x6, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0x6, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x10(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0x6, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x18(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x18(%rdi), %ecx
movl 0x1c(%rdi), %edx
shrl $0x6, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x1c(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x20(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x20(%rdi), %ecx
movl 0x24(%rdi), %edx
shrl $0x6, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x24(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xe(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack10x9c15
static inline void pack10x9c15(const uint32_t *v, char *s, unsigned e)
{
    uint32_t x;
    x = (v[0] & Mask(10)) | (v[1] & Mask(10)) << 10 | (v[2] & Mask(10)) << 20;
    s[ 0] = base64[(x & Mask( 6))];
    s[ 1] = base64[(x & Mask(12)) >> 6];
    s[ 2] = base64[(x & Mask(18)) >> 12];
    s[ 3] = base64[(x & Mask(24)) >> 18];
    s[ 4] = base64[(x >> 24)];
    x = (v[3] & Mask(10)) | (v[4] & Mask(10)) << 10 | (v[5] & Mask(10)) << 20;
    s[ 5] = base64[(x & Mask( 6))];
    s[ 6] = base64[(x & Mask(12)) >> 6];
    s[ 7] = base64[(x & Mask(18)) >> 12];
    s[ 8] = base64[(x & Mask(24)) >> 18];
    s[ 9] = base64[(x >> 24)];
    x = (v[6] & Mask(10)) | (v[7] & Mask(10)) << 10 | (v[8] & Mask(10)) << 20;
    s[10] = base64[(x & Mask( 6))];
    s[11] = base64[(x & Mask(12)) >> 6];
    s[12] = base64[(x & Mask(18)) >> 12];
    s[13] = base64[(x & Mask(24)) >> 18];
    s[14] = base64[(x >> 24)];
    (void) e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rdi), %r11d
movl 0x4(%rdi), %r9d
movl $0x3c0, %ecx            # imm = 0x3C0
movl %r11d, %eax
andl %ecx, %eax
movl %r9d, %ebx
shll $0xa, %ebx
movl $0xc0000, %edx          # imm = 0xC0000
movl %ebx, %ebp
andl %edx, %ebp
movl 0x8(%rdi), %r8d
movl %r8d, %r10d
shll $0x14, %r10d
orl %ebp, %r10d
orl %eax, %ebx
andl $0x3f, %r11d
leaq 0x36e1(%rip), %rax      # 0x9010
movb (%r11,%rax), %r11b
movb %r11b, (%rsi)
shrl $0x6, %ebx
andl $0x3f, %ebx
movb (%rbx,%rax), %r11b
movb %r11b, 0x1(%rsi)
shrl $0x2, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r9b
movb %r9b, 0x2(%rsi)
shrl $0x12, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %r9b
movb %r9b, 0x3(%rsi)
shrl $0x4, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x4(%rsi)
movl 0xc(%rdi), %r10d
movl 0x10(%rdi), %r9d
movl %r10d, %r11d
andl %ecx, %r11d
movl %r9d, %ebx
shll $0xa, %ebx
movl %ebx, %ebp
andl %edx, %ebp
movl 0x14(%rdi), %r8d
movl %r8d, %r14d
shll $0x14, %r14d
orl %ebp, %r14d
orl %r11d, %ebx
andl $0x3f, %r10d
movb (%r10,%rax), %r10b
movb %r10b, 0x5(%rsi)
shrl $0x6, %ebx
andl $0x3f, %ebx
movb (%rbx,%rax), %r10b
movb %r10b, 0x6(%rsi)
shrl $0x2, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %r9b
movb %r9b, 0x7(%rsi)
shrl $0x12, %r14d
andl $0x3f, %r14d
movb (%r14,%rax), %r9b
movb %r9b, 0x8(%rsi)
shrl $0x4, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %r8b
movb %r8b, 0x9(%rsi)
movl 0x18(%rdi), %r9d
movl 0x1c(%rdi), %r8d
andl %r9d, %ecx
movl %r8d, %r10d
shll $0xa, %r10d
andl %r10d, %edx
movl 0x20(%rdi), %edi
movl %edi, %r11d
shll $0x14, %r11d
orl %edx, %r11d
orl %ecx, %r10d
andl $0x3f, %r9d
movb (%r9,%rax), %cl
movb %cl, 0xa(%rsi)
shrl $0x6, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %cl
movb %cl, 0xb(%rsi)
shrl $0x2, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %cl
movb %cl, 0xc(%rsi)
shrl $0x12, %r11d
andl $0x3f, %r11d
movb (%r11,%rax), %cl
movb %cl, 0xd(%rsi)
shrl $0x4, %edi
andl $0x3f, %edi
movb (%rdi,%rax), %al
movb %al, 0xe(%rsi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack11x8c15e2
static inline void pack11x8c15e2(const uint32_t *v, char *s, unsigned e)
{
    uint32_t x;
    x = (v[0] & Mask(10))
      | (v[7] & Mask(11)) >> 5 << 10
      | (  e  & Mask( 2)) << 16;
    s[ 0] = base64[(x & Mask(6))];
    s[ 1] = base64[(x & Mask(12)) >> 6];
    s[ 2] = base64[(x >> 12)];
    s[ 3] = base64[(v[0] & Mask(11)) >> 10 |
		   (v[1] & Mask( 5)) <<  1];
    s[ 4] = base64[(v[1] & Mask(11)) >>  5];
    s[ 5] = base64[(v[2] & Mask( 6))];
    s[ 6] = base64[(v[2] & Mask(11)) >>  6 |
		   (v[3] & Mask( 1)) <<  5];
    s[ 7] = base64[(v[3] & Mask( 7)) >>  1];
    s[ 8] = base64[(v[3] & Mask(11)) >>  7 |
		   (v[4] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[4] & Mask( 8)) >>  2];
    s[10] = base64[(v[4] & Mask(11)) >>  8 |
		   (v[5] & Mask( 3)) <<  3];
    s[11] = base64[(v[5] & Mask( 9)) >>  3];
    s[12] = base64[(v[5] & Mask(11)) >>  9 |
		   (v[6] & Mask( 4)) <<  2];
    s[13] = base64[(v[6] & Mask(10)) >>  4];
    s[14] = base64[(v[6] & Mask(11)) >> 10 |
		   (v[7] & Mask( 5)) <<  1];
}

// Assembly:
movl (%rdi), %ecx
movl 0x1c(%rdi), %r8d
movl %ecx, %eax
andl $0x3c0, %eax            # imm = 0x3C0
shll $0x5, %r8d
andl $0xfc00, %r8d           # imm = 0xFC00
andl $0x3, %edx
shll $0x10, %edx
orl %r8d, %edx
orl %eax, %r8d
andl $0x3f, %ecx
leaq 0x2e1e(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
shrl $0x6, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %cl
movb %cl, 0x1(%rsi)
shrl $0xc, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x2(%rsi)
movl (%rdi), %ecx
movl 0x4(%rdi), %edx
shrl $0xa, %ecx
andl $0x1, %ecx
andl $0x1f, %edx
leal (%rcx,%rdx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0x6, %ecx
andl $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0xc(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0x7, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0x8, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x14(%rdi), %ecx
movl 0x18(%rdi), %edx
shrl $0x9, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x18(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x18(%rdi), %ecx
movl 0x1c(%rdi), %edx
shrl $0xa, %ecx
andl $0x1, %ecx
andl $0x1f, %edx
leal (%rcx,%rdx,2), %ecx
movb (%rcx,%rax), %al
movb %al, 0xe(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack11x8c16e8
static inline void pack11x8c16e8(const uint32_t *v, char *s, unsigned e)
{
    uint32_t x;
    x = (  e  & Mask(8))
      | (v[0] & Mask(11)) << 8
      | (v[1] & Mask(11)) << 19;
    s[ 0] = base64[(x & Mask(6))];
    s[ 1] = base64[(x & Mask(12)) >>  6];
    s[ 2] = base64[(x & Mask(18)) >> 12];
    s[ 3] = base64[(x & Mask(24)) >> 18];
    s[ 4] = base64[(x & Mask(30)) >> 24];
    s[ 5] = base64[(v[2] & Mask( 6))];
    s[ 6] = base64[(v[2] & Mask(11)) >>  6 |
		   (v[3] & Mask( 1)) <<  5];
    s[ 7] = base64[(v[3] & Mask( 7)) >>  1];
    s[ 8] = base64[(v[3] & Mask(11)) >>  7 |
		   (v[4] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[4] & Mask( 8)) >>  2];
    s[10] = base64[(v[4] & Mask(11)) >>  8 |
		   (v[5] & Mask( 3)) <<  3];
    s[11] = base64[(v[5] & Mask( 9)) >>  3];
    s[12] = base64[(v[5] & Mask(11)) >>  9 |
		   (v[6] & Mask( 4)) <<  2];
    s[13] = base64[(v[6] & Mask(10)) >>  4];
    s[14] = base64[(v[6] & Mask(11)) >> 10 |
		   (v[7] & Mask( 5)) <<  1];
    s[15] = base64[(v[7] & Mask(11)) >>  5];
}

// Assembly:
movl %edx, %eax
andl $0xc0, %eax
movl (%rdi), %r9d
movl 0x4(%rdi), %ecx
movl %r9d, %r10d
shll $0x8, %r10d
movl %r10d, %r11d
andl $0x40000, %r11d         # imm = 0x40000
movl %ecx, %r8d
shll $0x13, %r8d
orl %r11d, %r8d
orl %eax, %r10d
andl $0x3f, %edx
leaq 0x2ce2(%rip), %rax      # 0x9010
movb (%rdx,%rax), %dl
movb %dl, (%rsi)
shrl $0x6, %r10d
andl $0x3f, %r10d
movb (%r10,%rax), %dl
movb %dl, 0x1(%rsi)
shrl $0x4, %r9d
andl $0x3f, %r9d
movb (%r9,%rax), %dl
movb %dl, 0x2(%rsi)
shrl $0x12, %r8d
andl $0x3f, %r8d
movb (%r8,%rax), %dl
movb %dl, 0x3(%rsi)
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0x6, %ecx
andl $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0xc(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0x7, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0x8, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x14(%rdi), %ecx
movl 0x18(%rdi), %edx
shrl $0x9, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x18(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x18(%rdi), %ecx
movl 0x1c(%rdi), %edx
shrl $0xa, %ecx
andl $0x1, %ecx
andl $0x1f, %edx
leal (%rcx,%rdx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0x1c(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack12x8c16
static inline void pack12x8c16(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[1] & Mask( 6))];
    s[ 3] = base64[(v[1] & Mask(12)) >> 6];
    s[ 4] = base64[(v[2] & Mask( 6))];
    s[ 5] = base64[(v[2] & Mask(12)) >> 6];
    s[ 6] = base64[(v[3] & Mask( 6))];
    s[ 7] = base64[(v[3] & Mask(12)) >> 6];
    s[ 8] = base64[(v[4] & Mask( 6))];
    s[ 9] = base64[(v[4] & Mask(12)) >> 6];
    s[10] = base64[(v[5] & Mask( 6))];
    s[11] = base64[(v[5] & Mask(12)) >> 6];
    s[12] = base64[(v[6] & Mask( 6))];
    s[13] = base64[(v[6] & Mask(12)) >> 6];
    s[14] = base64[(v[7] & Mask( 6))];
    s[15] = base64[(v[7] & Mask(12)) >> 6];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x2a49(%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 0x4(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x8(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0xc(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0x10(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x14(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x18(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x18(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x1c(%rdi), %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0x1c(%rdi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack13x6c13
static inline void pack13x6c13(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(13)) >> 12 |
		   (v[1] & Mask( 5)) <<  1];
    s[ 3] = base64[(v[1] & Mask(11)) >>  5];
    s[ 4] = base64[(v[1] & Mask(13)) >> 11 |
		   (v[2] & Mask( 4)) <<  2];
    s[ 5] = base64[(v[2] & Mask(10)) >>  4];
    s[ 6] = base64[(v[2] & Mask(13)) >> 10 |
		   (v[3] & Mask( 3)) <<  3];
    s[ 7] = base64[(v[3] & Mask( 9)) >>  3];
    s[ 8] = base64[(v[3] & Mask(13)) >>  9 |
		   (v[4] & Mask( 2)) <<  4];
    s[ 9] = base64[(v[4] & Mask( 8)) >>  2];
    s[10] = base64[(v[4] & Mask(13)) >>  8 |
		   (v[5] & Mask( 1)) <<  5];
    s[11] = base64[(v[5] & Mask( 7)) >>  1];
    s[12] = base64[(v[5] & Mask(13)) >>  7];
    (void) e;
}

// Assembly:
movl (%rdi), %ecx
andl $0x3f, %ecx
leaq 0x27b7(%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
movl 0x4(%rdi), %edx
shrl $0xc, %ecx
andl $0x1, %ecx
andl $0x1f, %edx
leal (%rcx,%rdx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x2(%rsi)
movl 0x4(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x3(%rsi)
movl 0x4(%rdi), %ecx
movl 0x8(%rdi), %edx
shrl $0xb, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x4(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0xa, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0x9, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0x8, %ecx
andl $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x14(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x7, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xc(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/svpv[P]rpmset/./base64pack.h
// Function: pack13x7c16e5
static inline void pack13x7c16e5(const uint32_t *v, char *s, unsigned e)
{
    s[ 0] = base64[(  e  & Mask( 5))       |
		   (v[0] & Mask( 1)) <<  5];
    s[ 1] = base64[(v[0] & Mask( 7)) >>  1];
    s[ 2] = base64[(v[0] & Mask(13)) >>  7];
    s[ 3] = base64[(v[1] & Mask( 6))];
    s[ 4] = base64[(v[1] & Mask(12)) >>  6];
    s[ 5] = base64[(v[1] & Mask(13)) >> 12 |
		   (v[2] & Mask( 5)) <<  1];
    s[ 6] = base64[(v[2] & Mask(11)) >>  5];
    s[ 7] = base64[(v[2] & Mask(13)) >> 11 |
		   (v[3] & Mask( 4)) <<  2];
    s[ 8] = base64[(v[3] & Mask(10)) >>  4];
    s[ 9] = base64[(v[3] & Mask(13)) >> 10 |
		   (v[4] & Mask( 3)) <<  3];
    s[10] = base64[(v[4] & Mask( 9)) >>  3];
    s[11] = base64[(v[4] & Mask(13)) >>  9 |
		   (v[5] & Mask( 2)) <<  4];
    s[12] = base64[(v[5] & Mask( 8)) >>  2];
    s[13] = base64[(v[5] & Mask(13)) >>  8 |
		   (v[6] & Mask( 1)) <<  5];
    s[14] = base64[(v[6] & Mask( 7)) >>  1];
    s[15] = base64[(v[6] & Mask(13)) >>  7];
}

// Assembly:
andl $0x1f, %edx
movl (%rdi), %ecx
shll $0x5, %ecx
andl $0x20, %ecx
orl %edx, %ecx
leaq 0x26bb(%rip), %rax      # 0x9010
movb (%rcx,%rax), %cl
movb %cl, (%rsi)
movl (%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x1(%rsi)
movl (%rdi), %ecx
shrl $0x7, %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
movl 0x8(%rdi), %edx
shrl $0xc, %ecx
andl $0x1, %ecx
andl $0x1f, %edx
leal (%rcx,%rdx,2), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x5(%rsi)
movl 0x8(%rdi), %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x6(%rsi)
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %edx
shrl $0xb, %ecx
andl $0x3, %ecx
andl $0xf, %edx
leal (%rcx,%rdx,4), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x7(%rsi)
movl 0xc(%rdi), %ecx
shrl $0x4, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x8(%rsi)
movl 0xc(%rdi), %ecx
movl 0x10(%rdi), %edx
shrl $0xa, %ecx
andl $0x7, %ecx
andl $0x7, %edx
leal (%rcx,%rdx,8), %ecx
movb (%rcx,%rax), %cl
movb %cl, 0x9(%rsi)
movl 0x10(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xa(%rsi)
movl 0x10(%rdi), %ecx
movl 0x14(%rdi), %edx
shrl $0x9, %ecx
andl $0xf, %ecx
shll $0x4, %edx
andl $0x30, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0xb(%rsi)
movl 0x14(%rdi), %ecx
shrl $0x2, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xc(%rsi)
movl 0x14(%rdi), %ecx
movl 0x18(%rdi), %edx
shrl $0x8, %ecx
andl $0x1f, %ecx
shll $0x5, %edx
andl $0x20, %edx
orl %ecx, %edx
movb (%rdx,%rax), %cl
movb %cl, 0xd(%rsi)
movl 0x18(%rdi), %ecx
shrl %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %cl
movb %cl, 0xe(%rsi)
movl 0x18(%rdi), %ecx
shrl $0x7, %ecx
andl $0x3f, %ecx
movb (%rcx,%rax), %al
movb %al, 0xf(%rsi)
retq