// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./semantic/semantic_analyzer.hpp
// Function: semantic_analyzer_t::validate_expression(expression_t*, symbol_table_t)
bool validate_expression(expression_t* expression, symbol_table_t symbols) {
		expression_type(expression, symbols);
		if (expression->type == et_character_literal) {
			// Expand the character literal.
			character_t expanded_literal = expand_literal(expression->character_literal, expression);
			if (expanded_literal.length() != 1) {
				die("multi-character character literal", expression);
				return false;
			}
			expression->character_literal = expanded_literal;
		} else if (expression->type == et_string_literal) {
			expression->string_literal = expand_literal(expression->string_literal, expression);
		} else if (expression->type == et_identifier) {
			// Identifiers are invalid if they are undefined or reserved.
			if (is_reserved(expression->identifier)) {
				die("cannot refer to reserved identifier '" + expression->identifier + "'", expression);
				return false;
			}
			else if (!symbols.exists(expression->identifier)) {
				die("unknown identifier '" + expression->identifier + "'", expression);
				return false;
			}
		} else if (expression->type == et_indexing) {
			indexing_expression_t indexing = expression->indexing;
			// An indexing expression is invalid if the array is invalid or
			// the index is invalid.
			if (!validate_expression(indexing.array, symbols)) {
				return false;
			} else if (!validate_expression(indexing.index, symbols)) {
				return false;
			}
			// An indexing expression is invalid if the index expression's
			// return type cannot be converted to int.
			type_t index_type = expression_type(indexing.index, symbols);
			if (!can_convert(index_type, {0})) {
				die("cannot convert index expression of type '" + prettyprint_type(index_type) + "' to 'int'", expression);
				return false;
			}
		} else if (expression->type == et_function_call) {
			function_call_expression_t function_call = expression->function_call;
			// It is valid to refer to functions that have not been defined.
			// However, there are many rules that can render an expression
			// invalid if the function being referred to has been defined.
			if (symbols.exists(function_call.function)) {
				// A function call expression is invalid if there is a
				// non-function symbol under the function call's function
				// identifier.
				if (!symbols.fetch(function_call.function).is_function) {
					die("called variable '" + function_call.function + "' is not a function", expression);
					return false;
				}
				// A function call expression is invalid if it's parameter count
				// is not equal to the parameter count of it's registered symbol.
				symbol_t function = symbols.fetch(function_call.function);
				if (function.parameters.size() != function_call.arguments.size()) {
					die("no matching function call to '" + function_call.function + "'", expression);
					return false;
				}
				// A function call expression is invalid if any of it's parameter
				// expression types cannot be converted to it's corresponding type
				// as defined in the function's registered symbol.
				for (int i = 0; i < function_call.arguments.size(); i++) {
					type_t parameter_type = expression_type(function_call.arguments[i], symbols);
					type_t expected_type = function.parameters[i].type;
					if (!can_convert(parameter_type, expected_type)) {
						die("cannot convert parameter expression of type '" + prettyprint_type(parameter_type) + "' to '" + prettyprint_type(expected_type) + "'", function_call.arguments[i]);
						return false;
					}
				}
			}
			// A function call expression is invalid if any of it's parameter
			// expressions are invalid.
			for (int i = 0; i < function_call.arguments.size(); i++) {
				if (!validate_expression(function_call.arguments[i], symbols)) {
					return false;
				}
			}
		} else if (expression->type == et_binary) {
			binary_expression_t binary = expression->binary;
			// Any binary expression is invalid if the operands are invalid.
			if (!validate_expression(binary.left_operand, symbols) ||
				!validate_expression(binary.right_operand, symbols))
			{
				return false;
			} else if (binary.binary_operator == bi_addition ||
					   binary.binary_operator == bi_subtraction ||
					   binary.binary_operator == bi_multiplication ||
					   binary.binary_operator == bi_division ||
					   binary.binary_operator == bi_modulo ||
					   binary.binary_operator == bi_assignment ||
					   binary.binary_operator == bi_addition_assignment ||
					   binary.binary_operator == bi_subtraction_assignment ||
					   binary.binary_operator == bi_multiplication_assignment ||
					   binary.binary_operator == bi_division_assignment ||
					   binary.binary_operator == bi_modulo_assignment ||
					   binary.binary_operator == bi_binary_and ||
					   binary.binary_operator == bi_binary_or ||
					   binary.binary_operator == bi_binary_xor ||
					   binary.binary_operator == bi_binary_and_assignment ||
					   binary.binary_operator == bi_binary_or_assignment ||
					   binary.binary_operator == bi_binary_xor_assignment ||
					   binary.binary_operator == bi_binary_left_shift ||
					   binary.binary_operator == bi_binary_right_shift ||
					   binary.binary_operator == bi_binary_left_shift_assignment ||
					   binary.binary_operator == bi_binary_right_shift_assignment ||

					   binary.binary_operator == bi_relational_equal ||
					   binary.binary_operator == bi_relational_non_equal)
			{
				// A binary expression of this type is invalid if the return
				// type of the right-hand operand cannot be converted to the
				// return type of the left-hand operand.
				type_t left_type = expression_type(binary.left_operand, symbols);
				type_t right_type = expression_type(binary.right_operand, symbols);
				if (!can_convert(left_type, right_type)) {
					die("invalid operands to binary expression ('" + prettyprint_type(left_type) + "' and '" + prettyprint_type(right_type) + "')", expression);
					return false;
				}
				if (binary.binary_operator == bi_assignment ||
				    binary.binary_operator == bi_addition_assignment ||
				    binary.binary_operator == bi_subtraction_assignment ||
				    binary.binary_operator == bi_multiplication_assignment ||
				    binary.binary_operator == bi_division_assignment ||
				    binary.binary_operator == bi_modulo_assignment ||
				    binary.binary_operator == bi_binary_and_assignment ||
					binary.binary_operator == bi_binary_or_assignment ||
					binary.binary_operator == bi_binary_xor_assignment ||
					binary.binary_operator == bi_binary_left_shift_assignment ||
					binary.binary_operator == bi_binary_right_shift_assignment)
				{
					// A binary expression of this type is invalid if the
					// left-hand operand is an rvalue.
					if (is_rvalue(binary.left_operand, symbols)) {
						die("expression is not assignable", binary.left_operand);
						return false;
					}
				}
				if (left_type.pointer_depth > 0) {
					if (binary.binary_operator == bi_multiplication ||
						binary.binary_operator == bi_division ||
						binary.binary_operator == bi_modulo ||
						binary.binary_operator == bi_multiplication_assignment ||
						binary.binary_operator == bi_division_assignment ||
						binary.binary_operator == bi_modulo_assignment ||
						binary.binary_operator == bi_binary_and ||
						binary.binary_operator == bi_binary_or ||
						binary.binary_operator == bi_binary_xor ||
						binary.binary_operator == bi_binary_and_assignment ||
						binary.binary_operator == bi_binary_or_assignment ||
						binary.binary_operator == bi_binary_xor_assignment ||
						binary.binary_operator == bi_binary_left_shift ||
						binary.binary_operator == bi_binary_right_shift ||
						binary.binary_operator == bi_binary_left_shift_assignment ||
						binary.binary_operator == bi_binary_right_shift_assignment)
					{
						// A binary expression of this type is invalid if the
						// left-hand operand is a pointer and the operator is
						// multiplication, division, modulo or any bitwise
						// operator.
						die("invalid operands to binary expression ('" + prettyprint_type(left_type) + "' and '" + prettyprint_type(right_type) + "')", expression);
						return false;
					} else if (binary.binary_operator == bi_addition) {
						if (right_type.pointer_depth > 0) {
							// It is invalid to add pointers.
							die("invalid operands to binary expression ('" + prettyprint_type(left_type) + "' and '" + prettyprint_type(right_type) + "')", expression);
							return false;
						}
					}
				} else if (right_type.pointer_depth > 0) {
					if (binary.binary_operator == bi_multiplication ||
						binary.binary_operator == bi_division ||
						binary.binary_operator == bi_modulo ||
						binary.binary_operator == bi_multiplication_assignment ||
						binary.binary_operator == bi_division_assignment ||
						binary.binary_operator == bi_modulo_assignment ||
						binary.binary_operator == bi_binary_and ||
						binary.binary_operator == bi_binary_or ||
						binary.binary_operator == bi_binary_xor ||
						binary.binary_operator == bi_binary_and_assignment ||
						binary.binary_operator == bi_binary_or_assignment ||
						binary.binary_operator == bi_binary_xor_assignment ||
						binary.binary_operator == bi_binary_left_shift ||
						binary.binary_operator == bi_binary_right_shift ||
						binary.binary_operator == bi_binary_left_shift_assignment ||
						binary.binary_operator == bi_binary_right_shift_assignment)
					{
						// A binary expression of this type is invalid if the
						// right-hand operand is a pointer and the operator is
						// multiplication, division, modulo or any bitwise
						// operator.
						die("invalid operands to binary expression ('" + prettyprint_type(left_type) + "' and '" + prettyprint_type(right_type) + "')", expression);
						return false;
					}
				}
			} else {
				// bi_logical_and
				// bi_logical_or
				// bi_relational_greater_than
				// bi_relational_lesser_than
				// bi_relational_greater_than_or_equal_to
				// bi_relational_lesser_than_or_equal_to
				//
				// A binary expression of this type is invalid if the return
				// type of either operand cannot be converted to int.
				type_t left_type = expression_type(binary.left_operand, symbols);
				type_t right_type = expression_type(binary.right_operand, symbols);
				if (!can_convert(left_type, {0}) ||
					!can_convert(right_type, {0}))
				{
					die("invalid operands to binary expression ('" + prettyprint_type(left_type) + "' and '" + prettyprint_type(right_type) + "')", expression);
					return false;
				}
			}
		} else if (expression->type == et_unary) {
			unary_expression_t unary = expression->unary;
			// Any unary expression is invalid if the operand is invalid.
			if (!validate_expression(unary.operand, symbols)) {
				return false;
			}
			else if (unary.unary_operator == un_value_of) {
				// A unary expression of this type is invalid if the operand's
				// pointer depth is less than 1.
				type_t operand_type = expression_type(unary.operand, symbols);
				if (operand_type.pointer_depth < 1) {
					die("cannot dereference expression of type '" + prettyprint_type(operand_type) + "'", expression);
					return false;
				}
			} else if (unary.unary_operator == un_arithmetic_positive ||
					   unary.unary_operator == un_arithmetic_negative ||
					   unary.unary_operator == un_binary_not)
			{
				// A unary expression of this type is invalid if the operand
				// is a pointer.
				type_t operand_type = expression_type(unary.operand, symbols);
				if (operand_type.pointer_depth > 0) {
					die("wrong type argument to unary operator ('" + prettyprint_type(operand_type) + "')", expression);
					return false;
				}
			} else {
				// un_address_of
				//
				// A unary expression of this type is invalid if the operand
				// is an rvalue.
				if (is_rvalue(unary.operand, symbols)) {
					die("cannot take the address of an rvalue of type '" + prettyprint_type(expression_type(unary.operand, symbols)) + "'", expression);
					return false;
				}
			}
		}
		return true;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7e8, %rsp            # imm = 0x7E8
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x688(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xc7c4
leaq 0x690(%rsp), %rdi
callq 0xdbb0
movl (%r14), %eax
decl %eax
cmpl $0x6, %eax
ja 0xc0a3
leaq 0x4a33(%rip), %rcx      # 0x10174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20(%r14), %r15
leaq 0x308(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x22e0
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0xce52
leaq 0x50(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22a0
movq %rbx, %rdi
callq 0x2100
leaq 0x308(%rsp), %rdi
callq 0x2100
jmp 0xc0a3
leaq 0xb8(%r14), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xd096
leaq 0x268(%rsp), %rdi
movq %r12, %rsi
callq 0x22e0
movq %rbx, (%rsp)
leaq 0x268(%rsp), %rsi
movq %r15, %rdi
callq 0xa168
movl %eax, %ebp
leaq 0x268(%rsp), %rdi
callq 0x2100
testb %bpl, %bpl
je 0xc032
leaq 0x248(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x22e0
leaq 0x248(%rsp), %rsi
movq %r15, %rdi
callq 0xcc74
movb 0x40(%rax), %bl
leaq 0x248(%rsp), %rdi
callq 0x2100
testb %bl, %bl
je 0xbe4a
leaq 0x208(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x22e0
movq (%rsp), %rbx
leaq 0x208(%rsp), %rsi
movq %r15, %rdi
callq 0xcc74
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0xa6b8
leaq 0x208(%rsp), %rdi
callq 0x2100
movq 0x80(%rsp), %rax
subq 0x78(%rsp), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r13, %r12
movq %r12, 0xa0(%rsp)
movq %r13, 0x48(%rsp)
jne 0xbfb7
leaq 0x790(%rsp), %r14
xorl %r12d, %r12d
leaq 0x788(%rsp), %r13
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
jbe 0xc019
movq (%rax,%r12,8), %rbp
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0xc7c4
movq %r14, %rdi
callq 0xdbb0
incq %r12
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
jmp 0xb8bd
leaq 0x88(%r14), %r12
leaq 0x7c8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x22e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0xcda8
movl %eax, %ebp
movq %r13, %rdi
callq 0x2100
testb %bpl, %bpl
je 0xbca9
leaq 0x51f6(%rip), %rsi      # 0x10b36
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0x6775
leaq 0x528e(%rip), %rdx      # 0x10be5
leaq 0x2a8(%rsp), %rdi
movq %r15, %rsi
callq 0x3ae1
leaq 0x2a8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x2a8(%rsp), %rdi
jmp 0xbd28
movq 0xa8(%r14), %r12
movq 0xb0(%r14), %r14
leaq 0x648(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xb6e4
movl %eax, %ebp
leaq 0x650(%rsp), %rdi
callq 0xdbb0
testb %bpl, %bpl
je 0xc43f
leaq 0x608(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xb6e4
movl %eax, %ebp
leaq 0x610(%rsp), %rdi
callq 0xdbb0
testb %bpl, %bpl
je 0xc43f
leaq 0x5c8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xc7c4
leaq 0x5d0(%rsp), %rdi
jmp 0xbb99
leaq 0x68(%r14), %r12
leaq 0x3a8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x22e0
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xce52
leaq 0x3a8(%rsp), %rdi
callq 0x2100
movq 0x58(%rsp), %r13
cmpq $0x1, %r13
jne 0xbd37
leaq 0x50(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2140
jmp 0xbd70
movq 0xf0(%r14), %r13
movq 0xf8(%r14), %r12
movl 0x100(%r14), %eax
movq %rax, (%rsp)
leaq 0x368(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xb6e4
testb %al, %al
je 0xbd89
leaq 0x328(%rsp), %rdi
movq %r15, %rsi
callq 0xc78c
leaq 0x328(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb6e4
movl %eax, %ebp
leaq 0x330(%rsp), %rdi
callq 0xdbb0
leaq 0x370(%rsp), %rdi
callq 0xdbb0
testb %bpl, %bpl
je 0xc43f
movq (%rsp), %rax
leal -0x13(%rax), %ecx
cmpl $0xa, %ecx
jb 0xbeac
cmpl $0xb, %eax
jb 0xbeac
addl $-0xd, %eax
cmpl $0x1, %eax
jbe 0xbeac
leaq 0x508(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0xc7c4
leaq 0x510(%rsp), %rdi
callq 0xdbb0
leaq 0x4c8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xc7c4
leaq 0x4d0(%rsp), %rdi
callq 0xdbb0
jmp 0xc0a3
movq 0x108(%r14), %r12
movq %rbx, %rbp
movl 0x110(%r14), %ebx
leaq 0x488(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbp, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xb6e4
movl %eax, %ebp
leaq 0x490(%rsp), %rdi
callq 0xdbb0
testb %bpl, %bpl
je 0xc43f
leal -0x1(%rbx), %eax
cmpl $0x2, %eax
jb 0xbd9b
cmpl $0x5, %ebx
je 0xbd9b
testl %ebx, %ebx
jne 0xc0aa
leaq 0x448(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc7c4
movq %rax, %r15
leaq 0x450(%rsp), %rdi
callq 0xdbb0
testq %r15, %r15
jg 0xc0a3
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3359
leaq 0x4fa4(%rip), %rsi      # 0x10c07
leaq 0x50(%rsp), %rdi
movq %r12, %rdx
callq 0x3ab3
leaq 0x4f6e(%rip), %rdx      # 0x10be5
leaq 0x148(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x148(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x148(%rsp), %rdi
jmp 0xbe31
leaq 0x2e8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x22e0
movq %r15, %rdi
movq %r13, %rsi
callq 0xa168
movl %eax, %ebp
leaq 0x2e8(%rsp), %rdi
callq 0x2100
testb %bpl, %bpl
jne 0xc0a3
leaq 0x4e76(%rip), %rsi      # 0x10b5c
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0x6775
leaq 0x4ee8(%rip), %rdx      # 0x10be5
leaq 0x288(%rsp), %rdi
movq %r15, %rsi
callq 0x3ae1
leaq 0x288(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x288(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
jmp 0xc43a
leaq 0x4dd6(%rip), %rsi      # 0x10b14
leaq 0x2c8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3a1e
leaq 0x2c8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x2c8(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x2100
cmpq $0x1, %r13
je 0xc0a3
jmp 0xc43f
leaq 0x370(%rsp), %rdi
callq 0xdbb0
jmp 0xc43f
leaq 0x408(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc7c4
movq %rax, %r15
leaq 0x410(%rsp), %rdi
callq 0xdbb0
testq %r15, %r15
jle 0xc0a3
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3359
leaq 0x4e3f(%rip), %rsi      # 0x10c2f
leaq 0x50(%rsp), %rdi
movq %r12, %rdx
callq 0x3ab3
leaq 0x4de3(%rip), %rdx      # 0x10be7
leaq 0x128(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x128(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x128(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x2100
leaq 0x10(%rsp), %rdi
jmp 0xc43a
leaq 0x4d20(%rip), %rsi      # 0x10b71
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6775
movq (%rsp), %rbx
leaq 0x4d18(%rip), %rdx      # 0x10b83
leaq 0x228(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x228(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x228(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x2100
jmp 0xc08a
movl %ecx, 0xc(%rsp)
leaq 0x588(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xc7c4
movq %rax, 0xa0(%rsp)
leaq 0x590(%rsp), %rdi
callq 0xdbb0
leaq 0x548(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xc7c4
movq %rax, 0x48(%rsp)
leaq 0x550(%rsp), %rdi
callq 0xdbb0
movq (%rsp), %rcx
movl %ecx, %r12d
andl $0x1e, %r12d
cmpl $0x16, %r12d
je 0xbf41
cmpl $0x1c, %ecx
ja 0xc181
movl $0x190007e0, %eax       # imm = 0x190007E0
btl %ecx, %eax
jae 0xc181
leaq 0x708(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xd0d0
movl %eax, %ebp
leaq 0x710(%rsp), %rdi
callq 0xdbb0
movq (%rsp), %rcx
testb %bpl, %bpl
je 0xc181
leaq 0x4c65(%rip), %rsi      # 0x10bea
leaq 0x1c8(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x3a1e
leaq 0x1c8(%rsp), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0xcc22
leaq 0x1c8(%rsp), %rdi
jmp 0xc43a
leaq 0x4bd9(%rip), %rsi      # 0x10b97
leaq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x6775
leaq 0x4c0e(%rip), %rdx      # 0x10be5
leaq 0x1e8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x3ae1
leaq 0x1e8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x1e8(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0xa0d6
movq 0x48(%rsp), %rax
cmpq %rax, 0xa0(%rsp)
jne 0xc08a
leaq 0x750(%rsp), %r14
xorl %ebx, %ebx
leaq 0x748(%rsp), %r12
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbx, %rcx
jbe 0xc099
movq (%rax,%rbx,8), %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0xc78c
movq (%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xb6e4
movl %eax, %ebp
movq %r14, %rdi
callq 0xdbb0
incq %rbx
testb %bpl, %bpl
jne 0xc044
leaq 0x10(%rsp), %rdi
callq 0x9afc
jmp 0xc43f
leaq 0x10(%rsp), %rdi
callq 0x9afc
movb $0x1, %al
jmp 0xc441
leaq 0x6c8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xd0d0
movl %eax, %ebp
leaq 0x6d0(%rsp), %rdi
callq 0xdbb0
testb %bpl, %bpl
je 0xc0a3
leaq 0x3c8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xc78c
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0xc7c4
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3359
leaq 0x4b40(%rip), %rsi      # 0x10c58
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3ab3
leaq 0x4ab7(%rip), %rdx      # 0x10be5
leaq 0x108(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x108(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x108(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x2100
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x3d0(%rsp), %rdi
jmp 0xbd91
movq 0xa0(%rsp), %rsi
testq %rsi, %rsi
jle 0xc295
cmpl $0xa, %ecx
movq 0x48(%rsp), %r13
je 0xc364
cmpl $0x4, %ecx
je 0xc364
cmpl $0x1c, %ecx
je 0xc364
movl %ecx, %eax
andl $0x1c, %eax
cmpl $0x18, %eax
je 0xc364
cmpl $0x5, 0xc(%rsp)
jb 0xc364
cmpl $0x2, %r12d
je 0xc364
cmpl $0x8, %r12d
je 0xc364
testl %ecx, %ecx
sete %al
testq %r13, %r13
setg %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xc0a3
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
callq 0x3359
leaq 0x49aa(%rip), %rsi      # 0x10bb6
leaq 0xa8(%rsp), %rdi
movq %r15, %rdx
callq 0x3ab3
leaq 0x49bc(%rip), %rdx      # 0x10bdf
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x3ae1
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x3359
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0xcd13
leaq 0x4984(%rip), %rdx      # 0x10be7
leaq 0x188(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x188(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x188(%rsp), %rdi
jmp 0xc3ff
movq 0x48(%rsp), %r13
testq %r13, %r13
jle 0xc0a3
cmpl $0xa, %ecx
je 0xc2c4
cmpl $0x4, %ecx
je 0xc2c4
cmpl $0xa, 0xc(%rsp)
jb 0xc2c4
cmpl $0x2, %r12d
je 0xc2c4
cmpl $0x8, %r12d
jne 0xc0a3
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
callq 0x3359
leaq 0x48db(%rip), %rsi      # 0x10bb6
leaq 0xa8(%rsp), %rdi
movq %r15, %rdx
callq 0x3ab3
leaq 0x48ed(%rip), %rdx      # 0x10bdf
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x3ae1
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x3359
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0xcd13
leaq 0x48b5(%rip), %rdx      # 0x10be7
leaq 0x168(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x168(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x168(%rsp), %rdi
jmp 0xc3ff
leaq 0xe8(%rsp), %r15
movq %r15, %rdi
callq 0x3359
leaq 0x483b(%rip), %rsi      # 0x10bb6
leaq 0xa8(%rsp), %rdi
movq %r15, %rdx
callq 0x3ab3
leaq 0x484d(%rip), %rdx      # 0x10bdf
leaq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x3ae1
leaq 0xc8(%rsp), %rdi
movq %r13, %rsi
callq 0x3359
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
callq 0xcd13
leaq 0x4815(%rip), %rdx      # 0x10be7
leaq 0x1a8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3ae1
leaq 0x1a8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xcc22
leaq 0x1a8(%rsp), %rdi
callq 0x2100
leaq 0x50(%rsp), %rdi
callq 0x2100
leaq 0xc8(%rsp), %rdi
callq 0x2100
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0xe8(%rsp), %rdi
callq 0x2100
xorl %eax, %eax
addq $0x7e8, %rsp            # imm = 0x7E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x168(%rsp), %rdi
jmp 0xc48c
jmp 0xc493
jmp 0xc4a2
jmp 0xc4b4
jmp 0xc4c3
jmp 0xc4e0
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
jmp 0xc48c
jmp 0xc493
jmp 0xc4a2
jmp 0xc4b4
jmp 0xc4c3
jmp 0xc4e0
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x2100
jmp 0xc496
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2100
jmp 0xc4a5
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x2100
jmp 0xc4b7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0xc4c6
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0xe8(%rsp), %rdi
jmp 0xc725
movq %rax, %rbx
jmp 0xc4d3
movq %rax, %rbx
leaq 0x148(%rsp), %rdi
jmp 0xc5de
jmp 0xc5e5
jmp 0xc5f4
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x2100
jmp 0xc514
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2100
jmp 0xc523
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0xc54a
movq %rax, %rbx
leaq 0x1c8(%rsp), %rdi
jmp 0xc725
movq %rax, %rbx
jmp 0xc783
movq %rax, %rbx
leaq 0x3d0(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x450(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
callq 0x2100
jmp 0xc57c
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2100
jmp 0xc74b
jmp 0xc748
movq %rax, %rbx
leaq 0x550(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x4d0(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x590(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x510(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x128(%rsp), %rdi
callq 0x2100
jmp 0xc5e8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2100
jmp 0xc5f7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xc725
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x2100
jmp 0xc616
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0xc6eb
jmp 0xc769
jmp 0xc769
movq %rax, %rbx
leaq 0x288(%rsp), %rdi
jmp 0xc6c2
movq %rax, %rbx
leaq 0x5d0(%rsp), %rdi
jmp 0xc762
jmp 0xc6d6
movq %rax, %rbx
leaq 0x410(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x208(%rsp), %rdi
jmp 0xc6eb
movq %rax, %rbx
leaq 0x248(%rsp), %rdi
jmp 0xc6eb
movq %rax, %rbx
leaq 0x2c8(%rsp), %rdi
callq 0x2100
jmp 0xc708
movq %rax, %rbx
leaq 0x330(%rsp), %rdi
callq 0xdbb0
jmp 0xc731
jmp 0xc6a2
movq %rax, %rbx
jmp 0xc708
movq %rax, %rbx
leaq 0x610(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x2a8(%rsp), %rdi
callq 0x2100
jmp 0xc6d9
movq %rax, %rbx
leaq 0x2e8(%rsp), %rdi
jmp 0xc725
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0xc725
movq %rax, %rbx
leaq 0x268(%rsp), %rdi
callq 0x2100
jmp 0xc779
movq %rax, %rbx
leaq 0x490(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
movq %r13, %r15
movq %r15, %rdi
jmp 0xc725
movq %rax, %rbx
leaq 0x650(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
leaq 0x308(%rsp), %rdi
callq 0x2100
jmp 0xc783
jmp 0xc769
movq %rax, %rbx
leaq 0x370(%rsp), %rdi
jmp 0xc762
movq %rax, %rbx
movq %r14, %rdi
callq 0xdbb0
jmp 0xc74b
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xa0d6
jmp 0xc779
movq %rax, %rbx
leaq 0x690(%rsp), %rdi
callq 0xdbb0
jmp 0xc783
movq %rax, %rbx
jmp 0xc779
movq %rax, %rbx
movq %r14, %rdi
callq 0xdbb0
leaq 0x10(%rsp), %rdi
callq 0x9afc
movq %rbx, %rdi
callq 0x2390
nop