LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x37f25(%rip), %rsi     # 0x60798
leaq 0x28(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1d260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x288a7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2891a
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x288cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x288f8
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x288fb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x288fb
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x28912
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::UnitTestImpl::os_stack_trace_getter()
OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
  if (os_stack_trace_getter_ == NULL) {
#ifdef GTEST_OS_STACK_TRACE_GETTER_
    os_stack_trace_getter_ = new GTEST_OS_STACK_TRACE_GETTER_;
#else
    os_stack_trace_getter_ = new OsStackTraceGetter;
#endif  // GTEST_OS_STACK_TRACE_GETTER_
  }

  return os_stack_trace_getter_;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x1a8(%rdi)
jne 0x2a253
movl $0x8, %edi
callq 0x1d430
leaq 0x3547f(%rip), %rcx     # 0x5f6c8
movq %rcx, (%rax)
movq %rax, 0x1a8(%rbx)
movq 0x1a8(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x28(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
xorl %ebx, %ebx
movsbl %sil, %ebp
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1d6a0
movq %rax, %r13
cmpq $-0x1, %rax
je 0x2a351
movq %r13, %rcx
subq %rbx, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1d490
movq %r15, %rdi
movq %r12, %rsi
callq 0x46728
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a34b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x1(%r13), %rbx
jmp 0x2a38d
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x1d490
movq %r15, %rdi
movq %r12, %rsi
callq 0x46728
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a38d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
cmpq $-0x1, %r13
jne 0x2a2fa
movq 0x28(%rsp), %rdx
movups (%rdx), %xmm0
movq 0x10(%rdx), %rax
leaq 0x30(%rsp), %rdi
movq (%rdi), %rcx
movq %rcx, (%rdx)
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdx)
movq 0x10(%rdi), %rcx
movq %rcx, 0x10(%rdx)
movaps %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
callq 0x3fdaa
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a3fe
jmp 0x2a3dd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a401
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2a401
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3fdaa
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 0x43db6
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x2aee3
movq 0x40(%rax), %r15
jmp 0x2aef5
movq 0x28(%r14), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43d3a
movq %r15, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2b4c7
cmpl $0x2b, %ebp
je 0x2b4b5
cmpl $0x20, %ebp
jne 0x2b4fb
incq 0x20(%rbx)
movq %rbx, %rdi
callq 0x3ee02
movl $0x38, %r12d
movl $0x28, %r15d
jmp 0x2b4d7
incq 0x10(%rbx)
movl $0x50, %r12d
movl $0x40, %r15d
jmp 0x2b4d7
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_O1/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 0x2b8c5
movq (%r14), %rax
cmpb $0x22, (%rax)
jne 0x2b8c5
xorl %edx, %edx
cmpb $0x22, -0x1(%rax,%r15)
leaq -0x1(%r15), %rax
sete %dl
cmoveq %rax, %r15
jmp 0x2b8c7
xorl %edx, %edx
leaq 0x1(%rdx), %rbp
cmpq %r15, %rbp
jae 0x2b93c
leaq 0x18(%rsp), %r13
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq (%r14), %rcx
movb -0x1(%rcx,%rbp), %cl
testb $0x1, %al
je 0x2b92a
cmpb $0x6e, %cl
jne 0x2b932
movq %rbp, %rcx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d490
movq %rbx, %rdi
movq %r12, %rsi
callq 0x46728
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b923
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
xorl %eax, %eax
movq %rbp, %rdx
jmp 0x2b934
cmpb $0x5c, %cl
sete %al
jmp 0x2b934
xorl %eax, %eax
incq %rbp
cmpq %rbp, %r15
jne 0x2b8dc
subq %rdx, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x1d490
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x46728
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b977
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rax
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 0x2b9ab
jmp 0x2b9bd
jmp 0x2b9ba
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2b9bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2b9bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x3fdaa
movq %r14, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bd69
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x2bddc
movq %rdx, %r14
movq %rsi, %r15
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x46f9f
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x46f9f
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2b578
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bdc1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2bddc
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 0x2be0c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2be0c
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2be27
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 %r8, %r8
sete %al
testq %rcx, %rcx
je 0x2d676
testq %r8, %r8
je 0x2d687
movq %rcx, %rdi
movq %r8, %rsi
callq 0x1d660
testl %eax, %eax
sete %al
testb %al, %al
je 0x2d687
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
jmp 0x2d6f4
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x41256
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x41256
leaq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x2b578
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d6d9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d6f4
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 0x2d724
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2d724
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d73f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest.cc
// Function: testing::internal::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 0x3fe54
leaq 0x10(%rsp), %rdi
leaq 0x6(%rsp), %rdx
movq %rbp, %rsi
callq 0x3fe54
leaq 0x60(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x20cd0
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 0x2edd4
addq $0x10, %rsp
movq 0x50(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2f147
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d460
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f162
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 0x2f18d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
callq 0x28270
movq 0x3166f(%rip), %rdi     # 0x60808
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x419f0
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 0x2f1d8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2f1d8
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1f8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2f1f8
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f218
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1d460
jmp 0x2f218
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_O1/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 0x30164
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 0x30636(%rip), %al      # 0x607c0
testb %al, %al
je 0x301f1
testl %ebp, %ebp
je 0x301b1
cmpb $0x0, 0x3061f(%rip)     # 0x607b8
je 0x301b1
cmpl $0x3, %ebp
ja 0x301be
movslq %ebp, %rax
leaq 0x2f8c6(%rip), %rcx     # 0x5fa70
movq -0x8(%rcx,%rax,8), %rsi
jmp 0x301c0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d470
jmp 0x301e7
xorl %esi, %esi
leaq 0x1bb49(%rip), %rdi     # 0x4bd10
xorl %eax, %eax
callq 0x1d080
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d470
leaq 0x1bb39(%rip), %rdi     # 0x4bd19
xorl %eax, %eax
callq 0x1d080
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1dfba
jmp 0x3018e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35be4
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
leaq 0x1d0(%rdi), %r14
callq 0x3d12a
movq %r14, %rdi
movq %rax, %rsi
callq 0x45e26
cmpq $0x0, 0x1d0(%rbx)
je 0x35c1e
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
cmpb $0x0, 0x100(%rbx)
jne 0x35c4d
movq 0xe8(%rbx), %r14
cmpq 0xf0(%rbx), %r14
je 0x35c46
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x8, %r14
jmp 0x35c2e
movb $0x1, 0x100(%rbx)
movq %rbx, %rdi
callq 0x3592c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35a66
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeb3c(%rip), %r15      # 0x4be6a
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 0x4620c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fe06
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3d377
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 0x3d3a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/src/gtest-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 0x3e5df
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d360
leaq 0xe3ee(%rip), %rsi      # 0x4c9a6
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 0x3e5fa
leaq 0xe3bb(%rip), %rsi      # 0x4c9a1
movl $0x4, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d540
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1da30(%rip), %rsi     # 0x60798
cmpq %rsi, 0x1da31(%rip)     # 0x607a0
jne 0x42e07
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x42e07
movq %rax, (%rsp)
leaq 0x1da0c(%rip), %rdi     # 0x60798
callq 0x48ac4
cmpl $0x0, (%r14)
je 0x42dea
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x1d9ee(%rip), %r12     # 0x60798
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x489a3
movq %r12, %rdi
movq %r15, %rsi
callq 0x46728
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x42ddb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x42dae
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x42a72
callq 0x28270
movq 0x1da06(%rip), %rdi     # 0x60808
callq 0x35bda
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 0x42e30
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1d460
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/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 0x44385
movq %rax, %rdi
callq 0x4442b
movq %rax, %rbx
jmp 0x44406
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 0x44406
movl %eax, %ebp
leaq 0x86cd(%rip), %rdx      # 0x4ca77
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x824, %ecx            # imm = 0x824
callq 0x3de56
movq 0x1bc2b(%rip), %rdi     # 0x5fff0
leaq 0x891d(%rip), %rsi      # 0x4cce9
movl $0x26, %edx
callq 0x1d540
movq 0x1bc13(%rip), %rdi     # 0x5fff0
leaq 0x8738(%rip), %rsi      # 0x4cb1c
movl $0x12, %edx
callq 0x1d540
movq 0x1bbfb(%rip), %rdi     # 0x5fff0
movl %ebp, %esi
callq 0x1d8c0
leaq 0xc(%rsp), %rdi
callq 0x3df98
addq $0x8, %rbx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3df98
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/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 0x444c2
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x91a5(%rip), %rax      # 0x4d5f3
cmpq %rax, %rdi
je 0x444a5
cmpb $0x2a, (%rdi)
je 0x44468
leaq 0x9194(%rip), %rsi      # 0x4d5f3
callq 0x1d700
testl %eax, %eax
je 0x444a5
leaq 0x8608(%rip), %rdx      # 0x4ca77
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x572, %ecx            # imm = 0x572
callq 0x3de56
movq 0x1bb66(%rip), %rdi     # 0x5fff0
leaq 0x887f(%rip), %rsi      # 0x4cd10
movl $0x33, %edx
callq 0x1d540
leaq 0xc(%rsp), %rdi
callq 0x3df98
leaq 0x1b6c4(%rip), %rsi     # 0x5fb70
leaq 0x1b6cd(%rip), %rdx     # 0x5fb80
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x1d530
callq 0x1d4e0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3df98
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O1/chen3feng[P]error-handling/result.cpp
// Function: ParseInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Result<int, ErrnoError> ParseInt(const std::string& s) {
    errno = 0;
    char* end = const_cast<char*>(s.c_str());
    long n = strtol(s.c_str(), &end, 0);
    if (errno == 0) {
        if (*end != '\0') {
            errno = EINVAL;
        } else if (n > INT_MAX || n < INT_MIN) {
            errno = ERANGE;
        } else {
            return static_cast<int>(n);
        }
    }
    return ErrnoError(ErrnoType(errno));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2040
movq %rax, %r14
movl $0x0, (%rax)
movq (%r15), %rdi
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
xorl %edx, %edx
callq 0x2120
cmpl $0x0, (%r14)
jne 0x25c4
movq -0x20(%rbp), %rdx
movl $0x16, %ecx
cmpb $0x0, (%rdx)
jne 0x25c1
movslq %eax, %rdx
movl $0x22, %ecx
cmpq %rax, %rdx
je 0x262f
movl %ecx, (%r14)
movl (%r14), %r14d
movl $0x38, %edi
callq 0x20d0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x36f2(%rip), %rcx      # 0x5cd8
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x3794(%rip), %rdx      # 0x5d88
movq %rdx, 0x10(%rax)
movl %r14d, 0x18(%rax)
leaq 0x1a16(%rip), %rdx      # 0x4019
movq %rdx, 0x20(%rax)
movl $0x11a, 0x28(%rax)      # imm = 0x11A
leaq 0x1a18(%rip), %rdx      # 0x402d
movq %rdx, 0x30(%rax)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x2621
// File: /workspace/github_cpp_makefile_star2_O1/aempirei[P]Chat-Art/pgmtobraile.c
// Function: dither
void dither(uint8_t *data, size_t width, size_t height) {

	int *front;
	int *error;

	size_t sz = width * height;

	front = malloc(sizeof(int) * sz);
	error = malloc(sizeof(int) * sz);

	memset(error, 0, sizeof(int) * sz);

	for(size_t z = 0; z < sz; z++)
		front[z] = ((data[z] > 40) ? 128 : 32) - data[z];

	for(size_t y = 1; y < height - 1; y++) {
		for(size_t x = 1; x < width - 1; x++) {

			int d = BIT(front,x,y,width) / 6;

			BIT(error,x,y-1,width) += d;
			BIT(error,x-1,y,width) += d;
			BIT(error,x+1,y,width) += d;
			BIT(error,x,y+1,width) += d;

			BIT(error,x,y,width) -= d * 6;
		}
	}

	for(size_t z = 0; z < sz; z++) {
		int x = (int)data[z] + error[z];
		data[z] = (uint8_t)((x < 0) ? 0 : (x > 255) ? 255 : x);
	}

	free(front);
	free(error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, %r15
imulq %rsi, %r12
leaq (,%r12,4), %rbp
movq %rbp, %rdi
callq 0x10b0
movq %rax, %r14
movq %rbp, %rdi
callq 0x10b0
movq %rax, 0x8(%rsp)
movq %rax, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x1070
testq %r12, %r12
je 0x1340
xorl %eax, %eax
movl $0x80, %ecx
movzbl (%rbx,%rax), %edx
cmpl $0x29, %edx
movl $0x20, %esi
cmovael %ecx, %esi
subl %edx, %esi
movl %esi, (%r14,%rax,4)
incq %rax
cmpq %rax, %r12
jne 0x1323
movq %r14, 0x10(%rsp)
decq %r15
cmpq $0x2, %r15
jb 0x140f
movq %r15, %rax
leaq -0x1(%r13), %rcx
movq %rcx, 0x20(%rsp)
leaq (,%r13,4), %rcx
movq 0x8(%rsp), %r10
leaq (%r10,%r13,4), %r11
movq 0x10(%rsp), %rdx
leaq (%rdx,%r13,4), %rsi
leaq (%r10,%r13,8), %rdi
movl $0x1, %r8d
xorl %r9d, %r9d
movq %r11, 0x18(%rsp)
cmpq $0x2, 0x20(%rsp)
jb 0x13f4
movq %rcx, %rdx
imulq %r9, %rdx
movq 0x18(%rsp), %r14
movl 0x4(%r14,%rdx), %r14d
movl $0x2, %edx
movslq -0x4(%rsi,%rdx,4), %rbp
imulq $0x2aaaaaab, %rbp, %rbp # imm = 0x2AAAAAAB
movq %rbp, %r15
shrq $0x3f, %r15
shrq $0x20, %rbp
addl %r15d, %ebp
addl %ebp, -0x4(%r10,%rdx,4)
addl %ebp, -0x8(%r11,%rdx,4)
movl (%r11,%rdx,4), %r15d
addl %ebp, %r15d
movl %r15d, (%r11,%rdx,4)
addl %ebp, -0x4(%rdi,%rdx,4)
addl %ebp, %ebp
leal (%rbp,%rbp,2), %ebp
subl %ebp, %r14d
movl %r14d, -0x4(%r11,%rdx,4)
incq %rdx
movl %r15d, %r14d
cmpq %rdx, %r13
jne 0x13a8
incq %r8
incq %r9
addq %rcx, %r11
addq %rcx, %rsi
addq %rcx, %rdi
addq %rcx, %r10
cmpq %rax, %r8
jne 0x138a
testq %r12, %r12
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r14
je 0x1443
xorl %eax, %eax
movl $0xff, %ecx
movzbl (%rbx,%rax), %edx
addl (%r14,%rax,4), %edx
cmpl %ecx, %edx
cmovgel %ecx, %edx
testl %edx, %edx
jg 0x1438
xorl %edx, %edx
movb %dl, (%rbx,%rax)
incq %rax
cmpq %rax, %r12
jne 0x1425
callq 0x1030
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O1/aempirei[P]Chat-Art/pgmtobraile.c
// Function: braileencode
void braileencode(FILE *fpout, uint8_t *data, size_t width, size_t height) {
	for(size_t y = 0; y < height; y += 4) {
		for(size_t x = 0; x < width; x += 2) {
			wint_t wch = 0x2800;
			if(BIT0(data,x,y,width) > 0x80) wch |= 0x01;
			if(BIT1(data,x,y,width) > 0x80) wch |= 0x02;
			if(BIT2(data,x,y,width) > 0x80) wch |= 0x04;
			if(BIT3(data,x,y,width) > 0x80) wch |= 0x08;
			if(BIT4(data,x,y,width) > 0x80) wch |= 0x10;
			if(BIT5(data,x,y,width) > 0x80) wch |= 0x20;
			if(BIT6(data,x,y,width) > 0x80) wch |= 0x40;
			if(BIT7(data,x,y,width) > 0x80) wch |= 0x80;
			fputwc(wch, fpout);
		}
		fputwc(L'\n', fpout);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0x1589
movq %rsi, %r15
movq %rdi, %r12
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax), %r13
incq %r13
leaq (,%rdx,4), %rax
movq %rax, 0x10(%rsp)
leaq (%rsi,%rdx,2), %rbx
incq %rbx
leaq (%rsi,%rdx), %rbp
incq %rbp
incq %r15
xorl %ecx, %ecx
movq %rdx, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
testq %rdx, %rdx
je 0x1552
xorl %r14d, %r14d
xorl %eax, %eax
cmpb $-0x7f, -0x1(%r15,%r14)
setae %al
xorl %ecx, %ecx
cmpb $-0x7f, -0x1(%rbp,%r14)
setae %cl
leal (%rax,%rcx,2), %eax
xorl %ecx, %ecx
cmpb $-0x7f, -0x1(%rbx,%r14)
setae %cl
leal (%rax,%rcx,4), %ecx
xorl %edx, %edx
cmpb $-0x7f, (%r15,%r14)
setae %dl
xorl %eax, %eax
cmpb $-0x7f, (%rbp,%r14)
leal (%rcx,%rdx,8), %ecx
setae %al
shll $0x4, %eax
orl %ecx, %eax
xorl %ecx, %ecx
cmpb $-0x7f, (%rbx,%r14)
setae %cl
shll $0x5, %ecx
xorl %edx, %edx
cmpb $-0x7f, -0x1(%r13,%r14)
setae %dl
shll $0x6, %edx
orl %ecx, %edx
xorl %edi, %edi
cmpb $-0x7f, (%r13,%r14)
setae %dil
shll $0x7, %edi
orl %edx, %edi
orl %eax, %edi
orl $0x2800, %edi           # imm = 0x2800
movq %r12, %rsi
callq 0x1060
addq $0x2, %r14
cmpq 0x8(%rsp), %r14
jb 0x14c1
movl $0xa, %edi
movq %r12, %rsi
callq 0x1060
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
movq 0x10(%rsp), %rax
addq %rax, %r13
addq %rax, %rbx
addq %rax, %rbp
addq %rax, %r15
cmpq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rdx
jb 0x14b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/aempirei[P]Chat-Art/pgmtobraile.c
// Function: pgmtobraile
void pgmtobraile(FILE * fpin, FILE * fpout) {

	const size_t max_rad = 16;
	const int expected_maxval = 255;
	const char *locale = "";
	uint8_t *data;
	int width;
	int height;
	int maxval;
	int ch;
	
	if (setlocale(LC_CTYPE, locale) == NULL) {
		fprintf(stderr, "failed to set locale LC_CTYPE=\"%s\"\n", locale);
		exit(EXIT_FAILURE);
	}

	if(fscanf(fpin, "P5 %d %d %d", &width, &height, &maxval) != 3) {
		fprintf(stderr, "failed to parse pgm header\n");
		exit(EXIT_FAILURE);
	}

	ch = fgetc(fpin);
	if(ch == EOF) {
		perror("fgetc()");
		exit(EXIT_FAILURE);
	}

	if(!isspace(ch)) {
		fprintf(stderr, "unexpected character found after maxval, was expecting whitespace\n");
		exit(EXIT_FAILURE);
	}

	if(maxval != expected_maxval) {
		fprintf(stderr, "unexpected maxval of %d, was expecting %d\n", maxval, expected_maxval);
	}

	data = malloc(width * height);

	if(fread(data, width, height, fpin) != (size_t)height) {
		perror("fread()");
		exit(EXIT_FAILURE);
	}

	if(fgetc(fpin) != EOF || !feof(fpin)) {
		fprintf(stderr, "unexpected trailing data after pgm\n");
	}

	for(size_t rad = 0; rad < max_rad; rad++)
		dither(data, width, height);

	braileencode(fpout, data, width, height);

	free(data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa74(%rip), %rsi       # 0x2027
xorl %edi, %edi
callq 0x10c0
testq %rax, %rax
je 0x16e8
leaq 0xa5e(%rip), %rsi       # 0x2028
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x14(%rsp), %r8
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
cmpl $0x3, %eax
jne 0x16ed
movq %r14, %rdi
callq 0x1080
cmpl $-0x1, %eax
je 0x16f2
movl %eax, %ebp
callq 0x1100
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x16f7
movl 0x14(%rsp), %edx
cmpl $0xff, %edx
jne 0x16c6
movslq 0x10(%rsp), %r12
movslq 0xc(%rsp), %r13
movq %r13, %rdi
imulq %r12, %rdi
callq 0x10b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1050
movslq 0xc(%rsp), %rcx
cmpq %rcx, %rax
jne 0x16fc
movq %r14, %rdi
callq 0x1080
cmpl $-0x1, %eax
jne 0x16bf
movq %r14, %rdi
callq 0x10a0
testl %eax, %eax
je 0x16bf
movl $0x10, %r14d
movslq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
movq %r15, %rdi
callq 0x12cc
decq %r14
jne 0x167c
movslq 0x10(%rsp), %rdx
movslq 0xc(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x145e
movq %r15, %rdi
callq 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x115a
jmp 0x1676
movq 0x292b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x9c4(%rip), %rsi       # 0x209b
movl $0xff, %ecx
xorl %eax, %eax
callq 0x1090
jmp 0x1625
callq 0x11b6
callq 0x1120
callq 0x11a1
callq 0x117c
callq 0x1145
// File: /workspace/github_cpp_makefile_star2_O1/ps-george[P]ansi_c_compiler/src/lexer/lexer_main.cpp
// Function: escape_chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string escape_chars(const std::string &before){
    std::string after;
    after.reserve(before.length() + 4);
    for (std::string::size_type i = 0; i < before.length(); ++i) {
        switch (before[i]) {
            // Replace tab character with \t
            case '\t':
              after += '\\';
              after += 't';
              break;
            // Replace newline character with \n - not sure if I need this for ANSI C
            case '\n':
              after += '\\';
              after += 'n';
              break;
            case '\r':
              after += '\\';
              after += 'r';
              break;
            case '\v':
              after += '\\';
              after += 'v';
              break;
            case '\f':
              after += '\\';
              after += 'f';
              break;
            case '\\': // If the next character is an n or t
              if (i+1 < before.length() && (before[i+1]=='n' || before[i+1]=='t' || before[i+1]=='r' || before[i+1]=='v' || before[i+1]=='f')){
                after += before[i];
                break;
              }
            case '\"':
                after += '\\';
                // Fall through.
            default:
                after += before[i];
        }
    }
    return after;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq $0x4, %rsi
callq 0x21c0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x27b5
xorl %r12d, %r12d
leaq 0x4927(%rip), %r13      # 0x7004
movq (%r14), %rcx
movb (%rcx,%r12), %bpl
movzbl %bpl, %edx
leal -0x9(%rdx), %esi
cmpl $0x4, %esi
ja 0x270f
movslq (%r13,%rsi,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x74, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x2799
cmpl $0x22, %edx
je 0x273d
cmpl $0x5c, %edx
jne 0x274a
leaq 0x1(%r12), %rdx
cmpq %rax, %rdx
jae 0x273d
movb 0x1(%rcx,%r12), %al
addb $-0x66, %al
rorb %al
cmpb $0x8, %al
ja 0x273d
movzbl %al, %eax
movl $0x1d1, %ecx            # imm = 0x1D1
btl %eax, %ecx
jb 0x2799
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
movq (%r14), %rax
movb (%rax,%r12), %bpl
jmp 0x2799
movb $0x72, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x2799
movb $0x76, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x2799
movb $0x66, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x2799
movb $0x6e, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x20c0
incq %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
jb 0x26dd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27c9
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x27df
movq (%r15), %rsi
incq %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_direct.c
// Function: hookdemo_dataset_cmd
scdcint_t hookdemo_dataset_cmd(void *dataprov, void *dataset, const char *cmd, const char *params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result_t *result)
{
  printf(PREFIX "dataset_cmd:\n");
  printf(PREFIX "  dataprov: '%p'\n", dataprov);
  printf(PREFIX "  dataset: '%p'\n", dataset);
  printf(PREFIX "  cmd: '%s'\n", cmd);
  printf(PREFIX "  params: '%s'\n", params);

  printf(PREFIX "  "); scdc_dataset_input_print(input); printf("\n");

  printf(PREFIX "  "); scdc_dataset_output_print(output); printf("\n");

  printf(PREFIX "\n");

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x4ec49(%rip), %rdi     # 0x5b0b9
callq 0xb840
leaq 0x4eb88(%rip), %rdi     # 0x5b004
movq %rbp, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4eb96(%rip), %rdi     # 0x5b023
movq %r13, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4eba3(%rip), %rdi     # 0x5b041
movq %r12, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4ebac(%rip), %rdi     # 0x5b05b
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4ebb8(%rip), %r15     # 0x5b078
movq %r15, %rdi
xorl %eax, %eax
callq 0xb080
movq %r14, %rdi
callq 0x1e93c
movl $0xa, %edi
callq 0xb740
movq %r15, %rdi
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
callq 0x1ea70
movl $0xa, %edi
callq 0xb740
leaq 0x4ec1b(%rip), %rdi     # 0x5b11a
callq 0xb840
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_direct.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;


  printf(PREFIX "start hook demo direct\n");
  printf(PREFIX "\n");

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook", &hookdemo);

  scdc_dataset_input_t input;
  scdc_dataset_output_t output;

  scdc_dataset_input_unset(&input);
  scdc_dataset_output_unset(&output);

/*
  char format[SCDC_FORMAT_MAX_SIZE];
  scdcint_t buf_size;
  void *buf;
  scdcint_t total_size, current_size;
  char total_size_given;
  scdc_dataset_inout_next_f *next;
  void *data;
*/

  scdc_dataset_cmd(SCDC_DATASET_NULL, "scdc:/hookdemo CMD PARAM1 PARAM2 PARAM3", &input, &output);

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo direct\n");
  printf(PREFIX "\n");

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x4eba6(%rip), %rdi     # 0x5b0d3
callq 0xb840
leaq 0x4ebe1(%rip), %rbx     # 0x5b11a
movq %rbx, %rdi
callq 0xb840
leaq 0x504ba(%rip), %rdi     # 0x5ca02
xorl %eax, %eax
callq 0xcce1
leaq 0x4eb32(%rip), %rdi     # 0x5b088
leaq 0x51751(%rip), %rsi     # 0x5dcae
leaq 0x69604(%rip), %rdx     # 0x75b68
xorl %eax, %eax
callq 0xd0a3
movq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x1ebf8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1ec18
leaq 0x4eb02(%rip), %rsi     # 0x5b091
xorl %edi, %edi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe724
movq %r14, %rdi
callq 0xd19e
callq 0xcde6
leaq 0x4eb45(%rip), %rdi     # 0x5b0f7
callq 0xb840
movq %rbx, %rdi
callq 0xb840
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_config
scdcint_t hook_config(void *dataprov, const char *cmd, const char *param, const char *input, scdcint_t input_size, scdc_result_t *result)
{
  if (strncmp(cmd, "ls", 2) == 0)
  {
    printf("hook_config: listing parameters\n");

    SCDC_RESULT_SET_STR(result, "param0,param1,param2");

  } else if (strncmp(cmd, "put", 3) == 0)
  {
    printf("hook_config: setting '%s' to '%.*s'\n", param, (int) input_size, input);

  } else if (strncmp(cmd, "get", 3) == 0)
  {
    printf("hook_config: getting '%s'\n", param);

    snprintf(SCDC_RESULT_STR(result), SCDC_RESULT_SIZE(result), "%s_VAL", param);

  } else
  {
    return SCDC_FAILURE;
  }

  printf("%s: return %" scdcint_fmt ", result: '%s'\n", __func__, SCDC_SUCCESS, SCDC_RESULT_STR(result));

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r13
leaq 0x4fd04(%rip), %rsi     # 0x5c34d
movl $0x2, %edx
movq %r13, %rdi
callq 0xb240
testl %eax, %eax
je 0xc692
leaq 0x4f985(%rip), %rsi     # 0x5bfe6
movl $0x3, %edx
movq %r13, %rdi
callq 0xb240
testl %eax, %eax
je 0xc6b6
leaq 0x4f9e5(%rip), %rsi     # 0x5c05e
movl $0x3, %edx
movq %r13, %rdi
callq 0xb240
testl %eax, %eax
je 0xc6cf
xorl %r14d, %r14d
jmp 0xc71f
leaq 0x4ef51(%rip), %rdi     # 0x5b5ea
callq 0xb840
leaq 0x8(%rbx), %rdi
movq (%rbx), %rdx
decq %rdx
leaq 0x4eab8(%rip), %rsi     # 0x5b167
callq 0xb2a0
jmp 0xc6f8
leaq 0x4eabf(%rip), %rdi     # 0x5b17c
movq %r14, %rsi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0xb080
jmp 0xc6f8
leaq 0x4eacb(%rip), %rdi     # 0x5b1a1
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x8(%rbx), %rdi
movq (%rbx), %rsi
leaq 0x4eace(%rip), %rdx     # 0x5b1bc
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
addq $0x8, %rbx
leaq 0x4eac0(%rip), %rdi     # 0x5b1c3
leaq 0x4f0b5(%rip), %rsi     # 0x5b7bf
movl $0x1, %r14d
movl $0x1, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb080
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_open
void *hook_dataset_open(void *dataprov, const char *path, scdc_result_t *result)
{
  hook_dataset_t *dataset_hook;
  
  union { void *dataprov; hook_dataset_t dataset_hook; } z;


  printf("hook_dataset_open: dataprov: '%p', path: '%s'\n", dataprov, path);

  dataset_hook = (hook_dataset_t *) malloc(sizeof(hook_dataset_t));

  z.dataprov = dataprov;

  *dataset_hook = ((char *) z.dataset_hook) + 1;

  SCDC_RESULT_SET_STR(result, "result of hook_dataset_open");

  printf("hook_dataset_open: return '%p' (%p), result: '%s'\n", dataset_hook, *dataset_hook, SCDC_RESULT_STR(result));

  return dataset_hook;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x4eaa1(%rip), %rdi     # 0x5b1e2
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
movl $0x8, %edi
callq 0xb6d0
movq %rax, %r15
incq %r14
movq %r14, (%rax)
movq (%rbx), %rdx
addq $0x8, %rbx
decq %rdx
leaq 0x4eaa2(%rip), %rsi     # 0x5b211
movq %rbx, %rdi
callq 0xb2a0
leaq 0x4eaaf(%rip), %rdi     # 0x5b22d
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb080
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq