LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::InitAsDefaultInstance()
void SaveState::InitAsDefaultInstance() {
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->dma_ = const_cast< ::Rnes::DmaState*>(
      ::Rnes::DmaState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->cpu_ = const_cast< ::Rnes::CpuState*>(
      ::Rnes::CpuState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->apu_ = const_cast< ::Rnes::ApuState*>(
      ::Rnes::ApuState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->ppu_ = const_cast< ::Rnes::PpuState*>(
      ::Rnes::PpuState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->controller_ = const_cast< ::Rnes::ControllerState*>(
      ::Rnes::ControllerState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->cpumem_ = const_cast< ::Rnes::CpuMemoryState*>(
      ::Rnes::CpuMemoryState::internal_default_instance());
  ::Rnes::_SaveState_default_instance_._instance.get_mutable()->vidmem_ = const_cast< ::Rnes::VideoMemoryState*>(
      ::Rnes::VideoMemoryState::internal_default_instance());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x63720
movq %rax, -0x38(%rbp)
leaq 0x37a48(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
callq 0x5ef90
movq %rax, -0x30(%rbp)
leaq 0x37a2b(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x30(%rbp), %rcx
movq %rcx, 0x28(%rax)
callq 0x60520
movq %rax, -0x28(%rbp)
leaq 0x37a0e(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x28(%rbp), %rcx
movq %rcx, 0x30(%rax)
callq 0x61010
movq %rax, -0x20(%rbp)
leaq 0x379f1(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
callq 0x62a80
movq %rax, -0x18(%rbp)
leaq 0x379d4(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x18(%rbp), %rcx
movq %rcx, 0x40(%rax)
callq 0x62db0
movq %rax, -0x10(%rbp)
leaq 0x379b7(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x10(%rbp), %rcx
movq %rcx, 0x48(%rax)
callq 0x632a0
movq %rax, -0x8(%rbp)
leaq 0x3799a(%rip), %rdi     # 0x92da0
callq 0x638a0
movq -0x8(%rbp), %rcx
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::MergeFrom(google::protobuf::Message const&)
void SaveState::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:Rnes.SaveState)
  GOOGLE_DCHECK_NE(&from, this);
  const SaveState* source =
      ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated<SaveState>(
          &from);
  if (source == nullptr) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:Rnes.SaveState)
    ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:Rnes.SaveState)
    MergeFrom(*source);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x49(%rbp)
cmpq %rcx, %rax
je 0x5d45a
jmp 0x5d4a3
leaq 0xdcd0(%rip), %rdx      # 0x6b131
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x3, %esi
movl $0x1a99, %ecx           # imm = 0x1A99
callq 0xe690
movq -0x80(%rbp), %rdi
movb $0x1, -0x49(%rbp)
leaq 0xdcb9(%rip), %rsi      # 0x6b140
callq 0xed00
movq %rax, -0x78(%rbp)
jmp 0x5d492
movq -0x78(%rbp), %rsi
leaq -0x5d(%rbp), %rdi
callq 0xe820
jmp 0x5d4a1
jmp 0x5d4a3
testb $0x1, -0x49(%rbp)
jne 0x5d4ab
jmp 0x5d4b4
leaq -0x48(%rbp), %rdi
callq 0xe9d0
movq -0x10(%rbp), %rdi
callq 0x64e50
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x5d4f6
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xe7a0
jmp 0x5d503
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x49(%rbp)
jne 0x5d4eb
jmp 0x5d4f4
leaq -0x48(%rbp), %rdi
callq 0xe9d0
jmp 0x5d50c
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x5d520
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xe700
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::CopyFrom(google::protobuf::Message const&)
void SaveState::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:Rnes.SaveState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x5d900
jmp 0x5d916
movq -0x18(%rbp), %rdi
callq 0x5bc40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::CopyFrom(Rnes::SaveState const&)
void SaveState::CopyFrom(const SaveState& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:Rnes.SaveState)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq %rax, -0x10(%rbp)
jne 0x5d940
jmp 0x5d956
movq -0x18(%rbp), %rdi
callq 0x5bc40
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d520
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::InternalSwap(Rnes::SaveState*)
void SaveState::InternalSwap(SaveState* other) {
  using std::swap;
  _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  savedate_.Swap(&other->savedate_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SaveState, gametime_)
      + sizeof(SaveState::gametime_)
      - PROTOBUF_FIELD_OFFSET(SaveState, dma_)>(
          reinterpret_cast<char*>(&dma_),
          reinterpret_cast<char*>(&other->dma_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rsi, -0xb0(%rbp)
movq -0xa8(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
addq $0x8, %rcx
movq -0xb0(%rbp), %rax
addq $0x8, %rax
movq %rcx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
je 0x5d9f5
movq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
jne 0x5da61
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpl $0x1, %eax
sete %al
testb $0x1, %al
jne 0x5da2b
jmp 0x5da41
movq -0xc8(%rbp), %rdi
callq 0x66310
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x5da51
movq -0xc8(%rbp), %rdi
callq 0x66330
movq %rax, -0x68(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x66c30
movq -0xc0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movq -0x88(%rbp), %rdi
movslq -0x8c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movq -0xb0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x98(%rbp), %rsi
movslq -0x9c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x5f3c0
movq -0xc0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xe8(%rbp)
movq -0xb0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xe0(%rbp)
callq 0x442b0
movq -0xc0(%rbp), %rdi
movq %rax, -0xd8(%rbp)
callq 0x284d0
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
movq -0xd8(%rbp), %rcx
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq -0x30(%rbp), %rsi
callq 0x66070
testb $0x1, %al
jne 0x5db43
jmp 0x5db58
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x66070
testb $0x1, %al
jne 0x5db56
jmp 0x5db58
jmp 0x5db92
movq -0xd0(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x65ff0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x65ff0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xec90
movq -0xc0(%rbp), %rdi
addq $0x20, %rdi
movq -0xb0(%rbp), %rsi
addq $0x20, %rsi
callq 0x64f70
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::ApuState::SharedCtor()
void ApuState::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ApuState_save_2eproto.base);
  ::memset(&pulsea_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&nextsamplecountdown_) -
      reinterpret_cast<char*>(&pulsea_)) + sizeof(nextsamplecountdown_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x3284d(%rip), %rdi     # 0x926e8
callq 0x5ef00
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq %rax, %rdx
addq $0x6c, %rdx
addq $0x28, %rax
subq %rax, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0xe420
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::ApuState::SharedDtor()
void ApuState::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete pulsea_;
  if (this != internal_default_instance()) delete pulseb_;
  if (this != internal_default_instance()) delete triangle_;
  if (this != internal_default_instance()) delete noise_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x284d0
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
jne 0x60388
jmp 0x603d1
leaq 0xada2(%rip), %rdx      # 0x6b131
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %esi
movl $0x9c4, %ecx            # imm = 0x9C4
callq 0xe690
movq -0x70(%rbp), %rdi
movb $0x1, -0x41(%rbp)
leaq 0xafa5(%rip), %rsi      # 0x6b35a
callq 0xed00
movq %rax, -0x68(%rbp)
jmp 0x603c0
movq -0x68(%rbp), %rsi
leaq -0x55(%rbp), %rdi
callq 0xe820
jmp 0x603cf
jmp 0x603d1
testb $0x1, -0x41(%rbp)
jne 0x603d9
jmp 0x603e2
leaq -0x40(%rbp), %rdi
callq 0xe9d0
callq 0x60520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x60440
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x6041c
movq -0x78(%rbp), %rdi
callq 0x47770
movq -0x78(%rbp), %rdi
movl $0x38, %esi
callq 0xe170
jmp 0x60440
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x60432
jmp 0x6043b
leaq -0x40(%rbp), %rdi
callq 0xe9d0
jmp 0x6050f
callq 0x60520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x6047c
movq -0x60(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x6047a
movq -0x80(%rbp), %rdi
callq 0x47770
movq -0x80(%rbp), %rdi
movl $0x38, %esi
callq 0xe170
jmp 0x6047c
callq 0x60520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x604c1
movq -0x60(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x604bf
movq -0x88(%rbp), %rdi
callq 0x493e0
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0xe170
jmp 0x604c1
callq 0x60520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x60506
movq -0x60(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x60504
movq -0x90(%rbp), %rdi
callq 0x4a960
movq -0x90(%rbp), %rdi
movl $0x38, %esi
callq 0xe170
jmp 0x60506
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xe700
nopl (%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::PpuState::SharedCtor()
void PpuState::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PpuState_save_2eproto.base);
  ::memset(&cycle_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&yscrollorigin_) -
      reinterpret_cast<char*>(&cycle_)) + sizeof(yscrollorigin_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x3197d(%rip), %rdi     # 0x92808
callq 0x5ef00
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movq %rax, %rdx
addq $0x70, %rdx
addq $0x40, %rax
subq %rax, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0xe420
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::MmcState_Mmc3State::SharedCtor()
void MmcState_Mmc3State::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MmcState_Mmc3State_save_2eproto.base);
  bankregister_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&bankselectreg_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&irqpending_) -
      reinterpret_cast<char*>(&bankselectreg_)) + sizeof(irqpending_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x30d45(%rip), %rdi     # 0x927c0
callq 0x5ef00
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
callq 0x442b0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x61ae0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq %rax, %rdx
addq $0x35, %rdx
addq $0x20, %rax
subq %rax, %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::MmcState::SharedCtor()
void MmcState::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_MmcState_save_2eproto.base);
  ::memset(&mmcnone_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&mmc3_) -
      reinterpret_cast<char*>(&mmcnone_)) + sizeof(mmc3_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x3077d(%rip), %rdi     # 0x92778
callq 0x5ef00
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movq %rax, %rdx
addq $0x28, %rdx
addq $0x18, %rax
subq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0xe420
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::MmcState::SharedDtor()
void MmcState::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  if (this != internal_default_instance()) delete mmcnone_;
  if (this != internal_default_instance()) delete mmc1_;
  if (this != internal_default_instance()) delete mmc3_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x284d0
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
jne 0x623c8
jmp 0x62411
leaq 0x8d62(%rip), %rdx      # 0x6b131
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %esi
movl $0x1361, %ecx           # imm = 0x1361
callq 0xe690
movq -0x70(%rbp), %rdi
movb $0x1, -0x41(%rbp)
leaq 0x8f65(%rip), %rsi      # 0x6b35a
callq 0xed00
movq %rax, -0x68(%rbp)
jmp 0x62400
movq -0x68(%rbp), %rsi
leaq -0x55(%rbp), %rdi
callq 0xe820
jmp 0x6240f
jmp 0x62411
testb $0x1, -0x41(%rbp)
jne 0x62419
jmp 0x62422
leaq -0x40(%rbp), %rdi
callq 0xe9d0
callq 0x62520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x62480
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, %rax
je 0x6245c
movq -0x78(%rbp), %rdi
callq 0x52340
movq -0x78(%rbp), %rdi
movl $0x18, %esi
callq 0xe170
jmp 0x62480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x62472
jmp 0x6247b
leaq -0x40(%rbp), %rdi
callq 0xe9d0
jmp 0x6250a
callq 0x62520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x624bc
movq -0x60(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x624ba
movq -0x80(%rbp), %rdi
callq 0x52d60
movq -0x80(%rbp), %rdi
movl $0x30, %esi
callq 0xe170
jmp 0x624bc
callq 0x62520
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x62501
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x624ff
movq -0x88(%rbp), %rdi
callq 0x541f0
movq -0x88(%rbp), %rdi
movl $0x38, %esi
callq 0xe170
jmp 0x62501
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xe700
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mindbeast[P]rnes/bin/save.pb.h
// Function: Rnes::MmcState::_internal_mutable_mmcnone()
inline ::Rnes::MmcState_MmcNoneState* MmcState::_internal_mutable_mmcnone() {
  _has_bits_[0] |= 0x00000001u;
  if (mmcnone_ == nullptr) {
    auto* p = CreateMaybeMessage<::Rnes::MmcState_MmcNoneState>(GetArena());
    mmcnone_ = p;
  }
  return mmcnone_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
orl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
cmpq $0x0, 0x18(%rax)
jne 0x62662
movq -0x28(%rbp), %rdi
callq 0x284d0
movq %rax, %rdi
callq 0x66090
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::VideoMemoryState::SharedCtor()
void VideoMemoryState::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_VideoMemoryState_save_2eproto.base);
  patterntablememory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  nametablememory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  palettememory_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2f865(%rip), %rdi     # 0x928c0
callq 0x5ef00
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
callq 0x442b0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x61ae0
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
callq 0x442b0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x61ae0
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x10(%rbp)
callq 0x442b0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x61ae0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::VideoMemoryState::SharedDtor()
void VideoMemoryState::SharedDtor() {
  GOOGLE_DCHECK(GetArena() == nullptr);
  patterntablememory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  nametablememory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  palettememory_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x284d0
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
jne 0x631b8
jmp 0x63201
leaq 0x7f72(%rip), %rdx      # 0x6b131
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3, %esi
movl $0x169e, %ecx           # imm = 0x169E
callq 0xe690
movq -0x70(%rbp), %rdi
movb $0x1, -0x41(%rbp)
leaq 0x8175(%rip), %rsi      # 0x6b35a
callq 0xed00
movq %rax, -0x68(%rbp)
jmp 0x631f0
movq -0x68(%rbp), %rsi
leaq -0x55(%rbp), %rdi
callq 0xe820
jmp 0x631ff
jmp 0x63201
testb $0x1, -0x41(%rbp)
jne 0x63209
jmp 0x63212
leaq -0x40(%rbp), %rdi
callq 0xe9d0
movq -0x60(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x88(%rbp)
callq 0x442b0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x65f90
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x80(%rbp)
callq 0x442b0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x65f90
movq -0x60(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x78(%rbp)
callq 0x442b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x65f90
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x6328c
jmp 0x63295
leaq -0x40(%rbp), %rdi
callq 0xe9d0
jmp 0x63297
movq -0x50(%rbp), %rdi
callq 0xe700
// File: mindbeast[P]rnes/bin/save.pb.cc
// Function: Rnes::SaveState::SharedCtor()
void SaveState::SharedCtor() {
  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SaveState_save_2eproto.base);
  savedate_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  ::memset(&dma_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&gametime_) -
      reinterpret_cast<char*>(&dma_)) + sizeof(gametime_));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x2ef8d(%rip), %rdi     # 0x92858
callq 0x5ef00
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
callq 0x442b0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x61ae0
movq -0x10(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq %rax, %rdx
addq $0x58, %rdx
addq $0x20, %rax
subq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0xe420
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH09_SequentialContainers/examples/stack.cc
// Function: main
int main()
{
    stack<int> intStack;  // empty stack

    // fill up the stack
    for (size_t ix = 0; ix != 10; ++ix)
        intStack.push(ix);   // intStack holds 0 . . . 9 inclusive

    // while there are still values in intStack
    while (!intStack.empty()) {
        int value = intStack.top();
        // code that uses value
        cout << value << endl;
        intStack.pop(); // pop the top element, and repeat
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1380
movq $0x0, -0x60(%rbp)
cmpq $0xa, -0x60(%rbp)
je 0x12d9
movl -0x60(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x13b0
jmp 0x12af
jmp 0x12b1
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x1293
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1440
jmp 0x1368
jmp 0x12db
leaq -0x58(%rbp), %rdi
callq 0x13e0
movb %al, -0x79(%rbp)
jmp 0x12e9
movb -0x79(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12f4
jmp 0x134c
leaq -0x58(%rbp), %rdi
callq 0x1400
movq %rax, -0x88(%rbp)
jmp 0x1306
movq -0x88(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl -0x78(%rbp), %esi
movq 0x4cbc(%rip), %rdi      # 0x5fd8
callq 0x1110
movq %rax, -0x90(%rbp)
jmp 0x132a
movq -0x90(%rbp), %rdi
movq 0x4c90(%rip), %rsi      # 0x5fc8
callq 0x10c0
jmp 0x133f
leaq -0x58(%rbp), %rdi
callq 0x1420
jmp 0x134a
jmp 0x12db
movl $0x0, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1440
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1120
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: zengfenfei[P]codility/src/PermCheck.cpp
// Function: solution(std::vector<int, std::allocator<int>>&)
int solution(vector<int> &A) {
	unsigned int n = A.size();
	vector<bool> occurs(n, false);	// occurrence of 1 ~ n
	for (unsigned int i = 0; i < n; i++) {
		if (A[i] < 1 || A[i] > n) {
			return 0;
		}
		if (occurs[A[i] - 1]) {
			return 0;
		} else {
			occurs[A[i] - 1] = true;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1530
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x90(%rbp)
movb $0x0, -0x41(%rbp)
leaq -0x42(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1550
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x41(%rbp), %rdx
callq 0x1570
jmp 0x12a6
leaq -0x42(%rbp), %rdi
callq 0x15f0
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x13f9
movq -0x10(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, %esi
callq 0x1610
cmpl $0x1, (%rax)
jl 0x12ea
movq -0x10(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, %esi
callq 0x1610
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0x1317
movl $0x0, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x1407
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x42(%rbp), %rdi
callq 0x15f0
jmp 0x141c
movq -0x10(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, %esi
callq 0x1610
movl (%rax), %eax
decl %eax
movslq %eax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1630
movq %rdx, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x1345
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1690
testb $0x1, %al
jne 0x136a
jmp 0x1397
movl $0x0, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
jmp 0x1407
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1710
jmp 0x141c
movq -0x10(%rbp), %rdi
movl -0x58(%rbp), %eax
movl %eax, %esi
callq 0x1610
movl (%rax), %eax
decl %eax
movslq %eax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1630
movq %rdx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
jmp 0x13c5
movq -0xb0(%rbp), %rax
movq -0xa8(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x80(%rbp), %rdi
movl $0x1, %esi
callq 0x16c0
jmp 0x13eb
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x12b6
movl $0x1, -0x4(%rbp)
movl $0x1, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1710
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: zengfenfei[P]codility/src/PermCheck.cpp
// Function: main
int main() {
	vector<int> A(4);
	A[0] = 4;
	A[1] = 1;
	A[2] = 3;
	A[3] = 2;
	cout << solution(A) << '\n';	// 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1730
movq -0x38(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x1750
jmp 0x1459
leaq -0x19(%rbp), %rdi
callq 0x17c0
xorl %eax, %eax
movl %eax, %esi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1610
movq -0x48(%rbp), %rdi
movl $0x4, (%rax)
movl $0x1, %esi
callq 0x1610
movq -0x48(%rbp), %rdi
movl $0x1, (%rax)
movl $0x2, %esi
callq 0x1610
movq -0x48(%rbp), %rdi
movl $0x3, (%rax)
movl $0x3, %esi
callq 0x1610
movq -0x48(%rbp), %rdi
movl $0x2, (%rax)
callq 0x1250
movl %eax, -0x3c(%rbp)
jmp 0x14c3
movl -0x3c(%rbp), %esi
movq 0x4b0b(%rip), %rdi      # 0x5fd8
callq 0x10f0
movq %rax, -0x50(%rbp)
jmp 0x14d8
movq -0x50(%rbp), %rdi
movl $0xa, %esi
callq 0x10d0
jmp 0x14e8
leaq -0x18(%rbp), %rdi
callq 0x17e0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x17c0
jmp 0x1525
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x17e0
movq -0x28(%rbp), %rdi
callq 0x1100
nop
// File: ingowald[P]closestSurfacePointQueries/src/distanceQueries.cpp
// Function: rtdqNewTriangleMeshfi
distance_query_scene rtdqNewTriangleMeshfi(const float   *vertex_x,
                                             const float   *vertex_y,
                                             const float   *vertex_z,
                                             const size_t   vertex_stride,
                                             const int32_t *index_x,
                                             const int32_t *index_y,
                                             const int32_t *index_z,
                                             const size_t   index_stride,
                                             const size_t    numTriangles)
  {
    if (index_stride == 1 && vertex_stride == 1)
      return (distance_query_scene)
        new GeneralTriangleMesh<float,int,0>(vertex_x,vertex_y,vertex_z,vertex_stride,
                                             index_x,index_y,index_z,index_stride,
                                             numTriangles);
    else
      return (distance_query_scene)
        new GeneralTriangleMesh<float,int,1>(vertex_x,vertex_y,vertex_z,vertex_stride,
                                             index_x,index_y,index_z,index_stride,
                                             numTriangles);

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
cmpq $0x1, 0x18(%rbp)
jne 0x8231
cmpq $0x1, -0x38(%rbp)
jne 0x8231
movl $0x90, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r10
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r14
movq %rsp, %rax
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x8d20
jmp 0x8205
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x82a8
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x90, %esi
callq 0x3290
jmp 0x82b8
movl $0x90, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r10
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r14
movq %rsp, %rax
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x8df0
jmp 0x8282
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x82a8
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x90, %esi
callq 0x3290
jmp 0x82b8
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: ingowald[P]closestSurfacePointQueries/src/distanceQueries.cpp
// Function: rtdqNewTriangleMeshdi
distance_query_scene rtdqNewTriangleMeshdi(const double   *vertex_x,
                                             const double   *vertex_y,
                                             const double   *vertex_z,
                                             const size_t   vertex_stride,
                                             const int32_t *index_x,
                                             const int32_t *index_y,
                                             const int32_t *index_z,
                                             const size_t   index_stride,
                                             const size_t    numTriangles)
  {
    if (index_stride == 1 && vertex_stride == 1)
      return (distance_query_scene)
        new GeneralTriangleMesh<double,int,0>(vertex_x,vertex_y,vertex_z,vertex_stride,
                                              index_x,index_y,index_z,index_stride,
                                              numTriangles);
    else
      return (distance_query_scene)
        new GeneralTriangleMesh<double,int,1>(vertex_x,vertex_y,vertex_z,vertex_stride,
                                              index_x,index_y,index_z,index_stride,
                                              numTriangles);

  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %r9, -0x48(%rbp)
cmpq $0x1, 0x18(%rbp)
jne 0x8391
cmpq $0x1, -0x38(%rbp)
jne 0x8391
movl $0x90, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r10
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r14
movq %rsp, %rax
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x8ec0
jmp 0x8365
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8408
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x90, %esi
callq 0x3290
jmp 0x8418
movl $0x90, %edi
callq 0x3280
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq -0x48(%rbp), %r10
movq 0x10(%rbp), %r11
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r14
movq %rsp, %rax
movq %r14, 0x18(%rax)
movq %rbx, 0x10(%rax)
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x8f90
jmp 0x83e2
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x8408
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
movl $0x90, %esi
callq 0x3290
jmp 0x8418
movq -0x18(%rbp), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
// File: ingowald[P]closestSurfacePointQueries/src/distanceQueries.cpp
// Function: bvhlib::projectToPlane(float&, ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&)
inline vec3fa projectToPlane(float &dist, const vec3fa &P, const vec3fa &N, const vec3fa &A)
  {
    const float den = dot(N,N);
    if (den == 0.f) {
      const vec3fa PP = A;
      dist = length(PP-P);
      return PP;
    } else {
      const vec3fa PP = P - float((dot(P-A,N)/(double)den)) * N;
      dist = length(PP-P);
      return PP;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa7f0
movss %xmm0, -0x2c(%rbp)
movss -0x2c(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xa63f
jp 0xa63f
movq -0xc8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa850
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9610
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x95e0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
jmp 0xa73c
movq -0x18(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq -0x28(%rbp), %rsi
callq 0x9610
movss %xmm1, -0x80(%rbp)
movlpd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0xa540
cvtss2sd %xmm0, %xmm0
movss -0x2c(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xa890
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x9610
movq -0xc8(%rbp), %rdi
movss %xmm1, -0x90(%rbp)
movlpd %xmm0, -0x98(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x95a0
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9610
movss %xmm1, -0xb0(%rbp)
movlpd %xmm0, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xa4(%rbp)
movl -0xb0(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0xa4(%rbp), %rdi
callq 0x95e0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0xc0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: ingowald[P]closestSurfacePointQueries/src/distanceQueries.cpp
// Function: bvhlib::checkEdge(ospcommon::vec_t<float, 3, 1>&, float&, ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&)
inline void checkEdge(vec3fa &closestPoint, float &closestDist,
                        const vec3fa &queryPoint,
                        const vec3fa &v0, const vec3fa &e0)
  {
    const vec3fa PP = projectToEdge(queryPoint,v0,e0);
    const float dist = length(PP-queryPoint);
    if (dist < closestDist) {
      closestDist = dist;
      closestPoint = PP;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xa8f0
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9610
movss %xmm1, -0x50(%rbp)
movlpd %xmm0, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x95e0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm1
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0xa7ea
movss -0x3c(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
// File: ingowald[P]closestSurfacePointQueries/src/distanceQueries.cpp
// Function: bvhlib::projectToEdge(ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&, ospcommon::vec_t<float, 3, 1> const&)
inline vec3fa projectToEdge(const vec3fa &P, const vec3fa &v0, const vec3fa &e0)
  {
    const float den = dot(e0,e0);
    if (den == 0.f) return v0;

#if 0
    float f = dot(P-v0,e0) / den;
#else
    float f = dot(P-v0,e0) / (double)den;
#endif
    f = std::max(0.f,std::min(1.f,f));
    return v0+f*e0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xa7f0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xa952
jp 0xa952
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa850
jmp 0xaa2d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9610
movss %xmm1, -0x40(%rbp)
movlpd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xa540
cvtss2sd %xmm0, %xmm0
movss -0x24(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x28(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x3f800000, -0x50(%rbp) # imm = 0x3F800000
leaq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9200
movq %rax, %rsi
leaq -0x4c(%rbp), %rdi
callq 0xaa40
movss (%rax), %xmm0
movss %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movss -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rsi
leaq -0x6c(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xa890
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0xaa80
movq -0x90(%rbp), %rdi
movss %xmm1, -0x78(%rbp)
movlpd %xmm0, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x5c(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x5c(%rbp), %rsi
callq 0x95a0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: ingowald[P]closestSurfacePointQueries/src/bvh.cpp
// Function: bvhlib::widestDimension(ospcommon::box_t<float, 3, 1> const&)
inline size_t widestDimension(const box3fa &box) 
  {
    const vec3fa width = box.upper - box.lower;
    size_t widest = width.y > width.x;
    if (width.z > width[widest]) widest = 2;
    return widest;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
callq 0x9610
movss %xmm1, -0x30(%rbp)
movlpd %xmm0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x24(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x95a0
movss -0x14(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x40(%rbp)
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xebe0
movss -0x44(%rbp), %xmm0
ucomiss (%rax), %xmm0
jbe 0xe1ff
movq $0x2, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: agctIndex(char)
int agctIndex(char ch) { //encoding rule
    if (ch == 'A') {
        return 0;
    }
    if (ch == 'C') {
        return 1;
    } 
    if (ch == 'G') {
        return 2;
    }
    if (ch == 'T') {
        return 3;
    }
    return 4;
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
cmpl $0x41, %eax
jne 0x316b
movl $0x0, -0x4(%rsp)
jmp 0x31af
movsbl -0x5(%rsp), %eax
cmpl $0x43, %eax
jne 0x317f
movl $0x1, -0x4(%rsp)
jmp 0x31af
movsbl -0x5(%rsp), %eax
cmpl $0x47, %eax
jne 0x3193
movl $0x2, -0x4(%rsp)
jmp 0x31af
movsbl -0x5(%rsp), %eax
cmpl $0x54, %eax
jne 0x31a7
movl $0x3, -0x4(%rsp)
jmp 0x31af
movl $0x4, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: readRefFile(char*)
void readRefFile(char *refFile) { // processing reference file
	int _ref_seq_len = 0;
	char ch[1024];
	FILE *fp = fopen(refFile, "r");
	if (NULL == fp) {
		printf("fail to open file %s\n", refFile);
		return;
	}
	int temp_len, index;
	char temp_ch;
	
	// fscanf(fp, "%s", ch);//meta_data
	fgets(ch, 1024, fp);
	while (fscanf(fp, "%s", ch) != EOF) {
		temp_len = strlen(ch);
		for (int i = 0; i < temp_len; i++) {
			temp_ch = ch[i];
			if (islower(temp_ch)) {
				temp_ch = toupper(temp_ch);
			}
			index = agctIndex(temp_ch);
			if (index^4) {//only A T C T are saved
				ref_seq_code[_ref_seq_len++] = index;
			}
		}
	}
	fclose(fp);
	ref_seq_len = _ref_seq_len;
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movl $0x0, 0x42c(%rsp)
movq 0x430(%rsp), %rdi
leaq 0x4e57(%rip), %rsi      # 0x8040
callq 0x21b0
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0x3217
movq 0x430(%rsp), %rsi
leaq 0x4e51(%rip), %rdi      # 0x805c
movb $0x0, %al
callq 0x2040
jmp 0x3302
leaq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2230
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x4e64(%rip), %rsi      # 0x80a0
movb $0x0, %al
callq 0x22a0
cmpl $-0x1, %eax
je 0x32eb
leaq 0x20(%rsp), %rdi
callq 0x20d0
movl %eax, 0x14(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x32e6
movslq 0x8(%rsp), %rax
movb 0x20(%rsp,%rax), %al
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x21d0
cmpl $0x0, %eax
je 0x3296
movsbl 0xf(%rsp), %edi
callq 0x22b0
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %edi
callq 0x3150
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
xorl $0x4, %eax
cmpl $0x0, %eax
je 0x32d4
movl 0x10(%rsp), %edx
movq 0x7efd(%rip), %rax      # 0xb1b8
movl 0x42c(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x42c(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x32d6
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3262
jmp 0x322b
movq 0x18(%rsp), %rdi
callq 0x2180
movl 0x42c(%rsp), %eax
movl %eax, 0x7eca(%rip)      # 0xb1cc
addq $0x438, %rsp            # imm = 0x438
retq
nopw (%rax,%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: writeRunLengthCoding(_IO_FILE*, int, int*)
void writeRunLengthCoding(FILE *fp, int vec_len, int *vec) { // run-length coding for EOL
	vector<int> code;
	if (vec_len > 0) {
		code.push_back(vec[0]);
		int pre_value = code[0], cnt = 1;
		for (int i = 1; i < vec_len; i++) {
			if (vec[i] == pre_value) {
				cnt++;
			} else {
				code.push_back(cnt);
				code.push_back(vec[i]);
				pre_value = vec[i];
				cnt = 1;
			}
		}
		code.push_back(cnt);
	}
	int code_len = code.size();
	fprintf(fp, "%d", code_len);

	for (int i = 0; i < code_len; i++) {
		fprintf(fp, " %d", code[i]);
	}
	fprintf(fp, "\n");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x51b0
cmpl $0x0, 0x4c(%rsp)
jle 0x37d0
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x51c0
jmp 0x36f8
leaq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5230
movl (%rax), %eax
movl %eax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x37bd
movq 0x40(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x18(%rsp), %eax
jne 0x3767
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x37ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5270
jmp 0x3862
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x51c0
jmp 0x3778
movq 0x40(%rsp), %rax
movslq 0x10(%rsp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq 0x28(%rsp), %rdi
callq 0x51c0
jmp 0x3792
movq 0x40(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
jmp 0x37ad
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x371c
leaq 0x28(%rsp), %rdi
leaq 0x14(%rsp), %rsi
callq 0x51c0
jmp 0x37ce
jmp 0x37d0
leaq 0x28(%rsp), %rdi
callq 0x5250
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0x485c(%rip), %rsi      # 0x804a
movb $0x0, %al
callq 0x2200
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x3840
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movslq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x5230
movq (%rsp), %rdi
movl (%rax), %edx
leaq 0x4819(%rip), %rsi      # 0x8045
movb $0x0, %al
callq 0x2200
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x37fd
movq 0x50(%rsp), %rdi
leaq 0x496d(%rip), %rsi      # 0x81b9
movb $0x0, %al
callq 0x2200
leaq 0x28(%rsp), %rdi
callq 0x5270
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x2280
nopl (%rax)
// File: yuansliu[P]HiRGC/hirgc.cpp
// Function: preProcessRef()
void preProcessRef() { // construction of hash table
	for (int i = 0; i < max_arr_num; i++) {//initial entries
		point[i] = -1;
	}

	// memset(point, -1, sizeof(int)*max_arr_num);

	uint64_t value = 0;
	for (int k = sub_str_num - 1; k >= 0; k--) {
		value <<= 2;
		value += ref_seq_code[k];
	}
	int id = value&(uint64_t)(max_arr_num-1);
	loc[0] = point[id];
	point[id] = 0;

	int step_len = ref_seq_len - sub_str_num + 1;
	int shift_bit_num = (sub_str_num*2-2);
	int one_sub_str = sub_str_num - 1;

	for (int i = 1; i < step_len; i++) {
		value >>= 2;
		value += ((uint64_t)ref_seq_code[i + one_sub_str]<<shift_bit_num);
		
		id = value&(uint64_t)(max_arr_num-1);
		loc[i] = point[id];
		point[id] = i;
	}	
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x40000000, -0x4(%rsp) # imm = 0x40000000
jge 0x3d42
movq 0x74bf(%rip), %rax      # 0xb1e8
movslq -0x4(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x3d18
movq $0x0, -0x10(%rsp)
movl $0x13, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jl 0x3d8f
movq -0x10(%rsp), %rax
shlq $0x2, %rax
movq %rax, -0x10(%rsp)
movq 0x7449(%rip), %rax      # 0xb1b8
movslq -0x14(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3d53
movq -0x10(%rsp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movl %eax, -0x18(%rsp)
movq 0x7443(%rip), %rax      # 0xb1e8
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %ecx
movq 0x742c(%rip), %rax      # 0xb1e0
movl %ecx, (%rax)
movq 0x742b(%rip), %rax      # 0xb1e8
movslq -0x18(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x73fd(%rip), %eax      # 0xb1cc
subl $0x14, %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movl $0x26, -0x20(%rsp)
movl $0x13, -0x24(%rsp)
movl $0x1, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x3e84
movq -0x10(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x10(%rsp)
movq 0x73a4(%rip), %rax      # 0xb1b8
movl -0x28(%rsp), %ecx
addl -0x24(%rsp), %ecx
movslq %ecx, %rcx
movslq (%rax,%rcx,4), %rax
movl -0x20(%rsp), %ecx
shlq %cl, %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
andq $0x3fffffff, %rax       # imm = 0x3FFFFFFF
movl %eax, -0x18(%rsp)
movq 0x739e(%rip), %rax      # 0xb1e8
movslq -0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x7387(%rip), %rax      # 0xb1e0
movslq -0x28(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rsp), %edx
movq 0x737c(%rip), %rax      # 0xb1e8
movslq -0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x3df1
retq
nopw %cs:(%rax,%rax)