LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x238(%rsi)
leaq 0x218(%rsi), %r15
movq 0x220(%rsi), %rdx
leaq 0x7ea(%rip), %rcx       # 0x40ce
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22a0
leaq 0x88(%r14), %rdi
callq 0x2080
testb %al, %al
je 0x395c
cmpl $0x1f, 0x238(%r14)
jg 0x395c
leaq 0x10(%r14), %r12
leaq 0x7(%rsp), %r13
cmpb $0x0, (%r14)
jne 0x3958
movq %r12, %rdi
movq %r13, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3958
movsbl 0x7(%rsp), %esi
movq %r15, %rdi
callq 0x2150
movl 0x238(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x238(%r14)
cmpl $0x1f, %eax
jl 0x3914
jmp 0x395c
movb $0x1, (%r14)
movq 0x220(%r14), %rax
cmpq $0x1f, %rax
ja 0x398b
movb $0x20, %r12b
subb %al, %r12b
movb $0x50, %cl
subb %al, %cl
xorl %r13d, %r13d
movzbl %cl, %ebp
movq %r15, %rdi
movl %ebp, %esi
callq 0x2150
incb %r13b
cmpb %r13b, %r12b
ja 0x3979
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x218(%r14), %rsi
movq 0x220(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3070
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2240
movq %r14, %rdi
callq 0x22f0
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2240
movq 0x8(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/gtest.h
// Function: testing::AssertionResult testing::internal::CmpHelperEQ<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(char const*, char const*, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq (%r8), %rdx
movq 0x8(%r8), %rcx
subq %rdx, %rcx
cmpq %rcx, %rax
jne 0x21652
callq 0x2174a
testb %al, %al
je 0x21652
movq %rbx, %rdi
callq 0x29be1
jmp 0x21666
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x21673
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x211aa
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2122d
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2b578
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2113a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21155
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21187
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x21187
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x211a2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x5(%rsp), %rsi
movb $0x7b, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
movq (%r14), %r15
cmpq 0x8(%r14), %r15
je 0x21918
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
leaq 0x3(%rsp), %r13
testq %rbp, %rbp
je 0x218b9
movb $0x2c, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1d540
cmpq $0x20, %rbp
je 0x218ef
movb $0x20, 0x4(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1d540
xorl %edi, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2193c
addq $0x18, %r15
incq %rbp
cmpq 0x8(%r14), %r15
jne 0x21899
testq %rbp, %rbp
jne 0x21903
jmp 0x21918
leaq 0x2a8c3(%rip), %rsi     # 0x4c1b9
movl $0x4, %edx
movq %rbx, %rdi
callq 0x1d540
leaq 0x6(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
leaq 0x7(%rsp), %rsi
movb $0x7d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1d540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x1d430
movq %rax, %r14
movq %rax, %rdi
movl $0x6, %esi
movl $0x4, %edx
callq 0x273cc
movq %r14, 0x10(%rbx)
movl $0x30, %edi
callq 0x1d430
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x275a0
movq %r15, 0x18(%rbx)
movl $0x20, %edi
callq 0x1d430
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x273cc
movq %r14, 0x20(%rbx)
movl $0x30, %edi
callq 0x1d430
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x275a0
movq %r15, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21b20
jmp 0x21b2d
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
jmp 0x21b38
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager_InitPixelArtManager_Test::TestBody()
TEST_F(TestPixelArtManager, InitPixelArtManager)
  {
    LCDState expect = {
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0},
      {0, 0, 0, 0, 0, 0}
    };
    EXPECT_EQ(expect, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %r15
leaq 0x18(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0x28(%rsp), %r14
leaq 0xf(%rsp), %rcx
movl $0x6, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x40(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xe(%rsp), %rcx
movl $0x6, %edx
movq %rbx, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rbx
leaq 0xa8(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xd(%rsp), %rcx
movl $0x6, %edx
movq %rbx, %rdi
callq 0x20d70
leaq 0x70(%rsp), %rbx
leaq 0xa0(%rsp), %rsi
movw $0x0, 0x4(%rsi)
movl $0x0, (%rsi)
leaq 0xc(%rsp), %rcx
movl $0x6, %edx
movq %rbx, %rdi
callq 0x20d70
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xb(%rsp), %rcx
movl $0x4, %edx
callq 0x20db4
movl $0x60, %ebx
movq 0x10(%rsp,%rbx), %rdi
testq %rdi, %rdi
je 0x21c35
movq 0x20(%rsp,%rbx), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %rbx
jne 0x21c1e
movq 0x10(%r15), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x2789b(%rip), %rsi     # 0x494eb
leaq 0x2789b(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x21d06
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x21c9c
movq (%rax), %r8
jmp 0x21ca3
leaq 0x2a1c7(%rip), %r8      # 0x4be6a
leaq 0x27717(%rip), %rdx     # 0x493c1
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x23, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x21d06
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x21cfd
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x21cfd
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x88(%rsp), %rdi
callq 0x20e26
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21d5b
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x21d40
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x21d4f
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x21d75
movq %rax, %rdi
callq 0x20d60
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x21d75
movq %rax, %r15
leaq 0x88(%rsp), %rdi
callq 0x20e26
jmp 0x21ddd
movq %rax, %r15
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1da94
movb $0x1, %al
jmp 0x21db0
jmp 0x21da1
jmp 0x21da1
movq %rax, %r15
xorl %eax, %eax
jmp 0x21db0
movq %rax, %r15
xorl %eax, %eax
movq %r14, %rbx
cmpq %rbx, %r14
sete %cl
orb %al, %cl
jne 0x21ddd
leaq 0x28(%rsp), %r14
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x21dd4
movq -0x8(%rbx), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %rbx
cmpq %r14, %rbx
jne 0x21dbf
movq %r15, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/pixel_art_manager_test.cpp
// Function: (anonymous namespace)::TestPixelArtManager_DrawNullPixelFrameDoNotChangeLCD_Test::TestBody()
TEST_F(TestPixelArtManager, DrawNullPixelFrameDoNotChangeLCD)
  {
    OperationType no_op = OperationType::NO_OPERATION;
    mng_small->drawNextFrame(no_op);
    LCDState expect = {{0}};
    EXPECT_EQ(expect, lcd_small->getState());
  }

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
xorl %esi, %esi
callq 0x276ee
leaq 0x28(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movl $0x1, %edx
callq 0x20d70
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
callq 0x20db4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22d31
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
movq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2133c
leaq 0x267a5(%rip), %rsi     # 0x494eb
leaq 0x267c2(%rip), %rdx     # 0x4950f
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rcx
leaq 0x8(%rsp), %r8
callq 0x2160b
leaq 0x8(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x28(%rsp)
jne 0x22df9
leaq 0x8(%rsp), %rdi
callq 0x2a416
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x22d8f
movq (%rax), %r8
jmp 0x22d96
leaq 0x290d4(%rip), %r8      # 0x4be6a
leaq 0x26624(%rip), %rdx     # 0x493c1
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
movl $0x68, %ecx
callq 0x280e0
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2817e
leaq 0x20(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x8(%rsp)
je 0x22df9
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x22df0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22df0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x38(%rsp), %rdi
callq 0x20e26
addq $0x50, %rsp
popq %rbx
retq
jmp 0x22e44
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2814c
jmp 0x22e29
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20dfe
jmp 0x22e38
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e10
jmp 0x22e5e
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20e26
jmp 0x22e5e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20e26
jmp 0x22e89
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22e89
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x22e89
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_LCDisWhiteWhenInitilize_Test::TestBody()
TEST_F(TestLCDMock, LCDisWhiteWhenInitilize)
  {
    LCDState expect_state = {
      {0, 0, 0},
      {0, 0, 0}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x2451c
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24505
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x24fcb(%rip), %rsi     # 0x49502
leaq 0x24fb4(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x245ea
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x24580
movq (%rax), %r8
jmp 0x24587
leaq 0x278e3(%rip), %r8      # 0x4be6a
leaq 0x25669(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x18, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x245ea
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x245e1
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x245e1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x24639
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x2461e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x2462d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x24653
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x24653
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x246b1
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dc78
movb $0x1, %al
jmp 0x24684
movq %rax, %rbx
xorl %eax, %eax
jmp 0x24684
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x246b1
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x246a8
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x24693
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlack_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlack)
  {
    int v_pos = 0, h_pos = 1;
    int v_len = 2, h_len = 1;
    lcd->fillRect(v_pos, h_pos, v_len, h_len, 1);
    LCDState expect_state = {
      {0, 1, 0},
      {0, 1, 0}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
movl $0x1, %edx
movl $0x2, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x27490
leaq 0x18(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x100, (%rsi)          # imm = 0x100
movb $0x0, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x247cf
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x247b8
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x24d18(%rip), %rsi     # 0x49502
leaq 0x24d01(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x2489d
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x24833
movq (%rax), %r8
jmp 0x2483a
leaq 0x27630(%rip), %r8      # 0x4be6a
leaq 0x253b6(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x24, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x2489d
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x24894
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x24894
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x248ec
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x248d1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x248e0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x24906
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x24906
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x24964
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dcc2
movb $0x1, %al
jmp 0x24937
movq %rax, %rbx
xorl %eax, %eax
jmp 0x24937
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x24964
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2495b
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x24946
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlackAll_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlackAll)
  {
    int v_pos = 0, h_pos = 0;
    int v_len = 2, h_len = 3;
    lcd->fillRect(v_pos, h_pos, v_len, h_len, 1);
    LCDState expect_state = {
      {1, 1, 1},
      {1, 1, 1}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x2, %ecx
movl $0x3, %r8d
movl $0x1, %r9d
callq 0x27490
leaq 0x18(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24a7e
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24a67
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x24a69(%rip), %rsi     # 0x49502
leaq 0x24a52(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x24b4c
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x24ae2
movq (%rax), %r8
jmp 0x24ae9
leaq 0x27381(%rip), %r8      # 0x4be6a
leaq 0x25107(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x30, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x24b4c
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x24b43
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x24b43
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x24b9b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x24b80
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x24b8f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x24bb5
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x24bb5
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x24c13
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dcf2
movb $0x1, %al
jmp 0x24be6
movq %rax, %rbx
xorl %eax, %eax
jmp 0x24be6
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x24c13
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x24c0a
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x24bf5
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_FillRectBlackOverSize_Test::TestBody()
TEST_F(TestLCDMock, FillRectBlackOverSize)
  {
    int v_pos = 0, h_pos = 0;
    int v_len = 100, h_len = 100;
    lcd->fillRect(v_pos, h_pos, v_len, h_len, 1);
    LCDState expect_state = {
      {1, 1, 1},
      {1, 1, 1}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x64, %ecx
movl $0x64, %r8d
movl $0x1, %r9d
callq 0x27490
leaq 0x18(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24d2e
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24d17
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x247b9(%rip), %rsi     # 0x49502
leaq 0x247a2(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x24dfc
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x24d92
movq (%rax), %r8
jmp 0x24d99
leaq 0x270d1(%rip), %r8      # 0x4be6a
leaq 0x24e57(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x3c, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x24dfc
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x24df3
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x24df3
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x24e4b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x24e30
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x24e3f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x24e65
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x24e65
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x24ec3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dd22
movb $0x1, %al
jmp 0x24e96
movq %rax, %rbx
xorl %eax, %eax
jmp 0x24e96
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x24ec3
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x24eba
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x24ea5
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_DrawDot_Test::TestBody()
TEST_F(TestLCDMock, DrawDot)
  {
    int dot_size = 1;
    int dot_color = 1;
    lcd->fillRect(0, 0, dot_size, dot_size, dot_color);
    lcd->fillRect(1, 2, dot_size, dot_size, dot_color);
    LCDState expect_state = {
      {1, 0, 0},
      {0, 0, 1}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x27490
movq 0x10(%rbx), %rdi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x27490
leaq 0x18(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x1, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x25002
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24feb
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x244e5(%rip), %rsi     # 0x49502
leaq 0x244ce(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x250d0
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x25066
movq (%rax), %r8
jmp 0x2506d
leaq 0x26dfd(%rip), %r8      # 0x4be6a
leaq 0x24b83(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x49, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x250d0
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x250c7
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x250c7
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2511f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x25104
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x25113
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x25139
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x25139
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x25197
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dd52
movb $0x1, %al
jmp 0x2516a
movq %rax, %rbx
xorl %eax, %eax
jmp 0x2516a
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x25197
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x2518e
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x25179
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lcd_mock_test.cpp
// Function: (anonymous namespace)::TestLCDMock_DrawDotAtUnderLimit_Test::TestBody()
TEST_F(TestLCDMock, DrawDotAtUnderLimit)
  {
    int dot_size = 1;
    int dot_color = 1;
    lcd->fillRect(-1, -1, dot_size, dot_size, dot_color);
    LCDState expect_state = {
      {0, 0, 0},
      {0, 0, 0}
    };
    EXPECT_EQ(expect_state, lcd->getState());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x27490
leaq 0x18(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
movq %r15, %rdi
callq 0x20d70
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0xe(%rsp), %rcx
movl $0x3, %edx
movq %r14, %rdi
callq 0x20d70
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xd(%rsp), %rcx
movl $0x2, %edx
callq 0x20db4
movl $0x30, %r14d
movq 0x10(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x252b8
movq 0x20(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x252a1
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2133c
leaq 0x2422f(%rip), %rsi     # 0x49502
leaq 0x24218(%rip), %rdx     # 0x494f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x2160b
leaq 0x28(%rsp), %rdi
callq 0x20e26
cmpb $0x0, 0x18(%rsp)
jne 0x25386
leaq 0x28(%rsp), %rdi
callq 0x2a416
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2531c
movq (%rax), %r8
jmp 0x25323
leaq 0x26b47(%rip), %r8      # 0x4be6a
leaq 0x248cd(%rip), %rdx     # 0x49bf7
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
movl $0x55, %ecx
callq 0x280e0
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2817e
leaq 0x10(%rsp), %rdi
callq 0x2814c
cmpq $0x0, 0x28(%rsp)
je 0x25386
movl $0x1, %edi
callq 0x280dc
testb %al, %al
je 0x2537d
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2537d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x212e8
leaq 0x58(%rsp), %rdi
callq 0x20e26
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x253d5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2814c
jmp 0x253ba
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20dfe
jmp 0x253c9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20e10
jmp 0x253ef
movq %rax, %rdi
callq 0x20d60
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x253ef
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20e26
jmp 0x2544d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1dd82
movb $0x1, %al
jmp 0x25420
movq %rax, %rbx
xorl %eax, %eax
jmp 0x25420
movq %rax, %rbx
xorl %eax, %eax
movq %r15, %r14
cmpq %r14, %r15
sete %cl
orb %al, %cl
jne 0x2544d
leaq 0x28(%rsp), %r15
movq -0x18(%r14), %rdi
testq %rdi, %rdi
je 0x25444
movq -0x8(%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
cmpq %r15, %r14
jne 0x2542f
movq %rbx, %rdi
callq 0x1d900
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movslq %esi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x26a08
movslq %r14d, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x26a68
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2742a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x26f56
movl %r14d, 0x1c(%rbx)
movl %ebp, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x20e26
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20e26
jmp 0x2747f
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2747f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x2747f
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e26
movq %r14, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
testl %ecx, %ecx
jle 0x274df
pushq %r14
pushq %rbx
addl %esi, %ecx
leal (%r8,%rdx), %eax
testl %r8d, %r8d
jle 0x274d6
movl %esi, %r10d
leaq (%r10,%r10,2), %r10
movl %edx, %r11d
testl %esi, %esi
js 0x274ce
testl %r11d, %r11d
js 0x274ce
cmpl 0x1c(%rdi), %esi
jge 0x274ce
cmpl 0x18(%rdi), %r11d
jge 0x274ce
movq (%rdi), %rbx
movl %r11d, %r14d
movq (%rbx,%r10,8), %rbx
movb %r9b, (%rbx,%r14)
incl %r11d
cmpl %eax, %r11d
jl 0x274ac
incl %esi
cmpl %ecx, %esi
jl 0x2749d
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq (%rsi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
movq %rcx, 0x18(%rsp)
testl %ecx, %ecx
jle 0x2767d
movl %r8d, %r14d
movq %rdi, %r13
movq 0x8(%rsi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, 0x18(%rsp)
movq %rdx, 0x28(%rsp)
andq %rax, %rdx
movq %rdx, 0x20(%rsp)
xorl %ebx, %ebx
movq %rsi, 0x30(%rsp)
cmpl $0x0, 0x28(%rsp)
jle 0x27673
movl %ebx, %eax
imull %r14d, %eax
addl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %r15
xorl %r12d, %r12d
movl 0x10(%rsp), %ebp
movq (%rsi), %rax
movq (%rax,%r12), %rax
movzbl (%rax,%rbx), %r9d
movq (%r13), %rdi
movl %ebp, %esi
movl 0x14(%rsp), %edx
movl %r14d, %ecx
movl %r14d, %r8d
callq 0x27490
movq 0x30(%rsp), %rsi
addl %r14d, %ebp
addq $0x18, %r12
decq %r15
jne 0x27641
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x27620
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x20, %edi
callq 0x1d430
movq %rax, %r14
leaq 0x38aca(%rip), %rax     # 0x60520
movl (%rax), %esi
leaq 0x38ac5(%rip), %rax     # 0x60524
movl (%rax), %edx
movq %r14, %rdi
callq 0x273cc
movq %r14, 0x38c10(%rip)     # 0x60680
movl $0x30, %edi
callq 0x1d430
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x275a0
movq %r15, 0x38bf9(%rip)     # 0x60688
leaq 0x38b9a(%rip), %rax     # 0x60630
movq (%rax), %r12
cmpq %r12, 0x8(%rax)
je 0x27b48
xorl %ebp, %ebp
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
xorl %r13d, %r13d
movl $0x20, %edi
callq 0x1d430
movq %rax, %r15
addq %rbp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x242ba
movq %r15, %rdi
movq %rbx, %rsi
callq 0x274f4
movq %rbx, %rdi
callq 0x21420
movq 0x38ba3(%rip), %r12     # 0x60688
movq %r14, %rdi
movq %r15, %rsi
callq 0x242ba
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0x38b50(%rip), %rax     # 0x60650
movl (%rax), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2768c
movq %r14, %rdi
callq 0x21420
incq %r13
leaq 0x38b11(%rip), %rax     # 0x60630
movq (%rax), %r12
movq 0x8(%rax), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
addq $0x18, %rbp
cmpq %r13, %rax
ja 0x27ab0
movq 0x38b39(%rip), %rdi     # 0x60688
leaq 0x38af2(%rip), %rax     # 0x60648
movl (%rax), %esi
leaq 0x38aed(%rip), %rax     # 0x6064c
movl (%rax), %edx
callq 0x277be
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x30, %esi
jmp 0x27ba3
movq %rax, %rbx
movl $0x20, %esi
movq %r14, %rdi
jmp 0x27ba6
movq %rax, %rbx
jmp 0x27b9e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x21420
movl $0x20, %esi
movq %r15, %rdi
callq 0x1d460
jmp 0x27bb8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21420
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3e1e5
movq (%r14), %r14
movq %r14, %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x27c21
leaq 0x2554a(%rip), %rsi     # 0x4d15e
movq %rax, %rdi
callq 0x1d700
testl %eax, %eax
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x27c3b
movq 0x18(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1d460
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::StringFromGTestEnv[abi:cxx11](char const*, char const*)
std::string StringFromGTestEnv(const char* flag, const char* default_value) {
#if defined(GTEST_GET_STRING_FROM_ENV_)
  return GTEST_GET_STRING_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_STRING_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* value = posix::GetEnv(env_var.c_str());
  if (value != NULL) {
    return value;
  }

  // As a special case for the 'output' flag, if GTEST_OUTPUT is not
  // set, we look for XML_OUTPUT_FILE, which is set by the Bazel build
  // system.  The value of XML_OUTPUT_FILE is a filename without the
  // "xml:" prefix of GTEST_OUTPUT.
  //
  // The net priority order after flag processing is thus:
  //   --gtest_output command line flag
  //   GTEST_OUTPUT environment variable
  //   XML_OUTPUT_FILE environment variable
  //   'default_value'
  if (strcmp(flag, "output") == 0) {
    value = posix::GetEnv("XML_OUTPUT_FILE");
    if (value != NULL) {
      return std::string("xml:") + value;
    }
  }
  return default_value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x3e1e5
movq (%r12), %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x27c99
movq %rax, %r12
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x1d1e0
movq %r12, %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4620c
jmp 0x27cbc
leaq 0x22a2e(%rip), %rsi     # 0x4a6ce
movq %r15, %rdi
callq 0x1d700
testl %eax, %eax
je 0x27ce6
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fe54
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27cd7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x24c9f(%rip), %rdi     # 0x4c98c
callq 0x1d5f0
testq %rax, %rax
je 0x27cac
movq %rax, %r15
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x24c92(%rip), %rsi     # 0x4c99c
leaq 0x24c8f(%rip), %rdx     # 0x4c9a0
leaq 0x8(%rsp), %rdi
callq 0x4620c
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d9d0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x27d4a
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x27d50
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27cbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x27cbc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27daa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x27daa
jmp 0x27da7
jmp 0x27da7
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27dc5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-port.cc
// Function: testing::internal::Int32FromGTestEnv(char const*, int)
Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
#if defined(GTEST_GET_INT32_FROM_ENV_)
  return GTEST_GET_INT32_FROM_ENV_(flag, default_value);
#endif  // defined(GTEST_GET_INT32_FROM_ENV_)
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == NULL) {
    // The environment variable is not set.
    return default_value;
  }

  Int32 result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3e1e5
movq (%r14), %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x27eec
movq %rax, %r15
movl %ebx, 0x4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2a416
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x24b3a(%rip), %rsi     # 0x4c957
movl $0x15, %edx
movq %r12, %rdi
callq 0x1d540
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %r12, %rdi
callq 0x1d540
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x363aa
movl %eax, %ebp
testq %r14, %r14
je 0x27e67
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
testb %bpl, %bpl
je 0x27e72
movl 0x4(%rsp), %ebx
jmp 0x27eec
leaq 0x8(%rsp), %rdi
callq 0x2a416
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x1d8c0
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2a68b
leaq 0x20(%rsp), %r15
movq -0x10(%r15), %rsi
leaq 0x24ac4(%rip), %rdi     # 0x4c96d
xorl %eax, %eax
callq 0x1d080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x27ec6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
testq %r14, %r14
je 0x27edd
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x380b4(%rip), %rax     # 0x5ff98
movq (%rax), %rdi
callq 0x1d580
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27f07
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27f34
movq %rax, %rbx
testq %r14, %r14
je 0x27f53
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x27f53
movq %rax, %rbx
jmp 0x27f53
movq %rax, %rbx
testq %r14, %r14
je 0x27f53
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27f6e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x1a8(%rsi)
jne 0x28823
movl $0x8, %edi
callq 0x1d430
leaq 0x36eaf(%rip), %rcx     # 0x5f6c8
movq %rcx, (%rax)
movq %rax, 0x1a8(%r14)
movq 0x1a8(%r14), %rsi
movl 0x37ee0(%rip), %edx     # 0x60710
incl %ebp
movq (%rsi), %rax
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq