// File: /workspace/github_cpp_makefile_star2_O3/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
subq $0x18, %rsp
movq 0x68(%rdi), %rax
movl $0x1, %r12d
testq %rax, %rax
je 0x6901
movq %rdi, %rbx
leaq 0x60(%rdi), %r15
movq 0x60(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %r13
movq 0x28(%r13), %rcx
cmpq 0x30(%r13), %rcx
jb 0x6019
cmpq $0x0, 0x40(%rbx)
je 0x697c
movq %rbx, %rdi
cmpq $0x1, %rax
je 0x606c
callq 0x970e
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x699b
movq (%r15), %rcx
jmp 0x5fdf
movq 0x20(%r13), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r13)
leaq (%rcx,%rcx,2), %rcx
movl (%rax,%rcx,8), %r12d
movl 0x4(%rax,%rcx,8), %esi
movq 0x8(%rax,%rcx,8), %r14
movq 0x10(%rax,%rcx,8), %rdx
movl %esi, 0x88(%rbx)
cmpq $0x25, %r12
ja 0x69ba
leaq 0x5132(%rip), %rax      # 0xb184
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
jmp 0x68fe
callq 0x9668
movq %rbx, %rdi
callq 0x970e
jmp 0x6901
cmpl $0x2, %r14d
jne 0x69c3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x9db2
jmp 0x64ca
movq %rbx, %rdi
callq 0x99e6
cltq
movq %rax, 0x90(%rbx)
addq $0x38, %rbx
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9f32
movl $0x2, %r12d
jmp 0x6901
movq %rbx, %rdi
movl %esi, %r14d
callq 0x9752
leaq 0x10(%rbx), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x9d1c
addq $0x38, %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x61e8
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
xorl %r12d, %r12d
testl %eax, %eax
je 0x6901
movslq %r14d, %rax
movq %rax, 0x28(%r13)
jmp 0x6901
leaq 0x38(%r13), %r14
cmpq $0x0, 0x40(%r13)
jne 0x6130
leaq 0x5b5b(%rip), %rsi      # 0xbc81
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9886
movq %r14, %rdi
callq 0x9cc8
cltq
jmp 0x67fb
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x4848
jmp 0x64aa
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x47ec
jmp 0x64aa
addq $0x38, %r13
movq %r13, %rdi
movl %r14d, %esi
callq 0x928e
jmp 0x68fe
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r14d
callq 0xa104
movq %rdx, %rcx
xorl %r12d, %r12d
movl $0x1, %edi
xorl %esi, %esi
movl %eax, %edx
movl %r14d, %r8d
callq 0x4674
movq %rbx, %rdi
movl %eax, %esi
callq 0x9f32
jmp 0x6901
movq %rbx, %rdi
callq 0x9752
movq %rax, %r14
leaq 0x38(%rbx), %rdi
callq 0xa104
movq %rdx, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x9788
jmp 0x68fe
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x4712
jmp 0x64aa
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x46a8
jmp 0x65a3
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
xorl %edx, %edx
testl %eax, %eax
sete %dl
jmp 0x64ad
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
movl %eax, %r14d
movq %rbx, %rdi
callq 0xa104
xorl %edx, %edx
orl %r14d, %eax
setne %dl
jmp 0x64ad
addq $0x38, %rbx
movq %rbx, %rdi
movl %r14d, %esi
jmp 0x68f9
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x47be
jmp 0x64aa
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x69d1
movq 0x38(%rbx), %rcx
addq $0x38, %rbx
shlq $0x4, %rax
movl -0x10(%rcx,%rax), %esi
movq -0x8(%rcx,%rax), %rdx
movq %rbx, %rdi
jmp 0x68f9
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x4640
jmp 0x65a3
movq %rbx, %rdi
callq 0x9752
movq %rax, %r15
leaq 0x38(%rbx), %r14
movq %r14, %rdi
callq 0xa104
movq %rdx, %r12
cmpl $0x7, %eax
je 0x638e
leaq 0x58c0(%rip), %rsi      # 0xbc44
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9886
movq %r12, %rdi
movq %r15, %rsi
callq 0x9aea
testb %al, %al
jne 0x63b1
leaq 0x58c2(%rip), %rsi      # 0xbc66
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x9886
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b58
movq %r14, %rdi
jmp 0x65a6
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x481a
jmp 0x64aa
movq %rbx, %rdi
callq 0x970e
jmp 0x68fe
movq %rbx, %rdi
callq 0x9752
movq %rax, %r14
leaq 0x38(%rbx), %rdi
callq 0xa104
movq %rdx, %rcx
movq 0x8(%r13), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x97f4
testb %al, %al
jne 0x68fe
leaq 0x5769(%rip), %rsi      # 0xbba3
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9886
jmp 0x6901
movq (%r13), %rdx
testq %rdx, %rdx
jne 0x646d
leaq 0x57bb(%rip), %rsi      # 0xbc1a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9886
movq (%r13), %rdx
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x68f9
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x4712
xorb $0x1, %al
movzbl %al, %edx
movq %rbx, %rdi
movl %edx, %esi
jmp 0x68f9
movq %rbx, %rdi
callq 0x9752
movq %rbx, %rdi
movq %rax, %rsi
callq 0x98fa
addq $0x38, %rbx
jmp 0x65a3
movq %rbx, %rdi
callq 0x99e6
movl %eax, %r12d
movl $0x20, %edi
callq 0x43bf
movq %rax, %r15
movq %r14, 0x10(%rax)
movslq %r12d, %r14
movq %r14, 0x8(%rax)
leaq (,%r14,8), %rdi
callq 0x43bf
movq %rax, (%r15)
testl %r14d, %r14d
jle 0x6528
movq %r14, %r12
decq %r12
movq %rbx, %rdi
callq 0x9752
movq (%r15), %rcx
movq %rax, (%rcx,%r12,8)
decq %r12
decq %r14
jne 0x6511
movq 0x8(%r13), %rax
movq %rax, 0x18(%r15)
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x5, %esi
jmp 0x68f6
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x46dc
jmp 0x65a3
addq $0x38, %rbx
movq %rbx, %rdi
movl %esi, %r12d
callq 0xa104
movl %eax, %r14d
movq %rdx, %r15
movq %rbx, %rdi
callq 0xa104
movl %eax, %edi
movq %rdx, %rsi
movl %r14d, %edx
movq %r15, %rcx
movl %r12d, %r8d
callq 0x4674
movq %rbx, %rdi
movl %eax, %esi
jmp 0x68f9
movq %rbx, %rdi
callq 0x99e6
movl %eax, %r15d
movl $0x10, %edi
callq 0x43bf
movq %rax, %r14
movslq %r15d, %r12
leaq (,%r12,8), %rdi
callq 0x43bf
movq %rax, (%r14)
movq %r12, 0x8(%r14)
testl %r12d, %r12d
jle 0x65fe
movl %r15d, %r15d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x9752
movq (%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x65e7
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x6, %esi
movq %r14, %rdx
jmp 0x68f9
movq %rbx, %rdi
callq 0x9752
movq %rax, %r14
leaq 0x38(%rbx), %r15
movq %r15, %rdi
callq 0xa104
movq %rdx, %r12
cmpl $0x7, %eax
je 0x6642
leaq 0x560c(%rip), %rsi      # 0xbc44
movq %rbx, %rdi
xorl %eax, %eax
callq 0x9886
movq %r12, %rdi
movq %r14, %rsi
callq 0x9aea
testb %al, %al
jne 0x6665
leaq 0x560e(%rip), %rsi      # 0xbc66
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x9886
movq %r15, %rdi
callq 0xa104
movq %rdx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x9c12
jmp 0x68fe
movq %rbx, %rdi
callq 0x9752
movq %rax, %r14
movl $0x10, %edi
callq 0x43bf
movq %rax, %r15
movq %r14, %rdi
callq 0x1080
movq %rax, 0x8(%r15)
movq %rax, %rdi
callq 0x43bf
movq %rax, (%r15)
movq 0x8(%r15), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10b0
addq $0x38, %rbx
movq %rbx, %rdi
movl $0x4, %esi
jmp 0x68f6
leaq 0x38(%rbx), %rdi
movq %rdi, %r14
callq 0xa104
movq %rdx, -0x30(%rbp)
cmpl $0x6, %eax
je 0x686c
cmpl $0x5, %eax
je 0x6804
cmpl $0x3, %eax
jne 0x69f0
movq %rbx, %rdi
callq 0x99e6
movslq %eax, %r15
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdx
cmpq %r15, %rdx
movq %r14, %r13
movq %rcx, %r14
je 0x6731
leaq 0x54a5(%rip), %rsi      # 0xbbc6
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x9886
movq 0x8(%r14), %r15
movq %r15, %rdi
shlq $0x4, %rdi
callq 0x1200
movq %rax, %rbx
testq %r15, %r15
je 0x676b
movq %rbx, %r15
addq $0x8, %r15
xorl %r12d, %r12d
movq %r13, %rdi
callq 0xa104
movl %eax, -0x8(%r15)
movq %rdx, (%r15)
incq %r12
addq $0x10, %r15
cmpq %r12, 0x8(%r14)
ja 0x674f
movq %rbx, %rdi
callq *0x10(%r14)
movq %r13, %rdi
movl %eax, %esi
callq 0x9f32
movq %rbx, %rdi
callq 0x11f8
jmp 0x68fe
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
movl %eax, %r14d
movq %rbx, %rdi
callq 0xa104
testl %eax, %eax
setne %al
testl %r14d, %r14d
setne %cl
andb %al, %cl
movzbl %cl, %edx
jmp 0x64ad
callq 0x5e44
movq 0x8(%r13), %rcx
movq %rcx, 0x50(%rax)
movq %rax, 0x8(%r13)
jmp 0x68fe
movq 0x8(%r13), %rax
movq 0x50(%rax), %rax
movq %rax, 0x8(%r13)
cvtss2sd 0x9a51(%rip), %xmm0     # 0x10230
addsd 0x4981(%rip), %xmm0     # 0xb168
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x9a3d(%rip)     # 0x10230
jmp 0x68fe
movslq %r14d, %rax
movq %rax, 0x28(%r13)
jmp 0x68fe
movq %rbx, %rdi
callq 0x99e6
movl %eax, %r12d
cltq
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdx
cmpq %rax, %rdx
je 0x6832
leaq 0x53a1(%rip), %rsi      # 0xbbc6
movq %rbx, %rdi
movl %r12d, %ecx
xorl %eax, %eax
callq 0x9886
movq 0x28(%r13), %rcx
movq 0x30(%r13), %rax
subq %rcx, %rax
jbe 0x6918
leaq (%rcx,%rcx,2), %rcx
shlq $0x3, %rcx
addq 0x20(%r13), %rcx
movl (%rcx), %edx
testl %edx, %edx
je 0x685e
cmpl $0x1d, %edx
jne 0x6913
addq $0x18, %rcx
decq %rax
jne 0x684f
jmp 0x6918
movl $0x58, %edi
callq 0x43bf
movq %rax, %r15
leaq -0x5201(%rip), %rsi     # 0x167f
movq %rax, %rdi
callq 0x9a1c
movq %rbx, %rdi
callq 0x99e6
movslq %eax, %rcx
movq -0x30(%rbp), %rdx
movq 0x8(%rdx), %rdx
cmpq %rcx, %rdx
je 0x68bb
leaq 0x534a(%rip), %rsi      # 0xbbf1
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x9886
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
movq %r14, %r12
movq -0x30(%rbp), %r14
je 0x68ee
xorl %ebx, %ebx
movq %r12, %rdi
callq 0xa104
movq %rdx, %rcx
movq (%r14), %rdx
movq (%rdx,%rbx,8), %rsi
movq %r15, %rdi
movl %eax, %edx
callq 0x9a8e
incq %rbx
cmpq %rbx, 0x8(%r14)
ja 0x68c9
movq %r12, %rdi
movl $0x7, %esi
movq %r15, %rdx
callq 0x9f32
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x14, %edx
jne 0x6920
movq %rbx, %rdi
callq 0x970e
movq (%rbx), %rdi
movq -0x30(%rbp), %rdx
movq 0x10(%rdx), %rsi
movq 0x18(%rdx), %rcx
callq 0x94d0
movq %r15, %rdi
movq %rax, %rsi
callq 0x944e
testl %r12d, %r12d
jle 0x68fe
movl %r12d, %eax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq -0x30(%rbp), %r15
movq %r14, %rdi
callq 0xa104
movq %rdx, %rcx
movq (%r15), %rdx
movq (%rdx,%r13,8), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x9788
incq %r13
cmpq %r13, -0x38(%rbp)
jne 0x6955
jmp 0x6901
leaq 0x5395(%rip), %rdi      # 0xbd18
leaq 0x51f8(%rip), %rsi      # 0xbb82
leaq 0x51fb(%rip), %rcx      # 0xbb8c
movl $0xe2, %edx
callq 0x10d0
leaq 0x5371(%rip), %rdi      # 0xbd13
leaq 0x51d9(%rip), %rsi      # 0xbb82
leaq 0x5377(%rip), %rcx      # 0xbd27
movl $0x99, %edx
callq 0x10d0
leaq 0x5322(%rip), %rdi      # 0xbce3
jmp 0x69ca
leaq 0x52cf(%rip), %rdi      # 0xbc99
xorl %eax, %eax
callq 0x1a00
leaq 0x4d6b(%rip), %rdi      # 0xb743
leaq 0x4d71(%rip), %rsi      # 0xb750
leaq 0x4d76(%rip), %rcx      # 0xb75c
movl $0x7b, %edx
callq 0x10d0
leaq 0x55a2(%rip), %rdi      # 0xbf99
leaq 0x55a4(%rip), %rsi      # 0xbfa2
leaq 0x55af(%rip), %rcx      # 0xbfb4
movl $0x47, %edx
callq 0x10d0
jmp 0x6a11
movq %rax, %r14
movq %rbx, %rdi
callq 0x11f8
movq %r14, %rdi
callq 0x11c0