LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*)
void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
                   Test::TearDownTestCaseFunc tear_down_tc,
                   TestInfo* test_info) {
    // In order to support thread-safe death tests, we need to
    // remember the original working directory when the test program
    // was first invoked.  We cannot do this in RUN_ALL_TESTS(), as
    // the user may have changed the current directory before calling
    // RUN_ALL_TESTS().  Therefore we capture the current directory in
    // AddTestInfo(), which is called to register a TEST or TEST_F
    // before main() is reached.
    if (original_working_dir_.IsEmpty()) {
      original_working_dir_.Set(FilePath::GetCurrentDir());
      GTEST_CHECK_(!original_working_dir_.IsEmpty())
          << "Failed to get the current working directory.";
    }

    GetTestCase(test_info->test_case_name(),
                test_info->type_param(),
                set_up_tc,
                tear_down_tc)->AddTestInfo(test_info);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x1fc64
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x1b70c
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6220
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
cmpq $0x0, 0x18(%r12)
jne 0x1fc64
leaq 0x867b(%rip), %rdx      # 0x28291
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x42b, %ecx            # imm = 0x42B
callq 0x1c270
movq 0x173bf(%rip), %rdi     # 0x36ff0
leaq 0x9aa7(%rip), %rsi      # 0x296df
movl $0x33, %edx
callq 0x6510
movq 0x173a7(%rip), %rdi     # 0x36ff0
leaq 0x9ac3(%rip), %rsi      # 0x29713
movl $0x2c, %edx
callq 0x6510
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
movq (%rbx), %rsi
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x1fc75
movq (%rax), %rdx
jmp 0x1fc77
xorl %edx, %edx
movq %r12, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x14532
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe4fa
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
jmp 0x1fccc
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fccc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*)
explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
      : premature_exit_filepath_(premature_exit_filepath) {
    // If a path to the premature-exit file is specified...
    if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') {
      // create the file with a single "0" character in it.  I/O
      // errors are ignored as there's nothing better we can do and we
      // don't want to fail the test because of this.
      FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
      fwrite("0", 1, 1, pfile);
      fclose(pfile);
    }
  }

// Assembly:
movq %rsi, (%rdi)
testq %rsi, %rsi
je 0x202a9
cmpb $0x0, (%rsi)
je 0x202a9
pushq %rbx
leaq 0x88ef(%rip), %rax      # 0x28b74
movq %rsi, %rdi
movq %rax, %rsi
callq 0x6570
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0x65f0
movq %rbx, %rdi
popq %rbx
jmp 0x63f0
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::~ThreadLocal()
~ThreadLocal() {
    // Destroys the managed object for the current thread, if any.
    DeleteThreadLocalValue(pthread_getspecific(key_));

    // Releases resources associated with the key.  This will *not*
    // delete managed objects for other threads.
    GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x6780
testq %rax, %rax
je 0x2047b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x6580
testl %eax, %eax
je 0x204eb
movl %eax, %ebp
leaq 0x9144(%rip), %rdx      # 0x295d3
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xa21, %ecx            # imm = 0xA21
callq 0x1c270
movq 0x16b46(%rip), %rdi     # 0x36ff0
leaq 0x98ff(%rip), %rsi      # 0x29db0
movl $0x18, %edx
callq 0x6510
movq 0x16b2e(%rip), %rdi     # 0x36ff0
leaq 0x9136(%rip), %rsi      # 0x295ff
movl $0x12, %edx
callq 0x6510
movq 0x16b16(%rip), %rdi     # 0x36ff0
movl %ebp, %esi
callq 0x68a0
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22806
movq %rax, %rdi
callq 0x75c6
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetNextRandomSeed(int)
inline int GetNextRandomSeed(int seed) {
  GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
      << "Invalid random seed " << seed << " - must be in [1, "
      << kMaxRandomSeed << "].";
  const int next_seed = seed + 1;
  return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax          # imm = 0x1869F
jb 0x2091d
leaq 0x7a08(%rip), %rdx      # 0x28291
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x229, %ecx            # imm = 0x229
callq 0x1c270
movq 0x1674c(%rip), %rdi     # 0x36ff0
leaq 0x911b(%rip), %rsi      # 0x299c6
movl $0x36, %edx
callq 0x6510
movq 0x16734(%rip), %rdi     # 0x36ff0
leaq 0x913a(%rip), %rsi      # 0x299fd
movl $0x14, %edx
callq 0x6510
movq 0x1671c(%rip), %rdi     # 0x36ff0
movl %ebx, %esi
callq 0x68a0
movq %rax, %r14
leaq 0x912d(%rip), %rsi      # 0x29a12
movl $0x12, %edx
movq %rax, %rdi
callq 0x6510
movq %r14, %rdi
movl $0x1869f, %esi          # imm = 0x1869F
callq 0x68a0
leaq 0x911f(%rip), %rsi      # 0x29a25
movl $0x2, %edx
movq %rax, %rdi
callq 0x6510
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx          # imm = 0x1869F
movl $0x1, %eax
cmovll %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: void testing::internal::InitGoogleTestImpl<char>(int*, char**)
void InitGoogleTestImpl(int* argc, CharType** argv) {
  g_init_gtest_count++;

  // We don't want to run the initialization code twice.
  if (g_init_gtest_count != 1) return;

  if (*argc <= 0) return;

  internal::g_executable_path = internal::StreamableToString(argv[0]);

#if GTEST_HAS_DEATH_TEST

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

#endif  // GTEST_HAS_DEATH_TEST

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl 0x16374(%rip), %eax     # 0x375ec
leal 0x1(%rax), %ecx
movl %ecx, 0x1636b(%rip)     # 0x375ec
testl %eax, %eax
jne 0x21353
movq %rdi, %r14
cmpl $0x0, (%rdi)
jle 0x21353
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rsi, (%rsp)
callq 0x265c1
leaq 0x1637b(%rip), %rdi     # 0x37628
movq %r15, %rsi
callq 0x65d0
movq (%r15), %rdi
leaq 0x18(%rsp), %rbp
cmpq %rbp, %rdi
je 0x212cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x16452(%rip), %rsi     # 0x37728
leaq 0x1644b(%rip), %rdi     # 0x37728
callq 0x266e2
cmpl $0x0, (%r14)
je 0x21336
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x16432(%rip), %r12     # 0x37728
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x265c1
movq %r12, %rdi
movq %r15, %rsi
callq 0x24516
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x21327
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x212fa
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x20c0a
callq 0x7e2e
movq 0x16352(%rip), %rdi     # 0x376a0
callq 0x144a8
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 0x2137c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::CapturedStream::GetCapturedString[abi:cxx11]()
std::string GetCapturedString() {
    if (uncaptured_fd_ != -1) {
      // Restores the original stream.
      fflush(NULL);
      dup2(uncaptured_fd_, fd_);
      close(uncaptured_fd_);
      uncaptured_fd_ = -1;
    }

    FILE* const file = posix::FOpen(filename_.c_str(), "r");
    const std::string content = ReadEntireFile(file);
    posix::FClose(file);
    return content;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x2178c
xorl %edi, %edi
callq 0x6560
movl (%r14), %esi
movl 0x4(%r14), %edi
callq 0x63d0
movl 0x4(%r14), %edi
callq 0x69d0
movl $0xffffffff, 0x4(%r14)  # imm = 0xFFFFFFFF
movq 0x8(%r14), %rdi
leaq 0x8736(%rip), %rsi      # 0x29ecd
callq 0x6570
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c422
movq %r14, %rdi
callq 0x63f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::MutexBase::Unlock()
void Unlock() {
    // Since the lock is being released the owner_ field should no longer be
    // considered valid. We don't protect writing to has_owner_ here, as it's
    // the caller's responsibility to ensure that the current thread holds the
    // mutex when this is called.
    has_owner_ = false;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_));
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0x6300
testl %eax, %eax
je 0x222cf
movl %eax, %ebx
leaq 0x7360(%rip), %rdx      # 0x295d3
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x99b, %ecx            # imm = 0x99B
callq 0x1c270
movq 0x14d62(%rip), %rdi     # 0x36ff0
leaq 0x737d(%rip), %rsi      # 0x29612
movl $0x1d, %edx
callq 0x6510
movq 0x14d4a(%rip), %rdi     # 0x36ff0
leaq 0x7352(%rip), %rsi      # 0x295ff
movl $0x12, %edx
callq 0x6510
movq 0x14d32(%rip), %rdi     # 0x36ff0
movl %ebx, %esi
callq 0x68a0
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.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 = new ValueHolder(default_);
    ThreadLocalValueHolderBase* const holder_base = new_holder;
    GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base));
    return new_holder->pointer();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl (%rdi), %edi
callq 0x6780
testq %rax, %rax
je 0x224a8
movq %rax, %rdi
callq 0x2257b
movq %rax, %rbx
addq $0x8, %rbx
jmp 0x22546
movl $0x20, %edi
callq 0x6400
movq %rax, %r15
leaq 0x8(%r14), %rsi
leaq 0x14758(%rip), %rax     # 0x36c18
movq %rax, (%r15)
movq %r15, %rbx
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x2262c
movl (%r14), %edi
movq %r15, %rsi
callq 0x60c0
testl %eax, %eax
je 0x22546
movl %eax, %ebp
leaq 0x70e9(%rip), %rdx      # 0x295d3
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xa48, %ecx            # imm = 0xA48
callq 0x1c270
movq 0x14aeb(%rip), %rdi     # 0x36ff0
leaq 0x7266(%rip), %rsi      # 0x29772
movl $0x26, %edx
callq 0x6510
movq 0x14ad3(%rip), %rdi     # 0x36ff0
leaq 0x70db(%rip), %rsi      # 0x295ff
movl $0x12, %edx
callq 0x6510
movq 0x14abb(%rip), %rdi     # 0x36ff0
movl %ebp, %esi
callq 0x68a0
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x6430
jmp 0x22573
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.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));
  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 0x22612
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x7af9(%rip), %rax      # 0x2a097
cmpq %rax, %rdi
je 0x225f5
cmpb $0x2a, (%rdi)
je 0x225b8
leaq 0x7ae8(%rip), %rsi      # 0x2a097
callq 0x66d0
testl %eax, %eax
je 0x225f5
leaq 0x7014(%rip), %rdx      # 0x295d3
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x8ce, %ecx            # imm = 0x8CE
callq 0x1c270
movq 0x14a16(%rip), %rdi     # 0x36ff0
leaq 0x71b8(%rip), %rsi      # 0x29799
movl $0x33, %edx
callq 0x6510
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
leaq 0x145e4(%rip), %rsi     # 0x36be0
leaq 0x145ed(%rip), %rdx     # 0x36bf0
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x6500
callq 0x64b0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::OnTestProgramEnd(testing::UnitTest const&)
void OnTestProgramEnd(const UnitTest& unit_test) {
    // Note that Google Test current only report elapsed time for each
    // test iteration, not for the entire test program.
    SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed()));

    // Notify the streaming server to stop.
    socket_writer_->CloseConnection();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x200b0
