// File: /workspace/github_c_makefile_star2_O0/hsjoihs[P]c-compiler/parse_analyze_statement.c
// Function: parse_statement
struct Statement parse_statement(struct AnalyzerState *ptr_ps,
                                 const struct Token **ptr_tokvec)
{
	const struct Token *tokvec = *ptr_tokvec;
	if (tokvec[0].kind == RES_CASE || tokvec[0].kind == RES_DEFAULT ||
	    (tokvec[0].kind == IDENT_OR_RESERVED && tokvec[1].kind == COLON)) {
		return parse_labeled_statement(ptr_ps, ptr_tokvec);
	}

	switch (tokvec[0].kind) {
	case LEFT_BRACE: {
		return parse_compound_statement(ptr_ps, ptr_tokvec);
	}

	case RES_IF: {
		++tokvec;
		expect_and_consume(&tokvec, LEFT_PAREN,
		                   "left parenthesis immediately after `if`");

		const struct UntypedExpr u = parse_expression(&tokvec);
		struct Expr expr = typecheck_expression(ptr_ps, &u);
		expect_scalar(&expr.details.type, "`if` statement");

		expect_and_consume(&tokvec, RIGHT_PAREN, "right parenthesis of `if`");

		struct Statement *ptr_inner_s = calloc(1, sizeof(struct Statement));
		*ptr_inner_s = parse_statement(ptr_ps, &tokvec);

		struct Statement s;
		s.labels = init_vector();
		s.expr1 = expr;
		if (tokvec[0].kind == RES_ELSE) { /* must bind to the most inner one */
			++tokvec;
			struct Statement *ptr_inner_s2 =
			    calloc(1, sizeof(struct Statement));
			*ptr_inner_s2 = parse_statement(ptr_ps, &tokvec);

			*ptr_tokvec = tokvec;

			s.category = IF_ELSE_STATEMENT;
			s.statement_vector = init_vector();
			push_vector(&s.statement_vector, ptr_inner_s);
			push_vector(&s.statement_vector, ptr_inner_s2);
			return s;
		}

		*ptr_tokvec = tokvec;
		s.category = IF_STATEMENT;
		s.inner_statement = ptr_inner_s;
		return s;
	}

	case RES_SWITCH: {
		++tokvec;
		expect_and_consume(&tokvec, LEFT_PAREN,
		                   "left parenthesis immediately after `switch`");

		const struct UntypedExpr u = parse_expression(&tokvec);

		struct Expr expr = typecheck_expression(ptr_ps, &u);
		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "right parenthesis of `switch`");

		expect_integral(
		    &expr.details.type,
		    "controlling expression of `switch` must be integer type");

		struct Statement *ptr_inner_s = calloc(1, sizeof(struct Statement));
		*ptr_inner_s = parse_statement(ptr_ps, &tokvec);

		struct Statement s;
		s.labels = init_vector();
		s.expr1 = expr;
		*ptr_tokvec = tokvec;
		s.category = SWITCH_STATEMENT;
		s.inner_statement = ptr_inner_s;
		return s;
	}

	case RES_RETURN: {
		++tokvec;
		*ptr_tokvec = tokvec;
		struct Statement s;
		s.labels = init_vector();
		s.category = RETURN_STATEMENT;

		if (tokvec[0].kind == SEMICOLON) {
			++tokvec;
			s.expr1.category = VOID_EXPR;
			s.expr1.details.type.type_category = VOID_;
			s.expr1.details.true_type.type_category = VOID_;
		} else {
			const struct UntypedExpr u = parse_expression(&tokvec);
			struct Expr expr = typecheck_expression(ptr_ps, &u);

			if (ptr_ps->func_ret_type.type_category == PTR_) {
				struct TypePair details;
				details.type = ptr_ps->func_ret_type;
				details.true_type = ptr_ps->func_ret_type;
				cast_to_null_pointer_if_possible(&expr, &details);
				if_function_cast_to_pointer(&expr);
			}

			expect_type(ptr_ps, &expr.details.type, &ptr_ps->func_ret_type,
			            "mismatched type in the return value");
			expect_and_consume(&tokvec, SEMICOLON,
			                   "semicolon (after `return expr`)");
			s.expr1 = expr;
		}

		*ptr_tokvec = tokvec;
		return s;
	}

	case RES_DO: {
		++tokvec;

		struct Statement inner_s = parse_statement(ptr_ps, &tokvec);

		expect_and_consume(&tokvec, RES_WHILE, "`while` of do-while");
		expect_and_consume(&tokvec, LEFT_PAREN, "left parenthesis of do-while");

		const struct UntypedExpr u = parse_expression(&tokvec);

		struct Expr expr = typecheck_expression(ptr_ps, &u);
		expect_scalar(&expr.details.type, "`do-while` statement");

		expect_and_consume(&tokvec, RIGHT_PAREN,
		                   "right parenthesis of do-while");
		expect_and_consume(&tokvec, SEMICOLON, "semicolon after do-while");
		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = DO_WHILE_STATEMENT;
		s.expr1 = expr;

		struct Statement *ptr_inner_s = calloc(1, sizeof(struct Statement));
		*ptr_inner_s = inner_s;
		s.inner_statement = ptr_inner_s;
		return s;
	}

	case RES_WHILE: {
		++tokvec;

		expect_and_consume(&tokvec, LEFT_PAREN, "left parenthesis of while");

		const struct UntypedExpr u = parse_expression(&tokvec);

		struct Expr expr = typecheck_expression(ptr_ps, &u);
		expect_scalar(&expr.details.type, "`while` statement");

		expect_and_consume(&tokvec, RIGHT_PAREN, "left parenthesis of while");

		struct Statement inner_s = parse_statement(ptr_ps, &tokvec);

		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = WHILE_STATEMENT;
		s.expr1 = expr;

		struct Statement *ptr_inner_s = calloc(1, sizeof(struct Statement));
		*ptr_inner_s = inner_s;
		s.inner_statement = ptr_inner_s;
		return s;
	}

	case RES_BREAK: {
		++tokvec;
		expect_and_consume(&tokvec, SEMICOLON, "semicolon after `break`");
		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = BREAK_STATEMENT;
		return s;
	}

	case RES_CONTINUE: {
		++tokvec;
		expect_and_consume(&tokvec, SEMICOLON, "semicolon after `continue`");
		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = CONTINUE_STATEMENT;
		return s;
	}

	case RES_GOTO: {
		++tokvec;
		expect_and_consume(&tokvec, IDENT_OR_RESERVED,
		                   "identifier after `goto`");
		const char *ident = tokvec[-1].ident_str;
		expect_and_consume(&tokvec, SEMICOLON,
		                   "semicolon after `goto identifier`");
		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = GOTO_STATEMENT;
		s.destination = ident;
		return s;
	}

	case RES_FOR: {

		++tokvec;
		expect_and_consume(&tokvec, LEFT_PAREN, "left parenthesis of `for`");

		/* make the whole thing into a block*/
		struct Statement statement;
		statement.category = COMPOUND_STATEMENT;
		statement.labels = init_vector();
		statement.statement_vector = init_vector();

		/* block scope begins */
		struct ScopeChain current_table = ptr_ps->scope_chain;
		struct ScopeChain new_table;
		new_table.var_table = init_map();
		new_table.outer = &current_table;
		ptr_ps->scope_chain = new_table;

		struct Expr expr1;
		struct Expr expr2;
		struct Expr expr3;

		if (tokvec[0].kind == SEMICOLON) { /* expression1 is missing */
			expr1 = integer_1();
			++tokvec;
		} else if (can_start_a_type(tokvec)) {
			const char *str;
			struct UntypedExpr *ptr_uexpr;
			const struct Type vartype =
			    parse_declaration(&tokvec, &str, &ptr_uexpr);

			struct Expr *ptr_expr = declare_var_and_return_initializer(
			    ptr_ps, &vartype, str, ptr_uexpr, &statement);

			expr1 = ptr_expr ? *ptr_expr : integer_1();
		} else {
			const struct UntypedExpr u = parse_expression(&tokvec);
			expr1 = typecheck_expression(ptr_ps, &u);
			expect_and_consume(&tokvec, SEMICOLON, "first semicolon of `for`");
		}

		if (tokvec[0].kind == SEMICOLON) { /* expression2 is missing */
			expr2 = integer_1();
		} else {
			const struct UntypedExpr u = parse_expression(&tokvec);
			expr2 = typecheck_expression(ptr_ps, &u);
		}
		expect_scalar(&expr2.details.type, "`for` statement");
		expect_and_consume(&tokvec, SEMICOLON, "second semicolon of `for`");

		if (tokvec[0].kind == RIGHT_PAREN) { /* expression3 is missing */
			expr3 = integer_1();
		} else {
			const struct UntypedExpr u = parse_expression(&tokvec);
			expr3 = typecheck_expression(ptr_ps, &u);
		}
		expect_and_consume(&tokvec, RIGHT_PAREN, "right parenthesis of `for`");
		struct Statement s;
		s.labels = init_vector();
		s.category = FOR_STATEMENT;
		s.expr1 = expr1;
		s.expr2 = expr2;
		s.expr3 = expr3;

		struct Statement inner_s = parse_statement(ptr_ps, &tokvec);
		*ptr_tokvec = tokvec;
		struct Statement *ptr_inner_s = calloc(1, sizeof(struct Statement));
		*ptr_inner_s = inner_s;
		s.inner_statement = ptr_inner_s;

		struct Statement *ptr_s = calloc(1, sizeof(struct Statement));
		*ptr_s = s;
		push_vector(&statement.statement_vector, ptr_s);

		/* block scope ends */
		ptr_ps->scope_chain = current_table;
		return statement;
	}

	default: {
		const struct UntypedExpr uexpr = parse_expression(&tokvec);
		struct Expr expr = typecheck_expression(ptr_ps, &uexpr);

		expect_and_consume(&tokvec, SEMICOLON, "semicolon after an expression");

		*ptr_tokvec = tokvec;

		struct Statement s;
		s.labels = init_vector();
		s.category = EXPRESSION_STATEMENT;
		s.expr1 = expr;
		return s;
	}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3110, %rsp           # imm = 0x3110
movq %rdi, -0x30f0(%rbp)
movq %rdi, -0x30e8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x40, (%rax)
je 0x3771
movq -0x18(%rbp), %rax
cmpl $0x41, (%rax)
je 0x3771
movq -0x18(%rbp), %rax
cmpl $0x18, (%rax)
jne 0x378a
movq -0x18(%rbp), %rax
cmpl $0x1d, 0x20(%rax)
jne 0x378a
movq -0x30f0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x35d0
jmp 0x45b1
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $-0x19, %eax
movl %eax, %ecx
movq %rcx, -0x30f8(%rbp)
subl $0x30, %eax
ja 0x4519
movq -0x30f8(%rbp), %rax
leaq 0x10041(%rip), %rcx     # 0x137f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30f0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x45d0
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq 0x100fc(%rip), %rdx     # 0x138ed
callq 0xb190
leaq -0xb8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x1b8(%rbp), %rdi
leaq -0xb8(%rbp), %rdx
callq 0x7130
leaq -0x1b8(%rbp), %rdi
leaq 0x100ea(%rip), %rsi     # 0x13915
callq 0x6960
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0x100e4(%rip), %rdx     # 0x13924
callq 0xb190
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rax
movq %rax, -0x3100(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x550(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
movq -0x3100(%rbp), %rdi
leaq -0x550(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0x560(%rbp)
movq %rdx, -0x558(%rbp)
movq -0x560(%rbp), %rax
movq %rax, 0x378(%rdi)
movq -0x558(%rbp), %rax
movq %rax, 0x380(%rdi)
addq $0x18, %rdi
leaq -0x1b8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x18(%rbp), %rax
cmpl $0x2d, (%rax)
jne 0x39bd
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x568(%rbp)
movq -0x568(%rbp), %rax
movq %rax, -0x3108(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x8f8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
movq -0x3108(%rbp), %rdi
leaq -0x8f8(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
movq -0x30f0(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movl $0x2, (%rax)
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0x908(%rbp)
movq %rdx, -0x900(%rbp)
movq -0x908(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x900(%rbp), %rax
movq %rax, 0x10(%rdi)
addq $0x8, %rdi
movq -0x1c0(%rbp), %rsi
callq 0x62c0
movq -0x30f0(%rbp), %rdi
addq $0x8, %rdi
movq -0x568(%rbp), %rsi
callq 0x62c0
jmp 0x45b1
movq -0x30f0(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movl $0x1, (%rax)
movq -0x1c0(%rbp), %rcx
movq %rcx, 0x318(%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq 0xff3a(%rip), %rdx      # 0x1393e
callq 0xb190
leaq -0x9a8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0xaa8(%rbp), %rdi
leaq -0x9a8(%rbp), %rdx
callq 0x7130
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0xff2a(%rip), %rdx      # 0x1396a
callq 0xb190
leaq -0xaa8(%rbp), %rdi
leaq 0xff35(%rip), %rsi      # 0x13988
callq 0x6a10
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0xab0(%rbp)
movq -0xab0(%rbp), %rax
movq %rax, -0x3110(%rbp)
movq -0x8(%rbp), %rsi
leaq -0xe40(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
movq -0x3110(%rbp), %rdi
leaq -0xe40(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0xe50(%rbp)
movq %rdx, -0xe48(%rbp)
movq -0xe50(%rbp), %rax
movq %rax, 0x378(%rdi)
movq -0xe48(%rbp), %rax
movq %rax, 0x380(%rdi)
addq $0x18, %rdi
leaq -0xaa8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30f0(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movl $0xb, (%rax)
movq -0xab0(%rbp), %rcx
movq %rcx, 0x318(%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0xe60(%rbp)
movq %rdx, -0xe58(%rbp)
movq -0xe60(%rbp), %rcx
movq %rcx, 0x378(%rax)
movq -0xe58(%rbp), %rcx
movq %rcx, 0x380(%rax)
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x3bad
movq -0x30f0(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movq %rcx, -0x18(%rbp)
movl $0x13, 0xb8(%rax)
movl $0x7, 0x18(%rax)
movl $0x7, 0x68(%rax)
jmp 0x3c83
leaq -0xf00(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x1000(%rbp), %rdi
leaq -0xf00(%rbp), %rdx
callq 0x7130
movq -0x8(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3c33
leaq -0x10a0(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movl $0x50, %edx
callq 0x10e0
leaq -0x10a0(%rbp), %rdi
addq $0x50, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
movl $0x50, %edx
callq 0x10e0
leaq -0x1000(%rbp), %rdi
leaq -0x10a0(%rbp), %rsi
callq 0x6b70
leaq -0x1000(%rbp), %rdi
callq 0x6bc0
movq -0x8(%rbp), %rdi
leaq -0x1000(%rbp), %rsi
movq -0x8(%rbp), %rdx
addq $0x20, %rdx
leaq 0xfd73(%rip), %rcx      # 0x139c0
callq 0x6630
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xfd82(%rip), %rdx      # 0x139e4
callq 0xb190
movq -0x30f0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x1000(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x1430(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
leaq -0x18(%rbp), %rdi
movl $0x2f, %esi
leaq 0xfd41(%rip), %rdx      # 0x13a04
callq 0xb190
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq 0xfd40(%rip), %rdx      # 0x13a18
callq 0xb190
leaq -0x14d0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x15d0(%rbp), %rdi
leaq -0x14d0(%rbp), %rdx
callq 0x7130
leaq -0x15d0(%rbp), %rdi
leaq 0xfd23(%rip), %rsi      # 0x13a35
callq 0x6960
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0xfd23(%rip), %rdx      # 0x13a4a
callq 0xb190
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xfd2c(%rip), %rdx      # 0x13a68
callq 0xb190
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0x15e0(%rbp)
movq %rdx, -0x15d8(%rbp)
movq -0x15e0(%rbp), %rax
movq %rax, 0x378(%rdi)
movq -0x15d8(%rbp), %rax
movq %rax, 0x380(%rdi)
movl $0x5, (%rdi)
addq $0x18, %rdi
leaq -0x15d0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x15e8(%rbp)
movq -0x15e8(%rbp), %rdi
leaq -0x1430(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
movq -0x30f0(%rbp), %rax
movq -0x15e8(%rbp), %rcx
movq %rcx, 0x318(%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq 0xfc80(%rip), %rdx      # 0x13a81
callq 0xb190
leaq -0x1688(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x1788(%rbp), %rdi
leaq -0x1688(%rbp), %rdx
callq 0x7130
leaq -0x1788(%rbp), %rdi
leaq 0xfc60(%rip), %rsi      # 0x13a9b
callq 0x6960
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0xfc31(%rip), %rdx      # 0x13a81
callq 0xb190
movq -0x8(%rbp), %rsi
leaq -0x1b18(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0x1b28(%rbp)
movq %rdx, -0x1b20(%rbp)
movq -0x1b28(%rbp), %rax
movq %rax, 0x378(%rdi)
movq -0x1b20(%rbp), %rax
movq %rax, 0x380(%rdi)
movl $0x4, (%rdi)
addq $0x18, %rdi
leaq -0x1788(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x1b30(%rbp)
movq -0x1b30(%rbp), %rdi
leaq -0x1b18(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
movq -0x30f0(%rbp), %rax
movq -0x1b30(%rbp), %rcx
movq %rcx, 0x318(%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xfb84(%rip), %rdx      # 0x13aad
callq 0xb190
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0x1b40(%rbp)
movq %rdx, -0x1b38(%rbp)
movq -0x1b40(%rbp), %rcx
movq %rcx, 0x378(%rax)
movq -0x1b38(%rbp), %rcx
movq %rcx, 0x380(%rax)
movl $0x7, (%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xfb2c(%rip), %rdx      # 0x13ac5
callq 0xb190
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0x1b50(%rbp)
movq %rdx, -0x1b48(%rbp)
movq -0x1b50(%rbp), %rcx
movq %rcx, 0x378(%rax)
movq -0x1b48(%rbp), %rcx
movq %rcx, 0x380(%rax)
movl $0x8, (%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x18, %esi
leaq 0xfad7(%rip), %rdx      # 0x13ae0
callq 0xb190
movq -0x18(%rbp), %rax
movq -0x18(%rax), %rax
movq %rax, -0x1b58(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xfacb(%rip), %rdx      # 0x13af8
callq 0xb190
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0x1b68(%rbp)
movq %rdx, -0x1b60(%rbp)
movq -0x1b68(%rbp), %rcx
movq %rcx, 0x378(%rax)
movq -0x1b60(%rbp), %rcx
movq %rcx, 0x380(%rax)
movl $0xc, (%rax)
movq -0x1b58(%rbp), %rcx
movq %rcx, 0x388(%rax)
jmp 0x45b1
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x6, %esi
leaq 0xfa6f(%rip), %rdx      # 0x13b1a
callq 0xb190
movq -0x30f0(%rbp), %rax
movl $0x0, (%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0x1b78(%rbp)
movq %rdx, -0x1b70(%rbp)
movq -0x1b78(%rbp), %rcx
movq %rcx, 0x378(%rax)
movq -0x1b70(%rbp), %rcx
movq %rcx, 0x380(%rax)
callq 0x61d0
movq %rax, %rcx
movq -0x30f0(%rbp), %rax
movq %rcx, -0x1b88(%rbp)
movq %rdx, -0x1b80(%rbp)
movq -0x1b88(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x1b80(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x1b98(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x1b90(%rbp)
callq 0xccc0
movq %rax, -0x1ba8(%rbp)
leaq -0x1b98(%rbp), %rax
movq %rax, -0x1ba0(%rbp)
movq -0x8(%rbp), %rax
movq -0x1ba8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1ba0(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x41b3
leaq -0x1fa8(%rbp), %rdi
callq 0x4960
leaq -0x1ca8(%rbp), %rdi
leaq -0x1fa8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x42af
movq -0x18(%rbp), %rdi
callq 0xc270
cmpl $0x0, %eax
je 0x4259
leaq -0x2008(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x1fb0(%rbp), %rdx
leaq -0x1fb8(%rbp), %rcx
callq 0xc300
movq -0x30f0(%rbp), %r8
movq -0x8(%rbp), %rdi
movq -0x1fb0(%rbp), %rdx
movq -0x1fb8(%rbp), %rcx
leaq -0x2008(%rbp), %rsi
callq 0x49b0
movq %rax, -0x2010(%rbp)
cmpq $0x0, -0x2010(%rbp)
je 0x4233
movq -0x2010(%rbp), %rsi
leaq -0x1ca8(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
jmp 0x4257
leaq -0x2110(%rbp), %rdi
callq 0x4960
leaq -0x1ca8(%rbp), %rdi
leaq -0x2110(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
jmp 0x42ad
leaq -0x21b0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x22b0(%rbp), %rdi
leaq -0x21b0(%rbp), %rdx
callq 0x7130
leaq -0x1ca8(%rbp), %rdi
leaq -0x22b0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xf88c(%rip), %rdx      # 0x13b34
callq 0xb190
jmp 0x42af
movq -0x18(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x42de
leaq -0x23b0(%rbp), %rdi
callq 0x4960
leaq -0x1da8(%rbp), %rdi
leaq -0x23b0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
jmp 0x431d
leaq -0x2450(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x2550(%rbp), %rdi
leaq -0x2450(%rbp), %rdx
callq 0x7130
leaq -0x1da8(%rbp), %rdi
leaq -0x2550(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
leaq -0x1da8(%rbp), %rdi
leaq 0xf822(%rip), %rsi      # 0x13b4d
callq 0x6960
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xf81d(%rip), %rdx      # 0x13b5d
callq 0xb190
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x4374
leaq -0x2650(%rbp), %rdi
callq 0x4960
leaq -0x1ea8(%rbp), %rdi
leaq -0x2650(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
jmp 0x43b3
leaq -0x26f0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x27f0(%rbp), %rdi
leaq -0x26f0(%rbp), %rdx
callq 0x7130
leaq -0x1ea8(%rbp), %rdi
leaq -0x27f0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
leaq -0x18(%rbp), %rdi
movl $0x7, %esi
leaq 0xf7b4(%rip), %rdx      # 0x13b77
callq 0xb190
callq 0x61d0
movq %rax, -0x2b90(%rbp)
movq %rdx, -0x2b88(%rbp)
movq -0x2b90(%rbp), %rax
movq %rax, -0x2808(%rbp)
movq -0x2b88(%rbp), %rax
movq %rax, -0x2800(%rbp)
movl $0x3, -0x2b80(%rbp)
leaq -0x2b80(%rbp), %rdi
addq $0x18, %rdi
leaq -0x1ca8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
leaq -0x2b80(%rbp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq -0x1da8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
leaq -0x2b80(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
leaq -0x1ea8(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x8(%rbp), %rsi
leaq -0x2f20(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x3720
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x2f28(%rbp)
movq -0x2f28(%rbp), %rdi
leaq -0x2f20(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
movq -0x2f28(%rbp), %rax
movq %rax, -0x2868(%rbp)
movl $0x1, %edi
movl $0x390, %esi            # imm = 0x390
callq 0x10b0
movq %rax, -0x2f30(%rbp)
movq -0x2f30(%rbp), %rdi
leaq -0x2b80(%rbp), %rsi
movl $0x390, %edx            # imm = 0x390
callq 0x10e0
movq -0x30f0(%rbp), %rdi
addq $0x8, %rdi
movq -0x2f30(%rbp), %rsi
callq 0x62c0
movq -0x8(%rbp), %rax
movq -0x1b98(%rbp), %rcx
movq %rcx, (%rax)
movq -0x1b90(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x45b1
leaq -0x2fd0(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xa050
movq -0x8(%rbp), %rsi
leaq -0x30d0(%rbp), %rdi
leaq -0x2fd0(%rbp), %rdx
callq 0x7130
leaq -0x18(%rbp), %rdi
movl $0x1a, %esi
leaq 0xf642(%rip), %rdx      # 0x13b92
callq 0xb190
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x61d0
movq -0x30f0(%rbp), %rdi
movq %rax, -0x30e0(%rbp)
movq %rdx, -0x30d8(%rbp)
movq -0x30e0(%rbp), %rax
movq %rax, 0x378(%rdi)
movq -0x30d8(%rbp), %rax
movq %rax, 0x380(%rdi)
movl $0x9, (%rdi)
addq $0x18, %rdi
leaq -0x30d0(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10e0
movq -0x30e8(%rbp), %rax
addq $0x3110, %rsp           # imm = 0x3110
popq %rbp
retq
nopw %cs:(%rax,%rax)