LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x64
popq %rcx
pushq $0x1
popq %r9
xorl %esi, %esi
xorl %edx, %edx
movl %ecx, %r8d
callq 0x2d322
leaq 0x10(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movw $0x101, (%rsi)          # imm = 0x101
movb $0x1, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b09a
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x27ed2
leaq 0x1a43c(%rip), %rsi     # 0x45502
leaq 0x1a425(%rip), %rdx     # 0x454f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x281b7
leaq 0x20(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x10(%rsp)
jne 0x2b14c
leaq 0x20(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2b10b
movq (%rax), %r8
jmp 0x2b112
leaq 0x1cd58(%rip), %r8      # 0x47e6a
leaq 0x1aade(%rip), %rdx     # 0x45bf7
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x3c
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x20(%rsp), %rdi
callq 0x27e3a
leaq 0x18(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x2b17a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e3a
jmp 0x2b189
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e80
jmp 0x2b1a7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
jmp 0x2b1a7
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2b1e5
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b1ba
jmp 0x2b1e5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x2b1e5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
pushq $0x1
popq %rbp
xorl %esi, %esi
xorl %edx, %edx
movl %ebp, %ecx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x2d322
movq 0x10(%rbx), %rdi
pushq $0x2
popq %rdx
movl %ebp, %esi
movl %ebp, %ecx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0x2d322
leaq 0x18(%rsp), %rsi
movw $0x1, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0xf(%rsp), %rcx
callq 0x2795e
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x1, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0xe(%rsp), %rcx
callq 0x2795e
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b2e1
movq 0x10(%rbx), %rsi
leaq 0x28(%rsp), %rdi
callq 0x27ed2
leaq 0x1a1f5(%rip), %rsi     # 0x45502
leaq 0x1a1de(%rip), %rdx     # 0x454f2
leaq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x281b7
leaq 0x28(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x18(%rsp)
jne 0x2b393
leaq 0x28(%rsp), %rdi
callq 0x2f572
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x2b352
movq (%rax), %r8
jmp 0x2b359
leaq 0x1cb11(%rip), %r8      # 0x47e6a
leaq 0x1a897(%rip), %rdx     # 0x45bf7
leaq 0x10(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x49
popq %rcx
callq 0x2dddc
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2de5a
leaq 0x10(%rsp), %rdi
callq 0x2de3c
leaq 0x28(%rsp), %rdi
callq 0x27e3a
leaq 0x20(%rsp), %rdi
callq 0x27e80
leaq 0x58(%rsp), %rdi
callq 0x279ce
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2de3c
jmp 0x2b3c2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27e3a
jmp 0x2b3d1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e80
jmp 0x2b3ef
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x279ce
jmp 0x2b3ef
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x279ce
jmp 0x2b42d
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b402
jmp 0x2b42d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x27a48
jmp 0x2b42d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rdx
pushq $0x1
popq %rcx
movl %edx, %esi
movl %ecx, %r8d
movl %ecx, %r9d
callq 0x2d322
leaq 0x10(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
leaq 0x7(%rsp), %rcx
callq 0x2795e
leaq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
andw $0x0, (%rsi)
movb $0x0, 0x2(%rsi)
pushq $0x3
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x2795e
leaq 0x50(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0x5(%rsp), %rcx
callq 0x27994
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b510
movq 0x10(%rbx), %rsi
leaq 0x20(%rsp), %rdi
callq 0x27ed2
leaq 0x19fc6(%rip), %rsi     # 0x45502
leaq 0x19faf(%rip), %rdx     # 0x454f2
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
leaq 0x20(%rsp), %r8
callq 0x281b7
leaq 0x20(%rsp), %rdi
callq 0x279ce
cmpb $0x0, 0x10(%rsp)
jne 0x2b5c2
leaq 0x20(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x2b581
movq (%rax), %r8
jmp 0x2b588
leaq 0x1c8e2(%rip), %r8      # 0x47e6a
leaq 0x1a668(%rip), %rdx     # 0x45bf7
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x55
popq %rcx
callq 0x2dddc
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2de5a
leaq 0x8(%rsp), %rdi
callq 0x2de3c
leaq 0x20(%rsp), %rdi
callq 0x27e3a
leaq 0x18(%rsp), %rdi
callq 0x27e80
leaq 0x50(%rsp), %rdi
callq 0x279ce
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2de3c
jmp 0x2b5f0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27e3a
jmp 0x2b5ff
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e80
jmp 0x2b61d
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
jmp 0x2b61d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x279ce
jmp 0x2b65b
movq %rax, %rbx
pushq $0x18
popq %r14
leaq (%rsp,%r14), %rdi
addq $0x20, %rdi
callq 0x27a48
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0x2b630
jmp 0x2b65b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x27a48
jmp 0x2b65b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
movslq %esi, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2c852
movslq %r14d, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xe(%rsp), %rcx
callq 0x2c8a4
leaq 0x10(%rsp), %rdi
callq 0x27a48
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2cdd8
movl %r14d, 0x1c(%rbx)
movl %ebp, 0x18(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x279ce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x279ce
jmp 0x2d312
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x27a48
jmp 0x2d312
movq %rax, %r14
movq %rbx, %rdi
callq 0x279ce
movq %r14, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/mock/lcd_controller_mock.cpp
// Function: LCDController::fillRect(int, int, int, int, unsigned char)
void LCDController::fillRect(int v_pos, int h_pos, int v_len, int h_len, uint8_t cell_val)
{
    int v_pos_end = v_pos + v_len;
    int h_pos_end = h_pos + h_len;
    for(int v_idx=v_pos; v_idx<v_pos_end; v_idx++){
        for(int h_idx=h_pos; h_idx<h_pos_end; h_idx++){
            if(v_idx < 0 || v_idx >= height_) continue;
            if(h_idx < 0 || h_idx >= width_) continue;
            state_[v_idx][h_idx] = cell_val;
        }
    }
}

// Assembly:
pushq %rbx
addl %esi, %ecx
addl %edx, %r8d
cmpl %ecx, %esi
jge 0x2d365
movl %esi, %eax
imulq $0x18, %rax, %rax
movl %edx, %r10d
cmpl %r8d, %r10d
jge 0x2d361
testl %esi, %esi
js 0x2d35c
testl %r10d, %r10d
js 0x2d35c
cmpl 0x1c(%rdi), %esi
jge 0x2d35c
cmpl 0x18(%rdi), %r10d
jge 0x2d35c
movq (%rdi), %r11
movl %r10d, %ebx
movq (%r11,%rax), %r11
movb %r9b, (%r11,%rbx)
incl %r10d
jmp 0x2d335
incl %esi
jmp 0x2d328
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movl %r8d, %ebx
movl %ecx, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rsi), %rcx
movq %rsi, 0x20(%rsp)
movq 0x8(%rsi), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movl 0x8(%rcx), %edx
subl (%rcx), %edx
xorl %r14d, %r14d
testl %eax, %eax
cmovlel %r14d, %eax
testl %edx, %edx
cmovlel %r14d, %edx
movq %rdx, 0x10(%rsp)
imulq $0x18, %rax, %r15
cmpq 0x10(%rsp), %r14
je 0x2d4ca
movl %r14d, %r13d
imull %ebx, %r13d
addl 0x8(%rsp), %r13d
xorl %r12d, %r12d
movl 0xc(%rsp), %ebp
cmpq %r12, %r15
je 0x2d4c5
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax,%r12), %rax
movzbl (%rax,%r14), %r9d
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl %ebp, %esi
movl %r13d, %edx
movl %ebx, %ecx
movl %ebx, %r8d
callq 0x2d322
addl %ebx, %ebp
addq $0x18, %r12
jmp 0x2d490
incq %r14
jmp 0x2d476
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/pixel_art_m5stack/src/pixel_art_manager.cpp
// Function: PixelArtManager::drawNextFrame(OperationType)
void PixelArtManager::drawNextFrame(OperationType operation)
{

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %esi, %ecx
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
movq %rdi, %rax
subq %rsi, %rax
pushq $0x28
popq %r8
cqto
idivq %r8
cmpq %rsi, %rdi
je 0x2d5d1
movl 0x20(%rbx), %edx
cmpl $0x1, %ecx
jne 0x2d567
incl %edx
movl %edx, 0x20(%rbx)
movslq %edx, %rcx
cmpq %rcx, %rax
ja 0x2d575
andl $0x0, 0x20(%rbx)
xorl %edx, %edx
movslq %edx, %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x2d3e4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x27ed2
movl 0x24(%rbx), %edx
movl 0x28(%rbx), %ecx
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rsi
imulq $0x28, %rax, %rax
movl 0x20(%rsi,%rax), %r8d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2d424
leaq 0x8(%rsp), %rdi
callq 0x279ce
leaq 0x20(%rsp), %rdi
callq 0x279ce
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x279ce
jmp 0x2d5eb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x279ce
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x25460
movq %rax, %r14
leaq 0x31c58(%rip), %rax     # 0x5f548
movl (%rax), %esi
leaq 0x31c53(%rip), %rax     # 0x5f54c
movl (%rax), %edx
movq %r14, %rdi
callq 0x2d27c
movq %r14, 0x31d9e(%rip)     # 0x5f6a8
pushq $0x30
popq %rdi
callq 0x25460
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2d410
movq %r15, 0x31d89(%rip)     # 0x5f6b0
xorl %ebp, %ebp
movq %rsp, %r14
leaq 0x18(%rsp), %r15
xorl %ebx, %ebx
leaq 0x31d1e(%rip), %rax     # 0x5f658
movq (%rax), %r13
movq 0x8(%rax), %rax
subq %r13, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x2d9b7
pushq $0x20
popq %rdi
callq 0x25460
movq %rax, %r12
addq %rbp, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x2a7fa
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d37c
movq %r14, %rdi
callq 0x27f66
movq 0x31d2c(%rip), %r13     # 0x5f6b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a7da
leaq 0x31ce2(%rip), %rax     # 0x5f678
movl (%rax), %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x2d4da
movq %r15, %rdi
callq 0x27f66
incq %rbx
addq $0x18, %rbp
jmp 0x2d933
movq 0x31cf2(%rip), %rdi     # 0x5f6b0
leaq 0x31cab(%rip), %rax     # 0x5f670
movl (%rax), %esi
leaq 0x31ca6(%rip), %rax     # 0x5f674
movl (%rax), %edx
callq 0x2d5fe
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r15, %rdi
jmp 0x2da1f
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
jmp 0x2da1f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27f66
jmp 0x2da24
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27f66
jmp 0x2da19
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x25490
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bb1a
movq (%r14), %rdi
callq 0x25610
testq %rax, %rax
je 0x2da84
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x2da84
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x25a68
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3bb1a
movq (%r12), %rdi
callq 0x25610
testq %rax, %rax
je 0x2dad9
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x27910
jmp 0x2db42
leaq 0x18bee(%rip), %rsi     # 0x466ce
movq %r15, %rdi
callq 0x25750
testl %eax, %eax
je 0x2dafe
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27910
jmp 0x2db42
leaq 0x1ae87(%rip), %rdi     # 0x4898c
callq 0x25610
testq %rax, %rax
je 0x2daec
movq %rax, %r15
leaq 0x1ae83(%rip), %rsi     # 0x4899c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27910
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3cc07
leaq 0x8(%rsp), %rdi
callq 0x25a68
leaq 0x28(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25a68
jmp 0x2db71
jmp 0x2db6e
jmp 0x2db6e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x3bb1a
movq (%r14), %rdi
callq 0x25610
testq %rax, %rax
je 0x2dc6d
movq %rax, %r14
movl %ebx, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2f572
movq 0x18(%rsp), %r15
addq $0x10, %r15
leaq 0x1ad86(%rip), %rsi     # 0x48957
movq %r15, %rdi
callq 0x25440
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x253f0
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq 0x37d37
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x27e3a
testb %bpl, %bpl
je 0x2dc0f
movl 0xc(%rsp), %ebx
jmp 0x2dc6d
leaq 0x10(%rsp), %rdi
callq 0x2f572
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x25910
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x2f747
leaq 0x18(%rsp), %r14
movq (%r14), %rsi
leaq 0x1ad28(%rip), %rdi     # 0x4896d
xorl %eax, %eax
callq 0x25070
movq %r14, %rdi
callq 0x25a68
leaq 0x10(%rsp), %rdi
callq 0x27e3a
movq 0x31333(%rip), %rax     # 0x5ef98
movq (%rax), %rdi
callq 0x255b0
leaq 0x38(%rsp), %rdi
callq 0x25a68
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2dc90
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x2dc9d
movq %rax, %rbx
jmp 0x2dca2
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27e3a
leaq 0x38(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2f3e2
movl 0x31429(%rip), %edx     # 0x5f738
incl %ebx
movq (%rax), %r8
movq %r14, %rdi
movq %rax, %rsi
movl %ebx, %ecx
callq *0x10(%r8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x3cbc4
movq 0x31476(%rip), %rsi     # 0x5f7c0
leaq 0x20(%rsp), %rdi
callq 0x3cbd8
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x25270
leaq 0x20(%rsp), %rdi
callq 0x25a68
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2e3ac
movq %rsp, %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x2e398
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x25a68
jmp 0x2e39b
movq %rax, %rbx
movq %rsp, %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f3ef
retq
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rdi
callq 0x25460
leaq 0x2f2c6(%rip), %rcx     # 0x5e6c8
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
xorl %ebx, %ebx
movsbl %sil, %ebp
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x256e0
cmpq $-0x1, %rax
je 0x2f4e0
movq %rax, %r13
movq %rax, %rcx
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x254c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x41fb2
movq %r12, %rdi
callq 0x25a68
incq %r13
movq %r13, %rbx
jmp 0x2f49b
leaq 0x10(%rsp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x254c0
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x41fb2
leaq 0x10(%rsp), %rdi
callq 0x25a68
movq 0x8(%rsp), %rdx
movq 0x10(%rdx), %rax
leaq 0x30(%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 0x3cba2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f54f
jmp 0x2f54a
movq %rax, %rbx
jmp 0x2f55c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25a68
leaq 0x30(%rsp), %rdi
callq 0x3cba2
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::edit_distance::CalculateOptimalEdits(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::vector<EditType> CalculateOptimalEdits(
    const std::vector<std::string>& left,
    const std::vector<std::string>& right) {
  std::vector<size_t> left_ids, right_ids;
  {
    InternalStrings intern_table;
    for (size_t i = 0; i < left.size(); ++i) {
      left_ids.push_back(intern_table.GetId(left[i]));
    }
    for (size_t i = 0; i < right.size(); ++i) {
      right_ids.push_back(intern_table.GetId(right[i]));
    }
  }
  return CalculateOptimalEdits(left_ids, right_ids);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x28(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x50(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %ebx, %ebx
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %rbp
xorl %r12d, %r12d
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r12
jae 0x2fcf6
addq %rbx, %rsi
movq %r13, %rdi
callq 0x2fdb8
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
movq %rbp, %rsi
callq 0x4281e
incq %r12
addq $0x20, %rbx
jmp 0x2fcbd
xorl %ebp, %ebp
leaq 0x48(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x8(%rsp), %r13
xorl %ebx, %ebx
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbx
jae 0x2fd40
addq %rbp, %rsi
movq %r15, %rdi
callq 0x2fdb8
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4281e
incq %rbx
addq $0x20, %rbp
jmp 0x2fd09
leaq 0x48(%rsp), %rdi
callq 0x405dc
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x2f8f5
leaq 0x10(%rsp), %rdi
callq 0x427ea
leaq 0x30(%rsp), %rdi
callq 0x427ea
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2fd9b
jmp 0x2fd8e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x405dc
leaq 0x10(%rsp), %rdi
callq 0x427ea
leaq 0x30(%rsp), %rdi
callq 0x427ea
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x401be
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x2fdd7
movq 0x40(%rax), %r15
jmp 0x2fde9
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40158
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x2d, %esi
je 0x30298
cmpl $0x2b, %esi
je 0x30286
cmpl $0x20, %esi
jne 0x302b4
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x3c3b8
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
jmp 0x302a8
incq 0x10(%rbx)
addq $0x40, %rbx
leaq 0x8(%rsp), %rsi
movb $0x2b, (%rsi)
jmp 0x302a8
incq 0x18(%rbx)
addq $0x58, %rbx
leaq 0x8(%rsp), %rsi
movb $0x2d, (%rsi)
movq %r14, 0x8(%rsi)
movq %rbx, %rdi
callq 0x40626
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq 0x8(%rsi), %r15
cmpq $0x3, %r15
jb 0x3056d
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x3056d
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x3056f
xorl %edx, %edx
pushq $0x1
popq %r13
leaq 0x8(%rsp), %r12
movq (%r14), %rax
addq %rdx, %rax
xorl %esi, %esi
movq %r13, %rcx
leaq (%rdx,%rcx), %rbp
cmpq %r15, %rbp
jae 0x305d5
movb -0x1(%rax,%rcx), %dil
testb $0x1, %sil
je 0x305a1
cmpb $0x6e, %dil
je 0x305ae
xorl %esi, %esi
jmp 0x305a9
cmpb $0x5c, %dil
sete %sil
incq %rcx
jmp 0x30583
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x254c0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x41fb2
movq %r12, %rdi
callq 0x25a68
movq %rbp, %rdx
jmp 0x30578
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x254c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x41fb2
leaq 0x8(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30615
jmp 0x30624
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x25a68
jmp 0x30627
movq %rax, %r14
movq %rbx, %rdi
callq 0x3cba2
movq %r14, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 0x30941
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x30992
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x42ac7
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x42ac7
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x302df
leaq 0x10(%rsp), %rdi
callq 0x25a68
leaq 0x30(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25a68
jmp 0x309b1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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)
movq %rcx, %rdi
movq %r8, %rsi
callq 0x31d70
testb %al, %al
je 0x31dcf
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
jmp 0x31e1a
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3db56
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x3db56
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x302df
leaq 0x10(%rsp), %rdi
callq 0x25a68
leaq 0x30(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25a68
jmp 0x31e39
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8(%rsp)
movq %r8, %r13
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r14
movl $0x108, %edi            # imm = 0x108
callq 0x25460
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x27910
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x27910
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
callq 0x3e1e4
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rcx
movq %r15, %r8
pushq 0xc0(%rsp)
pushq 0x10(%rsp)
callq 0x32e5c
popq %rax
popq %rcx
movq 0xb8(%rsp), %r14
movq 0xb0(%rsp), %r15
leaq 0x50(%rsp), %rdi
callq 0x25a68
leaq 0x10(%rsp), %rdi
callq 0x25a68
leaq 0x30(%rsp), %rdi
callq 0x25a68
callq 0x3cc5e
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3e20a
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x25a68
jmp 0x330e3
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x25a68
jmp 0x330f2
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x25a68
jmp 0x33101
movq %rax, %r14
movl $0x108, %esi            # imm = 0x108
movq %rbx, %rdi
callq 0x25490
movq %r14, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::ReportInvalidTestCaseType(char const*, testing::internal::CodeLocation)
void ReportInvalidTestCaseType(const char* test_case_name,
                               CodeLocation code_location) {
  Message errors;
  errors
      << "Attempted redefinition of test case " << test_case_name << ".\n"
      << "All tests in the same test case must use the same test fixture\n"
      << "class.  However, in test case " << test_case_name << ", you tried\n"
      << "to define a test using a fixture class different from the one\n"
      << "used earlier. This can happen if the two fixture classes are\n"
      << "from different namespaces and have the same name. You should\n"
      << "probably rename one of the classes to put the tests into different\n"
      << "test cases.";

  fprintf(stderr, "%s %s",
          FormatFileLocation(code_location.file.c_str(),
                             code_location.line).c_str(),
          errors.GetString().c_str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rsp, %r14
movq %r14, %rdi
callq 0x2f572
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x149ae(%rip), %rsi     # 0x47aee
callq 0x25440
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3d17e
leaq 0x14c6d(%rip), %rsi     # 0x47dc6
movq %rax, %rdi
callq 0x3d1f0
leaq 0x14716(%rip), %rsi     # 0x4787e
movq %rax, %rdi
callq 0x3e008
leaq 0x14823(%rip), %rsi     # 0x4799a
movq %rax, %rdi
callq 0x3e08c
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3d17e
leaq 0x14980(%rip), %rsi     # 0x47b13
movq %rax, %rdi
callq 0x3d1c4
leaq 0x1497e(%rip), %rsi     # 0x47b20
movq %rax, %rdi
callq 0x3e0a2
leaq 0x149ae(%rip), %rsi     # 0x47b5f
movq %rax, %rdi
callq 0x3e076
leaq 0x149dd(%rip), %rsi     # 0x47b9d
movq %rax, %rdi
callq 0x3e076
leaq 0x14a0c(%rip), %rsi     # 0x47bdb
movq %rax, %rdi
callq 0x3e2fe
leaq 0x148e3(%rip), %rsi     # 0x47ac1
movq %rax, %rdi
callq 0x3d1da
movq 0x2bdd3(%rip), %rax     # 0x5efc0
movq (%rax), %r14
movq (%rbx), %rsi
movl 0x20(%rbx), %edx
leaq 0x10(%rsp), %rdi
callq 0x33277
movq 0x10(%rsp), %rbx
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x2f747
leaq 0x30(%rsp), %r15
movq (%r15), %rcx
leaq 0x149fd(%rip), %rsi     # 0x47c1f
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x25770
movq %r15, %rdi
callq 0x25a68
leaq 0x10(%rsp), %rdi
callq 0x25a68
movq %rsp, %rdi
callq 0x27e3a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25a68
jmp 0x33267
jmp 0x33264
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27e3a
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
leaq 0x30(%rsp), %r14
movl $0x1001, %edx           # imm = 0x1001
movq %r14, %rdi
xorl %esi, %esi
callq 0x25280
movl $0x1001, %esi           # imm = 0x1001
movq %r14, %rdi
callq 0x25240
testq %rax, %rax
leaq 0xcca2(%rip), %rsi      # 0x47e6a
cmovneq %r14, %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x27910
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3cbd8
leaq 0x10(%rsp), %rdi
callq 0x25a68
movq %rbx, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x25a68
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3be2f
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25370
leaq 0xcb99(%rip), %rsi      # 0x489a6
movq %rax, %rdi
callq 0x25440
movq %r14, %rdi
callq 0x253c0
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3be45
leaq 0xcb6b(%rip), %rsi      # 0x489a1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x25440
// File: /workspace/github_cpp_makefile_star2_O2/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 0x257f0
testq %rax, %rax
je 0x4095a
movq %rax, %rdi
callq 0x409ec
movq %rax, %rbx
jmp 0x409c7
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x250d0
testl %eax, %eax
je 0x409c7
movl %eax, %ebp
leaq 0x80f8(%rip), %rdx      # 0x48a77
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x824, %ecx            # imm = 0x824
callq 0x3b888
movq 0x1e650(%rip), %rdi     # 0x5efe8
leaq 0x834a(%rip), %rsi      # 0x48ce9
callq 0x25440
leaq 0x8171(%rip), %rsi      # 0x48b1c
movq %rax, %rdi
callq 0x25440
movq %rax, %rdi
movl %ebp, %esi
callq 0x25910
leaq 0xc(%rsp), %rdi
callq 0x3b94c
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3b94c
movq %rbx, %rdi
callq 0x25930
// File: /workspace/github_cpp_makefile_star2_O2/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>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x40a63
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rdi
leaq 0x1e179(%rip), %rsi     # 0x5eb80
callq 0x40a7e
testb %al, %al
jne 0x40a46
leaq 0x8060(%rip), %rdx      # 0x48a77
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x572, %ecx            # imm = 0x572
callq 0x3b888
movq 0x1e5b8(%rip), %rdi     # 0x5efe8
leaq 0x82d9(%rip), %rsi      # 0x48d10
callq 0x25440
leaq 0xc(%rsp), %rdi
callq 0x3b94c
leaq 0x1e123(%rip), %rsi     # 0x5eb70
leaq 0x1e12c(%rip), %rdx     # 0x5eb80
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x25560
callq 0x25520
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3b94c
movq %rbx, %rdi
callq 0x25930
nop
// File: /workspace/github_cpp_makefile_star2_O2/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::StripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
inline std::string StripTrailingSpaces(std::string str) {
  std::string::iterator it = str.end();
  while (it != str.begin() && IsSpace(*--it))
    it = str.erase(it);
  return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %r15
addq %rax, %r15
cmpq %rax, %r15
je 0x41aae
movsbl -0x1(%r15), %edi
callq 0x41b38
testb %al, %al
je 0x41aae
decq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x25640
movq %rax, %r15
movq (%r14), %rax
jmp 0x41a85
movq %rbx, %rdi
movq %r14, %rsi
callq 0x256c0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq