LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/./src/sandbox.cpp
// Function: sandboxInit(int)
int sandboxInit(int boxid)
{
   ostringstream sout;
   sout << "isolate --box-id=" << boxid;
   sout << " --cg";
   sout << " --init 2>/dev/null >/dev/null";
   cerr << "[debug] box-" << boxid << " inited" << endl;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x4480
movq -0x1c0(%rbp), %rdi
leaq 0x9739(%rip), %rsi      # 0xf2d8
callq 0x4320
movq %rax, -0x1b8(%rbp)
jmp 0x5bad
movq -0x1b8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x45e0
jmp 0x5bbe
leaq 0x9725(%rip), %rsi      # 0xf2ea
leaq -0x180(%rbp), %rdi
callq 0x4320
jmp 0x5bd3
leaq 0x97d7(%rip), %rsi      # 0xf3b1
leaq -0x180(%rbp), %rdi
callq 0x4320
jmp 0x5be8
movq 0xf401(%rip), %rdi      # 0x14ff0
leaq 0x979a(%rip), %rsi      # 0xf390
callq 0x4320
movq %rax, -0x1c8(%rbp)
jmp 0x5c04
movq -0x1c8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x45e0
movq %rax, -0x1d0(%rbp)
jmp 0x5c1c
movq -0x1d0(%rbp), %rdi
leaq 0x97a6(%rip), %rsi      # 0xf3d0
callq 0x4320
movq %rax, -0x1d8(%rbp)
jmp 0x5c38
movq -0x1d8(%rbp), %rdi
movq 0xf362(%rip), %rsi      # 0x14fa8
callq 0x4370
jmp 0x5c4d
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x4350
jmp 0x5c62
leaq -0x1b0(%rbp), %rdi
callq 0x4180
movq %rax, %rdi
callq 0x42f0
jmp 0x5c78
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
xorl %eax, %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x5ccd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
movq -0x188(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/./src/sandbox.cpp
// Function: sandboxDele(int)
int sandboxDele(int boxid)
{
   ostringstream sout;
   sout << "isolate --box-id=" << boxid;
   sout << " --cg";
   sout << " --cleanup 2>/dev/null >/dev/null";
   cerr << "[debug] box-" << boxid << " cleaned" << endl;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x4480
movq -0x1c0(%rbp), %rdi
leaq 0x95b9(%rip), %rsi      # 0xf2d8
callq 0x4320
movq %rax, -0x1b8(%rbp)
jmp 0x5d2d
movq -0x1b8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x45e0
jmp 0x5d3e
leaq 0x95a5(%rip), %rsi      # 0xf2ea
leaq -0x180(%rbp), %rdi
callq 0x4320
jmp 0x5d53
leaq 0x967e(%rip), %rsi      # 0xf3d8
leaq -0x180(%rbp), %rdi
callq 0x4320
jmp 0x5d68
movq 0xf281(%rip), %rdi      # 0x14ff0
leaq 0x961a(%rip), %rsi      # 0xf390
callq 0x4320
movq %rax, -0x1c8(%rbp)
jmp 0x5d84
movq -0x1c8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x45e0
movq %rax, -0x1d0(%rbp)
jmp 0x5d9c
movq -0x1d0(%rbp), %rdi
leaq 0x9650(%rip), %rsi      # 0xf3fa
callq 0x4320
movq %rax, -0x1d8(%rbp)
jmp 0x5db8
movq -0x1d8(%rbp), %rdi
movq 0xf1e2(%rip), %rsi      # 0x14fa8
callq 0x4370
jmp 0x5dcd
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x4350
jmp 0x5de2
leaq -0x1b0(%rbp), %rdi
callq 0x4180
movq %rax, %rdi
callq 0x42f0
jmp 0x5df8
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
xorl %eax, %eax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x5e4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
movq -0x188(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/./src/server_io.cpp
// Function: respondValidating(int)
int respondValidating(int submission_id)
{
   ostringstream sout;
   sout << "respond_validating.py " << submission_id;
   system(sout.str().c_str());
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movl %edi, -0x4(%rbp)
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x4480
movq -0x1c0(%rbp), %rdi
leaq 0x3225(%rip), %rsi      # 0xf704
callq 0x4320
movq %rax, -0x1b8(%rbp)
jmp 0xc4ed
movq -0x1b8(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x45e0
jmp 0xc4fe
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x4350
jmp 0xc513
leaq -0x1b0(%rbp), %rdi
callq 0x4180
movq %rax, %rdi
callq 0x42f0
jmp 0xc529
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
xorl %eax, %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0xc57e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x4240
leaq -0x180(%rbp), %rdi
callq 0x40d0
movq -0x188(%rbp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/./src/utils.h
// Function: fromVerdict::toAbr() const
const char* toAbr() const
		{
			switch(verdict){
				case AC:
					return "AC";
				case WA:
					return "WA";
				case TLE:
					return "TLE";
				case MLE:
					return "MLE";
				case OLE:
					return "OLE";
				case RE:
					return "RE";
				case SIG:
					return "SIG";
				case CE:
					return "CE";
				case CO:
					return "CO";
				case ER:
					return "ER";
                                default:
                                        return "";
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0xe459
movq -0x18(%rbp), %rax
leaq 0x12e9(%rip), %rcx      # 0xf6b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1437(%rip), %rax      # 0xf812
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x142a(%rip), %rax      # 0xf815
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x1420(%rip), %rax      # 0xf818
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x1417(%rip), %rax      # 0xf81c
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x140e(%rip), %rax      # 0xf820
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x10d2(%rip), %rax      # 0xf4f1
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x13f8(%rip), %rax      # 0xf824
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x13a9(%rip), %rax      # 0xf7e2
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x13e2(%rip), %rax      # 0xf828
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x1392(%rip), %rax      # 0xf7e5
movq %rax, -0x8(%rbp)
jmp 0xe464
leaq 0x110a(%rip), %rax      # 0xf56a
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/silverneko[P]miku/./src/utils.h
// Function: fromVerdict::toStr() const
const char* toStr() const
		{
			switch(verdict){
				case AC:
					return "Accepted";
				case WA:
					return "Wrong Answer";
				case TLE:
					return "Time Limit Exceeded";
				case MLE:
					return "Segmentation Fault";
				case OLE:
					return "Output Limit Exceeded";
				case RE:
					return "Runtime Error (exited with nonzero status)";
				case SIG:
					return "Runtime Error (exited with signal)";
				case CE:
					return "Compile Error";
				case CO:
					return "Compilation Timed Out";
				case ER:
					return "WTF!";
                                default:
                                        return "nil";
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $-0xa, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0xe529
movq -0x18(%rbp), %rax
leaq 0x1241(%rip), %rcx      # 0xf6dc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1380(%rip), %rax      # 0xf82b
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x1379(%rip), %rax      # 0xf834
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x1379(%rip), %rax      # 0xf841
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x1380(%rip), %rax      # 0xf855
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x1386(%rip), %rax      # 0xf868
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x138f(%rip), %rax      # 0xf87e
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x13ad(%rip), %rax      # 0xf8a9
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x13c3(%rip), %rax      # 0xf8cc
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x13c4(%rip), %rax      # 0xf8da
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x13cd(%rip), %rax      # 0xf8f0
movq %rax, -0x8(%rbp)
jmp 0xe534
leaq 0x13c5(%rip), %rax      # 0xf8f5
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::ThreadStateInit(t2::ThreadState*, t2::BuildQueue*, unsigned long, int)
static void ThreadStateInit(ThreadState* self, BuildQueue* queue, size_t scratch_size, int index)
  {
    HeapInit(&self->m_LocalHeap);
    LinearAllocInit(&self->m_ScratchAlloc, &self->m_LocalHeap, scratch_size, "thread-local scratch");
    self->m_ThreadIndex = index;
    self->m_Queue       = queue;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18920
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1f151(%rip), %rcx     # 0x23a58
callq 0x189e0
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::BuildThreadRoutine(void*)
static ThreadRoutineReturnType TUNDRA_STDCALL BuildThreadRoutine(void* param)
  {
    ThreadState *thread_state = static_cast<ThreadState*>(param);

    LinearAllocSetOwner(&thread_state->m_ScratchAlloc, ThreadCurrent());

    BuildLoop(thread_state);

    return 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
callq 0x1eb20
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x18b00
movq -0x10(%rbp), %rdi
callq 0x4cb0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::BuildQueueBuildNodeRange(t2::BuildQueue*, int, int, int)
BuildResult::Enum BuildQueueBuildNodeRange(BuildQueue* queue, int start_index, int count, int pass_index)
  {
    // Make sure none of the build threads see in-progress state due to a spurious wakeup.
    MutexLock(&queue->m_Lock);

    CHECK(start_index + count <= queue->m_Config.m_MaxNodes);

    queue->m_CurrentPassIndex = pass_index;

    // Initialize build queue with index range to build
    int32_t   *build_queue = queue->m_Queue;
    NodeState *node_states = queue->m_Config.m_NodeState;

    for (int i = 0; i < count; ++i)
    {
      NodeState* state = node_states + start_index + i;

      NodeStateFlagQueued(state);

      // Verify node hasn't been touched already
      CHECK(state->m_Progress == BuildProgress::kInitial);

      build_queue[i] = start_index + i;
    }

    queue->m_PendingNodeCount = count;
    queue->m_FailedNodeCount  = 0;
    queue->m_QueueWriteIndex  = count;
    queue->m_QueueReadIndex   = 0;

    MutexUnlock(&queue->m_Lock);

    CondBroadcast(&queue->m_WorkAvailable);

    // This thread is thread 0.
    BuildLoop(&queue->m_ThreadState[0]);

    if (SignalGetReason())
      return BuildResult::kInterrupted;
    else if (queue->m_FailedNodeCount)
      return BuildResult::kBuildError;
    else
      return BuildResult::kOk;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69b0
jmp 0x4ba0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xf0(%rax)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4c1c
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq -0x34(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x6af0
jmp 0x4c00
movl -0x14(%rbp), %edx
addl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4bcf
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xec(%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x10(%rbp), %rdi
callq 0x69f0
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x6a30
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rdi
callq 0x4cb0
callq 0x1d940
cmpq $0x0, %rax
je 0x4c86
movl $0x1, -0x4(%rbp)
jmp 0x4ca3
movq -0x10(%rbp), %rax
cmpl $0x0, 0xec(%rax)
je 0x4c9c
movl $0x2, -0x4(%rbp)
jmp 0x4ca3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::BuildLoop(t2::ThreadState*)
static void BuildLoop(ThreadState* thread_state)
  {
    BuildQueue        *queue = thread_state->m_Queue;
    ConditionVariable *cv    = &queue->m_WorkAvailable;
    Mutex             *mutex = &queue->m_Lock;

    MutexLock(mutex);

    while (ShouldKeepBuilding(queue, thread_state->m_ThreadIndex))
    {
      if (NodeState* node = NextNode(queue))
      {
        AdvanceNode(queue, thread_state, node, mutex);
      }
      else
      {
        CondWait(cv, mutex);
      }
    }

    MutexUnlock(mutex);

    Log(kSpam, "build thread %d exiting\n", thread_state->m_ThreadIndex);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x69b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x4d60
testb $0x1, %al
jne 0x4cfb
jmp 0x4d35
movq -0x10(%rbp), %rdi
callq 0x4df0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4d26
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x4ea0
jmp 0x4d33
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b80
jmp 0x4ce5
movq -0x20(%rbp), %rdi
callq 0x69f0
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
movl $0x10, %edi
leaq 0x1edb3(%rip), %rsi     # 0x23b04
movb $0x0, %al
callq 0x7a60
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::ShouldKeepBuilding(t2::BuildQueue*, int)
static bool ShouldKeepBuilding(BuildQueue* queue, int thread_index)
  {
    // Stop running if we were signalled
    if (nullptr != SignalGetReason())
      return false;

    // Stop running if there are errors and we're stopping on the first error.
    if (queue->m_FailedNodeCount > 0)
    {
      if (0 == (queue->m_Config.m_Flags & BuildQueueConfig::kFlagContinueOnError))
      {
        return false;
      }
    }

    // If we're quitting, definitely stop building.
    if (queue->m_QuitSignalled)
      return false;

    // If we're a worker thread, keep running until we quit.
    if (0 != thread_index)
      return true;

    // We're the main thread. Just loop until there's no more nodes and then move on to the next pass.
    return queue->m_PendingNodeCount > 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0x1d940
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x4d84
movb $0x0, -0x1(%rbp)
jmp 0x4ddc
movq -0x10(%rbp), %rax
cmpl $0x0, 0xec(%rax)
jle 0x4da9
movq -0x10(%rbp), %rax
movl 0x70(%rax), %ecx
andl $0x4, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x4da7
movb $0x0, -0x1(%rbp)
jmp 0x4ddc
jmp 0x4da9
movq -0x10(%rbp), %rax
testb $0x1, 0x118(%rax)
je 0x4dbc
movb $0x0, -0x1(%rbp)
jmp 0x4ddc
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
je 0x4dc9
movb $0x1, -0x1(%rbp)
jmp 0x4ddc
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe8(%rax)
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::NextNode(t2::BuildQueue*)
static NodeState* NextNode(BuildQueue* queue)
  {
    int avail_count = AvailableNodeCount(queue);

    if (0 == avail_count)
      return nullptr;

    uint32_t read_index = queue->m_QueueReadIndex;

    int32_t node_index = queue->m_Queue[read_index];

    // Update read index
    queue->m_QueueReadIndex = (read_index + 1) & (queue->m_QueueCapacity - 1);

    NodeState* state = queue->m_Config.m_NodeState + node_index;

    CHECK(NodeStateIsQueued(state));
    CHECK(!NodeStateIsActive(state));

    NodeStateFlagUnqueued(state);
    NodeStateFlagActive(state);

    return state;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50e0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jne 0x4e19
movq $0x0, -0x8(%rbp)
jmp 0x4e87
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl -0x18(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x1, %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x64(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x4e69
jmp 0x4e6b
jmp 0x4e6d
movq -0x28(%rbp), %rdi
callq 0x6bc0
movq -0x28(%rbp), %rdi
callq 0x6be0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::AvailableNodeCount(t2::BuildQueue*)
static int AvailableNodeCount(BuildQueue* queue)
  {
    const uint32_t queue_mask  = queue->m_QueueCapacity - 1;
    uint32_t       read_index  = queue->m_QueueReadIndex;
    uint32_t       write_index = queue->m_QueueWriteIndex;

    return (write_index - read_index) & queue_mask;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
andl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::SetupDependencies(t2::BuildQueue*, t2::NodeState*)
static BuildProgress::Enum SetupDependencies(BuildQueue* queue, NodeState* node)
  {
    const NodeData *src_node         = node->m_MmapData;
    int             dep_waits_needed = 0;
    int             enqueue_count    = 0;

    // Go through all dependencies and see how those nodes are doing.  If any
    // of them are not finished, we'll have to wait before this node can continue
    // to advance its state machine.
    for (int32_t dep_index : src_node->m_Dependencies)
    {
      NodeState* state = GetStateForNode(queue, dep_index);

      CHECK(state != nullptr);

      CHECK(state->m_MmapData->m_PassIndex <= src_node->m_PassIndex);

      if (NodeStateIsCompleted(state))
        continue;

      ++dep_waits_needed;

      if (!NodeStateIsQueued(state) && !NodeStateIsActive(state) && !NodeStateIsBlocked(state))
      {
        Enqueue(queue, state);
        ++enqueue_count;
      }
    }

    if (enqueue_count > 0)
      WakeWaiters(queue, enqueue_count);

    // We're waiting on dependencies to be ready.
    if (dep_waits_needed > 0)
      return BuildProgress::kBlocked;

    return BuildProgress::kUnblocked;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6c60
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x6c80
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x5207
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x62c0
movq %rax, -0x50(%rbp)
jmp 0x5199
jmp 0x519b
jmp 0x519d
movq -0x50(%rbp), %rdi
callq 0x6cc0
testb $0x1, %al
jne 0x51ac
jmp 0x51ae
jmp 0x51f6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x50(%rbp), %rdi
callq 0x6ce0
testb $0x1, %al
jne 0x51f4
movq -0x50(%rbp), %rdi
callq 0x6d00
testb $0x1, %al
jne 0x51f4
movq -0x50(%rbp), %rdi
callq 0x6d20
testb $0x1, %al
jne 0x51f4
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x6320
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x51f6
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x5170
cmpl $0x0, -0x28(%rbp)
jle 0x5219
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x63c0
cmpl $0x0, -0x24(%rbp)
jle 0x5228
movl $0x1, -0x4(%rbp)
jmp 0x522f
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::UnparkExpensiveNode(t2::BuildQueue*)
static void UnparkExpensiveNode(BuildQueue* queue)
  {
    if (queue->m_ExpensiveWaitCount > 0)
    {
      NodeState* node = queue->m_ExpensiveWaitList[--queue->m_ExpensiveWaitCount];
      CHECK(NodeStateIsQueued(node));
      // Really only to avoid tripping up checks in Enqueue()
      NodeStateFlagUnqueued(node);
      NodeStateFlagInactive(node);
      Enqueue(queue, node);
      CondSignal(&queue->m_WorkAvailable);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10c(%rax)
jle 0x61a0
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x10c(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10c(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x6174
movq -0x10(%rbp), %rdi
callq 0x6bc0
movq -0x10(%rbp), %rdi
callq 0x6c40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6320
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x6da0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::UnblockWaiters(t2::BuildQueue*, t2::NodeState*)
static void UnblockWaiters(BuildQueue* queue, NodeState* node)
  {
    const NodeData *src_node       = node->m_MmapData;
    int             enqueue_count  = 0;

    for (int32_t link : src_node->m_BackLinks)
    {
      if (NodeState* waiter = GetStateForNode(queue, link))
      {
        // Only wake nodes in our current pass
        if (waiter->m_MmapData->m_PassIndex != queue->m_CurrentPassIndex)
          continue;

        // If the node isn't ready, skip it.
        if (!AllDependenciesReady(queue, waiter))
          continue;

        // Did someone else get to the node first?
        if (NodeStateIsQueued(waiter) || NodeStateIsActive(waiter))
          continue;

        //printf("%s is ready to go\n", GetSourceNode(queue, waiter)->m_Annotation);
        Enqueue(queue, waiter);
        ++enqueue_count;
      }
    }

    if (enqueue_count > 0)
      WakeWaiters(queue, enqueue_count);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6c60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6c80
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x629a
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x62c0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x6287
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xf0(%rcx), %eax
je 0x6240
jmp 0x6289
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6740
testb $0x1, %al
jne 0x6253
jmp 0x6289
movq -0x48(%rbp), %rdi
callq 0x6ce0
testb $0x1, %al
jne 0x626f
movq -0x48(%rbp), %rdi
callq 0x6d00
testb $0x1, %al
jne 0x626f
jmp 0x6271
jmp 0x6289
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x6320
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6289
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x61f9
cmpl $0x0, -0x1c(%rbp)
jle 0x62ac
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x63c0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::GetStateForNode(t2::BuildQueue*, int)
static NodeState* GetStateForNode(BuildQueue* queue, int32_t src_index)
  {
    int32_t state_index = queue->m_Config.m_NodeRemappingTable[src_index];

    if (state_index == -1)
      return nullptr;

    NodeState* state = queue->m_Config.m_NodeState + state_index;

    CHECK(int(state->m_MmapData - queue->m_Config.m_NodeData) == src_index);

    return state;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x62f0
movq $0x0, -0x8(%rbp)
jmp 0x6314
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x630c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::Enqueue(t2::BuildQueue*, t2::NodeState*)
static void Enqueue(BuildQueue* queue, NodeState* state)
  {
    uint32_t       write_index = queue->m_QueueWriteIndex;
    const uint32_t queue_mask  = queue->m_QueueCapacity - 1;
    int32_t*       build_queue = queue->m_Queue;


    CHECK(AllDependenciesReady(queue, state));
    CHECK(!NodeStateIsQueued(state));
    CHECK(!NodeStateIsActive(state));
    CHECK(!NodeStateIsCompleted(state));
    CHECK(state->m_MmapData->m_PassIndex == queue->m_CurrentPassIndex);

#if ENABLED(CHECKED_BUILD)
    const int avail_init = AvailableNodeCount(queue);
#endif

    int state_index = int(state - queue->m_Config.m_NodeState);

    build_queue[write_index] = state_index;
    write_index              = (write_index + 1) & queue_mask;
    queue->m_QueueWriteIndex = write_index;

    NodeStateFlagQueued(state);

    CHECK(AvailableNodeCount(queue) == 1 + avail_init);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6355
jmp 0x6357
jmp 0x6359
jmp 0x635b
jmp 0x635d
jmp 0x635f
jmp 0x6361
jmp 0x6363
jmp 0x6365
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rcx
subq %rcx, %rax
sarq $0x6, %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
andl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x6af0
jmp 0x63ac
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::OutputFilesDiffer(t2::NodeData const*, t2::NodeStateData const*)
static bool OutputFilesDiffer(const NodeData* node_data, const NodeStateData* prev_state)
  {
    int file_count = node_data->m_OutputFiles.GetCount();

    if (file_count != prev_state->m_OutputFiles.GetCount())
      return true;

    for (int i = 0; i < file_count; ++i)
    {
      if (0 != strcmp(node_data->m_OutputFiles[i].m_Filename, prev_state->m_OutputFiles[i]))
        return true;
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x70b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
callq 0x70c0
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
je 0x6442
movb $0x1, -0x1(%rbp)
jmp 0x64b0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x64ac
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movl -0x20(%rbp), %esi
callq 0x70d0
movq %rax, %rdi
callq 0x6e20
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x14, %rdi
movl -0x20(%rbp), %esi
callq 0x7110
movq %rax, %rdi
callq 0x6e20
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x3658
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x649f
movb $0x1, -0x1(%rbp)
jmp 0x64b0
jmp 0x64a1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6449
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::OutputFilesMissing(t2::StatCache*, t2::NodeData const*)
static bool OutputFilesMissing(StatCache* stat_cache, const NodeData* node)
  {
    for (const FrozenFileAndHash& f : node->m_OutputFiles)
    {
      FileInfo i = StatCacheStat(stat_cache, f.m_Filename, f.m_FilenameHash);

      if (!i.Exists())
        return true;
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6e90
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6eb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x6553
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6e20
movq -0x58(%rbp), %rsi
movq %rax, %rdx
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
leaq -0x50(%rbp), %rdi
callq 0x1dd10
leaq -0x50(%rbp), %rdi
callq 0x71b0
testb $0x1, %al
jne 0x6543
movb $0x1, -0x1(%rbp)
jmp 0x6557
jmp 0x6545
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x64f6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::MakeDirectoriesRecursive(t2::StatCache*, t2::PathBuffer const&)
static bool MakeDirectoriesRecursive(StatCache* stat_cache, const PathBuffer& dir)
  {
    PathBuffer parent_dir = dir;
    PathStripLast(&parent_dir);

    // Can't go any higher.
    if (dir == parent_dir)
      return true;

    if (!MakeDirectoriesRecursive(stat_cache, parent_dir))
      return false;

    char path[kMaxPathLength];
    PathFormat(path, &dir);

    FileInfo info = StatCacheStat(stat_cache, path);

    if (info.Exists())
    {
      // Just asssume this is a directory. We could check it - but there's currently no way via _stat64() calls
      // on Windows to check if a file is a symbolic link (to a directory).
      return true;
    }
    else
    {
      Log(kSpam, "create dir \"%s\"", path);
      bool success = MakeDirectory(path);
      StatCacheMarkDirty(stat_cache, path, Djb2HashPath(path));
      return success;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4e0, %rsp            # imm = 0x4E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x2a4(%rbp), %rdi
movl $0x28c, %edx            # imm = 0x28C
callq 0x32a0
leaq -0x2a4(%rbp), %rdi
callq 0x19370
movq -0x18(%rbp), %rdi
leaq -0x2a4(%rbp), %rsi
callq 0x7340
testb $0x1, %al
jne 0x665a
jmp 0x6663
movb $0x1, -0x1(%rbp)
jmp 0x6732
movq -0x10(%rbp), %rdi
leaq -0x2a4(%rbp), %rsi
callq 0x6610
testb $0x1, %al
jne 0x6680
movb $0x0, -0x1(%rbp)
jmp 0x6732
movq -0x18(%rbp), %rsi
leaq -0x4b0(%rbp), %rdi
callq 0x195c0
movq -0x10(%rbp), %rsi
leaq -0x4b0(%rbp), %rdx
leaq -0x4c8(%rbp), %rdi
callq 0x7420
leaq -0x4c8(%rbp), %rdi
callq 0x71b0
testb $0x1, %al
jne 0x66b9
jmp 0x66bf
movb $0x1, -0x1(%rbp)
jmp 0x6732
leaq -0x4b0(%rbp), %rdx
movl $0x10, %edi
leaq 0x1d6ac(%rip), %rsi     # 0x23d7e
movb $0x0, %al
callq 0x7a60
leaq -0x4b0(%rbp), %rdi
callq 0x7dc0
andb $0x1, %al
movb %al, -0x4c9(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x4e0(%rbp)
leaq -0x4b0(%rbp), %rax
movq %rax, -0x4d8(%rbp)
leaq -0x4b0(%rbp), %rdi
callq 0x7470
movq -0x4e0(%rbp), %rdi
movq -0x4d8(%rbp), %rsi
movl %eax, %edx
callq 0x1dcb0
movb -0x4c9(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x4e0, %rsp            # imm = 0x4E0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BuildQueue.cpp
// Function: t2::AllDependenciesReady(t2::BuildQueue*, t2::NodeState const*)
static bool AllDependenciesReady(BuildQueue* queue, const NodeState* state)
  {
    const NodeData *src_node      = state->m_MmapData;

    for (int32_t dep_index : src_node->m_Dependencies)
    {
      NodeState* state = GetStateForNode(queue, dep_index);

      CHECK(state != nullptr);

      if (!NodeStateIsCompleted(state))
      {
        return false;
      }
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6c60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6c80
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x67ca
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %esi
callq 0x62c0
movq %rax, -0x48(%rbp)
jmp 0x67a7
movq -0x48(%rbp), %rdi
callq 0x6cc0
testb $0x1, %al
jne 0x67ba
movb $0x0, -0x1(%rbp)
jmp 0x67ce
jmp 0x67bc
movq -0x30(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
jmp 0x6782
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/BinaryData.hpp
// Function: t2::FrozenPtr<char const>::Get() const
const T* Get() const
  {
    uintptr_t base      = (uintptr_t) this;
    uintptr_t target    = base + m_Offset;
    uintptr_t null_mask = (0 == m_Offset) ? 0 : ~uintptr_t(0);
    return reinterpret_cast<T*>(target & null_mask);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movslq (%rax), %rdx
addq %rdx, %rcx
movq %rcx, -0x18(%rbp)
movl (%rax), %esi
xorl %edx, %edx
movq $-0x1, %rax
xorl %ecx, %ecx
cmpl %esi, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq -0x20(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Hash.hpp
// Function: t2::CompareHashDigests(t2::HashDigest const&, t2::HashDigest const&)
inline int CompareHashDigests(const HashDigest& lhs, const HashDigest& rhs)
{
  const uint64_t l0 = lhs.m_Words64[0];
  const uint64_t r0 = rhs.m_Words64[0];

  const int res0 = (l0 > r0) - (l0 < r0);

  const uint64_t l1 = lhs.m_Words64[1];
  const uint64_t r1 = rhs.m_Words64[1];

  const int res1 = (l1 > r1) - (l1 < r1);

  return res0 ? res0 : res1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x30(%rbp), %rcx
cmpq -0x38(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x70a4
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x70aa
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Stats.hpp
// Function: t2::TimingScope::~TimingScope()
~TimingScope()
  {
    uint64_t micros = TimerGet() - m_StartTime;
    if (uint32_t *ptr = m_CountPtr)
      AtomicIncrement(ptr);
    AtomicAdd(m_TimePtr, micros);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x7d10
movq %rax, -0x20(%rbp)
jmp 0x728f
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x72ba
movq -0x18(%rbp), %rdi
callq 0x74e0
jmp 0x72b8
jmp 0x72ba
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x7500
jmp 0x72cd
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6b70
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/PathUtil.hpp
// Function: t2::operator==(t2::PathBuffer const&, t2::PathBuffer const&)
inline bool operator==(const PathBuffer& a, const PathBuffer& b)
  {
    if (a.m_SegCount != b.m_SegCount)
      return false;

    if (a.m_SegCount == 0)
      return true;

    return
      0 == memcmp(a.m_SegEnds, b.m_SegEnds, sizeof(uint16_t) * a.m_SegCount) &&
      0 == memcmp(a.m_Data, b.m_Data, a.SegLength(a.m_SegCount - 1));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
movq -0x18(%rbp), %rcx
movzwl 0x6(%rcx), %ecx
cmpl %ecx, %eax
je 0x736d
movb $0x0, -0x1(%rbp)
jmp 0x7408
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
cmpl $0x0, %eax
jne 0x7383
movb $0x1, -0x1(%rbp)
jmp 0x7408
movq -0x10(%rbp), %rdi
addq $0xa, %rdi
movq -0x18(%rbp), %rsi
addq $0xa, %rsi
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %eax
movl %eax, %edx
shlq %rdx
callq 0x3160
movl %eax, %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jne 0x7400
movq -0x10(%rbp), %rax
addq $0x8a, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x8a, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %esi
subl $0x1, %esi
callq 0x7490
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movzwl %ax, %eax
movl %eax, %edx
callq 0x3160
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/PathUtil.hpp
// Function: t2::PathBuffer::SegLength(int) const
uint16_t SegLength(int i) const
    {
      CHECK(uint16_t(i) < m_SegCount);
      if (i > 0)
      {
        return uint16_t(m_SegEnds[i] - m_SegEnds[i - 1]);
      }
      else
      {
        return m_SegEnds[0];
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x74a5
cmpl $0x0, -0x14(%rbp)
jle 0x74ce
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
movzwl 0xa(%rcx,%rax,2), %eax
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl 0xa(%rcx,%rdx,2), %ecx
subl %ecx, %eax
movw %ax, -0x2(%rbp)
jmp 0x74da
movq -0x20(%rbp), %rax
movw 0xa(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Croak(char const*, ...)
void NORETURN Croak(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  if (DebuggerAttached())
    abort();
  else
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x75d5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x279a9(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3450
leaq -0x20(%rbp), %rax
movq 0x2798e(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
leaq 0x1c299(%rip), %rsi     # 0x238e5
movb $0x0, %al
callq 0x3470
callq 0x7670
testb $0x1, %al
jne 0x765e
jmp 0x7663
callq 0x31d0
movl $0x1, %edi
callq 0x33f0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::CroakErrno(char const*, ...)
void NORETURN CroakErrno(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  fprintf(stderr, "errno: %d (%s)\n", errno, strerror(errno));
#if defined(TUNDRA_WIN32)
  DWORD gle = GetLastError();

  char* message = nullptr;
  size_t size = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                 NULL, gle, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&message, 0, NULL);
    
  fprintf(stderr, "Win32 GLE: %u (%s)\n", gle, message);
#endif
  if (DebuggerAttached())
    abort();
  else
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x76b5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x278c9(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3450
leaq -0x20(%rbp), %rax
movq 0x278ae(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
leaq 0x1c1b9(%rip), %rsi     # 0x238e5
movb $0x0, %al
callq 0x3470
movq 0x27896(%rip), %rax     # 0x2efd0
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
callq 0x3050
movl (%rax), %eax
movl %eax, -0xd4(%rbp)
callq 0x3050
movl (%rax), %edi
callq 0x30f0
movq -0xe0(%rbp), %rdi
movl -0xd4(%rbp), %edx
movq %rax, %rcx
leaq 0x1c6ac(%rip), %rsi     # 0x23e20
movb $0x0, %al
callq 0x3470
callq 0x7670
testb $0x1, %al
jne 0x7786
jmp 0x778b
callq 0x31d0
movl $0x1, %edi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::CroakAbort(char const*, ...)
void NORETURN CroakAbort(const char* fmt, ...)
{
  va_list args;
  va_start(args, fmt);
  vfprintf(stderr, fmt, args);
  va_end(args);
  fprintf(stderr, "\n");
  abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x77d5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x277a9(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3450
leaq -0x20(%rbp), %rax
movq 0x2778e(%rip), %rax     # 0x2efd0
movq (%rax), %rdi
leaq 0x1c099(%rip), %rsi     # 0x238e5
movb $0x0, %al
callq 0x3470
callq 0x31d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2Hash(char const*)
uint32_t Djb2Hash(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint32_t hash      = 5381;
  int c;

  while (0 != (c = *str++))
  {
    hash = (hash * 33) + c;
  }

  return hash ? hash : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1505, -0x14(%rbp)    # imm = 0x1505
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x789e
imull $0x21, -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x7877
cmpl $0x0, -0x14(%rbp)
je 0x78ac
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x78b6
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x78b6
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2Hash64(char const*)
uint64_t Djb2Hash64(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint64_t hash      = 5381;
  int c;

  while (0 != (c = *str++))
  {
    hash = (hash * 33) + c;
  }

  return hash ? hash : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x1505, -0x18(%rbp)    # imm = 0x1505
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %ecx
movl %ecx, -0x1c(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7905
imulq $0x21, -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x78d8
cmpq $0x0, -0x18(%rbp)
je 0x7916
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x7921
movl $0x1, %eax
movq %rax, -0x28(%rbp)
jmp 0x7921
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/deplinenoise[P]tundra/src/Common.cpp
// Function: t2::Djb2HashNoCase(char const*)
uint32_t Djb2HashNoCase(const char *str_)
{
  const uint8_t *str = (const uint8_t *) str_;
  uint32_t hash = 5381;
  int c;

  while (0 != (c = *str++))
  {
    hash = (hash * 33) + FoldCase(c);
  }

  return hash ? hash : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1505, -0x14(%rbp)    # imm = 0x1505
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %ecx
movl %ecx, -0x18(%rbp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x7981
imull $0x21, -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %edi
callq 0x7f50
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x794b
cmpl $0x0, -0x14(%rbp)
je 0x798f
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x7999
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7999
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)