LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1018b0, %edi         # imm = 0x1018B0
callq 0x1160
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x97f0
movq -0x8(%rbp), %rax
movl $0x0, 0x101808(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10180c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x101830(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x101888(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x101890(%rax)
movq -0x8(%rbp), %rax
movq $0x100000, 0x101898(%rax) # imm = 0x100000
movq -0x8(%rbp), %rax
movb $0x0, 0x1018a0(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x1018a8(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x101810, %rsi         # imm = 0x101810
callq 0x9330
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
callq 0x9330
movq -0x8(%rbp), %rdi
addq $0x101878, %rdi         # imm = 0x101878
callq 0x9560
movq -0x8(%rbp), %rdi
leaq 0x49fd(%rip), %rsi      # 0xe1c1
movl $0x6, %edx
callq 0x75a0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x101870(%rax)
movq -0x8(%rbp), %rdi
callq 0x68a0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x73f0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x101810, %rsi         # imm = 0x101810
callq 0x9360
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x101820, %rsi         # imm = 0x101820
callq 0x9360
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x101880(%rcx), %eax
jge 0x98bc
movq -0x8(%rbp), %rax
movq 0x101878(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x98af
movq -0x8(%rbp), %rax
movq 0x101878(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x1030
jmp 0x98b1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9864
movq -0x8(%rbp), %rdi
addq $0x101878, %rdi         # imm = 0x101878
callq 0x9590
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluInterpret
bluInterpretResult bluInterpret(bluVM* vm, const char* source, const char* name) {
	bluObjFunction* function = bluCompile(vm, source, name);
	bluObjClosure* closure = newClosure(vm, function);

	if (function == NULL) {
		return INTERPRET_COMPILE_ERROR;
	} else {
		callValue(vm, OBJ_VAL(closure), 0);

		return run(vm);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2850
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7940
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x992a
movl $0x1, -0x4(%rbp)
jmp 0x9957
movq -0x10(%rbp), %rdi
movl $0x3, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
xorl %ecx, %ecx
callq 0x9960
movq -0x10(%rbp), %rdi
callq 0x9c50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %esi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl -0x18(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
leaq 0x3a03(%rip), %rcx      # 0xfcc8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x101838(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movq -0x20(%rbp), %rax
movq 0x101840(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movq -0x20(%rbp), %rax
movq 0x101848(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0xc370
testb $0x1, %al
jne 0xc31b
jmp 0xc32c
movq -0x20(%rbp), %rax
movq 0x101858(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x7, %edx
callq 0xc370
testb $0x1, %al
jne 0xc343
jmp 0xc354
movq -0x20(%rbp), %rax
movq 0x101868(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xc362
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x101810, %rax         # imm = 0x101810
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
callq 0x75a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x28(%rbp), %rcx
callq 0x8db0
testb $0x1, %al
jne 0xc410
movq $0x0, -0x8(%rbp)
jmp 0xc428
cmpl $0x3, -0x28(%rbp)
je 0xc420
movq $0x0, -0x8(%rbp)
jmp 0xc428
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluDefineMethod
bool bluDefineMethod(bluVM* vm, bluObj* obj, const char* name, bluNativeFn function, int8_t arity) {
	if (obj->type != OBJ_CLASS) {
		return false;
	}

	bluObjNative* native = bluNewNative(vm, function, arity);

	bluObjClass* class = (bluObjClass*)obj;
	return bluTableSet(vm, &class->methods, bluCopyString(vm, name, strlen(name)), OBJ_VAL(native));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0xc470
movb $0x0, -0x1(%rbp)
jmp 0xc4f4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movsbl -0x29(%rbp), %edx
callq 0x7a70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl %eax, %edx
callq 0x75a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movl $0x3, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %ecx
movq -0x48(%rbp), %r8
callq 0x8ef0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: bluDefineStaticMethod
bool bluDefineStaticMethod(bluVM* vm, bluObj* obj, const char* name, bluNativeFn function, int8_t arity) {
	if (obj->type != OBJ_CLASS) {
		return false;
	}

	bluObjNative* native = bluNewNative(vm, function, arity);

	bluObjClass* class = (bluObjClass*)obj;
	return bluTableSet(vm, &class->fields, bluCopyString(vm, name, strlen(name)), OBJ_VAL(native));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0xc530
movb $0x0, -0x1(%rbp)
jmp 0xc5b4
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movsbl -0x29(%rbp), %edx
callq 0x7a70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10c0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl %eax, %edx
callq 0x75a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movl $0x3, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %ecx
movq -0x48(%rbp), %r8
callq 0x8ef0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10c0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl %eax, %edx
callq 0x75a0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0x101878, %rdi         # imm = 0x101878
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x96a0
addq $0x70, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: runtimeError
static void runtimeError(bluVM* vm, const char* format, ...) {
	va_list args;
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fputs("\n", stderr);

	for (int i = vm->frameCount - 1; i >= 0; i--) {
		bluCallFrame* frame = &vm->frames[i];
		bluObjFunction* function = frame->closure->function;

		// -1 because the IP is sitting on the next instruction to be executed.
		size_t instruction = frame->ip - function->chunk.code.data - 1;

		fprintf(stderr, "[line %d] in ", function->chunk.lines.data[instruction]);
		fprintf(stderr, "%s\n", function->chunk.name);
	}

	resetStack(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0xc68e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x791b(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11b0
leaq -0x30(%rbp), %rax
movq 0x7900(%rip), %rax      # 0x13ff8
movq (%rax), %rsi
leaq 0x1927(%rip), %rdi      # 0xe029
callq 0x10f0
movq -0x8(%rbp), %rax
movl 0x101808(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xc7b9
movq -0x8(%rbp), %rax
addq $0x100008, %rax         # imm = 0x100008
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x48(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
movq 0x788d(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x50(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x35d2(%rip), %rsi      # 0xfd56
movb $0x0, %al
callq 0x1130
movq 0x7866(%rip), %rax      # 0x13ff8
movq (%rax), %rdi
movq -0x48(%rbp), %rax
movq 0x30(%rax), %rdx
leaq 0x19c6(%rip), %rsi      # 0xe16a
movb $0x0, %al
callq 0x1130
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc717
movq -0x8(%rbp), %rdi
callq 0x97f0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movsbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
jge 0xc824
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movsbl 0x20(%rax), %edx
movsbl -0x19(%rbp), %ecx
leaq 0x350a(%rip), %rsi      # 0xfd1e
movb $0x0, %al
callq 0xc650
movb $0x0, -0x1(%rbp)
jmp 0xc8c5
movq -0x10(%rbp), %rax
cmpl $0x100, 0x101808(%rax)  # imm = 0x100
jne 0xc84c
movq -0x10(%rbp), %rdi
leaq 0x3525(%rip), %rsi      # 0xfd64
movb $0x0, %al
callq 0xc650
movb $0x0, -0x1(%rbp)
jmp 0xc8c5
movq -0x10(%rbp), %rax
addq $0x100008, %rax         # imm = 0x100008
movq -0x10(%rbp), %rdx
movl 0x101808(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x101808(%rdx)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x100000(%rax), %rcx
movsbl -0x19(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
subq %rdx, %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x8db0
testb $0x1, %al
jne 0xc9e1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x28, %rdx
leaq 0x357a(%rip), %rsi      # 0xff4e
movb $0x0, %al
callq 0xc650
movb $0x0, -0x1(%rbp)
jmp 0xca34
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc910
movq -0x60(%rbp), %rdi
movl %eax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movl -0x48(%rbp), %esi
movq -0x40(%rbp), %rdx
callq 0x7830
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x58(%rbp), %esi
movq -0x50(%rbp), %rdx
callq 0xc8d0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: invoke
static bool invoke(bluVM* vm, bluObjString* name, int8_t argCount) {
	bluValue receiver = bluPeek(vm, argCount);

	if (IS_INSTANCE(receiver)) {
		bluValue value;
		if (bluTableGet(vm, &AS_INSTANCE(receiver)->fields, name, &value)) {
			return callValue(vm, value, argCount);
		}
	} else if (IS_CLASS(receiver)) {
		bluValue value;
		if (bluTableGet(vm, &AS_CLASS(receiver)->fields, name, &value)) {
			return callValue(vm, value, argCount);
		}
	}

	bluObjClass* class = bluGetClass(vm, receiver);
	return invokeFromClass(vm, class, name, argCount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movsbl -0x19(%rbp), %esi
callq 0xc950
movl %eax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movl -0x30(%rbp), %edi
movq -0x28(%rbp), %rsi
movl $0x5, %edx
callq 0xc370
testb $0x1, %al
jne 0xca80
jmp 0xcac1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x8db0
testb $0x1, %al
jne 0xca9f
jmp 0xcabf
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movl -0x40(%rbp), %esi
movq -0x38(%rbp), %rdx
movsbl %al, %ecx
callq 0x9960
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcb46
jmp 0xcb18
movl -0x30(%rbp), %edi
movq -0x28(%rbp), %rsi
movl $0x2, %edx
callq 0xc370
testb $0x1, %al
jne 0xcad8
jmp 0xcb16
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0x8db0
testb $0x1, %al
jne 0xcaf7
jmp 0xcb14
movq -0x10(%rbp), %rdi
movb -0x19(%rbp), %al
movl -0x50(%rbp), %esi
movq -0x48(%rbp), %rdx
movsbl %al, %ecx
callq 0x9960
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcb46
jmp 0xcb16
jmp 0xcb18
movq -0x10(%rbp), %rdi
movl -0x30(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0xc2a0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdx
movsbl -0x19(%rbp), %ecx
callq 0xcb60
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x8db0
testb $0x1, %al
jne 0xcbe6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xcbc6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x20(%rbp), %rdx
movsbl -0x21(%rbp), %ecx
callq 0xcb60
testb $0x1, %al
jne 0xcbc0
jmp 0xcbc6
movb $0x1, -0x1(%rbp)
jmp 0xcc30
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
addq $0x28, %rdx
leaq 0x3375(%rip), %rsi      # 0xff4e
movb $0x0, %al
callq 0xc650
movb $0x0, -0x1(%rbp)
jmp 0xcc30
movl -0x38(%rbp), %edi
movq -0x30(%rbp), %rsi
movl $0x6, %edx
callq 0xc370
testb $0x1, %al
jne 0xcbfd
jmp 0xcc1a
movq -0x10(%rbp), %rdi
movb -0x21(%rbp), %al
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
movsbl %al, %ecx
callq 0x9960
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xcc30
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movsbl -0x21(%rbp), %edx
callq 0xc7d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: concatenate
static void concatenate(bluVM* vm) {
	bluObjString* right = AS_STRING(bluPop(vm));
	bluObjString* left = AS_STRING(bluPop(vm));

	int32_t length = left->length + right->length;
	bluObjString* string = bluNewString(vm, length);
	memcpy(string->chars, left->chars, left->length);
	memcpy(string->chars + left->length, right->chars, right->length);
	string->chars[length] = '\0';

	bluObjString* result = bluTakeString(vm, string);

	bluPush(vm, OBJ_VAL(result));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc910
movl %eax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc910
movl %eax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x20(%rcx), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x7ad0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rax
movslq 0x20(%rax), %rdx
callq 0x1150
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq -0x28(%rbp), %rax
movslq 0x20(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x10(%rbp), %rax
movslq 0x20(%rax), %rdx
callq 0x1150
movq -0x48(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb $0x0, 0x28(%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x7bb0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3, -0x60(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x60(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0xc8d0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: closeUpvalues
static void closeUpvalues(bluVM* vm, bluValue* last) {
	while (vm->openUpvalues != NULL && vm->openUpvalues->value >= last) {
		bluObjUpvalue* upvalue = vm->openUpvalues;

		// Move the value into the upvalue itself and point the upvalue to it.
		upvalue->closed = *upvalue->value;
		upvalue->value = &upvalue->closed;

		// Pop it off the open upvalue list.
		vm->openUpvalues = upvalue->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x101830(%rcx)
movb %al, -0x19(%rbp)
je 0xcd68
movq -0x8(%rbp), %rax
movq 0x101830(%rax), %rax
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
setae %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xcd71
jmp 0xcdc3
movq -0x8(%rbp), %rax
movq 0x101830(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, 0x28(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
addq $0x28, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x101830(%rax)
jmp 0xcd3c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: captureUpvalue
static bluObjUpvalue* captureUpvalue(bluVM* vm, bluValue* local) {
	// If there are no open upvalues at all, we must need a new one.
	if (vm->openUpvalues == NULL) {
		vm->openUpvalues = bluNewUpvalue(vm, local);
	}

	bluObjUpvalue* prevUpvalue = NULL;
	bluObjUpvalue* upvalue = vm->openUpvalues;

	// Walk towards the bottom of the stack until we find a previously existing upvalue or reach where it should be.
	while (upvalue != NULL && upvalue->value > local) {
		prevUpvalue = upvalue;
		upvalue = upvalue->next;
	}

	// If we found it, reuse it.
	if (upvalue != NULL && upvalue->value == local) return upvalue;

	// We walked past the local on the stack, so there must not be an upvalue for it already. Make a new one and link it
	// in in the right place to keep the list sorted.
	bluObjUpvalue* createdUpvalue = bluNewUpvalue(vm, local);
	createdUpvalue->next = upvalue;

	if (prevUpvalue == NULL) {
		// The new one is the first one in the list.
		vm->openUpvalues = createdUpvalue;
	} else {
		prevUpvalue->next = createdUpvalue;
	}

	return createdUpvalue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x101830(%rax)
jne 0xce09
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b40
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x101830(%rax)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x101830(%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0xce3e
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
seta %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xce47
jmp 0xce5d
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xce20
cmpq $0x0, -0x28(%rbp)
je 0xce7c
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0xce7c
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcec5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7b40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xceb1
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x101830(%rax)
jmp 0xcebd
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/adamjedlicka[P]blu/src/vm/vm.c
// Function: importModule
static bool importModule(bluVM* vm, bluObjString* moduleName) {
	for (int32_t i = 0; i < vm->modules.count; i++) {
		if (bluValuesEqual(OBJ_VAL(moduleName), OBJ_VAL(vm->modules.data[i].name))) {
			bluModule* module = &vm->modules.data[i];

			if (module->loaded == true) return true;

			module->loaded = true;

			int32_t frameCountStart = vm->frameCountStart;
			vm->frameCountStart = vm->frameCount;

			module->loader(vm);

			vm->frameCountStart = frameCountStart;

			return true;
		}
	}

	runtimeError(vm, "No such module '%s'", moduleName->chars);

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x101880(%rcx), %eax
jge 0xd001
movl $0x3, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x3, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x101878(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x30(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0x93b0
testb $0x1, %al
jne 0xcf76
jmp 0xcff1
movq -0x10(%rbp), %rax
movq 0x101878(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xcfa7
movb $0x1, -0x1(%rbp)
jmp 0xd01f
movq -0x48(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x10180c(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movl 0x101808(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10180c(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl -0x4c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10180c(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xd01f
jmp 0xcff3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcf17
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x28, %rdx
leaq 0x2f53(%rip), %rsi      # 0xff67
movb $0x0, %al
callq 0xc650
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, %al
callq 0x57f0
leaq -0x30(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x7883(%rip), %rdi      # 0xbf58
leaq -0x30(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
movl $0x2, %edi
callq 0x3f10
xorl %edi, %edi
callq 0x4740
movb $0x0, %al
callq 0x5860
movb $0x0, %al
callq 0x5b90
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x471c
movl -0xc(%rbp), %esi
leaq 0x2eb6(%rip), %rdi      # 0x75cb
movb $0x0, %al
callq 0x2080
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x2470
cmpl $0x3, -0xc(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tyabu12[P]pl0compiler/compile.c
// Function: block
void block(int pIndex) {        /* pIndex はこのブロックの関数名のインデックス */
    int backP;
    backP = genCodeV(jmp, 0);   /* 内部関数を飛び越す命令、後でバックパッチ */
    while (1) {                 /* 宣言部のコンパイルを繰り返す         */
        switch (token.kind) {
        case Const:             /* 定数宣言部のコンパイル               */
            token = nextToken();
            constDecl(); continue;
        case Var:               /* 変数宣言部のコンパイル               */
            token = nextToken();
            varDecl(); continue;
        case Func:              /* 関数宣言部のコンパイル               */
            token = nextToken();
            funcDecl(); continue;
        default:                /* それ以外なら宣言部は終わり           */
            break;
        }
        break;
    }
    backPatch(backP);           /* 内部関数を飛び越す命令にパッチ       */
    changeV(pIndex, nextCode()); /* この関数の開始番地を修正            */
    genCodeV(ict, frameL());    /* このブロックの実行時の必要記憶域をとる命令 */
    statement();                /* このブロックの主文                   */
    genCodeR();                 /* リターン命令                         */
    blockEnd();                 /* ブロックが終ったことをtableに連絡    */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl $0x7, %edi
xorl %esi, %esi
callq 0x2260
movl %eax, -0x8(%rbp)
movl 0x77f5(%rip), %eax      # 0xbf58
movl %eax, -0x78(%rbp)
subl $0x7, %eax
je 0x47cf
jmp 0x476d
movl -0x78(%rbp), %eax
subl $0x8, %eax
je 0x47a8
jmp 0x4777
movl -0x78(%rbp), %eax
subl $0x9, %eax
jne 0x47f9
jmp 0x4781
leaq -0x2c(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x77c5(%rip), %rdi      # 0xbf58
leaq -0x2c(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x4850
jmp 0x475d
leaq -0x50(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x779e(%rip), %rdi      # 0xbf58
leaq -0x50(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x49d0
jmp 0x475d
leaq -0x74(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x7777(%rip), %rdi      # 0xbf58
leaq -0x74(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x4ac0
jmp 0x475d
jmp 0x47fb
jmp 0x47fd
movl -0x8(%rbp), %edi
callq 0x2440
movl -0x4(%rbp), %eax
movl %eax, -0x7c(%rbp)
movb $0x0, %al
callq 0x2250
movl -0x7c(%rbp), %edi
movl %eax, %esi
callq 0x4320
movb $0x0, %al
callq 0x4480
movl %eax, %esi
movl $0x6, %edi
callq 0x2260
callq 0x4cd0
movb $0x0, %al
callq 0x2390
movb $0x0, %al
callq 0x3fb0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tyabu12[P]pl0compiler/compile.c
// Function: constDecl
void constDecl() {              /* 定数宣言のコンパイル                 */
    Token temp;
    while (1) {
        if (token.kind == Id) {
            setIdKind(constId); /* 印字のための情報のセット             */
            temp = token;       /* 名前を入れておく                     */
            token = checkGet(nextToken(), Equal); /* 名前の次は"="のはず */
            if (token.kind == Num)
                enterTconst(temp.u.id, token.u.value); /* 定数名と値をテーブルに */
            else
                errorType("number");
            token = nextToken();
        } else
            errorMissingId();
        if (token.kind != Comma) { /* 次がコンマなら定数宣言が続く      */
            if (token.kind == Id) { /* 次が名前ならコンマを忘れたことにする */
                errorInsert(Comma);
                continue;
            } else
                break;
        }
        token = nextToken();
    }
    token = checkGet(token, Semicolon); /* 最後は";"のはず              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
cmpl $0x20, 0x76f6(%rip)     # 0xbf58
jne 0x491f
movl $0x3, %edi
callq 0x6020
leaq -0x24(%rbp), %rdi
leaq 0x76db(%rip), %rsi      # 0xbf58
movl $0x24, %edx
callq 0x20e0
leaq -0x70(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
movl -0x50(%rbp), %ecx
movq %rsp, %rax
movl %ecx, 0x20(%rax)
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0x48(%rbp), %rdi
movl $0x15, %esi
callq 0x5f20
leaq 0x7699(%rip), %rdi      # 0xbf58
leaq -0x48(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
cmpl $0x21, 0x7684(%rip)     # 0xbf58
jne 0x48eb
leaq -0x24(%rbp), %rdi
addq $0x4, %rdi
movl 0x7678(%rip), %esi      # 0xbf5c
callq 0x4250
jmp 0x48f7
leaq 0x2b06(%rip), %rdi      # 0x73f8
callq 0x5940
leaq -0x94(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x764c(%rip), %rdi      # 0xbf58
leaq -0x94(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
jmp 0x4926
movb $0x0, %al
callq 0x5990
cmpl $0x1b, 0x762b(%rip)     # 0xbf58
je 0x4949
cmpl $0x20, 0x7622(%rip)     # 0xbf58
jne 0x4947
movl $0x1b, %edi
callq 0x58a0
jmp 0x485b
jmp 0x4974
leaq -0xb8(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x75fa(%rip), %rdi      # 0xbf58
leaq -0xb8(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
jmp 0x485b
movl 0x75fe(%rip), %ecx      # 0xbf78
movq %rsp, %rax
movl %ecx, 0x20(%rax)
movups 0x75e1(%rip), %xmm0     # 0xbf68
movups %xmm0, 0x10(%rax)
movups 0x75c6(%rip), %xmm0     # 0xbf58
movups %xmm0, (%rax)
leaq -0xdc(%rbp), %rdi
movl $0x1d, %esi
callq 0x5f20
leaq 0x75ab(%rip), %rdi      # 0xbf58
leaq -0xdc(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tyabu12[P]pl0compiler/compile.c
// Function: varDecl
void varDecl() {                /* 変数宣言のコンパイル                 */
    while (1) {
        if (token.kind == Id) {
            setIdKind(varId);   /* 印字のための情報のセット             */
            enterTvar(token.u.id); /* 変数名をテーブルに、番地はtableが決める */
            token = nextToken();
        } else
            errorMissingId();
        if (token.kind != Comma) { /* 次がコンマなら変数宣言が続く      */
            if (token.kind == Id) { /* 次が名前ならコンマを忘れたことにする */
                errorInsert(Comma);
                continue;
            } else
                break;
        }
        token = nextToken();
    }
    token = checkGet(token, Semicolon); /* 最後は";"のはず              */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
cmpl $0x20, 0x7576(%rip)     # 0xbf58
jne 0x4a1d
xorl %edi, %edi
callq 0x6020
leaq 0x7566(%rip), %rdi      # 0xbf58
addq $0x4, %rdi
callq 0x41c0
leaq -0x24(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x754b(%rip), %rdi      # 0xbf58
leaq -0x24(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
jmp 0x4a24
movb $0x0, %al
callq 0x5990
cmpl $0x1b, 0x752d(%rip)     # 0xbf58
je 0x4a44
cmpl $0x20, 0x7524(%rip)     # 0xbf58
jne 0x4a42
movl $0x1b, %edi
callq 0x58a0
jmp 0x49db
jmp 0x4a69
leaq -0x48(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x7502(%rip), %rdi      # 0xbf58
leaq -0x48(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
jmp 0x49db
movl 0x7509(%rip), %ecx      # 0xbf78
movq %rsp, %rax
movl %ecx, 0x20(%rax)
movups 0x74ec(%rip), %xmm0     # 0xbf68
movups %xmm0, 0x10(%rax)
movups 0x74d1(%rip), %xmm0     # 0xbf58
movups %xmm0, (%rax)
leaq -0x6c(%rbp), %rdi
movl $0x1d, %esi
callq 0x5f20
leaq 0x74b9(%rip), %rdi      # 0xbf58
leaq -0x6c(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tyabu12[P]pl0compiler/compile.c
// Function: isStBeginKey
int isStBeginKey(Token t) {     /* トークンtは文の先頭のキーか？        */
    switch (t.kind) {
    case If:
    case Begin:
    case Ret:
    case While:
    case Write:
    case WriteLn:
        return 1;
    default:
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
testl %eax, %eax
je 0x50fe
jmp 0x50d3
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0x50fe
jmp 0x50dd
movl -0x8(%rbp), %eax
subl $0x4, %eax
je 0x50fe
jmp 0x50e7
movl -0x8(%rbp), %eax
subl $0x6, %eax
je 0x50fe
jmp 0x50f1
movl -0x8(%rbp), %eax
addl $-0xc, %eax
subl $0x1, %eax
ja 0x5107
jmp 0x50fe
movl $0x1, -0x4(%rbp)
jmp 0x510e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x6e2a(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
cmpl $0xf, -0x4(%rbp)
je 0x513d
cmpl $0x10, -0x4(%rbp)
jne 0x5171
leaq -0x28(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x6e09(%rip), %rdi      # 0xbf58
leaq -0x28(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x51f0
cmpl $0x10, -0x4(%rbp)
jne 0x516f
xorl %edi, %edi
callq 0x2330
jmp 0x5176
callq 0x51f0
movl 0x6ddc(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0xf, -0x4(%rbp)
movb %al, -0x4d(%rbp)
je 0x5194
cmpl $0x10, -0x4(%rbp)
sete %al
movb %al, -0x4d(%rbp)
movb -0x4d(%rbp), %al
testb $0x1, %al
jne 0x519d
jmp 0x51e9
leaq -0x4c(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x6da9(%rip), %rdi      # 0xbf58
leaq -0x4c(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x51f0
cmpl $0x10, -0x4(%rbp)
jne 0x51d4
movl $0x2, %edi
callq 0x2330
jmp 0x51de
movl $0x1, %edi
callq 0x2330
movl 0x6d74(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
jmp 0x517f
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x5280
movl 0x6d55(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0x11, -0x4(%rbp)
movb %al, -0x29(%rbp)
je 0x521b
cmpl $0x12, -0x4(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5224
jmp 0x5270
leaq -0x28(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x6d22(%rip), %rdi      # 0xbf58
leaq -0x28(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x5280
cmpl $0x11, -0x4(%rbp)
jne 0x525b
movl $0x3, %edi
callq 0x2330
jmp 0x5265
movl $0x4, %edi
callq 0x2330
movl 0x6ced(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
jmp 0x5206
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
cmpl $0xa, 0x6959(%rip)      # 0xbf58
jne 0x5635
leaq -0x28(%rbp), %rdi
movb $0x0, %al
callq 0x5ba0
leaq 0x6945(%rip), %rdi      # 0xbf58
leaq -0x28(%rbp), %rsi
movl $0x24, %edx
callq 0x20e0
callq 0x5120
movl $0x5, %edi
callq 0x2330
jmp 0x5708
callq 0x5120
movl 0x6918(%rip), %eax      # 0xbf58
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x15, %eax
subl $0x5, %eax
ja 0x5652
jmp 0x5650
jmp 0x565e
leaq 0x1db4(%rip), %rdi      # 0x740d
callq 0x5940
xorl %eax, %eax
leaq -0x4c(%rbp), %rdi
callq 0x5ba0
movl -0x2c(%rbp), %eax
movl %eax, 0x6906(%rip)      # 0xbf78
movups -0x4c(%rbp), %xmm0
movups -0x3c(%rbp), %xmm1
movups %xmm1, 0x68e7(%rip)     # 0xbf68
movups %xmm0, 0x68d0(%rip)     # 0xbf58
callq 0x5120
movl -0x4(%rbp), %eax
addl $-0x15, %eax
movl %eax, %ecx
movq %rcx, -0x58(%rbp)
subl $0x5, %eax
ja 0x56fa
movq -0x58(%rbp), %rax
leaq 0x1d37(%rip), %rcx      # 0x73e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x6, %edi
callq 0x2330
jmp 0x5706
movl $0x7, %edi
callq 0x2330
jmp 0x5706
movl $0x8, %edi
callq 0x2330
jmp 0x5706
movl $0x9, %edi
callq 0x2330
jmp 0x5706
movl $0xa, %edi
callq 0x2330
jmp 0x5706
movl $0xb, %edi
callq 0x2330
jmp 0x5706
leaq 0x1d0c(%rip), %rdi      # 0x740d
callq 0x5940
jmp 0x5708
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 $0xa0, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq -0x98(%rbp), %rsi
callq 0x10e0
cmpl $0x0, %eax
jge 0x1521
movq 0x2b0f(%rip), %rax      # 0x3ff8
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x10d0
movq -0xa0(%rbp), %rdi
movq %rax, %rdx
leaq 0xb52(%rip), %rsi       # 0x2062
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x1030, %rsp           # imm = 0x1030
movl %edi, -0x4(%rbp)
movq $0x0, -0x1018(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1060
movl -0x4(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0xfff, %edx            # imm = 0xFFF
callq 0x1070
movq %rax, -0x1020(%rbp)
cmpq $0x0, %rax
jle 0x15d1
movq $0x0, -0x1028(%rbp)
movq -0x1028(%rbp), %rax
cmpq -0x1020(%rbp), %rax
jae 0x15cf
movq -0x1028(%rbp), %rax
movsbl -0x1010(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x15b9
movq -0x1018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1018(%rbp)
jmp 0x15bb
movq -0x1028(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1028(%rbp)
jmp 0x1583
jmp 0x1557
movq -0x1018(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x1030, %rsp           # imm = 0x1030
movl %edi, -0x4(%rbp)
movq $0x0, -0x1018(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1060
movl -0x4(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x1070
movq %rax, -0x1020(%rbp)
cmpq $0x0, %rax
jle 0x16db
movq $0x1, -0x1028(%rbp)
movq -0x1028(%rbp), %rax
cmpq -0x1020(%rbp), %rax
jae 0x16d6
callq 0x10f0
movq (%rax), %rax
movq -0x1028(%rbp), %rcx
subq $0x1, %rcx
movsbl -0x1010(%rbp,%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x16bd
callq 0x10f0
movq (%rax), %rax
movq -0x1028(%rbp), %rcx
movsbl -0x1010(%rbp,%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x16bd
movq -0x1018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1018(%rbp)
jmp 0x16bf
movq -0x1028(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1028(%rbp)
jmp 0x1647
jmp 0x1617
movq -0x1018(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax,%rax)