// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::generate_and_append_code(neteruhsp::execute_environment_t*, neteruhsp::list_t*)::_::walk(neteruhsp::execute_environment_t*, neteruhsp::ast_node_t const*, neteruhsp::generate_and_append_code(neteruhsp::execute_environment_t*, neteruhsp::list_t*)::generate_context_t*)
static void walk( execute_environment_t* e, const ast_node_t* n, generate_context_t* c )
			{
				switch( n->tag_ )
				{
					case NODE_EMPTY:
						break;

					case NODE_LABEL:
					{
						const auto label_name = n->token_->content_;
						const auto label = search_label( e, label_name );
						assert( label != nullptr );
						label->position_ = static_cast<int>( e->execute_code_->code_size_ );

						code_write( e, OPERATOR_LABEL );
						break;
					}

					case NODE_BLOCK_STATEMENTS:
						if ( n->left_ )
						{ walk( e, n->left_, c ); }
						if ( n->right_ )
						{ walk( e, n->right_, c ); }
						break;

					case NODE_COMMAND:
					{
						assert( n->token_->tag_ == TOKEN_IDENTIFIER );
						const auto command_name = n->token_->content_;

						const auto command = query_command( command_name );
						if ( command == -1 )
						{
							raise_error( "コマンドが見つかりません：%s", command_name );
						}

						const auto top = c->stack_;
						if ( n->left_ != nullptr )
						{
							walk( e, n->left_, c );
						}
						const auto arg_num = c->stack_ -top;

						code_write( e, OPERATOR_COMMAND );
						code_write( e, command );
						code_write( e, arg_num );

						c->stack_ = top;
						break;
					}
					case NODE_ARGUMENTS:
					{
						if ( n->left_ != nullptr )
						{ walk( e, n->left_, c ); }
						if ( n->right_ != nullptr )
						{ walk( e, n->right_, c ); }
						break;
					}

					case NODE_ASSIGN:
					case NODE_ADD_ASSIGN:
					case NODE_SUB_ASSIGN:
					case NODE_MUL_ASSIGN:
					case NODE_DIV_ASSIGN:
					case NODE_MOD_ASSIGN:
					case NODE_BOR_ASSIGN:
					case NODE_BAND_ASSIGN:
					case NODE_BXOR_ASSIGN:
					{
						walk( e, n->left_, c );
						walk( e, n->right_, c );
						switch( n->tag_ )
						{
						case NODE_ASSIGN:		code_write( e, OPERATOR_ASSIGN ); break;
						case NODE_ADD_ASSIGN:	code_write( e, OPERATOR_ADD_ASSIGN ); break;
						case NODE_SUB_ASSIGN:	code_write( e, OPERATOR_SUB_ASSIGN ); break;
						case NODE_MUL_ASSIGN:	code_write( e, OPERATOR_MUL_ASSIGN ); break;
						case NODE_DIV_ASSIGN:	code_write( e, OPERATOR_DIV_ASSIGN ); break;
						case NODE_MOD_ASSIGN:	code_write( e, OPERATOR_MOD_ASSIGN ); break;
						case NODE_BOR_ASSIGN:	code_write( e, OPERATOR_BOR_ASSIGN ); break;
						case NODE_BAND_ASSIGN:	code_write( e, OPERATOR_BAND_ASSIGN ); break;
						case NODE_BXOR_ASSIGN:	code_write( e, OPERATOR_BXOR_ASSIGN ); break;
						default: assert( false ); break;
						}
						c->stack_ -= 2; 
						break;
					}
					case NODE_VARIABLE:
					{
						auto idx_node = n->left_;
						if ( idx_node )
						{
							walk( e, idx_node, c );
						}
						else
						{
							code_write( e, OPERATOR_PUSH_INT );
							code_write( e, 0 );
						}

						const auto var_name = n->token_->content_;
						const auto var = search_variable( e->variable_table_, var_name );
						assert( var != nullptr );

						code_write( e, OPERATOR_PUSH_VARIABLE );
						code_write( e, var );
						++c->stack_;
						break;
					}

					case NODE_EXPRESSION:
						assert( n->left_ != nullptr );
						walk( e, n->left_, c );
						break;

					case NODE_BOR:
					case NODE_BAND:
					case NODE_BXOR:
					case NODE_EQ:
					case NODE_NEQ:
					case NODE_GT:
					case NODE_GTOE:
					case NODE_LT:
					case NODE_LTOE:
					case NODE_ADD:
					case NODE_SUB:
					case NODE_MUL:
					case NODE_DIV:
					case NODE_MOD:
					{
						assert( n->left_ != nullptr );
						walk( e, n->left_, c );
						assert( n->right_ != nullptr );
						walk( e, n->right_, c );

						switch( n->tag_ )
						{
							case NODE_BOR:		code_write( e, OPERATOR_BOR ); break;
							case NODE_BAND:		code_write( e, OPERATOR_BAND ); break;
							case NODE_BXOR:		code_write( e, OPERATOR_BXOR ); break;
							case NODE_EQ:		code_write( e, OPERATOR_EQ ); break;
							case NODE_NEQ:		code_write( e, OPERATOR_NEQ ); break;
							case NODE_GT:		code_write( e, OPERATOR_GT ); break;
							case NODE_GTOE:		code_write( e, OPERATOR_GTOE ); break;
							case NODE_LT:		code_write( e, OPERATOR_LT ); break;
							case NODE_LTOE:		code_write( e, OPERATOR_LTOE ); break;
							case NODE_ADD:		code_write( e, OPERATOR_ADD ); break;
							case NODE_SUB:		code_write( e, OPERATOR_SUB ); break;
							case NODE_MUL:		code_write( e, OPERATOR_MUL ); break;
							case NODE_DIV:		code_write( e, OPERATOR_DIV ); break;
							case NODE_MOD:		code_write( e, OPERATOR_MOD ); break;
							default: assert( false ); break;
						}

						--c->stack_;
						break;
					}

					case NODE_UNARY_MINUS:
					{
						assert( n->left_ != nullptr );
						walk( e, n->left_, c );
						code_write( e, OPERATOR_UNARY_MINUS );
						break;
					}

					case NODE_PRIMITIVE_VALUE:
					{
						switch( n->token_->tag_ )
						{
							case TOKEN_INTEGER:	code_write( e, OPERATOR_PUSH_INT ); code_write( e, atoi( n->token_->content_ ) ); break;
							case TOKEN_REAL:	code_write( e, OPERATOR_PUSH_DOUBLE ); code_write_block( e, atof( n->token_->content_ ) ); break;
							case TOKEN_STRING:	code_write( e, OPERATOR_PUSH_STRING ); code_write( e, n->token_->content_ ); break;
							default: assert( false ); break;
						}
						++c->stack_;
						break;
					}
					case NODE_IDENTIFIER_EXPR:
					{
						assert( n->token_->tag_ == TOKEN_IDENTIFIER );
						const auto ident = n->token_->content_;

						const auto top = c->stack_;
						if ( n->left_ != nullptr )
						{
							walk( e, n->left_, c );
						}
						const auto arg_num = c->stack_ -top;

						const auto function = query_function( ident );
						if ( function >= 0 )
						{
							code_write( e, OPERATOR_FUNCTION );
							code_write( e, function );
							code_write( e, arg_num );
						}
						else
						{
							// システム変数
							const auto sysvar = query_sysvar( ident );
							if ( sysvar >= 0 )
							{
								if ( arg_num > 0 )
								{
									raise_error( "システム変数に添え字はありません : %s", ident );
								}

								code_write( e, OPERATOR_PUSH_SYSVAR );
								code_write( e, sysvar );
							}
							else
							{
								// 配列変数
								if ( arg_num > 1 )
								{
									raise_error( "関数がみつかりません、配列変数の添え字は1次元までです@@ %s", ident );
								}

								const auto var = search_variable( e->variable_table_, ident );
								assert( var != nullptr );

								if ( arg_num == 0 )
								{
									code_write( e, OPERATOR_PUSH_INT );
									code_write( e, 0 );
								}

								code_write( e, OPERATOR_PUSH_VARIABLE );
								code_write( e, var );
							}
						}

						c->stack_ = top +1;
						break;
					}

					case NODE_END:
						code_write( e, OPERATOR_END );
						break;

					case NODE_RETURN:
					{
						if ( n->left_ )
						{
							walk( e, n->left_, c );
							--c->stack_;
						}
						code_write( e, OPERATOR_RETURN );
						code_write( e, n->left_==nullptr ? 0 : 1 );
						break;
					}

					case NODE_GOTO:
					{
						const auto label_node = n->left_;
						assert( label_node != nullptr );
						assert( label_node->tag_ == NODE_LABEL );

						const auto label_name = label_node->token_->content_;
						const auto label = search_label( e, label_name );
						if ( label == nullptr )
						{
							raise_error( "goto：ラベルがみつかりません@@ %s", label_name );
						}

						code_write( e, OPERATOR_GOTO );
						code_write( e, label );
						break;
					}
					case NODE_GOSUB:
					{
						const auto label_node = n->left_;
						assert( label_node != nullptr );
						assert( label_node->tag_ == NODE_LABEL );

						const auto label_name = label_node->token_->content_;
						const auto label = search_label( e, label_name );
						if ( label == nullptr )
						{
							raise_error( "gosub：ラベルがみつかりません@@ %s", label_name );
						}

						code_write( e, OPERATOR_GOSUB );
						code_write( e, label );
						break;
					}

					case NODE_REPEAT:
					{
						if ( n->left_ )
						{
							walk( e, n->left_, c );
							--c->stack_;
						}
						else
						{
							code_write( e, OPERATOR_PUSH_INT );
							code_write( e, -1 );
						}
						const auto pos_head = e->execute_code_->code_size_;
						code_write( e, OPERATOR_REPEAT );
						code_write( e, 0 );// dummy TAIL

						if ( c->repeat_depth_ >= sizeof(c->repeat_head_) /sizeof(*c->repeat_head_) )
						{
							raise_error( "repeat-loop: ソースコード上でネストが深すぎます@@ %d行目", n->token_->appear_line_ );
						}
						c->repeat_head_[c->repeat_depth_] = static_cast<int>( pos_head );
						++c->repeat_depth_;

						code_write( e, OPERATOR_REPEAT_CHECK );
						break;
					}
					case NODE_LOOP:
					{
						if ( c->repeat_depth_ <= 0 )
						{
							raise_error( "repeat-loop: repeatがないのにloopを検出しました@@ %d行目", n->token_->appear_line_ );
						}

						const auto loop_head = e->execute_code_->code_size_;
						code_write( e, OPERATOR_LOOP );

						const auto write_offset = c->repeat_head_[c->repeat_depth_ -1] +1;
						e->execute_code_->code_[ write_offset ] = static_cast<int>( loop_head );
						--c->repeat_depth_;
						break;
					}
					case NODE_CONTINUE:		code_write( e, OPERATOR_CONTINUE ); break;
					case NODE_BREAK:		code_write( e, OPERATOR_BREAK ); break;

					case NODE_IF:
					{
						assert( n->left_ != nullptr );
						walk( e, n->left_, c );

						assert( n->right_ != nullptr );
						const auto dispatcher = n->right_;
						assert( dispatcher->tag_ == NODE_IF_DISPATCHER );

						const auto pos_root = e->execute_code_->code_size_;
						code_write( e, OPERATOR_IF );
						code_write( e, 0 );// dummy FALSE

						walk( e, dispatcher->left_, c );
						const auto pos_true_tail = e->execute_code_->code_size_;
						code_write( e, OPERATOR_JUMP_RELATIVE );
						code_write( e, 0 );// dummy TAIL

						const auto pos_false_head = e->execute_code_->code_size_;
						if ( dispatcher->right_ )
						{
							walk( e, dispatcher->right_, c );
						}

						const auto pos_tail = e->execute_code_->code_size_;
						e->execute_code_->code_[ pos_root +1 ] = static_cast<int>( pos_false_head - pos_root );
						e->execute_code_->code_[ pos_true_tail +1 ] = static_cast<int>( pos_tail - pos_true_tail );
						break;
					}
					case NODE_IF_DISPATCHER:
						assert( false );
						break;

					default: assert( false ); break;
				}
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x39d4(%rip), %r12      # 0xb52c
movl (%r15), %eax
cmpq $0x2a, %rax
ja 0x81b3
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x7b82
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x7b58
jmp 0x7c41
movq 0x10(%r15), %r15
testq %r15, %r15
jne 0x7b58
leaq 0x6ef9(%rip), %rdi      # 0xea99
leaq 0x3cf2(%rip), %rsi      # 0xb899
leaq 0x71b4(%rip), %rcx      # 0xed62
movl $0x1641, %edx           # imm = 0x1641
callq 0x20e0
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x81d2
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x81f1
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movl (%r15), %esi
leal -0x10(%rsi), %eax
cmpl $0xe, %eax
jae 0x8210
decl %esi
movq %rbx, %rdi
callq 0x8465
decl (%r14)
jmp 0x7c41
movq 0x10(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x18(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movl (%r15), %esi
leal -0x5(%rsi), %eax
cmpl $0x9, %eax
jae 0x822f
incl %esi
movq %rbx, %rdi
callq 0x8465
addl $-0x2, (%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r15), %rax
cmpl $0x23, (%rax)
jne 0x824e
movq 0x8(%rax), %r12
movl (%r14), %r13d
movq 0x10(%r15), %rsi
movl %r13d, %eax
testq %rsi, %rsi
je 0x7c7e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movl (%r14), %eax
movl %eax, %ebp
movl %r13d, (%rsp)
subl %r13d, %ebp
movq %r12, %rdi
movl %eax, %r13d
callq 0x8f70
testl %eax, %eax
js 0x8085
movl %eax, %r15d
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8465
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8465
movl (%rsp), %ebp
jmp 0x818a
pushq $0x2c
jmp 0x8026
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xa117
testq %rax, %rax
je 0x826d
movq 0x20(%rbx), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
pushq $0x24
jmp 0x8026
movq 0x8(%r15), %rax
cmpl $0x23, (%rax)
jne 0x828c
movq 0x8(%rax), %r12
movq %r12, %rdi
callq 0x8866
cmpl $-0x1, %eax
je 0x836b
movl %eax, %ebp
movl (%r14), %r12d
movq 0x10(%r15), %rsi
movl %r12d, %r15d
testq %rsi, %rsi
je 0x7d37
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movl (%r14), %r15d
subl %r12d, %r15d
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8465
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8465
movl %r12d, (%r14)
jmp 0x7c41
pushq $0x23
jmp 0x8026
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x82ab
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x18(%r15), %r12
testq %r12, %r12
je 0x837a
cmpl $0x2a, (%r12)
jne 0x83d7
movq 0x20(%rbx), %rax
movq 0x8(%rax), %r15
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8465
movq 0x10(%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x20(%rbx), %rax
movq 0x8(%rax), %r13
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8465
movq 0x20(%rbx), %rcx
movq 0x8(%rcx), %rbp
movq 0x18(%r12), %rsi
movq %rbp, %rax
testq %rsi, %rsi
je 0x7e0b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
movq 0x20(%rbx), %rcx
movq 0x8(%rcx), %rax
subl %r15d, %ebp
movq (%rcx), %rcx
movl %ebp, 0x4(%rcx,%r15,4)
subl %r13d, %eax
movl %eax, 0x4(%rcx,%r13,4)
jmp 0x7c41
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x82ca
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
pushq $0x1d
jmp 0x8026
cmpl $0x0, 0x84(%r14)
jle 0x82e9
movq 0x20(%rbx), %rax
movl 0x8(%rax), %ebp
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0x8465
movslq 0x84(%r14), %rax
movslq (%r14,%rax,4), %rax
movq 0x20(%rbx), %rcx
movq (%rcx), %rcx
movl %ebp, 0x4(%rcx,%rax,4)
decl 0x84(%r14)
jmp 0x7c41
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x82f9
cmpl $0x1, (%rax)
jne 0x8399
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa117
testq %rax, %rax
je 0x83f6
movq %rax, %r15
pushq $0x26
jmp 0x7f83
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x7fd4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
decl (%r14)
jmp 0x7fea
movq 0x8(%r15), %rax
movl (%rax), %eax
cmpl $0xb, %eax
je 0x8110
cmpl $0xa, %eax
je 0x80c8
cmpl $0x9, %eax
jne 0x8410
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x2250
movq %rbx, %rdi
movl %eax, %esi
callq 0x8465
jmp 0x812b
pushq $0x22
jmp 0x8026
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x803d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
jmp 0x8052
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x8318
cmpl $0x1, (%rax)
jne 0x83b8
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa117
testq %rax, %rax
je 0x83ff
movq %rax, %r15
pushq $0x25
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa15c
movq 0x10(%r15), %rsi
testq %rsi, %rsi
je 0x7fbc
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7b3a
decl (%r14)
pushq $0x2b
popq %rsi
movq %rbx, %rdi
callq 0x8465
xorl %esi, %esi
cmpq $0x0, 0x10(%r15)
setne %sil
jmp 0x8027
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8465
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq 0x20(%rbx), %rax
movq 0x8(%rax), %r12
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8465
movl 0x84(%r14), %eax
cmpq $0x20, %rax
jae 0x8337
movl %r12d, 0x4(%r14,%rax,4)
incl 0x84(%r14)
pushq $0x20
popq %rsi
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8465
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8465
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rbx), %rdi
callq 0x56c7
testq %rax, %rax
je 0x834c
movq %rax, %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x8126
movl %r13d, 0x14(%rsp)
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x6d72
testl %eax, %eax
js 0x8133
testl %ebp, %ebp
movl (%rsp), %ebp
jg 0x842f
movl %eax, %r15d
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8465
jmp 0x818a
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
callq 0x21c0
movsd %xmm0, (%rsp)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xa18e
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
movsd (%rsp), %xmm0
movsd %xmm0, (%rcx,%rax,4)
movq 0x20(%rbx), %rax
addq $0x2, 0x8(%rax)
jmp 0x812b
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xa15c
incl (%r14)
jmp 0x7c41
cmpl $0x2, %ebp
movl (%rsp), %ebp
jge 0x8438
movq 0x18(%rbx), %rdi
movq 0x8(%rsp), %rsi
callq 0x56c7
testq %rax, %rax
je 0x8446
movq %rax, %r15
cmpl %ebp, 0x14(%rsp)
jne 0x8174
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8465
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x8465
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa15c
incl %ebp
movl %ebp, (%r14)
jmp 0x7c41
leaq 0x45ea(%rip), %rdi      # 0xc785
leaq 0x36f7(%rip), %rsi      # 0xb899
leaq 0x6bb9(%rip), %rcx      # 0xed62
movl $0x173c, %edx           # imm = 0x173C
callq 0x20e0
leaq 0x45cb(%rip), %rdi      # 0xc785
leaq 0x36d8(%rip), %rsi      # 0xb899
leaq 0x6b9a(%rip), %rcx      # 0xed62
movl $0x173f, %edx           # imm = 0x173F
callq 0x20e0
leaq 0x68c0(%rip), %rdi      # 0xea99
leaq 0x36b9(%rip), %rsi      # 0xb899
leaq 0x6b7b(%rip), %rcx      # 0xed62
movl $0x1654, %edx           # imm = 0x1654
callq 0x20e0
leaq 0x68f6(%rip), %rdi      # 0xeaee
leaq 0x369a(%rip), %rsi      # 0xb899
leaq 0x6b5c(%rip), %rcx      # 0xed62
movl $0x1656, %edx           # imm = 0x1656
callq 0x20e0
leaq 0x456e(%rip), %rdi      # 0xc785
leaq 0x367b(%rip), %rsi      # 0xb899
leaq 0x6b3d(%rip), %rcx      # 0xed62
movl $0x1669, %edx           # imm = 0x1669
callq 0x20e0
leaq 0x454f(%rip), %rdi      # 0xc785
leaq 0x365c(%rip), %rsi      # 0xb899
leaq 0x6b1e(%rip), %rcx      # 0xed62
movl $0x1624, %edx           # imm = 0x1624
callq 0x20e0
leaq 0x6bac(%rip), %rdi      # 0xee01
leaq 0x363d(%rip), %rsi      # 0xb899
leaq 0x6aff(%rip), %rcx      # 0xed62
movl $0x1686, %edx           # imm = 0x1686
callq 0x20e0
leaq 0x6700(%rip), %rdi      # 0xe974
leaq 0x361e(%rip), %rsi      # 0xb899
leaq 0x6ae0(%rip), %rcx      # 0xed62
movl $0x15dd, %edx           # imm = 0x15DD
callq 0x20e0
leaq 0x6b6e(%rip), %rdi      # 0xee01
leaq 0x35ff(%rip), %rsi      # 0xb899
leaq 0x6ac1(%rip), %rcx      # 0xed62
movl $0x15ed, %edx           # imm = 0x15ED
callq 0x20e0
leaq 0x67e7(%rip), %rdi      # 0xea99
leaq 0x35e0(%rip), %rsi      # 0xb899
leaq 0x6aa2(%rip), %rcx      # 0xed62
movl $0x1720, %edx           # imm = 0x1720
callq 0x20e0
leaq 0x67c8(%rip), %rdi      # 0xea99
leaq 0x35c1(%rip), %rsi      # 0xb899
leaq 0x6a83(%rip), %rcx      # 0xed62
movl $0x1672, %edx           # imm = 0x1672
callq 0x20e0
movq 0x8(%r15), %rax
movl 0x18(%rax), %esi
leaq 0x6cc1(%rip), %rdi      # 0xefb8
jmp 0x8345
leaq 0x6bda(%rip), %rdi      # 0xeeda
leaq 0x3592(%rip), %rsi      # 0xb899
leaq 0x6a54(%rip), %rcx      # 0xed62
movl $0x16d2, %edx           # imm = 0x16D2
callq 0x20e0
leaq 0x6bbb(%rip), %rdi      # 0xeeda
leaq 0x3573(%rip), %rsi      # 0xb899
leaq 0x6a35(%rip), %rcx      # 0xed62
movl $0x16e3, %edx           # imm = 0x16E3
callq 0x20e0
movq 0x8(%r15), %rax
movl 0x18(%rax), %esi
leaq 0x6c27(%rip), %rdi      # 0xef6c
xorl %eax, %eax
callq 0x326e
leaq 0x5109(%rip), %rdi      # 0xd45c
leaq 0x353f(%rip), %rsi      # 0xb899
leaq 0x6a01(%rip), %rcx      # 0xed62
movl $0x1638, %edx           # imm = 0x1638
callq 0x20e0
leaq 0x6ab3(%rip), %rdi      # 0xee25
movq %r12, %rsi
jmp 0x8409
leaq 0x676d(%rip), %rdi      # 0xeaee
leaq 0x3511(%rip), %rsi      # 0xb899
leaq 0x69d3(%rip), %rcx      # 0xed62
movl $0x1723, %edx           # imm = 0x1723
callq 0x20e0
leaq 0x6b50(%rip), %rdi      # 0xeef0
leaq 0x34f2(%rip), %rsi      # 0xb899
leaq 0x69b4(%rip), %rcx      # 0xed62
movl $0x16d3, %edx           # imm = 0x16D3
callq 0x20e0
leaq 0x6b31(%rip), %rdi      # 0xeef0
leaq 0x34d3(%rip), %rsi      # 0xb899
leaq 0x6995(%rip), %rcx      # 0xed62
movl $0x16e4, %edx           # imm = 0x16E4
callq 0x20e0
leaq 0x6c21(%rip), %rdi      # 0xefff
leaq 0x34b4(%rip), %rsi      # 0xb899
leaq 0x6976(%rip), %rcx      # 0xed62
movl $0x1725, %edx           # imm = 0x1725
callq 0x20e0
leaq 0x6b12(%rip), %rdi      # 0xef0f
jmp 0x8406
leaq 0x6b37(%rip), %rdi      # 0xef3d
movq %r14, %rsi
xorl %eax, %eax
callq 0x326e
leaq 0x436e(%rip), %rdi      # 0xc785
leaq 0x347b(%rip), %rsi      # 0xb899
leaq 0x693d(%rip), %rcx      # 0xed62
movl $0x167f, %edx           # imm = 0x167F
callq 0x20e0
leaq 0x6a19(%rip), %rdi      # 0xee4f
jmp 0x843f
leaq 0x6a46(%rip), %rdi      # 0xee85
movq 0x8(%rsp), %rsi
jmp 0x8409
leaq 0x500f(%rip), %rdi      # 0xd45c
leaq 0x3445(%rip), %rsi      # 0xb899
leaq 0x6907(%rip), %rcx      # 0xed62
movl $0x16ae, %edx           # imm = 0x16AE
callq 0x20e0