LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: makeToken
static bluToken makeToken(bluParser* parser, bluTokenType type) {
	bluToken token;
	token.type = type;

	switch (type) {
	case TOKEN_NEWLINE:
		token.start = "<NEWLINE>";
		token.length = 9;
		break;

	case TOKEN_EOF:
		token.start = "<EOF>";
		token.length = 5;
		break;

	default:
		token.start = parser->source + parser->from;
		token.length = parser->at - parser->from;
		break;
	}

	token.line = parser->lineFrom;
	token.column = parser->columnFrom;

	return token;
}

// Assembly:
movl %edx, (%rdi)
cmpl $0x2f, %edx
je 0x6fba
cmpl $0x30, %edx
jne 0x6fc9
leaq 0x39da(%rip), %rax      # 0xa98c
movq %rax, 0x8(%rdi)
movb $0x9, %al
jmp 0x6fdc
leaq 0x39d5(%rip), %rax      # 0xa996
movq %rax, 0x8(%rdi)
movb $0x5, %al
jmp 0x6fdc
movslq 0x8(%rsi), %rcx
movq %rcx, %rax
addq (%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0xc(%rsi), %eax
subl %ecx, %eax
movb %al, 0x10(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x14(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/parser/parser.c
// Function: string
static bluToken string(bluParser* parser) {
	while (peek(parser) != '"' && !isAtEnd(parser)) {
		if (peek(parser) == '\n') {
			newline(parser);
		}

		advance(parser);
	}

	if (isAtEnd(parser)) {
		return errorToken(parser, "Unterminated string.");
	}

	// The closing ".
	advance(parser);

	return makeToken(parser, TOKEN_STRING);
}

// Assembly:
movq (%rsi), %rcx
movslq 0xc(%rsi), %rdx
leal 0x1(%rdx), %eax
addq %rcx, %rdx
movzbl (%rdx), %r8d
cmpl $0xa, %r8d
je 0x7017
testl %r8d, %r8d
je 0x705a
cmpl $0x22, %r8d
je 0x702e
movl 0x1c(%rsi), %r8d
incl %r8d
jmp 0x7020
incl 0x14(%rsi)
movl $0x1, %r8d
movl %r8d, 0x1c(%rsi)
movl %eax, 0xc(%rsi)
incl %eax
incq %rdx
jmp 0x6ff9
incl 0x1c(%rsi)
movl %eax, 0xc(%rsi)
movl $0x1b, (%rdi)
movslq 0x8(%rsi), %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rdi)
negb %dl
movzbl %dl, %ecx
addl %eax, %ecx
movb %cl, 0x10(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x14(%rdi)
movl 0x18(%rsi), %eax
jmp 0x7078
movl 0x10(%rsi), %ecx
movl 0x18(%rsi), %eax
movl $0x31, (%rdi)
leaq 0x392f(%rip), %rdx      # 0xa99c
movq %rdx, 0x8(%rdi)
movb $0x14, 0x10(%rdi)
movl %ecx, 0x14(%rdi)
movl %eax, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableGet
bool bluTableGet(bluVM* vm, bluTable* table, bluObjString* key, bluValue* value) {
	if (table->entries == NULL) return false;

	bluEntry* entry = findEntry(table->entries, table->capacityMask, key);
	if (entry->key == NULL) return false;

	*value = entry->value;

	return true;
}

// Assembly:
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x70d3
movslq 0x4(%rsi), %rdi
movl 0x24(%rdx), %r8d
xorl %esi, %esi
movslq %r8d, %r8
andq %rdi, %r8
leaq (%r8,%r8,2), %r9
leaq (%rax,%r9,8), %r9
movq (%r9), %r10
testq %r10, %r10
je 0x70ac
cmpq %rdx, %r10
jne 0x70ba
jmp 0x70c8
testq %rsi, %rsi
cmoveq %r9, %rsi
cmpl $0x1, 0x8(%r9)
je 0x70bf
incl %r8d
jmp 0x708f
cmpq $0x0, (%rsi)
movq %rsi, %r9
je 0x70d3
movups 0x8(%r9), %xmm0
movups %xmm0, (%rcx)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableSet
bool bluTableSet(bluVM* vm, bluTable* table, bluObjString* key, bluValue value) {
	if (table->count + 1 > (table->capacityMask + 1) * TABLE_MAX_LOAD) {
		// TODO : Make macro for growing capacity
		int32_t capacityMask = ((table->capacityMask + 1) * 2) - 1;
		if (capacityMask == -1) {
			capacityMask = 63;
		}

		adjustCapacity(vm, table, capacityMask);
	}

	bluEntry* entry = findEntry(table->entries, table->capacityMask, key);

	bool isNewKey = entry->key == NULL;

	// Increase count only if we are inserting into empty bucket, not when replacing tombstone
	if (isNewKey && IS_NIL(entry->value)) table->count++;

	entry->key = key;
	entry->value = value;

	return isNewKey;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movl (%rsi), %eax
incl %eax
cvtsi2sd %eax, %xmm0
movl 0x4(%rsi), %ebx
leal 0x1(%rbx), %eax
cvtsi2sd %eax, %xmm1
mulsd 0x38b5(%rip), %xmm1     # 0xa9b8
ucomisd %xmm1, %xmm0
jbe 0x7216
movq %rdi, %r13
movq %r8, (%rsp)
leal -0x1(,%rax,2), %ecx
testl %eax, %eax
movl $0x3f, %ebx
cmovnel %ecx, %ebx
movslq %ebx, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
addq $0x18, %rsi
callq 0x5df0
movq %rax, %r12
testl %ebx, %ebx
js 0x716c
leal 0x1(%rbx), %eax
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, (%r12,%rdx)
movl $0x1, 0x8(%r12,%rdx)
movq %rcx, 0x10(%r12,%rdx)
addq $0x18, %rdx
cmpq %rdx, %rax
jne 0x7151
movl $0x0, (%r15)
movl 0x4(%r15), %edx
testl %edx, %edx
js 0x71ed
xorl %eax, %eax
movq 0x8(%r15), %rsi
leaq (%rax,%rax,2), %rdi
movq (%rsi,%rdi,8), %rcx
testq %rcx, %rcx
je 0x71de
leaq (%rsi,%rdi,8), %rdx
movl 0x24(%rcx), %esi
xorl %edi, %edi
andl %ebx, %esi
movslq %esi, %r8
leaq (%r8,%r8,2), %r9
leaq (%r12,%r9,8), %r8
movq (%r12,%r9,8), %r9
testq %r9, %r9
je 0x71b4
cmpq %rcx, %r9
jne 0x71c5
jmp 0x71c9
testq %rdi, %rdi
cmoveq %r8, %rdi
cmpl $0x1, 0x8(%r8)
movq %rdi, %r8
je 0x71c9
incl %esi
jmp 0x7197
movq %rcx, (%r8)
movupd 0x8(%rdx), %xmm0
movupd %xmm0, 0x8(%r8)
incl (%r15)
movl 0x4(%r15), %edx
leaq 0x1(%rax), %rcx
movslq %edx, %rsi
cmpq %rsi, %rax
movq %rcx, %rax
jl 0x717d
movq 0x8(%r15), %rsi
movslq %edx, %rax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
addq $0x18, %rdx
movq %r13, %rdi
callq 0x5e3d
movq %r12, 0x8(%r15)
movl %ebx, 0x4(%r15)
movq (%rsp), %r8
jmp 0x721a
movq 0x8(%r15), %r12
movl 0x24(%r14), %eax
xorl %ecx, %ecx
andl %ebx, %eax
movslq %eax, %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%r12,%rdx,8), %rdx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x723c
cmpq %r14, %rsi
jne 0x7249
jmp 0x724d
testq %rcx, %rcx
cmoveq %rdx, %rcx
cmpl $0x1, 0x8(%rdx)
je 0x7251
incl %eax
jmp 0x7220
xorl %eax, %eax
jmp 0x7269
cmpq $0x0, (%rcx)
je 0x725b
xorl %eax, %eax
jmp 0x7266
movb $0x1, %al
cmpl $0x1, 0x8(%rcx)
jne 0x7266
incl (%r15)
movq %rcx, %rdx
movq %r14, (%rdx)
movl %ebp, 0x8(%rdx)
movq %r8, 0x10(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableDelete
bool bluTableDelete(bluVM* vm, bluTable* table, bluObjString* key) {
	if (table->count == 0) return false;

	// Find the entry.
	bluEntry* entry = findEntry(table->entries, table->capacityMask, key);
	if (entry->key == NULL) return false;

	// Place a tombstone in the entry.
	entry->key = NULL;
	entry->value = BOOL_VAL(true);

	return true;
}

// Assembly:
cmpl $0x0, (%rsi)
je 0x72e3
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rsi
movl 0x24(%rdx), %edi
xorl %ecx, %ecx
movslq %edi, %rdi
andq %rsi, %rdi
leaq (%rdi,%rdi,2), %r8
leaq (%rax,%r8,8), %r8
movq (%r8), %r9
testq %r9, %r9
je 0x72b1
cmpq %rdx, %r9
jne 0x72bf
jmp 0x72cc
testq %rcx, %rcx
cmoveq %r8, %rcx
cmpl $0x1, 0x8(%r8)
je 0x72c3
incl %edi
jmp 0x7294
cmpq $0x0, (%rcx)
movq %rcx, %r8
je 0x72e3
movq $0x0, (%r8)
movl $0x0, 0x8(%r8)
movb $0x1, 0x10(%r8)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableAddAll
void bluTableAddAll(bluVM* vm, bluTable* from, bluTable* to) {
	for (int32_t i = 0; i <= from->capacityMask; i++) {
		bluEntry* entry = &from->entries[i];
		if (entry->key != NULL) {
			bluTableSet(vm, to, entry->key, entry->value);
		}
	}
}

// Assembly:
movl 0x4(%rsi), %eax
testl %eax, %eax
js 0x734a
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $-0x1, %r12
movl $0x10, %r13d
movq 0x8(%r14), %rsi
movq -0x10(%rsi,%r13), %rdx
testq %rdx, %rdx
je 0x7332
movl -0x8(%rsi,%r13), %ecx
movq (%rsi,%r13), %r8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x70d6
movl 0x4(%r14), %eax
movslq %eax, %rcx
incq %r12
addq $0x18, %r13
cmpq %rcx, %r12
jl 0x730c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/table.c
// Function: bluTableFindString
bluObjString* bluTableFindString(bluVM* vm, bluTable* table, const char* chars, int32_t length, int32_t hash) {
	// If the table is empty, we definitely won't find it.
	if (table->entries == NULL) return NULL;

	int32_t index = hash & table->capacityMask;

	while (true) {
		bluEntry* entry = &table->entries[index];

		if (entry->key == NULL) {
			// Stop if we find an empty non-tombstone entry.
			if (IS_NIL(entry->value)) return NULL;
		} else if (entry->key->length == length && entry->key->hash == hash &&
				   memcmp(entry->key->chars, chars, length) == 0) {
			// We found it.
			return entry->key;
		}

		// Try the next slot.
		index = (index + 1) & table->capacityMask;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq 0x8(%rsi), %r13
testq %r13, %r13
je 0x73d0
movl %r8d, %ebx
movl %ecx, %ebp
movl 0x4(%rsi), %r15d
movl %r15d, %r14d
andl %r8d, %r14d
movslq %ecx, %rax
movq %rax, 0x8(%rsp)
movslq %r14d, %rax
leaq (%rax,%rax,2), %rax
movq (%r13,%rax,8), %r12
testq %r12, %r12
je 0x73b7
cmpl %ebp, 0x20(%r12)
jne 0x73c8
cmpl %ebx, 0x24(%r12)
jne 0x73c8
leaq 0x28(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2190
testl %eax, %eax
jne 0x73c8
jmp 0x73d3
leaq (,%rax,8), %rax
addq %r13, %rax
cmpl $0x1, 0x8(%rax)
je 0x73d0
incl %r14d
andl %r15d, %r14d
jmp 0x737e
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/value.c
// Function: bluValuesEqual
bool bluValuesEqual(bluValue a, bluValue b) {
	if (a.type != b.type) return false;

	switch (a.type) {
	case VAL_BOOL: return AS_BOOL(a) == AS_BOOL(b);
	case VAL_NIL: return true;
	case VAL_NUMBER: return fabs(AS_NUMBER(a) - AS_NUMBER(b)) < __DBL_EPSILON__;
	case VAL_OBJ: return AS_OBJ(a) == AS_OBJ(b);
	}

	__builtin_unreachable();
}

// Assembly:
cmpl %edx, %edi
jne 0x743d
movl %edi, %eax
leaq 0x35ab(%rip), %rdx      # 0xa9d8
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
xorl %esi, %ecx
testb $0x1, %cl
jmp 0x7469
xorl %eax, %eax
retq
movq %rsi, %xmm0
movq %rcx, %xmm1
subsd %xmm1, %xmm0
andpd 0x356a(%rip), %xmm0     # 0xa9c0
movsd 0x3572(%rip), %xmm1     # 0xa9d0
ucomisd %xmm0, %xmm1
seta %al
retq
cmpq %rcx, %rsi
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/value.c
// Function: bluPrintValue
void bluPrintValue(bluValue value) {
	switch (value.type) {
	case VAL_BOOL: printf(AS_BOOL(value) ? "true" : "false"); break;
	case VAL_NIL: printf("nil"); break;
	case VAL_NUMBER: {
		if (AS_NUMBER(value) == (int)AS_NUMBER(value)) {
			printf("%d", (int)AS_NUMBER(value));
		} else {
			printf("%g", AS_NUMBER(value));
		}
		break;
	}
	case VAL_OBJ: bluPrintObject(value); break;
	}
}

// Assembly:
cmpl $0x3, %edi
ja 0x74f5
movl %edi, %eax
leaq 0x3553(%rip), %rcx      # 0xa9e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3553(%rip), %rax      # 0xa9f8
leaq 0x3551(%rip), %rdi      # 0xa9fd
testb $0x1, %sil
cmovneq %rax, %rdi
jmp 0x74ee
movq %rsi, %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x74f6
jp 0x74f6
cvttsd2si %xmm0, %esi
leaq 0x3531(%rip), %rdi      # 0xaa07
xorl %eax, %eax
jmp 0x20f0
movl $0x3, %edi
jmp 0x66bf
leaq 0x3515(%rip), %rdi      # 0xaa03
xorl %eax, %eax
jmp 0x20f0
retq
leaq 0x350d(%rip), %rdi      # 0xaa0a
movb $0x1, %al
jmp 0x20f0
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluNewVM
bluVM* bluNewVM() {
	bluVM* vm = malloc(sizeof(bluVM));

	resetStack(vm);

	vm->frameCount = 0;
	vm->frameCountStart = 0;

	vm->openUpvalues = NULL;
	vm->objects = NULL;

	vm->bytesAllocated = 0;
	vm->nextGC = 1024 * 1024;
	vm->shouldGC = false;
	vm->timeGC = 0;

	bluTableInit(vm, &vm->globals);
	bluTableInit(vm, &vm->strings);

	bluModuleBufferInit(&vm->modules);

	vm->stringInitializer = bluCopyString(vm, "__init", 6);

	bluInitStd(vm);

	return vm;
}

// Assembly:
pushq %rbx
movl $0x1018b0, %edi         # imm = 0x1018B0
callq 0x2170
movq %rax, %rbx
movq %rax, 0x100000(%rax)
xorl %eax, %eax
movq %rax, 0x101808(%rbx)
movq %rax, 0x101830(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x101888(%rbx)
movq $0x100000, 0x101898(%rbx) # imm = 0x100000
movb $0x0, 0x1018a0(%rbx)
movq %rax, 0x1018a8(%rbx)
leaq 0x101810(%rbx), %rsi
movq %rbx, %rdi
callq 0x73e5
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x73e5
xorps %xmm0, %xmm0
movups %xmm0, 0x101878(%rbx)
leaq 0x1b91(%rip), %rsi      # 0x91c9
movq %rbx, %rdi
movl $0x6, %edx
callq 0x6239
movq %rax, 0x101870(%rbx)
movq %rbx, %rdi
callq 0x59d0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluFreeVM
void bluFreeVM(bluVM* vm) {
	bluCollectMemory(vm);

	bluTableFree(vm, &vm->globals);
	bluTableFree(vm, &vm->strings);

	for (int32_t i = 0; i < vm->modules.count; i++) {
		if (vm->modules.data[i].source != NULL) {
			free(vm->modules.data[i].source);
		}
	}

	bluModuleBufferFree(&vm->modules);

#ifdef DEBUG
	assert(vm->bytesAllocated == 0);
#endif

	free(vm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6169
leaq 0x101810(%rbx), %rsi
movq %rbx, %rdi
callq 0x73fb
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x73fb
movl 0x101880(%rbx), %eax
testl %eax, %eax
jle 0x76c1
movl $0x10, %r14d
xorl %r15d, %r15d
movq 0x101878(%rbx), %rcx
movq (%rcx,%r14), %rdi
testq %rdi, %rdi
je 0x76b2
callq 0x2030
movl 0x101880(%rbx), %eax
incq %r15
movslq %eax, %rcx
addq $0x20, %r14
cmpq %rcx, %r15
jl 0x7697
movq 0x101878(%rbx), %rdi
testq %rdi, %rdi
je 0x76d2
callq 0x2030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluGetClass
bluObjClass* bluGetClass(bluVM* vm, bluValue value) {
	switch (value.type) {
	case VAL_NIL: return vm->nilClass;
	case VAL_BOOL: return vm->boolClass;
	case VAL_NUMBER: return vm->numberClass;
	case VAL_OBJ:
		if (IS_CLASS(value)) {
			// Core class were created before Class so they don't have a reference to it.
			return vm->classClass;
		} else if (IS_STRING(value)) {
			// String class can be defiend after some string instances have been already allocated so they have
			// incorrect pointer to String class.
			return vm->stringClass;
		} else {
			return AS_OBJ(value)->class;
		}
	}

	__builtin_unreachable();
}

// Assembly:
movl %esi, %eax
leaq 0x1ec3(%rip), %rcx      # 0xab10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x101840, %rdi         # imm = 0x101840
jmp 0x8c96
addq $0x101848, %rdi         # imm = 0x101848
jmp 0x8c96
movl (%rdx), %eax
cmpl $0x7, %eax
je 0x8c86
cmpl $0x2, %eax
jne 0x8c8f
addq $0x101858, %rdi         # imm = 0x101858
jmp 0x8c96
addq $0x101838, %rdi         # imm = 0x101838
jmp 0x8c96
addq $0x101868, %rdi         # imm = 0x101868
jmp 0x8c96
addq $0x8, %rdx
movq %rdx, %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluGetGlobal
bluObj* bluGetGlobal(bluVM* vm, const char* name) {
	bluValue value;
	if (!bluTableGet(vm, &vm->globals, bluCopyString(vm, name, strlen(name)), &value)) {
		return NULL;
	}

	if (!IS_OBJ(value)) {
		return NULL;
	}

	return AS_OBJ(value);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x101810(%rdi), %r15
movq %rsi, %rdi
callq 0x20e0
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x6239
movq %rsp, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x707c
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x3, (%rbx)
movl $0x0, %edx
jne 0x8cec
movq 0x8(%rsp), %rdx
testb %cl, %cl
cmovneq %rdx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluRegisterModule
void bluRegisterModule(bluVM* vm, const char* name, bluModuleLoader loader) {
	bluModule module;
	module.name = bluCopyString(vm, name, strlen(name));
	module.loader = loader;
	module.loaded = false;
	module.source = NULL;

	bluModuleBufferWrite(&vm->modules, module);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x20e0
movq %r15, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x6239
addq $0x101878, %r15         # imm = 0x101878
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movl $0x1, %esi
callq 0x7524
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: call
static bool call(bluVM* vm, bluObjClosure* closure, int8_t argCount) {
	if (argCount < closure->function->arity) {
		runtimeError(vm, "Expected %d arguments but got %d.", closure->function->arity, argCount);
		return false;
	}

	if (vm->frameCount == FRAMES_MAX) {
		runtimeError(vm, "Stack overflow.");
		return false;
	}

	bluCallFrame* frame = &vm->frames[vm->frameCount++];
	frame->closure = closure;
	frame->ip = closure->function->chunk.code.data;

	// +1 to include either the called function or the receiver.
	frame->slots = vm->stackTop - (argCount + 1);

	return true;
}

// Assembly:
pushq %rbx
movl %edx, %ecx
movq 0x20(%rsi), %rax
movsbl 0x20(%rax), %edx
cmpb %cl, %dl
jg 0x8e90
movslq 0x101808(%rdi), %rdx
cmpq $0x100, %rdx            # imm = 0x100
je 0x8ea2
leal 0x1(%rdx), %r8d
movl %r8d, 0x101808(%rdi)
leaq (%rdx,%rdx,2), %rdx
movq %rsi, 0x100008(%rdi,%rdx,8)
movq 0x38(%rax), %rax
movq %rax, 0x100010(%rdi,%rdx,8)
notl %ecx
movslq %ecx, %rax
shlq $0x4, %rax
addq 0x100000(%rdi), %rax
movq %rax, 0x100018(%rdi,%rdx,8)
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
leaq 0x1ccf(%rip), %rsi      # 0xab66
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2348
jmp 0x8e8c
leaq 0x1d03(%rip), %rsi      # 0xabac
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2348
jmp 0x8e8c
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: bindMethod
static bool bindMethod(bluVM* vm, bluObjClass* class, bluObjString* name) {
	bluValue method;
	if (!bluTableGet(vm, &class->methods, name, &method)) {
		runtimeError(vm, "Undefined property '%s'.", name->chars);
		return false;
	}

	bluObjBoundMethod* bound = bluNewBoundMethod(vm, bluPop(vm), AS_CLOSURE(method));
	bluPush(vm, OBJ_VAL(bound));

	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x30, %rsi
movq %rsp, %rcx
callq 0x707c
movl %eax, %ebp
testb %al, %al
je 0x8f21
movq 0x100000(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0x100000(%rbx)
movl -0x10(%rax), %esi
movq -0x8(%rax), %rdx
movq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x6391
movq 0x100000(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x100000(%rbx)
movl $0x3, (%rcx)
movq %rax, 0x8(%rcx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x28, %r14
leaq 0x1e6a(%rip), %rsi      # 0xad96
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2348
jmp 0x8f16
// File: /workspace/github_c_makefile_star2_O3/adamjedlicka[P]blu/src/vm/vm.c
// Function: invokeFromClass
static bool invokeFromClass(bluVM* vm, bluObjClass* class, bluObjString* name, int8_t argCount) {
	// Look for the method.
	bluValue method;
	if (!bluTableGet(vm, &class->methods, name, &method)) {
		if (class->superclass != NULL && invokeFromClass(vm, class->superclass, name, argCount)) {
			return true;
		} else {
			runtimeError(vm, "Undefined property '%s'.", name->chars);
			return false;
		}
	}

	if (IS_NATIVE(method)) {
		return callValue(vm, method, argCount);
	}

	return call(vm, AS_CLOSURE(method), argCount);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x30, %rsi
leaq 0x8(%rsp), %rcx
callq 0x707c
testb %al, %al
je 0x8f89
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rsp)
jne 0x8fc4
cmpl $0x6, (%rax)
jne 0x8fc4
movsbl %bpl, %ecx
movq %rbx, %rdi
movl $0x3, %esi
movq %rax, %rdx
callq 0x8a7d
jmp 0x8fd3
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x8fa8
movsbl %bpl, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8f3b
movb $0x1, %bpl
testb %al, %al
jne 0x8fd5
addq $0x28, %r14
leaq 0x1de3(%rip), %rsi      # 0xad96
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2348
jmp 0x8fd5
movsbl %bpl, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8e30
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tyabu12[P]pl0compiler/compile.c
// Function: compile
int compile(FILE *fout) {
    int i;
    /* printf("start compilation\n"); */
    initSource();               /* getSourceの初期設定                  */
    token = nextToken();        /* 最初のトークン                       */
    blockBegin(FIRSTADDR);      /* これ以後の宣言は新しいブロックのもの */
    block(0);                   /* 0 はダミー（主ブロックの関数名はない） */
    finalSource();
    i = errorN();               /* エラーメッセージの個数               */
    if (i!=0)
        printf("%d errors\n", i);
    listCode(fout, 1);          /* 目的コードのリスト（必要なら）       */
    return i < MINERROR;        /* エラーメッセージの個数が少ないかどうかの判定 */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x46ff
leaq 0xc(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x20(%r14), %eax
movl %eax, 0x7649(%rip)      # 0xad88
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x7629(%rip)     # 0xad78
movups %xmm0, 0x7612(%rip)     # 0xad68
movl $0x2, %edi
callq 0x31e8
xorl %edi, %edi
callq 0x37a9
xorl %eax, %eax
callq 0x49f8
xorl %eax, %eax
callq 0x4c95
movl %eax, %ebp
testl %eax, %eax
je 0x378b
leaq 0x2e3e(%rip), %rdi      # 0x65c0
movl %ebp, %esi
xorl %eax, %eax
callq 0x2090
movq %rbx, %rdi
movl $0x1, %esi
callq 0x244c
xorl %eax, %eax
cmpl $0x3, %ebp
setl %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tyabu12[P]pl0compiler/compile.c
// Function: expression
void expression() {             /* 式のコンパイル                       */
    KeyId k;
    k = token.kind;
    if (k == Plus || k == Minus) {
        token = nextToken();
        term();
        if (k == Minus)
            genCodeO(neg);
    } else
        term();
    k = token.kind;
    while (k == Plus || k == Minus) {
        token = nextToken();
        term();
        if (k == Minus)
            genCodeO(sub);
        else
            genCodeO(add);
        k = token.kind;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl 0x6c34(%rip), %r14d     # 0xad68
leal -0xf(%r14), %eax
cmpl $0x1, %eax
ja 0x417e
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x20(%rbx), %eax
movl %eax, 0x6c33(%rip)      # 0xad88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x6c15(%rip)     # 0xad78
movups %xmm0, 0x6bfe(%rip)     # 0xad68
callq 0x41f0
cmpl $0x10, %r14d
jne 0x4183
xorl %edi, %edi
callq 0x2372
jmp 0x4183
callq 0x41f0
movl 0x6bdf(%rip), %eax      # 0xad68
leal -0xf(%rax), %ecx
cmpl $0x1, %ecx
ja 0x41e7
leaq 0xc(%rsp), %rbx
xorl %ebp, %ebp
cmpl $0x10, %eax
sete %bpl
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x2c(%rsp), %eax
movl %eax, 0x6bd5(%rip)      # 0xad88
movups 0xc(%rsp), %xmm0
movups 0x1c(%rsp), %xmm1
movups %xmm1, 0x6bb4(%rip)     # 0xad78
movups %xmm0, 0x6b9d(%rip)     # 0xad68
callq 0x41f0
incl %ebp
movl %ebp, %edi
callq 0x2372
movl 0x6b89(%rip), %eax      # 0xad68
leal -0xf(%rax), %ecx
cmpl $0x2, %ecx
jb 0x4196
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tyabu12[P]pl0compiler/compile.c
// Function: term
void term() {                   /* 式の項のコンパイル                   */
    KeyId k;
    factor();
    k = token.kind;
    while (k == Mult || k == Div) {
        token = nextToken();
        factor();
        if (k == Mult)
            genCodeO(mul);
        else
            genCodeO(div);
        k = token.kind;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x426c
movl 0x6b65(%rip), %r14d     # 0xad68
leal -0x11(%r14), %eax
cmpl $0x1, %eax
ja 0x4264
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x24(%rsp), %eax
movl %eax, 0x6b63(%rip)      # 0xad88
movups 0x4(%rsp), %xmm0
movups 0x14(%rsp), %xmm1
movups %xmm1, 0x6b42(%rip)     # 0xad78
movups %xmm0, 0x6b2b(%rip)     # 0xad68
callq 0x426c
xorl %edi, %edi
cmpl $0x11, %r14d
setne %dil
addl $0x3, %edi
callq 0x2372
movl 0x6b0d(%rip), %r14d     # 0xad68
leal -0x11(%r14), %eax
cmpl $0x2, %eax
jb 0x4211
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tyabu12[P]pl0compiler/compile.c
// Function: condition
void condition() {              /* 条件式のコンパイル                   */
    KeyId k;
    if (token.kind == Odd) {
        token = nextToken();
        expression();
        genCodeO(odd);
    } else {
        expression();
        k = token.kind;
        switch (k) {
        case Equal:
        case Lss:
        case Gtr:
        case NotEq:
        case LssEq:
        case GtrEq:
            break;
        default:
            errorType("rel-op");
            break;
        }
        token = nextToken();
        expression();
        switch (k) {
        case Equal: genCodeO(eq); break;
        case Lss: genCodeO(ls); break;
        case Gtr: genCodeO(gr); break;
        case NotEq: genCodeO(neq); break;
        case LssEq: genCodeO(lseq); break;
        case GtrEq: genCodeO(greq); break;
        default:
            /* ishii */
            errorType("rel-op");
            break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0xa, 0x6816(%rip)      # 0xad68
jne 0x4598
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x20(%rbx), %eax
movl %eax, 0x681c(%rip)      # 0xad88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x67fe(%rip)     # 0xad78
movups %xmm0, 0x67e7(%rip)     # 0xad68
callq 0x4125
movl $0x5, %edi
callq 0x2372
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x4125
movl 0x67c4(%rip), %r14d     # 0xad68
addl $-0x15, %r14d
cmpl $0x6, %r14d
jb 0x45ba
leaq 0x1e28(%rip), %rdi      # 0x63dd
callq 0x4acf
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4c9c
movl 0x20(%rbx), %eax
movl %eax, 0x67b6(%rip)      # 0xad88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x6798(%rip)     # 0xad78
movups %xmm0, 0x6781(%rip)     # 0xad68
callq 0x4125
cmpl $0x5, %r14d
ja 0x463b
leaq 0x1db7(%rip), %rax      # 0x63b0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl $0x6, %edi
jmp 0x458b
movl $0xa, %edi
jmp 0x458b
movl $0x8, %edi
jmp 0x458b
movl $0x9, %edi
jmp 0x458b
movl $0x7, %edi
jmp 0x458b
movl $0xb, %edi
jmp 0x458b
leaq 0x1d9b(%rip), %rdi      # 0x63dd
callq 0x4acf
jmp 0x4590
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_byte_count
off_t wc_get_byte_count(int fd){
    struct stat s;
    if(fstat(fd, &s) < 0){
        fprintf(stderr, "wc: %s\n", strerror(errno));
        exit(1);
    }
    return s.st_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq -0x90(%rbp), %rsi
callq 0x10e0
testl %eax, %eax
js 0x147e
movq -0x60(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
callq 0x1110
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_nl_count
size_t wc_get_nl_count(int fd){
    char buf[4096];
    size_t sum = 0;
    ssize_t n;
    lseek(fd, 0, SEEK_SET);
    while((n = read(fd, buf, 4095)) > 0){
        for(size_t i = 0; i < n; i++){
            if(buf[i] == '\n'){
                sum++;
            }
        }
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edi, %ebx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
leaq -0x1020(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
movl %ebx, %edi
callq 0x1070
testq %rax, %rax
jle 0x14f1
xorl %r14d, %r14d
leaq -0x1020(%rbp), %r15
xorl %ecx, %ecx
xorl %edx, %edx
cmpb $0xa, -0x1020(%rbp,%rcx)
sete %dl
addq %rdx, %r14
incq %rcx
cmpq %rcx, %rax
jne 0x14c5
movl $0xfff, %edx            # imm = 0xFFF
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
testq %rax, %rax
jg 0x14c3
movq %r14, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/wc.c
// Function: wc_get_word_count
size_t wc_get_word_count(int fd){
    char buf[4096];
    size_t num = 0;
    ssize_t n;
    lseek(fd, 0, SEEK_SET);
    while((n = read(fd, buf, 4096)) > 0){
        for(size_t i = 1; i < n; i++){
            if(!isspace(buf[i-1]) && isspace(buf[i])){
                num++;
            }
        }
    }
    return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %edi, %ebx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
callq 0x1070
testq %rax, %rax
jle 0x159e
movq %rax, %r12
xorl %r14d, %r14d
leaq -0x1020(%rbp), %r15
cmpq $0x2, %r12
jb 0x1587
callq 0x10f0
movq (%rax), %rax
movl $0x1, %ecx
movsbq -0x1021(%rbp,%rcx), %rdx
testb $0x20, 0x1(%rax,%rdx,2)
jne 0x157f
movsbq -0x1020(%rbp,%rcx), %rdx
movzwl (%rax,%rdx,2), %edx
btl $0xd, %edx
adcq $0x0, %r14
incq %rcx
cmpq %rcx, %r12
jne 0x155a
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
movq %rax, %r12
testq %rax, %rax
jg 0x1547
movq %r14, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ikbenlike[P]nngutils/src/wc.c
// Function: main
int main(int argc, char **argv){
    struct wc_args *args = calloc(1, sizeof(struct wc_args));
    if(args == NULL){
        fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
        return 1;
    }
    args = parse_arg(args, argc, argv);
    for(int i = 0; i < args->fcount; i++){
        int fd = open(args->files[i], O_RDONLY);
        if(!strcmp(args->files[i], "-")){
            fd = STDIN_FILENO;
        }
        if(fd < 0){
            fprintf(stderr, "%s: %s\n", argv[0], strerror(errno));
            return 1;
        }
        /*if(args->byte_count){
            puts("byte count");
            printf("%zu\n", wc_get_byte_count(fd));
        }
        if(args->line_count){
            puts("line count");
            printf("%zu\n", wc_get_nl_count(fd));
        }
        if(args->word_count){
            puts("word count");
            printf("%zu\n", wc_get_word_count(fd));
        }*/
        printf("  %zu %zu %zu %s\n", wc_get_nl_count(fd), wc_get_word_count(fd), wc_get_byte_count(fd), args->files[i]);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movl %edi, %r15d
movl $0x1, %edi
movl $0x18, %esi
callq 0x1080
testq %rax, %rax
je 0x1692
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movq -0x30(%rbp), %rdx
callq 0x127c
cmpl $0x0, 0x10(%r14)
jle 0x167d
xorl %r15d, %r15d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10b0
movl %eax, %r12d
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rax
cmpb $0x2d, (%rax)
jne 0x1625
cmpb $0x0, 0x1(%rax)
je 0x1678
testl %r12d, %r12d
js 0x1692
movl %r12d, %edi
callq 0x1483
movq %rax, %r13
movl %r12d, %edi
callq 0x1502
movq %rax, %rbx
movl %r12d, %edi
callq 0x1456
movq 0x8(%r14), %rcx
movq (%rcx,%r15,8), %r8
xorl %r12d, %r12d
leaq 0xa09(%rip), %rdi       # 0x2063
movq %r13, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
incq %r15
movslq 0x10(%r14), %rax
cmpq %rax, %r15
jl 0x15fe
jmp 0x1680
xorl %r12d, %r12d
jmp 0x162a
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1148
movl $0x1, %r12d
jmp 0x1680
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: selftest
static int
selftest(void)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	char hbuf_hex[41];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing SHA1 of \"%s\"...", tests[i].s);
		SHA1_Init(&ctx);
		SHA1_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		SHA1_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 20);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed SHA1: %s\n", hbuf_hex);
			printf("Correct SHA1:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl $0x8, %ebx
leaq 0x4c(%rsp), %r14
leaq 0x20(%rsp), %r12
xorl %r15d, %r15d
leaq 0x63f9(%rip), %rax      # 0x7d60
movq -0x8(%rbx,%rax), %rbp
movq (%rbx,%rax), %r13
leaq 0x3750(%rip), %rdi      # 0x50c7
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x2040
movq %rbp, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x205b
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2d56
movl $0x14, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x36b4
movq %r12, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x19ff
leaq 0x3a82(%rip), %rdi      # 0x5455
callq 0x1090
leaq 0x3702(%rip), %rdi      # 0x50e1
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x3704(%rip), %rdi      # 0x50f4
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x1a0b
leaq 0x3a46(%rip), %rdi      # 0x544c
callq 0x1090
addq $0x10, %rbx
cmpq $0x98, %rbx
jne 0x1960
xorl %eax, %eax
testq %r15, %r15
setne %al
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/sha1/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	SHA1_CTX ctx;
	uint8_t hbuf[20];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	SHA1_Init(&ctx);
	for (i = 0; i < nreps; i++)
		SHA1_Update(&ctx, buf, buflen);
	SHA1_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1c(%rsp), %rdi
callq 0x2040
testq %rbx, %rbx
je 0x2022
leaq 0x1c(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x205b
decq %rbx
jne 0x200f
movq %rsp, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x2d56
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_SHA1_Final
void
SHA1_Final(uint8_t digest[20], SHA1_CTX * ctx)
{

	/* Add padding. */
	SHA1_Pad(ctx);

	/* Write the hash. */
	be32enc_vect(digest, ctx->state, 20);

	/* Clear the context state. */
	insecure_memzero(ctx, sizeof(SHA1_CTX));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl 0x14(%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%rsp,%rax,4)
incq %rax
cmpq $0x2, %rax
jne 0x2d62
movl 0x18(%rbx), %eax
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
leaq 0x537c(%rip), %rsi      # 0x8110
movq %rbx, %rdi
callq 0x205b
movq %rsp, %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x205b
xorl %eax, %eax
movl (%rbx,%rax,4), %ecx
bswapl %ecx
movl %ecx, (%r14,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x2dae
leaq 0x53d1(%rip), %rax      # 0x8198
movq (%rax), %rax
movl $0x5c, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_SHA1_Buf
void
SHA1_Buf(const void * in, size_t len, uint8_t digest[20])
{
	SHA1_CTX ctx;

	SHA1_Init(&ctx);
	SHA1_Update(&ctx, in, len);
	SHA1_Final(digest, &ctx);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %r14
movl $0x0, 0x18(%r14)
movaps 0x2683(%rip), %xmm0     # 0x5480
movaps %xmm0, (%r14)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x205b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d56
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Init
void
HMAC_SHA1_Init(HMAC_SHA1_CTX * ctx, const void * _k, size_t Klen)
{
	uint8_t pad[64];
	uint8_t khash[20];
	const uint8_t * K = _k;
	size_t i;

	/* If Klen > 64, the key is really SHA1(K). */
	if (Klen > 64) {
		SHA1_Init(&ctx->ictx);
		SHA1_Update(&ctx->ictx, K, Klen);
		SHA1_Final(khash, &ctx->ictx);
		K = khash;
		Klen = 20;
	}

	/* Inner SHA1 operation is SHA1(K xor [block of 0x36] || data). */
	SHA1_Init(&ctx->ictx);
	memset(pad, 0x36, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->ictx, pad, 64);

	/* Outer SHA1 operation is SHA1(K xor [block of 0x5c] || hash). */
	SHA1_Init(&ctx->octx);
	memset(pad, 0x5c, 64);
	for (i = 0; i < Klen; i++)
		pad[i] ^= K[i];
	SHA1_Update(&ctx->octx, pad, 64);

	/* Clean the stack. */
	insecure_memzero(khash, 20);
	insecure_memzero(pad, 64);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x41, %rdx
jb 0x2e81
movl $0x0, 0x18(%r15)
movaps 0x2630(%rip), %xmm0     # 0x5480
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x205b
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d56
movl $0x14, %r14d
movl $0x0, 0x18(%r15)
movaps 0x25f0(%rip), %xmm0     # 0x5480
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %r13d      # imm = 0xC3D2E1F0
movq %r13, 0x10(%r15)
movaps 0x25eb(%rip), %xmm0     # 0x5490
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %r14, %r14
je 0x2ecd
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %r14
jne 0x2ebf
movq %rsp, %r12
movl $0x40, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x205b
leaq 0x5c(%r15), %rdi
movl $0x0, 0x74(%r15)
movaps 0x258d(%rip), %xmm0     # 0x5480
movups %xmm0, 0x5c(%r15)
movq %r13, 0x6c(%r15)
movaps 0x259d(%rip), %xmm0     # 0x54a0
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
testq %r14, %r14
je 0x2f2f
xorl %eax, %eax
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %r14
jne 0x2f21
movq %rsp, %rbx
movl $0x40, %edx
movq %rbx, %rsi
callq 0x205b
leaq 0x5252(%rip), %r14      # 0x8198
movq (%r14), %rax
leaq 0x40(%rsp), %rdi
movl $0x14, %esi
callq *%rax
movq (%r14), %rax
movl $0x40, %esi
movq %rbx, %rdi
callq *%rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/liball/../alg/sha1.c
// Function: libcperciva_HMAC_SHA1_Final
void
HMAC_SHA1_Final(uint8_t digest[20], HMAC_SHA1_CTX * ctx)
{
	uint8_t ihash[20];

	/* Finish the inner SHA1 operation. */
	SHA1_Final(ihash, &ctx->ictx);

	/* Feed the inner hash to the outer SHA1 operation. */
	SHA1_Update(&ctx->octx, ihash, 20);

	/* Finish the outer SHA1 operation. */
	SHA1_Final(digest, &ctx->octx);

	/* Clean the stack. */
	insecure_memzero(ihash, 20);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2d56
addq $0x5c, %rbx
movl $0x14, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x205b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2d56
leaq 0x51e3(%rip), %rax      # 0x8198
movq (%rax), %rax
movl $0x14, %esi
movq %r15, %rdi
callq *%rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/ast.c
// Function: astn_del
void astn_del(ast_n *node) {
	if (node == NULL)
		return;

	//note: don't delete symbols here
	switch (node->kind) {
		case DECL:
			astn_del(node->dat.decl.init);
			astn_del(node->dat.decl.block);
			astn_del(node->dat.decl.next);
			break;
		case EXPR:
			if (node->dat.expr.type != NULL)
				type_del(node->dat.expr.type);
			astn_del(node->dat.expr.left);
			astn_del(node->dat.expr.right);
			break;
		case STMT:
			if (node->dat.stmt.lbl != NULL)
				free(node->dat.stmt.lbl);
			astn_del(node->dat.stmt.expr);
			astn_del(node->dat.stmt.body);
			astn_del(node->dat.stmt.else_body);
			break;
	}
	astn_del(node->next);

	//Free node data type tags
	if (node->tok.dtype != NULL)
		type_del(node->tok.dtype);

	free(node);
	return;
}

// Assembly:
testq %rdi, %rdi
je 0x35cc
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x35dd
cmpl $0x1, %eax
je 0x35cd
testl %eax, %eax
je 0x35eb
jmp 0x3606
retq
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35f4
callq 0xc233
jmp 0x35f4
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x35eb
callq 0x3030
movq 0x18(%rbx), %rdi
callq 0x35b1
movq 0x20(%rbx), %rdi
callq 0x35b1
movq 0x28(%rbx), %rdi
callq 0x35b1
movq 0x60(%rbx), %rdi
callq 0x35b1
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x361d
callq 0xc233
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/eval.c
// Function: do_op
long long do_op(int op, int lhs, int rhs, int trs) {
	switch (op) {
		case TOK_QMK:		return (lhs) ? rhs : trs;
		case TOK_NOT:		return !lhs;
		case TOK_TLD:		return ~lhs;
		case TOK_ASR:		return lhs * rhs;
		case TOK_DIV:		return lhs / rhs;
		case TOK_MOD:		return lhs % rhs;
		case TOK_ADD:		return lhs + rhs;
		case TOK_SUB:		return lhs - rhs;
		case TOK_LSHIFT:	return lhs << rhs;
		case TOK_RSHIFT:	return lhs >> rhs;
		case TOK_GTH:		return lhs > rhs;
		case TOK_LTH:		return lhs < rhs;
		case TOK_GEQ:		return lhs >= rhs;
		case TOK_LEQ:		return lhs <= rhs;
		case TOK_EQ: 		return lhs == rhs;
		case TOK_NEQ:		return lhs != rhs;
		case TOK_AND:		return lhs & rhs;
		case TOK_XOR:		return lhs ^ rhs;
		case TOK_OR:		return lhs | rhs;
		case TOK_LOGIC_AND:	return lhs && rhs;
		case TOK_LOGIC_OR:	return lhs || rhs;
		case TOK_CMM:		return lhs, rhs;
	}
	return -1;
}

// Assembly:
movq $-0x1, %rax
addl $-0x3, %edi
cmpl $0x23, %edi
ja 0x394c
movl %edx, %r8d
leaq 0x9809(%rip), %rdx      # 0xd0bc
movslq (%rdx,%rdi,4), %rdi
addq %rdx, %rdi
jmpq *%rdi
testl %esi, %esi
cmovel %ecx, %r8d
jmp 0x3949
testl %esi, %esi
setne %al
testl %r8d, %r8d
setne %cl
andb %al, %cl
movzbl %cl, %eax
retq
movl %r8d, %ecx
sarl %cl, %esi
jmp 0x3962
xorl %eax, %eax
cmpl %r8d, %esi
setle %al
retq
notl %esi
jmp 0x3962
xorl %eax, %eax
cmpl %r8d, %esi
setg %al
retq
xorl %eax, %eax
testl %esi, %esi
jmp 0x3932
addl %esi, %r8d
jmp 0x3949
movl %esi, %eax
cltd
idivl %r8d
cltq
retq
xorl %eax, %eax
cmpl %r8d, %esi
setl %al
retq
movl %esi, %eax
cltd
idivl %r8d
movslq %edx, %rax
retq
andl %esi, %r8d
jmp 0x3949
xorl %eax, %eax
cmpl %r8d, %esi
setge %al
retq
xorl %eax, %eax
cmpl %r8d, %esi
sete %al
retq
subl %r8d, %esi
jmp 0x3962
imull %esi, %r8d
jmp 0x3949
xorl %esi, %r8d
jmp 0x3949
orl %esi, %r8d
movslq %r8d, %rax
retq
xorl %eax, %eax
orl %esi, %r8d
jmp 0x3959
xorl %eax, %eax
cmpl %r8d, %esi
setne %al
retq
movl %r8d, %ecx
shll %cl, %esi
movslq %esi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/eval.c
// Function: do_calc
void do_calc(vector *ops, vector *vals) {
	int op = (long long)vector_pop(ops);
	int trs = (op == TOK_QMK) ? (long long)vector_pop(vals) : 0;
	int rhs = (!is_unary(op)) ? (long long)vector_pop(vals) : 0;
	int lhs = (long long)vector_pop(vals);
	long long res = do_op(op, lhs, rhs, trs);
	vector_push(vals, (void*)res);
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xc9d7
movq %rax, %r14
xorl %r15d, %r15d
cmpl $0x20, %r14d
jg 0x3996
cmpl $0xf, %r14d
je 0x39aa
movl $0x0, %r12d
cmpl $0x18, %r14d
je 0x39c5
jmp 0x39b5
cmpl $0x21, %r14d
je 0x39c2
movl $0x0, %r12d
cmpl $0x32, %r14d
je 0x39c5
jmp 0x39b5
movq %rbx, %rdi
callq 0xc9d7
movq %rax, %r15
movq %rbx, %rdi
callq 0xc9d7
movq %rax, %r12
jmp 0x39c5
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0xc9d7
movl %r14d, %edi
movl %eax, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x3896
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xc9d2
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/eval.c
// Function: eval_constexpr_ast
int _eval_constexpr_ast(ast_n *node, int *err) {
	if (node == NULL) return 0;

	//Perform action
	s_pos *loc = &node->tok.loc;
	int l_res = _eval_constexpr_ast(node->dat.expr.left, err);
	int r_res = _eval_constexpr_ast(node->dat.expr.right, err);
	int t_res = 0;
	switch (node->dat.expr.kind) {
		case EXPR_COND: {
			ast_n *res = node->dat.expr.right;
			r_res = _eval_constexpr_ast(res->dat.expr.left, err);
			t_res = _eval_constexpr_ast(res->dat.expr.right, err);
			}
			return do_op(node->tok.type, l_res, r_res, t_res); 
		case EXPR_COND_RES:
			return 0;
		case EXPR_LOGIC_OR:
		case EXPR_LOGIC_AND:
		case EXPR_OR:
		case EXPR_XOR:
		case EXPR_AND:
		case EXPR_GTH:
		case EXPR_LTH:
		case EXPR_GEQ:
		case EXPR_LEQ:
		case EXPR_LSHIFT:
		case EXPR_RSHIFT:
		case EXPR_EQ:
		case EXPR_NEQ:
		case EXPR_ADD:
		case EXPR_SUB:
		case EXPR_MUL:
		case EXPR_DIV:
			return do_op(node->tok.type, l_res, r_res, 0);
		case EXPR_MOD:
		case EXPR_POS:
		case EXPR_NEG:
		case EXPR_NOT:
		case EXPR_LOGIC_NOT:
			return do_op(node->tok.type, l_res, 0, 0);
			break;
		case EXPR_CAST:
		case EXPR_REF:
		case EXPR_DEREF:
		case EXPR_INC_PRE:
		case EXPR_DEC_PRE:
		case EXPR_ARRAY:
		case EXPR_CALL:
		case EXPR_MEMB:
		case EXPR_PTR_MEMB:
		case EXPR_INC_POST:
		case EXPR_DEC_POST:
			c_error(loc, "Invalid operation in constant expression\n");
			return 0;
		case EXPR_IDENT:
			c_error(loc, "Identifier in constant expression\n");
			return 0;
		case EXPR_CONST:
			if (node->tok.dtype->kind == TYPE_FLOAT)
				c_error(loc, "Floating point value in constant expression\n");
			return node->tok.dat.ival;
		default:
			c_error(loc, "Invalid constant expression\n");
			break;
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x3dda
movq %rsi, %r12
movq %rdi, %r14
leaq 0x38(%rdi), %r15
movq 0x20(%rdi), %rdi
callq 0x3d5a
movl %eax, %ebp
movq 0x28(%r14), %rdi
movq %r12, %rsi
callq 0x3d5a
movl 0x8(%r14), %ecx
decl %ecx
cmpl $0x24, %ecx
ja 0x3e38
leaq 0x93ac(%rip), %rdx      # 0xd14c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x30(%r14), %edi
movl %ebp, %esi
movl %eax, %edx
jmp 0x3dd0
leaq 0x9560(%rip), %rsi      # 0xd31a
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
jmp 0x3dda
movl 0x30(%r14), %edi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3896
movq %rax, %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r14), %r15
movq 0x20(%r15), %rdi
movq %r12, %rsi
callq 0x3d5a
movl %eax, %ebx
movq 0x28(%r15), %rdi
movq %r12, %rsi
callq 0x3d5a
movl 0x30(%r14), %edi
movl %ebp, %esi
movl %ebx, %edx
movl %eax, %ecx
jmp 0x3dd2
leaq 0x95dd(%rip), %rsi      # 0xd3f3
jmp 0x3dba
movq 0x58(%r14), %rax
cmpl $0x7, (%rax)
jne 0x3e32
leaq 0x947c(%rip), %rsi      # 0xd2a4
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
movl 0x50(%r14), %ebx
jmp 0x3dda
leaq 0x95d7(%rip), %rsi      # 0xd416
movq %r15, %rdi
xorl %eax, %eax
callq 0x3250
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3dda
// File: /workspace/github_c_makefile_star2_O3/Yamsman[P]scc/src/eval.c
// Function: eval_constexpr_ast
int eval_constexpr_ast(ast_n *root, int *err) {
	int eflag_prev = c_errflag;
	int res = _eval_constexpr_ast(root, err);
	*err = !eflag_prev && c_errflag;
	return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x10616(%rip), %r14     # 0x14474
cmpl $0x0, (%r14)
sete %bpl
callq 0x3d5a
cmpl $0x0, (%r14)
setne %cl
andb %bpl, %cl
movzbl %cl, %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop