LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x26e50
movq 0x10(%rbx), %rdi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0x26e50
leaq 0x10(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x1, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24a52
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24a3b
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x24a95(%rip), %rsi     # 0x49502
leaq 0x24a7e(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x24b13
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x24ab2
movq (%rax), %r8
jmp 0x24ab9
leaq 0x273e1(%rip), %r8      # 0x4be9a
leaq 0x25137(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x49, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x24b13
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x24b13
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24b13
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x24b60
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x24b45
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x24b54
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x24b7a
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x24b7a
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x24bcd
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24ba6
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24b8f
jmp 0x24bcd
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24bcd
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x24bcd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x68, %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 0x26e50
leaq 0x10(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x6(%rsp), %rcx
movl $0x3, %edx
callq 0x2093a
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x5(%rsp), %rcx
movl $0x2, %edx
callq 0x2097e
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24ce6
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24ccf
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20f12
leaq 0x24801(%rip), %rsi     # 0x49502
leaq 0x247ea(%rip), %rdx     # 0x494f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x211e7
leaq 0x20(%rsp), %rdi
callq 0x209f0
cmpb $0x0, 0x10(%rsp)
jne 0x24da7
leaq 0x20(%rsp), %rdi
callq 0x29d3a
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x24d46
movq (%rax), %r8
jmp 0x24d4d
leaq 0x2714d(%rip), %r8      # 0x4be9a
leaq 0x24ea3(%rip), %rdx     # 0x49bf7
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x55, %ecx
callq 0x27a58
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27af4
leaq 0x8(%rsp), %rdi
callq 0x27ac4
cmpq $0x0, 0x20(%rsp)
je 0x24da7
movl $0x1, %edi
callq 0x27a55
testb %al, %al
je 0x24da7
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24da7
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x20ebe
leaq 0x50(%rsp), %rdi
callq 0x209f0
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x24df4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ac4
jmp 0x24dd9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209c8
jmp 0x24de8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x209da
jmp 0x24e0e
movq %rax, %rdi
callq 0x2092b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x209f0
jmp 0x24e0e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x209f0
jmp 0x24e61
movq %rax, %rbx
movl $0x30, %r14d
movq 0x8(%rsp,%r14), %rdi
testq %rdi, %rdi
je 0x24e3a
movq 0x18(%rsp,%r14), %rsi
subq %rdi, %rsi
callq 0x1d460
addq $-0x18, %r14
jne 0x24e23
jmp 0x24e61
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24e61
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x24e61
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1d900
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26362
movslq %r14d, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x263c2
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26dea
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x268e4
movl %r14d, 0x1c(%rbx)
movl %ebp, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x209f0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x209f0
jmp 0x26e3f
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x26e3f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1d460
jmp 0x26e3f
movq %rax, %r14
movq %rbx, %rdi
callq 0x209f0
movq %r14, %rdi
callq 0x1d900
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26e9f
pushq %r14
pushq %rbx
addl %esi, %ecx
leal (%r8,%rdx), %eax
testl %r8d, %r8d
jle 0x26e96
movl %esi, %r10d
leaq (%r10,%r10,2), %r10
movl %edx, %r11d
testl %esi, %esi
js 0x26e8e
testl %r11d, %r11d
js 0x26e8e
cmpl 0x1c(%rdi), %esi
jge 0x26e8e
cmpl 0x18(%rdi), %r11d
jge 0x26e8e
movq (%rdi), %rbx
movl %r11d, %r14d
movq (%rbx,%r10,8), %rbx
movb %r9b, (%rbx,%r14)
incl %r11d
cmpl %eax, %r11d
jl 0x26e6c
incl %esi
cmpl %ecx, %esi
jl 0x26e5d
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27035
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 0x2702b
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 0x26e50
movq 0x30(%rsp), %rsi
addl %r14d, %ebp
addq $0x18, %r12
decq %r15
jne 0x26ff9
incq %rbx
cmpq 0x18(%rsp), %rbx
jne 0x26fd8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
leaq 0x39116(%rip), %rax     # 0x60520
movl (%rax), %esi
leaq 0x39111(%rip), %rax     # 0x60524
movl (%rax), %edx
movq %r15, %rdi
callq 0x26d8c
movq %r15, 0x3925c(%rip)     # 0x60680
movl $0x30, %edi
callq 0x1d430
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x26f58
movq %r14, 0x39245(%rip)     # 0x60688
leaq 0x391e6(%rip), %rax     # 0x60630
movq (%rax), %r12
cmpq %r12, 0x8(%rax)
je 0x27503
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 0x23d9c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x26eb4
movq %rbx, %rdi
callq 0x20ff6
movq 0x391ef(%rip), %r12     # 0x60688
movq %r14, %rdi
movq %r15, %rsi
callq 0x23d9c
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0x3919c(%rip), %rax     # 0x60650
movl (%rax), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x27044
movq %r14, %rdi
callq 0x20ff6
incq %r13
leaq 0x3915d(%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 0x27464
movq 0x39185(%rip), %r14     # 0x60688
leaq 0x3913e(%rip), %rax     # 0x60648
movl (%rax), %esi
leaq 0x39139(%rip), %rax     # 0x6064c
movl (%rax), %edx
movq %r14, %rdi
callq 0x2717a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x30, %esi
movq %r14, %rdi
jmp 0x27555
jmp 0x2753b
movq %rax, %rbx
jmp 0x2754d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20ff6
movl $0x20, %esi
movq %r15, %rdi
callq 0x1d460
jmp 0x27567
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20ff6
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3d855
movq (%r14), %r14
movq %r14, %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x275c7
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x275c7
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x18(%rsp), %rax
cmpq %rax, %r14
je 0x275e1
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_O3/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 0x3d855
movq (%r12), %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x2763f
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 0x45704
jmp 0x27662
leaq 0x230b8(%rip), %rsi     # 0x4a6fe
movq %r15, %rdi
callq 0x1d700
testl %eax, %eax
je 0x2768c
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f45c
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2767d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x25329(%rip), %rdi     # 0x4c9bc
callq 0x1d5f0
testq %rax, %rax
je 0x27652
movq %rax, %r15
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2531c(%rip), %rsi     # 0x4c9cc
leaq 0x25319(%rip), %rdx     # 0x4c9d0
leaq 0x8(%rsp), %rdi
callq 0x45704
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 0x276f0
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x276f6
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 0x27662
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x27662
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27750
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x27750
jmp 0x2774d
jmp 0x2774d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2776b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3d855
movq (%r14), %r14
movq %r14, %rdi
callq 0x1d5f0
testq %rax, %rax
je 0x27888
movq %rax, %r15
movl %ebx, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29d3a
movq 0x30(%rsp), %r14
leaq 0x10(%r14), %r12
leaq 0x251c1(%rip), %rsi     # 0x4c987
movl $0x15, %edx
movq %r12, %rdi
callq 0x1d540
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0x1d540
leaq 0x30(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x35b40
movl %eax, %ebp
testq %r14, %r14
je 0x27807
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x27812
movl 0x4(%rsp), %ebx
jmp 0x27883
leaq 0x8(%rsp), %rdi
callq 0x29d3a
movq 0x8(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x1d8c0
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x29fa3
leaq 0x40(%rsp), %r15
movq -0x10(%r15), %rsi
leaq 0x25154(%rip), %rdi     # 0x4c99d
xorl %eax, %eax
callq 0x1d080
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x27866
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
testq %r14, %r14
je 0x27874
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq 0x3871d(%rip), %rax     # 0x5ff98
movq (%rax), %rdi
callq 0x1d580
movq 0x10(%rsp), %r14
leaq 0x20(%rsp), %rax
cmpq %rax, %r14
je 0x278a2
movq 0x20(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x1d460
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x278b5
jmp 0x278ba
movq %rax, %rbx
jmp 0x278cb
movq %rax, %rbx
testq %r14, %r14
je 0x278cb
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x278e6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x1a8(%rsi), %rsi
testq %rsi, %rsi
je 0x28177
movq (%rsi), %rax
jmp 0x28195
movl $0x8, %edi
callq 0x1d430
movq %rax, %rsi
leaq 0x3753d(%rip), %rax     # 0x5f6c8
movq %rax, (%rsi)
movq %rsi, 0x1a8(%r14)
movl 0x38575(%rip), %edx     # 0x60710
incl %ebp
movq %rbx, %rdi
movl %ebp, %ecx
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x385bd(%rip), %rsi     # 0x60798
leaq 0x28(%rsp), %rdi
callq 0x3f40e
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1d260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2820f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x28282
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28233
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x28260
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28263
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x28263
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2827a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq 0x1a8(%rdi), %rax
testq %rax, %rax
je 0x29b4f
retq
pushq %rbx
movq %rdi, %rbx
movl $0x8, %edi
callq 0x1d430
leaq 0x35b64(%rip), %rcx     # 0x5f6c8
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::SplitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, 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>>>>*)
void SplitString(const ::std::string& str, char delimiter,
                 ::std::vector< ::std::string>* dest) {
  ::std::vector< ::std::string> parsed;
  ::std::string::size_type pos = 0;
  while (::testing::internal::AlwaysTrue()) {
    const ::std::string::size_type colon = str.find(delimiter, pos);
    if (colon == ::std::string::npos) {
      parsed.push_back(str.substr(pos));
      break;
    } else {
      parsed.push_back(str.substr(pos, colon - pos));
      pos = colon + 1;
    }
  }
  dest->swap(parsed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x40(%rsp)
movl %esi, %ebp
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x1d6a0
cmpq $-0x1, %rax
je 0x29c7a
movq %rax, %rbx
xorl %r15d, %r15d
movq %rsp, %r12
leaq 0x20(%rsp), %r13
movsbl %bpl, %ebp
movq %rbx, %rcx
subq %r15, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d490
movq %r13, %rdi
movq %r12, %rsi
callq 0x45c36
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x29c5e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %r15
incq %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x1d6a0
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x29c24
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x1d490
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x45c36
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29cb7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rax
leaq 0x20(%rsp), %rdi
movaps (%rdi), %xmm0
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rdx)
movups (%rdx), %xmm1
movups %xmm0, (%rdx)
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
callq 0x3f3b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x29d12
jmp 0x29d01
movq %rax, %rbx
jmp 0x29d24
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x29d24
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x20(%rsp), %rdi
callq 0x3f3b0
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x432ae
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x2a7db
movq 0x40(%rax), %r15
jmp 0x2a7ed
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43232
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x2ae11
cmpl $0x2b, %ebp
je 0x2adff
cmpl $0x20, %ebp
jne 0x2ae45
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x3e41a
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x2ae21
incq 0x10(%rbx)
movl $0x50, %r12d
movl $0x40, %r15d
jmp 0x2ae21
incq 0x18(%rbx)
movl $0x68, %r12d
movl $0x58, %r15d
addq %rbx, %r15
movl $0x20, %edi
callq 0x1d430
movb %bpl, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x1d090
incq (%rbx,%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::(anonymous namespace)::SplitEscapedString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::string> SplitEscapedString(const std::string& str) {
  std::vector<std::string> lines;
  size_t start = 0, end = str.size();
  if (end > 2 && str[0] == '"' && str[end - 1] == '"') {
    ++start;
    --end;
  }
  bool escaped = false;
  for (size_t i = start; i + 1 < end; ++i) {
    if (escaped) {
      escaped = false;
      if (str[i] == 'n') {
        lines.push_back(str.substr(start, i - start - 1));
        start = i + 1;
      }
    } else {
      escaped = str[i] == '\\';
    }
  }
  lines.push_back(str.substr(start, end - start));
  return lines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x2b1d0
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x2b1d0
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x2b1d2
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x2b247
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x2b235
cmpb $0x6e, %cl
jne 0x2b23d
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d490
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45c36
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b22e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x2b23f
cmpb $0x5c, %cl
sete %al
jmp 0x2b23f
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x2b1e7
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1d490
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x45c36
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b282
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x2b2b3
jmp 0x2b2c5
jmp 0x2b2c2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b2c5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2b2c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f3b0
movq %r14, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq %r8, %rcx
jne 0x2b65f
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x2b6d2
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x464b5
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x464b5
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2aec2
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b6b7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b6d2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b702
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2b702
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b71d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
testq %rcx, %rcx
sete %al
testq %r8, %r8
sete %dl
orb %al, %dl
je 0x2cf56
orq %r8, %rcx
jne 0x2cf65
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x2cfd2
movq %rcx, %rdi
movq %r8, %rsi
callq 0x1d660
testl %eax, %eax
je 0x2cf49
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x40716
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x40716
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2aec2
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cfb7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cfd2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d002
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2d002
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d01d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::MakeAndRegisterTestInfo(char const*, char const*, char const*, char const*, testing::internal::CodeLocation, void const*, void (*)(), void (*)(), testing::internal::TestFactoryBase*)
TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    CodeLocation code_location,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   code_location, fixture_class_id, factory);
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %rbx
movl $0x108, %edi            # imm = 0x108
callq 0x1d430
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rbx, %rsi
callq 0x3f45c
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x3f45c
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x20896
movq 0xc0(%rsp), %rax
movl 0x20(%r13), %ecx
leaq 0x50(%rsp), %r9
movl %ecx, 0x20(%r9)
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq %rax
pushq %r14
callq 0x2e638
addq $0x10, %rsp
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e9ab
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e9c6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e9f1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
callq 0x27be6
movq 0x31e0b(%rip), %rdi     # 0x60808
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x40e9a
movq %r13, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2ea3c
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2ea3c
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea5c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2ea5c
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ea7c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2ea7c
movq %rax, %r14
movl $0x108, %esi            # imm = 0x108
movq 0x8(%rsp), %rdi
callq 0x1d460
movq %r14, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::ColoredPrintf(testing::internal::GTestColor, char const*, ...)
void ColoredPrintf(GTestColor color, const char* fmt, ...) {
  va_list args;
  va_start(args, fmt);

#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || \
    GTEST_OS_IOS || GTEST_OS_WINDOWS_PHONE || GTEST_OS_WINDOWS_RT
  const bool use_color = AlwaysFalse();
#else
  static const bool in_color_mode =
      ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0);
  const bool use_color = in_color_mode && (color != COLOR_DEFAULT);
#endif  // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS
  // The '!= 0' comparison is necessary to satisfy MSVC 7.1.

  if (!use_color) {
    vprintf(fmt, args);
    va_end(args);
    return;
  }

#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE && \
    !GTEST_OS_WINDOWS_PHONE && !GTEST_OS_WINDOWS_RT
  const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);

  // Gets the current text color.
  CONSOLE_SCREEN_BUFFER_INFO buffer_info;
  GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
  const WORD old_color_attrs = buffer_info.wAttributes;

  // We need to flush the stream buffers into the console before each
  // SetConsoleTextAttribute call lest it affect the text that is already
  // printed but has not yet reached the console.
  fflush(stdout);
  SetConsoleTextAttribute(stdout_handle,
                          GetColorAttribute(color) | FOREGROUND_INTENSITY);
  vprintf(fmt, args);

  fflush(stdout);
  // Restores the text color.
  SetConsoleTextAttribute(stdout_handle, old_color_attrs);
#else
  printf("\033[0;3%sm", GetAnsiColorCode(color));
  vprintf(fmt, args);
  printf("\033[m");  // Resets the terminal to default.
#endif  // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE
  va_end(args);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2f965
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsp)
movb 0x30e35(%rip), %al      # 0x607c0
testb %al, %al
je 0x2f9f2
testl %ebp, %ebp
je 0x2f9b2
cmpb $0x0, 0x30e1e(%rip)     # 0x607b8
je 0x2f9b2
cmpl $0x3, %ebp
ja 0x2f9bf
movslq %ebp, %rax
leaq 0x300c5(%rip), %rcx     # 0x5fa70
movq -0x8(%rcx,%rax,8), %rsi
jmp 0x2f9c1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d470
jmp 0x2f9e8
xorl %esi, %esi
leaq 0x1c378(%rip), %rdi     # 0x4bd40
xorl %eax, %eax
callq 0x1d080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d470
leaq 0x1c368(%rip), %rdi     # 0x4bd49
xorl %eax, %eax
callq 0x1d080
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1dbfa
jmp 0x2f98f
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::PostFlagParsingInit()
void UnitTestImpl::PostFlagParsingInit() {
  // Ensures that this function does not execute more than once.
  if (!post_flag_parse_init_performed_) {
    post_flag_parse_init_performed_ = true;

#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
    // Register to send notifications about key process state changes.
    listeners()->Append(new GTEST_CUSTOM_TEST_EVENT_LISTENER_());
#endif  // defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)

#if GTEST_HAS_DEATH_TEST
    InitDeathTestSubprocessControlInfo();
    SuppressTestEventsIfInSubprocess();
#endif  // GTEST_HAS_DEATH_TEST

    // Registers parameterized tests. This makes parameterized tests
    // available to the UnitTest reflection API without running
    // RUN_ALL_TESTS.
    RegisterParameterizedTests();

    // Configures listeners for XML output. This makes it possible for users
    // to shut down the default XML output before invoking RUN_ALL_TESTS.
    ConfigureXmlOutput();

#if GTEST_CAN_STREAM_RESULTS_
    // Configures listeners for streaming test results to the specified server.
    ConfigureStreamingOutput();
#endif  // GTEST_CAN_STREAM_RESULTS_
  }
}

// Assembly:
cmpb $0x0, 0x1b0(%rdi)
je 0x352ec
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
leaq 0x1d0(%rdi), %r14
callq 0x3c7b3
movq %r14, %rdi
movq %rax, %rsi
callq 0x45316
cmpq $0x0, 0x1d0(%rbx)
je 0x35326
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
cmpb $0x0, 0x100(%rbx)
jne 0x35355
movq 0xe8(%rbx), %r14
cmpq 0xf0(%rbx), %r14
je 0x3534e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x35336
movb $0x1, 0x100(%rbx)
movq %rbx, %rdi
callq 0x35022
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35158
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x1d270
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0x1d230
testq %rax, %rax
leaq 0xf4e2(%rip), %r15      # 0x4be9a
cmovneq %r14, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1d1e0
leaq (%rax,%r15), %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x45704
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f40e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3ca01
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x1028, %rsp           # imm = 0x1028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3ca2c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-printers.cc
// Function: testing::internal::PrintTo(wchar_t const*, std::ostream*)
void PrintTo(const wchar_t* s, ostream* os) {
  if (s == NULL) {
    *os << "NULL";
  } else {
    *os << ImplicitCast_<const void*>(s) << " pointing to ";
    PrintCharsAsStringTo(s, std::wcslen(s), os);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3dc21
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d360
leaq 0xeddc(%rip), %rsi      # 0x4c9d6
movl $0xd, %edx
movq %rax, %rdi
callq 0x1d540
movq %r14, %rdi
callq 0x1d3b0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3dc3c
leaq 0xeda9(%rip), %rsi      # 0x4c9d1
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d540
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  // We don't want to run the initialization code twice.
  if (GTestIsInitialized()) return;

  if (*argc <= 0) return;

  g_argvs.clear();
  for (int i = 0; i != *argc; i++) {
    g_argvs.push_back(StreamableToString(argv[i]));
  }

  ParseGoogleTestFlagsOnly(argc, argv);
  GetUnitTestImpl()->PostFlagParsingInit();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq 0x1e5b6(%rip), %rsi     # 0x60798
cmpq %rsi, 0x1e5b7(%rip)     # 0x607a0
jne 0x42281
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x42281
movq %rax, (%rsp)
leaq 0x1e592(%rip), %rdi     # 0x60798
callq 0x47f60
cmpl $0x0, (%r14)
je 0x42264
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x1e574(%rip), %r12     # 0x60798
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x47e65
movq %r12, %rdi
movq %r15, %rsi
callq 0x45c36
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42255
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x42228
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x41eec
callq 0x27be6
movq 0x1e58c(%rip), %rdi     # 0x60808
callq 0x352e2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x422aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const
T* GetOrCreateValue() const {
    ThreadLocalValueHolderBase* const holder =
        static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
    if (holder != NULL) {
      return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
    }

    ValueHolder* const new_holder = default_factory_->MakeNewHolder();
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x1d7a0
testq %rax, %rax
je 0x4387d
movq %rax, %rdi
callq 0x43923
movq %rax, %rbx
jmp 0x438fe
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x1d0d0
testl %eax, %eax
je 0x438fe
movl %eax, %ebp
leaq 0x9205(%rip), %rdx      # 0x4caa7
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x824, %ecx            # imm = 0x824
callq 0x3d4cc
movq 0x1c733(%rip), %rdi     # 0x5fff0
leaq 0x9455(%rip), %rsi      # 0x4cd19
movl $0x26, %edx
callq 0x1d540
movq 0x1c71b(%rip), %rdi     # 0x5fff0
leaq 0x9270(%rip), %rsi      # 0x4cb4c
movl $0x12, %edx
callq 0x1d540
movq 0x1c703(%rip), %rdi     # 0x5fff0
movl %ebp, %esi
callq 0x1d8c0
leaq 0xc(%rsp), %rdi
callq 0x3d60e
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3d60e
movq %rbx, %rdi
callq 0x1d900