LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_bgzf.c
// Function: try_skip
static int try_skip(BGZF *fp, size_t count,
                   const char *name, const char *func) {
    size_t i;
    int c;
    for (i = 0; i < count; i++) {
        c = bgzf_getc(fp);
        if (c < 0) {
            fprintf(stderr,
                    "%s : Error from bgzf_getc on %s\n",
                    func, name);
            return -1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9b75
movq -0x10(%rbp), %rdi
callq 0xeb40
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x9b65
movq 0xfe49d(%rip), %rax     # 0x107fe0
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0xe0a02(%rip), %rsi     # 0xea557
movb $0x0, %al
callq 0x46d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9b7c
jmp 0x9b67
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9b20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_swap.c
// Function: shmem_int_atomic_swap
int shmem_int_atomic_swap( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	int r = *remote_ptr;
	*remote_ptr = val;
	__clear_spin_lock(x);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2060
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
leaq 0x2f84(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x2060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x45d0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x4590
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_04/link.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	if (argc < 3) {
		fprintf(stderr, "usage: %s <oldfile> <newfile>\n",
			argv[0]);
		return -1;
	}

	printf("linking %s to %s\n", argv[1], argv[2]);
	ret = link(argv[1], argv[2]);
	if (ret < 0) {
		perror("link");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x11b4
movq 0x2e65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe60(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x120c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xe58(%rip), %rdi       # 0x2023
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1205
leaq 0xe3e(%rip), %rdi       # 0x2035
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x120c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_pair__init
SH_dict_pair*
SH_dict_pair__init(SH_Key* key, SH_Item* value, int* err) {
	SH_dict_pair* obj;

	__cascade(err, (SH_dict_pair*)0);

	obj = (SH_dict_pair*)malloc(sizeof(SH_dict_pair));
	if ((SH_dict_pair*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_dict_pair*)0;
	}

	obj->key = key;
	obj->value = value;

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x11f0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x11f0
movq $0x0, -0x8(%rbp)
jmp 0x1253
movl $0x10, %edi
callq 0x1090
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1222
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1218
movq -0x20(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1253
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x124b
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_pair__destroy
void
SH_dict_pair__destroy(SH_dict_pair* obj, sh_bool_t recursive, int* err) {
	__cascade(err,);
	if (recursive) {
		SH_Key__destroy(obj->key, err);
		SH_Item__destroy(obj->value, recursive, err);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x128a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x128a
jmp 0x12d2
cmpb $0x0, -0x9(%rbp)
je 0x12b7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1040
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x12d2
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_bucket__init
SH_dict_bucket*
SH_dict_bucket__init(int *err) {
	SH_dict_bucket* obj;

	__cascade(err, (SH_dict_bucket*)0);

	obj = (SH_dict_bucket*)calloc(sizeof(SH_dict_bucket), 1);
	if ((SH_dict_bucket*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_dict_bucket*)0;
	}

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1308
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1308
movq $0x0, -0x8(%rbp)
jmp 0x1359
movl $0x30, %edi
movl $0x1, %esi
callq 0x1080
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x133f
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1335
movq -0x10(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1359
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1351
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_bucket__destroy
void
SH_dict_bucket__destroy(SH_dict_bucket* obj, sh_bool_t recursive, int* err) {
	__cascade(err,);
	if ((SH_dict_bucket*)0 != obj->next) {
		SH_dict_bucket__destroy(obj->next, recursive, err);
	}
	while (obj->num > (size_t)0) {
		obj->num --;
		SH_dict_pair__destroy(obj->pairs[obj->num], recursive, err);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x139a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x139a
jmp 0x1413
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x28(%rcx), %rax
je 0x13bd
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x10c0
jmp 0x13bf
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x13f8
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x1070
jmp 0x13bf
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1413
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict_bucket__add
void
SH_dict_bucket__add(SH_dict_bucket* obj, SH_dict_pair* pair, int* err) {
	__cascade(err,);
	while (obj->num >= SH_dict_bucket_size) {
		if ((SH_dict_bucket*)0 == obj->next) {
			obj->next = SH_dict_bucket__init(err);
			if (err) return;
		}
		obj = obj->next;
	}
	obj->pairs[obj->num] = pair;
	obj->num ++;

	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1448
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1448
jmp 0x14c1
jmp 0x144a
movq -0x8(%rbp), %rax
cmpq $0x4, (%rax)
jb 0x148d
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x28(%rcx), %rax
jne 0x147f
movq -0x18(%rbp), %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x147d
jmp 0x14c1
jmp 0x147f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x144a
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x14c1
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__init
SH_dict*
SH_dict__init(int* err) {
	SH_dict* obj;

	__cascade(err, (SH_dict*)0);

	obj = (SH_dict*)calloc(sizeof(SH_dict), 1);
	if ((SH_dict*)0 == obj) {
		__raise(err, SH_E_MALLOC_ERROR);
		return (SH_dict*)0;
	}

	__clear(err);
	return obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x14f8
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x14f8
movq $0x0, -0x8(%rbp)
jmp 0x1549
movl $0x808, %edi            # imm = 0x808
movl $0x1, %esi
callq 0x1080
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x152f
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1525
movq -0x10(%rbp), %rax
movl $0x80000001, (%rax)     # imm = 0x80000001
movq $0x0, -0x8(%rbp)
jmp 0x1549
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0x1541
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__destroy
void
SH_dict__destroy(SH_dict* obj, sh_bool_t recursive, int* err) {
	__cascade(err,);
	if ((SH_dict_bucket*)0 != obj->_list) {
		SH_dict_bucket__destroy(obj->_list, recursive, err);
	}
	free(obj);
	__clear(err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x158a
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x158a
jmp 0x15ce
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x800(%rcx), %rax
je 0x15b3
movq -0x8(%rbp), %rax
movq 0x800(%rax), %rdi
movb -0x9(%rbp), %al
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x10c0
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x15ce
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__get
SH_Item*
SH_dict__get(SH_dict* obj, SH_Key* key, int* err) {
	size_t i;
	uint8_t hash;
	SH_dict_bucket* bucket;
	SH_dict_pair* pair;

	hash = SH_Key__hash(key, err);
	bucket = obj->_hash[hash];

	__cascade(err, (SH_Item*)0);

	while ((SH_dict_bucket*)0 != bucket) {
		for (i = 0; /*i < SH_dict_bucket_size &&*/ i < bucket->num; i++) {
			pair = bucket->pairs[i];
			if (SH_Key__equal(key, pair->key, 0)) { /*FIXME: err?*/
				__clear(err);
				return pair->value;
			}
		}
		bucket = bucket->next;
	}

	/* not found, but no error */
	__clear(err);
	return (SH_Item*)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10b0
movb %al, -0x29(%rbp)
movq -0x10(%rbp), %rax
movzbl -0x29(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1633
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1633
movq $0x0, -0x8(%rbp)
jmp 0x16d6
jmp 0x1635
xorl %eax, %eax
cmpq -0x38(%rbp), %rax
je 0x16bc
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x16ab
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
cmpb $0x0, %al
je 0x169b
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x168d
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x16d6
jmp 0x169d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1645
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1635
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x16ce
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__count
size_t
SH_dict__count(SH_dict* obj, int* err) {
	SH_dict_bucket* bucket;
	size_t n = 0;

	__cascade(err, (size_t)0);

	bucket = obj->_list;
	while ((SH_dict_bucket*)0 != bucket) {
		n += bucket->num;
		bucket = bucket->next;
	}

	__clear(err);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1710
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1710
movq $0x0, -0x8(%rbp)
jmp 0x175e
movq -0x10(%rbp), %rax
movq 0x800(%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1744
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x171f
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x1756
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phluid61[P]hsf/src/_dict.c
// Function: SH_dict__add
void
SH_dict__add(SH_dict* obj, SH_Key* key, SH_Item* value, int* err) {
	SH_dict_pair* pair;
	uint8_t hash;

	__cascade(err,);

	pair = SH_dict_pair__init(key, value, err);
	__cascade(err,);

	/* add it to the _hash array */

	hash = SH_Key__hash(pair->key, err);
	if ((SH_dict_bucket*)0 == obj->_hash[hash]) {
		obj->_hash[hash] = SH_dict_bucket__init(err);
		__cascade(err,);
	}
	SH_dict_bucket__add(obj->_hash[hash], pair, err);
	__cascade(err,);

	/* add it to the _list list */

	if ((SH_dict_bucket*)0 == obj->_list) {
		obj->_list = SH_dict_bucket__init(err);
		__cascade(err,);
	}
	SH_dict_bucket__add(obj->_list, pair, err);
	__cascade(err,); /* FIXME are we left in a broken state? */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x179f
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x179f
jmp 0x18b6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10d0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x17cb
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x17cb
jmp 0x18b6
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x10b0
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rcx
movzbl -0x29(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq (%rcx,%rdx,8), %rax
jne 0x1821
movq -0x20(%rbp), %rdi
callq 0x10e0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movzbl -0x29(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x181f
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x181f
jmp 0x18b6
jmp 0x1821
movq -0x8(%rbp), %rax
movzbl -0x29(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10a0
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x184e
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x184e
jmp 0x18b6
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq 0x800(%rcx), %rax
jne 0x188a
movq -0x20(%rbp), %rdi
callq 0x10e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x800(%rax)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x1888
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x1888
jmp 0x18b6
jmp 0x188a
movq -0x8(%rbp), %rax
movq 0x800(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10a0
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x18b6
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
je 0x18b6
jmp 0x18b6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_12/itoa.c
// Function: main
int main(void)
{
  int n = -1234;
  char str[MAXLEN];

  int_to_array(n, str);
  printf("%s\n", str);

  n = -7676;

  int_to_array(n, str);
  printf("%s", str);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl $0xfffffb2e, -0x8(%rbp) # imm = 0xFFFFFB2E
movl -0x8(%rbp), %edi
leaq -0x70(%rbp), %rsi
callq 0x11b0
leaq -0x70(%rbp), %rsi
leaq 0xe97(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0xffffe204, -0x8(%rbp) # imm = 0xFFFFE204
movl -0x8(%rbp), %edi
leaq -0x70(%rbp), %rsi
callq 0x11b0
leaq -0x70(%rbp), %rsi
leaq 0xe76(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_12/itoa.c
// Function: int_to_array
void int_to_array(int n, char str[])
{
  static int i = 0;

  if (n)
  {
    if(n < 0){
      i = 0;
      str[i++] = '-';
      n *= -1;
    }

    int d = n % 10;
    n /= 10;


    int_to_array(n, str);
 

    str[i++] = d + '0';
    str[i] = '\0';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1256
cmpl $0x0, -0x4(%rbp)
jge 0x11fc
movl $0x0, 0x2e5b(%rip)      # 0x4034
movq -0x10(%rbp), %rax
movl 0x2e51(%rip), %ecx      # 0x4034
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x2e46(%rip)      # 0x4034
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
imull $-0x1, -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11b0
movl -0x14(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl 0x2dfe(%rip), %ecx      # 0x4034
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2df3(%rip)      # 0x4034
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movslq 0x2de2(%rip), %rcx      # 0x4034
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/toucs.c
// Function: charset_to_unicode
int charset_to_unicode(const char **input, int *inlen,
		       wchar_t *output, int outlen,
		       int charset, charset_state *state,
		       const wchar_t *errstr, int errlen)
{
    charset_spec const *spec = charset_find_spec(charset);
    charset_state localstate = CHARSET_INIT_STATE;
    struct unicode_emit_param param;

    param.output = output;
    param.outlen = outlen;
    param.errstr = errstr;
    param.errlen = errlen;
    param.writtenlen = 0;
    param.stopped = 0;

    if (state)
	localstate = *state;	       /* structure copy */

    while (*inlen > 0) {
	int lenbefore = param.writtenlen;
	spec->read(spec, (unsigned char)**input, &localstate,
		   unicode_emit, &param);
	if (param.stopped) {
	    /*
	     * The emit function has _tried_ to output some
	     * characters, but ran up against the end of the
	     * buffer. Leave immediately, and return what happened
	     * _before_ attempting to process this character.
	     */
	    return lenbefore;
	}
	if (state)
	    *state = localstate;   /* structure copy */
	(*input)++;
	(*inlen)--;
    }

    return param.writtenlen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x28(%rbp), %edi
callq 0x69d0
movq %rax, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x6060
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x60(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x6ae6
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x6ae8
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x6b63
movl -0x5c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl (%rcx), %ecx
movl %ecx, %esi
leaq -0x48(%rbp), %rdx
leaq 0x66(%rip), %rcx        # 0x6b80
leaq -0x68(%rbp), %r8
callq *%rax
cmpl $0x0, -0x4c(%rbp)
je 0x6b2e
movl -0x6c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6b69
cmpq $0x0, -0x30(%rbp)
je 0x6b48
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x6ae8
movl -0x5c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mloar[P]charset/toucs.c
// Function: unicode_emit
static void unicode_emit(void *ctx, long int output)
{
    struct unicode_emit_param *param = (struct unicode_emit_param *)ctx;
    wchar_t outval;
    wchar_t const *p;
    int outlen;

    if (output == ERROR) {
	if (param->errstr) {
	    p = param->errstr;
	    outlen = param->errlen;
	} else {
	    outval = 0xFFFD;	       /* U+FFFD REPLACEMENT CHARACTER */
	    p = &outval;
	    outlen = 1;
	}
    } else {
	outval = output;
	p = &outval;
	outlen = 1;
    }

    if (param->outlen < 0 || param->outlen >= outlen) {
	while (outlen > 0) {
	    if (param->output)
		*param->output++ = *p++;
	    if (param->outlen > 0)
		param->outlen--;
	    outlen--;
	    param->writtenlen++;
	}
    } else {
	param->stopped = 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0xffff, -0x10(%rbp)    # imm = 0xFFFF
jne 0x6bd9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6bc1
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x6bd7
movl $0xfffd, -0x1c(%rbp)    # imm = 0xFFFD
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
jmp 0x6bef
movq -0x10(%rbp), %rax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jl 0x6c05
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x2c(%rbp), %eax
jl 0x6c6c
jmp 0x6c07
cmpl $0x0, -0x2c(%rbp)
jle 0x6c6a
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c3b
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x4, %rsi
movq %rsi, (%rdx)
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jle 0x6c52
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x6c07
jmp 0x6c77
movq -0x18(%rbp), %rax
movl $0x1, 0x1c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/recovery.c
// Function: main
int main(void)
{
	run("Control", scen_control);
	run("Instant fail", scen_instant_fail);

	run("Fail after checkpoint", scen_after_check);
	run("Fail mid-checkpoint", scen_mid_check);
	run("Fail on meta", scen_meta_check);

	run("Cascade fail after checkpoint", scen_after_cascade);
	run("Cascade fail mid-checkpoint", scen_mid_cascade);

	run("Metadata dump failure", scen_meta_fail);

	run("Bad day", scen_bad_day);

	return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
leaq 0x2024(%rip), %rdi      # 0x5004
leaq 0x189(%rip), %rsi       # 0x3170
callq 0x3090
leaq 0x2019(%rip), %rdi      # 0x500c
leaq 0x186(%rip), %rsi       # 0x3180
callq 0x3090
leaq 0x2013(%rip), %rdi      # 0x5019
leaq 0x183(%rip), %rsi       # 0x3190
callq 0x3090
leaq 0x2016(%rip), %rdi      # 0x502f
leaq 0x180(%rip), %rsi       # 0x31a0
callq 0x3090
leaq 0x2017(%rip), %rdi      # 0x5043
leaq 0x17d(%rip), %rsi       # 0x31b0
callq 0x3090
leaq 0x2011(%rip), %rdi      # 0x5050
leaq 0x17a(%rip), %rsi       # 0x31c0
callq 0x3090
leaq 0x201c(%rip), %rdi      # 0x506e
leaq 0x197(%rip), %rsi       # 0x31f0
callq 0x3090
leaq 0x2025(%rip), %rdi      # 0x508a
leaq 0x1a4(%rip), %rsi       # 0x3210
callq 0x3090
leaq 0x2028(%rip), %rdi      # 0x50a0
leaq 0x1b1(%rip), %rsi       # 0x3230
callq 0x3090
xorl %eax, %eax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/recovery.c
// Function: run
static void run(const char *name, void (*scen)(void))
{
	uint8_t page_buf[1 << sim_nand.log2_page_size];
	struct dhara_journal journal;

	printf("========================================"
	       "================================\n"
	       "%s\n"
	       "========================================"
	       "================================\n\n", name);

	sim_reset();
	dhara_journal_init(&journal, &sim_nand, page_buf);

	/* All tests are tuned for this value */
	assert(journal.log2_ppc == 2);

	scen();

	jt_enqueue_sequence(&journal, 0, 30);
	jt_dequeue_sequence(&journal, 0, 30);

	sim_dump();
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x20e9(%rip), %rax      # 0x5190
movb (%rax), %cl
movl $0x1, %eax
shll %cl, %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x1fca(%rip), %rdi      # 0x50a8
movb $0x0, %al
callq 0x1050
callq 0x3270
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq 0x2097(%rip), %rsi      # 0x5190
callq 0x11c0
movzbl -0x48(%rbp), %eax
cmpl $0x2, %eax
jne 0x3109
jmp 0x3128
leaq 0x202f(%rip), %rdi      # 0x513f
leaq 0x203e(%rip), %rsi      # 0x5155
movl $0x25, %edx
leaq 0x2043(%rip), %rcx      # 0x5166
callq 0x1060
callq *-0x10(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x1e, %edx
callq 0x4130
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x1e, %edx
callq 0x4470
callq 0x3b60
leaq 0x1fe6(%rip), %rdi      # 0x513d
movb $0x0, %al
callq 0x1050
movq -0x18(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dlbeer[P]dhara/tests/recovery.c
// Function: scen_bad_day
static void scen_bad_day(void)
{
	int i;

	sim_set_timebomb(0, 7);
	for (i = 1; i < 5; i++)
		sim_set_timebomb(i, 3);
}

// Assembly:
pushq %rax
xorl %edi, %edi
movl $0x7, %esi
callq 0x3a00
movl $0x1, 0x4(%rsp)
cmpl $0x5, 0x4(%rsp)
jge 0x3267
movl 0x4(%rsp), %edi
movl $0x3, %esi
callq 0x3a00
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3245
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack7x12c14
static inline bool unpack7x12c14(const char *s, uint32_t *v, unsigned *e)
{
    int64_t x;
    x = base64wdec2(s + 0) | base64wdec2(s + 2) << 12 | base64wdec3(s + 4) << 24;
    if (x < 0) return false;
    v[ 0] = (x      ) & Mask(7);
    v[ 4] = (x >>  7) & Mask(7);
    v[ 8] = (x >> 14) & Mask(7);
    v[ 1] = (x >> 21) & Mask(7);
    v[ 5] = (x >> 28) & Mask(7);
    v[ 9] = (x >> 35);
    x = base64wdec2(s + 7) | base64wdec2(s + 9) << 12 | base64wdec3(s + 11) << 24;
    if (x < 0) return false;
    v[ 2] = (x      ) & Mask(7);
    v[ 6] = (x >>  7) & Mask(7);
    v[10] = (x >> 14) & Mask(7);
    v[ 3] = (x >> 21) & Mask(7);
    v[ 7] = (x >> 28) & Mask(7);
    v[11] = (x >> 35);
    return (void) e, true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0xf3b0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
addq $0x2, %rdi
callq 0xf3b0
movq %rax, %rcx
movq 0x10(%rsp), %rax
shlq $0xc, %rcx
orq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
addq $0x4, %rdi
callq 0xf250
movq %rax, %rcx
movq 0x18(%rsp), %rax
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jge 0x18a8
movb $0x0, 0x47(%rsp)
jmp 0x1a17
movq 0x20(%rsp), %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
sarq $0x7, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
sarq $0xe, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
sarq $0x15, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
sarq $0x1c, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x20(%rsp), %rax
sarq $0x23, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x38(%rsp), %rdi
addq $0x7, %rdi
callq 0xf3b0
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
addq $0x9, %rdi
callq 0xf3b0
movq %rax, %rcx
movq (%rsp), %rax
shlq $0xc, %rcx
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
addq $0xb, %rdi
callq 0xf250
movq %rax, %rcx
movq 0x8(%rsp), %rax
shlq $0x18, %rcx
orq %rcx, %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jge 0x1990
movb $0x0, 0x47(%rsp)
jmp 0x1a17
movq 0x20(%rsp), %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
sarq $0x7, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
sarq $0xe, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x20(%rsp), %rax
sarq $0x15, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rax
sarq $0x1c, %rax
andq $0x7f, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
sarq $0x23, %rax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x2c(%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack9x10c15
static inline bool unpack9x10c15(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[0] = (x & Mask(9));
    v[1] = (x >> 9);
    x = base64dec3(s + 3);
    if (x < 0) return false;
    v[2] = (x & Mask(9));
    v[3] = (x >> 9);
    x = base64dec3(s + 6);
    if (x < 0) return false;
    v[4] = (x & Mask(9));
    v[5] = (x >> 9);
    x = base64dec3(s + 9);
    if (x < 0) return false;
    v[6] = (x & Mask(9));
    v[7] = (x >> 9);
    x = base64dec3(s + 12);
    if (x < 0) return false;
    v[8] = (x & Mask(9));
    v[9] = (x >> 9);
    return (void) e, true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf2e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x2072
movb $0x0, 0x27(%rsp)
jmp 0x21a1
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
sarl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rdi
addq $0x3, %rdi
callq 0xf2e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x20b5
movb $0x0, 0x27(%rsp)
jmp 0x21a1
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x4(%rsp), %ecx
sarl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdi
addq $0x6, %rdi
callq 0xf2e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x20f9
movb $0x0, 0x27(%rsp)
jmp 0x21a1
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x4(%rsp), %ecx
sarl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x18(%rsp), %rdi
addq $0x9, %rdi
callq 0xf2e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x213a
movb $0x0, 0x27(%rsp)
jmp 0x21a1
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x4(%rsp), %ecx
sarl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x18(%rsp), %rdi
addq $0xc, %rdi
callq 0xf2e0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x217b
movb $0x0, 0x27(%rsp)
jmp 0x21a1
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x4(%rsp), %ecx
sarl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x24(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack10x9c15
static inline bool unpack10x9c15(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec3(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(10));
    v[1]  = (x & Mask(20)) >> 10;
    v[2]  = (x >> 20);
    x = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (x < 0) return false;
    v[3]  = (x & Mask(10));
    v[4]  = (x & Mask(20)) >> 10;
    v[5]  = (x >> 20);
    x = base64dec2(s + 10) | base64dec3(s + 12) << 12;
    if (x < 0) return false;
    v[6]  = (x & Mask(10));
    v[7]  = (x & Mask(20)) >> 10;
    v[8]  = (x >> 20);
    return (void) e, true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf2c0
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x2, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0x10(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x294f
movb $0x0, 0x37(%rsp)
jmp 0x2a72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rdi
addq $0x5, %rdi
callq 0xf2c0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
addq $0x7, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x29c4
movb $0x0, 0x37(%rsp)
jmp 0x2a72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x28(%rsp), %rdi
addq $0xa, %rdi
callq 0xf2c0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0xc, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0x8(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2a37
movb $0x0, 0x37(%rsp)
jmp 0x2a72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack10x10c18e8
static inline bool unpack10x10c18e8(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x;
    x = base64dec2(s + 0) | base64dec3(s + 2) << 12;
    if (x < 0) return false;
    v[0]  = (x & Mask(10));
    v[1]  = (x & Mask(20)) >> 10;
    v[2]  = (x >> 20);
    x = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (x < 0) return false;
    v[3]  = (x & Mask(10));
    v[4]  = (x & Mask(20)) >> 10;
    v[5]  = (x >> 20);
    x = base64dec2(s + 10) | base64dec3(s + 12) << 12;
    if (x < 0) return false;
    v[6]  = (x & Mask(10));
    v[7]  = (x & Mask(20)) >> 10;
    v[8]  = (x >> 20);
    x = base64dec3(s + 15);
    if (x < 0) return false;
    *e    = (x >> 10);
    v[9]  = (x & Mask(10));
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf2c0
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x2, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0x10(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2b0f
movb $0x0, 0x37(%rsp)
jmp 0x2c72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rdi
addq $0x5, %rdi
callq 0xf2c0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
addq $0x7, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2b84
movb $0x0, 0x37(%rsp)
jmp 0x2c72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x28(%rsp), %rdi
addq $0xa, %rdi
callq 0xf2c0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0xc, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0x8(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2bf7
movb $0x0, 0x37(%rsp)
jmp 0x2c72
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x14(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0xa, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl 0x14(%rsp), %ecx
sarl $0x14, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x28(%rsp), %rdi
addq $0xf, %rdi
callq 0xf2e0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x2c4d
movb $0x0, 0x37(%rsp)
jmp 0x2c72
movl 0x14(%rsp), %ecx
sarl $0xa, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, 0x24(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack11x8c15e2
static inline bool unpack11x8c15e2(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x, y;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[0]  = (x & Mask(10));
    *e    = (x >> 16);
    y = base64dec2(s + 3);
    if (y < 0) return false;
    v[0] |= (y & Mask(1)) << 10;
    v[1]  = (y >> 1);
    y = base64dec2(s + 5) | base64dec3(s + 7) << 12;
    if (y < 0) return false;
    v[2]  = (y & Mask(11));
    v[3]  = (y & Mask(22)) >> 11;
    v[4]  = (y >> 22);
    y = base64dec2(s + 10) | base64dec3(s + 12) << 12;
    if (y < 0) return false;
    v[4] |= (y & Mask(3)) << 8;
    v[5]  = (y & Mask(14)) >> 3;
    v[6]  = (y & Mask(25)) >> 14;
    v[7]  = (y >> 25);
    v[7] |= (x & Mask(6)<<10) >> 5;
    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xf2e0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x3582
movb $0x0, 0x37(%rsp)
jmp 0x3703
movl 0x14(%rsp), %ecx
andl $0x3ff, %ecx            # imm = 0x3FF
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
sarl $0x10, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rdi
addq $0x3, %rdi
callq 0xf2c0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x35c4
movb $0x0, 0x37(%rsp)
jmp 0x3703
movl 0x10(%rsp), %ecx
andl $0x1, %ecx
shll $0xa, %ecx
movq 0x20(%rsp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movl 0x10(%rsp), %ecx
sarl %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x28(%rsp), %rdi
addq $0x5, %rdi
callq 0xf2c0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
addq $0x7, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0xc(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x3625
movb $0x0, 0x37(%rsp)
jmp 0x3703
movl 0x10(%rsp), %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x10(%rsp), %ecx
andl $0x3fffff, %ecx         # imm = 0x3FFFFF
shrl $0xb, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x10(%rsp), %ecx
sarl $0x16, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rdi
addq $0xa, %rdi
callq 0xf2c0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0xc, %rdi
callq 0xf2e0
movl %eax, %ecx
movl 0x8(%rsp), %eax
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jge 0x3698
movb $0x0, 0x37(%rsp)
jmp 0x3703
movl 0x10(%rsp), %ecx
andl $0x7, %ecx
shll $0x8, %ecx
movq 0x20(%rsp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rsp), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
shrl $0x3, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x14(%rax)
movl 0x10(%rsp), %ecx
andl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
shrl $0xe, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0x10(%rsp), %ecx
sarl $0x19, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl 0x14(%rsp), %ecx
andl $0xfc00, %ecx           # imm = 0xFC00
shrl $0x5, %ecx
movq 0x20(%rsp), %rax
orl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack11x8c16e8
static inline bool unpack11x8c16e8(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x, y;
    x = base64dec5(s + 0);
    if (x < 0) return false;
    *e    = (uint8_t) x;
    v[0]  = (x & Mask(19)) >> 8;
    v[1]  = (x >> 19);
    x = base64dec5(s + 5);
    if (x < 0) return false;
    v[2]  = (x & Mask(11));
    v[3]  = (x & Mask(22)) >> 11;
    v[4]  = (x >> 22);
    y = base64dec5(s + 10);
    if (y < 0) return false;
    v[4] |= (y & Mask(3)) << 8;
    v[5]  = (y & Mask(14)) >> 3;
    v[6]  = (y & Mask(25)) >> 14;
    v[7]  = (y >> 25);
    x = base64dec1(s + 15);
    if (x < 0) return false;
    v[7] |= (x << 5);
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf430
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3782
movb $0x0, 0x27(%rsp)
jmp 0x38ae
movl 0x4(%rsp), %eax
movzbl %al, %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
andl $0x7ffff, %ecx          # imm = 0x7FFFF
shrl $0x8, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
sarl $0x13, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rdi
addq $0x5, %rdi
callq 0xf430
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x37d6
movb $0x0, 0x27(%rsp)
jmp 0x38ae
movl 0x4(%rsp), %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x4(%rsp), %ecx
andl $0x3fffff, %ecx         # imm = 0x3FFFFF
shrl $0xb, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x4(%rsp), %ecx
sarl $0x16, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x18(%rsp), %rdi
addq $0xa, %rdi
callq 0xf430
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jge 0x382d
movb $0x0, 0x27(%rsp)
jmp 0x38ae
movl (%rsp), %ecx
andl $0x7, %ecx
shll $0x8, %ecx
movq 0x10(%rsp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl (%rsp), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
shrl $0x3, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movl (%rsp), %ecx
andl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
shrl $0xe, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl (%rsp), %ecx
sarl $0x19, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x18(%rsp), %rdi
addq $0xf, %rdi
callq 0x6ef0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3897
movb $0x0, 0x27(%rsp)
jmp 0x38ae
movl 0x4(%rsp), %ecx
shll $0x5, %ecx
movq 0x10(%rsp), %rax
orl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack11x9c18e9
static inline bool unpack11x9c18e9(const char *s, uint32_t *v, unsigned *e)
{
    int32_t x, y;
    x = base64dec4(s + 0);
    if (x < 0) return false;
    *e    = (x & Mask(9));
    v[0]  = (x & Mask(20)) >> 9;
    v[1]  = (x >> 20);
    y = base64dec3(s + 4);
    if (y < 0) return false;
    v[1] |= (y & Mask(7)) << 4;
    v[2]  = (y >> 7);
    x = base64dec5(s + 7);
    if (x < 0) return false;
    v[3]  = (x & Mask(11));
    v[4]  = (x & Mask(22)) >> 11;
    v[5]  = (x >> 22);
    y = base64dec5(s + 12);
    if (y < 0) return false;
    v[5] |= (y & Mask(3)) << 8;
    v[6]  = (y & Mask(14)) >> 3;
    v[7]  = (y & Mask(25)) >> 14;
    v[8]  = (y >> 25);
    x = base64dec1(s + 17);
    if (x < 0) return false;
    v[8] |= (x << 5);
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf500
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3932
movb $0x0, 0x27(%rsp)
jmp 0x3aa4
movl 0x4(%rsp), %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
andl $0xfffff, %ecx          # imm = 0xFFFFF
shrl $0x9, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rsp), %ecx
sarl $0x14, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rdi
addq $0x4, %rdi
callq 0xf2e0
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jge 0x3987
movb $0x0, 0x27(%rsp)
jmp 0x3aa4
movl (%rsp), %ecx
andl $0x7f, %ecx
shll $0x4, %ecx
movq 0x10(%rsp), %rax
orl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl (%rsp), %ecx
sarl $0x7, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rdi
addq $0x7, %rdi
callq 0xf430
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x39cc
movb $0x0, 0x27(%rsp)
jmp 0x3aa4
movl 0x4(%rsp), %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x4(%rsp), %ecx
andl $0x3fffff, %ecx         # imm = 0x3FFFFF
shrl $0xb, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x4(%rsp), %ecx
sarl $0x16, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x18(%rsp), %rdi
addq $0xc, %rdi
callq 0xf430
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jge 0x3a23
movb $0x0, 0x27(%rsp)
jmp 0x3aa4
movl (%rsp), %ecx
andl $0x7, %ecx
shll $0x8, %ecx
movq 0x10(%rsp), %rax
orl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movl (%rsp), %ecx
andl $0x3fff, %ecx           # imm = 0x3FFF
shrl $0x3, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl (%rsp), %ecx
andl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
shrl $0xe, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl (%rsp), %ecx
sarl $0x19, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rdi
addq $0x11, %rdi
callq 0x6ef0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3a8d
movb $0x0, 0x27(%rsp)
jmp 0x3aa4
movl 0x4(%rsp), %ecx
shll $0x5, %ecx
movq 0x10(%rsp), %rax
orl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop