// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/typecheck_expression.c
// Function: typecheck_expression
struct Expr typecheck_expression(struct AnalyzerState *ptr_ps,
                                 const struct UntypedExpr *ref_uexpr)
{
	const struct UntypedExpr uexpr = *ref_uexpr;
	switch (uexpr.category) {
	case AMPERSAND_DOT: {
		struct Expr struct_or_union_expr =
		    typecheck_expression(ptr_ps, uexpr.ptr1);
		const char *ident_after_dot = uexpr.ident_after_dot;
		if (!is_struct_or_union(&struct_or_union_expr.details.type)) {
			fprintf(stderr, "member is requested but the left operand is "
			                "neither a struct nor a union\n");
			exit(EXIT_FAILURE);
		}

		const char *tag =
		    struct_or_union_expr.details.type.s.struct_or_union_tag;
		const struct StructOrUnionInternalCompleteInfo *ptr_info =
		    lookup(ptr_ps->global_struct_or_union_tag_map, tag);
		if (!ptr_info) {
			fprintf(stderr,
			        "tried to use a member of incomplete type `struct %s` / "
			        "`union %s`\n",
			        tag, tag);
			exit(EXIT_FAILURE);
		}

		struct Vector /* <TypeAndIdent> */ vec =
		    *ptr_info->info.ptr_types_and_idents;
		int nth_member = -1;

		struct Expr expr;
		for (int i = 0; i < vec.length; i++) {
			const struct TypeAndIdent *ptr_vec_i = vec.vector[i];
			if (strcmp(ptr_vec_i->ident_str, ident_after_dot) == 0) {
				nth_member = i;

				struct Type t2 = ptr_vec_i->type;
				struct Type t3 = ptr_to_type(&t2);
				expr.details.type = t3;
				expr.details.true_type = t3;
				break;
			}
		}

		if (nth_member == -1) {
			fprintf(stderr, "member `%s` does not belong to struct `%s`\n",
			        ident_after_dot, tag);
			exit(EXIT_FAILURE);
		}

		int offset = ptr_info->offset_vec[nth_member];

		struct Expr *ptr_struct_or_union_expr = calloc(1, sizeof(struct Expr));
		*ptr_struct_or_union_expr = struct_or_union_expr;

		expr.category = PTR_STRUCT_AND_OFFSET;
		expr.struct_offset = offset;
		expr.ptr1 = ptr_struct_or_union_expr;
		expr.ptr2 = 0;
		expr.ptr3 = 0;
		return expr;
	}
	case SIZEOF_TYPE: {
		struct Expr expr;
		expr.details.type = INT_TYPE();
		expr.int_value = size_of(ptr_ps, &uexpr.operand_of_sizeof_or_alignof);
		expr.category = INT_VALUE;
		return expr;
	}
	case ALIGNOF_TYPE: {
		struct Expr expr;
		expr.details.type = INT_TYPE();
		expr.int_value = align_of(ptr_ps, &uexpr.operand_of_sizeof_or_alignof);
		expr.category = INT_VALUE;
		return expr;
	}
	case UNARY_EXPR: {
		enum TokenKind kind = uexpr.operator_;
		const struct Expr expr = typecheck_expression(ptr_ps, uexpr.ptr1);
		return typecheck_unary_expression(ptr_ps, &expr, kind);
	}
	case FUNC_PTR_CALL: {
		struct Expr fp_expr = typecheck_expression(ptr_ps, uexpr.ptr1);

		struct Type fn_type;
		if (fp_expr.details.type.type_category == FN) {
			fn_type = fp_expr.details.type;
		} else if (fp_expr.details.type.type_category == PTR_ &&
		           fp_expr.details.type.derived_from->type_category == FN) {
			fn_type = *(fp_expr.details.type.derived_from);
		} else {
			fprintf(
			    stderr,
			    "function call operator was applied to something of type `");
			debug_print_type(&fp_expr.details.type);
			fprintf(stderr,
			        "`, which is neither a function nor a function pointer\n");
			exit(EXIT_FAILURE);
		}

		int param_infos_validity = fn_type.param_infos_validity;
		struct Vector /*<TypeAndIdent>*/ param_infos;

		if (param_infos_validity != INVALID) {
			param_infos = fn_type.param_infos;
		}

		struct Expr expr =
		    func_call_expr(ptr_ps, fn_type.derived_from,
		                   param_infos_validity != INVALID ? &param_infos : 0,
		                   &uexpr.arg_exprs_vec, 1 /* is_fp_call */);

		struct Expr *ptr_fp_expr = calloc(1, sizeof(struct Expr));
		*ptr_fp_expr = fp_expr;
		expr.ptr1 = ptr_fp_expr;

		return expr;
	}
	case BUILTIN_FUNCCALL: {
		const char *ident_str = uexpr.var_name;
		struct Expr expr = builtin_func_call_expr(ptr_ps, &uexpr.arg_exprs_vec);
		expr.global_var_name = ident_str;
		return expr;
	}
	case FUNCCALL: {
		const char *ident_str = uexpr.var_name;

		struct Type ret_type;

		int param_infos_validity;
		struct Vector /*<TypeAndIdent>*/ param_infos;
		if (!isElem(ptr_ps->func_info_map, ident_str)) {
			if (from_name_to_expr(ptr_ps, ident_str)) {
				struct UntypedExpr *p_fp_u =
				    calloc(1, sizeof(struct UntypedExpr));
				p_fp_u->category = VAR;
				p_fp_u->var_name = ident_str;

				struct UntypedExpr u = uexpr;
				u.category = FUNC_PTR_CALL;
				u.ptr1 = p_fp_u;

				return typecheck_expression(ptr_ps, &u);
			}
			fprintf(stderr, "Undeclared function `%s()` detected.\n",
			        ident_str);
			fprintf(stderr, "Assumes that `%s()` returns `int`\n", ident_str);
			ret_type = INT_TYPE();
			param_infos_validity = INVALID;
		} else {
			struct Type *ptr_func_info =
			    lookup(ptr_ps->func_info_map, ident_str);
			ret_type = *(ptr_func_info->derived_from);
			param_infos_validity = ptr_func_info->param_infos_validity;
			if (param_infos_validity != INVALID) {
				param_infos = ptr_func_info->param_infos;
			}
		}

		struct Expr expr =
		    func_call_expr(ptr_ps, &ret_type,
		                   param_infos_validity != INVALID ? &param_infos : 0,
		                   &uexpr.arg_exprs_vec, 0 /* is_fp_call */);
		expr.global_var_name = ident_str;
		return expr;
	}
	case POSTFIX_EXPR: {
		struct Expr expr = typecheck_expression(ptr_ps, uexpr.ptr1);
		struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
		*ptr_expr1 = expr;

		enum TokenKind opkind = uexpr.operator_;

		struct Expr new_expr;
		new_expr.details.type = expr.details.type;
		new_expr.details.true_type = expr.details.type;
		new_expr.category =
		    opkind == OP_PLUS_PLUS ? POSTFIX_INCREMENT : POSTFIX_DECREMENT;
		new_expr.ptr1 = ptr_expr1;
		new_expr.ptr2 = 0;
		new_expr.ptr3 = 0;
		if (expr.details.type.type_category == PTR_) {
			const struct Type deref = deref_type(&expr.details.type);
			new_expr.size_info_for_pointer_arith = size_of(ptr_ps, &deref);
		}

		return new_expr;
	}
	case INT_LITERAL_: {
		struct Expr expr;
		expr.details.type = INT_TYPE();
		expr.int_value = uexpr.int_value;
		expr.category = INT_VALUE;
		return expr;
	}
	case VAR: {
		struct Expr *p = from_name_to_expr(ptr_ps, uexpr.var_name);
		if (!p) {
			fprintf(stderr, "%s is not declared either globally or locally\n",
			        uexpr.var_name);
			exit(EXIT_FAILURE);
		}
		return *p;
	}
	case STRING_LITERAL_: {
		return string_literal(uexpr.literal_string);
	}
	case CONDITIONAL: {
		struct Expr expr = typecheck_expression(ptr_ps, uexpr.ptr1);
		struct Expr true_branch = typecheck_expression(ptr_ps, uexpr.ptr2);
		struct Expr false_branch = typecheck_expression(ptr_ps, uexpr.ptr3);

		if_function_cast_to_pointer(&true_branch);
		if_function_cast_to_pointer(&false_branch);

		if (false_branch.details.type.type_category == PTR_) {
			cast_to_null_pointer_if_possible(&true_branch,
			                                 &false_branch.details);
		} else if (true_branch.details.type.type_category == PTR_) {
			cast_to_null_pointer_if_possible(&false_branch,
			                                 &true_branch.details);
		}

		expect_type(ptr_ps, &false_branch.details.type,
		            &true_branch.details.type,
		            "mismatch of type between the false branch and the true "
		            "branch of a conditional operator");
		struct Expr *ptr_expr1 = calloc(1, sizeof(struct Expr));
		struct Expr *ptr_expr2 = calloc(1, sizeof(struct Expr));
		struct Expr *ptr_expr3 = calloc(1, sizeof(struct Expr));
		*ptr_expr1 = expr;
		*ptr_expr2 = true_branch;
		*ptr_expr3 = false_branch;

		struct Expr new_expr;
		new_expr.details = true_branch.details;
		new_expr.category = CONDITIONAL_EXPR;
		new_expr.ptr1 = ptr_expr1;
		new_expr.ptr2 = ptr_expr2;
		new_expr.ptr3 = ptr_expr3;
		return new_expr;
	}
	case BINARY_EXPR: {
		const struct Expr expr = typecheck_expression(ptr_ps, uexpr.ptr1);
		const struct Expr expr2 = typecheck_expression(ptr_ps, uexpr.ptr2);
		return typecheck_binary_expression(ptr_ps, &expr, &expr2,
		                                   uexpr.operator_);
	}
	}
	fprintf(stderr,
	        "****************************\n"
	        "* INTERNAL COMPILER ERROR @ %s\n"
	        "* Unexpected value in UntypedExprCategory: `uexpr.category` is `%d`\n"
	        "****************************\n",
	        __func__, uexpr.category);
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe40, %rsp            # imm = 0xE40
movq %rdi, -0xe10(%rbp)
movq %rdi, -0xe08(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movl $0xa0, %edx
callq 0x10e0
movl -0xac(%rbp), %eax
movq %rax, -0xe00(%rbp)
subq $0xc, %rax
ja 0x7cb6
movq -0xe00(%rbp), %rax
leaq 0xd4f5(%rip), %rcx      # 0x14680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x1b0(%rbp), %rdi
callq 0x7130
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xb250
cmpl $0x0, %eax
jne 0x71e9
movq 0x14e2a(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xd889(%rip), %rsi      # 0x14a61
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0x180(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x1c0(%rbp), %rsi
callq 0xcc00
movq %rax, -0x1c8(%rbp)
cmpq $0x0, -0x1c8(%rbp)
jne 0x724c
movq 0x14dd5(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x1c0(%rbp), %rdx
movq -0x1c0(%rbp), %rcx
leaq 0xd870(%rip), %rsi      # 0x14aab
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0x1c8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq %rcx, -0x1d8(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x1d0(%rbp)
movl $0xffffffff, -0x1dc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1e0(%rbp)
movl -0x1e0(%rbp), %eax
cmpl -0x1d8(%rbp), %eax
jge 0x7349
movq -0x1d0(%rbp), %rax
movslq -0x1e0(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x1b8(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x7333
movl -0x1e0(%rbp), %eax
movl %eax, -0x1dc(%rbp)
movq -0x1e8(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x50, %edx
callq 0x10e0
leaq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0xb8a0
movq -0xe10(%rbp), %rdi
leaq -0x288(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0xe10(%rbp), %rdi
addq $0x50, %rdi
leaq -0x288(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
jmp 0x7349
jmp 0x7335
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0x727f
cmpl $-0x1, -0x1dc(%rbp)
jne 0x7382
movq 0x14c9f(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x1b8(%rbp), %rdx
movq -0x1c0(%rbp), %rcx
leaq 0xd77d(%rip), %rsi      # 0x14aee
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0x1c8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1dc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28c(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x298(%rbp)
movq -0x298(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xe10(%rbp), %rax
movl $0x1a, 0xa0(%rax)
movl -0x28c(%rbp), %ecx
movl %ecx, 0xfc(%rax)
movq -0x298(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
jmp 0x7ce5
leaq -0x2e8(%rbp), %rdi
callq 0xb230
movq -0xe10(%rbp), %rdi
leaq -0x2e8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
addq $0x48, %rsi
callq 0x2570
movl %eax, %ecx
movq -0xe10(%rbp), %rax
movl %ecx, 0xc8(%rax)
movl $0x9, 0xa0(%rax)
jmp 0x7ce5
leaq -0x338(%rbp), %rdi
callq 0xb230
movq -0xe10(%rbp), %rdi
leaq -0x338(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0x8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
addq $0x48, %rsi
callq 0x2720
movl %eax, %ecx
movq -0xe10(%rbp), %rax
movl %ecx, 0xc8(%rax)
movl $0x9, 0xa0(%rax)
jmp 0x7ce5
movl -0xb0(%rbp), %eax
movl %eax, -0x33c(%rbp)
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x440(%rbp), %rdi
callq 0x7130
movq -0xe10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0x33c(%rbp), %ecx
leaq -0x440(%rbp), %rdx
callq 0x6ce0
jmp 0x7ce5
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x540(%rbp), %rdi
callq 0x7130
cmpl $0x3, -0x540(%rbp)
jne 0x753c
leaq -0x540(%rbp), %rsi
leaq -0x590(%rbp), %rdi
movl $0x50, %edx
callq 0x10e0
jmp 0x75b3
cmpl $0x1, -0x540(%rbp)
jne 0x756b
movq -0x538(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x756b
movq -0x538(%rbp), %rsi
leaq -0x590(%rbp), %rdi
movl $0x50, %edx
callq 0x10e0
jmp 0x75b1
movq 0x14a86(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xd59e(%rip), %rsi      # 0x14b1a
movb $0x0, %al
callq 0x10d0
leaq -0x540(%rbp), %rdi
callq 0xb390
movq 0x14a62(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xd5b4(%rip), %rsi      # 0x14b54
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
jmp 0x75b3
movl -0x568(%rbp), %eax
movl %eax, -0x594(%rbp)
cmpl $0x0, -0x594(%rbp)
je 0x75e4
movq -0x578(%rbp), %rax
movq %rax, -0x5a8(%rbp)
movq -0x570(%rbp), %rax
movq %rax, -0x5a0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe20(%rbp)
movq -0x588(%rbp), %rax
movq %rax, -0xe18(%rbp)
cmpl $0x0, -0x594(%rbp)
je 0x7616
leaq -0x5a8(%rbp), %rax
movq %rax, -0xe28(%rbp)
jmp 0x7621
xorl %eax, %eax
movq %rax, -0xe28(%rbp)
jmp 0x7621
movq -0xe10(%rbp), %rdi
movq -0xe18(%rbp), %rdx
movq -0xe20(%rbp), %rsi
movq -0xe28(%rbp), %rcx
leaq -0xb0(%rbp), %r8
addq $0x38, %r8
movl $0x1, %r9d
callq 0x7d00
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x5b0(%rbp)
movq -0x5b0(%rbp), %rdi
leaq -0x540(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xe10(%rbp), %rax
movq -0x5b0(%rbp), %rcx
movq %rcx, 0xb0(%rax)
jmp 0x7ce5
movq -0xe10(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x5b8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
addq $0x38, %rdx
callq 0x7000
movq -0xe10(%rbp), %rax
movq -0x5b8(%rbp), %rcx
movq %rcx, 0xd0(%rax)
jmp 0x7ce5
movq -0x88(%rbp), %rax
movq %rax, -0x5c0(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x5c0(%rbp), %rsi
callq 0xcc90
cmpl $0x0, %eax
jne 0x7813
movq -0x8(%rbp), %rdi
movq -0x5c0(%rbp), %rsi
callq 0x8120
cmpq $0x0, %rax
je 0x77a5
movl $0x1, %edi
movl $0xa0, %esi
callq 0x10b0
movq %rax, -0x630(%rbp)
movq -0x630(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x5c0(%rbp), %rcx
movq -0x630(%rbp), %rax
movq %rcx, 0x28(%rax)
leaq -0x6d0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0xe10(%rbp), %rdi
movl $0x7, -0x6cc(%rbp)
movq -0x630(%rbp), %rax
movq %rax, -0x6c8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x6d0(%rbp), %rdx
callq 0x7130
jmp 0x7ce5
movq 0x1484c(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x5c0(%rbp), %rdx
leaq 0xd3ce(%rip), %rsi      # 0x14b8b
movb $0x0, %al
callq 0x10d0
movq 0x1482d(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x5c0(%rbp), %rdx
leaq 0xd3d5(%rip), %rsi      # 0x14bb1
movb $0x0, %al
callq 0x10d0
leaq -0x720(%rbp), %rdi
callq 0xb230
leaq -0x610(%rbp), %rdi
leaq -0x720(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movl $0x0, -0x614(%rbp)
jmp 0x7882
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x5c0(%rbp), %rsi
callq 0xcc00
movq %rax, -0x728(%rbp)
movq -0x728(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x610(%rbp), %rdi
movl $0x50, %edx
callq 0x10e0
movq -0x728(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x614(%rbp)
cmpl $0x0, -0x614(%rbp)
je 0x7880
movq -0x728(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x628(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x620(%rbp)
jmp 0x7882
movq -0x8(%rbp), %rax
movq %rax, -0xe30(%rbp)
cmpl $0x0, -0x614(%rbp)
je 0x78a6
leaq -0x628(%rbp), %rax
movq %rax, -0xe38(%rbp)
jmp 0x78b1
xorl %eax, %eax
movq %rax, -0xe38(%rbp)
jmp 0x78b1
movq -0xe10(%rbp), %rdi
movq -0xe30(%rbp), %rsi
movq -0xe38(%rbp), %rcx
leaq -0xb0(%rbp), %r8
addq $0x38, %r8
leaq -0x610(%rbp), %rdx
xorl %r9d, %r9d
callq 0x7d00
movq -0xe10(%rbp), %rax
movq -0x5c0(%rbp), %rcx
movq %rcx, 0xd0(%rax)
jmp 0x7ce5
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x828(%rbp), %rdi
callq 0x7130
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0x830(%rbp)
movq -0x830(%rbp), %rdi
leaq -0x828(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xe10(%rbp), %rdi
movl -0xb0(%rbp), %eax
movl %eax, -0x834(%rbp)
leaq -0x828(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0xe10(%rbp), %rdi
addq $0x50, %rdi
leaq -0x828(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0xe10(%rbp), %rax
movl -0x834(%rbp), %esi
movl $0xb, %ecx
movl $0xa, %edx
cmpl $0x32, %esi
cmovel %edx, %ecx
movl %ecx, 0xa0(%rax)
movq -0x830(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
cmpl $0x1, -0x828(%rbp)
jne 0x7a01
leaq -0x828(%rbp), %rsi
leaq -0x888(%rbp), %rdi
callq 0xb800
movq -0x8(%rbp), %rdi
leaq -0x888(%rbp), %rsi
callq 0x2570
movl %eax, %ecx
movq -0xe10(%rbp), %rax
movl %ecx, 0xf4(%rax)
jmp 0x7ce5
leaq -0x8d8(%rbp), %rdi
callq 0xb230
movq -0xe10(%rbp), %rdi
leaq -0x8d8(%rbp), %rsi
movl $0x50, %edx
callq 0x10e0
movq -0xe10(%rbp), %rax
movl -0x90(%rbp), %ecx
movl %ecx, 0xc8(%rax)
movl $0x9, 0xa0(%rax)
jmp 0x7ce5
movq -0x8(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x8120
movq %rax, -0x8e0(%rbp)
cmpq $0x0, -0x8e0(%rbp)
jne 0x7a96
movq 0x14584(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq -0x88(%rbp), %rdx
leaq 0xd14f(%rip), %rsi      # 0x14bd4
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0xe10(%rbp), %rdi
movq -0x8e0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
jmp 0x7ce5
movq -0xe10(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x84c0
jmp 0x7ce5
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x9e0(%rbp), %rdi
callq 0x7130
movq -0x8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0xae0(%rbp), %rdi
callq 0x7130
movq -0x8(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0xbe0(%rbp), %rdi
callq 0x7130
leaq -0xae0(%rbp), %rdi
callq 0x6bc0
leaq -0xbe0(%rbp), %rdi
callq 0x6bc0
cmpl $0x1, -0xbe0(%rbp)
jne 0x7b43
leaq -0xbe0(%rbp), %rsi
leaq -0xae0(%rbp), %rdi
callq 0x6b70
jmp 0x7b61
cmpl $0x1, -0xae0(%rbp)
jne 0x7b5f
leaq -0xae0(%rbp), %rsi
leaq -0xbe0(%rbp), %rdi
callq 0x6b70
jmp 0x7b61
movq -0x8(%rbp), %rdi
leaq -0xbe0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq 0xd089(%rip), %rcx      # 0x14c03
callq 0x6630
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0xbe8(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0xbf0(%rbp)
movl $0x1, %edi
movl $0x100, %esi            # imm = 0x100
callq 0x10b0
movq %rax, -0xbf8(%rbp)
movq -0xbe8(%rbp), %rdi
leaq -0x9e0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xbf0(%rbp), %rdi
leaq -0xae0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xbf8(%rbp), %rdi
leaq -0xbe0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0xe10(%rbp), %rdi
leaq -0xae0(%rbp), %rsi
movl $0xa0, %edx
callq 0x10e0
movq -0xe10(%rbp), %rax
movl $0x5, 0xa0(%rax)
movq -0xbe8(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0xbf0(%rbp), %rcx
movq %rcx, 0xb8(%rax)
movq -0xbf8(%rbp), %rcx
movq %rcx, 0xc0(%rax)
jmp 0x7ce5
movq -0x8(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0xcf8(%rbp), %rdi
callq 0x7130
movq -0x8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0xdf8(%rbp), %rdi
callq 0x7130
movq -0xe10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl -0xb0(%rbp), %r8d
leaq -0xcf8(%rbp), %rdx
leaq -0xdf8(%rbp), %rcx
callq 0x8590
jmp 0x7ce5
movq 0x1433b(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl -0xac(%rbp), %ecx
leaq 0xcf8e(%rip), %rsi      # 0x14c5b
leaq 0xd025(%rip), %rdx      # 0x14cf9
movb $0x0, %al
callq 0x10d0
movl $0x1, %edi
callq 0x1150
movq -0xe08(%rbp), %rax
addq $0xe40, %rsp            # imm = 0xE40
popq %rbp
retq
nopw %cs:(%rax,%rax)