// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/compiler.cc
// Function: Compiler::compile_expr(Expr*)
void compile_expr(Expr * expr)
	{
		switch (expr->kind) {
		case EXPR_NOTHING:
			push(BC::create(BC_LOAD_CONST,
							Value::nothing(),
							expr->assoc));
			break;
		case EXPR_UNARY:
			compile_expr(expr->unary.expr);
			compile_operator(expr->unary.op, expr->assoc);
			break;
		case EXPR_BINARY:
			compile_expr(expr->binary.left);
			compile_expr(expr->binary.right);
			compile_operator(expr->binary.op, expr->assoc);
			break;
		case EXPR_INTEGER:
			push(BC::create(BC_LOAD_CONST,
							Value::raise(expr->integer),
							expr->assoc));
			break;
		case EXPR_STRING:
			push(BC::create(BC_LOAD_CONST,
							Value::raise(expr->string),
							expr->assoc));
			push(BC::create(BC_SYMBOL_TO_STRING,
							expr->assoc));
			break;
		case EXPR_VARIABLE:
			push(BC::create(BC_LOAD_CONST,
							Value::raise(expr->variable),
							expr->assoc));
			push(BC::create(BC_RESOLVE_BINDING,
							expr->assoc));
			break;
		case EXPR_SCOPE: {
			auto body = expr->scope.body;
			auto terminator = expr->scope.terminator;
			push(BC::create(BC_ENTER_SCOPE, expr->assoc));
			for (int i = 0; i < body.size; i++) {
				compile_stmt(body[i]);
			}
			if (terminator) {
				compile_expr(terminator);
			} else {
				push(BC::create(BC_LOAD_CONST,
								Value::nothing(),
								expr->assoc));
			}
			push(BC::create(BC_EXIT_SCOPE, expr->assoc));
		} break;
		case EXPR_LAMBDA: {
			auto params = expr->lambda.parameters;
			for (int i = 0; i < params.size; i++) {
				push(BC::create(BC_LOAD_CONST,
								Value::raise(params[i]),
								expr->assoc));
			}
			push(BC::create(BC_LOAD_CONST,
							Value::raise(params.size),
							expr->assoc));
			Compiler compiler;
			compiler.init(blocks);
			compiler.compile_expr(expr->lambda.body);
			compiler.finalize();
			compiler.destroy();
			
			push(BC::create(BC_CONSTRUCT_FUNCTION,
							compiler.block_reference,
							expr->assoc));
		} break;
		case EXPR_FUNCALL: {
			auto args = expr->funcall.args;
			// Args are pushed in reverse order
			for (int i = args.size - 1; i >= 0; i--) {
				compile_expr(args[i]);
			}
			push(BC::create(BC_LOAD_CONST,
							Value::raise(args.size),
							expr->assoc));
			compile_expr(expr->funcall.func);
			push(BC::create(BC_POP_AND_CALL_FUNCTION,
							expr->assoc));
		} break;
		case EXPR_IF: {
			List<int> end_jumps;
			end_jumps.alloc();

			auto _if = expr->if_expr;
			assert(_if.conditions.size == _if.expressions.size);
			for (int i = 0; i < _if.conditions.size; i++) {
				compile_expr(_if.conditions[i]);
				push(BC::create(BC_NOT, _if.conditions[i]->assoc));
				push(BC::create(BC_POP_JUMP, _if.conditions[i]->assoc));
				int skip_pos = bytecode.size - 1;
				compile_expr(_if.expressions[i]);
				push(BC::create(BC_JUMP, _if.conditions[i]->assoc));
				end_jumps.push(bytecode.size - 1);
				bytecode[skip_pos].arg.integer = bytecode.size;
			}
			if (_if.else_expr) {
				compile_expr(_if.else_expr);
			} else {
				push(BC::create(BC_LOAD_CONST,
								Value::nothing(),
								expr->assoc));
			}
			push(BC::create(BC_NOP, expr->assoc));
			for (int i = 0; i < end_jumps.size; i++) {
				assert(bytecode[end_jumps[i]].kind == BC_JUMP);
				bytecode[end_jumps[i]].arg.integer = bytecode.size - 1;
			}
			
			end_jumps.dealloc();
		} break;
		case EXPR_DIRECTIVE: {
			auto name = expr->directive.name;
			auto args = expr->directive.arguments;
			if (name == Intern::intern("builtin")) {
				// @builtin directive
				if (args.size != 1) {
					fatal_assoc(expr->assoc, "@builtin directive expects one argument");
				}
				// TODO(pixlark): This is a little bit hacky because
				// it's not really a variable, it's meant to be a
				// compile-time symbol. They are technically the same
				// thing but still it feels like we're trying to build
				// a directive-based DSL here out of an AST that was
				// parsed for something else. Maybe there should be a
				// new subtree type for compile-time expressions.
				if (args[0]->kind != EXPR_VARIABLE) {
					fatal_assoc(args[0]->assoc, "@builtin directive expects constant symbol");
				}
				auto builtin_symbol = args[0]->variable;
				// Builtin binding
				auto builtin = Builtins::get_builtin(builtin_symbol);
				Value value = Value::create(TYPE_BUILTIN);
				value.builtin = builtin;
				push(BC::create(BC_LOAD_CONST, value, expr->assoc));
			} else if (name == Intern::intern("struct")) {
				// @struct directive
				auto args = expr->directive.arguments;
				for (int i = args.size - 1; i >= 0; i--) {
					if (args[i]->kind != EXPR_VARIABLE) {
						fatal_assoc(args[i]->assoc, "@struct directive expects constant symbols");
					}
					push(BC::create(BC_LOAD_CONST, Value::raise(args[i]->variable), args[i]->assoc));
				}
				push(BC::create(BC_LOAD_CONST, Value::raise(args.size), expr->assoc));
				push(BC::create(BC_CONSTRUCT_CONSTRUCTOR, expr->assoc));
			} else if (name == Intern::intern("import")) {
				// @import directive
				if (args.size != 1) {
					fatal_assoc(expr->assoc, "@import directive expects one argument");
				}
				const char * path;
				if (args[0]->kind == EXPR_STRING) {
					auto filename = args[0]->string;
					path = Files::path_for_file(filename);
				} else if (args[0]->kind == EXPR_VARIABLE) {
					auto filename = args[0]->variable;
					path = Files::stdlib_file(filename);
				} else {
					fatal_assoc(args[0]->assoc, "@import directive expects constant string or symbol");
				}
				defer { free((void*) path); };
				// Compile file into our global Blocks
				size_t block_reference = blocks->upcoming_block();
				auto source = load_and_compile_file(blocks, path);
				if (!source) {
					fatal_assoc(args[0]->assoc, "Source file '%s' does not exist", path);
				}
				// @Warning: Implicit cast from size_t->int
				push(BC::create(BC_LOAD_CONST, Value::raise(block_reference), expr->assoc));
				push(BC::create(BC_RUN_FILE_UNIT, expr->assoc));
			} else if (name == Intern::intern("export")) {
				for (int i = 0; i < args.size; i++) {
					if (args[i]->kind != EXPR_VARIABLE) {
						fatal_assoc(args[i]->assoc, "@export directive expects constant symbols");
					}
					push(BC::create(BC_LOAD_CONST, Value::raise(args[i]->variable), args[i]->assoc));
					push(BC::create(BC_EXPORT_SYMBOL, args[i]->assoc));
				}
			} else {
				// No such directive
				fatal_assoc(expr->assoc, "No such directive as '%s'", name);
			}
		} break;
		case EXPR_THIS: {
			push(BC::create(BC_THIS_FUNCTION, expr->assoc));
		} break;
		case EXPR_FIELD: {
			compile_expr(expr->field.left);
			push(BC::create(BC_LOAD_CONST, Value::raise(expr->field.right), expr->assoc));
			push(BC::create(BC_RESOLVE_FIELD, expr->assoc));
		} break;
		case EXPR_LOOP: {
            int push_body_pos = bytecode.size;
            push(BC::create(BC_PUSH_BODY, expr->assoc));

			// Create a dummy value to be popped by first iteration
			push(BC::create(BC_LOAD_CONST, Value::nothing(), expr->assoc));
            int beginning = bytecode.size;

			push(BC::create(BC_POP_AND_DISCARD, expr->assoc));
            compile_expr(expr->loop.body);

			push(BC::create(BC_DUPLICATE, expr->assoc));
            push(BC::create(BC_NOT, expr->assoc));
            push(BC::create(BC_POP_JUMP, beginning, expr->assoc));
            //push(BC::create(BC_LOAD_CONST, Value::nothing(), expr->assoc));

            int exit_pos = bytecode.size;
            push(BC::create(BC_NOP, expr->assoc));
            bytecode[push_body_pos].arg.integer = exit_pos;
		} break;
		case EXPR_ON: {
			push(BC::create(BC_GET_CALL_FLAG, Value::raise(expr->on.to_bind), expr->assoc));
			push(BC::create(BC_NOT, expr->assoc));
			
			int jump_pos = bytecode.size;
			push(BC::create(BC_POP_JUMP, expr->assoc));
			
			push(BC::create(BC_LOAD_CONST, Value::raise(expr->on.to_bind), expr->assoc));
			push(BC::create(BC_CREATE_BINDING, expr->assoc));
			compile_expr(expr->on.body);
			
			int exit_pos = bytecode.size;
			push(BC::create(BC_NOP, expr->assoc));
			bytecode[jump_pos].arg.integer = exit_pos;
		} break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl (%rsi), %eax
cmpq $0xe, %rax
ja 0x68da
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x3343(%rip), %rcx      # 0x921c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x4(%r13), %eax
movl $0x2, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
andl $0x0, -0xc8(%rbp)
andq $0x0, -0xc0(%rbp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
jmp 0x68d2
movq 0x8(%r13), %rax
movl 0x4(%r13), %ecx
movl $0x25, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
pushq $0x2
popq %r12
movl %r12d, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x19, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movslq 0x8(%rbx), %r15
movl 0x4(%r13), %eax
movl $0x1b, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq 0x8(%r13), %rax
movl 0x4(%r13), %ecx
movl %r12d, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
movl %r12d, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x4, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
jmp 0x65bd
movl 0x4(%r13), %eax
movl $0x15, -0xd0(%rbp)
jmp 0x62d1
movq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movl 0x4(%r13), %edx
movl 0x8(%r13), %esi
jmp 0x644e
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movq 0x10(%r13), %rax
movl 0x4(%r13), %ecx
pushq $0x2
popq %rdx
movl %edx, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
movl %edx, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x1f, -0xd0(%rbp)
jmp 0x62d1
andq $0x0, -0x68(%rbp)
movq $0x4, -0x60(%rbp)
movq 0x8eef(%rip), %rax      # 0xefd0
movq %rax, -0x58(%rbp)
movq 0x8edc(%rip), %rax      # 0xefc8
movq %rax, -0x50(%rbp)
pushq $0x10
popq %rdi
callq 0x1200
movq %rax, -0x70(%rbp)
movq %r13, -0xd8(%rbp)
leaq 0x8(%r13), %rsi
pushq $0xb
popq %rcx
leaq -0xd0(%rbp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq 0x8(%rax), %rcx
cmpq 0x30(%rax), %rcx
jne 0x6c29
xorl %r12d, %r12d
leaq -0xd0(%rbp), %r13
cmpq %r12, %rcx
jbe 0x6865
movq %r13, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5eac
movq %r13, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
movl $0x19, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq %r13, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
movl $0x1b, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x8(%rbx), %r15d
leaq -0xa8(%rbp), %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5eac
movq %r13, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
movl $0x1a, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x8(%rbx), %esi
decl %esi
leaq -0x70(%rbp), %rdi
callq 0x6d88
movl 0x8(%rbx), %r14d
decl %r15d
movslq %r15d, %rsi
movq %rbx, %rdi
callq 0x6db8
movl %r14d, 0x8(%rax)
incq %r12
movq -0xc8(%rbp), %rcx
jmp 0x612f
movq 0x8(%r13), %rax
movl 0x4(%r13), %ecx
pushq $0x2
popq %rdx
movl %edx, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
movl %edx, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x16, -0xd0(%rbp)
jmp 0x62d1
movq 0x8(%r13), %rax
movl 0x4(%r13), %ecx
pushq $0x2
popq %rdx
movl %edx, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
movl %edx, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x6, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
jmp 0x68ce
movq 0x28(%r13), %rax
leaq -0x70(%rbp), %r15
movq %rax, 0x20(%r15)
movups 0x8(%r13), %xmm0
movq %r13, %r14
movups 0x18(%r13), %xmm1
movaps %xmm1, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %r12d, %r12d
pushq $0x2
popq %r13
movq -0x68(%rbp), %rax
cmpq %r12, %rax
jbe 0x636b
movq %r15, %rdi
movq %r12, %rsi
callq 0x4838
movq (%rax), %rax
movl 0x4(%r14), %ecx
movl %r13d, -0xd0(%rbp)
movl %ecx, -0xcc(%rbp)
movl %r13d, -0xc8(%rbp)
movq %rax, -0xc0(%rbp)
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
incq %r12
jmp 0x6318
movl %eax, %eax
movl 0x4(%r14), %ecx
leaq -0xd0(%rbp), %r15
movl $0x2, (%r15)
movl %ecx, 0x4(%r15)
movl $0x1, 0x8(%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq 0x28(%rbx), %rsi
movq %r15, %rdi
callq 0x4ca8
movq 0x30(%r14), %rsi
movq %r15, %rdi
callq 0x5eac
movq %r15, %rdi
callq 0x4e9c
movq (%r15), %rdi
callq *0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq 0x30(%r15), %rax
movl 0x4(%r14), %ecx
movl $0x12, -0x40(%rbp)
movl %ecx, -0x3c(%rbp)
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
jmp 0x68ce
movl 0x4(%r13), %eax
movl 0x8(%r13), %ecx
movl $0x2, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movl $0x1, -0xc8(%rbp)
movq %rcx, -0xc0(%rbp)
movq %rcx, 0x10(%rsp)
jmp 0x62e3
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movq 0x18(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movl 0x4(%r13), %edx
movl 0x10(%r13), %esi
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6cca
movslq 0x8(%rbx), %r15
movl 0x4(%r13), %eax
movl $0x21, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x2, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
andl $0x0, -0xc8(%rbp)
andq $0x0, -0xc0(%rbp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x8(%rbx), %r12d
movl 0x4(%r13), %eax
movl $0x1, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movl 0x4(%r13), %eax
movl $0x3, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x19, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x1b, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movl %r12d, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x8(%rbx), %r14d
movl 0x4(%r13), %eax
andl $0x0, -0xd0(%rbp)
movl %eax, -0xcc(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6db8
movl %r14d, 0x8(%rax)
jmp 0x68da
movq 0x28(%r13), %rax
leaq -0xd0(%rbp), %r12
movq %rax, 0x20(%r12)
movups 0x8(%r13), %xmm0
movups 0x18(%r13), %xmm1
movaps %xmm1, 0x10(%r12)
movaps %xmm0, (%r12)
movq 0x30(%r13), %r15
movq %r13, %r14
movl 0x4(%r13), %eax
movl $0x1c, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
xorl %r13d, %r13d
cmpq %r13, -0xc8(%rbp)
jbe 0x667f
movq %r12, %rdi
movq %r13, %rsi
callq 0x4950
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4cf8
incq %r13
jmp 0x665b
testq %r15, %r15
je 0x6886
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5eac
jmp 0x68b3
movq 0x8(%r13), %r15
movq 0x30(%r13), %rax
movq %rax, -0xb0(%rbp)
movups 0x10(%r13), %xmm0
movups 0x20(%r13), %xmm1
movaps %xmm1, -0xc0(%rbp)
movaps %xmm0, -0xd0(%rbp)
leaq 0x3266(%rip), %rdi      # 0x992c
callq 0x15b3
cmpq %rax, %r15
je 0x68ec
leaq 0x32ac(%rip), %rdi      # 0x9987
callq 0x15b3
cmpq %rax, %r15
je 0x6a05
leaq 0x32c9(%rip), %rdi      # 0x99b9
callq 0x15b3
cmpq %rax, %r15
je 0x6af2
leaq 0x3336(%rip), %rdi      # 0x9a3b
callq 0x15b3
cmpq %rax, %r15
jne 0x6c61
xorl %r14d, %r14d
leaq -0xd0(%rbp), %r15
pushq $0x2
popq %r12
cmpq %r14, -0xc8(%rbp)
jbe 0x68da
movq %r15, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rax
movl (%rax), %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rax
cmpl $0x3, %r13d
jne 0x6c0c
movq 0x8(%rax), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %r12d, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movl %r12d, -0x68(%rbp)
movq %r13, -0x60(%rbp)
movq %r13, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq %r15, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
movl $0x24, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
incq %r14
jmp 0x6721
movups 0x10(%r13), %xmm0
movups 0x20(%r13), %xmm1
leaq -0xd0(%rbp), %r15
movaps %xmm0, (%r15)
movq 0x30(%r13), %rax
movq %rax, 0x20(%r15)
movaps %xmm1, 0x10(%r15)
movl 0x8(%r15), %r12d
decq %r12
testl %r12d, %r12d
js 0x6818
movl %r12d, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
movq %r15, %rdi
callq 0x4982
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5eac
jmp 0x67f2
movl -0xc8(%rbp), %eax
movl 0x4(%r13), %ecx
movl $0x2, -0x70(%rbp)
movl %ecx, -0x6c(%rbp)
movl $0x1, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0x5eac
movl 0x4(%r13), %eax
movl $0x13, -0x70(%rbp)
jmp 0x68be
movq -0x80(%rbp), %rsi
testq %rsi, %rsi
je 0x694f
movq %rbx, %rdi
callq 0x5eac
movq -0xd8(%rbp), %r14
jmp 0x6983
movl 0x4(%r14), %eax
movl $0x2, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
andl $0x0, -0x68(%rbp)
andq $0x0, -0x60(%rbp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r14), %eax
movl $0x1d, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x1, -0xc8(%rbp)
jne 0x6c48
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
movl (%rax), %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
cmpl $0x3, %r14d
jne 0x6c55
movq 0x8(%rax), %rdi
callq 0x42e4
movl 0x4(%r13), %ecx
movl $0x2, -0x70(%rbp)
movl %ecx, -0x6c(%rbp)
movl $0x3, -0x68(%rbp)
movq %rax, -0x60(%rbp)
jmp 0x68c5
movq -0xd8(%rbp), %r14
movl 0x4(%r14), %eax
movl $0x2, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
andl $0x0, -0x38(%rbp)
andq $0x0, -0x30(%rbp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r14), %eax
andl $0x0, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
xorl %r14d, %r14d
leaq -0x70(%rbp), %r15
cmpq %r14, -0x68(%rbp)
jbe 0x69f9
movq %r15, %rdi
movq %r14, %rsi
callq 0x6de8
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x6db8
cmpl $0x1a, (%rax)
jne 0x6bed
movl 0x8(%rbx), %r12d
decl %r12d
movq %r15, %rdi
movq %r14, %rsi
callq 0x6de8
movslq (%rax), %rsi
movq %rbx, %rdi
callq 0x6db8
movl %r12d, 0x8(%rax)
incq %r14
jmp 0x69ae
movq -0x70(%rbp), %rdi
callq *-0x50(%rbp)
jmp 0x68da
movq %r13, -0xd8(%rbp)
leaq 0x10(%r13), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
leaq -0x70(%rbp), %r15
movaps %xmm0, (%r15)
movq 0x20(%rax), %rax
movq %rax, 0x20(%r15)
movaps %xmm1, 0x10(%r15)
movl 0x8(%r15), %r13d
decq %r13
testl %r13d, %r13d
js 0x6aa7
movl %r13d, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
movq %r15, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
movl (%rax), %r14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
cmpl $0x3, %r14d
jne 0x6c18
movq 0x8(%rax), %r14
movq %r15, %rdi
movq %r12, %rsi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %eax
pushq $0x2
popq %rcx
movl %ecx, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
movl %ecx, -0x38(%rbp)
movq %r14, -0x30(%rbp)
movq %r14, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
jmp 0x6a30
movl -0x68(%rbp), %eax
movq -0xd8(%rbp), %r14
movl 0x4(%r14), %ecx
movl $0x2, -0x40(%rbp)
movl %ecx, -0x3c(%rbp)
movl $0x1, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq %rax, 0x10(%rsp)
movups -0x40(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r14), %eax
movl $0x1e, -0x40(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x63e9
cmpq $0x1, -0xc8(%rbp)
jne 0x6c71
leaq -0xd0(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
movl (%rax), %r14d
movq %r15, %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
cmpl $0x2, %r14d
jne 0x6b35
movq 0x8(%rax), %rdi
callq 0x1e91
jmp 0x6b5c
movl (%rax), %r14d
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
cmpl $0x3, %r14d
jne 0x6ca4
movq 0x8(%rax), %rdi
callq 0x1def
leaq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq %rcx, -0xe0(%rbp)
movq 0x28(%rbx), %rdi
movl 0x8(%rdi), %r15d
movq %rax, %rsi
callq 0x4365
testq %rax, %rax
je 0x6c7e
movl 0x4(%r13), %eax
movl $0x2, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movl $0x1, -0x68(%rbp)
movq %r15, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
movl 0x4(%r13), %eax
movl $0x23, -0x70(%rbp)
movl %eax, -0x6c(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x70(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x6ef2
leaq -0xe0(%rbp), %rdi
callq 0x6ee2
jmp 0x68da
leaq 0x2d11(%rip), %rdi      # 0x9905
leaq 0x2cd6(%rip), %rsi      # 0x98d1
leaq 0x2cdf(%rip), %rcx      # 0x98e1
movl $0xb8, %edx
callq 0x10d0
movl 0x4(%rax), %edi
leaq 0x2e2c(%rip), %rsi      # 0x9a42
jmp 0x6c22
movl 0x4(%rax), %edi
leaq 0x2d6c(%rip), %rsi      # 0x998e
xorl %eax, %eax
callq 0x1b51
leaq 0x2c75(%rip), %rdi      # 0x98a5
leaq 0x2c9a(%rip), %rsi      # 0x98d1
leaq 0x2ca3(%rip), %rcx      # 0x98e1
movl $0xa4, %edx
callq 0x10d0
movl 0x4(%r13), %edi
leaq 0x2ce1(%rip), %rsi      # 0x9934
jmp 0x6c22
movl 0x4(%rax), %edi
leaq 0x2cfd(%rip), %rsi      # 0x995c
jmp 0x6c22
movl 0x4(%r13), %edi
leaq 0x2e01(%rip), %rsi      # 0x9a6d
movq %r15, %rdx
jmp 0x6c9d
movl 0x4(%r13), %edi
leaq 0x2d44(%rip), %rsi      # 0x99c0
jmp 0x6c22
leaq -0xd0(%rbp), %rdi
xorl %esi, %esi
callq 0x4982
movq (%rax), %rax
movl 0x4(%rax), %edi
movq -0x40(%rbp), %rdx
leaq 0x2d7e(%rip), %rsi      # 0x9a1b
xorl %eax, %eax
callq 0x1b51
movl 0x4(%rax), %edi
leaq 0x2d39(%rip), %rsi      # 0x99e7
jmp 0x6c22
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x6ee2
movq %rbx, %rdi
callq 0x11c0