// File: /workspace/github_cpp_makefile_star2_O2/exrd[P]neteruhsp/neteruhsp/neteruhsp.cc
// Function: neteruhsp::execute_inner(neteruhsp::execute_environment_t*, neteruhsp::execute_status_t*)
void execute_inner( execute_environment_t* e, execute_status_t* s )
{
	const code_t* codes =e->execute_code_->code_;
	const auto code_size = static_cast<int>(e->execute_code_->code_size_);

	auto& pc = s->pc_;

	for( ; ; )
	{

		// もう実行おわってる
		if ( s->is_end_ )
		{ break; }

		// 末尾に到達してる
		if ( code_size <= pc )
		{ break; }

		const auto op = codes[ pc ];
		switch( op )
		{
			case OPERATOR_NOP:
				break;

			case OPERATOR_PUSH_INT:
				stack_push( s->stack_, create_value( codes[ pc +1 ] ) );
				++pc;
				break;

			case OPERATOR_PUSH_DOUBLE:
			{
				double v =0.0;
				const auto stride = code_get_block( v, codes, pc +1 );
				stack_push( s->stack_, create_value( v ) );
				pc += stride;
				break;
			}

			case OPERATOR_PUSH_STRING:
			{
				const char* v =nullptr;
				const auto stride = code_get_block( v, codes, pc +1 );
				stack_push( s->stack_, create_value( v ) );
				pc += stride;
				break;
			}

			case OPERATOR_PUSH_VARIABLE:
			{
				variable_t* var =nullptr;
				const auto stride = code_get_block( var, codes, pc +1 );

				assert( s->stack_->top_ >= 1 );
				const auto i = stack_peek( s->stack_ );
				const auto idx = value_calc_int( *i );
				stack_pop( s->stack_, 1 );
				stack_push( s->stack_, create_value( var, idx ) );

				pc += stride;
				break;
			}

			case OPERATOR_PUSH_SYSVAR:
			{
				const auto sysvar = codes[ pc +1 ];
				switch( sysvar )
				{
					case SYSVAR_CNT:
						if ( s->current_loop_frame_ <= 0 )
						{
							raise_error( "システム変数cnt：repeat-loop中でないのに参照しました" );
						}
						stack_push( s->stack_, create_value( s->loop_frame_[s->current_loop_frame_ -1].cnt_ ) );
						break;
					case SYSVAR_STAT:
						stack_push( s->stack_, create_value( s->stat_ ) );
						break;
					case SYSVAR_REFDVAL:
						stack_push( s->stack_, create_value( s->refdval_ ) );
						break;
					case SYSVAR_REFSTR:
						stack_push( s->stack_, create_value( s->refstr_ ) );
						break;
					case SYSVAR_STRSIZE:
						stack_push( s->stack_, create_value( s->strsize_ ) );
						break;
					case SYSVAR_LOOPLEV:
						stack_push( s->stack_, create_value( s->current_loop_frame_ ) );
						break;
					default:
						assert( false );
						stack_push( s->stack_, create_value( 0 ) );
						break;
				}
				++pc;
				break;
			}

			case OPERATOR_ASSIGN:
			case OPERATOR_ADD_ASSIGN:
			case OPERATOR_SUB_ASSIGN:
			case OPERATOR_MUL_ASSIGN:
			case OPERATOR_DIV_ASSIGN:
			case OPERATOR_MOD_ASSIGN:
			case OPERATOR_BOR_ASSIGN:
			case OPERATOR_BAND_ASSIGN:
			case OPERATOR_BXOR_ASSIGN:
			{
				assert( s->stack_->top_ >= 2 );

				const auto var =stack_peek( s->stack_, -2 );
				if ( var->type_ != VALUE_VARIABLE )
				{
					raise_error( "変数代入：代入先が変数ではありませんでした" );
				}

				const auto v =stack_peek( s->stack_, -1 );
				value_isolate( *v );
				auto* t = ( op == OPERATOR_ASSIGN ? nullptr : value_convert_type( value_get_primitive_tag( *var ), *v ) );
				switch( op )
				{
				case OPERATOR_ASSIGN:		variable_set( var->variable_, *v, var->index_ ); break;
				case OPERATOR_ADD_ASSIGN:	variable_add( var->variable_, *t, var->index_ ); break;
				case OPERATOR_SUB_ASSIGN:	variable_sub( var->variable_, *t, var->index_ ); break;
				case OPERATOR_MUL_ASSIGN:	variable_mul( var->variable_, *t, var->index_ ); break;
				case OPERATOR_DIV_ASSIGN:	variable_div( var->variable_, *t, var->index_ ); break;
				case OPERATOR_MOD_ASSIGN:	variable_mod( var->variable_, *t, var->index_ ); break;
				case OPERATOR_BOR_ASSIGN:	variable_bor( var->variable_, *t, var->index_ ); break;
				case OPERATOR_BAND_ASSIGN:	variable_band( var->variable_, *t, var->index_ ); break;
				case OPERATOR_BXOR_ASSIGN:	variable_bxor( var->variable_, *t, var->index_ ); break;
				default: assert( false ); break;
				}
				if ( t != nullptr )
				{
					destroy_value( t );
					t = nullptr;
				}
				stack_pop( s->stack_, 2 );
				break;
			}

			case OPERATOR_BOR:
			case OPERATOR_BAND:
			case OPERATOR_BXOR:
			case OPERATOR_EQ:
			case OPERATOR_NEQ:
			case OPERATOR_GT:
			case OPERATOR_GTOE:
			case OPERATOR_LT:
			case OPERATOR_LTOE:
			case OPERATOR_ADD:
			case OPERATOR_SUB:
			case OPERATOR_MUL:
			case OPERATOR_DIV:
			case OPERATOR_MOD:
			{
				assert( s->stack_->top_ >= 2 );
				value_t* l =stack_peek( s->stack_, -2 );
				value_t* r =stack_peek( s->stack_, -1 );
				value_isolate( *l );

				switch( op )
				{
					case OPERATOR_BOR:		value_bor( l, *r ); break;
					case OPERATOR_BAND:		value_band( l, *r ); break;
					case OPERATOR_BXOR:		value_bxor( l, *r ); break;
					case OPERATOR_EQ:		value_eq( l, *r ); break;
					case OPERATOR_NEQ:		value_neq( l, *r ); break;
					case OPERATOR_GT:		value_gt( l, *r ); break;
					case OPERATOR_GTOE:		value_gtoe( l, *r ); break;
					case OPERATOR_LT:		value_lt( l, *r ); break;
					case OPERATOR_LTOE:		value_ltoe( l, *r ); break;
					case OPERATOR_ADD:		value_add( l, *r ); break;
					case OPERATOR_SUB:		value_sub( l, *r ); break;
					case OPERATOR_MUL:		value_mul( l, *r ); break;
					case OPERATOR_DIV:		value_div( l, *r ); break;
					case OPERATOR_MOD:		value_mod( l, *r ); break;
					default: assert( false ); break;
				}
				stack_pop( s->stack_ );
				break;
			}

			case OPERATOR_UNARY_MINUS:
			{
				assert( s->stack_->top_ >= 1 );
				value_t* v =stack_peek( s->stack_ );
				value_isolate( *v );
				value_unary_minus( v );
				break;
			}

			case OPERATOR_IF:
			{
				const auto cond = stack_peek( s->stack_ );
				const auto is_cond = value_calc_boolean( *cond );
				stack_pop( s->stack_ );
				if ( is_cond )
				{
					++pc;
				}
				else
				{
					const auto false_head = codes[ pc +1 ];
					pc += false_head -1;
				}
				break;
			}

			case OPERATOR_REPEAT:
			{
				if ( s->current_loop_frame_ +1 >= MAX_LOOP_FRAME )
				{
					raise_error( "repeat：ネストが深すぎます" );
				}

				const auto end_position = codes[ pc +1 ];

				auto& frame = s->loop_frame_[s->current_loop_frame_];
				++s->current_loop_frame_;
				frame.start_position_ = pc +2;
				frame.end_position_ = end_position;
				frame.cnt_ = 0;
				frame.counter_ = 0;
				frame.max_ = 0;

				int loop_num =-1;
				const auto v = stack_peek( s->stack_ );
				loop_num = value_calc_int( *v );
				stack_pop( s->stack_ );

				frame.max_ = loop_num;
				++pc;
				break;
			}
			case OPERATOR_REPEAT_CHECK:
			{
				assert( s->current_loop_frame_ > 0 );
				auto& frame = s->loop_frame_[ s->current_loop_frame_ -1 ];
				if ( frame.max_>=0 && frame.counter_>=frame.max_ )
				{
					pc = frame.end_position_;
					--s->current_loop_frame_;
				}
				break;
			}

			case OPERATOR_LOOP:
			case OPERATOR_CONTINUE:
			{
				if ( s->current_loop_frame_ <= 0 )
				{
					raise_error( "loop,continue：repeat-loopの中にありません" );
				}

				auto& frame = s->loop_frame_[ s->current_loop_frame_ -1 ];
				++frame.counter_;
				++frame.cnt_;
				pc = frame.start_position_ -1;
				break;
			}
			case OPERATOR_BREAK:
			{
				if ( s->current_loop_frame_ <= 0 )
				{
					raise_error( "break：repeat-loopの中にありません" );
				}

				auto& frame = s->loop_frame_[ s->current_loop_frame_ -1 ];
				pc = frame.end_position_;

				--s->current_loop_frame_;
				break;
			}

			case OPERATOR_LABEL:
				break;

			case OPERATOR_GOSUB:
			{
				if ( (s->current_call_frame_ +1) >= MAX_CALL_FRAME )
				{
					raise_error( "gosub：ネストが深すぎます" );
				}

				label_node_t* label =nullptr;
				const auto stride = code_get_block( label, codes, pc +1 );
				assert( label != nullptr );

				auto& frame = s->call_frame_[s->current_call_frame_];
				++s->current_call_frame_;
				frame.caller_poisition_ = pc +stride;

				pc = label->position_ -1;
				break;
			}
			case OPERATOR_GOTO:
			{
				label_node_t* label =nullptr;
				code_get_block( label, codes, pc +1 );
				assert( label != nullptr );
				pc = label->position_ -1;
				break;
			}

			case OPERATOR_COMMAND:
			{
				const auto command = codes[ pc +1 ];
				assert( command >= 0 );
				const auto arg_num = codes[ pc +2 ];

					// コマンド呼び出し
				const auto delegate = get_command_delegate( static_cast<builtin_command_tag>( command ) );
				assert( delegate != nullptr );
				const auto top = s->stack_->top_;
				delegate( e, s, arg_num );
				assert( s->stack_->top_ == top -arg_num );// 戻り値がないことを確認

				pc += 2;
				break;
			}
			case OPERATOR_FUNCTION:
			{
				const auto function = codes[ pc +1 ];
				assert( function >= 0 );
				const auto arg_num = codes[ pc +2 ];

					// 関数呼び出し
				const auto delegate = get_function_delegate( static_cast<builtin_function_tag>( function ) );
				assert( delegate != nullptr );
				const auto top = s->stack_->top_;
				delegate( e, s, arg_num );
				assert( s->stack_->top_ == top -arg_num +1 );// 戻り値が入っていることを確認する

				 pc += 2;
				break;
			}

			case OPERATOR_JUMP:
			{
				pc = codes[ pc +1 ] -1;
				break;
			}
			case OPERATOR_JUMP_RELATIVE:
			{
				pc += codes[ pc +1 ] -1;
				break;
			}
			case OPERATOR_RETURN:
			{
				if ( s->current_call_frame_ <= 0 )
				{
					raise_error( "サブルーチン外からのreturnは無効です" );
				}

				const auto arg_num = codes[ pc +1 ];
				if ( arg_num > 0 )
				{
					assert( arg_num == 1 );
					const auto res = stack_peek( s->stack_ );
					switch( value_get_primitive_tag(*res) )
					{
						case VALUE_INT:		s->stat_ = value_calc_int(*res); break;
						case VALUE_DOUBLE:	s->refdval_ = value_calc_double(*res); break;
						case VALUE_STRING:	destroy_string( s->refstr_ ); s->refstr_ = value_calc_string(*res); break;
						default: assert( false ); break;
					}
					stack_pop( s->stack_ );
				}

				--s->current_call_frame_;
				const auto& frame =s->call_frame_[ s->current_call_frame_ ];
				pc = frame.caller_poisition_;
				break;
			}

			case OPERATOR_END:
				s->is_end_ =true;
				break;

			default: assert( false ); break;
		}

		++pc;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, 0x10(%rsp)
movq 0x20(%rdi), %rax
movq (%rax), %r12
movl 0x8(%rax), %ebp
leaq 0x50(%rsi), %rax
movq %rax, 0x8(%rsp)
cmpb $0x0, 0x194(%rbx)
jne 0x788d
movslq 0x8(%rbx), %rax
cmpl %ebp, %eax
jge 0x788d
movl (%r12,%rax,4), %r15d
cmpq $0x2c, %r15
ja 0x7a35
leaq 0x41d0(%rip), %rdx      # 0xb408
movslq (%rdx,%r15,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x789c
pushq $-0x2
popq %rsi
callq 0x6d39
movq %rax, %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r13
movq %r14, %rdi
callq 0x47ad
leal -0xf(%r15), %eax
leaq 0x4242(%rip), %rcx      # 0xb4bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %r13, %rsi
callq 0x6440
jmp 0x7774
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x78bb
pushq $-0x2
popq %rsi
callq 0x6d39
cmpl $0x4, (%rax)
jne 0x78da
movq %rax, %r14
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r13
movq %rax, %rdi
callq 0x47ad
cmpl $0x6, %r15d
jne 0x72e5
movq 0x8(%r14), %rdi
movl 0x10(%r14), %edx
movq %r13, %rsi
callq 0x5764
jmp 0x77cc
movl (%r14), %edi
cmpl $0x4, %edi
jne 0x72f4
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
movq %r13, %rsi
callq 0x63d5
movq %rax, %r13
movq 0x8(%r14), %rdi
movl 0x10(%r14), %edx
leal -0x7(%r15), %eax
leaq 0x41e2(%rip), %rcx      # 0xb4f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r13, %rsi
callq 0x592e
jmp 0x77bf
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x78e8
decl %eax
imulq $0x14, %rax, %rax
movq 0x8(%rsp), %rcx
incl 0x8(%rcx,%rax)
incl 0x10(%rcx,%rax)
movl (%rcx,%rax), %eax
jmp 0x76ba
movl 0x4c(%rbx), %ecx
testl %ecx, %ecx
jle 0x78f1
movl 0x4(%r12,%rax,4), %eax
testl %eax, %eax
jle 0x7828
cmpl $0x1, %eax
jne 0x7a54
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r14
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x738e
movq 0x8(%r14), %rax
movl 0x8(%rax), %eax
cmpl $0x3, %eax
je 0x77ff
cmpl $0x2, %eax
je 0x77ed
cmpl $0x1, %eax
jne 0x7a73
movq %r14, %rdi
callq 0x4834
movl %eax, 0x198(%rbx)
jmp 0x781a
movslq 0x4c(%rbx), %rcx
leal -0xf(%rcx), %edx
cmpl $-0x11, %edx
jbe 0x79b4
movq 0x4(%r12,%rax,4), %rdx
testq %rdx, %rdx
je 0x7995
leal 0x1(%rcx), %esi
movl %esi, 0x4c(%rbx)
addl $0x2, %eax
movl %eax, 0xc(%rbx,%rcx,4)
movl 0x8(%rdx), %eax
jmp 0x76ba
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x79c0
decl %eax
imulq $0x14, %rax, %rcx
movq 0x8(%rsp), %rdx
movl 0x4(%rdx,%rcx), %ecx
jmp 0x7444
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x79cc
decl %eax
imulq $0x14, %rax, %rcx
movq 0x8(%rsp), %rdx
movl 0xc(%rdx,%rcx), %edx
testl %edx, %edx
js 0x77d7
addq 0x8(%rsp), %rcx
cmpl %edx, 0x8(%rcx)
jl 0x77d7
movl 0x4(%rcx), %ecx
movl %ecx, 0x8(%rbx)
movl %eax, 0x190(%rbx)
jmp 0x77d7
movb $0x1, 0x194(%rbx)
jmp 0x77d7
movq 0x4(%r12,%rax,4), %rdi
movq (%rbx), %r14
callq 0x613c
jmp 0x7499
movq (%rbx), %r14
movl 0x4(%r12,%rax,4), %edi
callq 0x60e2
movq %r14, %rdi
movq %rax, %rsi
callq 0x6cdd
jmp 0x764e
movsd 0x4(%r12,%rax,4), %xmm0
movq (%rbx), %r14
callq 0x611f
movq %r14, %rdi
jmp 0x7529
movslq 0x4(%r12,%rax,4), %rcx
testq %rcx, %rcx
js 0x78fa
movl 0x8(%r12,%rax,4), %r14d
movq (%rbx), %rax
movl 0x8(%rax), %r15d
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
leaq 0xd833(%rip), %rax      # 0x14d00
callq *(%rax,%rcx,8)
movq (%rbx), %rax
subl %r14d, %r15d
incl %r15d
cmpl %r15d, 0x8(%rax)
je 0x7695
jmp 0x7919
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x7a16
movq 0x4(%r12,%rax,4), %r14
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %r13d
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movq (%rbx), %r15
movq %r14, %rdi
movl %r13d, %esi
callq 0x6168
movq %r15, %rdi
movq %rax, %rsi
callq 0x6cdd
jmp 0x7695
movl 0x4(%r12,%rax,4), %eax
cmpq $0x5, %rax
ja 0x7a9e
leaq 0x3fc8(%rip), %rcx      # 0xb514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x7a92
movq (%rbx), %r14
decl %eax
imulq $0x14, %rax, %rax
movq 0x8(%rsp), %rcx
movl 0x10(%rcx,%rax), %edi
jmp 0x7475
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x468a
movl %eax, %r14d
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movslq 0x8(%rbx), %rax
testb %r14b, %r14b
je 0x77df
incl %eax
jmp 0x77e8
movl 0x4(%r12,%rax,4), %eax
jmp 0x76ba
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x79f7
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %r14
movq %rax, %rdi
callq 0x47ad
movq %r14, %rdi
callq 0x6b92
jmp 0x77d7
movslq 0x190(%rbx), %rcx
leal -0xf(%rcx), %edx
cmpl $-0x11, %edx
jbe 0x79eb
movl 0x4(%r12,%rax,4), %edx
imulq $0x14, %rcx, %r15
incl %ecx
movl %ecx, 0x190(%rbx)
addl $0x2, %eax
movq 0x8(%rsp), %r13
movl %eax, (%r13,%r15)
movl %edx, 0x4(%r13,%r15)
andl $0x0, 0x10(%r13,%r15)
andq $0x0, 0x8(%r13,%r15)
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x6d39
movq %rax, %rdi
callq 0x4834
movl %eax, %r14d
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movl %r14d, 0xc(%r13,%r15)
incl 0x8(%rbx)
jmp 0x77d7
movslq 0x4(%r12,%rax,4), %rcx
testq %rcx, %rcx
js 0x7938
movl 0x8(%r12,%rax,4), %r14d
movq (%rbx), %rax
movl 0x8(%rax), %r15d
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
leaq 0xd4ae(%rip), %rax      # 0x14b30
callq *(%rax,%rcx,8)
movq (%rbx), %rax
subl %r14d, %r15d
cmpl %r15d, 0x8(%rax)
jne 0x7957
addl $0x2, 0x8(%rbx)
jmp 0x77d7
movl 0x4(%r12,%rax,4), %ecx
addl %ecx, %eax
decl %eax
jmp 0x76bc
movq 0x4(%r12,%rax,4), %rax
testq %rax, %rax
je 0x7976
movl 0x8(%rax), %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x77d7
movq %r14, %rdi
movq %r13, %rsi
callq 0x69ec
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x662e
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x6a59
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x68c6
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x652c
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x65a2
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x67c0
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x64b6
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x66ba
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x6aee
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x673d
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x6983
jmp 0x7774
movq %r14, %rdi
movq %r13, %rsi
callq 0x6843
movq (%rbx), %rdi
pushq $0x1
jmp 0x77d1
movq %r13, %rsi
callq 0x5cbd
jmp 0x77bf
movq %r13, %rsi
callq 0x5b34
jmp 0x77bf
movq %r13, %rsi
callq 0x5be6
jmp 0x77bf
movq %r13, %rsi
callq 0x5ef6
jmp 0x77bf
movq %r13, %rsi
callq 0x5a85
jmp 0x77bf
movq %r13, %rsi
callq 0x5db8
jmp 0x77bf
movq %r13, %rsi
callq 0x5e57
testq %r13, %r13
je 0x77cc
movq %r13, %rdi
callq 0x4738
movq (%rbx), %rdi
pushq $0x2
popq %rsi
callq 0x6c55
incl 0x8(%rbx)
jmp 0x720a
movl 0x4(%r12,%rax,4), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x77d7
movq %r14, %rdi
callq 0x62f2
movsd %xmm0, 0x1a0(%rbx)
jmp 0x781a
movq 0x1a8(%rbx), %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x6372
movq %rax, 0x1a8(%rbx)
movq (%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x6c55
movl 0x4c(%rbx), %ecx
leal -0x1(%rcx), %eax
movl %eax, 0x4c(%rbx)
movslq %ecx, %rax
movl 0x8(%rbx,%rax,4), %eax
jmp 0x76bc
movq (%rbx), %r14
movl 0x1b0(%rbx), %edi
jmp 0x7475
movq (%rbx), %r14
movsd 0x1a0(%rbx), %xmm0
callq 0x611f
jmp 0x747a
movq (%rbx), %r14
movq 0x1a8(%rbx), %rdi
callq 0x613c
jmp 0x747a
movq (%rbx), %r14
movl 0x198(%rbx), %edi
jmp 0x7475
movq (%rbx), %r14
movl 0x190(%rbx), %edi
jmp 0x7475
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6fb8(%rip), %rdi      # 0xe85b
leaq 0x3fef(%rip), %rsi      # 0xb899
leaq 0x6f17(%rip), %rcx      # 0xe7c8
movl $0x14c6, %edx           # imm = 0x14C6
callq 0x20e0
leaq 0x6f99(%rip), %rdi      # 0xe85b
leaq 0x3fd0(%rip), %rsi      # 0xb899
leaq 0x6ef8(%rip), %rcx      # 0xe7c8
movl $0x1496, %edx           # imm = 0x1496
callq 0x20e0
leaq 0x6f8f(%rip), %rdi      # 0xe870
xorl %eax, %eax
callq 0x326e
leaq 0x7001(%rip), %rdi      # 0xe8f0
jmp 0x78e1
leaq 0x70eb(%rip), %rdi      # 0xe9e3
jmp 0x78e1
leaq 0x70b1(%rip), %rdi      # 0xe9b2
leaq 0x3f91(%rip), %rsi      # 0xb899
leaq 0x6eb9(%rip), %rcx      # 0xe7c8
movl $0x156e, %edx           # imm = 0x156E
callq 0x20e0
leaq 0x70a0(%rip), %rdi      # 0xe9c0
leaq 0x3f72(%rip), %rsi      # 0xb899
leaq 0x6e9a(%rip), %rcx      # 0xe7c8
movl $0x1576, %edx           # imm = 0x1576
callq 0x20e0
leaq 0x7046(%rip), %rdi      # 0xe985
leaq 0x3f53(%rip), %rsi      # 0xb899
leaq 0x6e7b(%rip), %rcx      # 0xe7c8
movl $0x155e, %edx           # imm = 0x155E
callq 0x20e0
leaq 0x7034(%rip), %rdi      # 0xe992
leaq 0x3f34(%rip), %rsi      # 0xb899
leaq 0x6e5c(%rip), %rcx      # 0xe7c8
movl $0x1566, %edx           # imm = 0x1566
callq 0x20e0
leaq 0x6ff7(%rip), %rdi      # 0xe974
leaq 0x3f15(%rip), %rsi      # 0xb899
leaq 0x6e3d(%rip), %rcx      # 0xe7c8
movl $0x1556, %edx           # imm = 0x1556
callq 0x20e0
leaq 0x6fd8(%rip), %rdi      # 0xe974
leaq 0x3ef6(%rip), %rsi      # 0xb899
leaq 0x6e1e(%rip), %rcx      # 0xe7c8
movl $0x1549, %edx           # imm = 0x1549
callq 0x20e0
leaq 0x6f95(%rip), %rdi      # 0xe950
jmp 0x78e1
leaq 0x6f5d(%rip), %rdi      # 0xe924
jmp 0x78e1
leaq 0x6f02(%rip), %rdi      # 0xe8d5
leaq 0x3ebf(%rip), %rsi      # 0xb899
leaq 0x6de7(%rip), %rcx      # 0xe7c8
movl $0x1517, %edx           # imm = 0x1517
callq 0x20e0
leaq 0x6ebe(%rip), %rdi      # 0xe8b0
jmp 0x78e1
leaq 0x6db5(%rip), %rdi      # 0xe7b3
leaq 0x3e94(%rip), %rsi      # 0xb899
leaq 0x6dbc(%rip), %rcx      # 0xe7c8
movl $0x14e3, %edx           # imm = 0x14E3
callq 0x20e0
leaq 0x6d96(%rip), %rdi      # 0xe7b3
leaq 0x3e75(%rip), %rsi      # 0xb899
leaq 0x6d9d(%rip), %rcx      # 0xe7c8
movl $0x145e, %edx           # imm = 0x145E
callq 0x20e0
leaq 0x4d49(%rip), %rdi      # 0xc785
leaq 0x3e56(%rip), %rsi      # 0xb899
leaq 0x6d7e(%rip), %rcx      # 0xe7c8
movl $0x15a6, %edx           # imm = 0x15A6
callq 0x20e0
leaq 0x6fbc(%rip), %rdi      # 0xea17
leaq 0x3e37(%rip), %rsi      # 0xb899
leaq 0x6d5f(%rip), %rcx      # 0xe7c8
movl $0x1590, %edx           # imm = 0x1590
callq 0x20e0
leaq 0x4d0b(%rip), %rdi      # 0xc785
leaq 0x3e18(%rip), %rsi      # 0xb899
leaq 0x6d40(%rip), %rcx      # 0xe7c8
movl $0x1597, %edx           # imm = 0x1597
callq 0x20e0
leaq 0x6d7a(%rip), %rdi      # 0xe813
jmp 0x78e1
leaq 0x4ce0(%rip), %rdi      # 0xc785
leaq 0x3ded(%rip), %rsi      # 0xb899
leaq 0x6d15(%rip), %rcx      # 0xe7c8
movl $0x1484, %edx           # imm = 0x1484
callq 0x20e0