LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_index_load
static int try_bgzf_index_load(BGZF *fp, const char *bname, const char *suffix,
                               const char *func) {
    if (bgzf_index_load(fp, bname, suffix) != 0) {
        fprintf(stderr, "%s : Couldn't bgzf_index_load %s%s : %s\n",
                func, bname, suffix ? suffix : "", strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0xb918
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x8247
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x92d92(%rip), %rax     # 0x9afe0
movq (%rax), %r12
testq %r15, %r15
leaq 0x6d90b(%rip), %r13     # 0x75b66
cmovneq %r15, %r13
callq 0x4050
movl (%rax), %edi
callq 0x4140
leaq 0x6c126(%rip), %rsi     # 0x74398
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rax
jmp 0x823d
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_index_dump
static int try_bgzf_index_dump(BGZF *fp, const char *bname, const char *suffix,
                               const char *func) {
    if (bgzf_index_dump(fp, bname, suffix) != 0) {
        fprintf(stderr, "%s : Couldn't bgzf_index_dump %s%s : %s\n",
                func, bname, suffix ? suffix : "", strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
callq 0xb660
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x82b6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x92d23(%rip), %rax     # 0x9afe0
movq (%rax), %r12
testq %r15, %r15
leaq 0x6d89c(%rip), %r13     # 0x75b66
cmovneq %r15, %r13
callq 0x4050
movl (%rax), %edi
callq 0x4140
leaq 0x6c0e0(%rip), %rsi     # 0x743c1
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movq %r13, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rax
jmp 0x82ac
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_useek
static int try_bgzf_useek(BGZF *fp, long uoffset, int where,
                          const char *name, const char *func) {
    if (bgzf_useek(fp, uoffset, where) < 0) {
        fprintf(stderr, "%s : Error from bgzf_useek(%s, %ld, %d) : %s\n",
                func, name, uoffset, where, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
xorl %ebp, %ebp
xorl %edx, %edx
callq 0xb9e0
testl %eax, %eax
js 0x832d
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x92cac(%rip), %rax     # 0x9afe0
movq (%rax), %r12
callq 0x4050
movl (%rax), %edi
callq 0x4140
movq %rax, (%rsp)
leaq 0x6c103(%rip), %rsi     # 0x74451
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rbp
jmp 0x831e
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_getc
static int try_bgzf_getc(BGZF *fp, size_t pos, int expected,
                         const char *name, const char *func) {
    int c = bgzf_getc(fp);
    if (c != expected) {
        fprintf(stderr,
                "%s : Unexpected value (%d) from bgzf_getc on %s pos %zu; "
                "expected %d\n",
                func, c, name, pos, expected);
        return -1;
    }
    return c;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
callq 0xb2a9
cmpl %ebp, %eax
jne 0x8391
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x92c48(%rip), %rcx     # 0x9afe0
movq (%rcx), %rdi
movl %ebp, (%rsp)
leaq 0x6c0da(%rip), %rsi     # 0x7447f
movq %r15, %rdx
movl %eax, %ecx
movq %rbx, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rbp
jmp 0x8384
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_tell
static int64_t try_bgzf_tell(BGZF *fp, const char *name, const char *func) {
    int64_t told = bgzf_tell(fp);
    if (told < 0) {
        fprintf(stderr, "%s : %s %s : %s\n",
                func, "Error telling in",
                name, strerror(errno));
        return -1;
    }

    return told;
}

// Assembly:
movq 0x18(%rdi), %rax
shlq $0x10, %rax
js 0x83ce
movzwl 0x10(%rdi), %ecx
orq %rcx, %rax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq 0x92c00(%rip), %rax     # 0x9afe0
movq (%rax), %r15
callq 0x4050
movl (%rax), %edi
callq 0x4140
leaq 0x6bf09(%rip), %rsi     # 0x742ff
leaq 0x6c0dc(%rip), %rcx     # 0x744d9
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_seek
static int try_bgzf_seek(BGZF *fp, int64_t pos, int whence,
                          const char *name, const char *func) {
    if (bgzf_seek(fp, pos, whence) < 0) {
        fprintf(stderr, "%s : Error from bgzf_seek(%s, %" PRId64 ", %d) : %s\n",
                func, name, pos, whence, strerror(errno));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
xorl %ebp, %ebp
xorl %edx, %edx
callq 0xb0fb
testq %rax, %rax
js 0x8441
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x92b98(%rip), %rax     # 0x9afe0
movq (%rax), %r15
callq 0x4050
movl (%rax), %edi
callq 0x4140
movq %rax, (%rsp)
leaq 0x6c088(%rip), %rsi     # 0x744ea
leaq 0x6c05c(%rip), %rdx     # 0x744c5
movq %r15, %rdi
movq %r14, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rbp
jmp 0x8434
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_bgzf.c
// Function: try_bgzf_tell_expect
static int64_t try_bgzf_tell_expect(BGZF *fp, int64_t expected, const char *name, const char *func) {
    int64_t told = try_bgzf_tell(fp, name, func);
    if (told != expected) {
        fprintf(stderr, "%s : Unexpected value (%" PRId64 ") from bgzf_tell on %s; "
                "expected %" PRId64 "\n",
                func, told, name, expected);
        return -1;
    }
    return told;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x83bc
cmpq %rbx, %rax
jne 0x84a8
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x92b31(%rip), %rcx     # 0x9afe0
movq (%rcx), %rdi
leaq 0x6c05e(%rip), %rsi     # 0x74517
movq %r15, %rdx
movq %rax, %rcx
movq %r14, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x4700
pushq $-0x1
popq %rbx
jmp 0x849f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movl %edx, %esi
callq 0x1ba4
movq %rax, %r14
leaq 0x33c0(%rip), %rdi      # 0x61f0
addq $0x10, %rdi
movl %ebx, %esi
callq 0x1ba4
movq %rax, %rbx
movq %rax, %rdi
callq 0x30c8
movl (%r14), %r15d
movl %ebp, (%r14)
movq %rbx, %rdi
callq 0x30b8
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x2, %edi
jle 0x11ab
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
leaq 0xe9c(%rip), %rdi       # 0x2023
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1030
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rsi
callq 0x1060
testl %eax, %eax
js 0x11c8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2e46(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%r14), %rdx
leaq 0xe45(%rip), %rsi       # 0x2004
xorl %eax, %eax
callq 0x1040
jmp 0x11d4
leaq 0xe66(%rip), %rdi       # 0x2035
callq 0x1050
pushq $-0x1
popq %rbx
jmp 0x11a1
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x11d8
cmpl $0x0, (%rbx)
je 0x11d8
xorl %eax, %eax
jmp 0x11fe
pushq $0x10
popq %rdi
callq 0x1090
testq %rax, %rax
je 0x11f0
xorl %ecx, %ecx
movq %r15, (%rax)
movq %r14, 0x8(%rax)
jmp 0x11f7
movl $0x80000001, %ecx       # imm = 0x80000001
xorl %eax, %eax
testq %rbx, %rbx
je 0x11fe
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdx, %rdx
je 0x121a
cmpl $0x0, (%rbx)
jne 0x124a
testb %bpl, %bpl
je 0x123a
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x1040
movq 0x8(%r14), %rdi
movzbl %bpl, %esi
movq %rbx, %rdx
callq 0x1060
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x124a
andl $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1261
cmpl $0x0, (%rbx)
je 0x1261
xorl %eax, %eax
jmp 0x1280
pushq $0x30
popq %rdi
pushq $0x1
popq %rsi
callq 0x1080
testq %rbx, %rbx
je 0x1280
xorl %ecx, %ecx
testq %rax, %rax
movl $0x80000001, %edx       # imm = 0x80000001
cmovnel %ecx, %edx
movl %edx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1296
cmpl $0x0, (%rbx)
jne 0x12dc
movq 0x28(%r14), %rdi
movzbl %sil, %ebp
testq %rdi, %rdi
je 0x12c4
movl %ebp, %esi
movq %rbx, %rdx
callq 0x10c0
jmp 0x12c4
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movq (%r14,%rax,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1070
movq (%r14), %rax
testq %rax, %rax
jne 0x12af
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x12dc
andl $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
testq %rdx, %rdx
je 0x1315
cmpl $0x0, (%rbx)
jne 0x1335
jmp 0x1315
movq 0x28(%r15), %rax
testq %rax, %rax
jne 0x1315
movq %rbx, %rdi
callq 0x10e0
movq %rax, 0x28(%r15)
testq %rbx, %rbx
jne 0x1335
movq %rax, %r15
movq (%rax), %rax
cmpq $0x4, %rax
jae 0x12fb
leaq 0x1(%rax), %rcx
movq %r14, 0x8(%r15,%rax,8)
movq %rcx, (%r15)
testq %rbx, %rbx
je 0x1335
andl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x134d
cmpl $0x0, (%rbx)
je 0x134d
xorl %eax, %eax
jmp 0x136e
pushq $0x1
popq %rsi
movl $0x808, %edi            # imm = 0x808
callq 0x1080
testq %rbx, %rbx
je 0x136e
xorl %ecx, %ecx
testq %rax, %rax
movl $0x80000001, %edx       # imm = 0x80000001
cmovnel %ecx, %edx
movl %edx, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1384
cmpl $0x0, (%rbx)
jne 0x13ac
movq 0x800(%r14), %rdi
testq %rdi, %rdi
je 0x139c
movzbl %sil, %esi
movq %rbx, %rdx
callq 0x10c0
movq %r14, %rdi
callq 0x1030
testq %rbx, %rbx
je 0x13ac
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x10b0
movzbl %al, %eax
movq (%r15,%rax,8), %r15
testq %rbx, %rbx
je 0x140e
cmpl $0x0, (%rbx)
je 0x140e
xorl %eax, %eax
jmp 0x142a
xorl %r13d, %r13d
cmpq (%r15), %r13
jae 0x140a
movq 0x8(%r15,%r13,8), %r12
movq (%r12), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1050
incq %r13
testb %al, %al
je 0x13e9
jmp 0x141d
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x13e6
testq %rbx, %rbx
je 0x13e2
andl $0x0, (%rbx)
jmp 0x13e2
testq %rbx, %rbx
je 0x1425
andl $0x0, (%rbx)
movq 0x8(%r12), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x1441
cmpl $0x0, (%rsi)
je 0x1441
xorl %eax, %eax
retq
addq $0x800, %rdi            # imm = 0x800
xorl %eax, %eax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x145b
addq (%rdi), %rax
addq $0x28, %rdi
jmp 0x144a
testq %rsi, %rsi
je 0x1463
andl $0x0, (%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x1480
cmpl $0x0, (%rbx)
jne 0x1531
movq %rsi, %rdi
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x10d0
movq %rax, %r14
testq %rbx, %rbx
je 0x149f
cmpl $0x0, (%rbx)
jne 0x1531
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10b0
movzbl %al, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x14ce
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10a0
testq %rbx, %rbx
je 0x14f3
cmpl $0x0, (%rbx)
jne 0x1531
jmp 0x14f3
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
movq %rax, (%r15,%r12,8)
testq %rbx, %rbx
je 0x14e9
cmpl $0x0, (%rbx)
jne 0x1531
jmp 0x14b7
movq %r14, %rsi
xorl %edx, %edx
callq 0x10a0
movq 0x800(%r15), %rdi
testq %rdi, %rdi
je 0x1515
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0
movq %rbx, %rdi
callq 0x10e0
movq %rax, %rdi
movq %rax, 0x800(%r15)
testq %rbx, %rbx
je 0x153d
cmpl $0x0, (%rbx)
je 0x14ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rsi
xorl %edx, %edx
jmp 0x1505
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
je 0x11e3
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
jns 0x11aa
movl $0x1, 0x2e97(%rip)      # 0x403c
movb $0x2d, (%rbx)
negl %edi
pushq $0xa
popq %rcx
movl %edi, %eax
xorl %edx, %edx
divl %ecx
movl %edx, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x118f
orb $0x30, %bpl
movslq 0x2e72(%rip), %rax      # 0x403c
leaq 0x1(%rax), %rcx
movl %ecx, 0x2e68(%rip)      # 0x403c
movb %bpl, (%rbx,%rax)
movb $0x0, 0x1(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movl %r8d, %edi
callq 0x6640
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r13, (%rsp)
movl %ebp, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x78(%rsp), %eax
movl %eax, 0x18(%rsp)
andl $0x0, 0xc(%rsp)
andl $0x0, 0x1c(%rsp)
testq %rbx, %rbx
je 0x66d4
movups (%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movl (%r14), %eax
movq %rsp, %r13
movl 0xc(%rsp), %ebp
testl %eax, %eax
jle 0x6720
movq (%r15), %rax
movzbl (%rax), %esi
movq %r12, %rdi
leaq 0x20(%rsp), %rdx
leaq 0x3a(%rip), %rcx        # 0x6731
movq %r13, %r8
callq *0x8(%r12)
cmpl $0x0, 0x1c(%rsp)
jne 0x6720
testq %rbx, %rbx
je 0x6713
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rbx)
incq (%r15)
movl (%r14), %eax
decl %eax
movl %eax, (%r14)
jmp 0x66da
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0xffff, %rsi           # imm = 0xFFFF
jne 0x6748
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x6751
movl 0x18(%rdi), %ecx
jmp 0x6761
leaq -0x4(%rsp), %rax
movl %esi, (%rax)
jmp 0x675c
leaq -0x4(%rsp), %rax
movl $0xfffd, (%rax)         # imm = 0xFFFD
movl $0x1, %ecx
movl 0x8(%rdi), %edx
testl %edx, %edx
setns %sil
cmpl %ecx, %edx
setl %r8b
testb %r8b, %sil
je 0x677d
movl $0x1, 0x1c(%rdi)
retq
testl %ecx, %ecx
jle 0x677c
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x679b
movl (%rax), %edx
addq $0x4, %rax
leaq 0x4(%rsi), %r8
movq %r8, (%rdi)
movl %edx, (%rsi)
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x67a4
decl %edx
movl %edx, 0x8(%rdi)
decl %ecx
incl 0xc(%rdi)
jmp 0x677d
nop
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x1158(%rip), %rdi      # 0x3004
leaq 0x15f(%rip), %rsi       # 0x2012
callq 0x1f54
leaq 0x114d(%rip), %rdi      # 0x300c
leaq 0x14d(%rip), %rsi       # 0x2013
callq 0x1f54
leaq 0x1147(%rip), %rdi      # 0x3019
leaq 0x141(%rip), %rsi       # 0x201a
callq 0x1f54
leaq 0x114a(%rip), %rdi      # 0x302f
leaq 0x138(%rip), %rsi       # 0x2024
callq 0x1f54
leaq 0x114b(%rip), %rdi      # 0x3043
leaq 0x12f(%rip), %rsi       # 0x202e
callq 0x1f54
leaq 0x1145(%rip), %rdi      # 0x3050
leaq 0x126(%rip), %rsi       # 0x2038
callq 0x1f54
leaq 0x1150(%rip), %rdi      # 0x306e
leaq 0x136(%rip), %rsi       # 0x205b
callq 0x1f54
leaq 0x1159(%rip), %rdi      # 0x308a
leaq 0x13b(%rip), %rsi       # 0x2073
callq 0x1f54
leaq 0x115c(%rip), %rdi      # 0x30a0
leaq 0x13c(%rip), %rsi       # 0x2087
callq 0x1f54
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x1236(%rip), %r14      # 0x31a0
movb (%r14), %cl
pushq $0x1
popq %rax
shlq %cl, %rax
movq %rsi, %rbx
movq %rdi, %rsi
addq $0xf, %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
leaq 0x1117(%rip), %rdi      # 0x30a8
xorl %eax, %eax
callq 0x1070
callq 0x20b4
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11dc
cmpb $0x2, 0x10(%r12)
jne 0x1ff5
callq *%rbx
leaq -0x58(%rbp), %rbx
pushq $0x1e
popq %r14
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x2994
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x2c4e
callq 0x25e0
pushq $0xa
popq %rdi
callq 0x1030
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1143(%rip), %rdi      # 0x313f
leaq 0x1152(%rip), %rsi      # 0x3155
leaq 0x115c(%rip), %rcx      # 0x3166
pushq $0x25
popq %rdx
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
pushq $0x7
popq %rsi
xorl %edi, %edi
callq 0x24ff
pushq $0x1
popq %rbx
pushq $0x3
popq %rbp
cmpl $0x5, %ebx
je 0x20ac
movl %ebx, %edi
movl %ebp, %esi
callq 0x24ff
incl %ebx
jmp 0x209a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack5x19c16e1
static inline bool unpack5x19c16e1(const char *s, uint32_t *v, unsigned *e)
{
    int64_t x;
    x = base64wdec3(s + 0) | base64wdec3(s + 3) << 18;
    if (x < 0) return false;
    *e    = (x & 1);
    v[ 0] = (x >>  1) & Mask(5);
    v[ 1] = (x >>  6) & Mask(5);
    v[ 2] = (x >> 11) & Mask(5);
    v[ 3] = (x >> 16) & Mask(5);
    v[ 4] = (x >> 21) & Mask(5);
    v[ 5] = (x >> 26) & Mask(5);
    v[ 6] = (x >> 31);
    int32_t y;
    y = base64dec2(s + 6) | base64dec3(s + 8) << 12;
    if (y < 0) return false;
    v[ 7] = (y      ) & Mask(5);
    v[ 8] = (y >>  5) & Mask(5);
    v[ 9] = (y >> 10) & Mask(5);
    v[10] = (y >> 15) & Mask(5);
    v[11] = (y >> 20) & Mask(5);
    v[12] = (y >> 25);
    y = base64dec2(s + 11) | base64dec3(s + 13) << 12;
    if (y < 0) return false;
    v[13] = (y      ) & Mask(5);
    v[14] = (y >>  5) & Mask(5);
    v[15] = (y >> 10) & Mask(5);
    v[16] = (y >> 15) & Mask(5);
    v[17] = (y >> 20) & Mask(5);
    v[18] = (y >> 25);
    return (void) e, true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8976
movq %rax, %r15
leaq 0x3(%r14), %rdi
callq 0x8976
shlq $0x12, %rax
orq %r15, %rax
js 0x1351
movl %r15d, %ecx
andl $0x1, %ecx
movl %ecx, (%r12)
movl %r15d, %ecx
shrl %ecx
andl $0x1f, %ecx
movl %ecx, (%rbx)
movl %r15d, %ecx
shrl $0x6, %ecx
andl $0x1f, %ecx
movl %ecx, 0x4(%rbx)
shrl $0xb, %r15d
andl $0x1f, %r15d
movl %r15d, 0x8(%rbx)
movl %eax, %ecx
shrl $0x10, %ecx
andl $0x1f, %ecx
movl %ecx, 0xc(%rbx)
movl %eax, %ecx
shrl $0x15, %ecx
andl $0x1f, %ecx
movl %ecx, 0x10(%rbx)
movl %eax, %ecx
shrl $0x1a, %ecx
andl $0x1f, %ecx
movl %ecx, 0x14(%rbx)
shrq $0x1f, %rax
movl %eax, 0x18(%rbx)
movzbl 0x6(%r14), %eax
movzbl 0x7(%r14), %ecx
leaq 0x7dc4(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
leaq 0x8(%r14), %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x1351
movl %ebp, %ecx
andl $0x1f, %ecx
movl %ecx, 0x1c(%rbx)
shrl $0x5, %ebp
andl $0x1f, %ebp
movl %ebp, 0x20(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %ecx, 0x24(%rbx)
movl %eax, %ecx
shrl $0xf, %ecx
andl $0x1f, %ecx
movl %ecx, 0x28(%rbx)
movl %eax, %ecx
shrl $0x14, %ecx
andl $0x1f, %ecx
movl %ecx, 0x2c(%rbx)
shrl $0x19, %eax
movl %eax, 0x30(%rbx)
movzbl 0xb(%r14), %eax
movzbl 0xc(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
addq $0xd, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x1351
movl %ebp, %ecx
andl $0x1f, %ecx
movl %ecx, 0x34(%rbx)
shrl $0x5, %ebp
andl $0x1f, %ebp
movl %ebp, 0x38(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl $0x1f, %ecx
movl %ecx, 0x3c(%rbx)
movl %eax, %ecx
shrl $0xf, %ecx
andl $0x1f, %ecx
movl %ecx, 0x40(%rbx)
movl %eax, %ecx
shrl $0x14, %ecx
andl $0x1f, %ecx
movl %ecx, 0x44(%rbx)
shrl $0x19, %eax
movl %eax, 0x48(%rbx)
movb $0x1, %al
jmp 0x1353
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x7b88(%rip), %r15      # 0x9050
movsbq (%rax,%r15), %rax
movswq 0x100(%r15,%rcx,2), %r12
orq %rax, %r12
movzbl 0x2(%rdi), %eax
movzbl 0x3(%rdi), %ecx
movsbq (%rax,%r15), %rax
movswq 0x100(%r15,%rcx,2), %r13
orq %rax, %r13
shlq $0xc, %r13
addq $0x4, %rdi
callq 0x8976
shlq $0x18, %rax
orq %r12, %rax
orq %r13, %rax
js 0x15de
andl $0x7f, %r12d
movl %r12d, (%rbx)
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x7f, %ecx
movl %ecx, 0x10(%rbx)
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x7f, %ecx
movl %ecx, 0x20(%rbx)
movl %eax, %ecx
shrl $0x15, %ecx
andl $0x7f, %ecx
movl %ecx, 0x4(%rbx)
movq %rax, %rcx
shrq $0x1c, %rcx
andl $0x7f, %ecx
movl %ecx, 0x14(%rbx)
shrq $0x23, %rax
movl %eax, 0x24(%rbx)
movzbl 0x7(%r14), %eax
movzbl 0x8(%r14), %ecx
movsbq (%rax,%r15), %rax
movswq 0x100(%r15,%rcx,2), %r12
orq %rax, %r12
movzbl 0x9(%r14), %eax
movzbl 0xa(%r14), %ecx
movsbq (%rax,%r15), %rax
movswq 0x100(%r15,%rcx,2), %r15
orq %rax, %r15
shlq $0xc, %r15
addq $0xb, %r14
movq %r14, %rdi
callq 0x8976
shlq $0x18, %rax
orq %r12, %rax
orq %r15, %rax
js 0x15de
andl $0x7f, %r12d
movl %r12d, 0x8(%rbx)
movl %eax, %ecx
shrl $0x7, %ecx
andl $0x7f, %ecx
movl %ecx, 0x18(%rbx)
movl %eax, %ecx
shrl $0xe, %ecx
andl $0x7f, %ecx
movl %ecx, 0x28(%rbx)
movl %eax, %ecx
shrl $0x15, %ecx
andl $0x7f, %ecx
movl %ecx, 0xc(%rbx)
movq %rax, %rcx
shrq $0x1c, %rcx
andl $0x7f, %ecx
movl %ecx, 0x1c(%rbx)
shrq $0x23, %rax
movl %eax, 0x2c(%rbx)
movb $0x1, %al
jmp 0x15e0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x1a9f
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, (%rbx)
shrl $0x9, %eax
movl %eax, 0x4(%rbx)
leaq 0x3(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x1a9f
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, 0x8(%rbx)
shrl $0x9, %eax
movl %eax, 0xc(%rbx)
leaq 0x6(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x1a9f
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, 0x10(%rbx)
shrl $0x9, %eax
movl %eax, 0x14(%rbx)
leaq 0x9(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x1a9f
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, 0x18(%rbx)
shrl $0x9, %eax
movl %eax, 0x1c(%rbx)
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
testl %eax, %eax
js 0x1a9f
movl %eax, %ecx
andl $0x1ff, %ecx            # imm = 0x1FF
movl %ecx, 0x20(%rbx)
shrl $0x9, %eax
movl %eax, 0x24(%rbx)
movb $0x1, %al
jmp 0x1aa1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/svpv[P]rpmset/./base64unpack-scalar.h
// Function: unpack10x8c14e4
static inline bool unpack10x8c14e4(const char *s, uint32_t *v, unsigned *e)
{
#if 0
    int32_t x, y;
    x = base64dec3(s + 0);
    if (x < 0) return false;
    v[0]  = (x & Mask(4));
    v[0] |= (x >> 12) << 4;
    *e    = (x & Mask(4)<<8) >> 8;
    y = base64dec2(s + 3) | base64dec3(s + 5) << 12;
    if (y < 0) return false;
    v[1]  = (y & Mask(10));
    v[2]  = (y & Mask(20)) >> 10;
    v[3]  = (y >> 20);
    y = base64dec2(s + 8) | base64dec3(s + 10) << 12;
    if (y < 0) return false;
    v[4]  = (y & Mask(10));
    v[5]  = (y & Mask(20)) >> 10;
    v[6]  = (y >> 20);
    y = base64dec1(s + 13);
    if (y < 0) return false;
    v[7]  =  y;
    v[7] |= (x & Mask(4)<<4) << 2;
#else
    int32_t x;
    x = base64dec2(s + 0) | base64dec2(s + 2) << 12;
    if (x < 0) return false;
    *e    = (x & Mask(4));
    v[0]  = (x & Mask(14)) >> 4;
    v[1]  = (x >> 14);
    x = base64dec2(s + 4) | base64dec3(s + 6) << 12;
    if (x < 0) return false;
    v[2]  = (x & Mask(10));
    v[3]  = (x & Mask(20)) >> 10;
    v[4]  = (x >> 20);
    x = base64dec2(s + 9) | base64dec3(s + 11) << 12;
    if (x < 0) return false;
    v[5]  = (x & Mask(10));
    v[6]  = (x & Mask(20)) >> 10;
    v[7]  = (x >> 20);
#endif
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x7241(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %esi
movswl 0x100(%r15,%rcx,2), %eax
orl %esi, %eax
movzbl 0x2(%rdi), %ecx
movzbl 0x3(%rdi), %esi
movsbl (%rcx,%r15), %edi
movswl 0x100(%r15,%rsi,2), %ecx
orl %edi, %ecx
shll $0xc, %ecx
orl %eax, %ecx
js 0x1eeb
andl $0xf, %eax
movl %eax, (%rdx)
movl %ecx, %eax
shrl $0x4, %eax
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, (%rbx)
shrl $0xe, %ecx
movl %ecx, 0x4(%rbx)
movzbl 0x4(%r14), %eax
movzbl 0x5(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r12d
orl %eax, %r12d
leaq 0x6(%r14), %rdi
callq 0x89a5
shll $0xc, %eax
orl %r12d, %eax
js 0x1eeb
movl $0x3ff, %ebp            # imm = 0x3FF
andl %ebp, %r12d
movl %r12d, 0x8(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0xc(%rbx)
shrl $0x14, %eax
movl %eax, 0x10(%rbx)
movzbl 0x9(%r14), %eax
movzbl 0xa(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r15d
orl %eax, %r15d
addq $0xb, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r15d, %eax
js 0x1eeb
andl %ebp, %r15d
movl %r15d, 0x14(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0x18(%rbx)
shrl $0x14, %eax
movl %eax, 0x1c(%rbx)
movb $0x1, %al
jmp 0x1eed
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x7121(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r12d
orl %eax, %r12d
addq $0x2, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r12d, %eax
js 0x1ffe
movl $0x3ff, %ebp            # imm = 0x3FF
andl %ebp, %r12d
movl %r12d, (%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x14, %eax
movl %eax, 0x8(%rbx)
movzbl 0x5(%r14), %eax
movzbl 0x6(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %r12d
orl %eax, %r12d
leaq 0x7(%r14), %rdi
callq 0x89a5
shll $0xc, %eax
orl %r12d, %eax
js 0x1ffe
andl %ebp, %r12d
movl %r12d, 0xc(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0x10(%rbx)
shrl $0x14, %eax
movl %eax, 0x14(%rbx)
movzbl 0xa(%r14), %eax
movzbl 0xb(%r14), %ecx
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x1ffe
movl $0x3ff, %ecx            # imm = 0x3FF
andl %ecx, %ebp
movl %ebp, 0x18(%rbx)
movl %eax, %edx
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x1c(%rbx)
shrl $0x14, %eax
movl %eax, 0x20(%rbx)
movb $0x1, %al
jmp 0x2000
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
leaq 0x7008(%rip), %r12      # 0x9050
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r13d
orl %eax, %r13d
addq $0x2, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r13d, %eax
js 0x2134
movl $0x3ff, %ebp            # imm = 0x3FF
andl %ebp, %r13d
movl %r13d, (%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x14, %eax
movl %eax, 0x8(%rbx)
movzbl 0x5(%r15), %eax
movzbl 0x6(%r15), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r13d
orl %eax, %r13d
leaq 0x7(%r15), %rdi
callq 0x89a5
shll $0xc, %eax
orl %r13d, %eax
js 0x2134
andl %ebp, %r13d
movl %r13d, 0xc(%rbx)
movl %eax, %ecx
shrl $0xa, %ecx
andl %ebp, %ecx
movl %ecx, 0x10(%rbx)
shrl $0x14, %eax
movl %eax, 0x14(%rbx)
movzbl 0xa(%r15), %eax
movzbl 0xb(%r15), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %ebp
orl %eax, %ebp
leaq 0xc(%r15), %rdi
callq 0x89a5
shll $0xc, %eax
orl %ebp, %eax
js 0x2134
movl $0x3ff, %ecx            # imm = 0x3FF
andl %ecx, %ebp
movl %ebp, 0x18(%rbx)
movl %eax, %edx
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x1c(%rbx)
shrl $0x14, %eax
movl %eax, 0x20(%rbx)
addq $0xf, %r15
movq %r15, %rdi
callq 0x89a5
testl %eax, %eax
js 0x2134
movl %eax, %ecx
shrl $0xa, %ecx
movl %ecx, (%r14)
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, 0x24(%rbx)
movb $0x1, %al
jmp 0x2136
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89a5
testl %eax, %eax
js 0x2838
movl %eax, %ebp
andl $0x3ff, %eax            # imm = 0x3FF
movl %eax, (%rbx)
movl %ebp, %eax
shrl $0x10, %eax
movl %eax, (%r15)
movzbl 0x3(%r14), %eax
movzbl 0x4(%r14), %ecx
leaq 0x6901(%rip), %r12      # 0x9050
movsbl (%rax,%r12), %eax
orw 0x100(%r12,%rcx,2), %ax
js 0x2838
movzwl %ax, %eax
movl %eax, %ecx
andl $0x1, %ecx
shll $0xa, %ecx
orl %ecx, (%rbx)
shrl %eax
movl %eax, 0x4(%rbx)
movzbl 0x5(%r14), %eax
movzbl 0x6(%r14), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r13d
orl %eax, %r13d
leaq 0x7(%r14), %rdi
callq 0x89a5
movl %eax, %r15d
shll $0xc, %r15d
orl %r13d, %r15d
js 0x2838
movl $0x7ff, %eax            # imm = 0x7FF
andl %eax, %r13d
movl %r13d, 0x8(%rbx)
movl $0x7ff, %r13d           # imm = 0x7FF
movl %r15d, %eax
shrl $0xb, %eax
andl %r13d, %eax
movl %eax, 0xc(%rbx)
shrl $0x16, %r15d
movl %r15d, 0x10(%rbx)
movzbl 0xa(%r14), %eax
movzbl 0xb(%r14), %ecx
movsbl (%rax,%r12), %eax
movswl 0x100(%r12,%rcx,2), %r12d
orl %eax, %r12d
addq $0xc, %r14
movq %r14, %rdi
callq 0x89a5
shll $0xc, %eax
orl %r12d, %eax
js 0x2838
andl $0x7, %r12d
shll $0x8, %r12d
orl %r15d, %r12d
movl %r12d, 0x10(%rbx)
movl %eax, %ecx
shrl $0x3, %ecx
andl %r13d, %ecx
movl %ecx, 0x14(%rbx)
movl %eax, %ecx
shrl $0xe, %ecx
andl %r13d, %ecx
movl %ecx, 0x18(%rbx)
shrl $0x19, %eax
shrl $0x5, %ebp
andl $0x7e0, %ebp            # imm = 0x7E0
orl %eax, %ebp
movl %ebp, 0x1c(%rbx)
movb $0x1, %al
jmp 0x283a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x89cd
testl %eax, %eax
js 0x291e
movzbl %al, %ecx
movl %ecx, (%r15)
movl %eax, %ecx
shrl $0x8, %ecx
andl $0x7ff, %ecx            # imm = 0x7FF
movl %ecx, (%rbx)
shrl $0x13, %eax
movl %eax, 0x4(%rbx)
leaq 0x5(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x291e
movl %eax, %ebp
movl $0x7ff, %r15d           # imm = 0x7FF
andl %r15d, %eax
movl %eax, 0x8(%rbx)
movl %ebp, %eax
shrl $0xb, %eax
andl %r15d, %eax
movl %eax, 0xc(%rbx)
shrl $0x16, %ebp
movl %ebp, 0x10(%rbx)
leaq 0xa(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x291e
movl %eax, %ecx
andl $0x7, %ecx
shll $0x8, %ecx
orl %ebp, %ecx
movl %ecx, 0x10(%rbx)
movl %eax, %ecx
shrl $0x3, %ecx
andl %r15d, %ecx
movl %ecx, 0x14(%rbx)
movl %eax, %ecx
shrl $0xe, %ecx
andl %r15d, %ecx
movl %ecx, 0x18(%rbx)
shrl $0x19, %eax
movl %eax, 0x1c(%rbx)
movzbl 0xf(%r14), %ecx
leaq 0x6746(%rip), %rdx      # 0x9050
movsbl (%rcx,%rdx), %ecx
testl %ecx, %ecx
js 0x291e
shll $0x5, %ecx
orl %eax, %ecx
movl %ecx, 0x1c(%rbx)
movb $0x1, %al
jmp 0x2920
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
movzbl 0x1(%rdi), %ecx
movzbl 0x2(%rdi), %esi
movzbl 0x3(%rdi), %edi
leaq 0x66e4(%rip), %r15      # 0x9050
movsbl (%rax,%r15), %eax
movswl 0x100(%r15,%rcx,2), %ebp
orl %eax, %ebp
orl 0x300(%r15,%rsi,4), %ebp
orl 0x700(%r15,%rdi,4), %ebp
js 0x2a4d
movl %ebp, %eax
andl $0x1ff, %eax            # imm = 0x1FF
movl %eax, (%rdx)
movl %ebp, %eax
shrl $0x9, %eax
andl $0x7ff, %eax            # imm = 0x7FF
movl %eax, (%rbx)
shrl $0x14, %ebp
movl %ebp, 0x4(%rbx)
leaq 0x4(%r14), %rdi
callq 0x89a5
testl %eax, %eax
js 0x2a4d
movl %eax, %ecx
andl $0x7f, %ecx
shll $0x4, %ecx
orl %ebp, %ecx
movl %ecx, 0x4(%rbx)
shrl $0x7, %eax
movl %eax, 0x8(%rbx)
leaq 0x7(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x2a4d
movl %eax, %ebp
movl $0x7ff, %r12d           # imm = 0x7FF
andl %r12d, %eax
movl %eax, 0xc(%rbx)
movl %ebp, %eax
shrl $0xb, %eax
andl %r12d, %eax
movl %eax, 0x10(%rbx)
shrl $0x16, %ebp
movl %ebp, 0x14(%rbx)
leaq 0xc(%r14), %rdi
callq 0x89cd
testl %eax, %eax
js 0x2a4d
movl %eax, %ecx
andl $0x7, %ecx
shll $0x8, %ecx
orl %ebp, %ecx
movl %ecx, 0x14(%rbx)
movl %eax, %ecx
shrl $0x3, %ecx
andl %r12d, %ecx
movl %ecx, 0x18(%rbx)
movl %eax, %ecx
shrl $0xe, %ecx
andl %r12d, %ecx
movl %ecx, 0x1c(%rbx)
shrl $0x19, %eax
movl %eax, 0x20(%rbx)
movzbl 0x11(%r14), %ecx
movsbl (%rcx,%r15), %ecx
testl %ecx, %ecx
js 0x2a4d
shll $0x5, %ecx
orl %eax, %ecx
movl %ecx, 0x20(%rbx)
movb $0x1, %al
jmp 0x2a4f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq