LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util.h
// Function: testing::internal::ParameterizedTestCaseInfo<SignalTestParametrized>* testing::internal::ParameterizedTestCaseRegistry::GetTestCasePatternHolder<SignalTestParametrized>(char const*, testing::internal::CodeLocation)
ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder(
      const char* test_case_name,
      CodeLocation code_location) {
    ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL;
    for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
         it != test_case_infos_.end(); ++it) {
      if ((*it)->GetTestCaseName() == test_case_name) {
        if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) {
          // Complain about incorrect usage of Google Test facilities
          // and terminate the program since we cannot guaranty correct
          // test case setup and tear-down in this case.
          ReportInvalidTestCaseType(test_case_name, code_location);
          posix::Abort();
        } else {
          // At this point we are sure that the object we found is of the same
          // type we are looking for, so we downcast it to that type
          // without further checks.
          typed_test_info = CheckedDowncastToActualType<
              ParameterizedTestCaseInfo<TestCase> >(*it);
        }
        break;
      }
    }
    if (typed_test_info == NULL) {
      typed_test_info = new ParameterizedTestCaseInfo<TestCase>(
          test_case_name, code_location);
      test_case_infos_.push_back(typed_test_info);
    }
    return typed_test_info;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
cmpq 0x8(%rbx), %r12
je 0x1c506
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x1d1eb
testb %al, %al
jne 0x1c4e2
addq $0x8, %r12
jmp 0x1c4bd
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cmpq 0x43a95(%rip), %rax     # 0x5ff88
jne 0x1c557
movq (%r12), %rdi
callq 0x1d216
movq %rax, %r12
testq %rax, %rax
jne 0x1c548
movl $0x80, %edi
callq 0xb510
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1d1f8
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d2b0
leaq 0x8(%rsp), %rdi
callq 0xbb78
movq %rsp, %rsi
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x1dfe2
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1d1f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x278da
leaq 0x30(%rsp), %rdi
callq 0xbb78
callq 0xb300
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xbb78
jmp 0x1c5af
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb78
jmp 0x1c5a2
movq %rax, %rbx
movl $0x80, %esi
movq %r12, %rdi
callq 0xb540
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::join(testing::internal::linked_ptr_internal const*)
GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    linked_ptr_internal const* p = ptr;
    while (p->next_ != ptr) {
      assert(p->next_ != this &&
             "Trying to join() a linked ring we are already in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = this;
    next_ = ptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x95f03(%rip), %rdi     # 0xb2b10
movq %rdi, (%rsp)
callq 0x1cc70
movq %rbx, %rax
movq (%rax), %rcx
cmpq %rbx, %rcx
je 0x1cc46
movq %rcx, %rax
cmpq %r14, %rcx
jne 0x1cc19
leaq 0x1f448(%rip), %rdi     # 0x3c078
leaq 0x1f321(%rip), %rsi     # 0x3bf58
leaq 0x1f4a5(%rip), %rcx     # 0x3c0e3
pushq $0x74
popq %rdx
callq 0xb370
movq %r14, (%rax)
movq %rbx, (%r14)
movq %rsp, %rdi
callq 0x1cc5c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::depart()
bool depart()
      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    if (next_ == this) return true;
    linked_ptr_internal const* p = next_;
    while (p->next_ != this) {
      assert(p->next_ != next_ &&
             "Trying to depart() a linked ring we are not in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = next_;
    return false;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x95c2f(%rip), %rdi     # 0xb2b10
movq %rdi, 0x8(%rsp)
callq 0x1cc70
movq (%rbx), %rax
cmpq %rbx, %rax
je 0x1cf28
movq %rax, %rcx
movq (%rcx), %rdx
cmpq %rbx, %rdx
je 0x1cf25
movq %rdx, %rcx
cmpq %rax, %rdx
jne 0x1cef6
leaq 0x1f2a6(%rip), %rdi     # 0x3c1b3
leaq 0x1f044(%rip), %rsi     # 0x3bf58
leaq 0x1f302(%rip), %rcx     # 0x3c21d
movl $0x86, %edx
callq 0xb370
movq %rax, (%rcx)
cmpq %rbx, %rax
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x1cc5c
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest-printers.h
// Function: void testing::internal::TuplePrefixPrinter<2ul>::PrintPrefixTo<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>>(std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme> const&, std::ostream*)
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
    GTEST_INTENTIONAL_CONST_COND_PUSH_()
    if (N > 1) {
    GTEST_INTENTIONAL_CONST_COND_POP_()
      *os << ", ";
    }
    UniversalPrinter<
        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x14, %rdi
callq 0x1a16c
leaq 0x215d2(%rip), %rsi     # 0x3f4d4
movq %rbx, %rdi
callq 0xb4f0
addq $0x10, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a16c
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/test/FunctionTimeRegular.hpp
// Function: FunctionTimeRegular<>::threadLoop()
void threadLoop(){
        auto begin = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed = std::chrono::high_resolution_clock::now() - begin;
        std::unique_lock<std::mutex> lock(m_mutex);
        for (std::chrono::duration<double> lastTime=elapsed; m_keepGoing; lastTime += m_interval){
            if (!m_tfunc())
                break;
            elapsed = std::chrono::high_resolution_clock::now() - begin;
            m_cv.wait_for(lock, m_interval - (elapsed-lastTime));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xb080
movq %rax, %r14
callq 0xb080
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1a334(%rip), %xmm0    # 0x3a008
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0xcc9e
leaq 0x70(%rbx), %r12
leaq 0x30(%rbx), %r13
leaq 0x10(%rsp), %rbp
movb (%rbx), %al
testb $0x1, %al
je 0x1fd55
movq %r12, %rdi
callq 0x11f42
testb %al, %al
je 0x1fd55
callq 0xb080
subq %r14, %rax
cvtsi2sd %rax, %xmm0
divsd 0x1a2e9(%rip), %xmm0    # 0x3a008
subsd 0x8(%rsp), %xmm0
movsd 0x68(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1fe08
movsd 0x8(%rsp), %xmm0
addsd 0x68(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x1fcf8
leaq 0x18(%rsp), %rdi
callq 0xccb4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fd70
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xccb4
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::ValueArray7<int, int, int, int, int, int, int>::operator testing::internal::ParamGenerator<unsigned int><unsigned int>() const
operator ParamGenerator<T>() const {
    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
        static_cast<T>(v6_), static_cast<T>(v7_)};
    return ValuesIn(array);
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movl 0x18(%rsi), %ecx
movl %ecx, 0x18(%rax)
movq %rax, %rsi
callq 0x2082b
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util.h
// Function: testing::internal::ValuesInIteratorRangeGenerator<unsigned int>::Iterator::Equals(testing::internal::ParamIteratorInterface<unsigned int> const&) const
virtual bool Equals(const ParamIteratorInterface<T>& other) const {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_ ==
          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
callq 0x22790
testb %al, %al
jne 0x2071b
leaq 0x1bc9c(%rip), %rdx     # 0x3c362
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x155, %ecx            # imm = 0x155
callq 0x37960
movq 0x3f909(%rip), %rdi     # 0x5ffe8
leaq 0x1bdf7(%rip), %rsi     # 0x3c4dd
callq 0xb4f0
leaq 0x1be27(%rip), %rsi     # 0x3c519
movq %rax, %rdi
callq 0xb4f0
leaq 0x1be44(%rip), %rsi     # 0x3c545
movq %rax, %rdi
callq 0xb4f0
movq %rax, %rdi
callq 0xb270
leaq 0xc(%rsp), %rdi
callq 0x37a24
movq %r14, %rdi
callq 0x20791
movq 0x10(%rbx), %rcx
cmpq 0x10(%rax), %rcx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x37a24
movq %rbx, %rdi
callq 0xba30
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductGenerator6<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>::Iterator::Advance()
virtual void Advance() {
      assert(!AtEnd());
      ++current6_;
      if (current6_ == end6_) {
        current6_ = begin6_;
        ++current5_;
      }
      if (current5_ == end5_) {
        current5_ = begin5_;
        ++current4_;
      }
      if (current4_ == end4_) {
        current4_ = begin4_;
        ++current3_;
      }
      if (current3_ == end3_) {
        current3_ = begin3_;
        ++current2_;
      }
      if (current2_ == end2_) {
        current2_ = begin2_;
        ++current1_;
      }
      ComputeCurrentValue();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x21d50
testb %al, %al
jne 0x21b9f
leaq 0x98(%rbx), %r14
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x21e0e
testb %al, %al
je 0x21ae5
leaq 0x88(%rbx), %rsi
movq %r14, %rdi
callq 0x21e50
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x80(%rbx), %r14
leaq 0x78(%rbx), %rsi
movq %r14, %rdi
callq 0x21df6
testb %al, %al
je 0x21b12
leaq 0x70(%rbx), %rsi
movq %r14, %rdi
callq 0x21e72
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x68(%rbx), %r14
leaq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x21dde
testb %al, %al
je 0x21b3c
leaq 0x58(%rbx), %rsi
movq %r14, %rdi
callq 0x21e94
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x50(%rbx), %r14
leaq 0x48(%rbx), %rsi
movq %r14, %rdi
callq 0x21dde
testb %al, %al
je 0x21b66
leaq 0x40(%rbx), %rsi
movq %r14, %rdi
callq 0x21e94
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x38(%rbx), %r14
leaq 0x30(%rbx), %rsi
movq %r14, %rdi
callq 0x21dde
testb %al, %al
je 0x21b90
leaq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x21e94
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x218f8
leaq 0x1ac14(%rip), %rdi     # 0x3c7ba
leaq 0x1ac16(%rip), %rsi     # 0x3c7c3
leaq 0x1ac53(%rip), %rcx     # 0x3c807
movl $0xec7, %edx            # imm = 0xEC7
callq 0xb370
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductGenerator6<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>::Iterator::Equals(testing::internal::ParamIteratorInterface<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>> const&) const
virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      const Iterator* typed_other =
          CheckedDowncastToActualType<const Iterator>(&other);
      // We must report iterators equal if they both point beyond their
      // respective ranges. That can happen in a variety of fashions,
      // so we have to consult AtEnd().
      return (AtEnd() && typed_other->AtEnd()) ||
         (
          current1_ == typed_other->current1_ &&
          current2_ == typed_other->current2_ &&
          current3_ == typed_other->current3_ &&
          current4_ == typed_other->current4_ &&
          current5_ == typed_other->current5_ &&
          current6_ == typed_other->current6_);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
callq 0x22790
testb %al, %al
jne 0x21c97
leaq 0x1ab81(%rip), %rdx     # 0x3c7c3
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0xee6, %ecx            # imm = 0xEE6
callq 0x37960
movq 0x3e38d(%rip), %rdi     # 0x5ffe8
leaq 0x1a87b(%rip), %rsi     # 0x3c4dd
callq 0xb4f0
leaq 0x1a8ab(%rip), %rsi     # 0x3c519
movq %rax, %rdi
callq 0xb4f0
leaq 0x1a8c8(%rip), %rsi     # 0x3c545
movq %rax, %rdi
callq 0xb4f0
movq %rax, %rdi
callq 0xb270
leaq 0xc(%rsp), %rdi
callq 0x37a24
movq %r14, %rdi
callq 0x221d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x21d50
testb %al, %al
je 0x21cbe
movq %r14, %rdi
callq 0x21d50
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x21d31
leaq 0x20(%rbx), %rdi
leaq 0x20(%r14), %rsi
callq 0x21dde
testb %al, %al
je 0x21d2f
leaq 0x38(%rbx), %rdi
leaq 0x38(%r14), %rsi
callq 0x21dde
testb %al, %al
je 0x21d2f
leaq 0x50(%rbx), %rdi
leaq 0x50(%r14), %rsi
callq 0x21dde
testb %al, %al
je 0x21d2f
leaq 0x68(%rbx), %rdi
leaq 0x68(%r14), %rsi
callq 0x21dde
testb %al, %al
je 0x21d2f
movl $0x80, %esi
leaq (%rbx,%rsi), %rdi
addq %r14, %rsi
callq 0x21df6
testb %al, %al
je 0x21d2f
movl $0x98, %eax
addq %rax, %rbx
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0e
jmp 0x21d31
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x37a24
movq %rbx, %rdi
callq 0xba30
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductGenerator6<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>::Iterator::AtEnd() const
bool AtEnd() const {
      // We must report iterator past the end of the range when either of the
      // component iterators has reached the end of its range.
      return
          current1_ == end1_ ||
          current2_ == end2_ ||
          current3_ == end3_ ||
          current4_ == end4_ ||
          current5_ == end5_ ||
          current6_ == end6_;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x20, %rdi
leaq 0x18(%rbx), %rsi
callq 0x21dde
testb %al, %al
jne 0x21dac
leaq 0x38(%rbx), %rdi
leaq 0x30(%rbx), %rsi
callq 0x21dde
testb %al, %al
jne 0x21dac
leaq 0x50(%rbx), %rdi
leaq 0x48(%rbx), %rsi
callq 0x21dde
testb %al, %al
jne 0x21dac
leaq 0x68(%rbx), %rdi
leaq 0x60(%rbx), %rsi
callq 0x21dde
testb %al, %al
jne 0x21dac
leaq 0x80(%rbx), %rdi
leaq 0x78(%rbx), %rsi
callq 0x21df6
testb %al, %al
je 0x21db0
movb $0x1, %al
popq %rbx
retq
leaq 0x98(%rbx), %rdi
addq $0x90, %rbx
movq %rbx, %rsi
popq %rbx
jmp 0x21e0e
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: main
int main(int argc, char **argv) {
    InitGoogleTest(&argc, argv);
    UnitTest& unit_test = *UnitTest::GetInstance();
    TestEventListeners& listeners = unit_test.listeners();

    // Removes the default console output listener from the list so it will
    // not receive events from Google Test and won't print any output. Since
    // this operation transfers ownership of the listener to the caller we
    // have to delete it as well.
    delete listeners.Release(listeners.default_result_printer());

    // Adds the custom output listener to the list. It will now receive
    // events from Google Test and print the alternative output. We don't
    // have to worry about deleting it since Google Test assumes ownership
    // over it after adding it to the list.
    listeners.Append(new CustomTestPrinter);
    int ret_val = RUN_ALL_TESTS();
    return ret_val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rax
movl %edi, (%rax)
movq %rax, %rdi
callq 0x2c823
callq 0x228be
movq %rax, %rdi
callq 0x27b46
movq %rax, %rbx
movq 0x8(%rax), %rsi
movq %rax, %rdi
callq 0x2b02c
testq %rax, %rax
je 0x38e52
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
pushq $0x8
popq %rdi
callq 0xb510
leaq 0x26e57(%rip), %rcx     # 0x5fcb8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2b024
callq 0x38e7e
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestIterationStart(testing::UnitTest const&, int)
void OnTestIterationStart(const UnitTest& unit_test, int iteration) {
        if (GTEST_FLAG(repeat) != 1) {
            printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
        }
        const char* const filter = GTEST_FLAG(filter).c_str();

        // Prints the filter if it's not *.  This reminds the user that some
        // tests may be skipped.
        if (strcmp(filter, kUniversalFilter) != 0) {
            printf("Note: %s filter = %s\n", GTEST_NAME_, filter);
        }

        if (GTEST_FLAG(shuffle)) {
            printf("Note: Randomizing tests' orders with a seed of %d .\n", unit_test.random_seed());
        }

        PRINT_SEPARATOR;
        PRINT_EXTENDER;
        printf("Running %d test%s from %d test case%s.\n",
                unit_test.test_to_run_count(), unit_test.test_to_run_count() == 1 ? "" : "s",
                unit_test.test_case_to_run_count(), unit_test.test_case_to_run_count() == 1 ? "" : "s");
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x79c0d(%rip), %rax     # 0xb2ab8
cmpl $0x1, (%rax)
je 0x38ec2
incl %edx
leaq 0x5a4f(%rip), %rdi      # 0x3e908
movl %edx, %esi
xorl %eax, %eax
callq 0xb070
leaq 0x79b9f(%rip), %rax     # 0xb2a68
movq (%rax), %rdx
cmpb $0x2a, (%rdx)
jne 0x38ed7
cmpb $0x0, 0x1(%rdx)
je 0x38eec
leaq 0x5a56(%rip), %rdi      # 0x3e934
leaq 0x556d(%rip), %rsi      # 0x3e452
xorl %eax, %eax
callq 0xb070
leaq 0x79bca(%rip), %rax     # 0xb2abd
cmpb $0x1, (%rax)
jne 0x38f10
movq %rbx, %rdi
callq 0x287ac
leaq 0x5a67(%rip), %rdi      # 0x3e96e
movl %eax, %esi
xorl %eax, %eax
callq 0xb070
leaq 0x7731(%rip), %rdi      # 0x40648
callq 0xb8f0
leaq 0x75a9(%rip), %rdi      # 0x404cc
xorl %eax, %eax
callq 0xb070
movq %rbx, %rdi
callq 0x287d4
movl %eax, %ebp
movq %rbx, %rdi
callq 0x287d4
cmpl $0x1, %eax
leaq 0x5afe(%rip), %r14      # 0x3ea44
leaq 0x6028(%rip), %r15      # 0x3ef75
movq %r15, %r12
cmoveq %r14, %r12
movq %rbx, %rdi
callq 0x287fa
movl %eax, %r13d
movq %rbx, %rdi
callq 0x287fa
cmpl $0x1, %eax
cmoveq %r14, %r15
leaq 0x755a(%rip), %rdi      # 0x404cf
movl %ebp, %esi
movq %r12, %rdx
movl %r13d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xb070
leaq 0x76ba(%rip), %rdi      # 0x40648
callq 0xb8f0
movq 0x26fce(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb650
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestCaseStart(testing::TestCase const&)
void OnTestCaseStart(const TestCase& test_case) {
        PRINT_ALT_EXTENDER;
        printf("Test Case: %s", test_case.name());
        if (test_case.type_param() == NULL) {
            printf("\n");
        } else {
            printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
        }
        PRINT_ALT_EXTENDER;
        printf("Tests: \n");
        for (int i=0; i<test_case.test_to_run_count(); i++){
            PRINT_ALT_EXTENDER;
            PRINT_LONG_EXTENDER;
            PRINT_EXTENDER;
            printf("%s\n", test_case.GetTestInfo(i)->name());
            
        }
        /*printf("%d %s from %s", test_case.test_to_run_count(), test_case.test_to_run_count() == 1 ? "test" : "tests", test_case.name());
        if (test_case.type_param() == NULL) {
            printf("\n");
        } else {
            printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
        }*/
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x7525(%rip), %rdi      # 0x404f7
xorl %eax, %eax
callq 0xb070
movq 0x8(%rbx), %rsi
leaq 0x7517(%rip), %rdi      # 0x404fb
xorl %eax, %eax
callq 0xb070
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x39013
movq (%rax), %rdx
testq %rdx, %rdx
je 0x39013
leaq 0x59e2(%rip), %rdi      # 0x3e9e5
leaq 0x7692(%rip), %rsi      # 0x4069c
xorl %eax, %eax
callq 0xb070
jmp 0x3901b
pushq $0xa
popq %rdi
callq 0xb7e0
leaq 0x74d5(%rip), %r14      # 0x404f7
movq %r14, %rdi
xorl %eax, %eax
callq 0xb070
leaq 0x756f(%rip), %rdi      # 0x405a2
callq 0xb8f0
leaq 0x6ce8(%rip), %r15      # 0x3fd27
leaq 0x7486(%rip), %r12      # 0x404cc
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x23b68
cmpl %eax, %ebp
jge 0x39089
movq %r14, %rdi
xorl %eax, %eax
callq 0xb070
movq %r15, %rdi
xorl %eax, %eax
callq 0xb070
movq %r12, %rdi
xorl %eax, %eax
callq 0xb070
movq %rbx, %rdi
movl %ebp, %esi
callq 0x27ce2
movq 0x20(%rax), %rdi
callq 0xb8f0
incl %ebp
jmp 0x39048
leaq 0x75b8(%rip), %rdi      # 0x40648
callq 0xb8f0
movq 0x26ecc(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb650
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestStart(testing::TestInfo const&)
void OnTestStart(const TestInfo& test_info) {
        PRINT_LONG_EXTENDER;
        printf("Test %s.%s RUNNING", test_info.test_case_name(), test_info.name());
        printf("\n");
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x6c70(%rip), %rdi      # 0x3fd27
xorl %eax, %eax
callq 0xb070
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x743d(%rip), %rdi      # 0x40509
xorl %eax, %eax
callq 0xb070
pushq $0xa
popq %rdi
callq 0xb7e0
leaq 0x7566(%rip), %rdi      # 0x40648
callq 0xb8f0
movq 0x26e7a(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
popq %rbx
jmp 0xb650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestPartResult(testing::TestPartResult const&)
void OnTestPartResult(
            const TestPartResult& result) {
        // If the test part succeeded, we don't need to do anything.
        if (result.type() == TestPartResult::kSuccess)
            return;
        PRINT_FAILSTART_MARKER;
        printf("Failure in %s:%d\n%s\n",
                result.file_name(),
                result.line_number(),
                result.summary());
        PRINT_FAILEND_MARKER;
        fflush(stdout);
    }

// Assembly:
cmpl $0x0, (%rsi)
je 0x3914b
pushq %rbx
movq %rsi, %rbx
leaq 0x74a2(%rip), %rdi      # 0x405aa
callq 0xb8f0
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x3911a
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq 0x30(%rbx), %rcx
leaq 0x73f4(%rip), %rdi      # 0x4051c
xorl %eax, %eax
callq 0xb070
leaq 0x74bb(%rip), %rdi      # 0x405f1
callq 0xb8f0
movq 0x26e26(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
popq %rbx
jmp 0xb650
retq
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestEnd(testing::TestInfo const&)
void OnTestEnd(const TestInfo& test_info) {
        PRINT_SEPARATOR;
        PRINT_LONG_EXTENDER;
        printf("Test %s.%s %s", test_info.test_case_name(), test_info.name(), test_info.result()->Passed() ? "PASSED" : "FAILED");

        if (test_info.result()->Failed())
            PrintFullTestCommentIfPresent(test_info);

        if (GTEST_FLAG(print_time)) {
            printf(" (%ld ms)\n", (long)test_info.result()->elapsed_time());
        } else {
            printf("\n");
        }
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x74e6(%rip), %rdi      # 0x40648
callq 0xb8f0
leaq 0x6bb9(%rip), %rdi      # 0x3fd27
xorl %eax, %eax
callq 0xb070
movq (%rbx), %r15
movq 0x20(%rbx), %r12
leaq 0x90(%rbx), %r13
movq %r13, %rdi
callq 0x2e364
leaq 0x73ad(%rip), %rdx      # 0x4053f
leaq 0x6e41(%rip), %rcx      # 0x3ffda
testb %al, %al
cmovneq %rdx, %rcx
leaq 0x738b(%rip), %rdi      # 0x40531
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb070
movq %r13, %rdi
callq 0x26e44
testb %al, %al
je 0x391ca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3947e
leaq 0x798df(%rip), %rax     # 0xb2ab0
cmpb $0x1, (%rax)
jne 0x391ed
movq 0x100(%rbx), %rsi
leaq 0x7362(%rip), %rdi      # 0x40546
xorl %eax, %eax
callq 0xb070
jmp 0x391f5
pushq $0xa
popq %rdi
callq 0xb7e0
leaq 0x744c(%rip), %rdi      # 0x40648
callq 0xb8f0
movq 0x26d60(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb650
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestCaseEnd(testing::TestCase const&)
void OnTestCaseEnd(const TestCase& test_case) {
        if (!GTEST_FLAG(print_time)) return;
        PRINT_ALT_EXTENDER;
        printf("%d %s from %s (%ld ms total)\n", 
                test_case.test_to_run_count(), test_case.test_to_run_count() == 1 ? "test" : "tests", test_case.name(), (long)test_case.elapsed_time());
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
leaq 0x7988f(%rip), %rax     # 0xb2ab0
cmpb $0x1, (%rax)
jne 0x3929a
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x72c4(%rip), %rdi      # 0x404f7
xorl %eax, %eax
callq 0xb070
movq %rbx, %rdi
callq 0x23b68
movl %eax, %ebp
movq %rbx, %rdi
callq 0x23b68
cmpl $0x1, %eax
leaq 0x6b0c(%rip), %rax      # 0x3fd62
leaq 0x5777(%rip), %rdx      # 0x3e9d4
cmoveq %rax, %rdx
movq 0x8(%rbx), %rcx
movq 0x78(%rbx), %r8
leaq 0x72e1(%rip), %rdi      # 0x40551
movl %ebp, %esi
xorl %eax, %eax
callq 0xb070
leaq 0x73c8(%rip), %rdi      # 0x40648
callq 0xb8f0
movq 0x26cdc(%rip), %rax     # 0x5ff68
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb650
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::PrintFailedTests(testing::UnitTest const&)
void PrintFailedTests(const UnitTest& unit_test) {
        const int failed_test_count = unit_test.failed_test_count();
        if (failed_test_count == 0) {
            return;
        }
        PRINT_SEPARATOR;
        printf("Failed tests: \n");
        for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
            const TestCase& test_case = *unit_test.GetTestCase(i);
            if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
                continue;
            }

            for (int j = 0; j < test_case.total_test_count(); ++j) {
                const TestInfo& test_info = *test_case.GetTestInfo(j);
                if (!test_info.should_run() || test_info.result()->Passed()) {
                    continue;
                }
                PRINT_EXTENDER;
                printf("%s.%s", test_case.name(), test_info.name());
                PrintFullTestCommentIfPresent(test_info);
                printf("\n");
            }   
        }
        PRINT_SEPARATOR;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x28c9e
testl %eax, %eax
je 0x3961e
leaq 0x7108(%rip), %rdi      # 0x40648
callq 0xb8f0
leaq 0x70ed(%rip), %rdi      # 0x40639
callq 0xb8f0
xorl %r13d, %r13d
movq %rbx, %rdi
callq 0x28ca8
cmpl %eax, %r13d
jge 0x39604
movq %rbx, %rdi
movl %r13d, %esi
callq 0x28cc0
cmpb $0x1, 0x70(%rax)
jne 0x395fc
movq %rax, %r15
movq %rax, %rdi
callq 0x23a92
testl %eax, %eax
je 0x395fc
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x23b46
cmpl %eax, %r12d
jge 0x395fc
movq %r15, %rdi
movl %r12d, %esi
callq 0x27ce2
cmpb $0x1, 0x80(%rax)
jne 0x395f7
movq %rax, %rbp
leaq 0x90(%rax), %rdi
callq 0x2e364
testb %al, %al
jne 0x395f7
leaq 0x6f05(%rip), %rdi      # 0x404cc
xorl %eax, %eax
callq 0xb070
movq 0x8(%r15), %rsi
movq 0x20(%rbp), %rdx
leaq 0x5468(%rip), %rdi      # 0x3ea45
xorl %eax, %eax
callq 0xb070
movq %r14, %rdi
movq %rbp, %rsi
callq 0x3947e
pushq $0xa
popq %rdi
callq 0xb7e0
incl %r12d
jmp 0x3958c
incl %r13d
jmp 0x39554
leaq 0x703d(%rip), %rdi      # 0x40648
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/main.cpp
// Function: main
int main()
{
	string DebugSymbolPath;
    cout << "Please enter the Debug Symbol path: ";
    cin >> DebugSymbolPath;
	
	ifstream InputFile(DebugSymbolPath.c_str());
	ScMain scmain;
	
	bool flag = scmain.find_scmain(InputFile);
	if (flag){
		cout << "\033[1;32mStarting XML file generation...\033[0m\n";
		scmain.print_data_XML ();
		cout <<"\033[1;32mXML file is successfully generated!\033[0m\n";
		scmain.print_data ();
	}
	else
		cout <<"\033[1;31mUnable to generate XML file!\033[0m\n";
	
	return 0;
}

// Assembly:
pushq %rbx
subq $0x240, %rsp            # imm = 0x240
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0xbf04(%rip), %rdi      # 0xefd0
leaq 0x6fb2(%rip), %rsi      # 0xa085
callq 0x21d0
movq 0xbf01(%rip), %rdi      # 0xefe0
leaq 0x18(%rsp), %rsi
callq 0x2220
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2320
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x38(%rsp), %rsi
callq 0x592c
testb %al, %al
je 0x314f
movq 0xbeb2(%rip), %rdi      # 0xefd0
leaq 0x6f85(%rip), %rsi      # 0xa0aa
callq 0x21d0
movq %rsp, %rdi
callq 0x3824
movq 0xbe97(%rip), %rdi      # 0xefd0
leaq 0x6f96(%rip), %rsi      # 0xa0d6
callq 0x21d0
movq %rsp, %rdi
callq 0x3674
jmp 0x3162
movq 0xbe7a(%rip), %rdi      # 0xefd0
leaq 0x6fa9(%rip), %rsi      # 0xa106
callq 0x21d0
movq %rsp, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
callq 0x2090
leaq 0x18(%rsp), %rdi
callq 0x2110
xorl %eax, %eax
addq $0x240, %rsp            # imm = 0x240
popq %rbx
retq
jmp 0x318b
movq %rax, %rbx
jmp 0x31a5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
callq 0x2090
leaq 0x18(%rsp), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::print_data()
void ScMain::print_data(){
	ofstream txtFile;
	txtFile.open ("output.txt");
	txtFile<<"--------------Extracted Static Information--------------"<<endl;
	for (auto i: static_data_final){
		txtFile<<"Module Name ----->\n"<<i.get_name()<<endl;	
		txtFile<<"Var List ----->\n"<<i.get_var()<<endl;	
		txtFile<<"Func List ----->\n"<<i.get_func()<<endl;
		txtFile<<"----------------------------------------------------"<<endl;	
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %r14
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x22f0
leaq 0x6aeb(%rip), %rsi      # 0xa18a
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2030
leaq 0x6ae4(%rip), %rsi      # 0xa195
leaq 0x98(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq (%r14), %rbx
movq 0x8(%r14), %rbp
leaq 0x28(%rsp), %r14
leaq 0x98(%rsp), %r12
leaq 0x8(%rsp), %r13
cmpq %rbp, %rbx
je 0x37c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bd0
movq %r12, %rdi
leaq 0x6ad1(%rip), %rsi      # 0xa1ce
callq 0x21d0
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x859c
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r13, %rdi
callq 0x2110
movq %r12, %rdi
leaq 0x6aad(%rip), %rsi      # 0xa1e2
callq 0x21d0
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x868c
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r13, %rdi
callq 0x2110
movq %r12, %rdi
leaq 0x6a86(%rip), %rsi      # 0xa1f3
callq 0x21d0
movq %rax, %r15
movq %r13, %rdi
movq %r14, %rsi
callq 0x8d32
movq %r15, %rdi
movq %r13, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r13, %rdi
callq 0x2110
movq %r12, %rdi
leaq 0x6a60(%rip), %rsi      # 0xa205
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x32c8
addq $0x70, %rbx
jmp 0x36df
leaq 0x98(%rsp), %rdi
callq 0x2290
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37e8
jmp 0x3802
jmp 0x3802
movq %rax, %rbx
jmp 0x380f
jmp 0x3802
jmp 0x37f3
jmp 0x37f3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
jmp 0x3805
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x32c8
leaq 0x98(%rsp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::print_data_XML()
void ScMain::print_data_XML(){
	ofstream xmlFile;
	xmlFile.open ("output.xml");

	xmlFile<<"<ESL_ARCH>"<<endl;	
	for (auto i: static_data_final){
		xmlFile<<i.get_name_XML()<<endl;	
		xmlFile<<i.get_var_XML()<<endl;	
		xmlFile<<i.get_func_XML()<<endl;
		if (i.get_name() == "sc_main")
			xmlFile<<"</Global_function>\n"<<endl;
		else
			xmlFile<<"</Module>\n"<<endl;
	}
	xmlFile<<"</ESL_ARCH>"<<endl;
	xmlFile.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %r14
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x22f0
leaq 0x69eb(%rip), %rsi      # 0xa23a
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x2030
leaq 0x69e4(%rip), %rsi      # 0xa245
leaq 0x98(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq (%r14), %rbx
movq 0x8(%r14), %r13
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x98(%rsp), %r12
cmpq %r13, %rbx
je 0x396f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bd0
movq %r15, %rdi
movq %r14, %rsi
callq 0x85ae
movq %r12, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %r14, %rsi
callq 0x889a
movq %r12, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %r14, %rsi
callq 0x8a2a
movq %r12, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x2120
movq %r15, %rdi
callq 0x2110
movq %r15, %rdi
movq %r14, %rsi
callq 0x859c
movq %r15, %rdi
leaq 0x69df(%rip), %rsi      # 0xa309
callq 0x6c26
movl %eax, %ebp
movq %r15, %rdi
callq 0x2110
testb %bpl, %bpl
leaq 0x6921(%rip), %rsi      # 0xa264
leaq 0x6906(%rip), %rax      # 0xa250
cmovneq %rax, %rsi
movq %r12, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x32c8
addq $0x70, %rbx
jmp 0x388f
leaq 0x68f9(%rip), %rsi      # 0xa26f
leaq 0x98(%rsp), %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
leaq 0x98(%rsp), %rdi
callq 0x2270
leaq 0x98(%rsp), %rdi
callq 0x2290
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39c1
jmp 0x39c6
jmp 0x39c6
jmp 0x39c6
jmp 0x39c6
movq %rax, %rbx
jmp 0x39e6
movq %rax, %rbx
jmp 0x39dc
jmp 0x39cf
jmp 0x39cf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x28(%rsp), %rdi
callq 0x32c8
leaq 0x98(%rsp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::find_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ScMain::find_element (string str){
	for (int i=0; i< static_data_final.size(); ++i){
		if (static_data_final[i].get_name() == str)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
xorl %ebx, %ebx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
cqto
pushq $0x70
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x3b23
addq %r13, %rsi
movq %r12, %rdi
callq 0x859c
movq %r12, %rdi
movq %r14, %rsi
callq 0x6db4
movl %eax, %ebp
movq %r12, %rdi
callq 0x2110
testb %bpl, %bpl
jne 0x3b28
incq %rbx
addq $0x70, %r13
jmp 0x3ade
pushq $-0x1
popq %rax
jmp 0x3b2a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::set_static_data_func(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void ScMain::set_static_data_func (string m_name, NT f_name){
	Component temp_struct;
	int index = find_element(m_name);
	
	if (index != -1){
		static_data_final[index].set_func(f_name);
	}
	else{
		temp_struct.set_name (m_name);
		temp_struct.set_func(f_name);
		static_data_final.push_back(temp_struct);		
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xf8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
leaq 0x128(%rsp), %rax
movups %xmm0, -0x38(%rax)
movups %xmm0, -0x28(%rax)
andq $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x2260
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ac0
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x4ed5
movq (%rbx), %rbx
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0x6d24
movslq %ebp, %rax
imulq $0x70, %rax, %rax
addq %rax, %rbx
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x840c
leaq 0x88(%rsp), %rdi
callq 0x334e
jmp 0x4f37
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2260
leaq 0xc8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8592
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6d24
leaq 0xc8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x840c
leaq 0x48(%rsp), %rdi
callq 0x334e
leaq 0xc8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d88
leaq 0xc8(%rsp), %rdi
callq 0x32c8
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x4f71
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x4f80
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x334e
jmp 0x4f8a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x4f8a
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x32c8
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::set_static_data_var(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>)
void ScMain::set_static_data_var (string m_name, NT v_name){
	Component temp_struct;
	int index = find_element(m_name);
	
	if (index != -1){
		static_data_final[index].set_var(v_name);	
	}
	else{
		temp_struct.set_name (m_name);
		temp_struct.set_var(v_name);
		static_data_final.push_back(temp_struct);		
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xf8(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
leaq 0x128(%rsp), %rax
movups %xmm0, -0x38(%rax)
movups %xmm0, -0x28(%rax)
andq $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x2260
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ac0
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x2110
cmpl $-0x1, %ebp
je 0x505d
movq (%rbx), %rbx
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
callq 0x6d24
movslq %ebp, %rax
imulq $0x70, %rax, %rax
addq %rax, %rbx
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x8508
leaq 0x88(%rsp), %rdi
callq 0x334e
jmp 0x50bf
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x2260
leaq 0xc8(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8592
leaq 0x8(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x6d24
leaq 0xc8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x8508
leaq 0x48(%rsp), %rdi
callq 0x334e
leaq 0xc8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d88
leaq 0xc8(%rsp), %rdi
callq 0x32c8
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x50f9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x5108
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x334e
jmp 0x5112
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2110
jmp 0x5112
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x32c8
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::find_module_func(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
NT ScMain:: find_module_func (string line){
	NT NameType;
	vector<string> split_line = split(line, ' ');
	remove_element_vector(split_line, "");

	if ((split_line.size()>1) && (!string_finder(line, "~"))){  			 //------------------- ignore constractor and destrocture function
		int index = find_in_vector(split_line, "(");
		if (index>=0){
			size_t pos = split_line[index].find("("); 
			NameType.first = split_line[index].substr(0,pos);
			NameType.second = split_line[index-1];
		}
	}
	return NameType;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
movq %rsp, %rdi
pushq $0x20
popq %rdx
movq %r14, %rsi
callq 0x7696
leaq 0x3af5(%rip), %rsi      # 0xa4ec
leaq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x31b8
movq %rsp, %rdi
leaq 0xb0(%rsp), %rsi
callq 0x7928
leaq 0xb0(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rax
subq (%rsp), %rax
cmpq $0x21, %rax
jb 0x6b41
leaq 0x90(%rsp), %rdi
movq %r14, %rsi
callq 0x2260
leaq 0x3a2d(%rip), %rsi      # 0xa47d
leaq 0x70(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x31b8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7630
movl %eax, %ebp
leaq 0x70(%rsp), %rdi
callq 0x2110
leaq 0x90(%rsp), %rdi
callq 0x2110
testb %bpl, %bpl
jne 0x6b41
leaq 0x18(%rsp), %rdi
movq %rsp, %rsi
callq 0x6e16
leaq 0x39d8(%rip), %rsi      # 0xa47f
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x31b8
leaq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x7888
movl %eax, %ebp
leaq 0x50(%rsp), %rdi
callq 0x2110
leaq 0x18(%rsp), %rdi
callq 0x322e
testl %ebp, %ebp
js 0x6b41
movl %ebp, %r12d
shlq $0x5, %r12
movq (%rsp), %rdi
addq %r12, %rdi
leaq 0x398b(%rip), %rsi      # 0xa47f
xorl %edx, %edx
callq 0x2360
movq (%rsp), %rsi
addq %r12, %rsi
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
movq %rax, %rcx
callq 0x2200
leaq 0x20(%rbx), %r14
leaq 0x30(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x2110
movq (%rsp), %rax
leaq (%rax,%r12), %rsi
addq $-0x20, %rsi
movq %r14, %rdi
callq 0x2140
movq %rsp, %rdi
callq 0x322e
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6bb0
jmp 0x6bb0
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x2110
jmp 0x6b72
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x322e
jmp 0x6bb3
jmp 0x6bb0
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x2110
jmp 0x6b92
movq %rax, %r14
leaq 0x90(%rsp), %rdi
jmp 0x6ba9
jmp 0x6bb0
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
callq 0x2110
jmp 0x6bb3
movq %rax, %r14
movq %rsp, %rdi
callq 0x322e
movq %rbx, %rdi
callq 0x334e
movq %r14, %rdi
callq 0x2300
movq %rax, %r14
jmp 0x6bbb
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: GotoLine(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
void GotoLine(ifstream& file, unsigned int num){
	file.clear();
    file.seekg(0, ios::beg);
	
    for(int i=0; i < num; ++i){
        file.ignore(numeric_limits<streamsize>::max(),'\n');
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x22e0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2250
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
pushq $0xa
popq %rbp
subl $0x1, %ebx
jb 0x768b
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2160
jmp 0x7677
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string &s, char delim) {
    vector<string> elems;
	string buff;                 //-----buffer string
    stringstream ss(s);       //-----insert the string into a stream
	
	while (getline(ss, buff, delim))
		elems.push_back(buff);
	return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rdi
pushq $0x18
popq %rdx
callq 0x22c0
movsbl %bpl, %ebp
leaq 0x20(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7705
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7fc6
jmp 0x76dd
leaq 0x20(%rsp), %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x773a
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x322e
movq %r14, %rdi
callq 0x2300