// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, 0x10(%rsp)
cmpb $0x0, 0x194(%rsi)
je 0x80d5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %r13
movl 0x8(%rax), %r14d
leaq 0x50(%rsi), %rax
movq %rax, (%rsp)
movl 0x8(%rsi), %eax
cmpl %r14d, %eax
jge 0x80c6
movslq %eax, %rcx
movl (%r13,%rcx,4), %ebp
cmpq $0x2c, %rbp
ja 0x8a2c
leaq 0x42f7(%rip), %rsi      # 0xc408
movslq (%rsi,%rbp,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x8893
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
movq %rax, %r12
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r15
movq %r12, %rdi
callq 0x4d52
leal -0xf(%rbp), %eax
leaq 0x4366(%rip), %rcx      # 0xc4bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r12, %rdi
movq %r15, %rsi
callq 0x71fe
jmp 0x86a9
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x88b2
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7b11
cmpl $0x4, (%rax)
jne 0x88d1
movq %rax, %r12
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r15
movq %rax, %rdi
callq 0x4d52
cmpl $0x6, %ebp
jne 0x81c6
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x636e
jmp 0x8727
movl (%r12), %edi
cmpl $0x4, %edi
jne 0x81d7
movq 0x8(%r12), %rax
movl 0x8(%rax), %edi
movq %r15, %rsi
callq 0x70d7
movq %rax, %r15
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
leal -0x7(%rbp), %eax
leaq 0x42fe(%rip), %rcx      # 0xc4f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rsi
callq 0x653c
jmp 0x871a
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x88df
decl %eax
leaq (%rax,%rax,4), %rax
movq (%rsp), %rcx
incl 0x8(%rcx,%rax,4)
incl 0x10(%rcx,%rax,4)
movl (%rcx,%rax,4), %eax
jmp 0x85ef
movl 0x4c(%rbx), %eax
testl %eax, %eax
jle 0x88e8
movl 0x4(%r13,%rcx,4), %ecx
testl %ecx, %ecx
jle 0x87e7
cmpl $0x1, %ecx
jne 0x8a4b
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r15
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x8273
movq 0x8(%r15), %rax
movl 0x8(%rax), %eax
cmpl $0x3, %eax
je 0x87bc
cmpl $0x2, %eax
je 0x87aa
cmpl $0x1, %eax
jne 0x8a6a
movq %r15, %rdi
callq 0x4e28
movl %eax, 0x198(%rbx)
jmp 0x87d7
movslq 0x4c(%rbx), %rdx
leal -0xf(%rdx), %esi
cmpl $-0x11, %esi
jbe 0x89ab
movq 0x4(%r13,%rcx,4), %rcx
testq %rcx, %rcx
je 0x898c
leal 0x1(%rdx), %esi
movl %esi, 0x4c(%rbx)
addl $0x2, %eax
movl %eax, 0xc(%rbx,%rdx,4)
movl 0x8(%rcx), %eax
jmp 0x85ef
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x89b7
decl %eax
leaq (%rax,%rax,4), %rcx
movq (%rsp), %rdx
movl 0x4(%rdx,%rcx,4), %ecx
jmp 0x832a
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x89c3
decl %eax
leaq (%rax,%rax,4), %rdx
movq (%rsp), %rcx
movl 0xc(%rcx,%rdx,4), %ecx
testl %ecx, %ecx
js 0x8734
movq (%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
cmpl %ecx, 0x8(%rdx)
jl 0x8734
movl 0x4(%rdx), %ecx
movl %ecx, 0x8(%rbx)
movl %eax, 0x190(%rbx)
jmp 0x8734
movb $0x1, 0x194(%rbx)
jmp 0x8734
movq 0x4(%r13,%rcx,4), %rdi
movq (%rbx), %r15
callq 0x6d77
movq %r15, %rdi
movq %rax, %rsi
jmp 0x879f
movq (%rbx), %r15
movl 0x4(%r13,%rcx,4), %ebp
movslq 0xe035(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x86b3
leal 0x1(%rax), %ecx
movl %ecx, 0xe022(%rip)      # 0x163a0
leaq 0xde1b(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0x86c0
movsd 0x4(%r13,%rcx,4), %xmm0
movq (%rbx), %r15
movslq 0xe001(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x874e
leal 0x1(%rax), %ecx
movl %ecx, 0xdfee(%rip)      # 0x163a0
leaq 0xdde7(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0x8767
movslq 0x4(%r13,%rcx,4), %rax
testq %rax, %rax
js 0x88f1
movl 0x8(%r13,%rcx,4), %ebp
movq (%rbx), %rcx
movl 0x8(%rcx), %r15d
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
leaq 0xd913(%rip), %rcx      # 0x15d00
callq *(%rcx,%rax,8)
movq (%rbx), %rax
subl %ebp, %r15d
incl %r15d
cmpl %r15d, 0x8(%rax)
je 0x87a4
jmp 0x8910
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x8a0d
movq 0x4(%r13,%rcx,4), %r12
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movq (%rbx), %r15
movslq 0xdf5b(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x8782
leal 0x1(%rax), %ecx
movl %ecx, 0xdf48(%rip)      # 0x163a0
leaq 0xdd41(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0x878f
movl 0x4(%r13,%rcx,4), %eax
cmpq $0x5, %rax
ja 0x8a95
leaq 0x4096(%rip), %rcx      # 0xc514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x8a89
movq (%rbx), %r15
decl %eax
leaq (%rax,%rax,4), %rax
movq (%rsp), %rcx
movl 0x10(%rcx,%rax,4), %ebp
jmp 0x8364
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4c2a
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movslq 0x8(%rbx), %rax
testb %bpl, %bpl
je 0x8774
incl %eax
jmp 0x877d
movl 0x4(%r13,%rcx,4), %eax
jmp 0x85ef
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x89ee
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %r15
movq %rax, %rdi
callq 0x4d52
movq %r15, %rdi
callq 0x7944
jmp 0x8734
movslq 0x190(%rbx), %rdx
leal -0xf(%rdx), %esi
cmpl $-0x11, %esi
jbe 0x89e2
movl 0x4(%r13,%rcx,4), %ecx
leaq (%rdx,%rdx,4), %r15
incl %edx
movl %edx, 0x190(%rbx)
addl $0x2, %eax
movq (%rsp), %r12
movl %eax, (%r12,%r15,4)
movl %ecx, 0x4(%r12,%r15,4)
movl $0x0, 0x10(%r12,%r15,4)
movq $0x0, 0x8(%r12,%r15,4)
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b11
movq %rax, %rdi
callq 0x4e28
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movl %ebp, 0xc(%r12,%r15,4)
jmp 0x86d1
movslq 0x4(%r13,%rcx,4), %rax
testq %rax, %rax
js 0x892f
movl 0x8(%r13,%rcx,4), %ebp
movq (%rbx), %rcx
movl 0x8(%rcx), %r15d
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
leaq 0xd575(%rip), %rcx      # 0x15b30
callq *(%rcx,%rax,8)
movq (%rbx), %rax
subl %ebp, %r15d
cmpl %r15d, 0x8(%rax)
je 0x87a4
jmp 0x894e
movl 0x4(%r13,%rcx,4), %ecx
addl %ecx, %eax
decl %eax
jmp 0x85f1
movq 0x4(%r13,%rcx,4), %rax
testq %rax, %rax
je 0x896d
movl 0x8(%rax), %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x8734
movq %r12, %rdi
movq %r15, %rsi
callq 0x779e
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x73e8
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x780b
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7675
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x72cc
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7333
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7589
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7265
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x749d
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x78a0
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7513
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x7735
jmp 0x86a9
movq %r12, %rdi
movq %r15, %rsi
callq 0x75ff
movq (%rbx), %rdi
movl $0x1, %esi
jmp 0x872f
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %r15, %rdi
callq 0x7ab5
incl 0x8(%rbx)
jmp 0x8734
movq %r15, %rsi
callq 0x68cf
jmp 0x871a
movq %r15, %rsi
callq 0x6746
jmp 0x871a
movq %r15, %rsi
callq 0x67f8
jmp 0x871a
movq %r15, %rsi
callq 0x6b08
jmp 0x871a
movq %r15, %rsi
callq 0x6697
jmp 0x871a
movq %r15, %rsi
callq 0x69ca
jmp 0x871a
movq %r15, %rsi
callq 0x6a69
testq %r15, %r15
je 0x8727
movq %r15, %rdi
callq 0x4cd8
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7a28
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
cmpb $0x1, 0x194(%rbx)
jne 0x80f3
jmp 0x80c6
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
jmp 0x879c
movl 0x4(%r13,%rax,4), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x8734
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x4, (%rsi)
movq %r12, 0x8(%rsi)
movl %ebp, 0x10(%rsi)
movq %r15, %rdi
callq 0x7ab5
addl $0x2, 0x8(%rbx)
jmp 0x8734
movq %r15, %rdi
callq 0x6fee
movsd %xmm0, 0x1a0(%rbx)
jmp 0x87d7
movq 0x1a8(%rbx), %rdi
callq 0x21a0
movq %r15, %rdi
callq 0x7074
movq %rax, 0x1a8(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7a28
movl 0x4c(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x4c(%rbx)
cltq
movl 0x8(%rbx,%rax,4), %eax
jmp 0x85f1
movq (%rbx), %r15
movl 0x1b0(%rbx), %ebp
jmp 0x8364
movq (%rbx), %r15
movsd 0x1a0(%rbx), %xmm0
movslq 0xdb88(%rip), %rax      # 0x163a0
cmpq $0x3f, %rax
jg 0x886a
leal 0x1(%rax), %ecx
movl %ecx, 0xdb79(%rip)      # 0x163a0
leaq 0xd972(%rip), %rcx      # 0x161a0
movq (%rcx,%rax,8), %rsi
jmp 0x8883
movq (%rbx), %r15
movq 0x1a8(%rbx), %rdi
callq 0x6d77
movq %r15, %rdi
movq %rax, %rsi
jmp 0x86cc
movq (%rbx), %r15
movl 0x198(%rbx), %ebp
jmp 0x8364
movq (%rbx), %r15
movl 0x190(%rbx), %ebp
jmp 0x8364
movl $0x18, %edi
movsd %xmm0, 0x8(%rsp)
callq 0x21d0
movsd 0x8(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
jmp 0x86c9
leaq 0x6fc1(%rip), %rdi      # 0xf85b
leaq 0x3ff8(%rip), %rsi      # 0xc899
leaq 0x6f20(%rip), %rcx      # 0xf7c8
movl $0x14c6, %edx           # imm = 0x14C6
callq 0x20e0
leaq 0x6fa2(%rip), %rdi      # 0xf85b
leaq 0x3fd9(%rip), %rsi      # 0xc899
leaq 0x6f01(%rip), %rcx      # 0xf7c8
movl $0x1496, %edx           # imm = 0x1496
callq 0x20e0
leaq 0x6f98(%rip), %rdi      # 0xf870
xorl %eax, %eax
callq 0x344d
leaq 0x700a(%rip), %rdi      # 0xf8f0
jmp 0x88d8
leaq 0x70f4(%rip), %rdi      # 0xf9e3
jmp 0x88d8
leaq 0x70ba(%rip), %rdi      # 0xf9b2
leaq 0x3f9a(%rip), %rsi      # 0xc899
leaq 0x6ec2(%rip), %rcx      # 0xf7c8
movl $0x156e, %edx           # imm = 0x156E
callq 0x20e0
leaq 0x70a9(%rip), %rdi      # 0xf9c0
leaq 0x3f7b(%rip), %rsi      # 0xc899
leaq 0x6ea3(%rip), %rcx      # 0xf7c8
movl $0x1576, %edx           # imm = 0x1576
callq 0x20e0
leaq 0x704f(%rip), %rdi      # 0xf985
leaq 0x3f5c(%rip), %rsi      # 0xc899
leaq 0x6e84(%rip), %rcx      # 0xf7c8
movl $0x155e, %edx           # imm = 0x155E
callq 0x20e0
leaq 0x703d(%rip), %rdi      # 0xf992
leaq 0x3f3d(%rip), %rsi      # 0xc899
leaq 0x6e65(%rip), %rcx      # 0xf7c8
movl $0x1566, %edx           # imm = 0x1566
callq 0x20e0
leaq 0x7000(%rip), %rdi      # 0xf974
leaq 0x3f1e(%rip), %rsi      # 0xc899
leaq 0x6e46(%rip), %rcx      # 0xf7c8
movl $0x1556, %edx           # imm = 0x1556
callq 0x20e0
leaq 0x6fe1(%rip), %rdi      # 0xf974
leaq 0x3eff(%rip), %rsi      # 0xc899
leaq 0x6e27(%rip), %rcx      # 0xf7c8
movl $0x1549, %edx           # imm = 0x1549
callq 0x20e0
leaq 0x6f9e(%rip), %rdi      # 0xf950
jmp 0x88d8
leaq 0x6f66(%rip), %rdi      # 0xf924
jmp 0x88d8
leaq 0x6f0b(%rip), %rdi      # 0xf8d5
leaq 0x3ec8(%rip), %rsi      # 0xc899
leaq 0x6df0(%rip), %rcx      # 0xf7c8
movl $0x1517, %edx           # imm = 0x1517
callq 0x20e0
leaq 0x6ec7(%rip), %rdi      # 0xf8b0
jmp 0x88d8
leaq 0x6dbe(%rip), %rdi      # 0xf7b3
leaq 0x3e9d(%rip), %rsi      # 0xc899
leaq 0x6dc5(%rip), %rcx      # 0xf7c8
movl $0x14e3, %edx           # imm = 0x14E3
callq 0x20e0
leaq 0x6d9f(%rip), %rdi      # 0xf7b3
leaq 0x3e7e(%rip), %rsi      # 0xc899
leaq 0x6da6(%rip), %rcx      # 0xf7c8
movl $0x145e, %edx           # imm = 0x145E
callq 0x20e0
leaq 0x4d52(%rip), %rdi      # 0xd785
leaq 0x3e5f(%rip), %rsi      # 0xc899
leaq 0x6d87(%rip), %rcx      # 0xf7c8
movl $0x15a6, %edx           # imm = 0x15A6
callq 0x20e0
leaq 0x6fc5(%rip), %rdi      # 0xfa17
leaq 0x3e40(%rip), %rsi      # 0xc899
leaq 0x6d68(%rip), %rcx      # 0xf7c8
movl $0x1590, %edx           # imm = 0x1590
callq 0x20e0
leaq 0x4d14(%rip), %rdi      # 0xd785
leaq 0x3e21(%rip), %rsi      # 0xc899
leaq 0x6d49(%rip), %rcx      # 0xf7c8
movl $0x1597, %edx           # imm = 0x1597
callq 0x20e0
leaq 0x6d83(%rip), %rdi      # 0xf813
jmp 0x88d8
leaq 0x4ce9(%rip), %rdi      # 0xd785
leaq 0x3df6(%rip), %rsi      # 0xc899
leaq 0x6d1e(%rip), %rcx      # 0xf7c8
movl $0x1484, %edx           # imm = 0x1484
callq 0x20e0