LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: m0Mh42[P]mash/./src/mash.cpp
// Function: Mashtree::mash_k_matching_nodes()
void Mashtree::mash_k_matching_nodes(){
    for (uint i = 0; i < tree_size; i++){
    for (uint n = 0; n < tree_size; n++){
        if (i == n)
            continue;
        if ((nodetree + i)->occupied && (nodetree + n)->occupied){
            if ((nodetree + i)->key == (nodetree + n)->key){
                mash.xor_random(*(nodetree + i));
                mash.xor_random(*(nodetree + n));
                mash.xor_chunks(*(nodetree + i), *(nodetree + n));
                (nodetree + i)->key += 1;
                (nodetree + n)->occupied = false;
                i = 0;
                n = 0;
            }
        }
    }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jae 0x44bc
movl $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movl 0x8(%rsp), %eax
cmpl (%rcx), %eax
jae 0x44aa
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jne 0x4381
jmp 0x449a
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x28(%rax)
je 0x4498
movq (%rsp), %rax
movq 0x20(%rax), %rax
movl 0x8(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
testb $0x1, 0x28(%rax)
je 0x4498
movq (%rsp), %rcx
movq 0x20(%rcx), %rax
movl 0xc(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movzwl (%rax), %eax
movq 0x20(%rcx), %rcx
movl 0x8(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4496
movq (%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x20(%rax), %rsi
movl 0xc(%rsp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0x3fa0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x20(%rax), %rsi
movl 0x8(%rsp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rsi
callq 0x3fa0
movq (%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x20(%rax), %rsi
movl 0xc(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rsi
movq 0x20(%rax), %rdx
movl 0x8(%rsp), %eax
imulq $0x30, %rax, %rax
addq %rax, %rdx
callq 0x4030
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movl 0xc(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movzwl (%rcx), %edx
addl $0x1, %edx
movw %dx, (%rcx)
movq 0x20(%rax), %rax
movl 0x8(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x28(%rax)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
jmp 0x4498
jmp 0x449a
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x4362
jmp 0x44ac
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x434a
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: m0Mh42[P]mash/./src/file.cpp
// Function: File::open_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void File::open_file(string filename){
    if(file.is_open()){
        file.close();
    }
    if (file.is_open() == false){
        file.open(filename, ios::binary);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x10, %rdi
callq 0x2380
testb $0x1, %al
jne 0x47ec
jmp 0x47fa
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x2080
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x2380
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x482a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movl $0x4, %edx
callq 0x2190
addq $0x28, %rsp
retq
nop
// File: m0Mh42[P]mash/./src/file.cpp
// Function: File::read_chunk[abi:cxx11]()
string File::read_chunk() {
    i = 0;
    chunk = "";
    char chr;
    if (file.is_open()){
        while (i < 32){
            if(!is_eof && file.get(chr)){
                chunk.push_back(chr);
                i++;
            } else {
                is_eof = true;
                break;
            }
        }
    }
    if (chunk.length() < 32){
        u_char chr;
        uint8_t len = 32 - chunk.length();
        for (uint8_t i = 0; i < len; i++){
            chr = '0' + len;
            chunk.push_back(chr);
        }
    }
    return chunk;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x0, 0x238(%rdi)
addq $0x218, %rdi            # imm = 0x218
leaq 0x8b2(%rip), %rsi       # 0x515f
callq 0x22e0
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
callq 0x2380
testb $0x1, %al
jne 0x48c6
jmp 0x4942
jmp 0x48c8
movq 0x18(%rsp), %rax
cmpl $0x20, 0x238(%rax)
jge 0x4940
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
jne 0x4934
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0x27(%rsp), %rsi
callq 0x22f0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x22c0
testb $0x1, %al
jne 0x4908
jmp 0x4934
movq 0x18(%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
movsbl 0x27(%rsp), %esi
callq 0x2180
movq 0x18(%rsp), %rax
movl 0x238(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x238(%rax)
jmp 0x493e
movq 0x18(%rsp), %rax
movb $0x1, (%rax)
jmp 0x4940
jmp 0x48c8
jmp 0x4942
movq 0x18(%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x2340
cmpq $0x20, %rax
jae 0x49bc
movq 0x18(%rsp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x2340
movq %rax, %rcx
movl $0x20, %eax
subq %rcx, %rax
movb %al, 0x25(%rsp)
movb $0x0, 0x24(%rsp)
movzbl 0x24(%rsp), %eax
movzbl 0x25(%rsp), %ecx
cmpl %ecx, %eax
jge 0x49ba
movq 0x18(%rsp), %rdi
movzbl 0x25(%rsp), %eax
addl $0x30, %eax
movb %al, 0x26(%rsp)
addq $0x218, %rdi            # imm = 0x218
movsbl 0x26(%rsp), %esi
callq 0x2180
movb 0x24(%rsp), %al
addb $0x1, %al
movb %al, 0x24(%rsp)
jmp 0x497e
jmp 0x49bc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x218, %rsi            # imm = 0x218
callq 0x20f0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: m0Mh42[P]mash/./src/file.cpp
// Function: File::get_file_length()
u_long File::get_file_length(){
    file.seekg(0, ios::end);
    len = file.tellg();
    file.seekg(0, ios::beg);
    return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x22d0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x23b0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4a50
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x22d0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQ<int, unsigned char>(char const*, char const*, int const&, unsigned char const&)
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            const T1& lhs,
                            const T2& rhs) {
GTEST_DISABLE_MSC_WARNINGS_PUSH_(4389 /* signed/unsigned mismatch */)
  if (lhs == rhs) {
    return AssertionSuccess();
  }
GTEST_DISABLE_MSC_WARNINGS_POP_()

  return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs, rhs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x58c63
movq -0x38(%rbp), %rdi
callq 0x6ec20
jmp 0x58c7c
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x58c90
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQFailure<int, unsigned char>(char const*, char const*, int const&, unsigned char const&)
AssertionResult CmpHelperEQFailure(const char* lhs_expression,
                                   const char* rhs_expression,
                                   const T1& lhs, const T2& rhs) {
  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x58d80
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x58db0
jmp 0x58cf7
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x71270
jmp 0x58d1b
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x58d60
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
movq -0x70(%rbp), %rdi
callq 0x52bc0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest-printers.h
// Function: void testing::internal::DefaultPrintTo<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(int, testing::internal::bool_constant<false>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&, std::ostream*)
void DefaultPrintTo(IsContainer /* dummy */,
                    false_type /* is not a pointer */,
                    const C& container, ::std::ostream* os) {
  const size_t kMaxCount = 32;  // The maximum number of elements to print.
  *os << '{';
  size_t count = 0;
  for (typename C::const_iterator it = container.begin();
       it != container.end(); ++it, ++count) {
    if (count > 0) {
      *os << ',';
      if (count == kMaxCount) {  // Enough has been printed.
        *os << " ...";
        break;
      }
    }
    *os << ' ';
    // We cannot call PrintTo(*it, os) here as PrintTo() doesn't
    // handle *it being a native array.
    internal::UniversalPrint(*it, os);
  }

  if (count > 0) {
    *os << ' ';
  }
  *os << '}';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x20, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x7b, %esi
callq 0x52780
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x59730
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x59760
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x59920
testb $0x1, %al
jne 0x5a94e
jmp 0x5a9bb
cmpq $0x0, -0x28(%rbp)
jbe 0x5a97e
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
callq 0x52780
cmpq $0x20, -0x28(%rbp)
jne 0x5a97c
movq -0x18(%rbp), %rdi
leaq 0x4fdd4(%rip), %rsi     # 0xaa749
callq 0x525b0
jmp 0x5a9bb
jmp 0x5a97e
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x52780
leaq -0x30(%rbp), %rdi
callq 0x59960
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5aa10
leaq -0x30(%rbp), %rdi
callq 0x59980
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5a92e
cmpq $0x0, -0x28(%rbp)
jbe 0x5a9d0
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x52780
movq -0x18(%rbp), %rdi
movl $0x7d, %esi
callq 0x52780
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager::SetUp()
void SetUp(){
        const int kLCDHorizontalPixelNum = 6;
        const int kLCDVerticalPixelNum = 4;
        lcd = new LCDController(kLCDHorizontalPixelNum, kLCDVerticalPixelNum);
        mng = new PixelArtManager(lcd);
        lcd_small = new LCDController(1, 1);
        mng_small = new PixelArtManager(lcd_small);
      }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x6, -0xc(%rbp)
movl $0x4, -0x10(%rbp)
movl $0x20, %edi
callq 0x525d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movl $0x6, %esi
movl $0x4, %edx
callq 0x6aab0
jmp 0x5b337
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x30, %edi
callq 0x525d0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rsi
callq 0x6af10
jmp 0x5b366
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movl $0x20, %edi
callq 0x525d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl $0x1, %edx
movl %edx, %esi
callq 0x6aab0
jmp 0x5b394
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl $0x30, %edi
callq 0x525d0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq 0x20(%rax), %rsi
callq 0x6af10
jmp 0x5b3c3
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x28(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x52600
jmp 0x5b443
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x52600
jmp 0x5b443
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x20, %esi
callq 0x52600
jmp 0x5b443
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x30, %esi
callq 0x52600
movq -0x18(%rbp), %rdi
callq 0x52bc0
nopl (%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest-printers.h
// Function: std::basic_ostream<char, std::char_traits<char>>& testing::internal2::operator<<<char, std::char_traits<char>, OperationType>(std::basic_ostream<char, std::char_traits<char>>&, OperationType const&)
::std::basic_ostream<Char, CharTraits>& operator<<(
    ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  TypeWithoutFormatter<T,
      (internal::IsAProtocolMessage<T>::value ? kProtobuf :
       internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
       kConvertibleToInteger : kOtherType)>::PrintValue(x, &os);
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x64b00
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/mock/lcd_controller_mock.cpp
// Function: LCDController::LCDController(int, int)
LCDController::LCDController(int horizontal_pixel_num, int vertical_pixel_num)
{
    LCDState init_state(vertical_pixel_num, std::vector<uint8_t>(horizontal_pixel_num));
    state_ = init_state;
    height_ = vertical_pixel_num;
    width_ = horizontal_pixel_num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x6acb0
movslq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x57400
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x67bb0
jmp 0x6ab09
leaq -0x55(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x574a0
movq -0x70(%rbp), %rsi
movq -0x88(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x67c20
jmp 0x6ab33
leaq -0x55(%rbp), %rdi
callq 0x57540
leaq -0x40(%rbp), %rdi
callq 0x57560
leaq -0x41(%rbp), %rdi
callq 0x575c0
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x693d0
jmp 0x6ab5d
movq -0x78(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0x57740
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6abab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x55(%rbp), %rdi
callq 0x57540
leaq -0x40(%rbp), %rdi
callq 0x57560
leaq -0x41(%rbp), %rdi
callq 0x575c0
jmp 0x6abcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x57740
movq -0x80(%rbp), %rdi
callq 0x57740
movq -0x50(%rbp), %rdi
callq 0x52bc0
nopl (%rax)
// File: interimadd[P]M5Stack-PixelArt/mock/lcd_controller_mock.cpp
// Function: LCDController::fillRect(int, int, int, int, unsigned char)
void LCDController::fillRect(int v_pos, int h_pos, int v_len, int h_len, uint8_t cell_val)
{
    int v_pos_end = v_pos + v_len;
    int h_pos_end = h_pos + h_len;
    for(int v_idx=v_pos; v_idx<v_pos_end; v_idx++){
        for(int h_idx=h_pos; h_idx<h_pos_end; h_idx++){
            if(v_idx < 0 || v_idx >= height_) continue;
            if(h_idx < 0 || h_idx >= width_) continue;
            state_[v_idx][h_idx] = cell_val;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6ac99
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6ac8c
cmpl $0x0, -0x28(%rbp)
jl 0x6ac47
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jl 0x6ac49
jmp 0x6ac81
cmpl $0x0, -0x2c(%rbp)
jl 0x6ac5b
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jl 0x6ac5d
jmp 0x6ac81
movq -0x38(%rbp), %rdi
movb -0x19(%rbp), %al
movb %al, -0x39(%rbp)
movslq -0x28(%rbp), %rsi
callq 0x57630
movq %rax, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x57650
movb -0x39(%rbp), %cl
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6ac2d
jmp 0x6ac8e
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6ac1f
addq $0x40, %rsp
popq %rbp
retq
nop
// File: interimadd[P]M5Stack-PixelArt/pixel_art_m5stack/src/pixel_art_manager.cpp
// Function: PixelArtManager::PixelArtManager(LCDController*)
PixelArtManager::PixelArtManager(LCDController* lcd)
{
    lcd_ = lcd;
    current_art_no_ = 0;
    draw_pos_x_ = 0;
    draw_pos_y_ = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x6b220
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/pixel_art_m5stack/src/pixel_art_manager.cpp
// Function: PixelArtManager::drawPixelArt(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>, int, int, int)
void PixelArtManager::drawPixelArt(MonochromePixelArt pixel_art, int pos_x, int pos_y, int scale)
{
    int vertical_pixel_num = pixel_art.size();
    int horizontal_pixel_num = pixel_art[0].size();
    for(int hp=0; hp<horizontal_pixel_num; hp++){
        for(int vp=0; vp<vertical_pixel_num; vp++){
            uint8_t pix_val = pixel_art[vp][hp];
            lcd_->fillRect(pos_y+vp*scale, pos_x+hp*scale, scale, scale, pix_val);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x59620
movq -0x38(%rbp), %rdi
movl %eax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x57630
movq %rax, %rdi
callq 0x586c0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6b038
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x6b02b
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x57630
movq %rax, %rdi
movslq -0x28(%rbp), %rsi
callq 0x57650
movq %rax, %rcx
movq -0x40(%rbp), %rax
movb (%rcx), %cl
movb %cl, -0x2d(%rbp)
movq (%rax), %rdi
movl -0x18(%rbp), %esi
movl -0x2c(%rbp), %eax
imull -0x1c(%rbp), %eax
addl %eax, %esi
movl -0x14(%rbp), %edx
movl -0x28(%rbp), %eax
imull -0x1c(%rbp), %eax
addl %eax, %edx
movl -0x1c(%rbp), %ecx
movl -0x1c(%rbp), %r8d
movzbl -0x2d(%rbp), %r9d
callq 0x6abe0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x6afc7
jmp 0x6b02d
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6afb8
addq $0x50, %rsp
popq %rbp
retq
nop
// File: interimadd[P]M5Stack-PixelArt/pixel_art_m5stack/src/pixel_art_manager.cpp
// Function: PixelArtManager::drawNextFrame(OperationType)
void PixelArtManager::drawNextFrame(OperationType operation)
{

    if(pixel_art_with_frame_list_.size() == 0) return;
    if(operation == OperationType::NEXT_BUTTON) current_art_no_++;
    if(current_art_no_ >= pixel_art_with_frame_list_.size()) current_art_no_ = 0;
    MonochromePixelArt pixel_art_to_display = pixel_art_with_frame_list_[current_art_no_].pixel_art.toNextFrame();
    drawPixelArt(pixel_art_to_display, draw_pos_x_, draw_pos_y_,
                 pixel_art_with_frame_list_[current_art_no_].scale);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
callq 0x6b2d0
cmpq $0x0, %rax
jne 0x6b0db
jmp 0x6b198
cmpl $0x1, -0xc(%rbp)
jne 0x6b0ee
movq -0x58(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x58(%rbp), %rdi
movslq 0x20(%rdi), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rdi
callq 0x6b2d0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jb 0x6b11a
movq -0x58(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x58(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0x6b300
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6ae10
movq -0x68(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x593c0
jmp 0x6b14d
movq -0x58(%rbp), %rax
movl 0x24(%rax), %ecx
movl %ecx, -0x70(%rbp)
movl 0x28(%rax), %ecx
movl %ecx, -0x6c(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0x6b300
movq -0x58(%rbp), %rdi
movl -0x70(%rbp), %edx
movl -0x6c(%rbp), %ecx
movl 0x20(%rax), %r8d
leaq -0x40(%rbp), %rsi
callq 0x6af60
jmp 0x6b186
leaq -0x40(%rbp), %rdi
callq 0x57740
leaq -0x28(%rbp), %rdi
callq 0x57740
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6b1c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x57740
leaq -0x28(%rbp), %rdi
callq 0x57740
movq -0x48(%rbp), %rdi
callq 0x52bc0
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/pixel_art_m5stack/entrypoint.cpp
// Function: setup()
void setup()
{
    lcd = new LCDController(LCD_HORIZONTAL_PIXEL_NUM, LCD_VERTICAL_PIXEL_NUM);
    mng = new PixelArtManager(lcd);
    for(int idx=0; idx<ALL_PIXEL_ARTS_LIST.size(); idx++){
        MonochromePixelArtWithFrame *pixel_with_frame = new MonochromePixelArtWithFrame(ALL_PIXEL_ARTS_LIST[idx]);
        mng->addPixelArtWithFrame(*pixel_with_frame, PIXEL_ART_SCALE);
    }
    mng->setDrawPosition(PIXEL_ART_POS_X, PIXEL_ART_POS_Y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x20, %edi
callq 0x525d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq 0x656ca(%rip), %rax     # 0xd16b0
movl (%rax), %esi
leaq 0x656c5(%rip), %rax     # 0xd16b4
movl (%rax), %edx
callq 0x6aab0
jmp 0x6bff8
movq -0x60(%rbp), %rax
movq %rax, 0x6580d(%rip)     # 0xd1810
movl $0x30, %edi
callq 0x525d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq 0x657f2(%rip), %rsi     # 0xd1810
callq 0x6af10
jmp 0x6c025
movq -0x68(%rbp), %rax
movq %rax, 0x657e8(%rip)     # 0xd1818
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq 0x6577a(%rip), %rdi     # 0xd17c0
callq 0x68530
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c18d
movl $0x20, %edi
callq 0x525d0
movq %rax, -0x78(%rbp)
movb $0x1, -0x31(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0x65748(%rip), %rdi     # 0xd17c0
callq 0x6c200
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x616d0
jmp 0x6c08b
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6ad50
jmp 0x6c09a
movb $0x0, -0x31(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x59550
movq -0x78(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x65762(%rip), %rax     # 0xd1818
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x61670
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
leaq 0x65700(%rip), %rax     # 0xd17e0
movl (%rax), %edx
callq 0x6b040
jmp 0x6c0e9
leaq -0x58(%rbp), %rdi
callq 0x616b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6c037
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0x20, %esi
callq 0x52600
jmp 0x6c1b4
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl $0x30, %esi
callq 0x52600
jmp 0x6c1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
jmp 0x6c15e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x59550
testb $0x1, -0x31(%rbp)
jne 0x6c166
jmp 0x6c174
movq -0x78(%rbp), %rdi
movl $0x20, %esi
callq 0x52600
jmp 0x6c1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x616b0
jmp 0x6c1b4
movq 0x65684(%rip), %rdi     # 0xd1818
leaq 0x6563d(%rip), %rax     # 0xd17d8
movl (%rax), %esi
leaq 0x65638(%rip), %rax     # 0xd17dc
movl (%rax), %edx
callq 0x6b1e0
addq $0x90, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x52bc0
nopl (%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::BoolFromGTestEnv(char const*, bool)
bool BoolFromGTestEnv(const char* flag, bool default_value) {
#if defined(GTEST_GET_BOOL_FROM_ENV_)
  return GTEST_GET_BOOL_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_BOOL_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x86700
movq -0x58(%rbp), %rdi
callq 0x52230
movq %rax, %rdi
callq 0x8d470
movq %rax, -0x50(%rbp)
jmp 0x6c25c
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6c273
movb -0x9(%rbp), %al
movb %al, -0x59(%rbp)
jmp 0x6c28c
movq -0x38(%rbp), %rdi
leaq 0x3f508(%rip), %rsi     # 0xab786
callq 0x52980
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
movb %al, -0x5a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52d38
movb -0x5a(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52d38
movq -0x40(%rbp), %rdi
callq 0x52bc0
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::CurrentOsStackTraceExceptTop[abi:cxx11](int)
std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) {
  return os_stack_trace_getter()->CurrentStackTrace(
      static_cast<int>(GTEST_FLAG(stack_trace_depth)),
      skip_count + 1
      // Skips the user-specified number of frames plus this function
      // itself.
      );  // NOLINT
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f450
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl 0x647fc(%rip), %edx     # 0xd18a0
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(GetArgvs()[0]).RemoveExtension("exe"));
#else
  result.Set(FilePath(GetArgvs()[0]));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x88e90
callq 0x6d0c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x88f30
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x88f50
jmp 0x6d10f
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x88f00
jmp 0x6d11e
leaq -0x48(%rbp), %rdi
callq 0x88fa0
movq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6d180
jmp 0x6d136
leaq -0x28(%rbp), %rdi
callq 0x88fa0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6d16c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x88fa0
leaq -0x28(%rbp), %rdi
callq 0x88fa0
movq -0x50(%rbp), %rdi
callq 0x52bc0
nop
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::os_stack_trace_getter()
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x1a8(%rax)
jne 0x6f4b6
movl $0x8, %edi
callq 0x525d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x8fb40
jmp 0x6f489
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x1a8(%rax)
jmp 0x6f4b6
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x8, %esi
callq 0x52600
jmp 0x6f4c7
movq -0x20(%rbp), %rax
movq 0x1a8(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x52bc0
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::CalculateOptimalEdits(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::vector<EditType> CalculateOptimalEdits(
    const std::vector<std::string>& left,
    const std::vector<std::string>& right) {
  std::vector<size_t> left_ids, right_ids;
  {
    InternalStrings intern_table;
    for (size_t i = 0; i < left.size(); ++i) {
      left_ids.push_back(intern_table.GetId(left[i]));
    }
    for (size_t i = 0; i < right.size(); ++i) {
      right_ids.push_back(intern_table.GetId(right[i]));
    }
  }
  return CalculateOptimalEdits(left_ids, right_ids);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8a0f0
leaq -0x48(%rbp), %rdi
callq 0x8a0f0
leaq -0x78(%rbp), %rdi
callq 0x70920
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8a110
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0x70820
movq -0x10(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x88f30
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x70940
movq %rax, -0xc8(%rbp)
jmp 0x707d0
movq -0xc8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8a130
jmp 0x707f0
jmp 0x707f2
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x7078b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x709e0
jmp 0x70902
movq $0x0, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8a110
movq %rax, %rcx
movq -0xd0(%rbp), %rax
cmpq %rcx, %rax
jae 0x708af
movq -0x18(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x88f30
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x70940
movq %rax, -0xd8(%rbp)
jmp 0x70876
movq -0xd8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8a130
jmp 0x70896
jmp 0x70898
movq -0xa0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa0(%rbp)
jmp 0x7082b
leaq -0x78(%rbp), %rdi
callq 0x709e0
movq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x6fe60
jmp 0x708ce
leaq -0x48(%rbp), %rdi
callq 0x8a160
leaq -0x30(%rbp), %rdi
callq 0x8a160
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8a160
leaq -0x30(%rbp), %rdi
callq 0x8a160
movq -0x90(%rbp), %rdi
callq 0x52bc0
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::InternalStrings::GetId(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t GetId(const std::string& str) {
    IdMap::iterator it = ids_.find(str);
    if (it != ids_.end()) return it->second;
    size_t id = ids_.size();
    return ids_[str] = id;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x925e0
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x92640
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x92610
testb $0x1, %al
jne 0x70985
jmp 0x70998
leaq -0x20(%rbp), %rdi
callq 0x92670
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x709c8
movq -0x38(%rbp), %rdi
callq 0x926a0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x926c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::Hunk::PushLine(char, char const*)
void PushLine(char edit, const char* line) {
    switch (edit) {
      case ' ':
        ++common_;
        FlushEdits();
        hunk_.push_back(std::make_pair(' ', line));
        break;
      case '-':
        ++removes_;
        hunk_removes_.push_back(std::make_pair('-', line));
        break;
      case '+':
        ++adds_;
        hunk_adds_.push_back(std::make_pair('+', line));
        break;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x60(%rbp)
subl $0x20, %eax
je 0x7103a
jmp 0x7101f
movl -0x60(%rbp), %eax
subl $0x2b, %eax
je 0x710c1
jmp 0x7102d
movl -0x60(%rbp), %eax
subl $0x2d, %eax
je 0x71082
jmp 0x710fe
movq -0x68(%rbp), %rdi
movq 0x20(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x20(%rdi)
callq 0x87820
movq -0x68(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x70(%rbp)
movb $0x20, -0x29(%rbp)
leaq -0x29(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x93c90
movq -0x70(%rbp), %rdi
movb %al, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x93c50
jmp 0x710fe
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x58, %rax
movq %rax, -0x78(%rbp)
movb $0x2d, -0x41(%rbp)
leaq -0x41(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x93c90
movq -0x78(%rbp), %rdi
movb %al, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x93c50
jmp 0x710fe
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rax
movq %rax, -0x80(%rbp)
movb $0x2b, -0x59(%rbp)
leaq -0x59(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x93c90
movq -0x80(%rbp), %rdi
movb %al, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x93c50
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintTo(std::ostream*)
void PrintTo(std::ostream* os) {
    PrintHeader(os);
    FlushEdits();
    for (std::list<std::pair<char, const char*> >::const_iterator it =
             hunk_.begin();
         it != hunk_.end(); ++it) {
      *os << it->first << it->second << "\n";
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x878c0
movq -0x38(%rbp), %rdi
callq 0x87820
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x93ef0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x93d30
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x93d00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x93d30
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x94380
testb $0x1, %al
jne 0x711c9
jmp 0x7121d
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x943b0
movq -0x48(%rbp), %rdi
movsbl (%rax), %esi
callq 0x52780
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x943b0
movq -0x40(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x525b0
movq %rax, %rdi
leaq 0x391d1(%rip), %rsi     # 0xaa3db
callq 0x525b0
leaq -0x18(%rbp), %rdi
callq 0x943e0
jmp 0x71198
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperEQ(char const*, char const*, long long, long long)
AssertionResult CmpHelperEQ(const char* lhs_expression,
                            const char* rhs_expression,
                            BiggestInt lhs,
                            BiggestInt rhs) {
  if (lhs == rhs) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   FormatForComparisonFailureMessage(lhs, rhs),
                   FormatForComparisonFailureMessage(rhs, lhs),
                   false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x71cc8
movq -0x88(%rbp), %rdi
callq 0x6ec20
jmp 0x71d7f
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rsi, -0x90(%rbp)
leaq -0x28(%rbp), %rdx
movq %rdx, -0x98(%rbp)
callq 0x8b160
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x8b160
jmp 0x71d16
movq -0xa0(%rbp), %rdx
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x71270
jmp 0x71d3d
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
jmp 0x71d7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x71d74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
jmp 0x71d8c
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x52bc0
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*)
AssertionResult CmpHelperSTREQ(const char* lhs_expression,
                               const char* rhs_expression,
                               const wchar_t* lhs,
                               const wchar_t* rhs) {
  if (String::WideCStringEquals(lhs, rhs)) {
    return AssertionSuccess();
  }

  return EqFailure(lhs_expression,
                   rhs_expression,
                   PrintToString(lhs),
                   PrintToString(rhs),
                   false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%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 -0x28(%rbp), %rsi
callq 0x73e90
testb $0x1, %al
jne 0x73f30
jmp 0x73f41
movq -0x88(%rbp), %rdi
callq 0x6ec20
jmp 0x73fdc
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8b4b0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8b4b0
jmp 0x73f73
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
xorl %r9d, %r9d
callq 0x71270
jmp 0x73f9a
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
jmp 0x73fdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x73fd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x52d38
leaq -0x48(%rbp), %rdi
callq 0x52d38
jmp 0x73fe9
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x52bc0
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::LoadFlagsFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void LoadFlagsFromFile(const std::string& path) {
  FILE* flagfile = posix::FOpen(path.c_str(), "r");
  if (!flagfile) {
    fprintf(stderr,
            "Unable to open file \"%s\"\n",
            GTEST_FLAG(flagfile).c_str());
    fflush(stderr);
    exit(EXIT_FAILURE);
  }
  std::string contents(ReadEntireFile(flagfile));
  posix::FClose(flagfile);
  std::vector<std::string> lines;
  SplitString(contents, '\n', &lines);
  for (size_t i = 0; i < lines.size(); ++i) {
    if (lines[i].empty())
      continue;
    if (!ParseGoogleTestFlag(lines[i].c_str()))
      g_help_flag = true;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x52230
movq %rax, %rdi
leaq 0x2bed5(%rip), %rsi     # 0xaba67
callq 0x8da10
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7fbea
movq 0x5141f(%rip), %rax     # 0xd0fc8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq 0x51d19(%rip), %rdi     # 0xd18d0
callq 0x52230
movq -0x68(%rbp), %rdi
movq %rax, %rdx
leaq 0x2a8d6(%rip), %rsi     # 0xaa4a0
movb $0x0, %al
callq 0x529a0
movq 0x513f0(%rip), %rax     # 0xd0fc8
movq (%rax), %rdi
callq 0x527a0
movl $0x1, %edi
callq 0x527f0
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x7fd00
movq -0x10(%rbp), %rdi
callq 0x8feb0
jmp 0x7fc02
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x88e10
movq -0x70(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x6f570
jmp 0x7fc23
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8a110
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x7fcd3
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x8fed0
movq %rax, %rdi
callq 0x52b40
testb $0x1, %al
jne 0x7fc67
jmp 0x7fc8e
jmp 0x7fcc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7fcee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x88e30
jmp 0x7fcee
movq -0x60(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x8fed0
movq %rax, %rdi
callq 0x52230
movq %rax, %rdi
callq 0x7f8d0
movb %al, -0x79(%rbp)
jmp 0x7fcb0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x7fcc0
jmp 0x7fcb9
movb $0x1, 0x51b61(%rip)     # 0xd1821
jmp 0x7fcc2
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x7fc2b
leaq -0x58(%rbp), %rdi
callq 0x88e30
leaq -0x30(%rbp), %rdi
callq 0x52d38
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x52d38
movq -0x38(%rbp), %rdi
callq 0x52bc0
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-death-test.cc
// Function: testing::KilledBySignal::operator()(int) const
bool KilledBySignal::operator()(int exit_status) const {
#  if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  {
    bool result;
    if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
      return result;
    }
  }
#  endif  // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
  return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %ecx
sarl %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0xd(%rbp)
jle 0x8001d
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
andl $0x7f, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-filepath.cc
// Function: testing::internal::FilePath::GetCurrentDir()
FilePath FilePath::GetCurrentDir() {
#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  // Windows CE doesn't have a current directory, so we just return
  // something reasonable.
  return FilePath(kCurrentDirectoryString);
#elif GTEST_OS_WINDOWS
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd);
#else
  char cwd[GTEST_PATH_MAX_ + 1] = { '\0' };
  char* result = getcwd(cwd, sizeof(cwd));
# if GTEST_OS_NACL
  // getcwd will likely fail in NaCl due to the sandbox, so return something
  // reasonable. The user may have provided a shim implementation for getcwd,
  // however, so fallback only when failure is detected.
  return FilePath(result == NULL ? kCurrentDirectoryString : cwd);
# endif  // GTEST_OS_NACL
  return FilePath(result == NULL ? "" : cwd);
#endif  // GTEST_OS_WINDOWS_MOBILE
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1080, %rsp           # imm = 0x1080
movq %rdi, -0x1060(%rbp)
movq %rdi, %rax
movq %rax, -0x1058(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0x52320
leaq -0x1010(%rbp), %rdi
movl $0x1001, %esi           # imm = 0x1001
callq 0x522e0
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x854e5
leaq 0x24f00(%rip), %rax     # 0xaa3dc
movq %rax, -0x1068(%rbp)
jmp 0x854f3
leaq -0x1010(%rbp), %rax
movq %rax, -0x1068(%rbp)
movq -0x1068(%rbp), %rax
movq %rax, -0x1078(%rbp)
leaq -0x1039(%rbp), %rdi
movq %rdi, -0x1070(%rbp)
callq 0x52bd0
movq -0x1078(%rbp), %rsi
movq -0x1070(%rbp), %rdx
leaq -0x1038(%rbp), %rdi
callq 0x57280
jmp 0x85530
movq -0x1060(%rbp), %rdi
leaq -0x1038(%rbp), %rsi
callq 0x88f50
jmp 0x85545
leaq -0x1038(%rbp), %rdi
callq 0x52d38
leaq -0x1039(%rbp), %rdi
callq 0x52690
movq -0x1058(%rbp), %rax
addq $0x1080, %rsp           # imm = 0x1080
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
jmp 0x8559f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1048(%rbp)
movl %eax, -0x104c(%rbp)
leaq -0x1038(%rbp), %rdi
callq 0x52d38
leaq -0x1039(%rbp), %rdi
callq 0x52690
movq -0x1048(%rbp), %rdi
callq 0x52bc0
nopw (%rax,%rax)