LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x28, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movl (%rsi), %eax
incl %eax
cvtsi2sd %eax, %xmm0
movl 0x4(%rsi), %esi
leal 0x1(%rsi), %eax
cvtsi2sd %eax, %xmm1
mulsd 0x44c4(%rip), %xmm1     # 0xa978
ucomisd %xmm1, %xmm0
jbe 0x6512
leal -0x1(,%rax,2), %ecx
testl %eax, %eax
pushq $0x3f
popq %rbx
cmovnel %ecx, %ebx
leal 0x1(%rbx), %eax
cltq
imulq $0x18, %rax, %rsi
movq %rdi, 0x10(%rsp)
callq 0x557f
testl %ebx, %ebx
pushq $-0x1
popq %rcx
movq %rbx, 0x8(%rsp)
cmovnsl %ebx, %ecx
movq %rax, %rbx
incl %ecx
imulq $0x18, %rcx, %rax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x651b
andq $0x0, (%rbx,%rcx)
movl $0x1, 0x8(%rbx,%rcx)
andq $0x0, 0x10(%rbx,%rcx)
addq $0x18, %rcx
jmp 0x64f4
movq 0x8(%r15), %rbx
jmp 0x65a6
movq %r12, 0x18(%rsp)
movl %ebp, 0x4(%rsp)
movq %r14, 0x20(%rsp)
andl $0x0, (%r15)
pushq $0x8
popq %r14
xorl %r12d, %r12d
movslq 0x4(%r15), %rax
movq 0x8(%r15), %rbp
cmpq %rax, %r12
jg 0x6576
movq -0x8(%rbp,%r14), %r13
testq %r13, %r13
je 0x656d
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x6449
movq %r13, (%rax)
movupd (%rbp,%r14), %xmm0
movupd %xmm0, 0x8(%rax)
incl (%r15)
incq %r12
addq $0x18, %r14
jmp 0x6534
imulq $0x18, %rax, %rdx
addq $0x18, %rdx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x55cc
movq %rbx, 0x8(%r15)
movq 0x8(%rsp), %rsi
movl %esi, 0x4(%r15)
movq 0x20(%rsp), %r14
movl 0x4(%rsp), %ebp
movq 0x18(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x6449
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x65c2
cmpl $0x1, 0x8(%rax)
jne 0x65c2
incl (%r15)
testq %rcx, %rcx
sete %cl
movq %r12, (%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ecx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x660b
pushq %rax
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
callq 0x6449
cmpq $0x0, (%rax)
je 0x660e
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
movb $0x1, 0x10(%rax)
movb $0x1, %al
jmp 0x6610
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %r12
xorl %r13d, %r13d
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jg 0x6662
movq 0x8(%r14), %rax
movq -0x10(%rax,%r12), %rdx
testq %rdx, %rdx
je 0x6659
movl -0x8(%rax,%r12), %ecx
movq (%rax,%r12), %r8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6481
incq %r13
addq $0x18, %r12
jmp 0x662e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x66e9
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
imulq $0x18, %rax, %rax
movq (%r13,%rax), %r12
testq %r12, %r12
je 0x66d8
cmpl %ebp, 0x20(%r12)
jne 0x66e1
cmpl %ebx, 0x24(%r12)
jne 0x66e1
leaq 0x28(%r12), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2190
testl %eax, %eax
jne 0x66e1
jmp 0x66ec
addq %r13, %rax
cmpl $0x1, 0x8(%rax)
je 0x66e9
incl %r14d
andl %r15d, %r14d
jmp 0x669f
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_O2/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 0x674d
movl %edi, %eax
leaq 0x425b(%rip), %rdx      # 0xa998
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
xorl %esi, %ecx
testb $0x1, %cl
jmp 0x6779
xorl %eax, %eax
retq
movq %rsi, %xmm0
movq %rcx, %xmm1
subsd %xmm1, %xmm0
andpd 0x421a(%rip), %xmm0     # 0xa980
movsd 0x4222(%rip), %xmm1     # 0xa990
ucomisd %xmm0, %xmm1
seta %al
retq
cmpq %rcx, %rsi
sete %al
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6803
movl %edi, %eax
leaq 0x4203(%rip), %rcx      # 0xa9a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4203(%rip), %rax      # 0xa9b8
leaq 0x4201(%rip), %rdi      # 0xa9bd
testb $0x1, %sil
cmovneq %rax, %rdi
jmp 0x67fc
movq %rsi, %xmm0
cvttpd2dq %xmm0, %xmm1
cvtdq2pd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x6804
jp 0x6804
cvttsd2si %xmm0, %esi
leaq 0x41e1(%rip), %rdi      # 0xa9c7
xorl %eax, %eax
jmp 0x20f0
pushq $0x3
popq %rdi
jmp 0x5c6c
leaq 0x41c7(%rip), %rdi      # 0xa9c3
xorl %eax, %eax
jmp 0x20f0
retq
leaq 0x41bf(%rip), %rdi      # 0xa9ca
movb $0x1, %al
jmp 0x20f0
nop
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x101808(%rax)
andq $0x0, 0x101830(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x101888(%rax)
movq $0x100000, 0x101898(%rax) # imm = 0x100000
movb $0x0, 0x1018a0(%rax)
andq $0x0, 0x1018a8(%rax)
leaq 0x101810(%rax), %rsi
movq %rax, %rdi
callq 0x66fe
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x66fe
xorps %xmm0, %xmm0
movups %xmm0, 0x101878(%rbx)
leaq 0x2831(%rip), %rsi      # 0x9175
pushq $0x6
popq %rdx
movq %rbx, %rdi
callq 0x58eb
movq %rax, 0x101870(%rbx)
movq %rbx, %rdi
callq 0x51b0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5826
leaq 0x101810(%rbx), %rsi
movq %rbx, %rdi
callq 0x6711
leaq 0x101820(%rbx), %rsi
movq %rbx, %rdi
callq 0x6711
leaq 0x101878(%rbx), %r14
pushq $0x10
popq %r15
xorl %r12d, %r12d
movslq 0x101880(%rbx), %rax
cmpq %rax, %r12
jge 0x69c0
movq (%r14), %rax
movq (%rax,%r15), %rdi
callq 0x2030
incq %r12
addq $0x20, %r15
jmp 0x699f
movq %r14, %rdi
callq 0x681b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 0x2ba7(%rip), %rcx      # 0xaac0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x101840, %rdi         # imm = 0x101840
jmp 0x7f62
addq $0x101848, %rdi         # imm = 0x101848
jmp 0x7f62
movl (%rdx), %eax
cmpl $0x7, %eax
je 0x7f52
cmpl $0x2, %eax
jne 0x7f5b
addq $0x101858, %rdi         # imm = 0x101858
jmp 0x7f62
addq $0x101838, %rdi         # imm = 0x101838
jmp 0x7f62
addq $0x101868, %rdi         # imm = 0x101868
jmp 0x7f62
addq $0x8, %rdx
movq %rdx, %rdi
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x58eb
movq %rsp, %rbx
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x641c
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x3, (%rbx)
movl $0x0, %edx
jne 0x7fb8
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_O2/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:
cmpl $0x2, (%rsi)
jne 0x8025
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movsbl %r8b, %edx
movq %rcx, %rsi
callq 0x5b87
movq %rax, %r12
addq $0x30, %rbx
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x58eb
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6481
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x2, (%rsi)
jne 0x8085
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movsbl %r8b, %edx
movq %rcx, %rsi
callq 0x5b87
movq %rax, %r12
addq $0x40, %rbx
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
movq %r15, %rsi
movl %eax, %edx
callq 0x58eb
pushq $0x3
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6481
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x58eb
addq $0x101878, %r15         # imm = 0x101878
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x682f
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x8157
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
movq 0x6e7a(%rip), %r12      # 0xeff8
movq (%r12), %rdi
callq 0x21d0
movq (%r12), %rsi
leaq 0xe91(%rip), %rdi       # 0x9023
callq 0x2110
movl 0x101808(%rbx), %r13d
imulq $0x18, %r13, %rax
leaq (%rax,%rbx), %rbp
addq $0xffff8, %rbp          # imm = 0xFFFF8
leaq 0xf6a(%rip), %r15       # 0x911e
testl %r13d, %r13d
jle 0x8204
movq -0x8(%rbp), %rax
movq (%rbp), %rcx
movq 0x20(%rax), %r14
movq 0x38(%r14), %rax
notq %rax
movq (%r12), %rdi
shlq $0x2, %rax
addq 0x48(%r14), %rax
movl (%rax,%rcx,4), %edx
leaq 0x296c(%rip), %rsi      # 0xab4e
xorl %eax, %eax
callq 0x2140
movq (%r12), %rdi
movq 0x30(%r14), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x2140
decl %r13d
addq $-0x18, %rbp
jmp 0x81b4
movq %rbx, 0x100000(%rbx)
andl $0x0, 0x101808(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
jle 0x8245
leaq 0x28dc(%rip), %rsi      # 0xab16
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80f3
jmp 0x82a4
movslq 0x101808(%rdi), %rdx
cmpq $0x100, %rdx            # imm = 0x100
jne 0x8267
leaq 0x2900(%rip), %rsi      # 0xab5c
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x80f3
jmp 0x82a4
leal 0x1(%rdx), %r8d
movl %r8d, 0x101808(%rdi)
imulq $0x18, %rdx, %rdx
movq %rsi, 0x100008(%rdi,%rdx)
movq 0x38(%rax), %rax
movq %rax, 0x100010(%rdi,%rdx)
notl %ecx
movslq %ecx, %rax
shlq $0x4, %rax
addq 0x100000(%rdi), %rax
movq %rax, 0x100018(%rdi,%rdx)
movb $0x1, %bl
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x641c
movl %eax, %ebp
testb %al, %al
je 0x830c
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 0x5a43
movq 0x100000(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x100000(%rbx)
movl $0x3, (%rcx)
movq %rax, 0x8(%rcx)
jmp 0x8324
addq $0x28, %r14
leaq 0x2a2f(%rip), %rsi      # 0xad46
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x80f3
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x641c
testb %al, %al
je 0x837b
movq 0x10(%rsp), %rax
cmpl $0x3, 0x8(%rsp)
jne 0x83b6
cmpl $0x6, (%rax)
jne 0x83b6
movsbl %bpl, %ecx
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x7d42
jmp 0x83c5
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x839a
movsbl %bpl, %ecx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x832f
movb $0x1, %bpl
testb %al, %al
jne 0x83c7
addq $0x28, %r14
leaq 0x29a1(%rip), %rsi      # 0xad46
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x80f3
jmp 0x83c7
movsbl %bpl, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8224
movl %eax, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x101830(%rdi), %rax
testq %rax, %rax
je 0x8405
movq 0x20(%rax), %rcx
cmpq %rsi, %rcx
jb 0x8405
leaq 0x28(%rax), %rdx
movups (%rcx), %xmm0
movups %xmm0, 0x28(%rax)
movq %rdx, 0x20(%rax)
movq 0x38(%rax), %rax
movq %rax, 0x101830(%rdi)
jmp 0x83db
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4408
leaq 0xc(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x20(%r14), %eax
movl %eax, 0x68b9(%rip)      # 0x9d88
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x6899(%rip)     # 0x9d78
movups %xmm0, 0x6882(%rip)     # 0x9d68
pushq $0x2
popq %rdi
callq 0x305c
xorl %edi, %edi
callq 0x3535
xorl %eax, %eax
callq 0x4508
xorl %eax, %eax
callq 0x4756
movl %eax, %ebp
testl %eax, %eax
je 0x3519
leaq 0x2040(%rip), %rdi      # 0x5550
movl %ebp, %esi
xorl %eax, %eax
callq 0x2090
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2396
xorl %eax, %eax
cmpl $0x3, %ebp
setl %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5ed7(%rip), %r14d     # 0x9d68
leal -0xf(%r14), %eax
cmpl $0x1, %eax
ja 0x3edb
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x20(%rbx), %eax
movl %eax, 0x5ed6(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x5eb8(%rip)     # 0x9d78
movups %xmm0, 0x5ea1(%rip)     # 0x9d68
callq 0x3f41
cmpl $0x10, %r14d
jne 0x3ee0
xorl %edi, %edi
callq 0x22f4
jmp 0x3ee0
callq 0x3f41
leaq 0xc(%rsp), %rbx
movl 0x5e7d(%rip), %eax      # 0x9d68
leal -0xf(%rax), %ecx
cmpl $0x1, %ecx
ja 0x3f38
xorl %ebp, %ebp
cmpl $0x10, %eax
sete %bpl
movq %rbx, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x2c(%rsp), %eax
movl %eax, 0x5e78(%rip)      # 0x9d88
movups 0xc(%rsp), %xmm0
movups 0x1c(%rsp), %xmm1
movups %xmm1, 0x5e57(%rip)     # 0x9d78
movups %xmm0, 0x5e40(%rip)     # 0x9d68
callq 0x3f41
incl %ebp
movl %ebp, %edi
callq 0x22f4
jmp 0x3ee5
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3faf
leaq 0x4(%rsp), %rbx
movl 0x5e0f(%rip), %r14d     # 0x9d68
leal -0x11(%r14), %eax
cmpl $0x1, %eax
ja 0x3fa7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x24(%rsp), %eax
movl %eax, 0x5e12(%rip)      # 0x9d88
movups 0x4(%rsp), %xmm0
movups 0x14(%rsp), %xmm1
movups %xmm1, 0x5df1(%rip)     # 0x9d78
movups %xmm0, 0x5dda(%rip)     # 0x9d68
callq 0x3faf
xorl %edi, %edi
cmpl $0x11, %r14d
setne %dil
addl $0x3, %edi
callq 0x22f4
jmp 0x3f52
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x5af0(%rip)      # 0x9d68
jne 0x42bc
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x20(%rbx), %eax
movl %eax, 0x5af6(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x5ad8(%rip)     # 0x9d78
movups %xmm0, 0x5ac1(%rip)     # 0x9d68
callq 0x3e82
pushq $0x5
popq %rdi
callq 0x22f4
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x3e82
movl 0x5aa0(%rip), %r14d     # 0x9d68
addl $-0x15, %r14d
cmpl $0x6, %r14d
jb 0x42de
leaq 0x10e0(%rip), %rdi      # 0x53b9
callq 0x45b5
leaq 0x4(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x475d
movl 0x20(%rbx), %eax
movl %eax, 0x5a92(%rip)      # 0x9d88
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x5a74(%rip)     # 0x9d78
movups %xmm0, 0x5a5d(%rip)     # 0x9d68
callq 0x3e82
cmpl $0x5, %r14d
ja 0x434a
leaq 0x106f(%rip), %rax      # 0x538c
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
pushq $0x6
jmp 0x42ae
pushq $0xa
jmp 0x42ae
pushq $0x8
jmp 0x42ae
pushq $0x9
jmp 0x42ae
pushq $0x7
jmp 0x42ae
pushq $0xb
jmp 0x42ae
leaq 0x1068(%rip), %rdi      # 0x53b9
callq 0x45b5
jmp 0x42b4
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x98, %rsp
leaq -0x98(%rbp), %rsi
callq 0x10e0
testl %eax, %eax
js 0x13e5
movq -0x68(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
movq 0x2c0c(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
callq 0x1030
movl (%rax), %edi
callq 0x10d0
leaq 0xc51(%rip), %rsi       # 0x2053
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rdi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/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), %r15
movl $0xfff, %edx            # imm = 0xFFF
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
testq %rax, %rax
jle 0x146c
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x143c
xorl %edx, %edx
cmpb $0xa, -0x1020(%rbp,%rcx)
sete %dl
addq %rdx, %r14
incq %rcx
jmp 0x1452
movq %r14, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edi, %ebx
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x1060
leaq -0x1030(%rbp), %r15
movl $0x1000, %edx           # imm = 0x1000
movl %ebx, %edi
movq %r15, %rsi
callq 0x1070
testq %rax, %rax
jle 0x14f8
movq %rax, %r12
pushq $0x1
popq %r13
cmpq %r13, %r12
je 0x14a6
callq 0x10f0
movq (%rax), %rax
movsbq -0x1031(%rbp,%r13), %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x14f3
movsbq -0x1030(%rbp,%r13), %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xd, %eax
adcq $0x0, %r14
incq %r13
jmp 0x14c1
movq %r14, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x1080
testq %rax, %rax
je 0x15d8
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movq -0x30(%rbp), %rdx
callq 0x11fc
xorl %r12d, %r12d
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0x15c7
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10b0
movl %eax, %r13d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
cmpb $0x2d, (%rax)
jne 0x157b
cmpb $0x0, 0x1(%rax)
je 0x15c2
testl %r13d, %r13d
js 0x15d8
movl %r13d, %edi
callq 0x1417
movq %rax, %rbx
movl %r13d, %edi
callq 0x147d
movq %rax, %r15
movl %r13d, %edi
callq 0x13bb
movq 0x8(%r14), %rcx
movq (%rcx,%r12,8), %r8
leaq 0xab6(%rip), %rdi       # 0x2063
movq %rbx, %rsi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
incq %r12
jmp 0x154b
xorl %r13d, %r13d
jmp 0x1580
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2a19(%rip), %rax      # 0x3ff8
movq (%rax), %rbx
movq -0x30(%rbp), %rax
movq (%rax), %r14
callq 0x1030
movl (%rax), %edi
callq 0x10d0
leaq 0xa5f(%rip), %rsi       # 0x205b
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x10a0
pushq $0x1
popq %rax
jmp 0x15c9
// File: /workspace/github_c_makefile_star2_O2/ddrown[P]pretend-ntp/ntp-exit.c
// Function: main
int main(int argc, char *argv[]) {
  struct ntp_msg buf;
  int sock;
  struct sockaddr_in addr;

  if(argc < 3) {
    printf("%s [ip] [port]\n", argv[0]);
    exit(1);
  }
  if(inet_aton(argv[1], &addr.sin_addr) == INADDR_NONE) {
    printf("invalid ip %s\n", argv[1]);
    exit(1);
  }
  addr.sin_port = htons(strtoul(argv[2], NULL, 10));
  addr.sin_family = AF_INET;

  memset(&buf, 0, sizeof(buf));
  buf.version = NTP_VERS_4;
  buf.mode = NTP_MODE_PRIV;

  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock == -1) {
    perror_exit("socket");
  }
  sendto(sock, &buf, sizeof(buf), 0, &addr, sizeof(addr));
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jle 0x1283
movq 0x8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
callq 0x1080
cmpl $-0x1, %eax
je 0x128f
movq 0x10(%rbx), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x10c0
rolw $0x8, %ax
movw %ax, 0x2(%rsp)
movw $0x2, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x27, 0x10(%rsp)
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x10e0
movl %eax, %ebx
cmpl $-0x1, %eax
jne 0x1263
leaq 0xdc5(%rip), %rdi       # 0x2023
callq 0x1904
leaq 0x10(%rsp), %rsi
pushq $0x30
popq %rdx
movq %rsp, %r8
pushq $0x10
popq %r9
movl %ebx, %edi
xorl %ecx, %ecx
callq 0x1070
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
movq (%rbx), %rsi
leaq 0xd77(%rip), %rdi       # 0x2004
jmp 0x129a
movq 0x8(%rbx), %rsi
leaq 0xd7a(%rip), %rdi       # 0x2014
xorl %eax, %eax
callq 0x1060
pushq $0x1
popq %rdi
callq 0x10d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/keiranrowan[P]tiny-core/./src/yes.c
// Function: main
int main(int argc, char **argv) {
    if (argc > 1 && argc < 3) {
        if ((strcmp(argv[1], "-h") == 0) || (strcmp(argv[1], "--help") == 0)) {
            printf("yes [STRING]...\nPrints y or given string repeatedly\n");
        } else {
            for(;;) {
                printf("%s\n", argv[1]);
            }
        }
    } else {
        for(;;) {
            printf("y\n");
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x1191
movq %rsi, %rbx
movq 0x8(%rsi), %r14
cmpb $0x2d, (%r14)
jne 0x1170
cmpb $0x68, 0x1(%r14)
jne 0x1170
cmpb $0x0, 0x2(%r14)
je 0x11a2
leaq 0xe8d(%rip), %rsi       # 0x2004
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x11a2
movq %r14, %rdi
callq 0x1030
movq 0x8(%rbx), %r14
jmp 0x1183
leaq 0xea5(%rip), %rbx       # 0x203d
movq %rbx, %rdi
callq 0x1030
jmp 0x1198
leaq 0xe62(%rip), %rdi       # 0x200b
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %r13
leaq 0x4c(%rsp), %r14
leaq 0x20(%rsp), %r12
xorl %r15d, %r15d
cmpq $0x98, %r13
je 0x1553
leaq 0x58b9(%rip), %rax      # 0x6d60
movq -0x8(%r13,%rax), %rbx
movq (%r13,%rax), %rbp
leaq 0x2b63(%rip), %rdi      # 0x401b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x1618
movq %rbx, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1630
movq %rsp, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2327
movq %rbx, %rdi
movq %r12, %rsi
pushq $0x14
popq %rdx
callq 0x2ea4
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1130
testl %eax, %eax
je 0x153e
leaq 0x2e97(%rip), %rdi      # 0x43a9
callq 0x1090
leaq 0x2b17(%rip), %rdi      # 0x4035
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x2b19(%rip), %rdi      # 0x4048
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x154a
leaq 0x2e5b(%rip), %rdi      # 0x43a0
callq 0x1090
addq $0x10, %r13
jmp 0x1493
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_O2/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), %r12
movq %r12, %rdi
callq 0x1618
subq $0x1, %rbx
jb 0x15fb
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1630
jmp 0x15e5
movq %rsp, %rdi
leaq 0x1c(%rsp), %rsi
callq 0x2327
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x14, %rsi
movq %rsp, %r15
pushq $0x8
popq %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x23ac
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 0x4da5(%rip), %rsi      # 0x7110
movq %rbx, %rdi
callq 0x1630
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1630
pushq $0x14
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23ac
leaq 0x4e02(%rip), %rax      # 0x7198
movq (%rax), %rax
pushq $0x5c
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x18(%r14)
movaps 0x1ffc(%rip), %xmm0     # 0x43e0
movaps %xmm0, (%r14)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x1630
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2327
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpq $0x41, %rdx
jb 0x2464
pushq $0x14
popq %r12
andl $0x0, 0x18(%r15)
movaps 0x1faa(%rip), %xmm0     # 0x43e0
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r15)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1630
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2327
movq %r12, %r14
andl $0x0, 0x18(%r15)
movaps 0x1f70(%rip), %xmm0     # 0x43e0
movups %xmm0, (%r15)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x10(%r15)
movaps 0x1f6c(%rip), %xmm0     # 0x43f0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorl %eax, %eax
cmpq %rax, %r14
je 0x24a9
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
jmp 0x2499
movq %rsp, %r12
pushq $0x40
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1630
leaq 0x5c(%r15), %rdi
andl $0x0, 0x74(%r15)
movaps 0x1f16(%rip), %xmm0     # 0x43e0
movups %xmm0, 0x5c(%r15)
movl $0xc3d2e1f0, %eax       # imm = 0xC3D2E1F0
movq %rax, 0x6c(%r15)
movaps 0x1f21(%rip), %xmm0     # 0x4400
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
xorl %eax, %eax
cmpq %rax, %r14
je 0x2508
movb (%rbx,%rax), %cl
xorb %cl, (%rsp,%rax)
incq %rax
jmp 0x24f8
movq %rsp, %rbx
pushq $0x40
popq %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1630
leaq 0x4c77(%rip), %r15      # 0x7198
movq (%r15), %rax
leaq 0x40(%rsp), %rdi
pushq $0x14
popq %rsi
callq *%rax
movq (%r15), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *%rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2327
addq $0x5c, %rbx
pushq $0x14
popq %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1630
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2327
leaq 0x4c0a(%rip), %rax      # 0x7198
movq (%rax), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *%rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/ast.c
// Function: astn_new
ast_n *astn_new(int kind, int s_kind, token t) {
	ast_n *node = calloc(1, sizeof(struct AST_NODE));
	node->kind = kind;

	switch (kind) {
		case DECL:
			node->dat.decl.kind = s_kind;
			break;
		case EXPR:
			node->dat.expr.kind = s_kind;
			break;
		case STMT:
			node->dat.stmt.kind = s_kind;
			break;
	}
	node->tok = t;

	return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x20(%rsp), %r14
pushq $0x1
popq %rdi
pushq $0x68
popq %rsi
callq 0x3100
movl %ebp, (%rax)
cmpl $0x2, %ebp
ja 0x335e
movl %ebx, 0x8(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x50(%rax)
movups %xmm1, 0x40(%rax)
movups %xmm0, 0x30(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3398
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x2, %eax
je 0x33a9
cmpl $0x1, %eax
je 0x3399
testl %eax, %eax
je 0x33b2
jmp 0x33cd
retq
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x33bb
callq 0xb8ba
jmp 0x33bb
movq 0x10(%rbx), %rdi
callq 0x3030
movq 0x18(%rbx), %rdi
callq 0x337d
movq 0x20(%rbx), %rdi
callq 0x337d
movq 0x28(%rbx), %rdi
callq 0x337d
movq 0x60(%rbx), %rdi
callq 0x337d
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x33e4
callq 0xb8ba
movq %rbx, %rdi
popq %rbx
jmp 0x3030
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/err.c
// Function: c_error
void c_error(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("ERROR: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	c_errflag = 1;
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x3642
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x366c
movq 0xf9aa(%rip), %rax      # 0x12ff8
movq (%rax), %rax
movq 0x10(%rdi), %rdx
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
leaq 0x8a3a(%rip), %rsi      # 0xc09c
movq %rax, %rdi
xorl %eax, %eax
callq 0x3130
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0xf960(%rip), %r15      # 0x12ff8
movq (%r15), %rsi
leaq 0x8a05(%rip), %rdi      # 0xc0a7
callq 0x30f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31f0
movl $0x1, 0xfdb5(%rip)      # 0x13474
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Yamsman[P]scc/src/err.c
// Function: c_warn
void c_warn(s_pos *pos, const char *msg, ...) {
	if (pos != NULL) {
		fprintf(stderr, "%s:%i:%i: ",
			pos->fname, pos->line, pos->col);
	}
	va_list args;
	va_start(args, msg);
	fputs("WARNING: ", stderr);
	vfprintf(stderr, msg, args);
	va_end(args);

	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x372a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0x3754
movq 0xf8c2(%rip), %rax      # 0x12ff8
movq (%rax), %rax
movq 0x10(%rdi), %rdx
movl (%rdi), %ecx
movl 0x4(%rdi), %r8d
leaq 0x8952(%rip), %rsi      # 0xc09c
movq %rax, %rdi
xorl %eax, %eax
callq 0x3130
leaq 0x20(%rsp), %rax
movq %rsp, %r14
movq %rax, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r14)
movq 0xf878(%rip), %r15      # 0x12ff8
movq (%r15), %rsi
leaq 0x8925(%rip), %rdi      # 0xc0af
callq 0x30f0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31f0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop