// File: /workspace/github_cpp_makefile_star2_O1/pixlark[P]Badge/src/vm.cc
// Function: VM::step()
VM_Response step()
	{	
		if (halted()) {
			return VM_HALTED;
		}
		
		/* Manage call stack and VM halting */
		Call_Frame * frame;
		{
			frame = frame_reference();
			
			// If our call frame has come to an implicit end
			while (frame->bc_pointer >= frame->bc_length) {
				assert(stack.size > 0);

				if (call_stack.size == 1) {
					// If we're about to return from global scope, we
					// need to do some special stuff
					do_halting_tasks();
					return_function();
					return VM_HALTED;
				}
				return_function();
				
				// Update frame reference
				frame = frame_reference();
			}
		}
		
		BC bc = frame->bytecode[frame->bc_pointer++];
		current_assoc = bc.assoc;
		
		switch (bc.kind) {
		case BC_NOP: break;
		case BC_POP_AND_DISCARD: {
			pop();
		} break;
		case BC_LOAD_CONST: {
			push(bc.arg.value);
		} break;
		case BC_DUPLICATE: {
			push(stack[stack.size - 1]);
		} break;
		case BC_CREATE_BINDING: {
			auto symbol = pop_symbol();
			auto value = pop();
			create_binding(symbol, value);
		} break;
		case BC_UPDATE_BINDING: {
			auto symbol = pop_symbol();
			auto value = pop();
			if (!frame->environment->update_binding(symbol, value)) {
				error("Tried to set unbound variable '%s'", symbol);
			}
		} break;
		case BC_RESOLVE_BINDING: {
			auto symbol = pop_symbol();
			auto value = resolve_binding(symbol);
			push(value);
		} break;
		case BC_ADD: {
			auto b = pop();
			auto a = pop();
			push(Value::add(a, b, bc.assoc));
		} break;
		case BC_SUBTRACT: {
			auto b = pop();
			auto a = pop();
			push(Value::subtract(a, b, bc.assoc));
		} break;
		case BC_MULTIPLY: {
			auto b = pop();
			auto a = pop();
			push(Value::multiply(a, b, bc.assoc));
		} break;
		case BC_DIVIDE: {
			auto b = pop();
			auto a = pop();
			push(Value::divide(a, b, bc.assoc));
		} break;
		case BC_NEGATE: {
			auto a = pop();
			push(Value::subtract(Value::raise(0), a, bc.assoc));
		} break;
		case BC_EQUAL: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::equal(a, b, bc.assoc)));
		} break;
		case BC_NOT_EQUAL: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(!Value::equal(a, b, bc.assoc)));
		} break;
		case BC_GREATER_THAN: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::greater_than(a, b, bc.assoc)));
		} break;
		case BC_LESS_THAN: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::less_than(a, b, bc.assoc)));
		} break;
		case BC_GREATER_THAN_OR_EQUAL_TO: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::greater_than_or_equal_to(a, b, bc.assoc)));
		} break;
		case BC_LESS_THAN_OR_EQUAL_TO: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::less_than_or_equal_to(a, b, bc.assoc)));
		} break;
		case BC_AND: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::_and(a, b, bc.assoc)));
		} break;
		case BC_OR: {
			auto b = pop();
			auto a = pop();
			push(Value::raise_bool(Value::_or(a, b, bc.assoc)));
		} break;
		case BC_NOT: {
			auto a = pop();
			push(Value::raise_bool(!a.truthy()));
		} break;
		case BC_CONSTRUCT_FUNCTION: {
			auto count = pop_integer();
			
			Function * func = (Function*) GC::alloc(sizeof(Function));
			func->block_reference = bc.arg.block_reference;

			// Insert parameters
			func->parameter_count = count;
			func->parameters = (Symbol*) GC::alloc(sizeof(Symbol) * count);
			for (int i = 0; i < count; i++) {
				auto it = pop_symbol();
				func->parameters[count - i - 1] = it;
			}

			// Close over local environment
			func->closure = frame->environment;
			
			// Create and push value
			Value value = Value::create(TYPE_FUNCTION);
			value.ref_function = func;
			push(value);
		} break;
		case BC_POP_AND_CALL_FUNCTION: {
			auto func_val = pop();
			if (func_val.is(TYPE_BUILTIN)) {
				// If this is a builtin function, override everything and just do a builtin call
				auto builtin = func_val.builtin;
				auto passed_arg_count = pop_integer();
				if (passed_arg_count != builtin->arg_count) {
					error("Function takes %d arguments; was passed %d",
						  builtin->arg_count,
						  passed_arg_count);
				}
				Value * args = (Value*) malloc(sizeof(Value) * builtin->arg_count);
				defer { free(args); };
				for (int i = 0; i < builtin->arg_count; i++) {
					args[i] = pop();
				}
				push((builtin->funcptr)(args));
			} else if (func_val.is(TYPE_CONSTRUCTOR)) {
				auto ctor = func_val.ref_constructor;
				auto object = (Object*) GC::alloc(sizeof(Object));
				object->fields.alloc(symbol_comparator);

				auto passed_arg_count = pop_integer();
				if (passed_arg_count != ctor->field_count) {
					error("Constructor has %d fields; was passed %d",
						  ctor->field_count,
						  passed_arg_count);
				}

				for (int i = 0; i < ctor->field_count; i++) {
					auto val = pop();
					auto symbol = ctor->fields[i];
					object->fields.add(symbol, val);
				}

				auto val = Value::create(TYPE_OBJECT);
				val.ref_object = object;
				push(val);
			} else {
				// Otherwise, this is a normal function
				func_val.assert_is(TYPE_FUNCTION);
				auto func = func_val.ref_function;
				auto passed_arg_count = pop_integer();
				if (passed_arg_count != func->parameter_count) {
					error("Function takes %d arguments; was passed %d",
						  func->parameter_count,
						  passed_arg_count);
				}

				#if TAIL_CALL_OPTIMIZATION
				{
					bool is_tail_call = true;
					size_t ptr = frame->bc_pointer;
					while (ptr < frame->bc_length) {
						auto kind = frame->bytecode[ptr].kind;
						if (kind == BC_RETURN) {
							break;
						}
						if (!BC::tail_call_safe(kind)) {
							is_tail_call = false;
							break;
						}
						ptr++;
					}
					if (is_tail_call) {
						return_function();
					}
				}
				#endif
				
				// Create our new call frame
				call_stack.push(Call_Frame::alloc(blocks, func->block_reference,
												  func, func->closure));
				
				// Create bindings to pushed arguments
				for (int i = 0; i < passed_arg_count; i++) {
					auto value = pop();
					create_binding(func->parameters[i], value);
				}
			}
		} break;
		case BC_RETURN: {
			// WARNING: `frame` invalidated here! Don't use it!
			return_function();
		} break;
		case BC_THIS_FUNCTION: {
			auto func = Value::create(TYPE_FUNCTION);
			if (!frame->origin) {
				error("Invalid use of this -- not in a function!");
			}
			func.ref_function = frame->origin;
			push(func);
		} break;
		case BC_SYMBOL_TO_STRING: {
			auto symbol = pop_symbol();
			auto string = (String*) GC::alloc(sizeof(String));
			string->length = strlen(symbol);
			string->string = (char*) GC::alloc(sizeof(char) * string->length);
			strncpy(string->string, symbol, string->length);
			auto value = Value::create(TYPE_STRING);
			value.ref_string = string;
			push(value);
		} break;
		case BC_JUMP: {
			frame->bc_pointer = bc.arg.integer;
		} break;
		case BC_POP_JUMP: {
			auto a = pop();
			if (a.type != TYPE_NOTHING) {
				frame->bc_pointer = bc.arg.integer;
			}
		} break;
		case BC_ENTER_SCOPE: {
			auto new_env = Environment::alloc();
			new_env->next_env = frame->environment;
			frame->environment = new_env;
		} break;
		case BC_EXIT_SCOPE: {
			frame->environment = frame->environment->next_env;
			GC::heuristic_exit_scope();
		} break;
		case BC_CONSTRUCT_CONSTRUCTOR: {
			auto count = pop_integer();
			auto ctor = (Constructor*) GC::alloc(sizeof(Constructor));
			ctor->fields = (Symbol*) GC::alloc(sizeof(Symbol) * count);
			ctor->field_count = count;
			for (int i = 0; i < count; i++) {
				ctor->fields[i] = pop_symbol();
			}
			auto val = Value::create(TYPE_CONSTRUCTOR);
			val.ref_constructor = ctor;
			push(val);
		} break;
		case BC_RESOLVE_FIELD: {
			auto symbol = pop_symbol();
			auto obj_val = pop();
			if (!obj_val.is(TYPE_OBJECT)) {
				error("Cannot access field of non-object");
			}
			auto obj = obj_val.ref_object;
			if (!obj->fields.bound(symbol)) {
				error("No such field %s on object", symbol);
			}
			auto resolved = obj->fields.lookup(symbol);
			push(resolved);
		} break;
		case BC_UPDATE_FIELD: {
			auto symbol = pop_symbol();
			auto obj_val = pop();
			if (!obj_val.is(TYPE_OBJECT)) {
				error("Cannot access field of non-object");
			}
			auto obj = obj_val.ref_object;
			if (!obj->fields.bound(symbol)) {
				error("No such field %s on object", symbol);
			}
			auto val = pop();
			obj->fields.update(symbol, val);
		} break;
		case BC_PUSH_BODY: {
			frame->body_stack.push(bc.arg.integer);
		} break;
		case BC_BREAK_BODY: {
			if (frame->body_stack.size == 0) {
				error("Nothing to break out of");
			}
			int exit_pos = frame->body_stack.pop();
			frame->bc_pointer = exit_pos;
		} break;
		case BC_RUN_FILE_UNIT: {
			block_reference_to_push = pop_integer();
			push(Value::nothing());
			return VM_SWITCH;
		} break;
		case BC_EXPORT_SYMBOL: {
			auto symbol = pop_symbol();
			export_queue.push((Export) { symbol, bc.assoc });
			push(Value::nothing());
		} break;
		case BC_GET_CALL_FLAG: {
			auto symbol_val = bc.arg.value;
			if (!symbol_val.is(TYPE_SYMBOL)) {
				fatal("Can't lookup call-flag for non-symbol. (This error should never trigger!)");
			}
			auto symbol = symbol_val.symbol;
			push(lookup_call_flag(symbol));
		} break;
		default: {
			fatal("Internal error: VM ran unrecognized instruction");
		}
		}

		return VM_OK;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x1, %r13d
cmpq $0x0, 0x68(%rdi)
je 0x6a6c
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x9132
movq %rax, %r12
movq 0x28(%rax), %rax
cmpq 0x30(%r12), %rax
jb 0x612e
cmpq $0x0, 0x40(%rbx)
je 0x6a7e
cmpq $0x1, 0x68(%rbx)
je 0x6185
movq %rbx, %rdi
callq 0x9234
jmp 0x60fc
movq 0x20(%r12), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x28(%r12)
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,8), %r13d
movl 0x4(%rcx,%rax,8), %r14d
movq 0x8(%rcx,%rax,8), %r15
movq 0x10(%rcx,%rax,8), %rdx
movl %r14d, 0x88(%rbx)
cmpq $0x25, %r13
ja 0x6a9d
leaq 0x5019(%rip), %rax      # 0xb184
movslq (%rax,%r13,4), %rcx
addq %rax, %rcx
jmpq *%rcx
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
jmp 0x6a69
movq %rbx, %rdi
callq 0x9192
movq %rbx, %rdi
callq 0x9234
jmp 0x6a6c
cmpl $0x2, %r15d
jne 0x6aa6
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x98ec
jmp 0x65d0
movq %rbx, %rdi
callq 0x94f2
cltq
movq %rax, 0x90(%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9a8e
movl $0x2, %r13d
jmp 0x6a6c
movq %rbx, %rdi
callq 0x927e
leaq 0x10(%rbx), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x9858
addq $0x38, %rbx
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x62fb
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
xorl %r13d, %r13d
testl %eax, %eax
je 0x6a6c
movslq %r15d, %rax
movq %rax, 0x28(%r12)
jmp 0x6a6c
leaq 0x38(%r12), %r14
cmpq $0x0, 0x40(%r12)
jne 0x624c
leaq 0x5aa7(%rip), %rsi      # 0xbce9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x93bc
movq %r14, %rdi
callq 0x9804
cltq
jmp 0x6903
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4b1c
jmp 0x65b0
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4ac0
jmp 0x65b0
addq $0x38, %r12
movq %r12, %rdi
movl %r15d, %esi
callq 0x8d58
jmp 0x6a69
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movq %rdx, %rcx
xorl %r13d, %r13d
movl $0x1, %edi
xorl %esi, %esi
movl %eax, %edx
movl %r14d, %r8d
callq 0x4948
movq %rbx, %rdi
movl %eax, %esi
callq 0x9a8e
jmp 0x6a6c
movq %rbx, %rdi
callq 0x927e
movq %rax, %r14
leaq 0x38(%rbx), %rdi
callq 0x9c5e
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x92b4
jmp 0x6a69
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x49e6
jmp 0x65b0
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x497c
jmp 0x669f
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
xorl %edx, %edx
testl %eax, %eax
sete %dl
jmp 0x65b3
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9c5e
xorl %edx, %edx
orl %r14d, %eax
setne %dl
jmp 0x65b3
addq $0x38, %rbx
movq %rbx, %rdi
movl %r15d, %esi
jmp 0x6a64
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4a92
jmp 0x65b0
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x6ab4
movq 0x38(%rbx), %rcx
addq $0x38, %rbx
shlq $0x4, %rax
movl -0x10(%rcx,%rax), %esi
movq -0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
jmp 0x6a64
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4914
jmp 0x669f
movq %rbx, %rdi
callq 0x927e
movq %rax, %r15
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x9c5e
movq %rdx, %r12
cmpl $0x7, %eax
je 0x6498
leaq 0x581e(%rip), %rsi      # 0xbcac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x93bc
movq %r12, %rdi
movq %r15, %rsi
callq 0x95f6
testb %al, %al
jne 0x64bb
leaq 0x5820(%rip), %rsi      # 0xbcce
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x93bc
movq %r12, %rdi
movq %r15, %rsi
callq 0x966a
movq %r14, %rdi
jmp 0x66a2
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4aee
jmp 0x65b0
movq %rbx, %rdi
callq 0x9234
jmp 0x6a69
movq %rbx, %rdi
callq 0x927e
movq %rax, %r14
leaq 0x38(%rbx), %rdi
callq 0x9c5e
movq %rdx, %rcx
movq 0x8(%r12), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x930c
testb %al, %al
jne 0x6a69
leaq 0x56c9(%rip), %rsi      # 0xbc0b
xorl %r13d, %r13d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x93bc
jmp 0x6a6c
cmpq $0x0, (%r12)
jne 0x656f
leaq 0x571d(%rip), %rsi      # 0xbc82
movq %rbx, %rdi
xorl %eax, %eax
callq 0x93bc
movq (%r12), %rdx
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x6a64
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x49e6
xorb $0x1, %al
movzbl %al, %edx
movq %rbx, %rdi
movl %edx, %esi
jmp 0x6a64
movq %rbx, %rdi
callq 0x927e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9430
addq $0x38, %rbx
jmp 0x669f
movq %rbx, %rdi
callq 0x94f2
movl %eax, %r13d
movl $0x20, %edi
callq 0x4685
movq %rax, %r14
movq %r15, 0x10(%rax)
movslq %r13d, %r15
movq %r15, 0x8(%rax)
leaq (,%r15,8), %rdi
callq 0x4685
movq %rax, (%r14)
testl %r15d, %r15d
jle 0x6629
movl %r13d, %r15d
movq %rbx, %rdi
callq 0x927e
movq (%r14), %rcx
movq %rax, -0x8(%rcx,%r15,8)
decq %r15
jne 0x6614
movq 0x8(%r12), %rax
movq %rax, 0x18(%r14)
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x6706
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x49b0
jmp 0x669f
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r15d
movq %rdx, %r12
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %edi
movq %rdx, %rsi
movl %r15d, %edx
movq %r12, %rcx
movl %r14d, %r8d
callq 0x4948
movq %rbx, %rdi
movl %eax, %esi
jmp 0x6a64
movq %rbx, %rdi
callq 0x94f2
movl %eax, %r15d
movl $0x10, %edi
callq 0x4685
movq %rax, %r14
movslq %r15d, %r12
leaq (,%r12,8), %rdi
callq 0x4685
movq %rax, (%r14)
movq %r12, 0x8(%r14)
testl %r12d, %r12d
jle 0x66fa
movl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x927e
movq (%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x66e3
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x6, %esi
movq %r14, %rdx
jmp 0x6a64
movq %rbx, %rdi
callq 0x927e
movq %rax, %r14
leaq 0x38(%rbx), %r15
movq %r15, %rdi
callq 0x9c5e
movq %rdx, %r12
cmpl $0x7, %eax
je 0x673e
leaq 0x5578(%rip), %rsi      # 0xbcac
movq %rbx, %rdi
xorl %eax, %eax
callq 0x93bc
movq %r12, %rdi
movq %r14, %rsi
callq 0x95f6
testb %al, %al
jne 0x6761
leaq 0x557a(%rip), %rsi      # 0xbcce
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x93bc
movq %r15, %rdi
callq 0x9c5e
movq %rdx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x973c
jmp 0x6a69
movq %rbx, %rdi
callq 0x927e
movq %rax, %r14
movl $0x10, %edi
callq 0x4685
movq %rax, %r15
movq %r14, %rdi
callq 0x1080
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x4685
movq %rax, (%r15)
movq 0x8(%r15), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10b0
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x4, %esi
movq %r15, %rdx
jmp 0x6a64
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0x9c5e
movq %rdx, %r15
cmpl $0x6, %eax
je 0x69e8
cmpl $0x5, %eax
je 0x690d
cmpl $0x3, %eax
jne 0x6ad3
movq %r15, %r12
movq %r14, %r15
movq %rbx, %rdi
callq 0x94f2
movslq %eax, %rcx
movq 0x8(%r12), %rdx
cmpq %rcx, %rdx
je 0x6828
leaq 0x5412(%rip), %rsi      # 0xbc2e
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x93bc
movq 0x8(%r12), %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x1200
movq %rax, %rbx
testq %r14, %r14
movq %r15, %r14
movq %r12, %r15
je 0x686f
movq %rbx, %r12
addq $0x8, %r12
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x9c5e
movl %eax, -0x8(%r12)
movq %rdx, (%r12)
incq %r13
addq $0x10, %r12
cmpq %r13, 0x8(%r15)
ja 0x6851
movq %rbx, %rdi
callq *0x10(%r15)
movq %r14, %rdi
movl %eax, %esi
callq 0x9a8e
movq %rbx, %rdi
callq 0x11f8
jmp 0x6a69
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9c5e
movl %eax, %r14d
movq %rbx, %rdi
callq 0x9c5e
testl %eax, %eax
setne %al
testl %r14d, %r14d
setne %cl
andb %al, %cl
movzbl %cl, %edx
jmp 0x65b3
callq 0x5f6e
movq 0x8(%r12), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x8(%r12)
jmp 0x6a69
movq 0x8(%r12), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%r12)
cvtss2sd 0xa949(%rip), %xmm0     # 0x11230
addsd 0x4879(%rip), %xmm0     # 0xb168
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xa935(%rip)     # 0x11230
jmp 0x6a69
movslq %r15d, %rax
movq %rax, 0x28(%r12)
jmp 0x6a69
movq %rbx, %rdi
callq 0x94f2
movl %eax, %r13d
cltq
movq 0x8(%r15), %rdx
cmpq %rax, %rdx
je 0x6937
leaq 0x5304(%rip), %rsi      # 0xbc2e
movq %rbx, %rdi
movl %r13d, %ecx
xorl %eax, %eax
callq 0x93bc
movq 0x28(%r12), %rcx
movq 0x30(%r12), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
jae 0x6973
movq 0x20(%r12), %rsi
leaq (%rcx,%rcx,2), %rdi
movl (%rsi,%rdi,8), %esi
cmpl $0x1d, %esi
je 0x6962
cmpl $0x14, %esi
je 0x696c
testl %esi, %esi
jne 0x696a
incq %rcx
movb $0x1, %sil
jmp 0x696e
xorl %eax, %eax
xorl %esi, %esi
testb %sil, %sil
jne 0x6943
testb $0x1, %al
je 0x697f
movq %rbx, %rdi
callq 0x9234
leaq 0x60(%rbx), %r12
movq (%rbx), %rdi
movq 0x10(%r15), %rsi
movq 0x18(%r15), %rcx
movq %r15, %rdx
callq 0x8f9a
movq %r12, %rdi
movq %rax, %rsi
callq 0x8f18
testl %r13d, %r13d
jle 0x6a69
movl %r13d, %eax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
movq %r15, %r12
movq %r14, %r15
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x9c5e
movq %rdx, %rcx
movq (%r12), %rdx
movq (%rdx,%r14,8), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x92b4
incq %r14
cmpq %r14, -0x30(%rbp)
jne 0x69bd
jmp 0x6a6c
movl $0x58, %edi
callq 0x4685
movq %rax, %r12
leaq -0x5352(%rip), %rsi     # 0x16aa
movq %rax, %rdi
callq 0x9528
movq %rbx, %rdi
callq 0x94f2
movslq %eax, %rcx
movq 0x8(%r15), %rdx
cmpq %rcx, %rdx
je 0x6a2b
leaq 0x523a(%rip), %rsi      # 0xbc59
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x93bc
cmpq $0x0, 0x8(%r15)
je 0x6a59
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x9c5e
movq %rdx, %rcx
movq (%r15), %rdx
movq (%rdx,%rbx,8), %rsi
movq %r12, %rdi
movl %eax, %edx
callq 0x959a
incq %rbx
cmpq %rbx, 0x8(%r15)
ja 0x6a34
movq %r14, %rdi
movl $0x7, %esi
movq %r12, %rdx
callq 0x9a8e
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52fb(%rip), %rdi      # 0xbd80
leaq 0x515e(%rip), %rsi      # 0xbbea
leaq 0x5161(%rip), %rcx      # 0xbbf4
movl $0xe2, %edx
callq 0x10d0
leaq 0x52a7(%rip), %rdi      # 0xbd4b
jmp 0x6aad
leaq 0x5254(%rip), %rdi      # 0xbd01
xorl %eax, %eax
callq 0x1a2a
leaq 0x4cf0(%rip), %rdi      # 0xb7ab
leaq 0x4cf6(%rip), %rsi      # 0xb7b8
leaq 0x4cfb(%rip), %rcx      # 0xb7c4
movl $0x7b, %edx
callq 0x10d0
leaq 0x5527(%rip), %rdi      # 0xc001
leaq 0x5529(%rip), %rsi      # 0xc00a
leaq 0x5534(%rip), %rcx      # 0xc01c
movl $0x47, %edx
callq 0x10d0
jmp 0x6af4
movq %rax, %r14
movq %rbx, %rdi
callq 0x11f8
movq %r14, %rdi
callq 0x11c0
nop