leaq 0x552b(%rip), %rcx      # 0x2930b
leaq 0x5e10(%rip), %rsi      # 0x29bf7
testb %al, %al
cmovneq %rcx, %rsi
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x550f(%rip), %rax      # 0x2930c
leaq 0x5df4(%rip), %rdx      # 0x29bf8
cmovneq %rax, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x247da
leaq 0x5b8d(%rip), %rcx      # 0x299a9
movl $0x1c, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x64f0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x23e54
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x23e5b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rbx), %rdi
callq 0x2411c
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x23e94
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23eab
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x23edd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6430
jmp 0x23edd
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23ef4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
virtual void Send(const string& message) {
      GTEST_CHECK_(sockfd_ != -1)
          << "Send() can be called only when there is a connection.";

      const int len = static_cast<int>(message.length());
      if (write(sockfd_, message.c_str(), len) != len) {
        GTEST_LOG_(WARNING)
            << "stream_result_to: failed to stream to "
            << host_name_ << ":" << port_num_;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x23fd6
leaq 0x4309(%rip), %rdx      # 0x28291
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x5e1, %ecx            # imm = 0x5E1
callq 0x1c270
movq 0x1304d(%rip), %rdi     # 0x36ff0
leaq 0x5823(%rip), %rsi      # 0x297cd
movl $0x20, %edx
callq 0x6510
movq 0x13035(%rip), %rdi     # 0x36ff0
leaq 0x582c(%rip), %rsi      # 0x297ee
movl $0x35, %edx
callq 0x6510
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
movslq 0x8(%r14), %r15
movl 0x8(%rbx), %edi
movq (%r14), %rsi
movq %r15, %rdx
callq 0x6170
cmpq %r15, %rax
je 0x24065
leaq 0x429d(%rip), %rdx      # 0x28291
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
movl $0x5e6, %ecx            # imm = 0x5E6
callq 0x1c270
movq 0x12fe1(%rip), %rdi     # 0x36ff0
leaq 0x580e(%rip), %rsi      # 0x29824
movl $0x26, %edx
callq 0x6510
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x12fc1(%rip), %rdi     # 0x36ff0
callq 0x6510
movq %rax, %r14
leaq 0x4df1(%rip), %rsi      # 0x28e2f
movl $0x1, %edx
movq %rax, %rdi
callq 0x6510
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
movq %r14, %rdi
callq 0x6510
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
jmp 0x24081
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamingListener::SocketWriter::CloseConnection()
void CloseConnection() {
      GTEST_CHECK_(sockfd_ != -1)
          << "CloseConnection() can be called only when there is a connection.";

      close(sockfd_);
      sockfd_ = -1;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $-0x1, 0x8(%rdi)
jne 0x240f1
leaq 0x41ee(%rip), %rdx      # 0x28291
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x5f2, %ecx            # imm = 0x5F2
callq 0x1c270
movq 0x12f32(%rip), %rdi     # 0x36ff0
leaq 0x5708(%rip), %rsi      # 0x297cd
movl $0x20, %edx
callq 0x6510
movq 0x12f1a(%rip), %rdi     # 0x36ff0
leaq 0x576e(%rip), %rsi      # 0x2984b
movl $0x40, %edx
callq 0x6510
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
movl 0x8(%rbx), %edi
callq 0x69d0
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::UniversalTersePrinter<char const*>::Print(char const*, std::ostream*)
static void Print(const char* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(string(str), os);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x249d5
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x61c0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x247da
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x1c978
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x249c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4b21(%rip), %rsi      # 0x294fd
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6510
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24a0e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*)
static void Print(const wchar_t* str, ::std::ostream* os) {
    if (str == NULL) {
      *os << "NULL";
    } else {
      UniversalPrint(::std::wstring(str), os);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x24a86
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x6380
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x24acc
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq 0x1ca86
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24a7a
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6430
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4a70(%rip), %rsi      # 0x294fd
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x6510
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24ac4
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6430
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const
bool AlmostEquals(const FloatingPoint& rhs) const {
    // The IEEE standard says that any comparison operation involving
    // a NAN must return false.
    if (is_nan() || rhs.is_nan()) return false;

    return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
        <= kMaxUlps;
  }

// Assembly:
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movq (%rdi), %rax
movq %rax, %rcx
notq %rcx
testq %rdx, %rcx
sete %cl
movq %rax, %rdi
shlq $0xc, %rdi
setne %dil
testb %dil, %cl
jne 0x24e60
movabsq $0xfffffffffffff, %rdi  # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rcx
movq %rcx, %rsi
notq %rsi
testq %rsi, %rdx
sete %dl
testq %rdi, %rcx
setne %sil
testb %sil, %dl
je 0x24e63
xorl %eax, %eax
retq
movq %rax, %rdx
negq %rdx
movq %rax, %rsi
btsq $0x3f, %rsi
testq %rax, %rax
cmovsq %rdx, %rsi
movq %rcx, %rax
negq %rax
movq %rcx, %rdx
btsq $0x3f, %rdx
testq %rcx, %rcx
cmovsq %rax, %rdx
movq %rsi, %rax
subq %rdx, %rax
negq %rax
subq %rdx, %rsi
cmovbq %rax, %rsi
cmpq $0x5, %rsi
setb %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::CreateKey()
static pthread_key_t CreateKey() {
    pthread_key_t key;
    // When a thread exits, DeleteThreadLocalValue() will be called on
    // the object managed for that thread.
    GTEST_CHECK_POSIX_SUCCESS_(
        pthread_key_create(&key, &DeleteThreadLocalValue));
    return key;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x92(%rip), %rsi        # 0x26290
leaq 0xc(%rsp), %rdi
callq 0x67f0
testl %eax, %eax
je 0x26271
movl %eax, %ebx
leaq 0x33be(%rip), %rdx      # 0x295d3
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0xa3b, %ecx            # imm = 0xA3B
callq 0x1c270
movq 0x10dc0(%rip), %rdi     # 0x36ff0
leaq 0x3b47(%rip), %rsi      # 0x29d7e
movl $0x31, %edx
callq 0x6510
movq 0x10da8(%rip), %rdi     # 0x36ff0
leaq 0x33b0(%rip), %rsi      # 0x295ff
movl $0x12, %edx
callq 0x6510
movq 0x10d90(%rip), %rdi     # 0x36ff0
movl %ebx, %esi
callq 0x68a0
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1c3b2
movq %rbx, %rdi
callq 0x68e0
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/jacobi.cpp
// Function: matrix_vector_mult(int, double const*, double const*, double*)
void matrix_vector_mult(const int n, const double* A, const double* x, double* y)
{
    for (int i = 0; i < n; i++) {
        y[i] = 0;
        for (int j = 0; j < n; j++) {
            y[i] += A[i * n + j] * x[j];
        }
    }
}

// Assembly:
testl %edi, %edi
jle 0x269b1
movl %edi, %eax
leaq (,%rax,8), %rdi
xorl %r8d, %r8d
movq $0x0, (%rcx,%r8,8)
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movsd (%rsi,%r9,8), %xmm1
mulsd (%rdx,%r9,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx,%r8,8)
incq %r9
cmpq %r9, %rax
jne 0x26988
incq %r8
addq %rdi, %rsi
cmpq %rax, %r8
jne 0x26979
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeihuaZhu[P]hpc_prog2/jacobi.cpp
// Function: matrix_vector_mult(int, int, double const*, double const*, double*)
void matrix_vector_mult(const int n, const int m, const double* A, const double* x, double* y)
{
    for (int i = 0; i < n; i++) {
        y[i] = 0;
        for (int j = 0; j < m; j++) {
            y[i] += A[i * m + j] * x[j];
        }
    }
}

// Assembly:
testl %edi, %edi
jle 0x26a03
movl %esi, %eax
movl %edi, %edi
leaq (,%rax,8), %r9
xorl %r10d, %r10d
movq $0x0, (%r8,%r10,8)
testl %esi, %esi
jle 0x269f8
movsd (%r8,%r10,8), %xmm0
xorl %r11d, %r11d
movsd (%rdx,%r11,8), %xmm1
mulsd (%rcx,%r11,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r8,%r10,8)
incq %r11
cmpq %r11, %rax
jne 0x269da
incq %r10
addq %r9, %rdx
cmpq %rdi, %r10
jne 0x269c5
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzeller[P]jcxxgen/schema-compiler.cc
// Function: main
int main(int argc, char *argv[]) {
  if (argc < 2) {
    fprintf(stderr, "usage: %s [options] <protocol-spec-yaml>\n", argv[0]);
    fprintf(stderr, "Options:\n"
            "  -o <filename>     : Output to filename\n"
            "  -j <json-include> : Include path to json.hpp, "
            "including brackets <> or quotes \"\" around.\n"
            "                      Default: '<nlohmann/json.hpp>'\n");
    return 1;
  }

  const char *out_filename = nullptr;
  const char *nlohmann_json_include = "<nlohmann/json.hpp>";
  int opt;
  while ((opt = getopt(argc, argv, "o:")) != -1) {
    switch (opt) {
    case 'o': out_filename = strdup(optarg); break;
    case 'j': nlohmann_json_include = strdup(optarg); break;
    }
  }

  const char *schema_filename = argv[optind];
  auto objects = LoadObjectTypes(schema_filename);
  if (!objects) {
    fprintf(stderr, "Couldn't parse spec\n");
    return 2;
  }

  FILE *out = stdout;
  if (out_filename) {
    out = fopen(out_filename, "w");
    if (!out) {
      perror("opening output file");
      return 3;
    }
  }

  GenerateCode(schema_filename, nlohmann_json_include, *objects, out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
cmpl $0x2, %edi
jl 0x6b0a
movl %edi, %r12d
leaq 0xfae7(%rip), %rbx      # 0x1650a
xorl %r14d, %r14d
leaq 0xfaf1(%rip), %r13      # 0x1651e
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
callq 0x4080
cmpl $-0x1, %eax
je 0x6a72
cmpl $0x6a, %eax
je 0x6a5e
cmpl $0x6f, %eax
jne 0x6a2d
movq 0x18527(%rip), %rax     # 0x1ef78
movq (%rax), %rdi
callq 0x44b0
movq %rax, %r14
jmp 0x6a2d
movq 0x18513(%rip), %rax     # 0x1ef78
movq (%rax), %rdi
callq 0x44b0
movq %rax, %rbx
jmp 0x6a2d
movq 0x18537(%rip), %rax     # 0x1efb0
movslq (%rax), %rax
movq (%r15,%rax,8), %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x489c
cmpq $0x0, (%r12)
je 0x6b1a
testq %r14, %r14
je 0x6aca
leaq 0xfa90(%rip), %rsi      # 0x16536
movq %r14, %rdi
callq 0x4330
movq %rax, %rcx
testq %rax, %rax
jne 0x6ad4
leaq 0xfa7b(%rip), %rdi      # 0x16538
callq 0x4230
movl $0x3, %r14d
jmp 0x6ae6
movq 0x1848f(%rip), %rax     # 0x1ef60
movq (%rax), %rcx
xorl %r14d, %r14d
movq -0x30(%rbp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6276
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6af8
leaq -0x30(%rbp), %rdi
callq 0x15d6c
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x4585
movl $0x1, %r14d
jmp 0x6af8
callq 0x4556
movl $0x2, %r14d
jmp 0x6ae6
movq %rax, %rbx
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6b3c
leaq -0x30(%rbp), %rdi
callq 0x15d6c
movq %rbx, %rdi
callq 0x4480
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/Register/RegisterBlock.cpp
// Function: RegisterBlock::createRegisters()
void RegisterBlock::createRegisters()
{
    _addressRegister.name = "A";
    for(size_t i = 1; i < 8; i++){
        Register r;
        char c =  'A' + i;
        r.name = c;
        _registers.push_back(r);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
addq $0x20, %rdi
movq 0x28(%rbx), %rdx
leaq 0x32792(%rip), %rcx     # 0x38094
xorl %r12d, %r12d
movl $0x1, %r8d
xorl %esi, %esi
callq 0x4440
leaq 0x20(%rsp), %r13
leaq 0x40(%rsp), %rbp
addq $0x68, %rbx
movq $-0x7, %r14
movq %rsp, %r15
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movb %r12b, 0x20(%rsp)
movq %rbp, 0x30(%rsp)
movq %r12, 0x38(%rsp)
movb %r12b, 0x40(%rsp)
movb %r12b, 0x50(%rsp)
callq 0x40b0
cltq
movq %rax, 0x8(%rsp)
movl $0x0, (%rsp)
leal 0x49(%r14), %eax
movq 0x18(%rsp), %rdx
movsbl %al, %r8d
movl $0x1, %ecx
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x44f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbdc6
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x59a0
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x59b7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
incq %r14
jne 0x592a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbdf0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/Register/Register.hpp
// Function: operator<<(std::ostream&, Register const&)
std::ostream& operator<<(std::ostream& os, const Register& r)
    {
        os <<"\t"<< r.name << " ";
        switch(r.state)
        {
            case RegisterState::UNKNOWN:
            {
                os << "unknown state";
                break;
            }
            case RegisterState::VARIABLE:
            {
                os << "variable="<<r.variableName;
                break;
            }
            case RegisterState::CONST:
            {
                os << "const="<<r.constValue<<" "<<r.variableName;
                break;
            }
            case RegisterState::TABLE:
            {
                os << "table="<<r.variableName;
                break;
            }
            case RegisterState::CONSTVARIABLE:
            {
                os <<"constvalue"<<r.variableName<<" with value "<<r.constValue;
            }
        }
        return os;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2c143(%rip), %rsi     # 0x380e2
movl $0x1, %edx
callq 0x4310
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movq %rbx, %rdi
callq 0x4310
leaq 0x2d4ab(%rip), %rsi     # 0x3946b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4310
movl (%r14), %eax
cmpq $0x4, %rax
ja 0xc0ba
leaq 0x2c09f(%rip), %rcx     # 0x38080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2c0f3(%rip), %rsi     # 0x380e4
movl $0xd, %edx
jmp 0xc0b2
leaq 0x2c108(%rip), %rsi     # 0x3810a
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4310
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x4310
movq %rax, %r15
leaq 0x2c0ec(%rip), %rsi     # 0x38115
movl $0xc, %edx
movq %rax, %rdi
callq 0x4310
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x41b0
jmp 0xc0ba
leaq 0x2c0b1(%rip), %rsi     # 0x380fc
movl $0x6, %edx
movq %rbx, %rdi
callq 0x4310
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x41b0
movq %rax, %r15
leaq 0x2d3fd(%rip), %rsi     # 0x3946b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4310
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %r15, %rdi
jmp 0xc0b5
leaq 0x2c074(%rip), %rsi     # 0x38103
movl $0x6, %edx
jmp 0xc0a2
leaq 0x2c055(%rip), %rsi     # 0x380f2
movl $0x9, %edx
movq %rbx, %rdi
callq 0x4310
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x4310
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/Calculators/NumberGenerator.cpp
// Function: NumberGenerator::getCostWithIncAndAdd(unsigned long long)
int NumberGenerator::getCostWithIncAndAdd(unsigned long long target)
{
    int cost = 0;
    while (target > 10)
    {
        if (target % 2 == 0)
        {
            target = target / 2;
            cost += 5;
        }
        else
        {
            target--;
            cost++;
        }
    }
    return cost + target;
}

// Assembly:
xorl %ecx, %ecx
cmpq $0xb, %rdi
jb 0x1974a
xorl %ecx, %ecx
movq %rdi, %rax
movq %rdi, %rdx
shrq %rdx
decq %rax
xorl %esi, %esi
testb $0x1, %dil
cmoveq %rdx, %rax
sete %sil
leal (%rcx,%rsi,4), %ecx
incl %ecx
movq %rax, %rdi
cmpq $0xa, %rax
ja 0x19723
jmp 0x1974d
movq %rdi, %rax
addl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::addVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SymbolTable::addVariable(std::string name)
{
    if (isNameTaken(name))
    {
        return "second " + name + " declaration!";
    }
    Variable v;
    _variables[name] = v;
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xca12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a78e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a687
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1a6d4
leaq 0x1dd02(%rip), %rsi     # 0x38395
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5474
leaq 0x1dcf3(%rip), %rsi     # 0x3839d
movq %r15, %rdi
callq 0x4510
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1a709
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1a70f
addq $0x40, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b4ea
movb $0x0, (%rax)
movq $0x0, 0x8(%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d9e7(%rip), %rdx     # 0x380e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x54fc
jmp 0x1a741
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a741
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a785
movq 0x38(%rsp), %rsi
jmp 0x1a77d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a785
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::isNameTaken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool SymbolTable::isNameTaken(std::string name)
{
    if(_variables.find(name) != _variables.end())
    {
        return true;
    }
    if(_tables.find(name) != _tables.end())
    {
        return true;
    }
    if(_currentIterators.find(name) != _currentIterators.end())
    {
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rdi
callq 0x1bab4
leaq 0x48(%rbx), %rcx
movb $0x1, %bpl
cmpq %rcx, %rax
jne 0x1a7df
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1bec0
leaq 0x78(%rbx), %rcx
cmpq %rcx, %rax
jne 0x1a7df
leaq 0xd0(%rbx), %rdi
movq %r14, %rsi
callq 0x1bafa
addq $0xd8, %rbx
cmpq %rbx, %rax
setne %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::getMemoryCell(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
unsigned long long SymbolTable::getMemoryCell(std::string name)
{
    if (_variables.find(name) != _variables.end())
    {
        return _variables[name].memoryCell;
    }

    if(_allIterators.find(name) != _allIterators.end())
    {
        return _allIterators[name].memoryCell;
    }

    if (_tables.find(name) != _tables.end())
    {
        return _tables[name].memoryCellStart;
    }
    std::cerr<<"ADDRESS OF "<<name<<" WAS NOT FOUND"<<std::endl;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x1bab4
leaq 0x48(%r14), %rcx
cmpq %rcx, %rax
je 0x1a817
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b4ea
movq 0x8(%rax), %rax
jmp 0x1a868
leaq 0x100(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1bafa
leaq 0x108(%r14), %rcx
cmpq %rcx, %rax
je 0x1a842
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b566
jmp 0x1a865
leaq 0x70(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1bec0
addq $0x78, %r14
cmpq %r14, %rax
je 0x1a86e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b5e2
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x2b77b(%rip), %r14     # 0x45ff0
leaq 0x1db2f(%rip), %rsi     # 0x383ab
movl $0xb, %edx
movq %r14, %rdi
callq 0x4310
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
leaq 0x1db15(%rip), %rsi     # 0x383b7
movl $0xe, %edx
movq %rax, %rdi
callq 0x4310
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41c0
xorl %eax, %eax
jmp 0x1a868
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::assignMemory()
void SymbolTable::assignMemory()
{
    for(auto& v : _variables)
    {
        if (!v.second.isInitialized)
        {
            _variables.erase(v.first);
        }
    }
    ull index = 0;
    //variables
    for (auto& v : _variables)
    {
        v.second.memoryCell = index;
        index++;
    } 

    //iterators
    for(auto& i : _allIterators)
    {
        i.second.memoryCell = index;
        index++;
    }

    //tables
    for(auto& t : _tables)
    {
        t.second.memoryCellStart = index;
        index += t.second.endIndex - t.second.beginIndex + 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %r14
leaq 0x48(%rdi), %r12
cmpq %r12, %r14
je 0x1a924
leaq 0x40(%rbx), %r15
cmpb $0x0, 0x40(%r14)
jne 0x1a914
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x1c28a
movq %r15, %rdi
movq %rax, %rsi
callq 0x1c332
movq %r14, %rdi
callq 0x41d0
movq %rax, %r14
cmpq %r12, %rax
jne 0x1a8f6
movq 0x58(%rbx), %rax
xorl %r14d, %r14d
cmpq %r12, %rax
je 0x1a941
movq %r14, 0x48(%rax)
incq %r14
movq %rax, %rdi
callq 0x41d0
jmp 0x1a92b
movq 0x118(%rbx), %rax
leaq 0x108(%rbx), %r15
cmpq %r15, %rax
je 0x1a965
movq %r14, 0x40(%rax)
incq %r14
movq %rax, %rdi
callq 0x41d0
jmp 0x1a94f
movq 0x88(%rbx), %rax
addq $0x78, %rbx
cmpq %rbx, %rax
je 0x1a98e
movq %r14, 0x40(%rax)
addq 0x50(%rax), %r14
subq 0x48(%rax), %r14
incq %r14
movq %rax, %rdi
callq 0x41d0
jmp 0x1a970
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::addTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long long, unsigned long long)
std::string SymbolTable::addTable(std::string name, ull beginIndex, ull endIndex)
{
    if (isNameTaken(name))
    {
        return "second " + name + " declaration!";
    }
    if (beginIndex > endIndex)
    {
        return "wrong " + name + " table size!";
    }
    Table t;
    t.beginIndex = beginIndex;
    t.endIndex = endIndex;
    _tables[name] = t;
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rcx, 0x20(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0xca12
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1a78e
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1aa69
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1aa94
leaq 0x1d920(%rip), %rsi     # 0x38395
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5474
leaq 0x1d913(%rip), %rsi     # 0x3839d
movq %r15, %rdi
callq 0x4510
jmp 0x1aac6
movq 0x20(%rsp), %r15
cmpq %r12, %r15
jbe 0x1ab22
leaq 0x1d927(%rip), %rsi     # 0x383d0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5474
leaq 0x1d919(%rip), %rsi     # 0x383d7
movq %r15, %rdi
callq 0x4510
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1aae8
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1aaee
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ab5f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1ab5f
addq $0x70, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1b5e2
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movw $0x0, 0x18(%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d58f(%rip), %rdx     # 0x380e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x54fc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ab73
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1aba5
movq 0x10(%rsp), %rsi
jmp 0x1ab9d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1aba5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::checkVariableExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SymbolTable::checkVariableExists(std::string name)
{
    if (name.find("(") != std::string::npos)
    {
        name = name.substr(0, name.find("("));
    }

    if (! isNameTaken(name))
    {
        return "undeclared variable " + name;
    }
    if (_variables.find(name) != _variables.end())
    {
        _variables[name].isInitialized = true;
    }
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1e9f1(%rip), %rsi     # 0x395bd
movl $0x1, %ecx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x1ac32
leaq 0x1e9d5(%rip), %rsi     # 0x395bd
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1ac32
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xca12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a78e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ac76
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1acbc
leaq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bab4
addq $0x48, %r15
cmpq %r15, %rax
je 0x1aca1
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b4ea
movb $0x1, (%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d434(%rip), %rdx     # 0x380e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x54fc
jmp 0x1acce
leaq 0x1d721(%rip), %rsi     # 0x383e4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5474
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1acfa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::checkVariableExistsAndIsInitialized(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SymbolTable::checkVariableExistsAndIsInitialized(std::string name)
{
    if (name.find("(") != std::string::npos)
    {
        name = name.substr(0, name.find("("));
    }

    if (! isNameTaken(name))
    {
        return "undeclared variable " + name;
    }
    if (_variables.find(name) != _variables.end())
    {
        if (! _variables[name].isInitialized)
        {
            return "using uninitialized variable " + name;
        }
    }

    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1e7c1(%rip), %rsi     # 0x395bd
movl $0x1, %ecx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x1ae62
leaq 0x1e7a5(%rip), %rsi     # 0x395bd
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1ae62
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xca12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a78e
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1aea6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1aeee
leaq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1bab4
addq $0x48, %r15
cmpq %r15, %rax
je 0x1aed3
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b4ea
cmpb $0x0, (%rax)
je 0x1aef7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1d202(%rip), %rdx     # 0x380e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x54fc
jmp 0x1af09
leaq 0x1d4ef(%rip), %rsi     # 0x383e4
jmp 0x1aefe
leaq 0x1d532(%rip), %rsi     # 0x38430
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5474
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1af35
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::addToIterators(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SymbolTable::addToIterators(std::string name)
{
    Iterator i;
    _currentIterators[name] = i;
    _allIterators[name] = i;
    Iterator iForControl;
    std::string newName = name + forControlName;
    _allIterators[newName] = iForControl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0xd0, %rdi
callq 0x1b566
xorl %r12d, %r12d
movq %r12, (%rax)
leaq 0x100(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b566
movq %r12, (%rax)
addq $0x20, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b6da
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b566
movq $0x0, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b324
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b34e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0