// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpb $0x0, 0x194(%rsi)
je 0x852f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rbx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %r14
movl 0x8(%rax), %r13d
leaq 0x50(%rsi), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x20(%rsp)
movslq 0x8(%rbx), %rax
cmpl %r13d, %eax
jge 0x8520
movl (%r14,%rax,4), %ebp
cmpq $0x2c, %rbp
ja 0x8f62
leaq 0x4eda(%rip), %rdx      # 0xd448
movslq (%rdx,%rbp,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x8d8b
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7f19
movq %rax, %r12
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %r15
movq %r12, %rdi
callq 0x5109
leal -0xf(%rbp), %eax
cmpl $0xd, %eax
ja 0x8f43
leaq 0x4f40(%rip), %rcx      # 0xd4fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r12, %rdi
movq %r15, %rsi
callq 0x7600
jmp 0x8b3c
movq (%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jle 0x8daa
movl %r13d, %r14d
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7f19
cmpl $0x4, (%rax)
jne 0x8dc9
movq %rax, %r12
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %r13
movq %rax, %rdi
callq 0x5109
cmpl $0x6, %ebp
jne 0x861d
xorl %r15d, %r15d
jmp 0x8639
movl (%r12), %edi
cmpl $0x4, %edi
jne 0x862e
movq 0x8(%r12), %rax
movl 0x8(%rax), %edi
movq %r13, %rsi
callq 0x74d9
movq %rax, %r15
leal -0x6(%rbp), %eax
cmpl $0x8, %eax
ja 0x8f24
leaq 0x4ee8(%rip), %rcx      # 0xd534
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r13, %rsi
callq 0x6788
jmp 0x8bea
cmpl $0x0, 0x190(%rbx)
jle 0x8dd7
movslq 0x190(%rbx), %rax
leaq (%rax,%rax,4), %rax
movq 0x8(%rsp), %rcx
incl -0xc(%rcx,%rax,4)
incl -0x4(%rcx,%rax,4)
movl -0x14(%rcx,%rax,4), %eax
jmp 0x8a82
cmpl $0x0, 0x4c(%rbx)
jle 0x8de0
movslq 0x8(%rbx), %rax
movl 0x4(%r14,%rax,4), %eax
testl %eax, %eax
jle 0x8cdd
cmpl $0x1, %eax
jne 0x8f81
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %r15
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x86dc
movq 0x8(%r15), %rax
movl 0x8(%rax), %eax
cmpl $0x3, %eax
je 0x8cb5
cmpl $0x2, %eax
je 0x8ca3
cmpl $0x1, %eax
jne 0x8fa0
movq %r15, %rdi
callq 0x51df
movl %eax, 0x198(%rbx)
jmp 0x8cd0
movl 0x4c(%rbx), %eax
addl $-0xf, %eax
cmpl $-0x11, %eax
jbe 0x8ea3
movslq 0x8(%rbx), %rcx
movq 0x4(%r14,%rcx,4), %rax
testq %rax, %rax
je 0x8e84
movslq 0x4c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x4c(%rbx)
addl $0x2, %ecx
movl %ecx, 0xc(%rbx,%rdx,4)
jmp 0x8a7f
cmpl $0x0, 0x190(%rbx)
jle 0x8eaf
movslq 0x190(%rbx), %rax
leal -0x1(%rax), %ecx
leaq (%rax,%rax,4), %rax
movq 0x8(%rsp), %rdx
movl -0x10(%rdx,%rax,4), %eax
movl %eax, 0x8(%rbx)
movl %ecx, 0x190(%rbx)
jmp 0x8c0c
movl 0x190(%rbx), %eax
testl %eax, %eax
jle 0x8ebb
decl %eax
leaq (%rax,%rax,4), %rdx
movq 0x8(%rsp), %rcx
movl 0xc(%rcx,%rdx,4), %ecx
testl %ecx, %ecx
js 0x8c0c
movq 0x8(%rsp), %rsi
leaq (%rsi,%rdx,4), %rdx
cmpl %ecx, 0x8(%rdx)
jl 0x8c0c
movl 0x4(%rdx), %ecx
movl %ecx, 0x8(%rbx)
movl %eax, 0x190(%rbx)
jmp 0x8c0c
movb $0x1, 0x194(%rbx)
jmp 0x8c0c
movq 0x4(%r14,%rax,4), %rdi
movq (%rbx), %r15
callq 0x7177
movq %r15, %rdi
movq %rax, %rsi
jmp 0x8c95
movq (%rbx), %r15
movl 0x4(%r14,%rax,4), %ebp
movslq 0xebb2(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x8c21
leal 0x1(%rax), %ecx
movl %ecx, 0xeb9f(%rip)      # 0x173a0
leaq 0xe998(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0x8c2e
movsd 0x4(%r14,%rax,4), %xmm0
movq (%rbx), %r15
movslq 0xeb7e(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x8c44
leal 0x1(%rax), %ecx
movl %ecx, 0xeb6b(%rip)      # 0x173a0
leaq 0xe964(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0x8c5d
movslq 0x4(%r14,%rax,4), %rcx
testq %rcx, %rcx
js 0x8de9
movl 0x8(%r14,%rax,4), %ebp
movq (%rbx), %rax
movl 0x8(%rax), %r15d
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
leaq 0xe490(%rip), %rax      # 0x16d00
callq *(%rax,%rcx,8)
movq (%rbx), %rax
subl %ebp, %r15d
incl %r15d
cmpl %r15d, 0x8(%rax)
je 0x8c9a
jmp 0x8e08
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x8f05
movq 0x4(%r14,%rax,4), %r12
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7e30
movq (%rbx), %r15
movslq 0xead8(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x8c78
leal 0x1(%rax), %ecx
movl %ecx, 0xeac5(%rip)      # 0x173a0
leaq 0xe8be(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0x8c85
movl 0x4(%r14,%rax,4), %eax
cmpq $0x5, %rax
ja 0x8fcb
leaq 0x4c57(%rip), %rcx      # 0xd558
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x0, 0x190(%rbx)
jle 0x8fbf
movq (%rbx), %r15
movslq 0x190(%rbx), %rax
leaq (%rax,%rax,4), %rax
movq 0x8(%rsp), %rcx
movl -0x4(%rcx,%rax,4), %ebp
jmp 0x87e7
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %rdi
callq 0x4fd1
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7e30
movslq 0x8(%rbx), %rax
testb %bpl, %bpl
je 0x8c6a
incl %eax
jmp 0x8c73
movl 0x4(%r14,%rax,4), %eax
jmp 0x8a82
movq (%rbx), %rdi
cmpl $0x0, 0x8(%rdi)
jle 0x8ee6
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7f19
movq %rax, %r15
movq %rax, %rdi
callq 0x5109
movq %r15, %rdi
callq 0x7d46
jmp 0x8c0c
movl 0x190(%rbx), %eax
addl $-0xf, %eax
cmpl $-0x11, %eax
jbe 0x8eda
movslq 0x8(%rbx), %rax
movl 0x4(%r14,%rax,4), %ecx
movslq 0x190(%rbx), %rdx
leaq (%rdx,%rdx,4), %r15
incl %edx
movl %edx, 0x190(%rbx)
addl $0x2, %eax
movq 0x8(%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 0x7f19
movq %rax, %rdi
callq 0x51df
movl %eax, %ebp
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7e30
movl %ebp, 0xc(%r12,%r15,4)
jmp 0x8c3f
movslq 0x4(%r14,%rax,4), %rcx
testq %rcx, %rcx
js 0x8e27
movl 0x8(%r14,%rax,4), %ebp
movq (%rbx), %rax
movl 0x8(%rax), %r15d
movq 0x18(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
leaq 0xe0e2(%rip), %rax      # 0x16b30
callq *(%rax,%rcx,8)
movq (%rbx), %rax
subl %ebp, %r15d
cmpl %r15d, 0x8(%rax)
je 0x8c9a
jmp 0x8e46
movl 0x4(%r14,%rax,4), %ecx
addl %ecx, %eax
decl %eax
jmp 0x8a84
movq 0x4(%r14,%rax,4), %rax
testq %rax, %rax
je 0x8e65
movl 0x8(%rax), %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x8c0c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7ba0
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x77ea
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7c0d
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7a77
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x76ce
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7735
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x798b
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7667
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x789f
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7ca2
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7915
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7b37
jmp 0x8b3c
movq %r12, %rdi
movq %r15, %rsi
callq 0x7a01
movq (%rbx), %rdi
movl $0x1, %esi
jmp 0x8c07
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6bf8
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6a97
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6b46
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6e69
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x694a
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6ccf
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6dca
jmp 0x8bea
movq 0x8(%r12), %rdi
movl 0x10(%r12), %edx
movq %r15, %rsi
callq 0x6f08
movl %r14d, %r13d
testq %r15, %r15
movq 0x20(%rsp), %r14
je 0x8bff
movq %r15, %rdi
callq 0x507f
movq (%rbx), %rdi
movl $0x2, %esi
callq 0x7e30
incl 0x8(%rbx)
cmpb $0x1, 0x194(%rbx)
jne 0x8550
jmp 0x8520
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x1, (%rsi)
movl %ebp, 0x8(%rsi)
movq %r15, %rdi
callq 0x7ec0
incl 0x8(%rbx)
jmp 0x8c0c
movl $0x18, %edi
movsd %xmm0, 0x10(%rsp)
callq 0x21d0
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
jmp 0x8c92
movl 0x4(%r14,%rax,4), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0x8(%rbx)
jmp 0x8c0c
movl $0x18, %edi
callq 0x21d0
movq %rax, %rsi
movl $0x4, (%rsi)
movq %r12, 0x8(%rsi)
movl %ebp, 0x10(%rsi)
movq %r15, %rdi
callq 0x7ec0
addl $0x2, 0x8(%rbx)
jmp 0x8c0c
movq %r15, %rdi
callq 0x73f0
movsd %xmm0, 0x1a0(%rbx)
jmp 0x8cd0
movq 0x1a8(%rbx), %rdi
callq 0x21a0
movq %r15, %rdi
callq 0x7476
movq %rax, 0x1a8(%rbx)
movq (%rbx), %rdi
movl $0x1, %esi
callq 0x7e30
movslq 0x4c(%rbx), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0x4c(%rbx)
movl 0x8(%rbx,%rax,4), %eax
jmp 0x8a84
movq (%rbx), %r15
movl 0x1b0(%rbx), %ebp
jmp 0x87e7
movq (%rbx), %r15
movsd 0x1a0(%rbx), %xmm0
movslq 0xe690(%rip), %rax      # 0x173a0
cmpq $0x3f, %rax
jg 0x8d62
leal 0x1(%rax), %ecx
movl %ecx, 0xe681(%rip)      # 0x173a0
leaq 0xe47a(%rip), %rcx      # 0x171a0
movq (%rcx,%rax,8), %rsi
jmp 0x8d7b
movq (%rbx), %r15
movq 0x1a8(%rbx), %rdi
callq 0x7177
movq %r15, %rdi
movq %rax, %rsi
jmp 0x8c3a
movq (%rbx), %r15
movl 0x198(%rbx), %ebp
jmp 0x87e7
movq (%rbx), %r15
movl 0x190(%rbx), %ebp
jmp 0x87e7
movl $0x18, %edi
movsd %xmm0, 0x10(%rsp)
callq 0x21d0
movsd 0x10(%rsp), %xmm0
movq %rax, %rsi
movl $0x2, (%rsi)
movsd %xmm0, 0x8(%rsi)
jmp 0x8c37
leaq 0x7bcf(%rip), %rdi      # 0x10961
leaq 0x4b40(%rip), %rsi      # 0xd8d9
leaq 0x7b2e(%rip), %rcx      # 0x108ce
movl $0x14c6, %edx           # imm = 0x14C6
callq 0x20f0
leaq 0x7bb0(%rip), %rdi      # 0x10961
leaq 0x4b21(%rip), %rsi      # 0xd8d9
leaq 0x7b0f(%rip), %rcx      # 0x108ce
movl $0x1496, %edx           # imm = 0x1496
callq 0x20f0
leaq 0x7ba6(%rip), %rdi      # 0x10976
xorl %eax, %eax
callq 0x34a8
leaq 0x7c18(%rip), %rdi      # 0x109f6
jmp 0x8dd0
leaq 0x7d02(%rip), %rdi      # 0x10ae9
jmp 0x8dd0
leaq 0x7cc8(%rip), %rdi      # 0x10ab8
leaq 0x4ae2(%rip), %rsi      # 0xd8d9
leaq 0x7ad0(%rip), %rcx      # 0x108ce
movl $0x156e, %edx           # imm = 0x156E
callq 0x20f0
leaq 0x7cb7(%rip), %rdi      # 0x10ac6
leaq 0x4ac3(%rip), %rsi      # 0xd8d9
leaq 0x7ab1(%rip), %rcx      # 0x108ce
movl $0x1576, %edx           # imm = 0x1576
callq 0x20f0
leaq 0x7c5d(%rip), %rdi      # 0x10a8b
leaq 0x4aa4(%rip), %rsi      # 0xd8d9
leaq 0x7a92(%rip), %rcx      # 0x108ce
movl $0x155e, %edx           # imm = 0x155E
callq 0x20f0
leaq 0x7c4b(%rip), %rdi      # 0x10a98
leaq 0x4a85(%rip), %rsi      # 0xd8d9
leaq 0x7a73(%rip), %rcx      # 0x108ce
movl $0x1566, %edx           # imm = 0x1566
callq 0x20f0
leaq 0x7c0e(%rip), %rdi      # 0x10a7a
leaq 0x4a66(%rip), %rsi      # 0xd8d9
leaq 0x7a54(%rip), %rcx      # 0x108ce
movl $0x1556, %edx           # imm = 0x1556
callq 0x20f0
leaq 0x7bef(%rip), %rdi      # 0x10a7a
leaq 0x4a47(%rip), %rsi      # 0xd8d9
leaq 0x7a35(%rip), %rcx      # 0x108ce
movl $0x1549, %edx           # imm = 0x1549
callq 0x20f0
leaq 0x7bac(%rip), %rdi      # 0x10a56
jmp 0x8dd0
leaq 0x7b74(%rip), %rdi      # 0x10a2a
jmp 0x8dd0
leaq 0x7b19(%rip), %rdi      # 0x109db
leaq 0x4a10(%rip), %rsi      # 0xd8d9
leaq 0x79fe(%rip), %rcx      # 0x108ce
movl $0x1517, %edx           # imm = 0x1517
callq 0x20f0
leaq 0x7ad5(%rip), %rdi      # 0x109b6
jmp 0x8dd0
leaq 0x79cc(%rip), %rdi      # 0x108b9
leaq 0x49e5(%rip), %rsi      # 0xd8d9
leaq 0x79d3(%rip), %rcx      # 0x108ce
movl $0x14e3, %edx           # imm = 0x14E3
callq 0x20f0
leaq 0x79ad(%rip), %rdi      # 0x108b9
leaq 0x49c6(%rip), %rsi      # 0xd8d9
leaq 0x79b4(%rip), %rcx      # 0x108ce
movl $0x145e, %edx           # imm = 0x145E
callq 0x20f0
leaq 0x58cc(%rip), %rdi      # 0xe7f7
leaq 0x49a7(%rip), %rsi      # 0xd8d9
leaq 0x7995(%rip), %rcx      # 0x108ce
movl $0x14ac, %edx           # imm = 0x14AC
callq 0x20f0
leaq 0x58ad(%rip), %rdi      # 0xe7f7
leaq 0x4988(%rip), %rsi      # 0xd8d9
leaq 0x7976(%rip), %rcx      # 0x108ce
movl $0x14db, %edx           # imm = 0x14DB
callq 0x20f0
leaq 0x588e(%rip), %rdi      # 0xe7f7
leaq 0x4969(%rip), %rsi      # 0xd8d9
leaq 0x7957(%rip), %rcx      # 0x108ce
movl $0x15a6, %edx           # imm = 0x15A6
callq 0x20f0
leaq 0x7b95(%rip), %rdi      # 0x10b1d
leaq 0x494a(%rip), %rsi      # 0xd8d9
leaq 0x7938(%rip), %rcx      # 0x108ce
movl $0x1590, %edx           # imm = 0x1590
callq 0x20f0
leaq 0x5850(%rip), %rdi      # 0xe7f7
leaq 0x492b(%rip), %rsi      # 0xd8d9
leaq 0x7919(%rip), %rcx      # 0x108ce
movl $0x1597, %edx           # imm = 0x1597
callq 0x20f0
leaq 0x7953(%rip), %rdi      # 0x10919
jmp 0x8dd0
leaq 0x5825(%rip), %rdi      # 0xe7f7
leaq 0x4900(%rip), %rsi      # 0xd8d9
leaq 0x78ee(%rip), %rcx      # 0x108ce
movl $0x1484, %edx           # imm = 0x1484
callq 0x20f0