LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: type_compare
int type_compare(s_type *a, s_type *b) {
	if (a == NULL && b == NULL) return 1;
	if (a == NULL || b == NULL) return 0;
	if (!type_compare_noref(a, b)) return 0;

	//Compare reference types
	s_type *i = a->ref;
	s_type *j = b->ref;
	while (i != NULL) {
		if (j == NULL) return 0;
		if (!type_compare_noref(i, j)) return 0;
		i = i->ref;
		j = j->ref;
	}
	if (j != NULL) return 0;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rax
orq %rsi, %rax
jne 0xb772
pushq $0x1
popq %rbx
jmp 0xb78a
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
je 0xb792
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0xba68
testl %eax, %eax
je 0xb78a
movq 0x18(%r14), %r14
movq 0x18(%r15), %r15
testq %r15, %r15
je 0xb7b5
testq %r14, %r14
jne 0xb792
jmp 0xb78a
xorl %ebx, %ebx
testq %r14, %r14
sete %bl
jmp 0xb78a
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: symtable_def_label
void symtable_def_label(symtable *stb, char *name, s_pos *loc) {
	if (stb->func == NULL) {
		c_error(loc, "Label '%s' declared outside of function\n", name);
		return;
	}
	
	//Check for duplicates
	symbol *dup = map_get(&stb->func->labels, name);
	if (dup != NULL) {
		c_error(loc, "Label '%s' is already declared\n", name);
		return;
	}

	map_insert(&stb->func->labels, name, name);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb7f0
addq $0x30, %rdi
movq %rbx, %rsi
callq 0xbd22
testq %rax, %rax
je 0xb809
leaq 0x2863(%rip), %rsi      # 0xe051
jmp 0xb7f7
leaq 0x2831(%rip), %rsi      # 0xe028
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x35e4
movq 0x10(%r15), %rdi
addq $0x30, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xbd89
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: symtable_search
symbol *symtable_search(symtable *stb, char *name) {
	scope *sc_ptr = stb->s_cur;
	while (sc_ptr != NULL) {
		symbol *s = map_get(&sc_ptr->table, name);
		if (s != NULL) return s;
		sc_ptr = sc_ptr->prev;
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0xb84e
movq %r15, %rdi
movq %r14, %rsi
callq 0xbd22
addq $0x18, %r15
testq %rax, %rax
je 0xb82f
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: sym_new
symbol *sym_new(char *name, s_type *type) {
	symbol *s = calloc(1, sizeof(struct SYMBOL));
	s->name = name;
	s->type = type;
	if (type->kind == TYPE_FUNC) {
		vector_init(&s->lvars, VECTOR_EMPTY);
		map_init(&s->labels, MAP_DEFAULT);
	}
	s->mac_exp = NULL;
	s->is_predef = 0;

	//Get base type from chain
	s_type *bt_ptr = type;
	while (bt_ptr->ref != NULL) 
		bt_ptr = bt_ptr->ref;
	s->btype = bt_ptr;

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
callq 0x3100
movq %rax, %r14
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
cmpl $0x4, (%rbx)
jne 0xb897
leaq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0xbe8a
movq %r14, %rdi
addq $0x30, %rdi
pushq $0x11
popq %rsi
callq 0xbb9a
andq $0x0, 0x48(%r14)
andl $0x0, 0x54(%r14)
movq %rbx, %rax
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xb8a1
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: type_del
void type_del(s_type *t) {
	//Reference data
	if (t->ref != NULL)
		type_del(t->ref);

	//Function/struct data
	for (int i=0; i<t->param.len; i++) {
		if (t->kind == TYPE_FUNC) {
			param_del(t->param.table[i]);
		} else {
			memb_del(t->param.table[i]);
		}
	}
	vector_close(&t->param);
	if (t->ret != NULL)
		type_del(t->ret);

	free(t);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xb8d0
callq 0xb8ba
leaq 0x28(%rbx), %r14
xorl %r15d, %r15d
movslq 0x30(%rbx), %rax
cmpq %rax, %r15
jge 0xb8fe
cmpl $0x4, (%rbx)
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
jne 0xb8f4
callq 0x3030
jmp 0xb8f9
callq 0xb926
incq %r15
jmp 0xb8d7
movq %r14, %rdi
callq 0xbecc
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0xb914
callq 0xb8ba
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: memb_del
void memb_del(s_param *m) {
	if (m->type != NULL)
		type_del(m->type);
	if (m->name != NULL)
		free(m->name);
	free(m);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xb938
callq 0xb8ba
movq (%rbx), %rdi
callq 0x3030
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: type_clone
s_type *type_clone(s_type *from) {
	if (from == NULL) return NULL;
	s_type *type = malloc(sizeof(struct TYPE));
	*type = *from;
	type->ref = type_clone(from->ref);
	type->ret = type_clone(from->ret);

	//Copy parameters
	vector_init(&type->param, VECTOR_EMPTY);
	for (int i=0; i<from->param.len; i++) {
		s_param *p = from->param.table[i];
		char *pname = malloc(strlen(p->name)+1);
		strncpy(pname, p->name, strlen(p->name)+1);
		s_param *pclone = param_new(type_clone(p->type), pname);
		vector_add(&type->param, pclone);
	}
	return type;
}

// Assembly:
testq %rdi, %rdi
je 0xba34
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0x3170
movq %rax, %r14
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movups %xmm2, 0x20(%rax)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movq 0x18(%rbx), %rdi
callq 0xb949
movq %rax, 0x18(%r14)
movq 0x38(%rbx), %rdi
callq 0xb949
movq %rax, 0x38(%r14)
movq %r14, 0x8(%rsp)
movq %r14, %rdi
addq $0x28, %rdi
xorl %r14d, %r14d
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0xbe8a
movslq 0x30(%rbx), %rax
cmpq %rax, %r14
jge 0xba20
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %r15
movq (%r15), %r12
movq %r12, %rdi
callq 0x30b0
leaq 0x1(%rax), %r13
movq %r13, %rdi
callq 0x3170
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3060
movq 0x8(%r15), %rdi
callq 0xb949
movq %rax, %rdi
movq %rbp, %rsi
callq 0xba37
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xbf10
incq %r14
jmp 0xb9c1
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: param_new
s_param *param_new(s_type *type, char *name) {
	s_param *param = malloc(sizeof(struct PARAM));
	param->type = type;
	param->name = name;

	//Get base type
	//TODO: just replace s_param with symbol
	s_type *bt_ptr = type;
	while (bt_ptr->ref != NULL) 
		bt_ptr = bt_ptr->ref;
	param->btype = bt_ptr;

	return param;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x3170
movq %rbx, 0x8(%rax)
movq %r14, (%rax)
movq %rbx, %rcx
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xba50
movq %rcx, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: type_compare_noref
int type_compare_noref(s_type *a, s_type *b) {
	if (a->kind != b->kind) return 0;
	if (a->s_class != b->s_class) return 0;

	//TODO: qualifiers
	if (a->ref_len != b->ref_len) return 0;

	//Compare parameters/members
	if (a->param.len != b->param.len) return 0;
	for (int i=0; i<a->param.len; i++) {
		s_param *ap = a->param.table[i];
		s_param *bp = b->param.table[i];
		if (!type_compare(ap->type, bp->type)) return 0;
	}
	if (!type_compare(a->ret, b->ret)) return 0;

	return 1;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpl (%rsi), %eax
jne 0xbaca
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0xbaca
movl 0x20(%r14), %eax
cmpl 0x20(%rbx), %eax
jne 0xbaca
movl 0x30(%r14), %r15d
cmpl 0x30(%rbx), %r15d
jne 0xbaca
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xbad8
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x28(%rbx), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rax), %rdi
movq 0x8(%rcx), %rsi
callq 0xb760
incq %r12
testl %eax, %eax
jne 0xbaa1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x38(%r14), %rdi
movq 0x38(%rbx), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb760
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/sym.c
// Function: type_sizeof
int type_sizeof(s_type *t) {
	//Base types
	switch (t->kind) {
		case TYPE_UNDEF:
		case TYPE_MACRO:
		case TYPE_LABEL:
			return -1;
		case TYPE_PTR:	
		case TYPE_FUNC:	
			return 8;
		case TYPE_VOID:
			return -1;
		case TYPE_INT:
		case TYPE_FLOAT:
			return t->size;
	}

	//User-defined types
	int ssum = 0;
	int smax = 0;
	for (int i=0; i<t->param.len; i++) {
		int msize = type_sizeof(t->param.table[i]);
		ssum += msize;
		if (msize > smax) smax = msize;
	}
	if (t->kind == TYPE_UNION)
		return smax;
	return ssum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %r14d
cmpl $0x7, %r14d
ja 0xbb27
pushq $0x27
popq %rax
btl %r14d, %eax
jae 0xbb14
pushq $-0x1
jmp 0xbb1f
pushq $0x18
popq %rax
btl %r14d, %eax
jae 0xbb22
pushq $0x8
popq %rbp
jmp 0xbb62
movl 0x4(%rbx), %ebp
jmp 0xbb62
movl 0x30(%rbx), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %ebp, %ebp
xorl %r13d, %r13d
cmpq %r12, %r15
je 0xbb5a
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0xbaf0
addl %eax, %ebp
cmpl %r13d, %eax
cmovgl %eax, %r13d
incq %r12
jmp 0xbb3a
cmpl $0x9, %r14d
cmovel %r13d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_init
void map_init(map *m, int size) {
	m->table = calloc(size, sizeof(void*));
	m->keys = calloc(size, sizeof(char*));
	m->count = 0;
	m->max = size;
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %esi, %r14
pushq $0x8
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3100
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3100
movq %rax, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_close
void map_close(map *m) {
	if (m->table != NULL)
		free(m->table);
	if (m->table != NULL)
		free(m->keys);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3030
cmpq $0x0, (%rbx)
je 0xbc02
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x3030
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: str_hash
unsigned int str_hash(const char *key) {
	//Jenkins one-at-a-time hash function
	unsigned int hash = 0;
	for (int i=0; i<strlen(key); i++) {
		hash += key[i++];
		hash += hash << 10;
		hash ^= hash >> 6;
	}
	hash += hash << 3;
	hash ^= hash >> 11;
	hash += hash << 15;

	return hash;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30b0
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rcx, %rax
jbe 0xbc2f
movsbl (%rbx,%rcx), %esi
addl %esi, %edx
imull $0x401, %edx, %esi      # imm = 0x401
movl %esi, %edx
shrl $0x6, %edx
xorl %esi, %edx
addq $0x2, %rcx
jmp 0xbc11
leal (%rdx,%rdx,8), %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
imull $0x8001, %ecx, %eax     # imm = 0x8001
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_expand
void map_expand(map *m) {
	//Allocate space for new table
	int n_max = m->max * 2;
	void **n_table = calloc(n_max, sizeof(void*));
	const char **n_keys = calloc(n_max, sizeof(char*));

	//Relocate all keys into new table
	for (int i=0; i<m->max; i++) {
		if (m->table[i] != NULL) {
			int n_index = str_hash(m->keys[i]) % n_max;
			while (n_keys[n_index] != NULL)
				n_index = (n_index + 1) % n_max;
			n_table[n_index] = m->table[i];
			n_keys[n_index] = m->keys[i];
		}
	}

	//Free old tables and switch to new ones
	free(m->table);
	free(m->keys);
	m->table = n_table;
	m->keys = n_keys;
	m->max = n_max;

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbp
movslq 0x14(%rdi), %r13
movq %r13, %r14
addq %r13, %r14
pushq $0x8
popq %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3100
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x3100
movq %rax, %r12
xorl %r15d, %r15d
testl %r13d, %r13d
movl $0x0, %ebx
cmovgl %r13d, %ebx
movq %rbp, 0x8(%rsp)
movq (%rbp), %rax
movq %rax, 0x10(%rsp)
cmpq %rbx, %r15
je 0xbcec
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %r13
testq %r13, %r13
je 0xbce7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax,%r15,8), %rbp
movq %rbp, %rdi
callq 0xbc04
xorl %edx, %edx
divl %r14d
movslq %edx, %rax
cmpq $0x0, (%r12,%rax,8)
je 0xbcdb
incl %edx
movl %edx, %eax
cltd
idivl %r14d
jmp 0xbcc7
movq (%rsp), %rcx
movq %r13, (%rcx,%rax,8)
movq %rbp, (%r12,%rax,8)
incq %r15
jmp 0xbc9a
movq 0x10(%rsp), %rdi
callq 0x3030
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x3030
movq (%rsp), %rax
movq %rax, (%rbx)
movq %r12, 0x8(%rbx)
movl %r14d, 0x14(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_get
void *map_get(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (!strcmp(m->keys[index], key)) {
			return m->table[index];
		}
		index = (index + 1) % m->max;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xbc04
movl 0x14(%r14), %r12d
xorl %edx, %edx
divl %r12d
movl %edx, %ebp
movq 0x8(%r14), %r13
movslq %ebp, %rbx
movq (%r13,%rbx,8), %rdi
testq %rdi, %rdi
je 0xbd6f
movq %r15, %rsi
callq 0x3110
testl %eax, %eax
je 0xbd73
incl %ebp
movl %ebp, %eax
cltd
idivl %r12d
movl %edx, %ebp
jmp 0xbd4a
xorl %eax, %eax
jmp 0xbd7a
movq (%r14), %rax
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_insert
void map_insert(map *m, const char *key, void *val) {
	//Expand the table capacity if load factor > 0.75
	if (m->count / (float)m->max > 0.75)
		map_expand(m);

	//Hash the key and perform linear probing if necessary
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		if (m->table[index] == NULL) break;
		index = (index + 1) % m->max;
	}

	//Insert the value and key
	m->table[index] = val;
	m->keys[index] = key;
	m->count++;

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm0
cvtdq2ps %xmm0, %xmm0
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
divss %xmm1, %xmm0
ucomiss 0x22c3(%rip), %xmm0     # 0xe074
jbe 0xbdbb
movq %rbx, %rdi
callq 0xbc41
movq %r14, %rdi
callq 0xbc04
movl 0x14(%rbx), %ecx
xorl %edx, %edx
divl %ecx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
movslq %edx, %rax
cmpq $0x0, (%rdi,%rax,8)
je 0xbdeb
cmpq $0x0, (%rsi,%rax,8)
je 0xbdeb
incl %edx
movl %edx, %eax
cltd
idivl %ecx
jmp 0xbdd1
movq %r15, (%rsi,%rax,8)
movq 0x8(%rbx), %rcx
movq %r14, (%rcx,%rax,8)
incl 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/map.c
// Function: map_remove
void map_remove(map *m, const char *key) {
	int index = str_hash(key) % m->max;
	while (m->keys[index] != NULL) {
		/* The data pointer is set to NULL, but the key isn't.
		 * As a result, get operations will return NULL, and insertion
		 * does an additional check to see if the space has been
		 * previously removed. If not reused, these spaces disappear
		 * upon resizing.
		 */
		if (!strcmp(m->keys[index], key)) {
			m->table[index] = NULL;
			break;
		}
		index = (index + 1) % m->max;
	}

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xbc04
movl 0x14(%rbx), %r15d
xorl %edx, %edx
divl %r15d
movl %edx, %ebp
movq 0x8(%rbx), %r12
movslq %ebp, %r13
movq (%r12,%r13,8), %rdi
testq %rdi, %rdi
je 0xbe54
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xbe4c
incl %ebp
movl %ebp, %eax
cltd
idivl %r15d
movl %edx, %ebp
jmp 0xbe28
movq (%rbx), %rax
andq $0x0, (%rax,%r13,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/vector.c
// Function: vector_init
void vector_init(vector *v, int size) {
	if (size > 0) {
		v->table = malloc(sizeof(void*)*size);
	} else {
		v->table = NULL;
	}
	v->len = 0;
	v->max = size;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %esi, %esi
jle 0xbea4
movl %ebx, %edi
shlq $0x3, %rdi
callq 0x3170
jmp 0xbea6
xorl %eax, %eax
movq %rax, (%r14)
andl $0x0, 0x8(%r14)
movl %ebx, 0xc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/vector.c
// Function: vector_add
void vector_add(vector *v, void *val) {
	//Allocate initial space if vector was initialized as empty
	if (v->max == VECTOR_EMPTY)
		vector_init(v, VECTOR_DEFAULT);

	//Expand the table if there is no room left
	if (v->len+1 >= v->max)
		vector_expand(v);

	//Add value to end of table
	int index = v->len;
	v->table[index] = val;
	v->len++;

	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %edx
testl %edx, %edx
jne 0xbf2f
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0xbe8a
movl 0xc(%rbx), %edx
movl 0x8(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl %edx, %ecx
jl 0xbf47
movq %rbx, %rdi
callq 0xbed4
movl 0x8(%rbx), %eax
leal 0x1(%rax), %ecx
movq (%rbx), %rdx
cltq
movq %r14, (%rdx,%rax,8)
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/vector.c
// Function: vector_remove
void vector_remove(vector *v, int index) {
	//Shift all entries if neccesary
	for (int i=index; i<v->len-1; i++)
		v->table[i] = v->table[i+1];
	v->table[v->len-1] = NULL;
	v->len--;

	return;
}

// Assembly:
movslq 0x8(%rdi), %rax
leaq -0x1(%rax), %rcx
movslq %esi, %rdx
movq (%rdi), %rsi
cmpq %rcx, %rdx
jge 0xbf7c
movq 0x8(%rsi,%rdx,8), %r8
movq %r8, (%rsi,%rdx,8)
incq %rdx
jmp 0xbf66
andq $0x0, -0x8(%rsi,%rax,8)
movl %ecx, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/util/vector.c
// Function: vector_pop
void *vector_pop(vector *v) {
	if (v->len == 0) return NULL;
	void *val = v->table[v->len-1];
	vector_remove(v, v->len-1);
	return val;
}

// Assembly:
pushq %rbx
movslq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0xbfa7
movq (%rdi), %rax
movq -0x8(%rax,%rsi,8), %rbx
decq %rsi
callq 0xbf5b
jmp 0xbfa9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: save
void save() {
  FILE *fp;
  if ((fp = fopen("ngaImage", "wb")) == NULL) {
    printf("Unable to save the image!\n");
    exit(2);
  }
  fwrite(&target, sizeof(CELL), here, fp);
  fclose(fp);
}

// Assembly:
pushq %rbx
leaq 0xcd1(%rip), %rdi       # 0x2006
leaq 0xcd3(%rip), %rsi       # 0x200f
callq 0x1090
testq %rax, %rax
je 0x136b
movq %rax, %rbx
movslq 0x82e00(%rip), %rdx     # 0x84150
leaq 0x2df9(%rip), %rdi      # 0x4150
pushq $0x4
popq %rsi
movq %rax, %rcx
callq 0x10c0
movq %rbx, %rdi
popq %rbx
jmp 0x1040
leaq 0xd4d(%rip), %rdi       # 0x20bf
callq 0x1030
pushq $0x2
popq %rdi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: lookup
CELL lookup(char *name) {
  CELL slice = -1;
  CELL n = np;
  while (n > 0) {
    n--;
    if (strcmp(Labels[n], name) == 0) {
      slice = Pointers[n];
    }
  }
  return slice;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x82dc0(%rip), %r15d    # 0x84154
pushq $-0x1
popq %rbp
leaq 0x82dc2(%rip), %r12     # 0x84160
movq %r15, %rax
shlq $0x6, %rax
leaq (%rax,%r12), %r14
addq $-0x40, %r14
xorl %r13d, %r13d
leal (%r15,%r13), %eax
testl %eax, %eax
jle 0x13e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
decq %r13
addq $-0x40, %r14
testl %eax, %eax
jne 0x13b0
leaq 0xc2d8b(%rip), %rax     # 0xc4160
leaq (%rax,%r15,4), %rax
movl (%rax,%r13,4), %ebp
addq %r13, %r15
jmp 0x139e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: add_label
void add_label(char *name, CELL slice) {
  if (lookup(name) == -1) {
    bsd_strlcpy(Labels[np], name, STRING_LEN);
    Pointers[np] = slice;
    np++;
  } else {
    printf("Fatal error: %s already defined\n", name);
    exit(0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x137f
cmpl $-0x1, %eax
jne 0x1447
movslq 0x82d47(%rip), %rax     # 0x84154
shlq $0x6, %rax
leaq 0x82d48(%rip), %rdi     # 0x84160
addq %rax, %rdi
pushq $0x40
popq %rdx
movq %r14, %rsi
callq 0x145f
movslq 0x82d27(%rip), %rax     # 0x84154
leaq 0xc2d2c(%rip), %rcx     # 0xc4160
movl %ebx, (%rcx,%rax,4)
incl %eax
movl %eax, 0x82d15(%rip)     # 0x84154
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xbc4(%rip), %rdi       # 0x2012
movq %r14, %rsi
xorl %eax, %eax
callq 0x1060
xorl %edi, %edi
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: opcode_for
CELL opcode_for(char *s) {
  char* opcodeList = "..lidudrswpupojucaccreeqneltgtfestadsumudianorxoshzrhaieiqii";
  int16_t* s16 = (int16_t *)s;
  int16_t* op16 = (int16_t *)opcodeList;
  int i = 0;
  for (i = 0; i <= 30; i++) {
    if (s16[0] == op16[i]) {
      return i;
    }
  }
  return 0;
}

// Assembly:
movzwl (%rdi), %ecx
leaq 0xb83(%rip), %rdx       # 0x2033
xorl %eax, %eax
xorl %esi, %esi
cmpq $0x1f, %rsi
je 0x14ca
cmpw (%rdx), %cx
je 0x14c8
incq %rsi
addq $0x2, %rdx
jmp 0x14b4
movl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: pass2
void pass2(char *buffer) {
  unsigned int opcode;
  char inst[3];
  inst[2] = '\0';
  switch (buffer[0]) {
    case 'i': memcpy(inst, buffer + 8, 2);
              opcode = opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 6, 2);
              opcode += opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 4, 2);
              opcode += opcode_for(inst);
              opcode = opcode << 8;
              memcpy(inst, buffer + 2, 2);
              opcode += opcode_for(inst);
              target[here++] = opcode;
              break;
    case 'r': here++;                             break;
    case 'd': here++;                             break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb $0x0, 0x6(%rsp)
movzbl (%rdi), %eax
cmpl $0x64, %eax
je 0x15c5
movq %rdi, %rbx
cmpl $0x73, %eax
je 0x15cd
cmpl $0x72, %eax
je 0x15c5
cmpl $0x69, %eax
jne 0x15e7
movzwl 0x8(%rbx), %eax
leaq 0x4(%rsp), %r14
movw %ax, (%r14)
movq %r14, %rdi
callq 0x14a6
movl %eax, %ebp
movzwl 0x6(%rbx), %eax
movw %ax, (%r14)
movq %r14, %rdi
callq 0x14a6
movl %eax, %r15d
shll $0x10, %ebp
shll $0x8, %r15d
addl %ebp, %r15d
movzwl 0x4(%rbx), %eax
movw %ax, (%r14)
movq %r14, %rdi
callq 0x14a6
movl %eax, %ebp
addl %r15d, %ebp
shll $0x8, %ebp
movzwl 0x2(%rbx), %eax
movw %ax, (%r14)
movq %r14, %rdi
callq 0x14a6
addl %ebp, %eax
movslq 0x82ba0(%rip), %rcx     # 0x84150
leal 0x1(%rcx), %edx
movl %edx, 0x82b97(%rip)     # 0x84150
leaq 0x2b90(%rip), %rdx      # 0x4150
movl %eax, (%rdx,%rcx,4)
jmp 0x15e7
incl 0x82b85(%rip)           # 0x84150
jmp 0x15e7
movl 0x82b7c(%rip), %r14d    # 0x84150
movq %rbx, %rdi
callq 0x1050
addl %r14d, %eax
decl %eax
movl %eax, 0x82b69(%rip)     # 0x84150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: pass3
void pass3(char *buffer) {
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': here++;                             break;
    case 'd': target[here++] = atoi(buffer+2);    break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %rbx
movzbl (%rdi), %eax
cmpl $0x64, %eax
je 0x1629
cmpl $0x73, %eax
je 0x1612
cmpl $0x72, %eax
je 0x160a
cmpl $0x69, %eax
jne 0x164c
incl 0x82b40(%rip)           # 0x84150
jmp 0x164c
movl 0x82b38(%rip), %ebx     # 0x84150
callq 0x1050
addl %ebx, %eax
decl %eax
movl %eax, 0x82b29(%rip)     # 0x84150
jmp 0x164c
addq $0x2, %rdi
callq 0x10a0
movslq 0x82b17(%rip), %rcx     # 0x84150
leal 0x1(%rcx), %edx
movl %edx, 0x82b0e(%rip)     # 0x84150
leaq 0x2b07(%rip), %rdx      # 0x4150
movl %eax, (%rdx,%rcx,4)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: pass4
void pass4(char *buffer) {
  unsigned int opcode;
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': here++;                             break;
    case 'd': here++;                             break;
    case 's': opcode = 2;
              while (opcode < strlen(buffer)) {
                target[here++] = buffer[opcode++];
              }
              target[here++] = 0;
                                                  break;
    case ':':                                     break;
  }
}

// Assembly:
movzbl (%rdi), %eax
cmpl $0x64, %eax
je 0x16b7
cmpl $0x69, %eax
je 0x16b7
cmpl $0x72, %eax
je 0x16b7
cmpl $0x73, %eax
jne 0x16de
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x82ad6(%rip), %r14     # 0x84150
movq %r14, %r12
shlq $0x2, %r12
xorl %r13d, %r13d
leaq 0x2ac5(%rip), %r15      # 0x4150
leal 0x2(%r13), %ebp
movq %rbx, %rdi
callq 0x1050
cmpq %rbp, %rax
jbe 0x16be
movsbl (%rbx,%rbp), %eax
incl %r14d
movl %r14d, 0x82aa6(%rip)    # 0x84150
leaq (%r12,%r13,4), %rcx
movl %eax, (%r15,%rcx)
incq %r13
jmp 0x168b
incl 0x82a93(%rip)           # 0x84150
retq
leal 0x1(%r14), %eax
movl %eax, 0x82a88(%rip)     # 0x84150
movslq %r14d, %rax
andl $0x0, (%r15,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: pass5
void pass5(char *buffer) {
  switch (buffer[0]) {
    case 'i': here++;                             break;
    case 'r': target[here++] = lookup(buffer+2);
              if (lookup(buffer+2) == -1)
                printf("Lookup failed: '%s'\n", buffer+2);
                                                  break;
    case 'd': here++;                             break;
    case 's': here = here + strlen(buffer) - 1;   break;
    case ':':                                     break;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
cmpl $0x64, %eax
je 0x16fd
movq %rdi, %rbx
cmpl $0x73, %eax
je 0x1705
cmpl $0x72, %eax
je 0x1721
cmpl $0x69, %eax
jne 0x1754
incl 0x82a4d(%rip)           # 0x84150
jmp 0x1754
movl 0x82a44(%rip), %r14d    # 0x84150
movq %rbx, %rdi
callq 0x1050
addl %r14d, %eax
decl %eax
movl %eax, 0x82a31(%rip)     # 0x84150
jmp 0x1754
addq $0x2, %rbx
movq %rbx, %rdi
callq 0x137f
movslq 0x82a1c(%rip), %rcx     # 0x84150
leal 0x1(%rcx), %edx
movl %edx, 0x82a13(%rip)     # 0x84150
leaq 0x2a0c(%rip), %rdx      # 0x4150
movl %eax, (%rdx,%rcx,4)
movq %rbx, %rdi
callq 0x137f
cmpl $-0x1, %eax
je 0x175c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x90d(%rip), %rdi       # 0x2070
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O2/crcx[P]retroforth/tools/retro-muri.c
// Function: main
int main(int argc, char **argv) {
  bsd_strlcpy(code_start, "~~~", 32);
  bsd_strlcpy(code_end,   "~~~", 32);
  bsd_strlcpy(test_start, "```", 32);
  bsd_strlcpy(test_end,   "```", 32);
  np = 0;
  if (argc > 1) {
    here = 0; unu(argv[1], 0, &pass1);
    here = 0; unu(argv[1], 0, &pass2);
    here = 0; unu(argv[1], 0, &pass3);
    here = 0; unu(argv[1], 0, &pass4);
    here = 0; unu(argv[1], 0, &pass5);
    save();
    printf("Wrote %lld cells to ngaImage\n", (long long)here);
  }
  else {
    printf("No file specified.\n");
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2909(%rip), %rdi      # 0x4090
leaq 0x8f7(%rip), %r14       # 0x2085
pushq $0x20
popq %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x145f
leaq 0x291c(%rip), %rdi      # 0x40c0
movq %r14, %rsi
movq %r15, %rdx
callq 0x145f
leaq 0x293a(%rip), %rdi      # 0x40f0
leaq 0x8cc(%rip), %r14       # 0x2089
movq %r14, %rsi
movq %r15, %rdx
callq 0x145f
leaq 0x2951(%rip), %rdi      # 0x4120
movq %r14, %rsi
movq %r15, %rdx
callq 0x145f
andl $0x0, 0x82973(%rip)     # 0x84154
cmpl $0x2, %ebp
jl 0x1883
andl $0x0, 0x8295f(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x331(%rip), %rdx      # 0x14cb
xorl %esi, %esi
callq 0x128a
andl $0x0, 0x82946(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x300(%rip), %rdx      # 0x1515
xorl %esi, %esi
callq 0x128a
andl $0x0, 0x8292d(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x23c(%rip), %rdx      # 0x15f2
xorl %esi, %esi
callq 0x128a
andl $0x0, 0x82914(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x1f9(%rip), %rdx      # 0x164e
xorl %esi, %esi
callq 0x128a
andl $0x0, 0x828fb(%rip)     # 0x84150
movq 0x8(%rbx), %rdi
leaq -0x181(%rip), %rdx      # 0x16df
xorl %esi, %esi
callq 0x128a
callq 0x132d
movslq 0x828dd(%rip), %rsi     # 0x84150
leaq 0x813(%rip), %rdi       # 0x208d
xorl %eax, %eax
callq 0x1060
jmp 0x188f
leaq 0x84f(%rip), %rdi       # 0x20d9
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radekh[P]palbart/palbart-2.5.c
// Function: defineSymbol
SYM_T *defineSymbol( char *name, WORD16 val, SYMTYP type, WORD16 start )
{
  SYM_T  *sym;
  int     xref_count;

  if( strlen( name ) < 1 )
  {
    return( &sym_undefined );   /* Protect against non-existent names.        */
  }
  sym = lookup( name );
  if( M_FIXED( sym->type ))
  {
      return( sym );            /* Can't modify permanent symbols.            */
  }

  xref_count = 0;               /* Set concordance for normal defintion.      */

  if( M_DEFINED( sym->type ))
  {
    if( pass == 2 && sym->val != val )
    {
      /* Generate diagnostic if redefining a symbol.                          */
      if( M_REDEFINED( sym->type ))
      {
        errorSymbol( &redefined_symbol, sym->name, start );
      }
      type = type | REDEFINED;
      sym->xref_count++;      /* Referenced suymbol, count it.                */
      xref_count = sym->xref_count;
    }
  }

  if( pass == 2 && xref )
  {
    /* Put the definition line number in the concordance table.               */
    /* Defined symbols are not counted as references.                         */
    xreftab[sym->xref_index] = lineno;
    /* Put the line number in the concordance table.                          */
    xreftab[sym->xref_index + xref_count] = lineno;
  }

  /* Now set the value and the type.                                          */
  sym->val = ( type == LABEL) ? val : val & 07777;
  sym->type = ( pass == 1 ) ? ( type | CONDITION ) : type;
  return( sym );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
je 0x2ac1
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
callq 0x397f
movq %rax, %rbx
movl (%rax), %edx
testb $0x2, %dl
jne 0x2b53
movl 0x774d(%rip), %eax      # 0xa1f0
cmpl $0x2, %eax
sete %sil
andb %dl, %sil
xorl %ecx, %ecx
cmpb $0x1, %sil
jne 0x2b01
cmpw %r14w, 0xc(%rbx)
jne 0x2acd
pushq $0x2
popq %rax
jmp 0x2b01
leaq 0x7668(%rip), %rbx      # 0xa130
jmp 0x2b53
notl %edx
testb $0x11, %dl
jne 0x2af3
movq %rbx, %rsi
addq $0x4, %rsi
movswl %r15w, %edx
leaq 0x750a(%rip), %rdi      # 0x9ff0
callq 0x3af4
movl 0x76ff(%rip), %eax      # 0xa1f0
jmp 0x2af6
pushq $0x2
popq %rax
orl $0x11, %ebp
movl 0x14(%rbx), %ecx
incl %ecx
movl %ecx, 0x14(%rbx)
cmpl $0x2, %eax
jne 0x2b2f
cmpb $0x0, 0x7641(%rip)      # 0xa14e
je 0x2b2f
movzwl 0x7b5e(%rip), %edx      # 0xa674
movq 0x7833(%rip), %rsi      # 0xa350
movslq 0x10(%rbx), %rdi
movw %dx, (%rsi,%rdi,2)
movslq %ecx, %rcx
addq %rdi, %rcx
movw %dx, (%rsi,%rcx,2)
movl %r14d, %ecx
andl $0xfff, %ecx            # imm = 0xFFF
cmpl $0x9, %ebp
cmovel %r14d, %ecx
movw %cx, 0xc(%rbx)
movl %ebp, %ecx
orl $0x81, %ecx
cmpl $0x1, %eax
cmovnel %ebp, %ecx
movl %ecx, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radekh[P]palbart/palbart-2.5.c
// Function: endOfBinary
void endOfBinary()
{
  /* Points to end of page for () operands.                                   */
  punchLiteralPool( &cp, clc - 1 );
  /* Points to end of page zero for [] operands.                              */
  punchLiteralPool( &pz, 0 );
  if( error_in_line )
  {
    listed = TRUE;
    clc = ( clc & 070000 ) + (( clc - 1 ) & 07777 );
    errorMessage( &end_of_file, -1 );
    clc = ( clc & 070000 ) + (( clc + 1 ) & 07777 );
  }
  else
  {
    listLine();             /* List line if not done yet.                     */
  }
  return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movzwl 0x6ef6(%rip), %eax      # 0xa460
decl %eax
movswl %ax, %esi
leaq 0x6ef2(%rip), %rdi      # 0xa468
callq 0x37c2
leaq 0x6fea(%rip), %rdi      # 0xa56c
xorl %esi, %esi
callq 0x37c2
cmpb $0x0, 0x7164(%rip)      # 0xa6f4
je 0x35e7
movb $0x1, 0x70d7(%rip)      # 0xa670
movzwl 0x6ec0(%rip), %eax      # 0xa460
movl $0x7000, %ebx           # imm = 0x7000
movl %eax, %ecx
andl %ebx, %ecx
decl %eax
movl $0xfff, %ebp            # imm = 0xFFF
andl %ebp, %eax
orl %ecx, %eax
movw %ax, 0x6ea5(%rip)       # 0xa460
leaq 0x6a9e(%rip), %rdi      # 0xa060
pushq $-0x1
popq %rsi
callq 0x4ba7
movzwl 0x6e8f(%rip), %eax      # 0xa460
andl %eax, %ebx
incl %eax
andl %ebp, %eax
orl %ebx, %eax
movw %ax, 0x6e80(%rip)       # 0xa460
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x54d9
// File: /workspace/github_c_makefile_star2_O2/radekh[P]palbart/palbart-2.5.c
// Function: punchLiteralPool
void punchLiteralPool( LPOOL_T *p, WORD16 lpool_page )
{
  WORD16  loc;
  WORD16  tmplc;

  lpool_page &= 07600;

  if( p->loc < 00200 )
  {
    if( !rim_mode )
    {
      /* Put out origin if not in rim mode.                                   */
      punchOrigin( p->loc | lpool_page );
    }
    /* Put the literals in the object file.                                    */
    for( loc = p->loc; loc < 00200; loc++ )
    {
      tmplc = loc + lpool_page;
      printLine( line, (field | tmplc), p->pool[loc], LOC_VAL );
      punchLocObject( tmplc, p->pool[loc] );
    }
    p->error = FALSE;
    p->loc = 00200;
  }
}

// Assembly:
movzwl 0x2(%rdi), %eax
cmpw $0x7f, %ax
jg 0x385a
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
andl $0xf80, %esi            # imm = 0xF80
cmpb $0x0, 0x6964(%rip)      # 0xa14c
movzwl %si, %r15d
jne 0x37fd
orl %r15d, %eax
movswl %ax, %edi
callq 0x385b
movzwl 0x2(%rbx), %eax
movswq %ax, %r12
addl %eax, %r15d
leaq 0x6e85(%rip), %r14      # 0xa690
pushq $0x3
popq %rbp
cmpq $0x7f, %r12
jg 0x3849
movzwl 0x6c47(%rip), %eax      # 0xa462
orw %r15w, %ax
movswl 0x4(%rbx,%r12,2), %edx
movswl %ax, %esi
movq %r14, %rdi
movl %ebp, %ecx
callq 0x3877
movswl 0x4(%rbx,%r12,2), %esi
movswl %r15w, %edi
callq 0x5735
incq %r12
incl %r15d
jmp 0x380e
movb $0x0, (%rbx)
movw $0x80, 0x2(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/radekh[P]palbart/palbart-2.5.c
// Function: printLine
void printLine( char *line, WORD16 loc, WORD16 val, LINESTYLE_T linestyle )
{
  if( listfile == NULL )
  {
    save_error_count = 0;
    return;
  }

  printPageBreak();

  list_lineno++;
  page_lineno++;
  switch( linestyle )
  {
  default:
  case LINE:
    fprintf(listfile, "%5d             ", lineno );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_VAL:
    fprintf(listfile, "%5d       %4.4o  ", lineno, val );
    fputs( line, listfile );
    listed = TRUE;
    break;

  case LINE_LOC_VAL:
    if( !listed )
    {
      if( indirect_generated )
      {
        fprintf( listfile, "%5d %5.5o %4.4o@ ", lineno, loc, val );
      }
      else
      {
        fprintf( listfile, "%5d %5.5o %4.4o  ", lineno, loc, val );
      }
      fputs( line, listfile );
      listed = TRUE;
    }
    else
    {
      fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    }
    break;

  case LOC_VAL:
    fprintf( listfile, "      %5.5o %4.4o\n", loc, val );
    break;
  }
  printErrorMessages();
}

// Assembly:
cmpq $0x0, 0x6ac1(%rip)      # 0xa340
je 0x38d6
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x54ff
incl 0x6dde(%rip)            # 0xa67c
incl 0x6970(%rip)            # 0xa214
cmpl $0x1, %r15d
je 0x3905
cmpl $0x2, %r15d
je 0x38de
cmpl $0x3, %r15d
je 0x38e7
movq 0x6a83(%rip), %rdi      # 0xa340
movl 0x6db1(%rip), %edx      # 0xa674
leaq 0x2e47(%rip), %rsi      # 0x6711
xorl %eax, %eax
callq 0x2100
jmp 0x395a
andl $0x0, 0x690f(%rip)      # 0xa1ec
retq
cmpb $0x0, 0x6d8b(%rip)      # 0xa670
je 0x3925
movq 0x6a52(%rip), %rdi      # 0xa340
movswl %r14w, %edx
movswl %bp, %ecx
leaq 0x2e5c(%rip), %rsi      # 0x6758
xorl %eax, %eax
callq 0x2100
jmp 0x3970
movq 0x6a34(%rip), %rdi      # 0xa340
movl 0x6d62(%rip), %edx      # 0xa674
movswl %bp, %ecx
leaq 0x2e06(%rip), %rsi      # 0x6722
xorl %eax, %eax
callq 0x2100
jmp 0x395a
cmpb $0x0, 0x6dd8(%rip)      # 0xa704
movq 0x6a0d(%rip), %rdi      # 0xa340
movl 0x6d3b(%rip), %edx      # 0xa674
movswl %r14w, %ecx
movswl %bp, %r8d
leaq 0x2dfe(%rip), %rax      # 0x6746
leaq 0x2de5(%rip), %rsi      # 0x6734
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x2100
movq 0x69df(%rip), %rsi      # 0xa340
movq %rbx, %rdi
callq 0x20b0
movb $0x1, 0x6d00(%rip)      # 0xa670
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x563e
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: CloseAGG
void CloseAGG(struct aggfile *agg)
{
	if (!agg)
		return;
	if (agg->filename)
		free(agg->filename);
	if (agg->buf)
		free(agg->buf);
	if (agg->allentry)
		free(agg->allentry);
	fclose(agg->fin);
	free(agg);
}

// Assembly:
testq %rdi, %rdi
je 0x1271
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1070
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: HashFilename
unsigned short HashFilename(char *filename)
{
	unsigned char actual;
	unsigned short result = 0;

	while (*filename)
	{
		actual = *filename++ & 0x7F;
		if (actual >= 0x60)
			actual = actual - 32;
		result = ROL16((result >> 8) | ((result & 0xFF) << 8), 1) - actual;
	}
	return result;
}

// Assembly:
xorl %eax, %eax
movb (%rdi), %cl
testb %cl, %cl
je 0x129a
incq %rdi
andb $0x7f, %cl
leal -0x20(%rcx), %edx
cmpb $0x60, %cl
movzbl %cl, %ecx
movzbl %dl, %edx
cmovbl %ecx, %edx
rolw $0x9, %ax
movzbl %dl, %ecx
subl %ecx, %eax
jmp 0x1274
retq
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: fillentry
void fillentry(struct aggfile *agg)
{
	struct aggentry *aggentry = NULL;
	char *bufname = NULL;
	unsigned int i;

	agg->numentry = *(unsigned short*)agg->buf;
	if (!(agg->allentry = malloc(sizeof (struct entry) * agg->numentry)))
	{
		perror("malloc()");
		return;
	}
	printf("NUM_ENTRY = %X\n", agg->numentry);
	bufname = (char*)(agg->buf + agg->bufsize - (agg->numentry * 15));
	aggentry = (struct aggentry*)(agg->buf + 2);
	for (i = 0; i < agg->numentry; i++)
	{
		agg->allentry[i].hash = aggentry->hash;
		agg->allentry[i].buf = agg->buf + aggentry->off;
		agg->allentry[i].size = aggentry->size;
		strncpy(agg->allentry[i].filename, bufname, 15 - 1);
		bufname += 15;
		aggentry++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movzwl (%rax), %ebp
movw %bp, 0x1c(%rdi)
movl %ebp, %edi
shll $0x5, %edi
callq 0x10c0
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x135c
leaq 0xd3b(%rip), %rdi       # 0x200d
xorl %r12d, %r12d
movl %ebp, %esi
xorl %eax, %eax
callq 0x1080
movq 0x10(%rbx), %r13
movl 0x18(%rbx), %ecx
addq %r13, %rcx
movzwl 0x1c(%rbx), %eax
imulq $-0xf, %rax, %r14
addq %rcx, %r14
addq $0x2, %r13
pushq $0xe
popq %r15
movq %r15, %rbp
movzwl %ax, %eax
cmpq %rax, %r12
jae 0x134d
movzwl (%r13), %eax
movq 0x20(%rbx), %rcx
movw %ax, -0x2(%rcx,%rbp)
movl 0x2(%r13), %eax
addq 0x10(%rbx), %rax
leaq (%rcx,%rbp), %rdi
movq %rax, -0xe(%rcx,%rbp)
movl 0x6(%r13), %eax
movl %eax, -0x6(%rcx,%rbp)
movq %r14, %rsi
movq %r15, %rdx
callq 0x1040
addq $0xf, %r14
addq $0xe, %r13
incq %r12
movzwl 0x1c(%rbx), %eax
addq $0x20, %rbp
jmp 0x12fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xca1(%rip), %rdi       # 0x2004
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: dump_to_file
void dump_to_file(char *filename, unsigned char *buf, size_t size)
{
	FILE *fout;

	if (!(fout = fopen(filename, "wb")))
	{
		perror("fopen()");
		return;
	}
	fwrite(buf, 1, size, fout);
	fclose(fout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc55(%rip), %rsi       # 0x201d
callq 0x10f0
testq %rax, %rax
je 0x13f3
movq %rax, %r15
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x1120
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1070
leaq 0xc26(%rip), %rdi       # 0x2020
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: extractall
void extractall(struct aggfile *agg, char *outputdir)
{
	char output_name[4096];
	unsigned int i;

	if (!direxists(outputdir))
		return;
	for (i = 0; i < agg->numentry; i++)
	{
		strcpy(output_name, outputdir);
  		strcat(output_name, agg->allentry[i].filename);
		dump_to_file(output_name, agg->allentry[i].buf, agg->allentry[i].size);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1376
testl %eax, %eax
je 0x1471
pushq $0xe
popq %r12
xorl %r13d, %r13d
movq %rsp, %r15
movzwl 0x1c(%r14), %eax
cmpq %rax, %r13
jae 0x1471
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1050
movq 0x20(%r14), %rbp
leaq (%r12,%rbp), %rsi
movq %r15, %rdi
callq 0x1110
movq -0xe(%rbp,%r12), %rsi
movl -0x6(%rbp,%r12), %edx
movq %r15, %rdi
callq 0x13b6
incq %r13
addq $0x20, %r12
jmp 0x1431
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: InfoAGG
void InfoAGG(struct aggfile *agg)
{
	unsigned int i;

	printf("Filename = %s\n", agg->filename);
	printf("NumEntry = %X\n", agg->numentry);
	for (i = 0; i < agg->numentry; i++)
	{
		printf("Hash = %X\n", agg->allentry[i].hash);
		printf("Name = %s\n", agg->allentry[i].filename);
		printf("Size = %X\n", agg->allentry[i].size);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
leaq 0xb8d(%rip), %rdi       # 0x2028
xorl %eax, %eax
callq 0x1080
movzwl 0x1c(%rbx), %esi
leaq 0xb8a(%rip), %rdi       # 0x2037
xorl %eax, %eax
callq 0x1080
pushq $0xe
popq %r13
leaq 0xb87(%rip), %r14       # 0x2046
leaq 0xb8b(%rip), %r15       # 0x2051
leaq 0xb8f(%rip), %r12       # 0x205c
xorl %ebp, %ebp
movzwl 0x1c(%rbx), %eax
cmpq %rax, %rbp
jae 0x1519
movq 0x20(%rbx), %rax
movzwl -0x2(%rax,%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1080
movq 0x20(%rbx), %rsi
addq %r13, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1080
movq 0x20(%rbx), %rax
movl -0x6(%rax,%r13), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1080
incq %rbp
addq $0x20, %r13
jmp 0x14cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/agg.c
// Function: OpenAGG
struct aggfile *OpenAGG(char *filename)
{
	struct aggfile *newagg = NULL;

	if (!(newagg = malloc(sizeof (struct aggfile))))
	{
		perror("malloc()");
		return NULL;
	}
	newagg->filename = strdup(filename);
	if (!(newagg->fin = fopen(filename, "rb")))
	{
		perror("fopen()");
		CloseAGG(newagg);
		return NULL;
	}
        fseek(newagg->fin,0, SEEK_END);
        newagg->bufsize = ftell(newagg->fin);
        fseek(newagg->fin, 0, SEEK_SET);
	if (!(newagg->buf = malloc(sizeof (char) * newagg->bufsize)))
	{
		perror("fopen()");
		CloseAGG(newagg);
		return NULL;
	}
	if (fread(newagg->buf, 1, newagg->bufsize, newagg->fin) != newagg->bufsize)
	{
		perror("fread()");
		CloseAGG(newagg);
		return NULL;
	}
	return newagg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x28
popq %rdi
callq 0x10c0
testq %rax, %rax
je 0x15da
movq %rax, %rbx
movq %r14, %rdi
callq 0x1130
movq %rax, (%rbx)
leaq 0xb12(%rip), %rsi       # 0x2067
movq %r14, %rdi
callq 0x10f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x15c4
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10d0
movq 0x8(%rbx), %rdi
callq 0x10a0
movl %eax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
movl 0x18(%rbx), %r14d
movq %r14, %rdi
callq 0x10c0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x15c4
movq 0x8(%rbx), %rcx
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x1060
movl 0x18(%rbx), %ecx
cmpq %rcx, %rax
je 0x15e8
leaq 0xaa8(%rip), %rdi       # 0x206a
jmp 0x15cb
leaq 0xa55(%rip), %rdi       # 0x2020
callq 0x1100
movq %rbx, %rdi
callq 0x123c
jmp 0x15e6
leaq 0xa23(%rip), %rdi       # 0x2004
callq 0x1100
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/w4kfu[P]HommI/Agg/main.c
// Function: main
int main(int argc, char *argv[])
{
	struct aggfile *agg = NULL;

	if (argc != 2)
	{
		fprintf(stderr, "%s <*.AGG>\n", argv[0]);
		return EXIT_FAILURE;
	}
	if (!(agg = OpenAGG(argv[1])))
		return EXIT_FAILURE;
	fillentry(agg);
	InfoAGG(agg);
	extractall(agg, "./extract/");
	CloseAGG(agg);
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jne 0x1636
movq 0x8(%rsi), %rdi
callq 0x1528
testq %rax, %rax
je 0x1651
movq %rax, %rbx
movq %rax, %rdi
callq 0x129b
movq %rbx, %rdi
callq 0x1483
leaq 0xa5c(%rip), %rsi       # 0x207e
movq %rbx, %rdi
callq 0x1404
movq %rbx, %rdi
callq 0x123c
xorl %eax, %eax
jmp 0x1654
movq 0x29bb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq (%rsi), %rdx
leaq 0xa28(%rip), %rsi       # 0x2072
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %rax
popq %rbx
retq